"""Wrapper functions for Tcl/Tk.

Tkinter provides classes which allow the display, positioning and

control of widgets. Toplevel widgets are Tk and Toplevel. Other

widgets are Frame, Label, Entry, Text, Canvas, Button, Radiobutton,

Checkbutton, Scale, Listbox, Scrollbar, OptionMenu, Spinbox

LabelFrame and PanedWindow.

Properties of the widgets are specified with keyword arguments.

Keyword arguments have the same name as the corresponding resource

under Tk.

Widgets are positioned with one of the geometry managers Place, Pack

or Grid. These managers can be called with methods place, pack, grid

available in every Widget.

Actions are bound to events by resources (e.g. keyword argument

command) or with the method bind.

Example (Hello, World):

import Tkinter

from Tkconstants import *

tk = Tkinter.Tk()

frame = Tkinter.Frame(tk, relief=RIDGE, borderwidth=2)

frame.pack(fill=BOTH,expand=1)

label = Tkinter.Label(frame, text="Hello, World")

label.pack(fill=X, expand=1)

button = Tkinter.Button(frame,text="Exit",command=tk.destroy)

button.pack(side=BOTTOM)

tk.mainloop()

"""

__version__ = "$Revision: 50704 $"

import sys

if sys.platform == "win32":

    import FixTk # Attempt to configure Tcl/Tk without requiring PATH

import _tkinter # If this fails your Python may not be configured for Tk

tkinter = _tkinter # b/w compat for export

TclError = _tkinter.TclError

from types import *

from Tkconstants import *

try:

    import MacOS; _MacOS = MacOS; del MacOS

except ImportError:

    _MacOS = None

wantobjects = 1

TkVersion = float(_tkinter.TK_VERSION)

TclVersion = float(_tkinter.TCL_VERSION)

READABLE = _tkinter.READABLE

WRITABLE = _tkinter.WRITABLE

EXCEPTION = _tkinter.EXCEPTION

# These are not always defined, e.g. not on Win32 with Tk 8.0 :-(

try: _tkinter.createfilehandler

except AttributeError: _tkinter.createfilehandler = None

try: _tkinter.deletefilehandler

except AttributeError: _tkinter.deletefilehandler = None

def _flatten(tuple):

    """Internal function."""

    res = ()

    for item in tuple:

        if type(item) in (TupleType, ListType):

            res = res + _flatten(item)

        elif item is not None:

            res = res + (item,)

    return res

try: _flatten = _tkinter._flatten

except AttributeError: pass

def _cnfmerge(cnfs):

    """Internal function."""

    if type(cnfs) is DictionaryType:

        return cnfs

    elif type(cnfs) in (NoneType, StringType):

        return cnfs

    else:

        cnf = {}

        for c in _flatten(cnfs):

            try:

                cnf.update(c)

            except (AttributeError, TypeError), msg:

                print "_cnfmerge: fallback due to:", msg

                for k, v in c.items():

                    cnf[k] = v

        return cnf

try: _cnfmerge = _tkinter._cnfmerge

except AttributeError: pass

class Event:

    """Container for the properties of an event.

    Instances of this type are generated if one of the following events occurs:

    KeyPress, KeyRelease - for keyboard events

    ButtonPress, ButtonRelease, Motion, Enter, Leave, MouseWheel - for mouse events

    Visibility, Unmap, Map, Expose, FocusIn, FocusOut, Circulate,

    Colormap, Gravity, Reparent, Property, Destroy, Activate,

    Deactivate - for window events.

    If a callback function for one of these events is registered

    using bind, bind_all, bind_class, or tag_bind, the callback is

    called with an Event as first argument. It will have the

    following attributes (in braces are the event types for which

    the attribute is valid):

        serial - serial number of event

    num - mouse button pressed (ButtonPress, ButtonRelease)

    focus - whether the window has the focus (Enter, Leave)

    height - height of the exposed window (Configure, Expose)

    width - width of the exposed window (Configure, Expose)

    keycode - keycode of the pressed key (KeyPress, KeyRelease)

    state - state of the event as a number (ButtonPress, ButtonRelease,

                            Enter, KeyPress, KeyRelease,

                            Leave, Motion)

    state - state as a string (Visibility)

    time - when the event occurred

    x - x-position of the mouse

    y - y-position of the mouse

    x_root - x-position of the mouse on the screen

             (ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion)

    y_root - y-position of the mouse on the screen

             (ButtonPress, ButtonRelease, KeyPress, KeyRelease, Motion)

    char - pressed character (KeyPress, KeyRelease)

    send_event - see X/Windows documentation

    keysym - keysym of the event as a string (KeyPress, KeyRelease)

    keysym_num - keysym of the event as a number (KeyPress, KeyRelease)

    type - type of the event as a number

    widget - widget in which the event occurred

    delta - delta of wheel movement (MouseWheel)

    """

    pass

_support_default_root = 1

_default_root = None

def NoDefaultRoot():

    """Inhibit setting of default root window.

    Call this function to inhibit that the first instance of

    Tk is used for windows without an explicit parent window.

    """

    global _support_default_root

    _support_default_root = 0

    global _default_root

    _default_root = None

    del _default_root

def _tkerror(err):

    """Internal function."""

    pass

def _exit(code='0'):

    """Internal function. Calling it will throw the exception SystemExit."""

    raise SystemExit, code

_varnum = 0

class Variable:

    """Class to define value holders for e.g. buttons.

    Subclasses StringVar, IntVar, DoubleVar, BooleanVar are specializations

    that constrain the type of the value returned from get()."""

    _default = ""

    def __init__(self, master=None, value=None, name=None):

        """Construct a variable

        MASTER can be given as master widget.

        VALUE is an optional value (defaults to "")

        NAME is an optional Tcl name (defaults to PY_VARnum).

        If NAME matches an existing variable and VALUE is omitted

        then the existing value is retained.

        """

        global _varnum

        if not master:

            master = _default_root

        self._master = master

        self._tk = master.tk

        if name:

            self._name = name

        else:

            self._name = 'PY_VAR' + repr(_varnum)

            _varnum += 1

        if value != None:

            self.set(value)

        elif not self._tk.call("info", "exists", self._name):

            self.set(self._default)

    def __del__(self):

        """Unset the variable in Tcl."""

        self._tk.globalunsetvar(self._name)

    def __str__(self):

        """Return the name of the variable in Tcl."""

        return self._name

    def set(self, value):

        """Set the variable to VALUE."""

        return self._tk.globalsetvar(self._name, value)

    def get(self):

        """Return value of variable."""

        return self._tk.globalgetvar(self._name)

    def trace_variable(self, mode, callback):

        """Define a trace callback for the variable.

        MODE is one of "r", "w", "u" for read, write, undefine.

        CALLBACK must be a function which is called when

        the variable is read, written or undefined.

        Return the name of the callback.

        """

        cbname = self._master._register(callback)

        self._tk.call("trace", "variable", self._name, mode, cbname)

        return cbname

    trace = trace_variable

    def trace_vdelete(self, mode, cbname):

        """Delete the trace callback for a variable.

        MODE is one of "r", "w", "u" for read, write, undefine.

        CBNAME is the name of the callback returned from trace_variable or trace.

        """

        self._tk.call("trace", "vdelete", self._name, mode, cbname)

        self._master.deletecommand(cbname)

    def trace_vinfo(self):

        """Return all trace callback information."""

        return map(self._tk.split, self._tk.splitlist(

            self._tk.call("trace", "vinfo", self._name)))

    def __eq__(self, other):

        """Comparison for equality (==).

        Note: if the Variable's master matters to behavior

        also compare self._master == other._master

        """

        return self.__class__.__name__ == other.__class__.__name__ \

            and self._name == other._name

class StringVar(Variable):

    """Value holder for strings variables."""

    _default = ""

    def __init__(self, master=None, value=None, name=None):

        """Construct a string variable.

        MASTER can be given as master widget.

        VALUE is an optional value (defaults to "")

        NAME is an optional Tcl name (defaults to PY_VARnum).

        If NAME matches an existing variable and VALUE is omitted

        then the existing value is retained.

        """

        Variable.__init__(self, master, value, name)

    def get(self):

        """Return value of variable as string."""

        value = self._tk.globalgetvar(self._name)

        if isinstance(value, basestring):

            return value

        return str(value)

class IntVar(Variable):

    """Value holder for integer variables."""

    _default = 0

    def __init__(self, master=None, value=None, name=None):

        """Construct an integer variable.

        MASTER can be given as master widget.

        VALUE is an optional value (defaults to 0)

        NAME is an optional Tcl name (defaults to PY_VARnum).

        If NAME matches an existing variable and VALUE is omitted

        then the existing value is retained.

        """

        Variable.__init__(self, master, value, name)

    def set(self, value):

        """Set the variable to value, converting booleans to integers."""

        if isinstance(value, bool):

            value = int(value)

        return Variable.set(self, value)

    def get(self):

        """Return the value of the variable as an integer."""

        return getint(self._tk.globalgetvar(self._name))

class DoubleVar(Variable):

    """Value holder for float variables."""

    _default = 0.0

    def __init__(self, master=None, value=None, name=None):

        """Construct a float variable.

        MASTER can be given as master widget.

        VALUE is an optional value (defaults to 0.0)

        NAME is an optional Tcl name (defaults to PY_VARnum).

        If NAME matches an existing variable and VALUE is omitted

        then the existing value is retained.

        """

        Variable.__init__(self, master, value, name)

    def get(self):

        """Return the value of the variable as a float."""

        return getdouble(self._tk.globalgetvar(self._name))

class BooleanVar(Variable):

    """Value holder for boolean variables."""

    _default = False

    def __init__(self, master=None, value=None, name=None):

        """Construct a boolean variable.

        MASTER can be given as master widget.

        VALUE is an optional value (defaults to False)

        NAME is an optional Tcl name (defaults to PY_VARnum).

        If NAME matches an existing variable and VALUE is omitted

        then the existing value is retained.

        """

        Variable.__init__(self, master, value, name)

    def get(self):

        """Return the value of the variable as a bool."""

        return self._tk.getboolean(self._tk.globalgetvar(self._name))

def mainloop(n=0):

    """Run the main loop of Tcl."""

    _default_root.tk.mainloop(n)

getint = int

getdouble = float

def getboolean(s):

    """Convert true and false to integer values 1 and 0."""

    return _default_root.tk.getboolean(s)

# Methods defined on both toplevel and interior widgets

class Misc:

    """Internal class.

    Base class which defines methods common for interior widgets."""

    # XXX font command?

    _tclCommands = None

    def destroy(self):

        """Internal function.

        Delete all Tcl commands created for

        this widget in the Tcl interpreter."""

        if self._tclCommands is not None:

            for name in self._tclCommands:

                #print '- Tkinter: deleted command', name

                self.tk.deletecommand(name)

            self._tclCommands = None

    def deletecommand(self, name):

        """Internal function.

        Delete the Tcl command provided in NAME."""

        #print '- Tkinter: deleted command', name

        self.tk.deletecommand(name)

        try:

            self._tclCommands.remove(name)

        except ValueError:

            pass

    def tk_strictMotif(self, boolean=None):

        """Set Tcl internal variable, whether the look and feel

        should adhere to Motif.

        A parameter of 1 means adhere to Motif (e.g. no color

        change if mouse passes over slider).

        Returns the set value."""

        return self.tk.getboolean(self.tk.call(

            'set', 'tk_strictMotif', boolean))

    def tk_bisque(self):

        """Change the color scheme to light brown as used in Tk 3.6 and before."""

        self.tk.call('tk_bisque')

    def tk_setPalette(self, *args, **kw):

        """Set a new color scheme for all widget elements.

        A single color as argument will cause that all colors of Tk

        widget elements are derived from this.

        Alternatively several keyword parameters and its associated

        colors can be given. The following keywords are valid:

        activeBackground, foreground, selectColor,

        activeForeground, highlightBackground, selectBackground,

        background, highlightColor, selectForeground,

        disabledForeground, insertBackground, troughColor."""

        self.tk.call(('tk_setPalette',)

              + _flatten(args) + _flatten(kw.items()))

    def tk_menuBar(self, *args):

        """Do not use. Needed in Tk 3.6 and earlier."""

        pass # obsolete since Tk 4.0

    def wait_variable(self, name='PY_VAR'):

        """Wait until the variable is modified.

        A parameter of type IntVar, StringVar, DoubleVar or

        BooleanVar must be given."""

        self.tk.call('tkwait', 'variable', name)

    waitvar = wait_variable # XXX b/w compat

    def wait_window(self, window=None):

        """Wait until a WIDGET is destroyed.

        If no parameter is given self is used."""

        if window is None:

            window = self

        self.tk.call('tkwait', 'window', window._w)

    def wait_visibility(self, window=None):

        """Wait until the visibility of a WIDGET changes

        (e.g. it appears).

        If no parameter is given self is used."""

        if window is None:

            window = self

        self.tk.call('tkwait', 'visibility', window._w)

    def setvar(self, name='PY_VAR', value='1'):

        """Set Tcl variable NAME to VALUE."""

        self.tk.setvar(name, value)

    def getvar(self, name='PY_VAR'):

        """Return value of Tcl variable NAME."""

        return self.tk.getvar(name)

    getint = int

    getdouble = float

    def getboolean(self, s):

        """Return a boolean value for Tcl boolean values true and false given as parameter."""

        return self.tk.getboolean(s)

    def focus_set(self):

        """Direct input focus to this widget.

        If the application currently does not have the focus

        this widget will get the focus if the application gets

        the focus through the window manager."""

        self.tk.call('focus', self._w)

    focus = focus_set # XXX b/w compat?

    def focus_force(self):

        """Direct input focus to this widget even if the

        application does not have the focus. Use with

        caution!"""

        self.tk.call('focus', '-force', self._w)

    def focus_get(self):

        """Return the widget which has currently the focus in the

        application.

        Use focus_displayof to allow working with several

        displays. Return None if application does not have

        the focus."""

        name = self.tk.call('focus')

        if name == 'none' or not name: return None

        return self._nametowidget(name)

    def focus_displayof(self):

        """Return the widget which has currently the focus on the

        display where this widget is located.

        Return None if the application does not have the focus."""

        name = self.tk.call('focus', '-displayof', self._w)

        if name == 'none' or not name: return None

        return self._nametowidget(name)

    def focus_lastfor(self):

        """Return the widget which would have the focus if top level

        for this widget gets the focus from the window manager."""

        name = self.tk.call('focus', '-lastfor', self._w)

        if name == 'none' or not name: return None

        return self._nametowidget(name)

    def tk_focusFollowsMouse(self):

        """The widget under mouse will get automatically focus. Can not

        be disabled easily."""

        self.tk.call('tk_focusFollowsMouse')

    def tk_focusNext(self):

        """Return the next widget in the focus order which follows

        widget which has currently the focus.

        The focus order first goes to the next child, then to

        the children of the child recursively and then to the

        next sibling which is higher in the stacking order.  A

        widget is omitted if it has the takefocus resource set

        to 0."""

        name = self.tk.call('tk_focusNext', self._w)

        if not name: return None

        return self._nametowidget(name)

    def tk_focusPrev(self):

        """Return previous widget in the focus order. See tk_focusNext for details."""

        name = self.tk.call('tk_focusPrev', self._w)

        if not name: return None

        return self._nametowidget(name)

    def after(self, ms, func=None, *args):

        """Call function once after given time.

        MS specifies the time in milliseconds. FUNC gives the

        function which shall be called. Additional parameters

        are given as parameters to the function call.  Return

        identifier to cancel scheduling with after_cancel."""

        if not func:

            # I'd rather use time.sleep(ms*0.001)

            self.tk.call('after', ms)

        else:

            def callit():

                try:

                    func(*args)

                finally:

                    try:

                        self.deletecommand(name)

                    except TclError:

                        pass

            name = self._register(callit)

            return self.tk.call('after', ms, name)

    def after_idle(self, func, *args):

        """Call FUNC once if the Tcl main loop has no event to

        process.

        Return an identifier to cancel the scheduling with

        after_cancel."""

        return self.after('idle', func, *args)

    def after_cancel(self, id):

        """Cancel scheduling of function identified with ID.

        Identifier returned by after or after_idle must be

        given as first parameter."""

        try:

            data = self.tk.call('after', 'info', id)

            # In Tk 8.3, splitlist returns: (script, type)

            # In Tk 8.4, splitlist may return (script, type) or (script,)

            script = self.tk.splitlist(data)[0]

            self.deletecommand(script)

        except TclError:

            pass

        self.tk.call('after', 'cancel', id)

    def bell(self, displayof=0):

        """Ring a display's bell."""