File Manager

X7ROOT File Manager

Current Path: /lib64/python2.7/Demo/tkinter/guido

lib64 / python2.7 / Demo / tkinter / guido /

?? ..
?? AttrDialog.py(14 KB)
?? AttrDialog.pyc(18.33 KB)
?? AttrDialog.pyo(18.33 KB)
?? ManPage.py(6.7 KB)
?? ManPage.pyc(6.27 KB)
?? ManPage.pyo(6.27 KB)
?? MimeViewer.py(4.39 KB)
?? MimeViewer.pyc(4.83 KB)
?? MimeViewer.pyo(4.83 KB)
?? ShellWindow.py(4.07 KB)
?? ShellWindow.pyc(5.47 KB)
?? ShellWindow.pyo(5.47 KB)
?? brownian.py(1.07 KB)
?? brownian.pyc(1.59 KB)
?? brownian.pyo(1.59 KB)
?? brownian2.py(1.35 KB)
?? brownian2.pyc(1.74 KB)
?? brownian2.pyo(1.74 KB)
?? canvasevents.py(6.45 KB)
?? canvasevents.pyc(10.46 KB)
?? canvasevents.pyo(10.46 KB)
?? dialog.py(3.13 KB)
?? dialog.pyc(3.11 KB)
?? dialog.pyo(3.11 KB)
?? electrons.py(2.27 KB)
?? electrons.pyc(2.33 KB)
?? electrons.pyo(2.33 KB)
?? hanoi.py(4.54 KB)
?? hanoi.pyc(3.82 KB)
?? hanoi.pyo(3.82 KB)
?? hello.py(331 B)
?? hello.pyc(701 B)
?? hello.pyo(701 B)
?? imagedraw.py(509 B)
?? imagedraw.pyc(1.13 KB)
?? imagedraw.pyo(1.13 KB)
?? imageview.py(205 B)
?? imageview.pyc(570 B)
?? imageview.pyo(570 B)
?? kill.py(3.79 KB)
?? kill.pyc(4.81 KB)
?? kill.pyo(4.81 KB)
?? listtree.py(991 B)
?? listtree.pyc(1.5 KB)
?? listtree.pyo(1.5 KB)
?? mbox.py(7.3 KB)
?? mbox.pyc(8.17 KB)
?? mbox.pyo(8.17 KB)
?? newmenubardemo.py(1.2 KB)
?? newmenubardemo.pyc(1.59 KB)
?? newmenubardemo.pyo(1.59 KB)
?? optionmenu.py(441 B)
?? optionmenu.pyc(594 B)
?? optionmenu.pyo(594 B)
?? paint.py(1.85 KB)
?? paint.pyc(2.19 KB)
?? paint.pyo(2.19 KB)
?? rmt.py(4.39 KB)
?? rmt.pyc(4.93 KB)
?? rmt.pyo(4.93 KB)
?? solitaire.py(17.37 KB)
?? solitaire.pyc(20.41 KB)
?? solitaire.pyo(20.41 KB)
?? sortvisu.py(18.89 KB)
?? sortvisu.pyc(23.18 KB)
?? sortvisu.pyo(23.18 KB)
?? ss1.py(25.57 KB)
?? ss1.pyc(31.67 KB)
?? ss1.pyo(31.07 KB)
?? svkill.py(4.75 KB)
?? svkill.pyc(5.8 KB)
?? svkill.pyo(5.8 KB)
?? switch.py(1.52 KB)
?? switch.pyc(2.85 KB)
?? switch.pyo(2.85 KB)
?? tkman.py(8.79 KB)
?? tkman.pyc(8.88 KB)
?? tkman.pyo(8.88 KB)
?? wish.py(623 B)
?? wish.pyc(737 B)
?? wish.pyo(737 B)

Editing: AttrDialog.py

# The options of a widget are described by the following attributes
# of the Pack and Widget dialogs:
#
# Dialog.current: {name: value}
# -- changes during Widget's lifetime
#
# Dialog.options: {name: (default, klass)}
# -- depends on widget class only
#
# Dialog.classes: {klass: (v0, v1, v2, ...) | 'boolean' | 'other'}
# -- totally static, though different between PackDialog and WidgetDialog
#    (but even that could be unified)

from Tkinter import *

class Option:

varclass = StringVar            # May be overridden

def __init__(self, dialog, option):
        self.dialog = dialog
        self.option = option
        self.master = dialog.top
        self.default, self.klass = dialog.options[option]
        self.var = self.varclass(self.master)
        self.frame = Frame(self.master)
        self.frame.pack(fill=X)
        self.label = Label(self.frame, text=(option + ":"))
        self.label.pack(side=LEFT)
        self.update()
        self.addoption()

def refresh(self):
        self.dialog.refresh()
        self.update()

def update(self):
        try:
            self.current = self.dialog.current[self.option]
        except KeyError:
            self.current = self.default
        self.var.set(self.current)

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

class BooleanOption(Option):

varclass = BooleanVar

def addoption(self):
        self.button = Checkbutton(self.frame,
                                 text='on/off',
                                 onvalue=1,
                                 offvalue=0,
                                 variable=self.var,
                                 relief=RAISED,
                                 borderwidth=2,
                                 command=self.set)
        self.button.pack(side=RIGHT)

class EnumOption(Option):

def addoption(self):
        self.button = Menubutton(self.frame,
                                 textvariable=self.var,
                                 relief=RAISED, borderwidth=2)
        self.button.pack(side=RIGHT)
        self.menu = Menu(self.button)
        self.button['menu'] = self.menu
        for v in self.dialog.classes[self.klass]:
            self.menu.add_radiobutton(
                label=v,
                variable=self.var,
                value=v,
                command=self.set)

class StringOption(Option):

def addoption(self):
        self.entry = Entry(self.frame,
                           textvariable=self.var,
                           width=10,
                           relief=SUNKEN,
                           borderwidth=2)
        self.entry.pack(side=RIGHT, fill=X, expand=1)
        self.entry.bind('<Return>', self.set)

class ReadonlyOption(Option):

def addoption(self):
        self.label = Label(self.frame, textvariable=self.var,
                           anchor=E)
        self.label.pack(side=RIGHT)

class Dialog:

def __init__(self, master):
        self.master = master
        self.fixclasses()
        self.refresh()
        self.top = Toplevel(self.master)
        self.top.title(self.__class__.__name__)
        self.top.minsize(1, 1)
        self.addchoices()

def refresh(self): pass         # Must override

def fixclasses(self): pass      # May override

def addchoices(self):
        self.choices = {}
        list = []
        for k, dc in self.options.items():
            list.append((k, dc))
        list.sort()
        for k, (d, c) in list:
            try:
                cl = self.classes[c]
            except KeyError:
                cl = 'unknown'
            if type(cl) == TupleType:
                cl = self.enumoption
            elif cl == 'boolean':
                cl = self.booleanoption
            elif cl == 'readonly':
                cl = self.readonlyoption
            else:
                cl = self.stringoption
            self.choices[k] = cl(self, k)

# Must override:
    options = {}
    classes = {}

# May override:
    booleanoption = BooleanOption
    stringoption = StringOption
    enumoption = EnumOption
    readonlyoption = ReadonlyOption

class PackDialog(Dialog):

def __init__(self, widget):
        self.widget = widget
        Dialog.__init__(self, widget)

def refresh(self):
        self.current = self.widget.info()
        self.current['.class'] = self.widget.winfo_class()
        self.current['.name'] = self.widget._w

class packoption: # Mix-in class
        def set(self, e=None):
            self.current = self.var.get()
            try:
                apply(self.dialog.widget.pack, (),
                      {self.option: self.current})
            except TclError, msg:
                print msg
                self.refresh()

class booleanoption(packoption, BooleanOption): pass
    class enumoption(packoption, EnumOption): pass
    class stringoption(packoption, StringOption): pass
    class readonlyoption(packoption, ReadonlyOption): pass

options = {
            '.class': (None, 'Class'),
            '.name': (None, 'Name'),
            'after': (None, 'Widget'),
            'anchor': ('center', 'Anchor'),
            'before': (None, 'Widget'),
            'expand': ('no', 'Boolean'),
            'fill': ('none', 'Fill'),
            'in': (None, 'Widget'),
            'ipadx': (0, 'Pad'),
            'ipady': (0, 'Pad'),
            'padx': (0, 'Pad'),
            'pady': (0, 'Pad'),
            'side': ('top', 'Side'),
            }

classes = {
            'Anchor': (N, NE, E, SE, S, SW, W, NW, CENTER),
            'Boolean': 'boolean',
            'Class': 'readonly',
            'Expand': 'boolean',
            'Fill': (NONE, X, Y, BOTH),
            'Name': 'readonly',
            'Pad': 'pixel',
            'Side': (TOP, RIGHT, BOTTOM, LEFT),
            'Widget': 'readonly',
            }

class RemotePackDialog(PackDialog):

def __init__(self, master, app, widget):
        self.master = master
        self.app = app
        self.widget = widget
        self.refresh()
        self.top = Toplevel(self.master)
        self.top.title(self.app + ' PackDialog')
        self.top.minsize(1, 1)
        self.addchoices()

def refresh(self):
        try:
            words = self.master.tk.splitlist(
                    self.master.send(self.app,
                                     'pack',
                                     'info',
                                     self.widget))
        except TclError, msg:
            print msg
            return
        dict = {}
        for i in range(0, len(words), 2):
            key = words[i][1:]
            value = words[i+1]
            dict[key] = value
        dict['.class'] = self.master.send(self.app,
                                          'winfo',
                                          'class',
                                          self.widget)
        dict['.name'] = self.widget
        self.current = dict

class remotepackoption: # Mix-in class
        def set(self, e=None):
            self.current = self.var.get()
            try:
                self.dialog.master.send(
                        self.dialog.app,
                        'pack',
                        'config',
                        self.dialog.widget,
                        '-'+self.option,
                        self.dialog.master.tk.merge(
                                self.current))
            except TclError, msg:
                print msg
                self.refresh()

class booleanoption(remotepackoption, BooleanOption): pass
    class enumoption(remotepackoption, EnumOption): pass
    class stringoption(remotepackoption, StringOption): pass
    class readonlyoption(remotepackoption, ReadonlyOption): pass

class WidgetDialog(Dialog):

def __init__(self, widget):
        self.widget = widget
        self.klass = widget.winfo_class()
        Dialog.__init__(self, widget)

def fixclasses(self):
        if self.addclasses.has_key(self.klass):
            classes = {}
            for c in (self.classes,
                      self.addclasses[self.klass]):
                for k in c.keys():
                    classes[k] = c[k]
            self.classes = classes

def refresh(self):
        self.configuration = self.widget.config()
        self.update()
        self.current['.class'] = self.widget.winfo_class()
        self.current['.name'] = self.widget._w

def update(self):
        self.current = {}
        self.options = {}
        for k, v in self.configuration.items():
            if len(v) > 4:
                self.current[k] = v[4]
                self.options[k] = v[3], v[2] # default, klass
        self.options['.class'] = (None, 'Class')
        self.options['.name'] = (None, 'Name')

class widgetoption: # Mix-in class
        def set(self, e=None):
            self.current = self.var.get()
            try:
                self.dialog.widget[self.option] = self.current
            except TclError, msg:
                print msg
                self.refresh()

class booleanoption(widgetoption, BooleanOption): pass
    class enumoption(widgetoption, EnumOption): pass
    class stringoption(widgetoption, StringOption): pass
    class readonlyoption(widgetoption, ReadonlyOption): pass

# Universal classes
    classes = {
            'Anchor': (N, NE, E, SE, S, SW, W, NW, CENTER),
            'Aspect': 'integer',
            'Background': 'color',
            'Bitmap': 'bitmap',
            'BorderWidth': 'pixel',
            'Class': 'readonly',
            'CloseEnough': 'double',
            'Command': 'command',
            'Confine': 'boolean',
            'Cursor': 'cursor',
            'CursorWidth': 'pixel',
            'DisabledForeground': 'color',
            'ExportSelection': 'boolean',
            'Font': 'font',
            'Foreground': 'color',
            'From': 'integer',
            'Geometry': 'geometry',
            'Height': 'pixel',
            'InsertWidth': 'time',
            'Justify': (LEFT, CENTER, RIGHT),
            'Label': 'string',
            'Length': 'pixel',
            'MenuName': 'widget',
            'Name': 'readonly',
            'OffTime': 'time',
            'OnTime': 'time',
            'Orient': (HORIZONTAL, VERTICAL),
            'Pad': 'pixel',
            'Relief': (RAISED, SUNKEN, FLAT, RIDGE, GROOVE),
            'RepeatDelay': 'time',
            'RepeatInterval': 'time',
            'ScrollCommand': 'command',
            'ScrollIncrement': 'pixel',
            'ScrollRegion': 'rectangle',
            'ShowValue': 'boolean',
            'SetGrid': 'boolean',
            'Sliderforeground': 'color',
            'SliderLength': 'pixel',
            'Text': 'string',
            'TickInterval': 'integer',
            'To': 'integer',
            'Underline': 'index',
            'Variable': 'variable',
            'Value': 'string',
            'Width': 'pixel',
            'Wrap': (NONE, CHAR, WORD),
            }

# Classes that (may) differ per widget type
    _tristate = {'State': (NORMAL, ACTIVE, DISABLED)}
    _bistate = {'State': (NORMAL, DISABLED)}
    addclasses = {
            'Button': _tristate,
            'Radiobutton': _tristate,
            'Checkbutton': _tristate,
            'Entry': _bistate,
            'Text': _bistate,
            'Menubutton': _tristate,
            'Slider': _bistate,
            }

class RemoteWidgetDialog(WidgetDialog):

def __init__(self, master, app, widget):
        self.app = app
        self.widget = widget
        self.klass = master.send(self.app,
                                 'winfo',
                                 'class',
                                 self.widget)
        Dialog.__init__(self, master)

def refresh(self):
        try:
            items = self.master.tk.splitlist(
                    self.master.send(self.app,
                                     self.widget,
                                     'config'))
        except TclError, msg:
            print msg
            return
        dict = {}
        for item in items:
            words = self.master.tk.splitlist(item)
            key = words[0][1:]
            value = (key,) + words[1:]
            dict[key] = value
        self.configuration = dict
        self.update()
        self.current['.class'] = self.klass
        self.current['.name'] = self.widget

class remotewidgetoption: # Mix-in class
        def set(self, e=None):
            self.current = self.var.get()
            try:
                self.dialog.master.send(
                        self.dialog.app,
                        self.dialog.widget,
                        'config',
                        '-'+self.option,
                        self.current)
            except TclError, msg:
                print msg
                self.refresh()

class booleanoption(remotewidgetoption, BooleanOption): pass
    class enumoption(remotewidgetoption, EnumOption): pass
    class stringoption(remotewidgetoption, StringOption): pass
    class readonlyoption(remotewidgetoption, ReadonlyOption): pass

def test():
    import sys
    root = Tk()
    root.minsize(1, 1)
    if sys.argv[1:]:
        remotetest(root, sys.argv[1])
    else:
        frame = Frame(root, name='frame')
        frame.pack(expand=1, fill=BOTH)
        button = Button(frame, name='button', text='button')
        button.pack(expand=1)
        canvas = Canvas(frame, name='canvas')
        canvas.pack()
        fpd = PackDialog(frame)
        fwd = WidgetDialog(frame)
        bpd = PackDialog(button)
        bwd = WidgetDialog(button)
        cpd = PackDialog(canvas)
        cwd = WidgetDialog(canvas)
    root.mainloop()

def remotetest(root, app):
    from listtree import listtree
    list = listtree(root, app)
    list.bind('<Any-Double-1>', opendialogs)
    list.app = app                  # Pass it on to handler

def opendialogs(e):
    import string
    list = e.widget
    sel = list.curselection()
    for i in sel:
        item = list.get(i)
        widget = string.split(item)[0]
        RemoteWidgetDialog(list, list.app, widget)
        if widget == '.': continue
        try:
            RemotePackDialog(list, list.app, widget)
        except TclError, msg:
            print msg

test()

X7ROOT File Manager

Editing: AttrDialog.py

Upload File

Create Folder