Gecko [ renovalkoronred.com.tr ]

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

Code Editor : 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()

${this.title}

Code Editor : AttrDialog.py