1 

     2 # The options of a widget are described by the following attributes

     3 # of the Pack and Widget dialogs:

     4 #

     5 # Dialog.current: {name: value}

     6 # -- changes during Widget's lifetime

     7 #

     8 # Dialog.options: {name: (default, klass)}

     9 # -- depends on widget class only

    10 #

    11 # Dialog.classes: {klass: (v0, v1, v2, ...) | 'boolean' | 'other'}

    12 # -- totally static, though different between PackDialog and WidgetDialog

    13 #    (but even that could be unified)

    14 

    15 from Tkinter import *

    16 

    17 class Option:

    18 

    19     varclass = StringVar            # May be overridden

    20 

    21     def __init__(self, dialog, option):

    22         self.dialog = dialog

    23         self.option = option

    24         self.master = dialog.top

    25         self.default, self.klass = dialog.options[option]

    26         self.var = self.varclass(self.master)

    27         self.frame = Frame(self.master)

    28         self.frame.pack(fill=X)

    29         self.label = Label(self.frame, text=(option + ":"))

    30         self.label.pack(side=LEFT)

    31         self.update()

    32         self.addoption()

    33 

    34     def refresh(self):

    35         self.dialog.refresh()

    36         self.update()

    37 

    38     def update(self):

    39         try:

    40             self.current = self.dialog.current[self.option]

    41         except KeyError:

    42             self.current = self.default

    43         self.var.set(self.current)

    44 

    45     def set(self, e=None):          # Should be overridden

    46         pass

    47 

    48 class BooleanOption(Option):

    49 

    50     varclass = BooleanVar

    51 

    52     def addoption(self):

    53         self.button = Checkbutton(self.frame,

    54                                  text='on/off',

    55                                  onvalue=1,

    56                                  offvalue=0,

    57                                  variable=self.var,

    58                                  relief=RAISED,

    59                                  borderwidth=2,

    60                                  command=self.set)

    61         self.button.pack(side=RIGHT)

    62 

    63 class EnumOption(Option):

    64 

    65     def addoption(self):

    66         self.button = Menubutton(self.frame,

    67                                  textvariable=self.var,

    68                                  relief=RAISED, borderwidth=2)

    69         self.button.pack(side=RIGHT)

    70         self.menu = Menu(self.button)

    71         self.button['menu'] = self.menu

    72         for v in self.dialog.classes[self.klass]:

    73             self.menu.add_radiobutton(

    74                 label=v,

    75                 variable=self.var,

    76                 value=v,

    77                 command=self.set)

    78 

    79 class StringOption(Option):

    80 

    81     def addoption(self):

    82         self.entry = Entry(self.frame,

    83                            textvariable=self.var,

    84                            width=10,

    85                            relief=SUNKEN,

    86                            borderwidth=2)

    87         self.entry.pack(side=RIGHT, fill=X, expand=1)

    88         self.entry.bind('<Return>', self.set)

    89 

    90 class ReadonlyOption(Option):

    91 

    92     def addoption(self):

    93         self.label = Label(self.frame, textvariable=self.var,

    94                            anchor=E)

    95         self.label.pack(side=RIGHT)

    96 

    97 class Dialog:

    98 

    99     def __init__(self, master):

   100         self.master = master

   101         self.fixclasses()

   102         self.refresh()

   103         self.top = Toplevel(self.master)

   104         self.top.title(self.__class__.__name__)

   105         self.top.minsize(1, 1)

   106         self.addchoices()

   107 

   108     def refresh(self): pass         # Must override

   109 

   110     def fixclasses(self): pass      # May override

   111 

   112     def addchoices(self):

   113         self.choices = {}

   114         list = []

   115         for k, dc in self.options.items():

   116             list.append((k, dc))

   117         list.sort()

   118         for k, (d, c) in list:

   119             try:

   120                 cl = self.classes[c]

   121             except KeyError:

   122                 cl = 'unknown'

   123             if type(cl) == TupleType:

   124                 cl = self.enumoption

   125             elif cl == 'boolean':

   126                 cl = self.booleanoption

   127             elif cl == 'readonly':

   128                 cl = self.readonlyoption

   129             else:

   130                 cl = self.stringoption

   131             self.choices[k] = cl(self, k)

   132 

   133     # Must override:

   134     options = {}

   135     classes = {}

   136 

   137     # May override:

   138     booleanoption = BooleanOption

   139     stringoption = StringOption

   140     enumoption = EnumOption

   141     readonlyoption = ReadonlyOption

   142 

   143 class PackDialog(Dialog):

   144 

   145     def __init__(self, widget):

   146         self.widget = widget

   147         Dialog.__init__(self, widget)

   148 

   149     def refresh(self):

   150         self.current = self.widget.info()

   151         self.current['.class'] = self.widget.winfo_class()

   152         self.current['.name'] = self.widget._w

   153 

   154     class packoption: # Mix-in class

   155         def set(self, e=None):

   156             self.current = self.var.get()

   157             try:

   158                 apply(self.dialog.widget.pack, (),

   159                       {self.option: self.current})

   160             except TclError, msg:

   161                 print msg

   162                 self.refresh()

   163 

   164     class booleanoption(packoption, BooleanOption): pass

   165     class enumoption(packoption, EnumOption): pass

   166     class stringoption(packoption, StringOption): pass

   167     class readonlyoption(packoption, ReadonlyOption): pass

   168 

   169     options = {

   170             '.class': (None, 'Class'),

   171             '.name': (None, 'Name'),

   172             'after': (None, 'Widget'),

   173             'anchor': ('center', 'Anchor'),

   174             'before': (None, 'Widget'),

   175             'expand': ('no', 'Boolean'),

   176             'fill': ('none', 'Fill'),

   177             'in': (None, 'Widget'),

   178             'ipadx': (0, 'Pad'),

   179             'ipady': (0, 'Pad'),

   180             'padx': (0, 'Pad'),

   181             'pady': (0, 'Pad'),

   182             'side': ('top', 'Side'),

   183             }

   184 

   185     classes = {

   186             'Anchor': (N, NE, E, SE, S, SW, W, NW, CENTER),

   187             'Boolean': 'boolean',

   188             'Class': 'readonly',

   189             'Expand': 'boolean',

   190             'Fill': (NONE, X, Y, BOTH),

   191             'Name': 'readonly',

   192             'Pad': 'pixel',

   193             'Side': (TOP, RIGHT, BOTTOM, LEFT),

   194             'Widget': 'readonly',

   195             }

   196 

   197 class RemotePackDialog(PackDialog):

   198 

   199     def __init__(self, master, app, widget):

   200         self.master = master

   201         self.app = app

   202         self.widget = widget

   203         self.refresh()

   204         self.top = Toplevel(self.master)

   205         self.top.title(self.app + ' PackDialog')

   206         self.top.minsize(1, 1)

   207         self.addchoices()

   208 

   209     def refresh(self):

   210         try:

   211             words = self.master.tk.splitlist(

   212                     self.master.send(self.app,

   213                                      'pack',

   214                                      'info',

   215                                      self.widget))

   216         except TclError, msg:

   217             print msg

   218             return

   219         dict = {}

   220         for i in range(0, len(words), 2):

   221             key = words[i][1:]

   222             value = words[i+1]

   223             dict[key] = value

   224         dict['.class'] = self.master.send(self.app,

   225                                           'winfo',

   226                                           'class',

   227                                           self.widget)

   228         dict['.name'] = self.widget

   229         self.current = dict

   230 

   231     class remotepackoption: # Mix-in class

   232         def set(self, e=None):

   233             self.current = self.var.get()

   234             try:

   235                 self.dialog.master.send(

   236                         self.dialog.app,

   237                         'pack',

   238                         'config',

   239                         self.dialog.widget,

   240                         '-'+self.option,

   241                         self.dialog.master.tk.merge(

   242                                 self.current))

   243             except TclError, msg:

   244                 print msg

   245                 self.refresh()

   246 

   247     class booleanoption(remotepackoption, BooleanOption): pass

   248     class enumoption(remotepackoption, EnumOption): pass

   249     class stringoption(remotepackoption, StringOption): pass

   250     class readonlyoption(remotepackoption, ReadonlyOption): pass

   251 

   252 class WidgetDialog(Dialog):

   253 

   254     def __init__(self, widget):

   255         self.widget = widget

   256         self.klass = widget.winfo_class()

   257         Dialog.__init__(self, widget)

   258 

   259     def fixclasses(self):

   260         if self.addclasses.has_key(self.klass):

   261             classes = {}

   262             for c in (self.classes,

   263                       self.addclasses[self.klass]):

   264                 for k in c.keys():

   265                     classes[k] = c[k]

   266             self.classes = classes

   267 

   268     def refresh(self):

   269         self.configuration = self.widget.config()

   270         self.update()

   271         self.current['.class'] = self.widget.winfo_class()

   272         self.current['.name'] = self.widget._w

   273 

   274     def update(self):

   275         self.current = {}

   276         self.options = {}

   277         for k, v in self.configuration.items():

   278             if len(v) > 4:

   279                 self.current[k] = v[4]

   280                 self.options[k] = v[3], v[2] # default, klass

   281         self.options['.class'] = (None, 'Class')

   282         self.options['.name'] = (None, 'Name')

   283 

   284     class widgetoption: # Mix-in class

   285         def set(self, e=None):

   286             self.current = self.var.get()

   287             try:

   288                 self.dialog.widget[self.option] = self.current

   289             except TclError, msg:

   290                 print msg

   291                 self.refresh()

   292 

   293     class booleanoption(widgetoption, BooleanOption): pass

   294     class enumoption(widgetoption, EnumOption): pass

   295     class stringoption(widgetoption, StringOption): pass

   296     class readonlyoption(widgetoption, ReadonlyOption): pass

   297 

   298     # Universal classes

   299     classes = {

   300             'Anchor': (N, NE, E, SE, S, SW, W, NW, CENTER),

   301             'Aspect': 'integer',

   302             'Background': 'color',

   303             'Bitmap': 'bitmap',

   304             'BorderWidth': 'pixel',

   305             'Class': 'readonly',

   306             'CloseEnough': 'double',

   307             'Command': 'command',

   308             'Confine': 'boolean',

   309             'Cursor': 'cursor',

   310             'CursorWidth': 'pixel',

   311             'DisabledForeground': 'color',

   312             'ExportSelection': 'boolean',

   313             'Font': 'font',

   314             'Foreground': 'color',

   315             'From': 'integer',

   316             'Geometry': 'geometry',

   317             'Height': 'pixel',

   318             'InsertWidth': 'time',

   319             'Justify': (LEFT, CENTER, RIGHT),

   320             'Label': 'string',

   321             'Length': 'pixel',

   322             'MenuName': 'widget',

   323             'Name': 'readonly',

   324             'OffTime': 'time',

   325             'OnTime': 'time',

   326             'Orient': (HORIZONTAL, VERTICAL),

   327             'Pad': 'pixel',

   328             'Relief': (RAISED, SUNKEN, FLAT, RIDGE, GROOVE),

   329             'RepeatDelay': 'time',

   330             'RepeatInterval': 'time',

   331             'ScrollCommand': 'command',

   332             'ScrollIncrement': 'pixel',

   333             'ScrollRegion': 'rectangle',

   334             'ShowValue': 'boolean',

   335             'SetGrid': 'boolean',

   336             'Sliderforeground': 'color',

   337             'SliderLength': 'pixel',

   338             'Text': 'string',

   339             'TickInterval': 'integer',

   340             'To': 'integer',

   341             'Underline': 'index',

   342             'Variable': 'variable',

   343             'Value': 'string',

   344             'Width': 'pixel',

   345             'Wrap': (NONE, CHAR, WORD),

   346             }

   347 

   348     # Classes that (may) differ per widget type

   349     _tristate = {'State': (NORMAL, ACTIVE, DISABLED)}

   350     _bistate = {'State': (NORMAL, DISABLED)}

   351     addclasses = {

   352             'Button': _tristate,

   353             'Radiobutton': _tristate,

   354             'Checkbutton': _tristate,

   355             'Entry': _bistate,

   356             'Text': _bistate,

   357             'Menubutton': _tristate,

   358             'Slider': _bistate,

   359             }

   360 

   361 class RemoteWidgetDialog(WidgetDialog):

   362 

   363     def __init__(self, master, app, widget):

   364         self.app = app

   365         self.widget = widget

   366         self.klass = master.send(self.app,

   367                                  'winfo',

   368                                  'class',

   369                                  self.widget)

   370         Dialog.__init__(self, master)

   371 

   372     def refresh(self):

   373         try:

   374             items = self.master.tk.splitlist(

   375                     self.master.send(self.app,

   376                                      self.widget,

   377                                      'config'))

   378         except TclError, msg:

   379             print msg

   380             return

   381         dict = {}

   382         for item in items:

   383             words = self.master.tk.splitlist(item)

   384             key = words[0][1:]

   385             value = (key,) + words[1:]

   386             dict[key] = value

   387         self.configuration = dict

   388         self.update()

   389         self.current['.class'] = self.klass

   390         self.current['.name'] = self.widget

   391 

   392     class remotewidgetoption: # Mix-in class

   393         def set(self, e=None):

   394             self.current = self.var.get()

   395             try:

   396                 self.dialog.master.send(

   397                         self.dialog.app,

   398                         self.dialog.widget,

   399                         'config',

   400                         '-'+self.option,

   401                         self.current)

   402             except TclError, msg:

   403                 print msg

   404                 self.refresh()

   405 

   406     class booleanoption(remotewidgetoption, BooleanOption): pass

   407     class enumoption(remotewidgetoption, EnumOption): pass

   408     class stringoption(remotewidgetoption, StringOption): pass

   409     class readonlyoption(remotewidgetoption, ReadonlyOption): pass

   410 

   411 def test():

   412     import sys

   413     root = Tk()

   414     root.minsize(1, 1)

   415     if sys.argv[1:]:

   416         remotetest(root, sys.argv[1])

   417     else:

   418         frame = Frame(root, name='frame')

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

   420         button = Button(frame, name='button', text='button')

   421         button.pack(expand=1)

   422         canvas = Canvas(frame, name='canvas')

   423         canvas.pack()

   424         fpd = PackDialog(frame)

   425         fwd = WidgetDialog(frame)

   426         bpd = PackDialog(button)

   427         bwd = WidgetDialog(button)

   428         cpd = PackDialog(canvas)

   429         cwd = WidgetDialog(canvas)

   430     root.mainloop()

   431 

   432 def remotetest(root, app):

   433     from listtree import listtree

   434     list = listtree(root, app)

   435     list.bind('<Any-Double-1>', opendialogs)

   436     list.app = app                  # Pass it on to handler

   437 

   438 def opendialogs(e):

   439     import string

   440     list = e.widget

   441     sel = list.curselection()

   442     for i in sel:

   443         item = list.get(i)

   444         widget = string.split(item)[0]

   445         RemoteWidgetDialog(list, list.app, widget)

   446         if widget == '.': continue

   447         try:

   448             RemotePackDialog(list, list.app, widget)

   449         except TclError, msg:

   450             print msg

   451 

   452 test()