Demo/tkinter/guido/AttrDialog.py

   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()