Whitespace normalization, via reindent.py.
diff --git a/Demo/tkinter/guido/AttrDialog.py b/Demo/tkinter/guido/AttrDialog.py
index 4878cb5..86333ad 100755
--- a/Demo/tkinter/guido/AttrDialog.py
+++ b/Demo/tkinter/guido/AttrDialog.py
@@ -16,437 +16,437 @@
class Option:
- varclass = StringVar # May be overridden
+ 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 __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 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 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
+ def set(self, e=None): # Should be overridden
+ pass
class BooleanOption(Option):
- varclass = BooleanVar
+ 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)
+ 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)
+ 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)
+ 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)
+ 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 __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 refresh(self): pass # Must override
- def fixclasses(self): pass # May 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)
+ 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 = {}
+ # Must override:
+ options = {}
+ classes = {}
- # May override:
- booleanoption = BooleanOption
- stringoption = StringOption
- enumoption = EnumOption
- readonlyoption = ReadonlyOption
+ # 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 __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
+ 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 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
+ 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'),
- }
+ 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',
- }
+ 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 __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
+ 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 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 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 __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 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 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')
+ 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 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
+ 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),
- }
+ # 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,
- }
+ # 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 __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
+ 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 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
+ 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()
+ 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
+ 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
+ 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()
diff --git a/Demo/tkinter/guido/ManPage.py b/Demo/tkinter/guido/ManPage.py
index ccd21b4..7d6fe00 100755
--- a/Demo/tkinter/guido/ManPage.py
+++ b/Demo/tkinter/guido/ManPage.py
@@ -12,173 +12,173 @@
# XXX Recognizing footers is system dependent
# (This one works for IRIX 5.2 and Solaris 2.2)
footerprog = regex.compile(
- '^ Page [1-9][0-9]*[ \t]+\|^.*Last change:.*[1-9][0-9]*\n')
+ '^ Page [1-9][0-9]*[ \t]+\|^.*Last change:.*[1-9][0-9]*\n')
emptyprog = regex.compile('^[ \t]*\n')
ulprog = regex.compile('^[ \t]*[Xv!_][Xv!_ \t]*\n')
# Basic Man Page class -- does not disable editing
class EditableManPage(ScrolledText):
- # Initialize instance
- def __init__(self, master=None, **cnf):
- # Initialize base class
- apply(ScrolledText.__init__, (self, master), cnf)
+ # Initialize instance
+ def __init__(self, master=None, **cnf):
+ # Initialize base class
+ apply(ScrolledText.__init__, (self, master), cnf)
- # Define tags for formatting styles
- self.tag_config('X', underline=1)
- self.tag_config('!', font=BOLDFONT)
- self.tag_config('_', font=ITALICFONT)
+ # Define tags for formatting styles
+ self.tag_config('X', underline=1)
+ self.tag_config('!', font=BOLDFONT)
+ self.tag_config('_', font=ITALICFONT)
- # Set state to idle
- self.fp = None
- self.lineno = 0
+ # Set state to idle
+ self.fp = None
+ self.lineno = 0
- # Test whether we are busy parsing a file
- def busy(self):
- return self.fp != None
+ # Test whether we are busy parsing a file
+ def busy(self):
+ return self.fp != None
- # Ensure we're not busy
- def kill(self):
- if self.busy():
- self._endparser()
+ # Ensure we're not busy
+ def kill(self):
+ if self.busy():
+ self._endparser()
- # Parse a file, in the background
- def asyncparsefile(self, fp):
- self._startparser(fp)
- self.tk.createfilehandler(fp, _tkinter.READABLE,
- self._filehandler)
+ # Parse a file, in the background
+ def asyncparsefile(self, fp):
+ self._startparser(fp)
+ self.tk.createfilehandler(fp, _tkinter.READABLE,
+ self._filehandler)
- parsefile = asyncparsefile # Alias
+ parsefile = asyncparsefile # Alias
- # I/O handler used by background parsing
- def _filehandler(self, fp, mask):
- nextline = self.fp.readline()
- if not nextline:
- self._endparser()
- return
- self._parseline(nextline)
+ # I/O handler used by background parsing
+ def _filehandler(self, fp, mask):
+ nextline = self.fp.readline()
+ if not nextline:
+ self._endparser()
+ return
+ self._parseline(nextline)
- # Parse a file, now (cannot be aborted)
- def syncparsefile(self, fp):
- from select import select
- def avail(fp=fp, tout=0.0, select=select):
- return select([fp], [], [], tout)[0]
- height = self.getint(self['height'])
- self._startparser(fp)
- while 1:
- nextline = fp.readline()
- if not nextline:
- break
- self._parseline(nextline)
- self._endparser()
+ # Parse a file, now (cannot be aborted)
+ def syncparsefile(self, fp):
+ from select import select
+ def avail(fp=fp, tout=0.0, select=select):
+ return select([fp], [], [], tout)[0]
+ height = self.getint(self['height'])
+ self._startparser(fp)
+ while 1:
+ nextline = fp.readline()
+ if not nextline:
+ break
+ self._parseline(nextline)
+ self._endparser()
- # Initialize parsing from a particular file -- must not be busy
- def _startparser(self, fp):
- if self.busy():
- raise RuntimeError, 'startparser: still busy'
- fp.fileno() # Test for file-ness
- self.fp = fp
- self.lineno = 0
- self.ok = 0
- self.empty = 0
- self.buffer = None
- savestate = self['state']
- self['state'] = NORMAL
- self.delete('1.0', END)
- self['state'] = savestate
+ # Initialize parsing from a particular file -- must not be busy
+ def _startparser(self, fp):
+ if self.busy():
+ raise RuntimeError, 'startparser: still busy'
+ fp.fileno() # Test for file-ness
+ self.fp = fp
+ self.lineno = 0
+ self.ok = 0
+ self.empty = 0
+ self.buffer = None
+ savestate = self['state']
+ self['state'] = NORMAL
+ self.delete('1.0', END)
+ self['state'] = savestate
- # End parsing -- must be busy, need not be at EOF
- def _endparser(self):
- if not self.busy():
- raise RuntimeError, 'endparser: not busy'
- if self.buffer:
- self._parseline('')
- try:
- self.tk.deletefilehandler(self.fp)
- except TclError, msg:
- pass
- self.fp.close()
- self.fp = None
- del self.ok, self.empty, self.buffer
+ # End parsing -- must be busy, need not be at EOF
+ def _endparser(self):
+ if not self.busy():
+ raise RuntimeError, 'endparser: not busy'
+ if self.buffer:
+ self._parseline('')
+ try:
+ self.tk.deletefilehandler(self.fp)
+ except TclError, msg:
+ pass
+ self.fp.close()
+ self.fp = None
+ del self.ok, self.empty, self.buffer
- # Parse a single line
- def _parseline(self, nextline):
- if not self.buffer:
- # Save this line -- we need one line read-ahead
- self.buffer = nextline
- return
- if emptyprog.match(self.buffer) >= 0:
- # Buffered line was empty -- set a flag
- self.empty = 1
- self.buffer = nextline
- return
- textline = self.buffer
- if ulprog.match(nextline) >= 0:
- # Next line is properties for buffered line
- propline = nextline
- self.buffer = None
- else:
- # Next line is read-ahead
- propline = None
- self.buffer = nextline
- if not self.ok:
- # First non blank line after footer must be header
- # -- skip that too
- self.ok = 1
- self.empty = 0
- return
- if footerprog.match(textline) >= 0:
- # Footer -- start skipping until next non-blank line
- self.ok = 0
- self.empty = 0
- return
- savestate = self['state']
- self['state'] = NORMAL
- if TkVersion >= 4.0:
- self.mark_set('insert', 'end-1c')
- else:
- self.mark_set('insert', END)
- if self.empty:
- # One or more previous lines were empty
- # -- insert one blank line in the text
- self._insert_prop('\n')
- self.lineno = self.lineno + 1
- self.empty = 0
- if not propline:
- # No properties
- self._insert_prop(textline)
- else:
- # Search for properties
- p = ''
- j = 0
- for i in range(min(len(propline), len(textline))):
- if propline[i] != p:
- if j < i:
- self._insert_prop(textline[j:i], p)
- j = i
- p = propline[i]
- self._insert_prop(textline[j:])
- self.lineno = self.lineno + 1
- self['state'] = savestate
+ # Parse a single line
+ def _parseline(self, nextline):
+ if not self.buffer:
+ # Save this line -- we need one line read-ahead
+ self.buffer = nextline
+ return
+ if emptyprog.match(self.buffer) >= 0:
+ # Buffered line was empty -- set a flag
+ self.empty = 1
+ self.buffer = nextline
+ return
+ textline = self.buffer
+ if ulprog.match(nextline) >= 0:
+ # Next line is properties for buffered line
+ propline = nextline
+ self.buffer = None
+ else:
+ # Next line is read-ahead
+ propline = None
+ self.buffer = nextline
+ if not self.ok:
+ # First non blank line after footer must be header
+ # -- skip that too
+ self.ok = 1
+ self.empty = 0
+ return
+ if footerprog.match(textline) >= 0:
+ # Footer -- start skipping until next non-blank line
+ self.ok = 0
+ self.empty = 0
+ return
+ savestate = self['state']
+ self['state'] = NORMAL
+ if TkVersion >= 4.0:
+ self.mark_set('insert', 'end-1c')
+ else:
+ self.mark_set('insert', END)
+ if self.empty:
+ # One or more previous lines were empty
+ # -- insert one blank line in the text
+ self._insert_prop('\n')
+ self.lineno = self.lineno + 1
+ self.empty = 0
+ if not propline:
+ # No properties
+ self._insert_prop(textline)
+ else:
+ # Search for properties
+ p = ''
+ j = 0
+ for i in range(min(len(propline), len(textline))):
+ if propline[i] != p:
+ if j < i:
+ self._insert_prop(textline[j:i], p)
+ j = i
+ p = propline[i]
+ self._insert_prop(textline[j:])
+ self.lineno = self.lineno + 1
+ self['state'] = savestate
- # Insert a string at the end, with at most one property (tag)
- def _insert_prop(self, str, prop = ' '):
- here = self.index(AtInsert())
- self.insert(AtInsert(), str)
- if TkVersion <= 4.0:
- tags = self.tag_names(here)
- for tag in tags:
- self.tag_remove(tag, here, AtInsert())
- if prop != ' ':
- self.tag_add(prop, here, AtInsert())
+ # Insert a string at the end, with at most one property (tag)
+ def _insert_prop(self, str, prop = ' '):
+ here = self.index(AtInsert())
+ self.insert(AtInsert(), str)
+ if TkVersion <= 4.0:
+ tags = self.tag_names(here)
+ for tag in tags:
+ self.tag_remove(tag, here, AtInsert())
+ if prop != ' ':
+ self.tag_add(prop, here, AtInsert())
# Readonly Man Page class -- disables editing, otherwise the same
class ReadonlyManPage(EditableManPage):
- # Initialize instance
- def __init__(self, master=None, **cnf):
- cnf['state'] = DISABLED
- apply(EditableManPage.__init__, (self, master), cnf)
+ # Initialize instance
+ def __init__(self, master=None, **cnf):
+ cnf['state'] = DISABLED
+ apply(EditableManPage.__init__, (self, master), cnf)
# Alias
ManPage = ReadonlyManPage
@@ -187,34 +187,34 @@
# usage: ManPage [manpage]; or ManPage [-f] file
# -f means that the file is nroff -man output run through ul -i
def test():
- import os
- import sys
- # XXX This directory may be different on your system
- MANDIR = '/usr/local/man/mann'
- DEFAULTPAGE = 'Tcl'
- formatted = 0
- if sys.argv[1:] and sys.argv[1] == '-f':
- formatted = 1
- del sys.argv[1]
- if sys.argv[1:]:
- name = sys.argv[1]
- else:
- name = DEFAULTPAGE
- if not formatted:
- if name[-2:-1] != '.':
- name = name + '.n'
- name = os.path.join(MANDIR, name)
- root = Tk()
- root.minsize(1, 1)
- manpage = ManPage(root, relief=SUNKEN, borderwidth=2)
- manpage.pack(expand=1, fill=BOTH)
- if formatted:
- fp = open(name, 'r')
- else:
- fp = os.popen('nroff -man %s | ul -i' % name, 'r')
- manpage.parsefile(fp)
- root.mainloop()
+ import os
+ import sys
+ # XXX This directory may be different on your system
+ MANDIR = '/usr/local/man/mann'
+ DEFAULTPAGE = 'Tcl'
+ formatted = 0
+ if sys.argv[1:] and sys.argv[1] == '-f':
+ formatted = 1
+ del sys.argv[1]
+ if sys.argv[1:]:
+ name = sys.argv[1]
+ else:
+ name = DEFAULTPAGE
+ if not formatted:
+ if name[-2:-1] != '.':
+ name = name + '.n'
+ name = os.path.join(MANDIR, name)
+ root = Tk()
+ root.minsize(1, 1)
+ manpage = ManPage(root, relief=SUNKEN, borderwidth=2)
+ manpage.pack(expand=1, fill=BOTH)
+ if formatted:
+ fp = open(name, 'r')
+ else:
+ fp = os.popen('nroff -man %s | ul -i' % name, 'r')
+ manpage.parsefile(fp)
+ root.mainloop()
# Run the test program when called as a script
if __name__ == '__main__':
- test()
+ test()
diff --git a/Demo/tkinter/guido/MimeViewer.py b/Demo/tkinter/guido/MimeViewer.py
index 2b98579..7494425 100755
--- a/Demo/tkinter/guido/MimeViewer.py
+++ b/Demo/tkinter/guido/MimeViewer.py
@@ -9,135 +9,135 @@
from ScrolledText import ScrolledText
class MimeViewer:
- def __init__(self, parent, title, msg):
- self.title = title
- self.msg = msg
- self.frame = Frame(parent, {'relief': 'raised', 'bd': 2})
- self.frame.packing = {'expand': 0, 'fill': 'both'}
- self.button = Checkbutton(self.frame,
- {'text': title,
- 'command': self.toggle})
- self.button.pack({'anchor': 'w'})
- headertext = msg.getheadertext(
- lambda x: x != 'received' and x[:5] != 'x400-')
- height = countlines(headertext, 4)
- if height:
- self.htext = ScrolledText(self.frame,
- {'height': height,
- 'width': 80,
- 'wrap': 'none',
- 'relief': 'raised',
- 'bd': 2})
- self.htext.packing = {'expand': 1, 'fill': 'both',
- 'after': self.button}
- self.htext.insert('end', headertext)
- else:
- self.htext = Frame(self.frame,
- {'relief': 'raised', 'bd': 2})
- self.htext.packing = {'side': 'top',
- 'ipady': 2,
- 'fill': 'x',
- 'after': self.button}
- body = msg.getbody()
- if type(body) == StringType:
- self.pad = None
- height = countlines(body, 10)
- if height:
- self.btext = ScrolledText(self.frame,
- {'height': height,
- 'width': 80,
- 'wrap': 'none',
- 'relief': 'raised',
- 'bd': 2})
- self.btext.packing = {'expand': 1,
- 'fill': 'both'}
- self.btext.insert('end', body)
- else:
- self.btext = None
- self.parts = None
- else:
- self.pad = Frame(self.frame,
- {'relief': 'flat', 'bd': 2})
- self.pad.packing = {'side': 'left', 'ipadx': 10,
- 'fill': 'y', 'after': self.htext}
- self.parts = []
- for i in range(len(body)):
- p = MimeViewer(self.frame,
- '%s.%d' % (title, i+1),
- body[i])
- self.parts.append(p)
- self.btext = None
- self.collapsed = 1
- def pack(self):
- self.frame.pack(self.frame.packing)
- def destroy(self):
- self.frame.destroy()
- def show(self):
- if self.collapsed:
- self.button.invoke()
- def toggle(self):
- if self.collapsed:
- self.explode()
- else:
- self.collapse()
- def collapse(self):
- self.collapsed = 1
- for comp in self.htext, self.btext, self.pad:
- if comp:
- comp.forget()
- if self.parts:
- for part in self.parts:
- part.frame.forget()
- self.frame.pack({'expand': 0})
- def explode(self):
- self.collapsed = 0
- for comp in self.htext, self.btext, self.pad:
- if comp: comp.pack(comp.packing)
- if self.parts:
- for part in self.parts:
- part.pack()
- self.frame.pack({'expand': 1})
+ def __init__(self, parent, title, msg):
+ self.title = title
+ self.msg = msg
+ self.frame = Frame(parent, {'relief': 'raised', 'bd': 2})
+ self.frame.packing = {'expand': 0, 'fill': 'both'}
+ self.button = Checkbutton(self.frame,
+ {'text': title,
+ 'command': self.toggle})
+ self.button.pack({'anchor': 'w'})
+ headertext = msg.getheadertext(
+ lambda x: x != 'received' and x[:5] != 'x400-')
+ height = countlines(headertext, 4)
+ if height:
+ self.htext = ScrolledText(self.frame,
+ {'height': height,
+ 'width': 80,
+ 'wrap': 'none',
+ 'relief': 'raised',
+ 'bd': 2})
+ self.htext.packing = {'expand': 1, 'fill': 'both',
+ 'after': self.button}
+ self.htext.insert('end', headertext)
+ else:
+ self.htext = Frame(self.frame,
+ {'relief': 'raised', 'bd': 2})
+ self.htext.packing = {'side': 'top',
+ 'ipady': 2,
+ 'fill': 'x',
+ 'after': self.button}
+ body = msg.getbody()
+ if type(body) == StringType:
+ self.pad = None
+ height = countlines(body, 10)
+ if height:
+ self.btext = ScrolledText(self.frame,
+ {'height': height,
+ 'width': 80,
+ 'wrap': 'none',
+ 'relief': 'raised',
+ 'bd': 2})
+ self.btext.packing = {'expand': 1,
+ 'fill': 'both'}
+ self.btext.insert('end', body)
+ else:
+ self.btext = None
+ self.parts = None
+ else:
+ self.pad = Frame(self.frame,
+ {'relief': 'flat', 'bd': 2})
+ self.pad.packing = {'side': 'left', 'ipadx': 10,
+ 'fill': 'y', 'after': self.htext}
+ self.parts = []
+ for i in range(len(body)):
+ p = MimeViewer(self.frame,
+ '%s.%d' % (title, i+1),
+ body[i])
+ self.parts.append(p)
+ self.btext = None
+ self.collapsed = 1
+ def pack(self):
+ self.frame.pack(self.frame.packing)
+ def destroy(self):
+ self.frame.destroy()
+ def show(self):
+ if self.collapsed:
+ self.button.invoke()
+ def toggle(self):
+ if self.collapsed:
+ self.explode()
+ else:
+ self.collapse()
+ def collapse(self):
+ self.collapsed = 1
+ for comp in self.htext, self.btext, self.pad:
+ if comp:
+ comp.forget()
+ if self.parts:
+ for part in self.parts:
+ part.frame.forget()
+ self.frame.pack({'expand': 0})
+ def explode(self):
+ self.collapsed = 0
+ for comp in self.htext, self.btext, self.pad:
+ if comp: comp.pack(comp.packing)
+ if self.parts:
+ for part in self.parts:
+ part.pack()
+ self.frame.pack({'expand': 1})
def countlines(str, limit):
- i = 0
- n = 0
- while n < limit:
- i = string.find(str, '\n', i)
- if i < 0: break
- n = n+1
- i = i+1
- return n
+ i = 0
+ n = 0
+ while n < limit:
+ i = string.find(str, '\n', i)
+ if i < 0: break
+ n = n+1
+ i = i+1
+ return n
def main():
- import sys
- import getopt
- import mhlib
- opts, args = getopt.getopt(sys.argv[1:], '')
- for o, a in opts:
- pass
- message = None
- folder = 'inbox'
- for arg in args:
- if arg[:1] == '+':
- folder = arg[1:]
- else:
- message = string.atoi(arg)
+ import sys
+ import getopt
+ import mhlib
+ opts, args = getopt.getopt(sys.argv[1:], '')
+ for o, a in opts:
+ pass
+ message = None
+ folder = 'inbox'
+ for arg in args:
+ if arg[:1] == '+':
+ folder = arg[1:]
+ else:
+ message = string.atoi(arg)
- mh = mhlib.MH()
- f = mh.openfolder(folder)
- if not message:
- message = f.getcurrent()
- m = f.openmessage(message)
+ mh = mhlib.MH()
+ f = mh.openfolder(folder)
+ if not message:
+ message = f.getcurrent()
+ m = f.openmessage(message)
- root = Tk()
- tk = root.tk
+ root = Tk()
+ tk = root.tk
- top = MimeViewer(root, '+%s/%d' % (folder, message), m)
- top.pack()
- top.show()
+ top = MimeViewer(root, '+%s/%d' % (folder, message), m)
+ top.pack()
+ top.show()
- root.minsize(1, 1)
+ root.minsize(1, 1)
- tk.mainloop()
+ tk.mainloop()
if __name__ == '__main__': main()
diff --git a/Demo/tkinter/guido/ShellWindow.py b/Demo/tkinter/guido/ShellWindow.py
index 98fe30f..609101b 100755
--- a/Demo/tkinter/guido/ShellWindow.py
+++ b/Demo/tkinter/guido/ShellWindow.py
@@ -10,142 +10,142 @@
class ShellWindow(ScrolledText):
- def __init__(self, master=None, shell=None, **cnf):
- if not shell:
- try:
- shell = os.environ['SHELL']
- except KeyError:
- shell = '/bin/sh'
- shell = shell + ' -i'
- args = string.split(shell)
- shell = args[0]
+ def __init__(self, master=None, shell=None, **cnf):
+ if not shell:
+ try:
+ shell = os.environ['SHELL']
+ except KeyError:
+ shell = '/bin/sh'
+ shell = shell + ' -i'
+ args = string.split(shell)
+ shell = args[0]
- apply(ScrolledText.__init__, (self, master), cnf)
- self.pos = '1.0'
- self.bind('<Return>', self.inputhandler)
- self.bind('<Control-c>', self.sigint)
- self.bind('<Control-t>', self.sigterm)
- self.bind('<Control-k>', self.sigkill)
- self.bind('<Control-d>', self.sendeof)
+ apply(ScrolledText.__init__, (self, master), cnf)
+ self.pos = '1.0'
+ self.bind('<Return>', self.inputhandler)
+ self.bind('<Control-c>', self.sigint)
+ self.bind('<Control-t>', self.sigterm)
+ self.bind('<Control-k>', self.sigkill)
+ self.bind('<Control-d>', self.sendeof)
- self.pid, self.fromchild, self.tochild = spawn(shell, args)
- self.tk.createfilehandler(self.fromchild, READABLE,
- self.outputhandler)
+ self.pid, self.fromchild, self.tochild = spawn(shell, args)
+ self.tk.createfilehandler(self.fromchild, READABLE,
+ self.outputhandler)
- def outputhandler(self, file, mask):
- data = os.read(file, BUFSIZE)
- if not data:
- self.tk.deletefilehandler(file)
- pid, sts = os.waitpid(self.pid, 0)
- print 'pid', pid, 'status', sts
- self.pid = None
- detail = sts>>8
- cause = sts & 0xff
- if cause == 0:
- msg = "exit status %d" % detail
- else:
- msg = "killed by signal %d" % (cause & 0x7f)
- if cause & 0x80:
- msg = msg + " -- core dumped"
- Dialog(self.master,
- text=msg,
- title="Exit status",
- bitmap='warning',
- default=0,
- strings=('OK',))
- return
- self.insert(END, data)
- self.pos = self.index("end - 1 char")
- self.yview_pickplace(END)
+ def outputhandler(self, file, mask):
+ data = os.read(file, BUFSIZE)
+ if not data:
+ self.tk.deletefilehandler(file)
+ pid, sts = os.waitpid(self.pid, 0)
+ print 'pid', pid, 'status', sts
+ self.pid = None
+ detail = sts>>8
+ cause = sts & 0xff
+ if cause == 0:
+ msg = "exit status %d" % detail
+ else:
+ msg = "killed by signal %d" % (cause & 0x7f)
+ if cause & 0x80:
+ msg = msg + " -- core dumped"
+ Dialog(self.master,
+ text=msg,
+ title="Exit status",
+ bitmap='warning',
+ default=0,
+ strings=('OK',))
+ return
+ self.insert(END, data)
+ self.pos = self.index("end - 1 char")
+ self.yview_pickplace(END)
- def inputhandler(self, *args):
- if not self.pid:
- self.no_process()
- return "break"
- self.insert(END, "\n")
- line = self.get(self.pos, "end - 1 char")
- self.pos = self.index(END)
- os.write(self.tochild, line)
- return "break"
+ def inputhandler(self, *args):
+ if not self.pid:
+ self.no_process()
+ return "break"
+ self.insert(END, "\n")
+ line = self.get(self.pos, "end - 1 char")
+ self.pos = self.index(END)
+ os.write(self.tochild, line)
+ return "break"
- def sendeof(self, *args):
- if not self.pid:
- self.no_process()
- return "break"
- os.close(self.tochild)
- return "break"
+ def sendeof(self, *args):
+ if not self.pid:
+ self.no_process()
+ return "break"
+ os.close(self.tochild)
+ return "break"
- def sendsig(self, sig):
- if not self.pid:
- self.no_process()
- return "break"
- os.kill(self.pid, sig)
- return "break"
+ def sendsig(self, sig):
+ if not self.pid:
+ self.no_process()
+ return "break"
+ os.kill(self.pid, sig)
+ return "break"
- def sigint(self, *args):
- return self.sendsig(signal.SIGINT)
+ def sigint(self, *args):
+ return self.sendsig(signal.SIGINT)
- def sigquit(self, *args):
- return self.sendsig(signal.SIGQUIT)
+ def sigquit(self, *args):
+ return self.sendsig(signal.SIGQUIT)
- def sigterm(self, *args):
- return self.sendsig(signal.SIGTERM)
+ def sigterm(self, *args):
+ return self.sendsig(signal.SIGTERM)
- def sigkill(self, *args):
- return self.sendsig(signal.SIGKILL)
+ def sigkill(self, *args):
+ return self.sendsig(signal.SIGKILL)
- def no_process(self):
- Dialog(self.master,
- text="No active process",
- title="No process",
- bitmap='error',
- default=0,
- strings=('OK',))
+ def no_process(self):
+ Dialog(self.master,
+ text="No active process",
+ title="No process",
+ bitmap='error',
+ default=0,
+ strings=('OK',))
-MAXFD = 100 # Max number of file descriptors (os.getdtablesize()???)
+MAXFD = 100 # Max number of file descriptors (os.getdtablesize()???)
def spawn(prog, args):
- p2cread, p2cwrite = os.pipe()
- c2pread, c2pwrite = os.pipe()
- pid = os.fork()
- if pid == 0:
- # Child
- for i in 0, 1, 2:
- try:
- os.close(i)
- except os.error:
- pass
- if os.dup(p2cread) <> 0:
- sys.stderr.write('popen2: bad read dup\n')
- if os.dup(c2pwrite) <> 1:
- sys.stderr.write('popen2: bad write dup\n')
- if os.dup(c2pwrite) <> 2:
- sys.stderr.write('popen2: bad write dup\n')
- for i in range(3, MAXFD):
- try:
- os.close(i)
- except:
- pass
- try:
- os.execvp(prog, args)
- finally:
- sys.stderr.write('execvp failed\n')
- os._exit(1)
- os.close(p2cread)
- os.close(c2pwrite)
- return pid, c2pread, p2cwrite
+ p2cread, p2cwrite = os.pipe()
+ c2pread, c2pwrite = os.pipe()
+ pid = os.fork()
+ if pid == 0:
+ # Child
+ for i in 0, 1, 2:
+ try:
+ os.close(i)
+ except os.error:
+ pass
+ if os.dup(p2cread) <> 0:
+ sys.stderr.write('popen2: bad read dup\n')
+ if os.dup(c2pwrite) <> 1:
+ sys.stderr.write('popen2: bad write dup\n')
+ if os.dup(c2pwrite) <> 2:
+ sys.stderr.write('popen2: bad write dup\n')
+ for i in range(3, MAXFD):
+ try:
+ os.close(i)
+ except:
+ pass
+ try:
+ os.execvp(prog, args)
+ finally:
+ sys.stderr.write('execvp failed\n')
+ os._exit(1)
+ os.close(p2cread)
+ os.close(c2pwrite)
+ return pid, c2pread, p2cwrite
def test():
- shell = string.join(sys.argv[1:])
- root = Tk()
- root.minsize(1, 1)
- if shell:
- w = ShellWindow(root, shell=shell)
- else:
- w = ShellWindow(root)
- w.pack(expand=1, fill=BOTH)
- w.focus_set()
- w.tk.mainloop()
+ shell = string.join(sys.argv[1:])
+ root = Tk()
+ root.minsize(1, 1)
+ if shell:
+ w = ShellWindow(root, shell=shell)
+ else:
+ w = ShellWindow(root)
+ w.pack(expand=1, fill=BOTH)
+ w.focus_set()
+ w.tk.mainloop()
if __name__ == '__main__':
- test()
+ test()
diff --git a/Demo/tkinter/guido/canvasevents.py b/Demo/tkinter/guido/canvasevents.py
index 60f4096..74ed76f 100644
--- a/Demo/tkinter/guido/canvasevents.py
+++ b/Demo/tkinter/guido/canvasevents.py
@@ -9,7 +9,7 @@
class Group(Group):
def bind(self, sequence=None, command=None):
- return self.canvas.tag_bind(self.id, sequence, command)
+ return self.canvas.tag_bind(self.id, sequence, command)
class Object:
@@ -33,45 +33,45 @@
"""
def __init__(self, canvas, x=0, y=0, fill='red', text='object'):
- self.canvas = canvas
- self.x = x
- self.y = y
- self.pile = None
- self.group = Group(self.canvas)
- self.createitems(fill, text)
+ self.canvas = canvas
+ self.x = x
+ self.y = y
+ self.pile = None
+ self.group = Group(self.canvas)
+ self.createitems(fill, text)
def __str__(self):
- return str(self.group)
+ return str(self.group)
def createitems(self, fill, text):
- self.__oval = Oval(self.canvas,
- self.x-20, self.y-10, self.x+20, self.y+10,
- fill=fill, width=3)
- self.group.addtag_withtag(self.__oval)
- self.__text = CanvasText(self.canvas,
- self.x, self.y, text=text)
- self.group.addtag_withtag(self.__text)
+ self.__oval = Oval(self.canvas,
+ self.x-20, self.y-10, self.x+20, self.y+10,
+ fill=fill, width=3)
+ self.group.addtag_withtag(self.__oval)
+ self.__text = CanvasText(self.canvas,
+ self.x, self.y, text=text)
+ self.group.addtag_withtag(self.__text)
def moveby(self, dx, dy):
- if dx == dy == 0:
- return
- self.group.move(dx, dy)
- self.x = self.x + dx
- self.y = self.y + dy
+ if dx == dy == 0:
+ return
+ self.group.move(dx, dy)
+ self.x = self.x + dx
+ self.y = self.y + dy
def moveto(self, x, y):
- self.moveby(x - self.x, y - self.y)
+ self.moveby(x - self.x, y - self.y)
def transfer(self, pile):
- if self.pile:
- self.pile.delete(self)
- self.pile = None
- self.pile = pile
- if self.pile:
- self.pile.add(self)
+ if self.pile:
+ self.pile.delete(self)
+ self.pile = None
+ self.pile = pile
+ if self.pile:
+ self.pile.add(self)
def tkraise(self):
- self.group.tkraise()
+ self.group.tkraise()
class Bottom(Object):
@@ -79,10 +79,10 @@
"""An object to serve as the bottom of a pile."""
def createitems(self, *args):
- self.__oval = Oval(self.canvas,
- self.x-20, self.y-10, self.x+20, self.y+10,
- fill='gray', outline='')
- self.group.addtag_withtag(self.__oval)
+ self.__oval = Oval(self.canvas,
+ self.x-20, self.y-10, self.x+20, self.y+10,
+ fill='gray', outline='')
+ self.group.addtag_withtag(self.__oval)
class Pile:
@@ -90,86 +90,86 @@
"""A group of graphical objects."""
def __init__(self, canvas, x, y, tag=None):
- self.canvas = canvas
- self.x = x
- self.y = y
- self.objects = []
- self.bottom = Bottom(self.canvas, self.x, self.y)
- self.group = Group(self.canvas, tag=tag)
- self.group.addtag_withtag(self.bottom.group)
- self.bindhandlers()
+ self.canvas = canvas
+ self.x = x
+ self.y = y
+ self.objects = []
+ self.bottom = Bottom(self.canvas, self.x, self.y)
+ self.group = Group(self.canvas, tag=tag)
+ self.group.addtag_withtag(self.bottom.group)
+ self.bindhandlers()
def bindhandlers(self):
- self.group.bind('<1>', self.clickhandler)
- self.group.bind('<Double-1>', self.doubleclickhandler)
+ self.group.bind('<1>', self.clickhandler)
+ self.group.bind('<Double-1>', self.doubleclickhandler)
def add(self, object):
- self.objects.append(object)
- self.group.addtag_withtag(object.group)
- self.position(object)
+ self.objects.append(object)
+ self.group.addtag_withtag(object.group)
+ self.position(object)
def delete(self, object):
- object.group.dtag(self.group)
- self.objects.remove(object)
+ object.group.dtag(self.group)
+ self.objects.remove(object)
def position(self, object):
- object.tkraise()
- i = self.objects.index(object)
- object.moveto(self.x + i*4, self.y + i*8)
+ object.tkraise()
+ i = self.objects.index(object)
+ object.moveto(self.x + i*4, self.y + i*8)
def clickhandler(self, event):
- pass
+ pass
def doubleclickhandler(self, event):
- pass
+ pass
class MovingPile(Pile):
def bindhandlers(self):
- Pile.bindhandlers(self)
- self.group.bind('<B1-Motion>', self.motionhandler)
- self.group.bind('<ButtonRelease-1>', self.releasehandler)
+ Pile.bindhandlers(self)
+ self.group.bind('<B1-Motion>', self.motionhandler)
+ self.group.bind('<ButtonRelease-1>', self.releasehandler)
movethis = None
def clickhandler(self, event):
- tags = self.canvas.gettags('current')
- for i in range(len(self.objects)):
- o = self.objects[i]
- if o.group.tag in tags:
- break
- else:
- self.movethis = None
- return
- self.movethis = self.objects[i:]
- for o in self.movethis:
- o.tkraise()
- self.lastx = event.x
- self.lasty = event.y
+ tags = self.canvas.gettags('current')
+ for i in range(len(self.objects)):
+ o = self.objects[i]
+ if o.group.tag in tags:
+ break
+ else:
+ self.movethis = None
+ return
+ self.movethis = self.objects[i:]
+ for o in self.movethis:
+ o.tkraise()
+ self.lastx = event.x
+ self.lasty = event.y
doubleclickhandler = clickhandler
def motionhandler(self, event):
- if not self.movethis:
- return
- dx = event.x - self.lastx
- dy = event.y - self.lasty
- self.lastx = event.x
- self.lasty = event.y
- for o in self.movethis:
- o.moveby(dx, dy)
+ if not self.movethis:
+ return
+ dx = event.x - self.lastx
+ dy = event.y - self.lasty
+ self.lastx = event.x
+ self.lasty = event.y
+ for o in self.movethis:
+ o.moveby(dx, dy)
def releasehandler(self, event):
- objects = self.movethis
- if not objects:
- return
- self.movethis = None
- self.finishmove(objects)
+ objects = self.movethis
+ if not objects:
+ return
+ self.movethis = None
+ self.finishmove(objects)
def finishmove(self, objects):
- for o in objects:
- self.position(o)
+ for o in objects:
+ self.position(o)
class Pile1(MovingPile):
@@ -179,29 +179,29 @@
tag = 'p1'
def __init__(self, demo):
- self.demo = demo
- MovingPile.__init__(self, self.demo.canvas, self.x, self.y, self.tag)
+ self.demo = demo
+ MovingPile.__init__(self, self.demo.canvas, self.x, self.y, self.tag)
def doubleclickhandler(self, event):
- try:
- o = self.objects[-1]
- except IndexError:
- return
- o.transfer(self.other())
- MovingPile.doubleclickhandler(self, event)
+ try:
+ o = self.objects[-1]
+ except IndexError:
+ return
+ o.transfer(self.other())
+ MovingPile.doubleclickhandler(self, event)
def other(self):
- return self.demo.p2
+ return self.demo.p2
def finishmove(self, objects):
- o = objects[0]
- p = self.other()
- x, y = o.x, o.y
- if (x-p.x)**2 + (y-p.y)**2 < (x-self.x)**2 + (y-self.y)**2:
- for o in objects:
- o.transfer(p)
- else:
- MovingPile.finishmove(self, objects)
+ o = objects[0]
+ p = self.other()
+ x, y = o.x, o.y
+ if (x-p.x)**2 + (y-p.y)**2 < (x-self.x)**2 + (y-self.y)**2:
+ for o in objects:
+ o.transfer(p)
+ else:
+ MovingPile.finishmove(self, objects)
class Pile2(Pile1):
@@ -210,26 +210,26 @@
tag = 'p2'
def other(self):
- return self.demo.p1
+ return self.demo.p1
class Demo:
def __init__(self, master):
- self.master = master
- self.canvas = Canvas(master,
- width=200, height=200,
- background='yellow',
- relief=SUNKEN, borderwidth=2)
- self.canvas.pack(expand=1, fill=BOTH)
- self.p1 = Pile1(self)
- self.p2 = Pile2(self)
- o1 = Object(self.canvas, fill='red', text='o1')
- o2 = Object(self.canvas, fill='green', text='o2')
- o3 = Object(self.canvas, fill='light blue', text='o3')
- o1.transfer(self.p1)
- o2.transfer(self.p1)
- o3.transfer(self.p2)
+ self.master = master
+ self.canvas = Canvas(master,
+ width=200, height=200,
+ background='yellow',
+ relief=SUNKEN, borderwidth=2)
+ self.canvas.pack(expand=1, fill=BOTH)
+ self.p1 = Pile1(self)
+ self.p2 = Pile2(self)
+ o1 = Object(self.canvas, fill='red', text='o1')
+ o2 = Object(self.canvas, fill='green', text='o2')
+ o3 = Object(self.canvas, fill='light blue', text='o3')
+ o1.transfer(self.p1)
+ o2.transfer(self.p1)
+ o3.transfer(self.p2)
# Main function, run when invoked as a stand-alone Python program.
diff --git a/Demo/tkinter/guido/dialog.py b/Demo/tkinter/guido/dialog.py
index 1f794ae..50d84b9 100755
--- a/Demo/tkinter/guido/dialog.py
+++ b/Demo/tkinter/guido/dialog.py
@@ -25,11 +25,11 @@
# 2. Fill the top part with the bitmap and message.
msg = Message(top, width='3i', text=text,
- font='-Adobe-Times-Medium-R-Normal-*-180-*')
+ font='-Adobe-Times-Medium-R-Normal-*-180-*')
msg.pack(side=RIGHT, expand=1, fill=BOTH, padx='3m', pady='3m')
if bitmap:
- bm = Label(top, bitmap=bitmap)
- bm.pack(side=LEFT, padx='3m', pady='3m')
+ bm = Label(top, bitmap=bitmap)
+ bm.pack(side=LEFT, padx='3m', pady='3m')
# 3. Create a row of buttons at the bottom of the dialog.
@@ -37,27 +37,27 @@
buttons = []
i = 0
for but in args:
- b = Button(bot, text=but, command=lambda v=var,i=i: v.set(i))
- buttons.append(b)
- if i == default:
- bd = Frame(bot, relief=SUNKEN, borderwidth=1)
- bd.pack(side=LEFT, expand=1, padx='3m', pady='2m')
- b.lift()
- b.pack (in_=bd, side=LEFT,
- padx='2m', pady='2m', ipadx='2m', ipady='1m')
- else:
- b.pack (side=LEFT, expand=1,
- padx='3m', pady='3m', ipadx='2m', ipady='1m')
- i = i+1
+ b = Button(bot, text=but, command=lambda v=var,i=i: v.set(i))
+ buttons.append(b)
+ if i == default:
+ bd = Frame(bot, relief=SUNKEN, borderwidth=1)
+ bd.pack(side=LEFT, expand=1, padx='3m', pady='2m')
+ b.lift()
+ b.pack (in_=bd, side=LEFT,
+ padx='2m', pady='2m', ipadx='2m', ipady='1m')
+ else:
+ b.pack (side=LEFT, expand=1,
+ padx='3m', pady='3m', ipadx='2m', ipady='1m')
+ i = i+1
# 4. Set up a binding for <Return>, if there's a default,
# set a grab, and claim the focus too.
if default >= 0:
- w.bind('<Return>',
- lambda e, b=buttons[default], v=var, i=default:
- (b.flash(),
- v.set(i)))
+ w.bind('<Return>',
+ lambda e, b=buttons[default], v=var, i=default:
+ (b.flash(),
+ v.set(i)))
oldFocus = w.focus_get()
w.grab_set()
@@ -75,23 +75,23 @@
def go():
i = dialog(mainWidget,
- 'Not Responding',
- "The file server isn't responding right now; "
- "I'll keep trying.",
- '',
- -1,
- 'OK')
+ 'Not Responding',
+ "The file server isn't responding right now; "
+ "I'll keep trying.",
+ '',
+ -1,
+ 'OK')
print 'pressed button', i
i = dialog(mainWidget,
- 'File Modified',
- 'File "tcl.h" has been modified since '
- 'the last time it was saved. '
- 'Do you want to save it before exiting the application?',
- 'warning',
- 0,
- 'Save File',
- 'Discard Changes',
- 'Return To Editor')
+ 'File Modified',
+ 'File "tcl.h" has been modified since '
+ 'the last time it was saved. '
+ 'Do you want to save it before exiting the application?',
+ 'warning',
+ 0,
+ 'Save File',
+ 'Discard Changes',
+ 'Return To Editor')
print 'pressed button', i
def test():
diff --git a/Demo/tkinter/guido/electrons.py b/Demo/tkinter/guido/electrons.py
index 97dad2d7..fdc558f 100755
--- a/Demo/tkinter/guido/electrons.py
+++ b/Demo/tkinter/guido/electrons.py
@@ -1,6 +1,6 @@
#! /usr/bin/env python
-# Simulate "electrons" migrating across the screen.
+# Simulate "electrons" migrating across the screen.
# An optional bitmap file in can be in the background.
#
# Usage: electrons [n [bitmapfile]]
@@ -18,74 +18,74 @@
# The graphical interface
class Electrons:
- # Create our objects
- def __init__(self, n, bitmap = None):
- self.n = n
- self.tk = tk = Tk()
- self.canvas = c = Canvas(tk)
- c.pack()
- width, height = tk.getint(c['width']), tk.getint(c['height'])
+ # Create our objects
+ def __init__(self, n, bitmap = None):
+ self.n = n
+ self.tk = tk = Tk()
+ self.canvas = c = Canvas(tk)
+ c.pack()
+ width, height = tk.getint(c['width']), tk.getint(c['height'])
- # Add background bitmap
- if bitmap:
- self.bitmap = c.create_bitmap(width/2, height/2,
- bitmap=bitmap,
- foreground='blue')
+ # Add background bitmap
+ if bitmap:
+ self.bitmap = c.create_bitmap(width/2, height/2,
+ bitmap=bitmap,
+ foreground='blue')
- self.pieces = []
- x1, y1, x2, y2 = 10,70,14,74
- for i in range(n):
- p = c.create_oval(x1, y1, x2, y2, fill='red')
- self.pieces.append(p)
- y1, y2 = y1 +2, y2 + 2
- self.tk.update()
+ self.pieces = []
+ x1, y1, x2, y2 = 10,70,14,74
+ for i in range(n):
+ p = c.create_oval(x1, y1, x2, y2, fill='red')
+ self.pieces.append(p)
+ y1, y2 = y1 +2, y2 + 2
+ self.tk.update()
- def random_move(self, n):
- c = self.canvas
- for p in self.pieces:
- x = random.choice(range(-2,4))
- y = random.choice(range(-3,4))
- c.move(p, x, y)
- self.tk.update()
+ def random_move(self, n):
+ c = self.canvas
+ for p in self.pieces:
+ x = random.choice(range(-2,4))
+ y = random.choice(range(-3,4))
+ c.move(p, x, y)
+ self.tk.update()
- # Run -- allow 500 movemens
- def run(self):
- try:
- for i in range(500):
- self.random_move(self.n)
- except TclError:
- try:
- self.tk.destroy()
- except TclError:
- pass
+ # Run -- allow 500 movemens
+ def run(self):
+ try:
+ for i in range(500):
+ self.random_move(self.n)
+ except TclError:
+ try:
+ self.tk.destroy()
+ except TclError:
+ pass
# Main program
def main():
- import sys, string
+ import sys, string
- # First argument is number of electrons, default 30
- if sys.argv[1:]:
- n = string.atoi(sys.argv[1])
- else:
- n = 30
+ # First argument is number of electrons, default 30
+ if sys.argv[1:]:
+ n = string.atoi(sys.argv[1])
+ else:
+ n = 30
- # Second argument is bitmap file, default none
- if sys.argv[2:]:
- bitmap = sys.argv[2]
- # Reverse meaning of leading '@' compared to Tk
- if bitmap[0] == '@': bitmap = bitmap[1:]
- else: bitmap = '@' + bitmap
- else:
- bitmap = None
+ # Second argument is bitmap file, default none
+ if sys.argv[2:]:
+ bitmap = sys.argv[2]
+ # Reverse meaning of leading '@' compared to Tk
+ if bitmap[0] == '@': bitmap = bitmap[1:]
+ else: bitmap = '@' + bitmap
+ else:
+ bitmap = None
- # Create the graphical objects...
- h = Electrons(n, bitmap)
+ # Create the graphical objects...
+ h = Electrons(n, bitmap)
- # ...and run!
- h.run()
+ # ...and run!
+ h.run()
# Call main when run as script
if __name__ == '__main__':
- main()
+ main()
diff --git a/Demo/tkinter/guido/hanoi.py b/Demo/tkinter/guido/hanoi.py
index 9e566c4..078c246 100755
--- a/Demo/tkinter/guido/hanoi.py
+++ b/Demo/tkinter/guido/hanoi.py
@@ -16,139 +16,139 @@
# Basic Towers-of-Hanoi algorithm: move n pieces from a to b, using c
# as temporary. For each move, call report()
def hanoi(n, a, b, c, report):
- if n <= 0: return
- hanoi(n-1, a, c, b, report)
- report(n, a, b)
- hanoi(n-1, c, b, a, report)
+ if n <= 0: return
+ hanoi(n-1, a, c, b, report)
+ report(n, a, b)
+ hanoi(n-1, c, b, a, report)
# The graphical interface
class Tkhanoi:
- # Create our objects
- def __init__(self, n, bitmap = None):
- self.n = n
- self.tk = tk = Tk()
- self.canvas = c = Canvas(tk)
- c.pack()
- width, height = tk.getint(c['width']), tk.getint(c['height'])
+ # Create our objects
+ def __init__(self, n, bitmap = None):
+ self.n = n
+ self.tk = tk = Tk()
+ self.canvas = c = Canvas(tk)
+ c.pack()
+ width, height = tk.getint(c['width']), tk.getint(c['height'])
- # Add background bitmap
- if bitmap:
- self.bitmap = c.create_bitmap(width/2, height/2,
- bitmap=bitmap,
- foreground='blue')
+ # Add background bitmap
+ if bitmap:
+ self.bitmap = c.create_bitmap(width/2, height/2,
+ bitmap=bitmap,
+ foreground='blue')
- # Generate pegs
- pegwidth = 10
- pegheight = height/2
- pegdist = width/3
- x1, y1 = (pegdist-pegwidth)/2, height*1/3
- x2, y2 = x1+pegwidth, y1+pegheight
- self.pegs = []
- p = c.create_rectangle(x1, y1, x2, y2, fill='black')
- self.pegs.append(p)
- x1, x2 = x1+pegdist, x2+pegdist
- p = c.create_rectangle(x1, y1, x2, y2, fill='black')
- self.pegs.append(p)
- x1, x2 = x1+pegdist, x2+pegdist
- p = c.create_rectangle(x1, y1, x2, y2, fill='black')
- self.pegs.append(p)
- self.tk.update()
+ # Generate pegs
+ pegwidth = 10
+ pegheight = height/2
+ pegdist = width/3
+ x1, y1 = (pegdist-pegwidth)/2, height*1/3
+ x2, y2 = x1+pegwidth, y1+pegheight
+ self.pegs = []
+ p = c.create_rectangle(x1, y1, x2, y2, fill='black')
+ self.pegs.append(p)
+ x1, x2 = x1+pegdist, x2+pegdist
+ p = c.create_rectangle(x1, y1, x2, y2, fill='black')
+ self.pegs.append(p)
+ x1, x2 = x1+pegdist, x2+pegdist
+ p = c.create_rectangle(x1, y1, x2, y2, fill='black')
+ self.pegs.append(p)
+ self.tk.update()
- # Generate pieces
- pieceheight = pegheight/16
- maxpiecewidth = pegdist*2/3
- minpiecewidth = 2*pegwidth
- self.pegstate = [[], [], []]
- self.pieces = {}
- x1, y1 = (pegdist-maxpiecewidth)/2, y2-pieceheight-2
- x2, y2 = x1+maxpiecewidth, y1+pieceheight
- dx = (maxpiecewidth-minpiecewidth) / (2*max(1, n-1))
- for i in range(n, 0, -1):
- p = c.create_rectangle(x1, y1, x2, y2, fill='red')
- self.pieces[i] = p
- self.pegstate[0].append(i)
- x1, x2 = x1 + dx, x2-dx
- y1, y2 = y1 - pieceheight-2, y2-pieceheight-2
- self.tk.update()
- self.tk.after(25)
+ # Generate pieces
+ pieceheight = pegheight/16
+ maxpiecewidth = pegdist*2/3
+ minpiecewidth = 2*pegwidth
+ self.pegstate = [[], [], []]
+ self.pieces = {}
+ x1, y1 = (pegdist-maxpiecewidth)/2, y2-pieceheight-2
+ x2, y2 = x1+maxpiecewidth, y1+pieceheight
+ dx = (maxpiecewidth-minpiecewidth) / (2*max(1, n-1))
+ for i in range(n, 0, -1):
+ p = c.create_rectangle(x1, y1, x2, y2, fill='red')
+ self.pieces[i] = p
+ self.pegstate[0].append(i)
+ x1, x2 = x1 + dx, x2-dx
+ y1, y2 = y1 - pieceheight-2, y2-pieceheight-2
+ self.tk.update()
+ self.tk.after(25)
- # Run -- never returns
- def run(self):
- while 1:
- hanoi(self.n, 0, 1, 2, self.report)
- hanoi(self.n, 1, 2, 0, self.report)
- hanoi(self.n, 2, 0, 1, self.report)
- hanoi(self.n, 0, 2, 1, self.report)
- hanoi(self.n, 2, 1, 0, self.report)
- hanoi(self.n, 1, 0, 2, self.report)
+ # Run -- never returns
+ def run(self):
+ while 1:
+ hanoi(self.n, 0, 1, 2, self.report)
+ hanoi(self.n, 1, 2, 0, self.report)
+ hanoi(self.n, 2, 0, 1, self.report)
+ hanoi(self.n, 0, 2, 1, self.report)
+ hanoi(self.n, 2, 1, 0, self.report)
+ hanoi(self.n, 1, 0, 2, self.report)
- # Reporting callback for the actual hanoi function
- def report(self, i, a, b):
- if self.pegstate[a][-1] != i: raise RuntimeError # Assertion
- del self.pegstate[a][-1]
- p = self.pieces[i]
- c = self.canvas
+ # Reporting callback for the actual hanoi function
+ def report(self, i, a, b):
+ if self.pegstate[a][-1] != i: raise RuntimeError # Assertion
+ del self.pegstate[a][-1]
+ p = self.pieces[i]
+ c = self.canvas
- # Lift the piece above peg a
- ax1, ay1, ax2, ay2 = c.bbox(self.pegs[a])
- while 1:
- x1, y1, x2, y2 = c.bbox(p)
- if y2 < ay1: break
- c.move(p, 0, -1)
- self.tk.update()
+ # Lift the piece above peg a
+ ax1, ay1, ax2, ay2 = c.bbox(self.pegs[a])
+ while 1:
+ x1, y1, x2, y2 = c.bbox(p)
+ if y2 < ay1: break
+ c.move(p, 0, -1)
+ self.tk.update()
- # Move it towards peg b
- bx1, by1, bx2, by2 = c.bbox(self.pegs[b])
- newcenter = (bx1+bx2)/2
- while 1:
- x1, y1, x2, y2 = c.bbox(p)
- center = (x1+x2)/2
- if center == newcenter: break
- if center > newcenter: c.move(p, -1, 0)
- else: c.move(p, 1, 0)
- self.tk.update()
+ # Move it towards peg b
+ bx1, by1, bx2, by2 = c.bbox(self.pegs[b])
+ newcenter = (bx1+bx2)/2
+ while 1:
+ x1, y1, x2, y2 = c.bbox(p)
+ center = (x1+x2)/2
+ if center == newcenter: break
+ if center > newcenter: c.move(p, -1, 0)
+ else: c.move(p, 1, 0)
+ self.tk.update()
- # Move it down on top of the previous piece
- pieceheight = y2-y1
- newbottom = by2 - pieceheight*len(self.pegstate[b]) - 2
- while 1:
- x1, y1, x2, y2 = c.bbox(p)
- if y2 >= newbottom: break
- c.move(p, 0, 1)
- self.tk.update()
+ # Move it down on top of the previous piece
+ pieceheight = y2-y1
+ newbottom = by2 - pieceheight*len(self.pegstate[b]) - 2
+ while 1:
+ x1, y1, x2, y2 = c.bbox(p)
+ if y2 >= newbottom: break
+ c.move(p, 0, 1)
+ self.tk.update()
- # Update peg state
- self.pegstate[b].append(i)
+ # Update peg state
+ self.pegstate[b].append(i)
# Main program
def main():
- import sys, string
+ import sys, string
- # First argument is number of pegs, default 4
- if sys.argv[1:]:
- n = string.atoi(sys.argv[1])
- else:
- n = 4
+ # First argument is number of pegs, default 4
+ if sys.argv[1:]:
+ n = string.atoi(sys.argv[1])
+ else:
+ n = 4
- # Second argument is bitmap file, default none
- if sys.argv[2:]:
- bitmap = sys.argv[2]
- # Reverse meaning of leading '@' compared to Tk
- if bitmap[0] == '@': bitmap = bitmap[1:]
- else: bitmap = '@' + bitmap
- else:
- bitmap = None
+ # Second argument is bitmap file, default none
+ if sys.argv[2:]:
+ bitmap = sys.argv[2]
+ # Reverse meaning of leading '@' compared to Tk
+ if bitmap[0] == '@': bitmap = bitmap[1:]
+ else: bitmap = '@' + bitmap
+ else:
+ bitmap = None
- # Create the graphical objects...
- h = Tkhanoi(n, bitmap)
+ # Create the graphical objects...
+ h = Tkhanoi(n, bitmap)
- # ...and run!
- h.run()
+ # ...and run!
+ h.run()
# Call main when run as script
if __name__ == '__main__':
- main()
+ main()
diff --git a/Demo/tkinter/guido/hello.py b/Demo/tkinter/guido/hello.py
index 237204f..358a7ec 100755
--- a/Demo/tkinter/guido/hello.py
+++ b/Demo/tkinter/guido/hello.py
@@ -4,14 +4,14 @@
from Tkinter import *
def main():
- root = Tk()
- button = Button(root)
- button['text'] = 'Hello, world'
- button['command'] = quit_callback # See below
- button.pack()
- root.mainloop()
+ root = Tk()
+ button = Button(root)
+ button['text'] = 'Hello, world'
+ button['command'] = quit_callback # See below
+ button.pack()
+ root.mainloop()
def quit_callback():
- sys.exit(0)
+ sys.exit(0)
main()
diff --git a/Demo/tkinter/guido/kill.py b/Demo/tkinter/guido/kill.py
index 577af8b..e7df261 100755
--- a/Demo/tkinter/guido/kill.py
+++ b/Demo/tkinter/guido/kill.py
@@ -8,92 +8,91 @@
import os
class BarButton(Menubutton):
- def __init__(self, master=None, **cnf):
- apply(Menubutton.__init__, (self, master), cnf)
- self.pack(side=LEFT)
- self.menu = Menu(self, name='menu')
- self['menu'] = self.menu
+ def __init__(self, master=None, **cnf):
+ apply(Menubutton.__init__, (self, master), cnf)
+ self.pack(side=LEFT)
+ self.menu = Menu(self, name='menu')
+ self['menu'] = self.menu
class Kill(Frame):
- # List of (name, option, pid_column)
- format_list = [('Default', '', 0),
- ('Long', '-l', 2),
- ('User', '-u', 1),
- ('Jobs', '-j', 1),
- ('Signal', '-s', 1),
- ('Memory', '-m', 0),
- ('VM', '-v', 0),
- ('Hex', '-X', 0)]
- def kill(self, selected):
- c = self.format_list[self.format.get()][2]
- pid = split(selected)[c]
- os.system('kill -9 ' + pid)
- self.do_update()
- def do_update(self):
- name, option, column = self.format_list[self.format.get()]
- s = commands.getoutput('ps -w ' + option)
- list = splitfields(s, '\n')
- self.header.set(list[0])
- del list[0]
- y = self.frame.vscroll.get()[0]
- self.frame.list.delete(0, AtEnd())
- for line in list:
- self.frame.list.insert(0, line)
- self.frame.list.yview(int(y))
- def do_motion(self, e):
- e.widget.select_clear(0, END)
- e.widget.select_set(e.widget.nearest(e.y))
- def do_leave(self, e):
- e.widget.select_clear(0, END)
- def do_1(self, e):
- self.kill(e.widget.get(e.widget.nearest(e.y)))
- def __init__(self, master=None, **cnf):
- Frame.__init__(self, master, cnf)
- self.pack(expand=1, fill=BOTH)
- self.bar = Frame(self, name='bar', relief=RAISED,
- borderwidth=2)
- self.bar.pack(fill=X)
- self.bar.file = BarButton(self.bar, text='File')
- self.bar.file.menu.add_command(
- label='Quit', command=self.quit)
- self.bar.view = BarButton(self.bar, text='View')
- self.format = IntVar(self)
- self.format.set(2)
- for num in range(len(self.format_list)):
- self.bar.view.menu.add_radiobutton(
- label=self.format_list[num][0],
- command=self.do_update,
- variable=self.format,
- value=num)
- #self.bar.view.menu.add_separator()
- #XXX ...
- self.bar.tk_menuBar(self.bar.file, self.bar.view)
- self.frame = Frame(self, relief=RAISED, borderwidth=2)
- self.frame.pack(expand=1, fill=BOTH)
- self.header = StringVar(self)
- self.frame.label = Label(self.frame, relief=FLAT, anchor=NW,
- borderwidth=0,
- textvariable=self.header)
- self.frame.label.pack(fill=X)
- self.frame.vscroll = Scrollbar(self.frame, orient=VERTICAL)
- self.frame.list = Listbox(self.frame, relief=SUNKEN,
- selectbackground='#eed5b7',
- selectborderwidth=0,
- yscroll=self.frame.vscroll.set)
- self.frame.vscroll['command'] = self.frame.list.yview
- self.frame.vscroll.pack(side=RIGHT, fill=Y)
- self.frame.list.pack(expand=1, fill=BOTH)
- self.update = Button(self, text="Update",
- command=self.do_update)
- self.update.pack(expand=1, fill=X)
- self.frame.list.bind('<Motion>', self.do_motion)
- self.frame.list.bind('<Leave>', self.do_leave)
- self.frame.list.bind('<1>', self.do_1)
- self.do_update()
+ # List of (name, option, pid_column)
+ format_list = [('Default', '', 0),
+ ('Long', '-l', 2),
+ ('User', '-u', 1),
+ ('Jobs', '-j', 1),
+ ('Signal', '-s', 1),
+ ('Memory', '-m', 0),
+ ('VM', '-v', 0),
+ ('Hex', '-X', 0)]
+ def kill(self, selected):
+ c = self.format_list[self.format.get()][2]
+ pid = split(selected)[c]
+ os.system('kill -9 ' + pid)
+ self.do_update()
+ def do_update(self):
+ name, option, column = self.format_list[self.format.get()]
+ s = commands.getoutput('ps -w ' + option)
+ list = splitfields(s, '\n')
+ self.header.set(list[0])
+ del list[0]
+ y = self.frame.vscroll.get()[0]
+ self.frame.list.delete(0, AtEnd())
+ for line in list:
+ self.frame.list.insert(0, line)
+ self.frame.list.yview(int(y))
+ def do_motion(self, e):
+ e.widget.select_clear(0, END)
+ e.widget.select_set(e.widget.nearest(e.y))
+ def do_leave(self, e):
+ e.widget.select_clear(0, END)
+ def do_1(self, e):
+ self.kill(e.widget.get(e.widget.nearest(e.y)))
+ def __init__(self, master=None, **cnf):
+ Frame.__init__(self, master, cnf)
+ self.pack(expand=1, fill=BOTH)
+ self.bar = Frame(self, name='bar', relief=RAISED,
+ borderwidth=2)
+ self.bar.pack(fill=X)
+ self.bar.file = BarButton(self.bar, text='File')
+ self.bar.file.menu.add_command(
+ label='Quit', command=self.quit)
+ self.bar.view = BarButton(self.bar, text='View')
+ self.format = IntVar(self)
+ self.format.set(2)
+ for num in range(len(self.format_list)):
+ self.bar.view.menu.add_radiobutton(
+ label=self.format_list[num][0],
+ command=self.do_update,
+ variable=self.format,
+ value=num)
+ #self.bar.view.menu.add_separator()
+ #XXX ...
+ self.bar.tk_menuBar(self.bar.file, self.bar.view)
+ self.frame = Frame(self, relief=RAISED, borderwidth=2)
+ self.frame.pack(expand=1, fill=BOTH)
+ self.header = StringVar(self)
+ self.frame.label = Label(self.frame, relief=FLAT, anchor=NW,
+ borderwidth=0,
+ textvariable=self.header)
+ self.frame.label.pack(fill=X)
+ self.frame.vscroll = Scrollbar(self.frame, orient=VERTICAL)
+ self.frame.list = Listbox(self.frame, relief=SUNKEN,
+ selectbackground='#eed5b7',
+ selectborderwidth=0,
+ yscroll=self.frame.vscroll.set)
+ self.frame.vscroll['command'] = self.frame.list.yview
+ self.frame.vscroll.pack(side=RIGHT, fill=Y)
+ self.frame.list.pack(expand=1, fill=BOTH)
+ self.update = Button(self, text="Update",
+ command=self.do_update)
+ self.update.pack(expand=1, fill=X)
+ self.frame.list.bind('<Motion>', self.do_motion)
+ self.frame.list.bind('<Leave>', self.do_leave)
+ self.frame.list.bind('<1>', self.do_1)
+ self.do_update()
if __name__ == '__main__':
- kill = Kill(None, borderwidth=5)
- kill.winfo_toplevel().title('Tkinter Process Killer')
- kill.winfo_toplevel().minsize(1, 1)
- kill.mainloop()
-
+ kill = Kill(None, borderwidth=5)
+ kill.winfo_toplevel().title('Tkinter Process Killer')
+ kill.winfo_toplevel().minsize(1, 1)
+ kill.mainloop()
diff --git a/Demo/tkinter/guido/listtree.py b/Demo/tkinter/guido/listtree.py
index 523f209..d28ce49 100755
--- a/Demo/tkinter/guido/listtree.py
+++ b/Demo/tkinter/guido/listtree.py
@@ -6,32 +6,32 @@
from Tkinter import *
def listtree(master, app):
- list = Listbox(master, name='list')
- list.pack(expand=1, fill=BOTH)
- listnodes(list, app, '.', 0)
- return list
+ list = Listbox(master, name='list')
+ list.pack(expand=1, fill=BOTH)
+ listnodes(list, app, '.', 0)
+ return list
def listnodes(list, app, widget, level):
- klass = list.send(app, 'winfo', 'class', widget)
-## i = string.rindex(widget, '.')
-## list.insert(END, '%s%s (%s)' % ((level-1)*'. ', widget[i:], klass))
- list.insert(END, '%s (%s)' % (widget, klass))
- children = list.tk.splitlist(
- list.send(app, 'winfo', 'children', widget))
- for c in children:
- listnodes(list, app, c, level+1)
+ klass = list.send(app, 'winfo', 'class', widget)
+## i = string.rindex(widget, '.')
+## list.insert(END, '%s%s (%s)' % ((level-1)*'. ', widget[i:], klass))
+ list.insert(END, '%s (%s)' % (widget, klass))
+ children = list.tk.splitlist(
+ list.send(app, 'winfo', 'children', widget))
+ for c in children:
+ listnodes(list, app, c, level+1)
def main():
- if not sys.argv[1:]:
- sys.stderr.write('Usage: listtree appname\n')
- sys.exit(2)
- app = sys.argv[1]
- tk = Tk()
- tk.minsize(1, 1)
- f = Frame(tk, name='f')
- f.pack(expand=1, fill=BOTH)
- list = listtree(f, app)
- tk.mainloop()
+ if not sys.argv[1:]:
+ sys.stderr.write('Usage: listtree appname\n')
+ sys.exit(2)
+ app = sys.argv[1]
+ tk = Tk()
+ tk.minsize(1, 1)
+ f = Frame(tk, name='f')
+ f.pack(expand=1, fill=BOTH)
+ list = listtree(f, app)
+ tk.mainloop()
if __name__ == '__main__':
- main()
+ main()
diff --git a/Demo/tkinter/guido/mbox.py b/Demo/tkinter/guido/mbox.py
index 6d7a410..9b16f6b 100755
--- a/Demo/tkinter/guido/mbox.py
+++ b/Demo/tkinter/guido/mbox.py
@@ -16,270 +16,270 @@
mailbox = os.environ['HOME'] + '/Mail'
def main():
- global root, tk, top, mid, bot
- global folderbox, foldermenu, scanbox, scanmenu, viewer
- global folder, seq
- global mh, mhf
+ global root, tk, top, mid, bot
+ global folderbox, foldermenu, scanbox, scanmenu, viewer
+ global folder, seq
+ global mh, mhf
- # Parse command line options
+ # Parse command line options
- folder = 'inbox'
- seq = 'all'
- try:
- opts, args = getopt.getopt(sys.argv[1:], '')
- except getopt.error, msg:
- print msg
- sys.exit(2)
- for arg in args:
- if arg[:1] == '+':
- folder = arg[1:]
- else:
- seq = arg
+ folder = 'inbox'
+ seq = 'all'
+ try:
+ opts, args = getopt.getopt(sys.argv[1:], '')
+ except getopt.error, msg:
+ print msg
+ sys.exit(2)
+ for arg in args:
+ if arg[:1] == '+':
+ folder = arg[1:]
+ else:
+ seq = arg
- # Initialize MH
+ # Initialize MH
- mh = mhlib.MH()
- mhf = mh.openfolder(folder)
+ mh = mhlib.MH()
+ mhf = mh.openfolder(folder)
- # Build widget hierarchy
+ # Build widget hierarchy
- root = Tk()
- tk = root.tk
+ root = Tk()
+ tk = root.tk
- top = Frame(root)
- top.pack({'expand': 1, 'fill': 'both'})
+ top = Frame(root)
+ top.pack({'expand': 1, 'fill': 'both'})
- # Build right part: folder list
+ # Build right part: folder list
- right = Frame(top)
- right.pack({'fill': 'y', 'side': 'right'})
+ right = Frame(top)
+ right.pack({'fill': 'y', 'side': 'right'})
- folderbar = Scrollbar(right, {'relief': 'sunken', 'bd': 2})
- folderbar.pack({'fill': 'y', 'side': 'right'})
+ folderbar = Scrollbar(right, {'relief': 'sunken', 'bd': 2})
+ folderbar.pack({'fill': 'y', 'side': 'right'})
- folderbox = Listbox(right, {'exportselection': 0})
- folderbox.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
+ folderbox = Listbox(right, {'exportselection': 0})
+ folderbox.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
- foldermenu = Menu(root)
- foldermenu.add('command',
- {'label': 'Open Folder',
- 'command': open_folder})
- foldermenu.add('separator')
- foldermenu.add('command',
- {'label': 'Quit',
- 'command': 'exit'})
- foldermenu.bind('<ButtonRelease-3>', folder_unpost)
+ foldermenu = Menu(root)
+ foldermenu.add('command',
+ {'label': 'Open Folder',
+ 'command': open_folder})
+ foldermenu.add('separator')
+ foldermenu.add('command',
+ {'label': 'Quit',
+ 'command': 'exit'})
+ foldermenu.bind('<ButtonRelease-3>', folder_unpost)
- folderbox['yscrollcommand'] = (folderbar, 'set')
- folderbar['command'] = (folderbox, 'yview')
- folderbox.bind('<Double-1>', open_folder, 1)
- folderbox.bind('<3>', folder_post)
+ folderbox['yscrollcommand'] = (folderbar, 'set')
+ folderbar['command'] = (folderbox, 'yview')
+ folderbox.bind('<Double-1>', open_folder, 1)
+ folderbox.bind('<3>', folder_post)
- # Build left part: scan list
+ # Build left part: scan list
- left = Frame(top)
- left.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
+ left = Frame(top)
+ left.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
- scanbar = Scrollbar(left, {'relief': 'sunken', 'bd': 2})
- scanbar.pack({'fill': 'y', 'side': 'right'})
+ scanbar = Scrollbar(left, {'relief': 'sunken', 'bd': 2})
+ scanbar.pack({'fill': 'y', 'side': 'right'})
- scanbox = Listbox(left, {'font': 'fixed'})
- scanbox.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
+ scanbox = Listbox(left, {'font': 'fixed'})
+ scanbox.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
- scanmenu = Menu(root)
- scanmenu.add('command',
- {'label': 'Open Message',
- 'command': open_message})
- scanmenu.add('command',
- {'label': 'Remove Message',
- 'command': remove_message})
- scanmenu.add('command',
- {'label': 'Refile Message',
- 'command': refile_message})
- scanmenu.add('separator')
- scanmenu.add('command',
- {'label': 'Quit',
- 'command': 'exit'})
- scanmenu.bind('<ButtonRelease-3>', scan_unpost)
+ scanmenu = Menu(root)
+ scanmenu.add('command',
+ {'label': 'Open Message',
+ 'command': open_message})
+ scanmenu.add('command',
+ {'label': 'Remove Message',
+ 'command': remove_message})
+ scanmenu.add('command',
+ {'label': 'Refile Message',
+ 'command': refile_message})
+ scanmenu.add('separator')
+ scanmenu.add('command',
+ {'label': 'Quit',
+ 'command': 'exit'})
+ scanmenu.bind('<ButtonRelease-3>', scan_unpost)
- scanbox['yscrollcommand'] = (scanbar, 'set')
- scanbar['command'] = (scanbox, 'yview')
- scanbox.bind('<Double-1>', open_message)
- scanbox.bind('<3>', scan_post)
+ scanbox['yscrollcommand'] = (scanbar, 'set')
+ scanbar['command'] = (scanbox, 'yview')
+ scanbox.bind('<Double-1>', open_message)
+ scanbox.bind('<3>', scan_post)
- # Separator between middle and bottom part
+ # Separator between middle and bottom part
- rule2 = Frame(root, {'bg': 'black'})
- rule2.pack({'fill': 'x'})
+ rule2 = Frame(root, {'bg': 'black'})
+ rule2.pack({'fill': 'x'})
- # Build bottom part: current message
+ # Build bottom part: current message
- bot = Frame(root)
- bot.pack({'expand': 1, 'fill': 'both'})
- #
- viewer = None
+ bot = Frame(root)
+ bot.pack({'expand': 1, 'fill': 'both'})
+ #
+ viewer = None
- # Window manager commands
+ # Window manager commands
- root.minsize(800, 1) # Make window resizable
+ root.minsize(800, 1) # Make window resizable
- # Fill folderbox with text
+ # Fill folderbox with text
- setfolders()
+ setfolders()
- # Fill scanbox with text
+ # Fill scanbox with text
- rescan()
+ rescan()
- # Enter mainloop
+ # Enter mainloop
- root.mainloop()
+ root.mainloop()
def folder_post(e):
- x, y = e.x_root, e.y_root
- foldermenu.post(x - 10, y - 10)
- foldermenu.grab_set()
+ x, y = e.x_root, e.y_root
+ foldermenu.post(x - 10, y - 10)
+ foldermenu.grab_set()
def folder_unpost(e):
- tk.call('update', 'idletasks')
- foldermenu.grab_release()
- foldermenu.unpost()
- foldermenu.invoke('active')
+ tk.call('update', 'idletasks')
+ foldermenu.grab_release()
+ foldermenu.unpost()
+ foldermenu.invoke('active')
def scan_post(e):
- x, y = e.x_root, e.y_root
- scanmenu.post(x - 10, y - 10)
- scanmenu.grab_set()
+ x, y = e.x_root, e.y_root
+ scanmenu.post(x - 10, y - 10)
+ scanmenu.grab_set()
def scan_unpost(e):
- tk.call('update', 'idletasks')
- scanmenu.grab_release()
- scanmenu.unpost()
- scanmenu.invoke('active')
+ tk.call('update', 'idletasks')
+ scanmenu.grab_release()
+ scanmenu.unpost()
+ scanmenu.invoke('active')
scanparser = regex.compile('^ *\([0-9]+\)')
def open_folder(e=None):
- global folder, mhf
- sel = folderbox.curselection()
- if len(sel) != 1:
- if len(sel) > 1:
- msg = "Please open one folder at a time"
- else:
- msg = "Please select a folder to open"
- dialog(root, "Can't Open Folder", msg, "", 0, "OK")
- return
- i = sel[0]
- folder = folderbox.get(i)
- mhf = mh.openfolder(folder)
- rescan()
+ global folder, mhf
+ sel = folderbox.curselection()
+ if len(sel) != 1:
+ if len(sel) > 1:
+ msg = "Please open one folder at a time"
+ else:
+ msg = "Please select a folder to open"
+ dialog(root, "Can't Open Folder", msg, "", 0, "OK")
+ return
+ i = sel[0]
+ folder = folderbox.get(i)
+ mhf = mh.openfolder(folder)
+ rescan()
def open_message(e=None):
- global viewer
- sel = scanbox.curselection()
- if len(sel) != 1:
- if len(sel) > 1:
- msg = "Please open one message at a time"
- else:
- msg = "Please select a message to open"
- dialog(root, "Can't Open Message", msg, "", 0, "OK")
- return
- cursor = scanbox['cursor']
- scanbox['cursor'] = 'watch'
- tk.call('update', 'idletasks')
- i = sel[0]
- line = scanbox.get(i)
- if scanparser.match(line) >= 0:
- num = string.atoi(scanparser.group(1))
- m = mhf.openmessage(num)
- if viewer: viewer.destroy()
- from MimeViewer import MimeViewer
- viewer = MimeViewer(bot, '+%s/%d' % (folder, num), m)
- viewer.pack()
- viewer.show()
- scanbox['cursor'] = cursor
+ global viewer
+ sel = scanbox.curselection()
+ if len(sel) != 1:
+ if len(sel) > 1:
+ msg = "Please open one message at a time"
+ else:
+ msg = "Please select a message to open"
+ dialog(root, "Can't Open Message", msg, "", 0, "OK")
+ return
+ cursor = scanbox['cursor']
+ scanbox['cursor'] = 'watch'
+ tk.call('update', 'idletasks')
+ i = sel[0]
+ line = scanbox.get(i)
+ if scanparser.match(line) >= 0:
+ num = string.atoi(scanparser.group(1))
+ m = mhf.openmessage(num)
+ if viewer: viewer.destroy()
+ from MimeViewer import MimeViewer
+ viewer = MimeViewer(bot, '+%s/%d' % (folder, num), m)
+ viewer.pack()
+ viewer.show()
+ scanbox['cursor'] = cursor
def interestingheader(header):
- return header != 'received'
+ return header != 'received'
def remove_message(e=None):
- itop = scanbox.nearest(0)
- sel = scanbox.curselection()
- if not sel:
- dialog(root, "No Message To Remove",
- "Please select a message to remove", "", 0, "OK")
- return
- todo = []
- for i in sel:
- line = scanbox.get(i)
- if scanparser.match(line) >= 0:
- todo.append(string.atoi(scanparser.group(1)))
- mhf.removemessages(todo)
- rescan()
- fixfocus(min(todo), itop)
+ itop = scanbox.nearest(0)
+ sel = scanbox.curselection()
+ if not sel:
+ dialog(root, "No Message To Remove",
+ "Please select a message to remove", "", 0, "OK")
+ return
+ todo = []
+ for i in sel:
+ line = scanbox.get(i)
+ if scanparser.match(line) >= 0:
+ todo.append(string.atoi(scanparser.group(1)))
+ mhf.removemessages(todo)
+ rescan()
+ fixfocus(min(todo), itop)
lastrefile = ''
tofolder = None
def refile_message(e=None):
- global lastrefile, tofolder
- itop = scanbox.nearest(0)
- sel = scanbox.curselection()
- if not sel:
- dialog(root, "No Message To Refile",
- "Please select a message to refile", "", 0, "OK")
- return
- foldersel = folderbox.curselection()
- if len(foldersel) != 1:
- if not foldersel:
- msg = "Please select a folder to refile to"
- else:
- msg = "Please select exactly one folder to refile to"
- dialog(root, "No Folder To Refile", msg, "", 0, "OK")
- return
- refileto = folderbox.get(foldersel[0])
- todo = []
- for i in sel:
- line = scanbox.get(i)
- if scanparser.match(line) >= 0:
- todo.append(string.atoi(scanparser.group(1)))
- if lastrefile != refileto or not tofolder:
- lastrefile = refileto
- tofolder = None
- tofolder = mh.openfolder(lastrefile)
- mhf.refilemessages(todo, tofolder)
- rescan()
- fixfocus(min(todo), itop)
+ global lastrefile, tofolder
+ itop = scanbox.nearest(0)
+ sel = scanbox.curselection()
+ if not sel:
+ dialog(root, "No Message To Refile",
+ "Please select a message to refile", "", 0, "OK")
+ return
+ foldersel = folderbox.curselection()
+ if len(foldersel) != 1:
+ if not foldersel:
+ msg = "Please select a folder to refile to"
+ else:
+ msg = "Please select exactly one folder to refile to"
+ dialog(root, "No Folder To Refile", msg, "", 0, "OK")
+ return
+ refileto = folderbox.get(foldersel[0])
+ todo = []
+ for i in sel:
+ line = scanbox.get(i)
+ if scanparser.match(line) >= 0:
+ todo.append(string.atoi(scanparser.group(1)))
+ if lastrefile != refileto or not tofolder:
+ lastrefile = refileto
+ tofolder = None
+ tofolder = mh.openfolder(lastrefile)
+ mhf.refilemessages(todo, tofolder)
+ rescan()
+ fixfocus(min(todo), itop)
def fixfocus(near, itop):
- n = scanbox.size()
- for i in range(n):
- line = scanbox.get(repr(i))
- if scanparser.match(line) >= 0:
- num = string.atoi(scanparser.group(1))
- if num >= near:
- break
- else:
- i = 'end'
- scanbox.select_from(i)
- scanbox.yview(itop)
+ n = scanbox.size()
+ for i in range(n):
+ line = scanbox.get(repr(i))
+ if scanparser.match(line) >= 0:
+ num = string.atoi(scanparser.group(1))
+ if num >= near:
+ break
+ else:
+ i = 'end'
+ scanbox.select_from(i)
+ scanbox.yview(itop)
def setfolders():
- folderbox.delete(0, 'end')
- for fn in mh.listallfolders():
- folderbox.insert('end', fn)
+ folderbox.delete(0, 'end')
+ for fn in mh.listallfolders():
+ folderbox.insert('end', fn)
def rescan():
- global viewer
- if viewer:
- viewer.destroy()
- viewer = None
- scanbox.delete(0, 'end')
- for line in scanfolder(folder, seq):
- scanbox.insert('end', line)
+ global viewer
+ if viewer:
+ viewer.destroy()
+ viewer = None
+ scanbox.delete(0, 'end')
+ for line in scanfolder(folder, seq):
+ scanbox.insert('end', line)
def scanfolder(folder = 'inbox', sequence = 'all'):
- return map(
- lambda line: line[:-1],
- os.popen('scan +%s %s' % (folder, sequence), 'r').readlines())
+ return map(
+ lambda line: line[:-1],
+ os.popen('scan +%s %s' % (folder, sequence), 'r').readlines())
main()
diff --git a/Demo/tkinter/guido/newmenubardemo.py b/Demo/tkinter/guido/newmenubardemo.py
index cafbf63..57bf13c 100644
--- a/Demo/tkinter/guido/newmenubardemo.py
+++ b/Demo/tkinter/guido/newmenubardemo.py
@@ -7,35 +7,35 @@
class App:
def __init__(self, master):
- self.master = master
+ self.master = master
- self.menubar = Menu(self.master)
+ self.menubar = Menu(self.master)
- self.filemenu = Menu(self.menubar)
-
- self.filemenu.add_command(label="New")
- self.filemenu.add_command(label="Open...")
- self.filemenu.add_command(label="Close")
- self.filemenu.add_separator()
- self.filemenu.add_command(label="Quit", command=self.master.quit)
+ self.filemenu = Menu(self.menubar)
- self.editmenu = Menu(self.menubar)
+ self.filemenu.add_command(label="New")
+ self.filemenu.add_command(label="Open...")
+ self.filemenu.add_command(label="Close")
+ self.filemenu.add_separator()
+ self.filemenu.add_command(label="Quit", command=self.master.quit)
- self.editmenu.add_command(label="Cut")
- self.editmenu.add_command(label="Copy")
- self.editmenu.add_command(label="Paste")
+ self.editmenu = Menu(self.menubar)
+
+ self.editmenu.add_command(label="Cut")
+ self.editmenu.add_command(label="Copy")
+ self.editmenu.add_command(label="Paste")
self.helpmenu = Menu(self.menubar, name='help')
self.helpmenu.add_command(label="About...")
- self.menubar.add_cascade(label="File", menu=self.filemenu)
- self.menubar.add_cascade(label="Edit", menu=self.editmenu)
- self.menubar.add_cascade(label="Help", menu=self.helpmenu)
+ self.menubar.add_cascade(label="File", menu=self.filemenu)
+ self.menubar.add_cascade(label="Edit", menu=self.editmenu)
+ self.menubar.add_cascade(label="Help", menu=self.helpmenu)
- self.top = Toplevel(menu=self.menubar)
+ self.top = Toplevel(menu=self.menubar)
- # Rest of app goes here...
+ # Rest of app goes here...
def main():
root = Tk()
diff --git a/Demo/tkinter/guido/paint.py b/Demo/tkinter/guido/paint.py
index 743d500..d46e20b 100644
--- a/Demo/tkinter/guido/paint.py
+++ b/Demo/tkinter/guido/paint.py
@@ -12,12 +12,12 @@
All this does is put up a canvas and draw a smooth black line
whenever you have the mouse button down, but hopefully it will
-be enough to start with.. It would be easy enough to add some
+be enough to start with.. It would be easy enough to add some
options like other shapes or colors...
- yours,
- dave mitchell
- davem@magnet.com
+ yours,
+ dave mitchell
+ davem@magnet.com
"""
from Tkinter import *
@@ -28,33 +28,33 @@
xold, yold = None, None
def main():
- root = Tk()
- drawing_area = Canvas(root)
- drawing_area.pack()
- drawing_area.bind("<Motion>", motion)
- drawing_area.bind("<ButtonPress-1>", b1down)
- drawing_area.bind("<ButtonRelease-1>", b1up)
- root.mainloop()
+ root = Tk()
+ drawing_area = Canvas(root)
+ drawing_area.pack()
+ drawing_area.bind("<Motion>", motion)
+ drawing_area.bind("<ButtonPress-1>", b1down)
+ drawing_area.bind("<ButtonRelease-1>", b1up)
+ root.mainloop()
def b1down(event):
- global b1
- b1 = "down" # you only want to draw when the button is down
- # because "Motion" events happen -all the time-
+ global b1
+ b1 = "down" # you only want to draw when the button is down
+ # because "Motion" events happen -all the time-
def b1up(event):
- global b1, xold, yold
- b1 = "up"
- xold = None # reset the line when you let go of the button
- yold = None
+ global b1, xold, yold
+ b1 = "up"
+ xold = None # reset the line when you let go of the button
+ yold = None
def motion(event):
- if b1 == "down":
- global xold, yold
- if xold != None and yold != None:
- event.widget.create_line(xold,yold,event.x,event.y,smooth=TRUE)
- # here's where you draw it. smooth. neat.
- xold = event.x
- yold = event.y
+ if b1 == "down":
+ global xold, yold
+ if xold != None and yold != None:
+ event.widget.create_line(xold,yold,event.x,event.y,smooth=TRUE)
+ # here's where you draw it. smooth. neat.
+ xold = event.x
+ yold = event.y
if __name__ == "__main__":
- main()
+ main()
diff --git a/Demo/tkinter/guido/rmt.py b/Demo/tkinter/guido/rmt.py
index 6e9a828..440650c 100755
--- a/Demo/tkinter/guido/rmt.py
+++ b/Demo/tkinter/guido/rmt.py
@@ -28,7 +28,7 @@
s.pack(side=RIGHT, fill=Y)
t = Text(f, relief=RAISED, borderwidth=2, yscrollcommand=s.set, setgrid=1)
t.pack(side=LEFT, fill=BOTH, expand=1)
-t.tag_config('bold', font='-Adobe-Courier-Bold-R-Normal-*-120-*')
+t.tag_config('bold', font='-Adobe-Courier-Bold-R-Normal-*-120-*')
s['command'] = t.yview
root.title('Tk Remote Controller')
@@ -42,7 +42,7 @@
file['menu'] = file_m
file_m_apps = Menu(file_m, tearoff=0)
file_m.add_cascade(label='Select Application', underline=0,
- menu=file_m_apps)
+ menu=file_m_apps)
file_m.add_command(label='Quit', underline=0, command=sys.exit)
# 3. Create bindings for text widget to allow commands to be
@@ -51,46 +51,46 @@
# insertion point).
def single1(e):
- x = e.x
- y = e.y
- t.setvar('tk_priv(selectMode)', 'char')
- t.mark_set('anchor', At(x, y))
- # Should focus W
+ x = e.x
+ y = e.y
+ t.setvar('tk_priv(selectMode)', 'char')
+ t.mark_set('anchor', At(x, y))
+ # Should focus W
t.bind('<1>', single1)
def double1(e):
- x = e.x
- y = e.y
- t.setvar('tk_priv(selectMode)', 'word')
- t.tk_textSelectTo(At(x, y))
+ x = e.x
+ y = e.y
+ t.setvar('tk_priv(selectMode)', 'word')
+ t.tk_textSelectTo(At(x, y))
t.bind('<Double-1>', double1)
def triple1(e):
- x = e.x
- y = e.y
- t.setvar('tk_priv(selectMode)', 'line')
- t.tk_textSelectTo(At(x, y))
+ x = e.x
+ y = e.y
+ t.setvar('tk_priv(selectMode)', 'line')
+ t.tk_textSelectTo(At(x, y))
t.bind('<Triple-1>', triple1)
def returnkey(e):
- t.insert(AtInsert(), '\n')
- invoke()
+ t.insert(AtInsert(), '\n')
+ invoke()
t.bind('<Return>', returnkey)
def controlv(e):
- t.insert(AtInsert(), t.selection_get())
- t.yview_pickplace(AtInsert())
- if t.index(AtInsert())[-2:] == '.0':
- invoke()
+ t.insert(AtInsert(), t.selection_get())
+ t.yview_pickplace(AtInsert())
+ if t.index(AtInsert())[-2:] == '.0':
+ invoke()
t.bind('<Control-v>', controlv)
# 4. Procedure to backspace over one character, as long as
# the character isn't part of the prompt.
def backspace(e):
- if t.index('promptEnd') != t.index('insert - 1 char'):
- t.delete('insert - 1 char', AtInsert())
- t.yview_pickplace(AtInsert())
+ if t.index('promptEnd') != t.index('insert - 1 char'):
+ t.delete('insert - 1 char', AtInsert())
+ t.yview_pickplace(AtInsert())
t.bind('<BackSpace>', backspace)
t.bind('<Control-h>', backspace)
t.bind('<Delete>', backspace)
@@ -103,49 +103,49 @@
# a new prompt.
def invoke():
- cmd = t.get('promptEnd + 1 char', AtInsert())
- if t.getboolean(tk.call('info', 'complete', cmd)): # XXX
- if app == root.winfo_name():
- msg = tk.call('eval', cmd) # XXX
- else:
- msg = t.send(app, cmd)
- if msg:
- t.insert(AtInsert(), msg + '\n')
- prompt()
- t.yview_pickplace(AtInsert())
+ cmd = t.get('promptEnd + 1 char', AtInsert())
+ if t.getboolean(tk.call('info', 'complete', cmd)): # XXX
+ if app == root.winfo_name():
+ msg = tk.call('eval', cmd) # XXX
+ else:
+ msg = t.send(app, cmd)
+ if msg:
+ t.insert(AtInsert(), msg + '\n')
+ prompt()
+ t.yview_pickplace(AtInsert())
def prompt():
- t.insert(AtInsert(), app + ': ')
- t.mark_set('promptEnd', 'insert - 1 char')
- t.tag_add('bold', 'insert linestart', 'promptEnd')
+ t.insert(AtInsert(), app + ': ')
+ t.mark_set('promptEnd', 'insert - 1 char')
+ t.tag_add('bold', 'insert linestart', 'promptEnd')
# 6. Procedure to select a new application. Also changes
# the prompt on the current command line to reflect the new
# name.
def newApp(appName):
- global app
- app = appName
- t.delete('promptEnd linestart', 'promptEnd')
- t.insert('promptEnd', appName + ':')
- t.tag_add('bold', 'promptEnd linestart', 'promptEnd')
+ global app
+ app = appName
+ t.delete('promptEnd linestart', 'promptEnd')
+ t.insert('promptEnd', appName + ':')
+ t.tag_add('bold', 'promptEnd linestart', 'promptEnd')
def fillAppsMenu():
- file_m_apps.add('command')
- file_m_apps.delete(0, 'last')
- names = root.winfo_interps()
- names = map(None, names) # convert tuple to list
- names.sort()
- for name in names:
- try:
- root.send(name, 'winfo name .')
- except TclError:
- # Inoperative window -- ignore it
- pass
- else:
- file_m_apps.add_command(
- label=name,
- command=lambda name=name: newApp(name))
+ file_m_apps.add('command')
+ file_m_apps.delete(0, 'last')
+ names = root.winfo_interps()
+ names = map(None, names) # convert tuple to list
+ names.sort()
+ for name in names:
+ try:
+ root.send(name, 'winfo name .')
+ except TclError:
+ # Inoperative window -- ignore it
+ pass
+ else:
+ file_m_apps.add_command(
+ label=name,
+ command=lambda name=name: newApp(name))
file_m_apps['postcommand'] = fillAppsMenu
mBar.tk_menuBar(file)
diff --git a/Demo/tkinter/guido/solitaire.py b/Demo/tkinter/guido/solitaire.py
index a205afd..50a8b26 100755
--- a/Demo/tkinter/guido/solitaire.py
+++ b/Demo/tkinter/guido/solitaire.py
@@ -11,7 +11,7 @@
- No keyboard shortcuts.
- Less fancy animation when you win.
- The determination of which stack you drag to is more relaxed.
-
+
Apology:
I'm not much of a card player, so my terminology in these comments may
@@ -35,7 +35,7 @@
class Group(Group):
def bind(self, sequence=None, command=None):
- return self.canvas.tag_bind(self.id, sequence, command)
+ return self.canvas.tag_bind(self.id, sequence, command)
# Constants determining the size and lay-out of cards and stacks. We
@@ -135,7 +135,7 @@
Semi-public read-only instance variables (XXX should be made
private):
-
+
group -- the Canvas.Group representing the card
x, y -- the position of the card's top left corner
@@ -150,68 +150,68 @@
"""
def __init__(self, suit, value, canvas):
- """Card constructor.
+ """Card constructor.
- Arguments are the card's suit and value, and the canvas widget.
+ Arguments are the card's suit and value, and the canvas widget.
- The card is created at position (0, 0), with its face down
- (adding it to a stack will position it according to that
- stack's rules).
+ The card is created at position (0, 0), with its face down
+ (adding it to a stack will position it according to that
+ stack's rules).
- """
- self.suit = suit
- self.value = value
- self.color = COLOR[suit]
- self.face_shown = 0
+ """
+ self.suit = suit
+ self.value = value
+ self.color = COLOR[suit]
+ self.face_shown = 0
- self.x = self.y = 0
- self.group = Group(canvas)
+ self.x = self.y = 0
+ self.group = Group(canvas)
- text = "%s %s" % (VALNAMES[value], suit)
- self.__text = CanvasText(canvas, CARDWIDTH/2, 0,
- anchor=N, fill=self.color, text=text)
- self.group.addtag_withtag(self.__text)
+ text = "%s %s" % (VALNAMES[value], suit)
+ self.__text = CanvasText(canvas, CARDWIDTH/2, 0,
+ anchor=N, fill=self.color, text=text)
+ self.group.addtag_withtag(self.__text)
- self.__rect = Rectangle(canvas, 0, 0, CARDWIDTH, CARDHEIGHT,
- outline='black', fill='white')
- self.group.addtag_withtag(self.__rect)
+ self.__rect = Rectangle(canvas, 0, 0, CARDWIDTH, CARDHEIGHT,
+ outline='black', fill='white')
+ self.group.addtag_withtag(self.__rect)
- self.__back = Rectangle(canvas, MARGIN, MARGIN,
- CARDWIDTH-MARGIN, CARDHEIGHT-MARGIN,
- outline='black', fill='blue')
- self.group.addtag_withtag(self.__back)
+ self.__back = Rectangle(canvas, MARGIN, MARGIN,
+ CARDWIDTH-MARGIN, CARDHEIGHT-MARGIN,
+ outline='black', fill='blue')
+ self.group.addtag_withtag(self.__back)
def __repr__(self):
- """Return a string for debug print statements."""
- return "Card(%r, %r)" % (self.suit, self.value)
+ """Return a string for debug print statements."""
+ return "Card(%r, %r)" % (self.suit, self.value)
def moveto(self, x, y):
- """Move the card to absolute position (x, y)."""
- self.moveby(x - self.x, y - self.y)
+ """Move the card to absolute position (x, y)."""
+ self.moveby(x - self.x, y - self.y)
def moveby(self, dx, dy):
- """Move the card by (dx, dy)."""
- self.x = self.x + dx
- self.y = self.y + dy
- self.group.move(dx, dy)
+ """Move the card by (dx, dy)."""
+ self.x = self.x + dx
+ self.y = self.y + dy
+ self.group.move(dx, dy)
def tkraise(self):
- """Raise the card above all other objects in its canvas."""
- self.group.tkraise()
+ """Raise the card above all other objects in its canvas."""
+ self.group.tkraise()
def showface(self):
- """Turn the card's face up."""
- self.tkraise()
- self.__rect.tkraise()
- self.__text.tkraise()
- self.face_shown = 1
+ """Turn the card's face up."""
+ self.tkraise()
+ self.__rect.tkraise()
+ self.__text.tkraise()
+ self.face_shown = 1
def showback(self):
- """Turn the card's face down."""
- self.tkraise()
- self.__rect.tkraise()
- self.__back.tkraise()
- self.face_shown = 0
+ """Turn the card's face down."""
+ self.tkraise()
+ self.__rect.tkraise()
+ self.__back.tkraise()
+ self.face_shown = 0
class Stack:
@@ -240,7 +240,7 @@
The default user (single) click handler shows the top card
face up. The default user double click handler calls the user
- single click handler.
+ single click handler.
usermovehandler(cards) -- called to complete a subpile move
@@ -255,133 +255,133 @@
The default event handlers turn the top card of the stack with
its face up on a (single or double) click, and also support
moving a subpile around.
-
+
startmoving(event) -- begin a move operation
finishmoving() -- finish a move operation
"""
def __init__(self, x, y, game=None):
- """Stack constructor.
+ """Stack constructor.
- Arguments are the stack's nominal x and y position (the top
- left corner of the first card placed in the stack), and the
- game object (which is used to get the canvas; subclasses use
- the game object to find other stacks).
+ Arguments are the stack's nominal x and y position (the top
+ left corner of the first card placed in the stack), and the
+ game object (which is used to get the canvas; subclasses use
+ the game object to find other stacks).
- """
- self.x = x
- self.y = y
- self.game = game
- self.cards = []
- self.group = Group(self.game.canvas)
- self.group.bind('<1>', self.clickhandler)
- self.group.bind('<Double-1>', self.doubleclickhandler)
- self.group.bind('<B1-Motion>', self.motionhandler)
- self.group.bind('<ButtonRelease-1>', self.releasehandler)
- self.makebottom()
+ """
+ self.x = x
+ self.y = y
+ self.game = game
+ self.cards = []
+ self.group = Group(self.game.canvas)
+ self.group.bind('<1>', self.clickhandler)
+ self.group.bind('<Double-1>', self.doubleclickhandler)
+ self.group.bind('<B1-Motion>', self.motionhandler)
+ self.group.bind('<ButtonRelease-1>', self.releasehandler)
+ self.makebottom()
def makebottom(self):
- pass
+ pass
def __repr__(self):
- """Return a string for debug print statements."""
- return "%s(%d, %d)" % (self.__class__.__name__, self.x, self.y)
+ """Return a string for debug print statements."""
+ return "%s(%d, %d)" % (self.__class__.__name__, self.x, self.y)
# Public methods
def add(self, card):
- self.cards.append(card)
- card.tkraise()
- self.position(card)
- self.group.addtag_withtag(card.group)
+ self.cards.append(card)
+ card.tkraise()
+ self.position(card)
+ self.group.addtag_withtag(card.group)
def delete(self, card):
- self.cards.remove(card)
- card.group.dtag(self.group)
+ self.cards.remove(card)
+ card.group.dtag(self.group)
def showtop(self):
- if self.cards:
- self.cards[-1].showface()
+ if self.cards:
+ self.cards[-1].showface()
def deal(self):
- if not self.cards:
- return None
- card = self.cards[-1]
- self.delete(card)
- return card
+ if not self.cards:
+ return None
+ card = self.cards[-1]
+ self.delete(card)
+ return card
# Subclass overridable methods
def position(self, card):
- card.moveto(self.x, self.y)
+ card.moveto(self.x, self.y)
def userclickhandler(self):
- self.showtop()
+ self.showtop()
def userdoubleclickhandler(self):
- self.userclickhandler()
+ self.userclickhandler()
def usermovehandler(self, cards):
- for card in cards:
- self.position(card)
+ for card in cards:
+ self.position(card)
# Event handlers
def clickhandler(self, event):
- self.finishmoving() # In case we lost an event
- self.userclickhandler()
- self.startmoving(event)
+ self.finishmoving() # In case we lost an event
+ self.userclickhandler()
+ self.startmoving(event)
def motionhandler(self, event):
- self.keepmoving(event)
+ self.keepmoving(event)
def releasehandler(self, event):
- self.keepmoving(event)
- self.finishmoving()
+ self.keepmoving(event)
+ self.finishmoving()
def doubleclickhandler(self, event):
- self.finishmoving() # In case we lost an event
- self.userdoubleclickhandler()
- self.startmoving(event)
+ self.finishmoving() # In case we lost an event
+ self.userdoubleclickhandler()
+ self.startmoving(event)
# Move internals
moving = None
def startmoving(self, event):
- self.moving = None
- tags = self.game.canvas.gettags('current')
- for i in range(len(self.cards)):
- card = self.cards[i]
- if card.group.tag in tags:
- break
- else:
- return
- if not card.face_shown:
- return
- self.moving = self.cards[i:]
- self.lastx = event.x
- self.lasty = event.y
- for card in self.moving:
- card.tkraise()
+ self.moving = None
+ tags = self.game.canvas.gettags('current')
+ for i in range(len(self.cards)):
+ card = self.cards[i]
+ if card.group.tag in tags:
+ break
+ else:
+ return
+ if not card.face_shown:
+ return
+ self.moving = self.cards[i:]
+ self.lastx = event.x
+ self.lasty = event.y
+ for card in self.moving:
+ card.tkraise()
def keepmoving(self, event):
- if not self.moving:
- return
- dx = event.x - self.lastx
- dy = event.y - self.lasty
- self.lastx = event.x
- self.lasty = event.y
- if dx or dy:
- for card in self.moving:
- card.moveby(dx, dy)
+ if not self.moving:
+ return
+ dx = event.x - self.lastx
+ dy = event.y - self.lasty
+ self.lastx = event.x
+ self.lasty = event.y
+ if dx or dy:
+ for card in self.moving:
+ card.moveby(dx, dy)
def finishmoving(self):
- cards = self.moving
- self.moving = None
- if cards:
- self.usermovehandler(cards)
+ cards = self.moving
+ self.moving = None
+ if cards:
+ self.usermovehandler(cards)
class Deck(Stack):
@@ -400,37 +400,37 @@
"""
def makebottom(self):
- bottom = Rectangle(self.game.canvas,
- self.x, self.y,
- self.x+CARDWIDTH, self.y+CARDHEIGHT,
- outline='black', fill=BACKGROUND)
- self.group.addtag_withtag(bottom)
+ bottom = Rectangle(self.game.canvas,
+ self.x, self.y,
+ self.x+CARDWIDTH, self.y+CARDHEIGHT,
+ outline='black', fill=BACKGROUND)
+ self.group.addtag_withtag(bottom)
def fill(self):
- for suit in ALLSUITS:
- for value in ALLVALUES:
- self.add(Card(suit, value, self.game.canvas))
+ for suit in ALLSUITS:
+ for value in ALLVALUES:
+ self.add(Card(suit, value, self.game.canvas))
def shuffle(self):
- n = len(self.cards)
- newcards = []
- for i in randperm(n):
- newcards.append(self.cards[i])
- self.cards = newcards
+ n = len(self.cards)
+ newcards = []
+ for i in randperm(n):
+ newcards.append(self.cards[i])
+ self.cards = newcards
def userclickhandler(self):
- opendeck = self.game.opendeck
- card = self.deal()
- if not card:
- while 1:
- card = opendeck.deal()
- if not card:
- break
- self.add(card)
- card.showback()
- else:
- self.game.opendeck.add(card)
- card.showface()
+ opendeck = self.game.opendeck
+ card = self.deal()
+ if not card:
+ while 1:
+ card = opendeck.deal()
+ if not card:
+ break
+ self.add(card)
+ card.showback()
+ else:
+ self.game.opendeck.add(card)
+ card.showface()
def randperm(n):
@@ -438,191 +438,191 @@
r = range(n)
x = []
while r:
- i = random.choice(r)
- x.append(i)
- r.remove(i)
+ i = random.choice(r)
+ x.append(i)
+ r.remove(i)
return x
class OpenStack(Stack):
def acceptable(self, cards):
- return 0
+ return 0
def usermovehandler(self, cards):
- card = cards[0]
- stack = self.game.closeststack(card)
- if not stack or stack is self or not stack.acceptable(cards):
- Stack.usermovehandler(self, cards)
- else:
- for card in cards:
- self.delete(card)
- stack.add(card)
- self.game.wincheck()
+ card = cards[0]
+ stack = self.game.closeststack(card)
+ if not stack or stack is self or not stack.acceptable(cards):
+ Stack.usermovehandler(self, cards)
+ else:
+ for card in cards:
+ self.delete(card)
+ stack.add(card)
+ self.game.wincheck()
def userdoubleclickhandler(self):
- if not self.cards:
- return
- card = self.cards[-1]
- if not card.face_shown:
- self.userclickhandler()
- return
- for s in self.game.suits:
- if s.acceptable([card]):
- self.delete(card)
- s.add(card)
- self.game.wincheck()
- break
+ if not self.cards:
+ return
+ card = self.cards[-1]
+ if not card.face_shown:
+ self.userclickhandler()
+ return
+ for s in self.game.suits:
+ if s.acceptable([card]):
+ self.delete(card)
+ s.add(card)
+ self.game.wincheck()
+ break
class SuitStack(OpenStack):
def makebottom(self):
- bottom = Rectangle(self.game.canvas,
- self.x, self.y,
- self.x+CARDWIDTH, self.y+CARDHEIGHT,
- outline='black', fill='')
+ bottom = Rectangle(self.game.canvas,
+ self.x, self.y,
+ self.x+CARDWIDTH, self.y+CARDHEIGHT,
+ outline='black', fill='')
def userclickhandler(self):
- pass
+ pass
def userdoubleclickhandler(self):
- pass
+ pass
def acceptable(self, cards):
- if len(cards) != 1:
- return 0
- card = cards[0]
- if not self.cards:
- return card.value == ACE
- topcard = self.cards[-1]
- return card.suit == topcard.suit and card.value == topcard.value + 1
+ if len(cards) != 1:
+ return 0
+ card = cards[0]
+ if not self.cards:
+ return card.value == ACE
+ topcard = self.cards[-1]
+ return card.suit == topcard.suit and card.value == topcard.value + 1
class RowStack(OpenStack):
def acceptable(self, cards):
- card = cards[0]
- if not self.cards:
- return card.value == KING
- topcard = self.cards[-1]
- if not topcard.face_shown:
- return 0
- return card.color != topcard.color and card.value == topcard.value - 1
+ card = cards[0]
+ if not self.cards:
+ return card.value == KING
+ topcard = self.cards[-1]
+ if not topcard.face_shown:
+ return 0
+ return card.color != topcard.color and card.value == topcard.value - 1
def position(self, card):
- y = self.y
- for c in self.cards:
- if c == card:
- break
- if c.face_shown:
- y = y + 2*MARGIN
- else:
- y = y + OFFSET
- card.moveto(self.x, y)
+ y = self.y
+ for c in self.cards:
+ if c == card:
+ break
+ if c.face_shown:
+ y = y + 2*MARGIN
+ else:
+ y = y + OFFSET
+ card.moveto(self.x, y)
class Solitaire:
def __init__(self, master):
- self.master = master
+ self.master = master
- self.canvas = Canvas(self.master,
- background=BACKGROUND,
- highlightthickness=0,
- width=NROWS*XSPACING,
- height=3*YSPACING + 20 + MARGIN)
- self.canvas.pack(fill=BOTH, expand=TRUE)
+ self.canvas = Canvas(self.master,
+ background=BACKGROUND,
+ highlightthickness=0,
+ width=NROWS*XSPACING,
+ height=3*YSPACING + 20 + MARGIN)
+ self.canvas.pack(fill=BOTH, expand=TRUE)
- self.dealbutton = Button(self.canvas,
- text="Deal",
- highlightthickness=0,
- background=BACKGROUND,
- activebackground="green",
- command=self.deal)
- Window(self.canvas, MARGIN, 3*YSPACING + 20,
- window=self.dealbutton, anchor=SW)
+ self.dealbutton = Button(self.canvas,
+ text="Deal",
+ highlightthickness=0,
+ background=BACKGROUND,
+ activebackground="green",
+ command=self.deal)
+ Window(self.canvas, MARGIN, 3*YSPACING + 20,
+ window=self.dealbutton, anchor=SW)
- x = MARGIN
- y = MARGIN
+ x = MARGIN
+ y = MARGIN
- self.deck = Deck(x, y, self)
+ self.deck = Deck(x, y, self)
- x = x + XSPACING
- self.opendeck = OpenStack(x, y, self)
-
- x = x + XSPACING
- self.suits = []
- for i in range(NSUITS):
- x = x + XSPACING
- self.suits.append(SuitStack(x, y, self))
+ x = x + XSPACING
+ self.opendeck = OpenStack(x, y, self)
- x = MARGIN
- y = y + YSPACING
+ x = x + XSPACING
+ self.suits = []
+ for i in range(NSUITS):
+ x = x + XSPACING
+ self.suits.append(SuitStack(x, y, self))
- self.rows = []
- for i in range(NROWS):
- self.rows.append(RowStack(x, y, self))
- x = x + XSPACING
+ x = MARGIN
+ y = y + YSPACING
- self.openstacks = [self.opendeck] + self.suits + self.rows
-
- self.deck.fill()
- self.deal()
+ self.rows = []
+ for i in range(NROWS):
+ self.rows.append(RowStack(x, y, self))
+ x = x + XSPACING
+
+ self.openstacks = [self.opendeck] + self.suits + self.rows
+
+ self.deck.fill()
+ self.deal()
def wincheck(self):
- for s in self.suits:
- if len(s.cards) != NVALUES:
- return
- self.win()
- self.deal()
+ for s in self.suits:
+ if len(s.cards) != NVALUES:
+ return
+ self.win()
+ self.deal()
def win(self):
- """Stupid animation when you win."""
- cards = []
- for s in self.openstacks:
- cards = cards + s.cards
- while cards:
- card = random.choice(cards)
- cards.remove(card)
- self.animatedmoveto(card, self.deck)
+ """Stupid animation when you win."""
+ cards = []
+ for s in self.openstacks:
+ cards = cards + s.cards
+ while cards:
+ card = random.choice(cards)
+ cards.remove(card)
+ self.animatedmoveto(card, self.deck)
def animatedmoveto(self, card, dest):
- for i in range(10, 0, -1):
- dx, dy = (dest.x-card.x)/i, (dest.y-card.y)/i
- card.moveby(dx, dy)
- self.master.update_idletasks()
+ for i in range(10, 0, -1):
+ dx, dy = (dest.x-card.x)/i, (dest.y-card.y)/i
+ card.moveby(dx, dy)
+ self.master.update_idletasks()
def closeststack(self, card):
- closest = None
- cdist = 999999999
- # Since we only compare distances,
- # we don't bother to take the square root.
- for stack in self.openstacks:
- dist = (stack.x - card.x)**2 + (stack.y - card.y)**2
- if dist < cdist:
- closest = stack
- cdist = dist
- return closest
+ closest = None
+ cdist = 999999999
+ # Since we only compare distances,
+ # we don't bother to take the square root.
+ for stack in self.openstacks:
+ dist = (stack.x - card.x)**2 + (stack.y - card.y)**2
+ if dist < cdist:
+ closest = stack
+ cdist = dist
+ return closest
def deal(self):
- self.reset()
- self.deck.shuffle()
- for i in range(NROWS):
- for r in self.rows[i:]:
- card = self.deck.deal()
- r.add(card)
- for r in self.rows:
- r.showtop()
+ self.reset()
+ self.deck.shuffle()
+ for i in range(NROWS):
+ for r in self.rows[i:]:
+ card = self.deck.deal()
+ r.add(card)
+ for r in self.rows:
+ r.showtop()
def reset(self):
- for stack in self.openstacks:
- while 1:
- card = stack.deal()
- if not card:
- break
- self.deck.add(card)
- card.showback()
+ for stack in self.openstacks:
+ while 1:
+ card = stack.deal()
+ if not card:
+ break
+ self.deck.add(card)
+ card.showback()
# Main function, run when invoked as a stand-alone Python program.
diff --git a/Demo/tkinter/guido/sortvisu.py b/Demo/tkinter/guido/sortvisu.py
index 6fe4002..f18f2c1 100644
--- a/Demo/tkinter/guido/sortvisu.py
+++ b/Demo/tkinter/guido/sortvisu.py
@@ -32,302 +32,302 @@
class Array:
def __init__(self, master, data=None):
- self.master = master
- self.frame = Frame(self.master)
- self.frame.pack(fill=X)
- self.label = Label(self.frame)
- self.label.pack()
- self.canvas = Canvas(self.frame)
- self.canvas.pack()
- self.report = Label(self.frame)
- self.report.pack()
- self.left = Line(self.canvas, 0, 0, 0, 0)
- self.right = Line(self.canvas, 0, 0, 0, 0)
- self.pivot = Line(self.canvas, 0, 0, 0, 0)
- self.items = []
- self.size = self.maxvalue = 0
- if data:
- self.setdata(data)
+ self.master = master
+ self.frame = Frame(self.master)
+ self.frame.pack(fill=X)
+ self.label = Label(self.frame)
+ self.label.pack()
+ self.canvas = Canvas(self.frame)
+ self.canvas.pack()
+ self.report = Label(self.frame)
+ self.report.pack()
+ self.left = Line(self.canvas, 0, 0, 0, 0)
+ self.right = Line(self.canvas, 0, 0, 0, 0)
+ self.pivot = Line(self.canvas, 0, 0, 0, 0)
+ self.items = []
+ self.size = self.maxvalue = 0
+ if data:
+ self.setdata(data)
def setdata(self, data):
- olditems = self.items
- self.items = []
- for item in olditems:
- item.delete()
- self.size = len(data)
- self.maxvalue = max(data)
- self.canvas.config(width=(self.size+1)*XGRID,
- height=(self.maxvalue+1)*YGRID)
- for i in range(self.size):
- self.items.append(ArrayItem(self, i, data[i]))
- self.reset("Sort demo, size %d" % self.size)
+ olditems = self.items
+ self.items = []
+ for item in olditems:
+ item.delete()
+ self.size = len(data)
+ self.maxvalue = max(data)
+ self.canvas.config(width=(self.size+1)*XGRID,
+ height=(self.maxvalue+1)*YGRID)
+ for i in range(self.size):
+ self.items.append(ArrayItem(self, i, data[i]))
+ self.reset("Sort demo, size %d" % self.size)
speed = "normal"
def setspeed(self, speed):
- self.speed = speed
+ self.speed = speed
def destroy(self):
- self.frame.destroy()
+ self.frame.destroy()
in_mainloop = 0
stop_mainloop = 0
def cancel(self):
- self.stop_mainloop = 1
- if self.in_mainloop:
- self.master.quit()
+ self.stop_mainloop = 1
+ if self.in_mainloop:
+ self.master.quit()
def step(self):
- if self.in_mainloop:
- self.master.quit()
+ if self.in_mainloop:
+ self.master.quit()
- Cancelled = "Array.Cancelled" # Exception
+ Cancelled = "Array.Cancelled" # Exception
def wait(self, msecs):
- if self.speed == "fastest":
- msecs = 0
- elif self.speed == "fast":
- msecs = msecs/10
- elif self.speed == "single-step":
- msecs = 1000000000
- if not self.stop_mainloop:
- self.master.update()
- id = self.master.after(msecs, self.master.quit)
- self.in_mainloop = 1
- self.master.mainloop()
- self.master.after_cancel(id)
- self.in_mainloop = 0
- if self.stop_mainloop:
- self.stop_mainloop = 0
- self.message("Cancelled")
- raise Array.Cancelled
+ if self.speed == "fastest":
+ msecs = 0
+ elif self.speed == "fast":
+ msecs = msecs/10
+ elif self.speed == "single-step":
+ msecs = 1000000000
+ if not self.stop_mainloop:
+ self.master.update()
+ id = self.master.after(msecs, self.master.quit)
+ self.in_mainloop = 1
+ self.master.mainloop()
+ self.master.after_cancel(id)
+ self.in_mainloop = 0
+ if self.stop_mainloop:
+ self.stop_mainloop = 0
+ self.message("Cancelled")
+ raise Array.Cancelled
def getsize(self):
- return self.size
+ return self.size
def show_partition(self, first, last):
- for i in range(self.size):
- item = self.items[i]
- if first <= i < last:
- item.item.config(fill='red')
- else:
- item.item.config(fill='orange')
- self.hide_left_right_pivot()
+ for i in range(self.size):
+ item = self.items[i]
+ if first <= i < last:
+ item.item.config(fill='red')
+ else:
+ item.item.config(fill='orange')
+ self.hide_left_right_pivot()
def hide_partition(self):
- for i in range(self.size):
- item = self.items[i]
- item.item.config(fill='red')
- self.hide_left_right_pivot()
+ for i in range(self.size):
+ item = self.items[i]
+ item.item.config(fill='red')
+ self.hide_left_right_pivot()
def show_left(self, left):
- if not 0 <= left < self.size:
- self.hide_left()
- return
- x1, y1, x2, y2 = self.items[left].position()
-## top, bot = HIRO
- self.left.coords([(x1-2, 0), (x1-2, 9999)])
- self.master.update()
+ if not 0 <= left < self.size:
+ self.hide_left()
+ return
+ x1, y1, x2, y2 = self.items[left].position()
+## top, bot = HIRO
+ self.left.coords([(x1-2, 0), (x1-2, 9999)])
+ self.master.update()
def show_right(self, right):
- if not 0 <= right < self.size:
- self.hide_right()
- return
- x1, y1, x2, y2 = self.items[right].position()
- self.right.coords(((x2+2, 0), (x2+2, 9999)))
- self.master.update()
+ if not 0 <= right < self.size:
+ self.hide_right()
+ return
+ x1, y1, x2, y2 = self.items[right].position()
+ self.right.coords(((x2+2, 0), (x2+2, 9999)))
+ self.master.update()
def hide_left_right_pivot(self):
- self.hide_left()
- self.hide_right()
- self.hide_pivot()
+ self.hide_left()
+ self.hide_right()
+ self.hide_pivot()
def hide_left(self):
- self.left.coords(((0, 0), (0, 0)))
+ self.left.coords(((0, 0), (0, 0)))
def hide_right(self):
- self.right.coords(((0, 0), (0, 0)))
+ self.right.coords(((0, 0), (0, 0)))
def show_pivot(self, pivot):
- x1, y1, x2, y2 = self.items[pivot].position()
- self.pivot.coords(((0, y1-2), (9999, y1-2)))
+ x1, y1, x2, y2 = self.items[pivot].position()
+ self.pivot.coords(((0, y1-2), (9999, y1-2)))
def hide_pivot(self):
- self.pivot.coords(((0, 0), (0, 0)))
+ self.pivot.coords(((0, 0), (0, 0)))
def swap(self, i, j):
- if i == j: return
- self.countswap()
- item = self.items[i]
- other = self.items[j]
- self.items[i], self.items[j] = other, item
- item.swapwith(other)
+ if i == j: return
+ self.countswap()
+ item = self.items[i]
+ other = self.items[j]
+ self.items[i], self.items[j] = other, item
+ item.swapwith(other)
def compare(self, i, j):
- self.countcompare()
- item = self.items[i]
- other = self.items[j]
- return item.compareto(other)
+ self.countcompare()
+ item = self.items[i]
+ other = self.items[j]
+ return item.compareto(other)
def reset(self, msg):
- self.ncompares = 0
- self.nswaps = 0
- self.message(msg)
- self.updatereport()
- self.hide_partition()
+ self.ncompares = 0
+ self.nswaps = 0
+ self.message(msg)
+ self.updatereport()
+ self.hide_partition()
def message(self, msg):
- self.label.config(text=msg)
+ self.label.config(text=msg)
def countswap(self):
- self.nswaps = self.nswaps + 1
- self.updatereport()
+ self.nswaps = self.nswaps + 1
+ self.updatereport()
def countcompare(self):
- self.ncompares = self.ncompares + 1
- self.updatereport()
+ self.ncompares = self.ncompares + 1
+ self.updatereport()
def updatereport(self):
- text = "%d cmps, %d swaps" % (self.ncompares, self.nswaps)
- self.report.config(text=text)
+ text = "%d cmps, %d swaps" % (self.ncompares, self.nswaps)
+ self.report.config(text=text)
class ArrayItem:
def __init__(self, array, index, value):
- self.array = array
- self.index = index
- self.value = value
- x1, y1, x2, y2 = self.position()
- self.item = Rectangle(array.canvas, x1, y1, x2, y2,
- fill='red', outline='black', width=1)
- self.item.bind('<Button-1>', self.mouse_down)
- self.item.bind('<Button1-Motion>', self.mouse_move)
- self.item.bind('<ButtonRelease-1>', self.mouse_up)
+ self.array = array
+ self.index = index
+ self.value = value
+ x1, y1, x2, y2 = self.position()
+ self.item = Rectangle(array.canvas, x1, y1, x2, y2,
+ fill='red', outline='black', width=1)
+ self.item.bind('<Button-1>', self.mouse_down)
+ self.item.bind('<Button1-Motion>', self.mouse_move)
+ self.item.bind('<ButtonRelease-1>', self.mouse_up)
def delete(self):
- item = self.item
- self.array = None
- self.item = None
- item.delete()
+ item = self.item
+ self.array = None
+ self.item = None
+ item.delete()
def mouse_down(self, event):
- self.lastx = event.x
- self.lasty = event.y
- self.origx = event.x
- self.origy = event.y
- self.item.tkraise()
-
+ self.lastx = event.x
+ self.lasty = event.y
+ self.origx = event.x
+ self.origy = event.y
+ self.item.tkraise()
+
def mouse_move(self, event):
- self.item.move(event.x - self.lastx, event.y - self.lasty)
- self.lastx = event.x
- self.lasty = event.y
+ self.item.move(event.x - self.lastx, event.y - self.lasty)
+ self.lastx = event.x
+ self.lasty = event.y
def mouse_up(self, event):
- i = self.nearestindex(event.x)
- if i >= self.array.getsize():
- i = self.array.getsize() - 1
- if i < 0:
- i = 0
- other = self.array.items[i]
- here = self.index
- self.array.items[here], self.array.items[i] = other, self
- self.index = i
- x1, y1, x2, y2 = self.position()
- self.item.coords(((x1, y1), (x2, y2)))
- other.setindex(here)
+ i = self.nearestindex(event.x)
+ if i >= self.array.getsize():
+ i = self.array.getsize() - 1
+ if i < 0:
+ i = 0
+ other = self.array.items[i]
+ here = self.index
+ self.array.items[here], self.array.items[i] = other, self
+ self.index = i
+ x1, y1, x2, y2 = self.position()
+ self.item.coords(((x1, y1), (x2, y2)))
+ other.setindex(here)
def setindex(self, index):
- nsteps = steps(self.index, index)
- if not nsteps: return
- if self.array.speed == "fastest":
- nsteps = 0
- oldpts = self.position()
- self.index = index
- newpts = self.position()
- trajectory = interpolate(oldpts, newpts, nsteps)
- self.item.tkraise()
- for pts in trajectory:
- self.item.coords((pts[:2], pts[2:]))
- self.array.wait(50)
+ nsteps = steps(self.index, index)
+ if not nsteps: return
+ if self.array.speed == "fastest":
+ nsteps = 0
+ oldpts = self.position()
+ self.index = index
+ newpts = self.position()
+ trajectory = interpolate(oldpts, newpts, nsteps)
+ self.item.tkraise()
+ for pts in trajectory:
+ self.item.coords((pts[:2], pts[2:]))
+ self.array.wait(50)
def swapwith(self, other):
- nsteps = steps(self.index, other.index)
- if not nsteps: return
- if self.array.speed == "fastest":
- nsteps = 0
- myoldpts = self.position()
- otheroldpts = other.position()
- self.index, other.index = other.index, self.index
- mynewpts = self.position()
- othernewpts = other.position()
- myfill = self.item['fill']
- otherfill = other.item['fill']
- self.item.config(fill='green')
- other.item.config(fill='yellow')
- self.array.master.update()
- if self.array.speed == "single-step":
- self.item.coords((mynewpts[:2], mynewpts[2:]))
- other.item.coords((othernewpts[:2], othernewpts[2:]))
- self.array.master.update()
- self.item.config(fill=myfill)
- other.item.config(fill=otherfill)
- self.array.wait(0)
- return
- mytrajectory = interpolate(myoldpts, mynewpts, nsteps)
- othertrajectory = interpolate(otheroldpts, othernewpts, nsteps)
- if self.value > other.value:
- self.item.tkraise()
- other.item.tkraise()
- else:
- other.item.tkraise()
- self.item.tkraise()
- try:
- for i in range(len(mytrajectory)):
- mypts = mytrajectory[i]
- otherpts = othertrajectory[i]
- self.item.coords((mypts[:2], mypts[2:]))
- other.item.coords((otherpts[:2], otherpts[2:]))
- self.array.wait(50)
- finally:
- mypts = mytrajectory[-1]
- otherpts = othertrajectory[-1]
- self.item.coords((mypts[:2], mypts[2:]))
- other.item.coords((otherpts[:2], otherpts[2:]))
- self.item.config(fill=myfill)
- other.item.config(fill=otherfill)
+ nsteps = steps(self.index, other.index)
+ if not nsteps: return
+ if self.array.speed == "fastest":
+ nsteps = 0
+ myoldpts = self.position()
+ otheroldpts = other.position()
+ self.index, other.index = other.index, self.index
+ mynewpts = self.position()
+ othernewpts = other.position()
+ myfill = self.item['fill']
+ otherfill = other.item['fill']
+ self.item.config(fill='green')
+ other.item.config(fill='yellow')
+ self.array.master.update()
+ if self.array.speed == "single-step":
+ self.item.coords((mynewpts[:2], mynewpts[2:]))
+ other.item.coords((othernewpts[:2], othernewpts[2:]))
+ self.array.master.update()
+ self.item.config(fill=myfill)
+ other.item.config(fill=otherfill)
+ self.array.wait(0)
+ return
+ mytrajectory = interpolate(myoldpts, mynewpts, nsteps)
+ othertrajectory = interpolate(otheroldpts, othernewpts, nsteps)
+ if self.value > other.value:
+ self.item.tkraise()
+ other.item.tkraise()
+ else:
+ other.item.tkraise()
+ self.item.tkraise()
+ try:
+ for i in range(len(mytrajectory)):
+ mypts = mytrajectory[i]
+ otherpts = othertrajectory[i]
+ self.item.coords((mypts[:2], mypts[2:]))
+ other.item.coords((otherpts[:2], otherpts[2:]))
+ self.array.wait(50)
+ finally:
+ mypts = mytrajectory[-1]
+ otherpts = othertrajectory[-1]
+ self.item.coords((mypts[:2], mypts[2:]))
+ other.item.coords((otherpts[:2], otherpts[2:]))
+ self.item.config(fill=myfill)
+ other.item.config(fill=otherfill)
def compareto(self, other):
- myfill = self.item['fill']
- otherfill = other.item['fill']
- outcome = cmp(self.value, other.value)
- if outcome < 0:
- myflash = 'white'
- otherflash = 'black'
- elif outcome > 0:
- myflash = 'black'
- otherflash = 'white'
- else:
- myflash = otherflash = 'grey'
- try:
- self.item.config(fill=myflash)
- other.item.config(fill=otherflash)
- self.array.wait(500)
- finally:
- self.item.config(fill=myfill)
- other.item.config(fill=otherfill)
- return outcome
+ myfill = self.item['fill']
+ otherfill = other.item['fill']
+ outcome = cmp(self.value, other.value)
+ if outcome < 0:
+ myflash = 'white'
+ otherflash = 'black'
+ elif outcome > 0:
+ myflash = 'black'
+ otherflash = 'white'
+ else:
+ myflash = otherflash = 'grey'
+ try:
+ self.item.config(fill=myflash)
+ other.item.config(fill=otherflash)
+ self.array.wait(500)
+ finally:
+ self.item.config(fill=myfill)
+ other.item.config(fill=otherfill)
+ return outcome
def position(self):
- x1 = (self.index+1)*XGRID - WIDTH/2
- x2 = x1+WIDTH
- y2 = (self.array.maxvalue+1)*YGRID
- y1 = y2 - (self.value)*YGRID
- return x1, y1, x2, y2
+ x1 = (self.index+1)*XGRID - WIDTH/2
+ x2 = x1+WIDTH
+ y2 = (self.array.maxvalue+1)*YGRID
+ y1 = y2 - (self.value)*YGRID
+ return x1, y1, x2, y2
def nearestindex(self, x):
- return int(round(float(x)/XGRID)) - 1
+ return int(round(float(x)/XGRID)) - 1
# Subroutines that don't need an object
@@ -335,22 +335,22 @@
def steps(here, there):
nsteps = abs(here - there)
if nsteps <= 3:
- nsteps = nsteps * 3
+ nsteps = nsteps * 3
elif nsteps <= 5:
- nsteps = nsteps * 2
+ nsteps = nsteps * 2
elif nsteps > 10:
- nsteps = 10
+ nsteps = 10
return nsteps
def interpolate(oldpts, newpts, n):
if len(oldpts) != len(newpts):
- raise ValueError, "can't interpolate arrays of different length"
+ raise ValueError, "can't interpolate arrays of different length"
pts = [0]*len(oldpts)
res = [tuple(oldpts)]
for i in range(1, n):
- for k in range(len(pts)):
- pts[k] = oldpts[k] + (newpts[k] - oldpts[k])*i/n
- res.append(tuple(pts))
+ for k in range(len(pts)):
+ pts[k] = oldpts[k] + (newpts[k] - oldpts[k])*i/n
+ res.append(tuple(pts))
res.append(tuple(newpts))
return res
@@ -371,110 +371,110 @@
array.reset("Randomizing")
n = array.getsize()
for i in range(n):
- j = random.randint(0, n-1)
- array.swap(i, j)
+ j = random.randint(0, n-1)
+ array.swap(i, j)
array.message("Randomized")
def insertionsort(array):
size = array.getsize()
array.reset("Insertion sort")
for i in range(1, size):
- j = i-1
- while j >= 0:
- if array.compare(j, j+1) <= 0:
- break
- array.swap(j, j+1)
- j = j-1
+ j = i-1
+ while j >= 0:
+ if array.compare(j, j+1) <= 0:
+ break
+ array.swap(j, j+1)
+ j = j-1
array.message("Sorted")
def selectionsort(array):
size = array.getsize()
array.reset("Selection sort")
try:
- for i in range(size):
- array.show_partition(i, size)
- for j in range(i+1, size):
- if array.compare(i, j) > 0:
- array.swap(i, j)
- array.message("Sorted")
+ for i in range(size):
+ array.show_partition(i, size)
+ for j in range(i+1, size):
+ if array.compare(i, j) > 0:
+ array.swap(i, j)
+ array.message("Sorted")
finally:
- array.hide_partition()
+ array.hide_partition()
def bubblesort(array):
size = array.getsize()
array.reset("Bubble sort")
for i in range(size):
- for j in range(1, size):
- if array.compare(j-1, j) > 0:
- array.swap(j-1, j)
+ for j in range(1, size):
+ if array.compare(j-1, j) > 0:
+ array.swap(j-1, j)
array.message("Sorted")
def quicksort(array):
size = array.getsize()
array.reset("Quicksort")
try:
- stack = [(0, size)]
- while stack:
- first, last = stack[-1]
- del stack[-1]
- array.show_partition(first, last)
- if last-first < 5:
- array.message("Insertion sort")
- for i in range(first+1, last):
- j = i-1
- while j >= first:
- if array.compare(j, j+1) <= 0:
- break
- array.swap(j, j+1)
- j = j-1
- continue
- array.message("Choosing pivot")
- j, i, k = first, (first+last)/2, last-1
- if array.compare(k, i) < 0:
- array.swap(k, i)
- if array.compare(k, j) < 0:
- array.swap(k, j)
- if array.compare(j, i) < 0:
- array.swap(j, i)
- pivot = j
- array.show_pivot(pivot)
- array.message("Pivot at left of partition")
- array.wait(1000)
- left = first
- right = last
- while 1:
- array.message("Sweep right pointer")
- right = right-1
- array.show_right(right)
- while right > first and array.compare(right, pivot) >= 0:
- right = right-1
- array.show_right(right)
- array.message("Sweep left pointer")
- left = left+1
- array.show_left(left)
- while left < last and array.compare(left, pivot) <= 0:
- left = left+1
- array.show_left(left)
- if left > right:
- array.message("End of partition")
- break
- array.message("Swap items")
- array.swap(left, right)
- array.message("Swap pivot back")
- array.swap(pivot, right)
- n1 = right-first
- n2 = last-left
- if n1 > 1: stack.append((first, right))
- if n2 > 1: stack.append((left, last))
- array.message("Sorted")
+ stack = [(0, size)]
+ while stack:
+ first, last = stack[-1]
+ del stack[-1]
+ array.show_partition(first, last)
+ if last-first < 5:
+ array.message("Insertion sort")
+ for i in range(first+1, last):
+ j = i-1
+ while j >= first:
+ if array.compare(j, j+1) <= 0:
+ break
+ array.swap(j, j+1)
+ j = j-1
+ continue
+ array.message("Choosing pivot")
+ j, i, k = first, (first+last)/2, last-1
+ if array.compare(k, i) < 0:
+ array.swap(k, i)
+ if array.compare(k, j) < 0:
+ array.swap(k, j)
+ if array.compare(j, i) < 0:
+ array.swap(j, i)
+ pivot = j
+ array.show_pivot(pivot)
+ array.message("Pivot at left of partition")
+ array.wait(1000)
+ left = first
+ right = last
+ while 1:
+ array.message("Sweep right pointer")
+ right = right-1
+ array.show_right(right)
+ while right > first and array.compare(right, pivot) >= 0:
+ right = right-1
+ array.show_right(right)
+ array.message("Sweep left pointer")
+ left = left+1
+ array.show_left(left)
+ while left < last and array.compare(left, pivot) <= 0:
+ left = left+1
+ array.show_left(left)
+ if left > right:
+ array.message("End of partition")
+ break
+ array.message("Swap items")
+ array.swap(left, right)
+ array.message("Swap pivot back")
+ array.swap(pivot, right)
+ n1 = right-first
+ n2 = last-left
+ if n1 > 1: stack.append((first, right))
+ if n2 > 1: stack.append((left, last))
+ array.message("Sorted")
finally:
- array.hide_partition()
+ array.hide_partition()
def demosort(array):
while 1:
- for alg in [quicksort, insertionsort, selectionsort, bubblesort]:
- randomize(array)
- alg(array)
+ for alg in [quicksort, insertionsort, selectionsort, bubblesort]:
+ randomize(array)
+ alg(array)
# Sort demo class -- usable as a Grail applet
@@ -482,144 +482,144 @@
class SortDemo:
def __init__(self, master, size=15):
- self.master = master
- self.size = size
- self.busy = 0
- self.array = Array(self.master)
+ self.master = master
+ self.size = size
+ self.busy = 0
+ self.array = Array(self.master)
- self.botframe = Frame(master)
- self.botframe.pack(side=BOTTOM)
- self.botleftframe = Frame(self.botframe)
- self.botleftframe.pack(side=LEFT, fill=Y)
- self.botrightframe = Frame(self.botframe)
- self.botrightframe.pack(side=RIGHT, fill=Y)
+ self.botframe = Frame(master)
+ self.botframe.pack(side=BOTTOM)
+ self.botleftframe = Frame(self.botframe)
+ self.botleftframe.pack(side=LEFT, fill=Y)
+ self.botrightframe = Frame(self.botframe)
+ self.botrightframe.pack(side=RIGHT, fill=Y)
- self.b_qsort = Button(self.botleftframe,
- text="Quicksort", command=self.c_qsort)
- self.b_qsort.pack(fill=X)
- self.b_isort = Button(self.botleftframe,
- text="Insertion sort", command=self.c_isort)
- self.b_isort.pack(fill=X)
- self.b_ssort = Button(self.botleftframe,
- text="Selection sort", command=self.c_ssort)
- self.b_ssort.pack(fill=X)
- self.b_bsort = Button(self.botleftframe,
- text="Bubble sort", command=self.c_bsort)
- self.b_bsort.pack(fill=X)
+ self.b_qsort = Button(self.botleftframe,
+ text="Quicksort", command=self.c_qsort)
+ self.b_qsort.pack(fill=X)
+ self.b_isort = Button(self.botleftframe,
+ text="Insertion sort", command=self.c_isort)
+ self.b_isort.pack(fill=X)
+ self.b_ssort = Button(self.botleftframe,
+ text="Selection sort", command=self.c_ssort)
+ self.b_ssort.pack(fill=X)
+ self.b_bsort = Button(self.botleftframe,
+ text="Bubble sort", command=self.c_bsort)
+ self.b_bsort.pack(fill=X)
- # Terrible hack to overcome limitation of OptionMenu...
- class MyIntVar(IntVar):
- def __init__(self, master, demo):
- self.demo = demo
- IntVar.__init__(self, master)
- def set(self, value):
- IntVar.set(self, value)
- if str(value) != '0':
- self.demo.resize(value)
+ # Terrible hack to overcome limitation of OptionMenu...
+ class MyIntVar(IntVar):
+ def __init__(self, master, demo):
+ self.demo = demo
+ IntVar.__init__(self, master)
+ def set(self, value):
+ IntVar.set(self, value)
+ if str(value) != '0':
+ self.demo.resize(value)
- self.v_size = MyIntVar(self.master, self)
- self.v_size.set(size)
- sizes = [1, 2, 3, 4] + range(5, 55, 5)
- if self.size not in sizes:
- sizes.append(self.size)
- sizes.sort()
- self.m_size = apply(OptionMenu,
- (self.botleftframe, self.v_size) + tuple(sizes))
- self.m_size.pack(fill=X)
-
- self.v_speed = StringVar(self.master)
- self.v_speed.set("normal")
- self.m_speed = OptionMenu(self.botleftframe, self.v_speed,
- "single-step", "normal", "fast", "fastest")
- self.m_speed.pack(fill=X)
-
- self.b_step = Button(self.botleftframe,
- text="Step", command=self.c_step)
- self.b_step.pack(fill=X)
-
- self.b_randomize = Button(self.botrightframe,
- text="Randomize", command=self.c_randomize)
- self.b_randomize.pack(fill=X)
- self.b_uniform = Button(self.botrightframe,
- text="Uniform", command=self.c_uniform)
- self.b_uniform.pack(fill=X)
- self.b_distinct = Button(self.botrightframe,
- text="Distinct", command=self.c_distinct)
- self.b_distinct.pack(fill=X)
- self.b_demo = Button(self.botrightframe,
- text="Demo", command=self.c_demo)
- self.b_demo.pack(fill=X)
- self.b_cancel = Button(self.botrightframe,
- text="Cancel", command=self.c_cancel)
- self.b_cancel.pack(fill=X)
- self.b_cancel.config(state=DISABLED)
- self.b_quit = Button(self.botrightframe,
- text="Quit", command=self.c_quit)
- self.b_quit.pack(fill=X)
+ self.v_size = MyIntVar(self.master, self)
+ self.v_size.set(size)
+ sizes = [1, 2, 3, 4] + range(5, 55, 5)
+ if self.size not in sizes:
+ sizes.append(self.size)
+ sizes.sort()
+ self.m_size = apply(OptionMenu,
+ (self.botleftframe, self.v_size) + tuple(sizes))
+ self.m_size.pack(fill=X)
+
+ self.v_speed = StringVar(self.master)
+ self.v_speed.set("normal")
+ self.m_speed = OptionMenu(self.botleftframe, self.v_speed,
+ "single-step", "normal", "fast", "fastest")
+ self.m_speed.pack(fill=X)
+
+ self.b_step = Button(self.botleftframe,
+ text="Step", command=self.c_step)
+ self.b_step.pack(fill=X)
+
+ self.b_randomize = Button(self.botrightframe,
+ text="Randomize", command=self.c_randomize)
+ self.b_randomize.pack(fill=X)
+ self.b_uniform = Button(self.botrightframe,
+ text="Uniform", command=self.c_uniform)
+ self.b_uniform.pack(fill=X)
+ self.b_distinct = Button(self.botrightframe,
+ text="Distinct", command=self.c_distinct)
+ self.b_distinct.pack(fill=X)
+ self.b_demo = Button(self.botrightframe,
+ text="Demo", command=self.c_demo)
+ self.b_demo.pack(fill=X)
+ self.b_cancel = Button(self.botrightframe,
+ text="Cancel", command=self.c_cancel)
+ self.b_cancel.pack(fill=X)
+ self.b_cancel.config(state=DISABLED)
+ self.b_quit = Button(self.botrightframe,
+ text="Quit", command=self.c_quit)
+ self.b_quit.pack(fill=X)
def resize(self, newsize):
- if self.busy:
- self.master.bell()
- return
- self.size = newsize
- self.array.setdata(range(1, self.size+1))
+ if self.busy:
+ self.master.bell()
+ return
+ self.size = newsize
+ self.array.setdata(range(1, self.size+1))
def c_qsort(self):
- self.run(quicksort)
+ self.run(quicksort)
def c_isort(self):
- self.run(insertionsort)
+ self.run(insertionsort)
def c_ssort(self):
- self.run(selectionsort)
+ self.run(selectionsort)
def c_bsort(self):
- self.run(bubblesort)
+ self.run(bubblesort)
def c_demo(self):
- self.run(demosort)
+ self.run(demosort)
def c_randomize(self):
- self.run(randomize)
+ self.run(randomize)
def c_uniform(self):
- self.run(uniform)
+ self.run(uniform)
def c_distinct(self):
- self.run(distinct)
+ self.run(distinct)
def run(self, func):
- if self.busy:
- self.master.bell()
- return
- self.busy = 1
- self.array.setspeed(self.v_speed.get())
- self.b_cancel.config(state=NORMAL)
- try:
- func(self.array)
- except Array.Cancelled:
- pass
- self.b_cancel.config(state=DISABLED)
- self.busy = 0
+ if self.busy:
+ self.master.bell()
+ return
+ self.busy = 1
+ self.array.setspeed(self.v_speed.get())
+ self.b_cancel.config(state=NORMAL)
+ try:
+ func(self.array)
+ except Array.Cancelled:
+ pass
+ self.b_cancel.config(state=DISABLED)
+ self.busy = 0
def c_cancel(self):
- if not self.busy:
- self.master.bell()
- return
- self.array.cancel()
+ if not self.busy:
+ self.master.bell()
+ return
+ self.array.cancel()
def c_step(self):
- if not self.busy:
- self.master.bell()
- return
- self.v_speed.set("single-step")
- self.array.setspeed("single-step")
- self.array.step()
+ if not self.busy:
+ self.master.bell()
+ return
+ self.v_speed.set("single-step")
+ self.array.setspeed("single-step")
+ self.array.step()
def c_quit(self):
- if self.busy:
- self.array.cancel()
- self.master.after_idle(self.master.quit)
+ if self.busy:
+ self.array.cancel()
+ self.master.after_idle(self.master.quit)
# Main program -- for stand-alone operation outside Grail
diff --git a/Demo/tkinter/guido/ss1.py b/Demo/tkinter/guido/ss1.py
index 95b3d81..8935475 100644
--- a/Demo/tkinter/guido/ss1.py
+++ b/Demo/tkinter/guido/ss1.py
@@ -315,7 +315,7 @@
"""Abstract base class for sheet cells.
Subclasses may but needn't provide the following APIs:
-
+
cell.reset() -- prepare for recalculation
cell.recalc(rexec) -> value -- recalculate formula
cell.format() -> (value, alignment) -- return formatted value
diff --git a/Demo/tkinter/guido/svkill.py b/Demo/tkinter/guido/svkill.py
index 1c54e4b..69f7f3b 100755
--- a/Demo/tkinter/guido/svkill.py
+++ b/Demo/tkinter/guido/svkill.py
@@ -5,7 +5,7 @@
from Tkinter import *
if TkVersion < 4.0:
- raise ImportError, "This version of svkill requires Tk 4.0 or later"
+ raise ImportError, "This version of svkill requires Tk 4.0 or later"
from string import splitfields
from string import split
@@ -15,114 +15,114 @@
user = os.environ['LOGNAME']
class BarButton(Menubutton):
- def __init__(self, master=None, **cnf):
- apply(Menubutton.__init__, (self, master), cnf)
- self.pack(side=LEFT)
- self.menu = Menu(self, name='menu')
- self['menu'] = self.menu
+ def __init__(self, master=None, **cnf):
+ apply(Menubutton.__init__, (self, master), cnf)
+ self.pack(side=LEFT)
+ self.menu = Menu(self, name='menu')
+ self['menu'] = self.menu
class Kill(Frame):
- # List of (name, option, pid_column)
- view_list = [
- ('Default', ''),
- ('Every (-e)', '-e'),
- ('Non process group leaders (-d)', '-d'),
- ('Non leaders with tty (-a)', '-a'),
- ('For this user (-u %s)' % user, '-u %s' % user),
- ]
- format_list = [
- ('Default', '', 0),
- ('Long (-l)', '-l', 3),
- ('Full (-f)', '-f', 1),
- ('Full Long (-f -l)', '-l -f', 3),
- ('Session and group ID (-j)', '-j', 0),
- ('Scheduler properties (-c)', '-c', 0),
- ]
- def kill(self, selected):
- c = self.format_list[self.format.get()][2]
- pid = split(selected)[c]
- os.system('kill -9 ' + pid)
- self.do_update()
- def do_update(self):
- format = self.format_list[self.format.get()][1]
- view = self.view_list[self.view.get()][1]
- s = commands.getoutput('ps %s %s' % (view, format))
- list = splitfields(s, '\n')
- self.header.set(list[0] + ' ')
- del list[0]
- self.frame.list.delete(0, AtEnd())
- for line in list:
- self.frame.list.insert(0, line)
- def do_motion(self, e):
- e.widget.select_clear('0', 'end')
- e.widget.select_set(e.widget.nearest(e.y))
- def do_leave(self, e):
- e.widget.select_clear('0', 'end')
- def do_1(self, e):
- self.kill(e.widget.get(e.widget.nearest(e.y)))
- def __init__(self, master=None, **cnf):
- apply(Frame.__init__, (self, master), cnf)
- self.pack(expand=1, fill=BOTH)
- self.bar = Frame(self, name='bar', relief=RAISED,
- borderwidth=2)
- self.bar.pack(fill=X)
- self.bar.file = BarButton(self.bar, text='File')
- self.bar.file.menu.add_command(
- label='Quit', command=self.quit)
- self.bar.view = BarButton(self.bar, text='View')
- self.bar.format = BarButton(self.bar, text='Format')
- self.view = IntVar(self)
- self.view.set(0)
- self.format = IntVar(self)
- self.format.set(0)
- for num in range(len(self.view_list)):
- label, option = self.view_list[num]
- self.bar.view.menu.add_radiobutton(
- label=label,
- command=self.do_update,
- variable=self.view,
- value=num)
- for num in range(len(self.format_list)):
- label, option, col = self.format_list[num]
- self.bar.format.menu.add_radiobutton(
- label=label,
- command=self.do_update,
- variable=self.format,
- value=num)
- self.bar.tk_menuBar(self.bar.file,
- self.bar.view,
- self.bar.format)
- self.frame = Frame(self, relief=RAISED, borderwidth=2)
- self.frame.pack(expand=1, fill=BOTH)
- self.header = StringVar(self)
- self.frame.label = Label(
- self.frame, relief=FLAT, anchor=NW, borderwidth=0,
- font='*-Courier-Bold-R-Normal-*-120-*',
- textvariable=self.header)
- self.frame.label.pack(fill=Y, anchor=W)
- self.frame.vscroll = Scrollbar(self.frame, orient=VERTICAL)
- self.frame.list = Listbox(
- self.frame,
- relief=SUNKEN,
- font='*-Courier-Medium-R-Normal-*-120-*',
- width=40, height=10,
- selectbackground='#eed5b7',
- selectborderwidth=0,
- selectmode=BROWSE,
- yscroll=self.frame.vscroll.set)
- self.frame.vscroll['command'] = self.frame.list.yview
- self.frame.vscroll.pack(side=RIGHT, fill=Y)
- self.frame.list.pack(expand=1, fill=BOTH)
- self.update = Button(self, text='Update',
- command=self.do_update)
- self.update.pack(fill=X)
- self.frame.list.bind('<Motion>', self.do_motion)
- self.frame.list.bind('<Leave>', self.do_leave)
- self.frame.list.bind('<1>', self.do_1)
- self.do_update()
+ # List of (name, option, pid_column)
+ view_list = [
+ ('Default', ''),
+ ('Every (-e)', '-e'),
+ ('Non process group leaders (-d)', '-d'),
+ ('Non leaders with tty (-a)', '-a'),
+ ('For this user (-u %s)' % user, '-u %s' % user),
+ ]
+ format_list = [
+ ('Default', '', 0),
+ ('Long (-l)', '-l', 3),
+ ('Full (-f)', '-f', 1),
+ ('Full Long (-f -l)', '-l -f', 3),
+ ('Session and group ID (-j)', '-j', 0),
+ ('Scheduler properties (-c)', '-c', 0),
+ ]
+ def kill(self, selected):
+ c = self.format_list[self.format.get()][2]
+ pid = split(selected)[c]
+ os.system('kill -9 ' + pid)
+ self.do_update()
+ def do_update(self):
+ format = self.format_list[self.format.get()][1]
+ view = self.view_list[self.view.get()][1]
+ s = commands.getoutput('ps %s %s' % (view, format))
+ list = splitfields(s, '\n')
+ self.header.set(list[0] + ' ')
+ del list[0]
+ self.frame.list.delete(0, AtEnd())
+ for line in list:
+ self.frame.list.insert(0, line)
+ def do_motion(self, e):
+ e.widget.select_clear('0', 'end')
+ e.widget.select_set(e.widget.nearest(e.y))
+ def do_leave(self, e):
+ e.widget.select_clear('0', 'end')
+ def do_1(self, e):
+ self.kill(e.widget.get(e.widget.nearest(e.y)))
+ def __init__(self, master=None, **cnf):
+ apply(Frame.__init__, (self, master), cnf)
+ self.pack(expand=1, fill=BOTH)
+ self.bar = Frame(self, name='bar', relief=RAISED,
+ borderwidth=2)
+ self.bar.pack(fill=X)
+ self.bar.file = BarButton(self.bar, text='File')
+ self.bar.file.menu.add_command(
+ label='Quit', command=self.quit)
+ self.bar.view = BarButton(self.bar, text='View')
+ self.bar.format = BarButton(self.bar, text='Format')
+ self.view = IntVar(self)
+ self.view.set(0)
+ self.format = IntVar(self)
+ self.format.set(0)
+ for num in range(len(self.view_list)):
+ label, option = self.view_list[num]
+ self.bar.view.menu.add_radiobutton(
+ label=label,
+ command=self.do_update,
+ variable=self.view,
+ value=num)
+ for num in range(len(self.format_list)):
+ label, option, col = self.format_list[num]
+ self.bar.format.menu.add_radiobutton(
+ label=label,
+ command=self.do_update,
+ variable=self.format,
+ value=num)
+ self.bar.tk_menuBar(self.bar.file,
+ self.bar.view,
+ self.bar.format)
+ self.frame = Frame(self, relief=RAISED, borderwidth=2)
+ self.frame.pack(expand=1, fill=BOTH)
+ self.header = StringVar(self)
+ self.frame.label = Label(
+ self.frame, relief=FLAT, anchor=NW, borderwidth=0,
+ font='*-Courier-Bold-R-Normal-*-120-*',
+ textvariable=self.header)
+ self.frame.label.pack(fill=Y, anchor=W)
+ self.frame.vscroll = Scrollbar(self.frame, orient=VERTICAL)
+ self.frame.list = Listbox(
+ self.frame,
+ relief=SUNKEN,
+ font='*-Courier-Medium-R-Normal-*-120-*',
+ width=40, height=10,
+ selectbackground='#eed5b7',
+ selectborderwidth=0,
+ selectmode=BROWSE,
+ yscroll=self.frame.vscroll.set)
+ self.frame.vscroll['command'] = self.frame.list.yview
+ self.frame.vscroll.pack(side=RIGHT, fill=Y)
+ self.frame.list.pack(expand=1, fill=BOTH)
+ self.update = Button(self, text='Update',
+ command=self.do_update)
+ self.update.pack(fill=X)
+ self.frame.list.bind('<Motion>', self.do_motion)
+ self.frame.list.bind('<Leave>', self.do_leave)
+ self.frame.list.bind('<1>', self.do_1)
+ self.do_update()
if __name__ == '__main__':
- kill = Kill(None, borderwidth=5)
- kill.winfo_toplevel().title('Tkinter Process Killer (SYSV)')
- kill.winfo_toplevel().minsize(1, 1)
- kill.mainloop()
+ kill = Kill(None, borderwidth=5)
+ kill.winfo_toplevel().title('Tkinter Process Killer (SYSV)')
+ kill.winfo_toplevel().minsize(1, 1)
+ kill.mainloop()
diff --git a/Demo/tkinter/guido/tkman.py b/Demo/tkinter/guido/tkman.py
index 84672fc..11d9690 100755
--- a/Demo/tkinter/guido/tkman.py
+++ b/Demo/tkinter/guido/tkman.py
@@ -15,253 +15,253 @@
foundmanndir = 0
for dir in MANNDIRLIST:
if os.path.exists(dir):
- MANNDIR = dir
- foundmanndir = 1
+ MANNDIR = dir
+ foundmanndir = 1
foundman3dir = 0
for dir in MAN3DIRLIST:
if os.path.exists(dir):
- MAN3DIR = dir
- foundman3dir = 1
+ MAN3DIR = dir
+ foundman3dir = 1
if not foundmanndir or not foundman3dir:
sys.stderr.write('\n')
if not foundmanndir:
- msg = """\
+ msg = """\
Failed to find mann directory.
-Please add the correct entry to the MANNDIRLIST
+Please add the correct entry to the MANNDIRLIST
at the top of %s script.""" % \
sys.argv[0]
- sys.stderr.write("%s\n\n" % msg)
+ sys.stderr.write("%s\n\n" % msg)
if not foundman3dir:
- msg = """\
+ msg = """\
Failed to find man3 directory.
-Please add the correct entry to the MAN3DIRLIST
+Please add the correct entry to the MAN3DIRLIST
at the top of %s script.""" % \
sys.argv[0]
- sys.stderr.write("%s\n\n" % msg)
+ sys.stderr.write("%s\n\n" % msg)
sys.exit(1)
del foundmanndir
del foundman3dir
def listmanpages(mandir):
- files = os.listdir(mandir)
- names = []
- for file in files:
- if file[-2:-1] == '.' and (file[-1] in 'ln123456789'):
- names.append(file[:-2])
- names.sort()
- return names
+ files = os.listdir(mandir)
+ names = []
+ for file in files:
+ if file[-2:-1] == '.' and (file[-1] in 'ln123456789'):
+ names.append(file[:-2])
+ names.sort()
+ return names
class SelectionBox:
- def __init__(self, master=None):
- self.choices = []
+ def __init__(self, master=None):
+ self.choices = []
- self.frame = Frame(master, name="frame")
- self.frame.pack(expand=1, fill=BOTH)
- self.master = self.frame.master
- self.subframe = Frame(self.frame, name="subframe")
- self.subframe.pack(expand=0, fill=BOTH)
- self.leftsubframe = Frame(self.subframe, name='leftsubframe')
- self.leftsubframe.pack(side=LEFT, expand=1, fill=BOTH)
- self.rightsubframe = Frame(self.subframe, name='rightsubframe')
- self.rightsubframe.pack(side=RIGHT, expand=1, fill=BOTH)
- self.chaptervar = StringVar(master)
- self.chapter = Menubutton(self.rightsubframe, name='chapter',
- text='Directory', relief=RAISED,
- borderwidth=2)
- self.chapter.pack(side=TOP)
- self.chaptermenu = Menu(self.chapter, name='chaptermenu')
- self.chaptermenu.add_radiobutton(label='C functions',
- value=MAN3DIR,
- variable=self.chaptervar,
- command=self.newchapter)
- self.chaptermenu.add_radiobutton(label='Tcl/Tk functions',
- value=MANNDIR,
- variable=self.chaptervar,
- command=self.newchapter)
- self.chapter['menu'] = self.chaptermenu
- self.listbox = Listbox(self.rightsubframe, name='listbox',
- relief=SUNKEN, borderwidth=2,
- width=20, height=5)
- self.listbox.pack(expand=1, fill=BOTH)
- self.l1 = Button(self.leftsubframe, name='l1',
- text='Display manual page named:',
- command=self.entry_cb)
- self.l1.pack(side=TOP)
- self.entry = Entry(self.leftsubframe, name='entry',
- relief=SUNKEN, borderwidth=2,
- width=20)
- self.entry.pack(expand=0, fill=X)
- self.l2frame = Frame(self.leftsubframe, name='l2frame')
- self.l2frame.pack(expand=0, fill=NONE)
- self.l2 = Button(self.l2frame, name='l2',
- text='Search regexp:',
- command=self.search_cb)
- self.l2.pack(side=LEFT)
- self.casevar = BooleanVar()
- self.casesense = Checkbutton(self.l2frame, name='casesense',
- text='Case sensitive',
- variable=self.casevar,
- relief=FLAT)
- self.casesense.pack(side=LEFT)
- self.search = Entry(self.leftsubframe, name='search',
- relief=SUNKEN, borderwidth=2,
- width=20)
- self.search.pack(expand=0, fill=X)
- self.title = Label(self.leftsubframe, name='title',
- text='(none)')
- self.title.pack(side=BOTTOM)
- self.text = ManPage(self.frame, name='text',
- relief=SUNKEN, borderwidth=2,
- wrap=NONE, width=72,
- selectbackground='pink')
- self.text.pack(expand=1, fill=BOTH)
+ self.frame = Frame(master, name="frame")
+ self.frame.pack(expand=1, fill=BOTH)
+ self.master = self.frame.master
+ self.subframe = Frame(self.frame, name="subframe")
+ self.subframe.pack(expand=0, fill=BOTH)
+ self.leftsubframe = Frame(self.subframe, name='leftsubframe')
+ self.leftsubframe.pack(side=LEFT, expand=1, fill=BOTH)
+ self.rightsubframe = Frame(self.subframe, name='rightsubframe')
+ self.rightsubframe.pack(side=RIGHT, expand=1, fill=BOTH)
+ self.chaptervar = StringVar(master)
+ self.chapter = Menubutton(self.rightsubframe, name='chapter',
+ text='Directory', relief=RAISED,
+ borderwidth=2)
+ self.chapter.pack(side=TOP)
+ self.chaptermenu = Menu(self.chapter, name='chaptermenu')
+ self.chaptermenu.add_radiobutton(label='C functions',
+ value=MAN3DIR,
+ variable=self.chaptervar,
+ command=self.newchapter)
+ self.chaptermenu.add_radiobutton(label='Tcl/Tk functions',
+ value=MANNDIR,
+ variable=self.chaptervar,
+ command=self.newchapter)
+ self.chapter['menu'] = self.chaptermenu
+ self.listbox = Listbox(self.rightsubframe, name='listbox',
+ relief=SUNKEN, borderwidth=2,
+ width=20, height=5)
+ self.listbox.pack(expand=1, fill=BOTH)
+ self.l1 = Button(self.leftsubframe, name='l1',
+ text='Display manual page named:',
+ command=self.entry_cb)
+ self.l1.pack(side=TOP)
+ self.entry = Entry(self.leftsubframe, name='entry',
+ relief=SUNKEN, borderwidth=2,
+ width=20)
+ self.entry.pack(expand=0, fill=X)
+ self.l2frame = Frame(self.leftsubframe, name='l2frame')
+ self.l2frame.pack(expand=0, fill=NONE)
+ self.l2 = Button(self.l2frame, name='l2',
+ text='Search regexp:',
+ command=self.search_cb)
+ self.l2.pack(side=LEFT)
+ self.casevar = BooleanVar()
+ self.casesense = Checkbutton(self.l2frame, name='casesense',
+ text='Case sensitive',
+ variable=self.casevar,
+ relief=FLAT)
+ self.casesense.pack(side=LEFT)
+ self.search = Entry(self.leftsubframe, name='search',
+ relief=SUNKEN, borderwidth=2,
+ width=20)
+ self.search.pack(expand=0, fill=X)
+ self.title = Label(self.leftsubframe, name='title',
+ text='(none)')
+ self.title.pack(side=BOTTOM)
+ self.text = ManPage(self.frame, name='text',
+ relief=SUNKEN, borderwidth=2,
+ wrap=NONE, width=72,
+ selectbackground='pink')
+ self.text.pack(expand=1, fill=BOTH)
- self.entry.bind('<Return>', self.entry_cb)
- self.search.bind('<Return>', self.search_cb)
- self.listbox.bind('<Double-1>', self.listbox_cb)
+ self.entry.bind('<Return>', self.entry_cb)
+ self.search.bind('<Return>', self.search_cb)
+ self.listbox.bind('<Double-1>', self.listbox_cb)
- self.entry.bind('<Tab>', self.entry_tab)
- self.search.bind('<Tab>', self.search_tab)
- self.text.bind('<Tab>', self.text_tab)
+ self.entry.bind('<Tab>', self.entry_tab)
+ self.search.bind('<Tab>', self.search_tab)
+ self.text.bind('<Tab>', self.text_tab)
- self.entry.focus_set()
+ self.entry.focus_set()
- self.chaptervar.set(MANNDIR)
- self.newchapter()
+ self.chaptervar.set(MANNDIR)
+ self.newchapter()
- def newchapter(self):
- mandir = self.chaptervar.get()
- self.choices = []
- self.addlist(listmanpages(mandir))
+ def newchapter(self):
+ mandir = self.chaptervar.get()
+ self.choices = []
+ self.addlist(listmanpages(mandir))
- def addchoice(self, choice):
- if choice not in self.choices:
- self.choices.append(choice)
- self.choices.sort()
- self.update()
+ def addchoice(self, choice):
+ if choice not in self.choices:
+ self.choices.append(choice)
+ self.choices.sort()
+ self.update()
- def addlist(self, list):
- self.choices[len(self.choices):] = list
- self.choices.sort()
- self.update()
+ def addlist(self, list):
+ self.choices[len(self.choices):] = list
+ self.choices.sort()
+ self.update()
- def entry_cb(self, *e):
- self.update()
+ def entry_cb(self, *e):
+ self.update()
- def listbox_cb(self, e):
- selection = self.listbox.curselection()
- if selection and len(selection) == 1:
- name = self.listbox.get(selection[0])
- self.show_page(name)
+ def listbox_cb(self, e):
+ selection = self.listbox.curselection()
+ if selection and len(selection) == 1:
+ name = self.listbox.get(selection[0])
+ self.show_page(name)
- def search_cb(self, *e):
- self.search_string(self.search.get())
+ def search_cb(self, *e):
+ self.search_string(self.search.get())
- def entry_tab(self, e):
- self.search.focus_set()
+ def entry_tab(self, e):
+ self.search.focus_set()
- def search_tab(self, e):
- self.entry.focus_set()
+ def search_tab(self, e):
+ self.entry.focus_set()
- def text_tab(self, e):
- self.entry.focus_set()
+ def text_tab(self, e):
+ self.entry.focus_set()
- def updatelist(self):
- key = self.entry.get()
- ok = filter(lambda name, key=key, n=len(key): name[:n]==key,
- self.choices)
- if not ok:
- self.frame.bell()
- self.listbox.delete(0, AtEnd())
- exactmatch = 0
- for item in ok:
- if item == key: exactmatch = 1
- self.listbox.insert(AtEnd(), item)
- if exactmatch:
- return key
- n = self.listbox.size()
- if n == 1:
- return self.listbox.get(0)
- # Else return None, meaning not a unique selection
+ def updatelist(self):
+ key = self.entry.get()
+ ok = filter(lambda name, key=key, n=len(key): name[:n]==key,
+ self.choices)
+ if not ok:
+ self.frame.bell()
+ self.listbox.delete(0, AtEnd())
+ exactmatch = 0
+ for item in ok:
+ if item == key: exactmatch = 1
+ self.listbox.insert(AtEnd(), item)
+ if exactmatch:
+ return key
+ n = self.listbox.size()
+ if n == 1:
+ return self.listbox.get(0)
+ # Else return None, meaning not a unique selection
- def update(self):
- name = self.updatelist()
- if name:
- self.show_page(name)
- self.entry.delete(0, AtEnd())
- self.updatelist()
+ def update(self):
+ name = self.updatelist()
+ if name:
+ self.show_page(name)
+ self.entry.delete(0, AtEnd())
+ self.updatelist()
- def show_page(self, name):
- file = '%s/%s.?' % (self.chaptervar.get(), name)
- fp = os.popen('nroff -man %s | ul -i' % file, 'r')
- self.text.kill()
- self.title['text'] = name
- self.text.parsefile(fp)
+ def show_page(self, name):
+ file = '%s/%s.?' % (self.chaptervar.get(), name)
+ fp = os.popen('nroff -man %s | ul -i' % file, 'r')
+ self.text.kill()
+ self.title['text'] = name
+ self.text.parsefile(fp)
- def search_string(self, search):
- if not search:
- self.frame.bell()
- print 'Empty search string'
- return
- if not self.casevar.get():
- map = regex.casefold
- else:
- map = None
- try:
- if map:
- prog = regex.compile(search, map)
- else:
- prog = regex.compile(search)
- except regex.error, msg:
- self.frame.bell()
- print 'Regex error:', msg
- return
- here = self.text.index(AtInsert())
- lineno = string.atoi(here[:string.find(here, '.')])
- end = self.text.index(AtEnd())
- endlineno = string.atoi(end[:string.find(end, '.')])
- wraplineno = lineno
- found = 0
- while 1:
- lineno = lineno + 1
- if lineno > endlineno:
- if wraplineno <= 0:
- break
- endlineno = wraplineno
- lineno = 0
- wraplineno = 0
- line = self.text.get('%d.0 linestart' % lineno,
- '%d.0 lineend' % lineno)
- i = prog.search(line)
- if i >= 0:
- found = 1
- n = max(1, len(prog.group(0)))
- try:
- self.text.tag_remove('sel',
- AtSelFirst(),
- AtSelLast())
- except TclError:
- pass
- self.text.tag_add('sel',
- '%d.%d' % (lineno, i),
- '%d.%d' % (lineno, i+n))
- self.text.mark_set(AtInsert(),
- '%d.%d' % (lineno, i))
- self.text.yview_pickplace(AtInsert())
- break
- if not found:
- self.frame.bell()
+ def search_string(self, search):
+ if not search:
+ self.frame.bell()
+ print 'Empty search string'
+ return
+ if not self.casevar.get():
+ map = regex.casefold
+ else:
+ map = None
+ try:
+ if map:
+ prog = regex.compile(search, map)
+ else:
+ prog = regex.compile(search)
+ except regex.error, msg:
+ self.frame.bell()
+ print 'Regex error:', msg
+ return
+ here = self.text.index(AtInsert())
+ lineno = string.atoi(here[:string.find(here, '.')])
+ end = self.text.index(AtEnd())
+ endlineno = string.atoi(end[:string.find(end, '.')])
+ wraplineno = lineno
+ found = 0
+ while 1:
+ lineno = lineno + 1
+ if lineno > endlineno:
+ if wraplineno <= 0:
+ break
+ endlineno = wraplineno
+ lineno = 0
+ wraplineno = 0
+ line = self.text.get('%d.0 linestart' % lineno,
+ '%d.0 lineend' % lineno)
+ i = prog.search(line)
+ if i >= 0:
+ found = 1
+ n = max(1, len(prog.group(0)))
+ try:
+ self.text.tag_remove('sel',
+ AtSelFirst(),
+ AtSelLast())
+ except TclError:
+ pass
+ self.text.tag_add('sel',
+ '%d.%d' % (lineno, i),
+ '%d.%d' % (lineno, i+n))
+ self.text.mark_set(AtInsert(),
+ '%d.%d' % (lineno, i))
+ self.text.yview_pickplace(AtInsert())
+ break
+ if not found:
+ self.frame.bell()
def main():
- root = Tk()
- sb = SelectionBox(root)
- if sys.argv[1:]:
- sb.show_page(sys.argv[1])
- root.minsize(1, 1)
- root.mainloop()
+ root = Tk()
+ sb = SelectionBox(root)
+ if sys.argv[1:]:
+ sb.show_page(sys.argv[1])
+ root.minsize(1, 1)
+ root.mainloop()
main()
diff --git a/Demo/tkinter/guido/wish.py b/Demo/tkinter/guido/wish.py
index 4f6fdee..0a61ad8 100755
--- a/Demo/tkinter/guido/wish.py
+++ b/Demo/tkinter/guido/wish.py
@@ -9,19 +9,19 @@
cmd = ''
while 1:
- if cmd: prompt = ''
- else: prompt = '% '
- try:
- line = raw_input(prompt)
- except EOFError:
- break
- cmd = cmd + (line + '\n')
- if tk.getboolean(tk.call('info', 'complete', cmd)):
- tk.record(line)
- try:
- result = tk.call('eval', cmd)
- except _tkinter.TclError, msg:
- print 'TclError:', msg
- else:
- if result: print result
- cmd = ''
+ if cmd: prompt = ''
+ else: prompt = '% '
+ try:
+ line = raw_input(prompt)
+ except EOFError:
+ break
+ cmd = cmd + (line + '\n')
+ if tk.getboolean(tk.call('info', 'complete', cmd)):
+ tk.record(line)
+ try:
+ result = tk.call('eval', cmd)
+ except _tkinter.TclError, msg:
+ print 'TclError:', msg
+ else:
+ if result: print result
+ cmd = ''
diff --git a/Demo/tkinter/matt/00-HELLO-WORLD.py b/Demo/tkinter/matt/00-HELLO-WORLD.py
index a32941b..1c3151b 100644
--- a/Demo/tkinter/matt/00-HELLO-WORLD.py
+++ b/Demo/tkinter/matt/00-HELLO-WORLD.py
@@ -1,27 +1,27 @@
from Tkinter import *
-# note that there is no explicit call to start Tk.
-# Tkinter is smart enough to start the system if it's not already going.
+# note that there is no explicit call to start Tk.
+# Tkinter is smart enough to start the system if it's not already going.
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
-
- self.QUIT.pack(side=LEFT, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
- # a hello button
- self.hi_there = Button(self, text='Hello',
- command=self.printit)
- self.hi_there.pack(side=LEFT)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
+
+ # a hello button
+ self.hi_there = Button(self, text='Hello',
+ command=self.printit)
+ self.hi_there.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
test.mainloop()
diff --git a/Demo/tkinter/matt/animation-simple.py b/Demo/tkinter/matt/animation-simple.py
index 435d6fa..b52e1dc 100644
--- a/Demo/tkinter/matt/animation-simple.py
+++ b/Demo/tkinter/matt/animation-simple.py
@@ -4,30 +4,30 @@
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=LEFT, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
- self.draw = Canvas(self, width="5i", height="5i")
+ self.draw = Canvas(self, width="5i", height="5i")
- # all of these work..
- self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
- self.draw.pack(side=LEFT)
+ # all of these work..
+ self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
+ self.draw.pack(side=LEFT)
def moveThing(self, *args):
- # move 1/10 of an inch every 1/10 sec (1" per second, smoothly)
- self.draw.move("thing", "0.01i", "0.01i")
- self.after(10, self.moveThing)
+ # move 1/10 of an inch every 1/10 sec (1" per second, smoothly)
+ self.draw.move("thing", "0.01i", "0.01i")
+ self.after(10, self.moveThing)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
- self.after(10, self.moveThing)
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
+ self.after(10, self.moveThing)
test = Test()
diff --git a/Demo/tkinter/matt/animation-w-velocity-ctrl.py b/Demo/tkinter/matt/animation-w-velocity-ctrl.py
index f3332f2..e676338 100644
--- a/Demo/tkinter/matt/animation-w-velocity-ctrl.py
+++ b/Demo/tkinter/matt/animation-w-velocity-ctrl.py
@@ -1,42 +1,42 @@
from Tkinter import *
-# this is the same as simple-demo-1.py, but uses
-# subclassing.
-# note that there is no explicit call to start Tk.
-# Tkinter is smart enough to start the system if it's not already going.
+# this is the same as simple-demo-1.py, but uses
+# subclassing.
+# note that there is no explicit call to start Tk.
+# Tkinter is smart enough to start the system if it's not already going.
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=BOTTOM, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=BOTTOM, fill=BOTH)
- self.draw = Canvas(self, width="5i", height="5i")
+ self.draw = Canvas(self, width="5i", height="5i")
- self.speed = Scale(self, orient=HORIZONTAL, from_=-100, to=100)
+ self.speed = Scale(self, orient=HORIZONTAL, from_=-100, to=100)
- self.speed.pack(side=BOTTOM, fill=X)
+ self.speed.pack(side=BOTTOM, fill=X)
- # all of these work..
- self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
- self.draw.pack(side=LEFT)
+ # all of these work..
+ self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
+ self.draw.pack(side=LEFT)
def moveThing(self, *args):
- velocity = self.speed.get()
- str = float(velocity) / 1000.0
- str = "%ri" % (str,)
- self.draw.move("thing", str, str)
- self.after(10, self.moveThing)
+ velocity = self.speed.get()
+ str = float(velocity) / 1000.0
+ str = "%ri" % (str,)
+ self.draw.move("thing", str, str)
+ self.after(10, self.moveThing)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
- self.after(10, self.moveThing)
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
+ self.after(10, self.moveThing)
test = Test()
diff --git a/Demo/tkinter/matt/bind-w-mult-calls-p-type.py b/Demo/tkinter/matt/bind-w-mult-calls-p-type.py
index 0907e41..f3220da 100644
--- a/Demo/tkinter/matt/bind-w-mult-calls-p-type.py
+++ b/Demo/tkinter/matt/bind-w-mult-calls-p-type.py
@@ -1,34 +1,34 @@
from Tkinter import *
-import string
+import string
# This program shows how to use a simple type-in box
class App(Frame):
def __init__(self, master=None):
- Frame.__init__(self, master)
- self.pack()
+ Frame.__init__(self, master)
+ self.pack()
- self.entrythingy = Entry()
- self.entrythingy.pack()
+ self.entrythingy = Entry()
+ self.entrythingy.pack()
- # and here we get a callback when the user hits return. we could
- # make the key that triggers the callback anything we wanted to.
- # other typical options might be <Key-Tab> or <Key> (for anything)
- self.entrythingy.bind('<Key-Return>', self.print_contents)
+ # and here we get a callback when the user hits return. we could
+ # make the key that triggers the callback anything we wanted to.
+ # other typical options might be <Key-Tab> or <Key> (for anything)
+ self.entrythingy.bind('<Key-Return>', self.print_contents)
- # Note that here is where we bind a completely different callback to
- # the same event. We pass "+" here to indicate that we wish to ADD
- # this callback to the list associated with this event type.
- # Not specifying "+" would simply override whatever callback was
- # defined on this event.
- self.entrythingy.bind('<Key-Return>', self.print_something_else, "+")
+ # Note that here is where we bind a completely different callback to
+ # the same event. We pass "+" here to indicate that we wish to ADD
+ # this callback to the list associated with this event type.
+ # Not specifying "+" would simply override whatever callback was
+ # defined on this event.
+ self.entrythingy.bind('<Key-Return>', self.print_something_else, "+")
def print_contents(self, event):
- print "hi. contents of entry is now ---->", self.entrythingy.get()
+ print "hi. contents of entry is now ---->", self.entrythingy.get()
def print_something_else(self, event):
- print "hi. Now doing something completely different"
+ print "hi. Now doing something completely different"
root = App()
@@ -37,8 +37,8 @@
-# secret tip for experts: if you pass *any* non-false value as
-# the third parameter to bind(), Tkinter.py will accumulate
+# secret tip for experts: if you pass *any* non-false value as
+# the third parameter to bind(), Tkinter.py will accumulate
# callbacks instead of overwriting. I use "+" here because that's
-# the Tk notation for getting this sort of behavior. The perfect GUI
+# the Tk notation for getting this sort of behavior. The perfect GUI
# interface would use a less obscure notation.
diff --git a/Demo/tkinter/matt/canvas-demo-simple.py b/Demo/tkinter/matt/canvas-demo-simple.py
index d989626..a01679a 100644
--- a/Demo/tkinter/matt/canvas-demo-simple.py
+++ b/Demo/tkinter/matt/canvas-demo-simple.py
@@ -4,24 +4,24 @@
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=BOTTOM, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=BOTTOM, fill=BOTH)
- self.draw = Canvas(self, width="5i", height="5i")
+ self.draw = Canvas(self, width="5i", height="5i")
- # see the other demos for other ways of specifying coords for a polygon
- self.draw.create_rectangle(0, 0, "3i", "3i", fill="black")
+ # see the other demos for other ways of specifying coords for a polygon
+ self.draw.create_rectangle(0, 0, "3i", "3i", fill="black")
- self.draw.pack(side=LEFT)
+ self.draw.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
diff --git a/Demo/tkinter/matt/canvas-gridding.py b/Demo/tkinter/matt/canvas-gridding.py
index b200ea4..3c52b91 100644
--- a/Demo/tkinter/matt/canvas-gridding.py
+++ b/Demo/tkinter/matt/canvas-gridding.py
@@ -1,60 +1,60 @@
from Tkinter import *
-# this is the same as simple-demo-1.py, but uses
-# subclassing.
-# note that there is no explicit call to start Tk.
-# Tkinter is smart enough to start the system if it's not already going.
+# this is the same as simple-demo-1.py, but uses
+# subclassing.
+# note that there is no explicit call to start Tk.
+# Tkinter is smart enough to start the system if it's not already going.
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT',
- background='red',
- foreground='white',
- height=3,
- command=self.quit)
- self.QUIT.pack(side=BOTTOM, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT',
+ background='red',
+ foreground='white',
+ height=3,
+ command=self.quit)
+ self.QUIT.pack(side=BOTTOM, fill=BOTH)
- self.canvasObject = Canvas(self, width="5i", height="5i")
- self.canvasObject.pack(side=LEFT)
+ self.canvasObject = Canvas(self, width="5i", height="5i")
+ self.canvasObject.pack(side=LEFT)
def mouseDown(self, event):
- # canvas x and y take the screen coords from the event and translate
- # them into the coordinate system of the canvas object
- self.startx = self.canvasObject.canvasx(event.x, self.griddingSize)
- self.starty = self.canvasObject.canvasy(event.y, self.griddingSize)
+ # canvas x and y take the screen coords from the event and translate
+ # them into the coordinate system of the canvas object
+ self.startx = self.canvasObject.canvasx(event.x, self.griddingSize)
+ self.starty = self.canvasObject.canvasy(event.y, self.griddingSize)
def mouseMotion(self, event):
- # canvas x and y take the screen coords from the event and translate
- # them into the coordinate system of the canvas object
- x = self.canvasObject.canvasx(event.x, self.griddingSize)
- y = self.canvasObject.canvasy(event.y, self.griddingSize)
+ # canvas x and y take the screen coords from the event and translate
+ # them into the coordinate system of the canvas object
+ x = self.canvasObject.canvasx(event.x, self.griddingSize)
+ y = self.canvasObject.canvasy(event.y, self.griddingSize)
- if (self.startx != event.x) and (self.starty != event.y) :
- self.canvasObject.delete(self.rubberbandBox)
- self.rubberbandBox = self.canvasObject.create_rectangle(
- self.startx, self.starty, x, y)
- # this flushes the output, making sure that
- # the rectangle makes it to the screen
- # before the next event is handled
- self.update_idletasks()
+ if (self.startx != event.x) and (self.starty != event.y) :
+ self.canvasObject.delete(self.rubberbandBox)
+ self.rubberbandBox = self.canvasObject.create_rectangle(
+ self.startx, self.starty, x, y)
+ # this flushes the output, making sure that
+ # the rectangle makes it to the screen
+ # before the next event is handled
+ self.update_idletasks()
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
- # this is a "tagOrId" for the rectangle we draw on the canvas
- self.rubberbandBox = None
+ # this is a "tagOrId" for the rectangle we draw on the canvas
+ self.rubberbandBox = None
- # this is the size of the gridding squares
- self.griddingSize = 50
+ # this is the size of the gridding squares
+ self.griddingSize = 50
- Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
- Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
-
+ Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
+ Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
+
test = Test()
diff --git a/Demo/tkinter/matt/canvas-moving-or-creating.py b/Demo/tkinter/matt/canvas-moving-or-creating.py
index 74729a6..5327c08 100644
--- a/Demo/tkinter/matt/canvas-moving-or-creating.py
+++ b/Demo/tkinter/matt/canvas-moving-or-creating.py
@@ -1,6 +1,6 @@
from Tkinter import *
-# this file demonstrates a more sophisticated movement --
+# this file demonstrates a more sophisticated movement --
# move dots or create new ones if you click outside the dots
class Test(Frame):
@@ -8,58 +8,55 @@
###### Event callbacks for THE CANVAS (not the stuff drawn on it)
###################################################################
def mouseDown(self, event):
- # see if we're inside a dot. If we are, it
- # gets tagged as CURRENT for free by tk.
- if not event.widget.find_withtag(CURRENT):
- # there is no dot here, so we can make one,
- # and bind some interesting behavior to it.
- # ------
- # create a dot, and mark it as CURRENT
- fred = self.draw.create_oval(
- event.x - 10, event.y -10, event.x +10, event.y + 10,
- fill="green", tags=CURRENT)
+ # see if we're inside a dot. If we are, it
+ # gets tagged as CURRENT for free by tk.
+ if not event.widget.find_withtag(CURRENT):
+ # there is no dot here, so we can make one,
+ # and bind some interesting behavior to it.
+ # ------
+ # create a dot, and mark it as CURRENT
+ fred = self.draw.create_oval(
+ event.x - 10, event.y -10, event.x +10, event.y + 10,
+ fill="green", tags=CURRENT)
- self.draw.tag_bind(fred, "<Any-Enter>", self.mouseEnter)
- self.draw.tag_bind(fred, "<Any-Leave>", self.mouseLeave)
+ self.draw.tag_bind(fred, "<Any-Enter>", self.mouseEnter)
+ self.draw.tag_bind(fred, "<Any-Leave>", self.mouseLeave)
- self.lastx = event.x
- self.lasty = event.y
+ self.lastx = event.x
+ self.lasty = event.y
def mouseMove(self, event):
- self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
- self.lastx = event.x
- self.lasty = event.y
+ self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
+ self.lastx = event.x
+ self.lasty = event.y
###################################################################
###### Event callbacks for canvas ITEMS (stuff drawn on the canvas)
###################################################################
def mouseEnter(self, event):
# the CURRENT tag is applied to the object the cursor is over.
- # this happens automatically.
- self.draw.itemconfig(CURRENT, fill="red")
+ # this happens automatically.
+ self.draw.itemconfig(CURRENT, fill="red")
def mouseLeave(self, event):
- # the CURRENT tag is applied to the object the cursor is over.
- # this happens automatically.
- self.draw.itemconfig(CURRENT, fill="blue")
+ # the CURRENT tag is applied to the object the cursor is over.
+ # this happens automatically.
+ self.draw.itemconfig(CURRENT, fill="blue")
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=LEFT, fill=BOTH)
- self.draw = Canvas(self, width="5i", height="5i")
- self.draw.pack(side=LEFT)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
+ self.draw = Canvas(self, width="5i", height="5i")
+ self.draw.pack(side=LEFT)
- Widget.bind(self.draw, "<1>", self.mouseDown)
- Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
+ Widget.bind(self.draw, "<1>", self.mouseDown)
+ Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
test.mainloop()
-
-
-
diff --git a/Demo/tkinter/matt/canvas-moving-w-mouse.py b/Demo/tkinter/matt/canvas-moving-w-mouse.py
index 447e290..81785d8 100644
--- a/Demo/tkinter/matt/canvas-moving-w-mouse.py
+++ b/Demo/tkinter/matt/canvas-moving-w-mouse.py
@@ -7,49 +7,49 @@
###### Event callbacks for THE CANVAS (not the stuff drawn on it)
###################################################################
def mouseDown(self, event):
- # remember where the mouse went down
- self.lastx = event.x
- self.lasty = event.y
+ # remember where the mouse went down
+ self.lastx = event.x
+ self.lasty = event.y
def mouseMove(self, event):
- # whatever the mouse is over gets tagged as CURRENT for free by tk.
- self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
- self.lastx = event.x
- self.lasty = event.y
+ # whatever the mouse is over gets tagged as CURRENT for free by tk.
+ self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
+ self.lastx = event.x
+ self.lasty = event.y
###################################################################
###### Event callbacks for canvas ITEMS (stuff drawn on the canvas)
###################################################################
def mouseEnter(self, event):
# the CURRENT tag is applied to the object the cursor is over.
- # this happens automatically.
- self.draw.itemconfig(CURRENT, fill="red")
-
+ # this happens automatically.
+ self.draw.itemconfig(CURRENT, fill="red")
+
def mouseLeave(self, event):
- # the CURRENT tag is applied to the object the cursor is over.
- # this happens automatically.
- self.draw.itemconfig(CURRENT, fill="blue")
+ # the CURRENT tag is applied to the object the cursor is over.
+ # this happens automatically.
+ self.draw.itemconfig(CURRENT, fill="blue")
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=LEFT, fill=BOTH)
- self.draw = Canvas(self, width="5i", height="5i")
- self.draw.pack(side=LEFT)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
+ self.draw = Canvas(self, width="5i", height="5i")
+ self.draw.pack(side=LEFT)
- fred = self.draw.create_oval(0, 0, 20, 20,
- fill="green", tags="selected")
+ fred = self.draw.create_oval(0, 0, 20, 20,
+ fill="green", tags="selected")
- self.draw.tag_bind(fred, "<Any-Enter>", self.mouseEnter)
- self.draw.tag_bind(fred, "<Any-Leave>", self.mouseLeave)
+ self.draw.tag_bind(fred, "<Any-Enter>", self.mouseEnter)
+ self.draw.tag_bind(fred, "<Any-Leave>", self.mouseLeave)
- Widget.bind(self.draw, "<1>", self.mouseDown)
- Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
+ Widget.bind(self.draw, "<1>", self.mouseDown)
+ Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
test.mainloop()
diff --git a/Demo/tkinter/matt/canvas-mult-item-sel.py b/Demo/tkinter/matt/canvas-mult-item-sel.py
index 2368733..a4f267c 100644
--- a/Demo/tkinter/matt/canvas-mult-item-sel.py
+++ b/Demo/tkinter/matt/canvas-mult-item-sel.py
@@ -1,6 +1,6 @@
from Tkinter import *
-# allows moving dots with multiple selection.
+# allows moving dots with multiple selection.
SELECTED_COLOR = "red"
UNSELECTED_COLOR = "blue"
@@ -10,72 +10,69 @@
###### Event callbacks for THE CANVAS (not the stuff drawn on it)
###################################################################
def mouseDown(self, event):
- # see if we're inside a dot. If we are, it
- # gets tagged as CURRENT for free by tk.
+ # see if we're inside a dot. If we are, it
+ # gets tagged as CURRENT for free by tk.
- if not event.widget.find_withtag(CURRENT):
- # we clicked outside of all dots on the canvas. unselect all.
-
- # re-color everything back to an unselected color
- self.draw.itemconfig("selected", fill=UNSELECTED_COLOR)
- # unselect everything
- self.draw.dtag("selected")
- else:
- # mark as "selected" the thing the cursor is under
- self.draw.addtag("selected", "withtag", CURRENT)
- # color it as selected
- self.draw.itemconfig("selected", fill=SELECTED_COLOR)
+ if not event.widget.find_withtag(CURRENT):
+ # we clicked outside of all dots on the canvas. unselect all.
- self.lastx = event.x
- self.lasty = event.y
-
-
+ # re-color everything back to an unselected color
+ self.draw.itemconfig("selected", fill=UNSELECTED_COLOR)
+ # unselect everything
+ self.draw.dtag("selected")
+ else:
+ # mark as "selected" the thing the cursor is under
+ self.draw.addtag("selected", "withtag", CURRENT)
+ # color it as selected
+ self.draw.itemconfig("selected", fill=SELECTED_COLOR)
+
+ self.lastx = event.x
+ self.lasty = event.y
+
+
def mouseMove(self, event):
- self.draw.move("selected", event.x - self.lastx, event.y - self.lasty)
- self.lastx = event.x
- self.lasty = event.y
+ self.draw.move("selected", event.x - self.lastx, event.y - self.lasty)
+ self.lastx = event.x
+ self.lasty = event.y
def makeNewDot(self):
- # create a dot, and mark it as current
- fred = self.draw.create_oval(0, 0, 20, 20,
- fill=SELECTED_COLOR, tags=CURRENT)
- # and make it selected
- self.draw.addtag("selected", "withtag", CURRENT)
-
+ # create a dot, and mark it as current
+ fred = self.draw.create_oval(0, 0, 20, 20,
+ fill=SELECTED_COLOR, tags=CURRENT)
+ # and make it selected
+ self.draw.addtag("selected", "withtag", CURRENT)
+
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
- ################
- # make the canvas and bind some behavior to it
- ################
- self.draw = Canvas(self, width="5i", height="5i")
- Widget.bind(self.draw, "<1>", self.mouseDown)
- Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
+ ################
+ # make the canvas and bind some behavior to it
+ ################
+ self.draw = Canvas(self, width="5i", height="5i")
+ Widget.bind(self.draw, "<1>", self.mouseDown)
+ Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
- # and other things.....
- self.button = Button(self, text="make a new dot", foreground="blue",
- command=self.makeNewDot)
+ # and other things.....
+ self.button = Button(self, text="make a new dot", foreground="blue",
+ command=self.makeNewDot)
- message = ("%s dots are selected and can be dragged.\n"
- "%s are not selected.\n"
- "Click in a dot to select it.\n"
- "Click on empty space to deselect all dots."
- ) % (SELECTED_COLOR, UNSELECTED_COLOR)
- self.label = Message(self, width="5i", text=message)
+ message = ("%s dots are selected and can be dragged.\n"
+ "%s are not selected.\n"
+ "Click in a dot to select it.\n"
+ "Click on empty space to deselect all dots."
+ ) % (SELECTED_COLOR, UNSELECTED_COLOR)
+ self.label = Message(self, width="5i", text=message)
- self.QUIT.pack(side=BOTTOM, fill=BOTH)
- self.label.pack(side=BOTTOM, fill=X, expand=1)
- self.button.pack(side=BOTTOM, fill=X)
- self.draw.pack(side=LEFT)
+ self.QUIT.pack(side=BOTTOM, fill=BOTH)
+ self.label.pack(side=BOTTOM, fill=X, expand=1)
+ self.button.pack(side=BOTTOM, fill=X)
+ self.draw.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
test.mainloop()
-
-
-
diff --git a/Demo/tkinter/matt/canvas-reading-tag-info.py b/Demo/tkinter/matt/canvas-reading-tag-info.py
index 7044691..f57ea18 100644
--- a/Demo/tkinter/matt/canvas-reading-tag-info.py
+++ b/Demo/tkinter/matt/canvas-reading-tag-info.py
@@ -3,46 +3,46 @@
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=BOTTOM, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=BOTTOM, fill=BOTH)
- self.drawing = Canvas(self, width="5i", height="5i")
+ self.drawing = Canvas(self, width="5i", height="5i")
- # make a shape
- pgon = self.drawing.create_polygon(
- 10, 10, 110, 10, 110, 110, 10 , 110,
- fill="red", tags=("weee", "foo", "groo"))
+ # make a shape
+ pgon = self.drawing.create_polygon(
+ 10, 10, 110, 10, 110, 110, 10 , 110,
+ fill="red", tags=("weee", "foo", "groo"))
- # this is how you query an object for its attributes
- # config options FOR CANVAS ITEMS always come back in tuples of length 5.
- # 0 attribute name
- # 1 BLANK
- # 2 BLANK
- # 3 default value
- # 4 current value
- # the blank spots are for consistency with the config command that
- # is used for widgets. (remember, this is for ITEMS drawn
- # on a canvas widget, not widgets)
- option_value = self.drawing.itemconfig(pgon, "stipple")
- print "pgon's current stipple value is -->", option_value[4], "<--"
- option_value = self.drawing.itemconfig(pgon, "fill")
- print "pgon's current fill value is -->", option_value[4], "<--"
- print " when he is usually colored -->", option_value[3], "<--"
+ # this is how you query an object for its attributes
+ # config options FOR CANVAS ITEMS always come back in tuples of length 5.
+ # 0 attribute name
+ # 1 BLANK
+ # 2 BLANK
+ # 3 default value
+ # 4 current value
+ # the blank spots are for consistency with the config command that
+ # is used for widgets. (remember, this is for ITEMS drawn
+ # on a canvas widget, not widgets)
+ option_value = self.drawing.itemconfig(pgon, "stipple")
+ print "pgon's current stipple value is -->", option_value[4], "<--"
+ option_value = self.drawing.itemconfig(pgon, "fill")
+ print "pgon's current fill value is -->", option_value[4], "<--"
+ print " when he is usually colored -->", option_value[3], "<--"
- ## here we print out all the tags associated with this object
- option_value = self.drawing.itemconfig(pgon, "tags")
- print "pgon's tags are", option_value[4]
+ ## here we print out all the tags associated with this object
+ option_value = self.drawing.itemconfig(pgon, "tags")
+ print "pgon's tags are", option_value[4]
- self.drawing.pack(side=LEFT)
+ self.drawing.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
diff --git a/Demo/tkinter/matt/canvas-w-widget-draw-el.py b/Demo/tkinter/matt/canvas-w-widget-draw-el.py
index a1bb3b5..5b26210 100644
--- a/Demo/tkinter/matt/canvas-w-widget-draw-el.py
+++ b/Demo/tkinter/matt/canvas-w-widget-draw-el.py
@@ -4,32 +4,32 @@
class Test(Frame):
def printhi(self):
- print "hi"
+ print "hi"
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=BOTTOM, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=BOTTOM, fill=BOTH)
- self.draw = Canvas(self, width="5i", height="5i")
+ self.draw = Canvas(self, width="5i", height="5i")
- self.button = Button(self, text="this is a button",
- command=self.printhi)
+ self.button = Button(self, text="this is a button",
+ command=self.printhi)
- # note here the coords are given in pixels (form the
- # upper right and corner of the window, as usual for X)
- # but might just have well been given in inches or points or
- # whatever...use the "anchor" option to control what point of the
- # widget (in this case the button) gets mapped to the given x, y.
- # you can specify corners, edges, center, etc...
- self.draw.create_window(300, 300, window=self.button)
+ # note here the coords are given in pixels (form the
+ # upper right and corner of the window, as usual for X)
+ # but might just have well been given in inches or points or
+ # whatever...use the "anchor" option to control what point of the
+ # widget (in this case the button) gets mapped to the given x, y.
+ # you can specify corners, edges, center, etc...
+ self.draw.create_window(300, 300, window=self.button)
- self.draw.pack(side=LEFT)
+ self.draw.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
diff --git a/Demo/tkinter/matt/canvas-with-scrollbars.py b/Demo/tkinter/matt/canvas-with-scrollbars.py
index 60c7b13..81ef25a 100644
--- a/Demo/tkinter/matt/canvas-with-scrollbars.py
+++ b/Demo/tkinter/matt/canvas-with-scrollbars.py
@@ -1,59 +1,59 @@
from Tkinter import *
-# This example program creates a scroling canvas, and demonstrates
+# This example program creates a scroling canvas, and demonstrates
# how to tie scrollbars and canvses together. The mechanism
# is analogus for listboxes and other widgets with
# "xscroll" and "yscroll" configuration options.
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def createWidgets(self):
- self.question = Label(self, text="Can Find The BLUE Square??????")
- self.question.pack()
+ self.question = Label(self, text="Can Find The BLUE Square??????")
+ self.question.pack()
- self.QUIT = Button(self, text='QUIT', background='red',
- height=3, command=self.quit)
- self.QUIT.pack(side=BOTTOM, fill=BOTH)
- spacer = Frame(self, height="0.25i")
- spacer.pack(side=BOTTOM)
+ self.QUIT = Button(self, text='QUIT', background='red',
+ height=3, command=self.quit)
+ self.QUIT.pack(side=BOTTOM, fill=BOTH)
+ spacer = Frame(self, height="0.25i")
+ spacer.pack(side=BOTTOM)
- # notice that the scroll region (20" x 20") is larger than
- # displayed size of the widget (5" x 5")
- self.draw = Canvas(self, width="5i", height="5i",
- background="white",
- scrollregion=(0, 0, "20i", "20i"))
+ # notice that the scroll region (20" x 20") is larger than
+ # displayed size of the widget (5" x 5")
+ self.draw = Canvas(self, width="5i", height="5i",
+ background="white",
+ scrollregion=(0, 0, "20i", "20i"))
- self.draw.scrollX = Scrollbar(self, orient=HORIZONTAL)
- self.draw.scrollY = Scrollbar(self, orient=VERTICAL)
+ self.draw.scrollX = Scrollbar(self, orient=HORIZONTAL)
+ self.draw.scrollY = Scrollbar(self, orient=VERTICAL)
- # now tie the three together. This is standard boilerplate text
- self.draw['xscrollcommand'] = self.draw.scrollX.set
- self.draw['yscrollcommand'] = self.draw.scrollY.set
- self.draw.scrollX['command'] = self.draw.xview
- self.draw.scrollY['command'] = self.draw.yview
+ # now tie the three together. This is standard boilerplate text
+ self.draw['xscrollcommand'] = self.draw.scrollX.set
+ self.draw['yscrollcommand'] = self.draw.scrollY.set
+ self.draw.scrollX['command'] = self.draw.xview
+ self.draw.scrollY['command'] = self.draw.yview
- # draw something. Note that the first square
- # is visible, but you need to scroll to see the second one.
- self.draw.create_rectangle(0, 0, "3.5i", "3.5i", fill="black")
- self.draw.create_rectangle("10i", "10i", "13.5i", "13.5i", fill="blue")
+ # draw something. Note that the first square
+ # is visible, but you need to scroll to see the second one.
+ self.draw.create_rectangle(0, 0, "3.5i", "3.5i", fill="black")
+ self.draw.create_rectangle("10i", "10i", "13.5i", "13.5i", fill="blue")
- # pack 'em up
- self.draw.scrollX.pack(side=BOTTOM, fill=X)
- self.draw.scrollY.pack(side=RIGHT, fill=Y)
- self.draw.pack(side=LEFT)
+ # pack 'em up
+ self.draw.scrollX.pack(side=BOTTOM, fill=X)
+ self.draw.scrollY.pack(side=RIGHT, fill=Y)
+ self.draw.pack(side=LEFT)
- def scrollCanvasX(self, *args):
- print "scrolling", args
- print self.draw.scrollX.get()
+ def scrollCanvasX(self, *args):
+ print "scrolling", args
+ print self.draw.scrollX.get()
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
diff --git a/Demo/tkinter/matt/dialog-box.py b/Demo/tkinter/matt/dialog-box.py
index cbfe29f..dea8f39 100644
--- a/Demo/tkinter/matt/dialog-box.py
+++ b/Demo/tkinter/matt/dialog-box.py
@@ -6,59 +6,59 @@
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def makeWindow(self):
- """Create a top-level dialog with some buttons.
+ """Create a top-level dialog with some buttons.
- This uses the Dialog class, which is a wrapper around the Tcl/Tk
- tk_dialog script. The function returns 0 if the user clicks 'yes'
- or 1 if the user clicks 'no'.
- """
- # the parameters to this call are as follows:
- d = Dialog(
- self, ## name of a toplevel window
- title="fred the dialog box",## title on the window
- text="click on a choice", ## message to appear in window
- bitmap="info", ## bitmap (if any) to appear;
- ## if none, use ""
- # legal values here are:
- # string what it looks like
- # ----------------------------------------------
- # error a circle with a slash through it
- # grey25 grey square
- # grey50 darker grey square
- # hourglass use for "wait.."
- # info a large, lower case "i"
- # questhead a human head with a "?" in it
- # question a large "?"
- # warning a large "!"
- # @fname X bitmap where fname is the path to the file
- #
- default=0, # the index of the default button choice.
- # hitting return selects this
- strings=("yes", "no"))
- # values of the 'strings' key are the labels for the
- # buttons that appear left to right in the dialog box
- return d.num
+ This uses the Dialog class, which is a wrapper around the Tcl/Tk
+ tk_dialog script. The function returns 0 if the user clicks 'yes'
+ or 1 if the user clicks 'no'.
+ """
+ # the parameters to this call are as follows:
+ d = Dialog(
+ self, ## name of a toplevel window
+ title="fred the dialog box",## title on the window
+ text="click on a choice", ## message to appear in window
+ bitmap="info", ## bitmap (if any) to appear;
+ ## if none, use ""
+ # legal values here are:
+ # string what it looks like
+ # ----------------------------------------------
+ # error a circle with a slash through it
+ # grey25 grey square
+ # grey50 darker grey square
+ # hourglass use for "wait.."
+ # info a large, lower case "i"
+ # questhead a human head with a "?" in it
+ # question a large "?"
+ # warning a large "!"
+ # @fname X bitmap where fname is the path to the file
+ #
+ default=0, # the index of the default button choice.
+ # hitting return selects this
+ strings=("yes", "no"))
+ # values of the 'strings' key are the labels for the
+ # buttons that appear left to right in the dialog box
+ return d.num
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=LEFT, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
- # a hello button
- self.hi_there = Button(self, text='Make a New Window',
- command=self.makeWindow)
- self.hi_there.pack(side=LEFT)
+ # a hello button
+ self.hi_there = Button(self, text='Make a New Window',
+ command=self.makeWindow)
+ self.hi_there.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.windownum = 0
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.windownum = 0
+ self.createWidgets()
test = Test()
test.mainloop()
diff --git a/Demo/tkinter/matt/entry-simple.py b/Demo/tkinter/matt/entry-simple.py
index cf82b89..5146e6f 100644
--- a/Demo/tkinter/matt/entry-simple.py
+++ b/Demo/tkinter/matt/entry-simple.py
@@ -1,25 +1,24 @@
from Tkinter import *
-import string
+import string
# This program shows how to use a simple type-in box
class App(Frame):
def __init__(self, master=None):
- Frame.__init__(self, master)
- self.pack()
+ Frame.__init__(self, master)
+ self.pack()
- self.entrythingy = Entry()
- self.entrythingy.pack()
+ self.entrythingy = Entry()
+ self.entrythingy.pack()
- # and here we get a callback when the user hits return. we could
- # make the key that triggers the callback anything we wanted to.
- # other typical options might be <Key-Tab> or <Key> (for anything)
- self.entrythingy.bind('<Key-Return>', self.print_contents)
+ # and here we get a callback when the user hits return. we could
+ # make the key that triggers the callback anything we wanted to.
+ # other typical options might be <Key-Tab> or <Key> (for anything)
+ self.entrythingy.bind('<Key-Return>', self.print_contents)
def print_contents(self, event):
- print "hi. contents of entry is now ---->", self.entrythingy.get()
+ print "hi. contents of entry is now ---->", self.entrythingy.get()
root = App()
root.master.title("Foo")
root.mainloop()
-
diff --git a/Demo/tkinter/matt/entry-with-shared-variable.py b/Demo/tkinter/matt/entry-with-shared-variable.py
index 360f973..2b76162 100644
--- a/Demo/tkinter/matt/entry-with-shared-variable.py
+++ b/Demo/tkinter/matt/entry-with-shared-variable.py
@@ -1,47 +1,46 @@
from Tkinter import *
-import string
+import string
# This program shows how to make a typein box shadow a program variable.
class App(Frame):
def __init__(self, master=None):
- Frame.__init__(self, master)
- self.pack()
+ Frame.__init__(self, master)
+ self.pack()
- self.entrythingy = Entry(self)
- self.entrythingy.pack()
+ self.entrythingy = Entry(self)
+ self.entrythingy.pack()
- self.button = Button(self, text="Uppercase The Entry",
- command=self.upper)
- self.button.pack()
+ self.button = Button(self, text="Uppercase The Entry",
+ command=self.upper)
+ self.button.pack()
- # here we have the text in the entry widget tied to a variable.
- # changes in the variable are echoed in the widget and vice versa.
- # Very handy.
- # there are other Variable types. See Tkinter.py for all
- # the other variable types that can be shadowed
- self.contents = StringVar()
- self.contents.set("this is a variable")
- self.entrythingy.config(textvariable=self.contents)
+ # here we have the text in the entry widget tied to a variable.
+ # changes in the variable are echoed in the widget and vice versa.
+ # Very handy.
+ # there are other Variable types. See Tkinter.py for all
+ # the other variable types that can be shadowed
+ self.contents = StringVar()
+ self.contents.set("this is a variable")
+ self.entrythingy.config(textvariable=self.contents)
- # and here we get a callback when the user hits return. we could
- # make the key that triggers the callback anything we wanted to.
- # other typical options might be <Key-Tab> or <Key> (for anything)
- self.entrythingy.bind('<Key-Return>', self.print_contents)
+ # and here we get a callback when the user hits return. we could
+ # make the key that triggers the callback anything we wanted to.
+ # other typical options might be <Key-Tab> or <Key> (for anything)
+ self.entrythingy.bind('<Key-Return>', self.print_contents)
def upper(self):
- # notice here, we don't actually refer to the entry box.
- # we just operate on the string variable and we
+ # notice here, we don't actually refer to the entry box.
+ # we just operate on the string variable and we
# because it's being looked at by the entry widget, changing
- # the variable changes the entry widget display automatically.
- # the strange get/set operators are clunky, true...
- str = string.upper(self.contents.get())
- self.contents.set(str)
+ # the variable changes the entry widget display automatically.
+ # the strange get/set operators are clunky, true...
+ str = string.upper(self.contents.get())
+ self.contents.set(str)
def print_contents(self, event):
- print "hi. contents of entry is now ---->", self.contents.get()
+ print "hi. contents of entry is now ---->", self.contents.get()
root = App()
root.master.title("Foo")
root.mainloop()
-
diff --git a/Demo/tkinter/matt/killing-window-w-wm.py b/Demo/tkinter/matt/killing-window-w-wm.py
index 805a6bc..6a0e2fe 100644
--- a/Demo/tkinter/matt/killing-window-w-wm.py
+++ b/Demo/tkinter/matt/killing-window-w-wm.py
@@ -1,8 +1,8 @@
from Tkinter import *
-# This file shows how to trap the killing of a window
+# This file shows how to trap the killing of a window
# when the user uses window manager menus (typ. upper left hand corner
-# menu in the decoration border).
+# menu in the decoration border).
### ******* this isn't really called -- read the comments
@@ -11,31 +11,31 @@
class Test(Frame):
def deathHandler(self, event):
- print self, "is now getting nuked. performing some save here...."
+ print self, "is now getting nuked. performing some save here...."
def createWidgets(self):
- # a hello button
- self.hi_there = Button(self, text='Hello')
- self.hi_there.pack(side=LEFT)
+ # a hello button
+ self.hi_there = Button(self, text='Hello')
+ self.hi_there.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
- ###
- ### PREVENT WM kills from happening
- ###
+ ###
+ ### PREVENT WM kills from happening
+ ###
- # the docs would have you do this:
+ # the docs would have you do this:
-# self.master.protocol("WM_DELETE_WINDOW", my_delete_callback)
+# self.master.protocol("WM_DELETE_WINDOW", my_delete_callback)
- # unfortunately, some window managers will not send this request to a window.
- # the "protocol" function seems incapable of trapping these "aggressive" window kills.
- # this line of code catches everything, tho. The window is deleted, but you have a chance
- # of cleaning up first.
- self.bind_all("<Destroy>", self.deathHandler)
+ # unfortunately, some window managers will not send this request to a window.
+ # the "protocol" function seems incapable of trapping these "aggressive" window kills.
+ # this line of code catches everything, tho. The window is deleted, but you have a chance
+ # of cleaning up first.
+ self.bind_all("<Destroy>", self.deathHandler)
test = Test()
diff --git a/Demo/tkinter/matt/menu-all-types-of-entries.py b/Demo/tkinter/matt/menu-all-types-of-entries.py
index 1ac51c8..f4afe4a 100644
--- a/Demo/tkinter/matt/menu-all-types-of-entries.py
+++ b/Demo/tkinter/matt/menu-all-types-of-entries.py
@@ -1,16 +1,16 @@
from Tkinter import *
-# some vocabulary to keep from getting confused. This terminology
-# is something I cooked up for this file, but follows the man pages
+# some vocabulary to keep from getting confused. This terminology
+# is something I cooked up for this file, but follows the man pages
# pretty closely
-#
-#
-#
+#
+#
+#
# This is a MENUBUTTON
# V
# +-------------+
# | |
-#
+#
# +------------++------------++------------+
# | || || |
# | File || Edit || Options | <-------- the MENUBAR
@@ -22,7 +22,7 @@
# | | <-------- This is a MENU. The lines of text in the menu are
# | | MENU ENTRIES
# | +---------------+
-# | Open Files > | file1 |
+# | Open Files > | file1 |
# | | file2 |
# | | another file | <------ this cascading part is also a MENU
# +----------------| |
@@ -53,11 +53,11 @@
print "anchovies?", anchovies
def makeCommandMenu():
- # make menu button
- Command_button = Menubutton(mBar, text='Simple Button Commands',
- underline=0)
+ # make menu button
+ Command_button = Menubutton(mBar, text='Simple Button Commands',
+ underline=0)
Command_button.pack(side=LEFT, padx="2m")
-
+
# make the pulldown part of the File menu. The parameter passed is the master.
# we attach it to the button as a python attribute called "menu" by convention.
# hopefully this isn't too confusing...
@@ -68,28 +68,28 @@
# undo is the 0th entry...
Command_button.menu.entryconfig(0, state=DISABLED)
- Command_button.menu.add_command(label='New...', underline=0,
- command=new_file)
- Command_button.menu.add_command(label='Open...', underline=0,
- command=open_file)
+ Command_button.menu.add_command(label='New...', underline=0,
+ command=new_file)
+ Command_button.menu.add_command(label='Open...', underline=0,
+ command=open_file)
Command_button.menu.add_command(label='Different Font', underline=0,
- font='-*-helvetica-*-r-*-*-*-180-*-*-*-*-*-*',
- command=print_something)
-
+ font='-*-helvetica-*-r-*-*-*-180-*-*-*-*-*-*',
+ command=print_something)
+
# we can make bitmaps be menu entries too. File format is X11 bitmap.
# if you use XV, save it under X11 bitmap format. duh-uh.,..
Command_button.menu.add_command(
- bitmap="info")
- #bitmap='@/home/mjc4y/dilbert/project.status.is.doomed.last.panel.bm')
-
+ bitmap="info")
+ #bitmap='@/home/mjc4y/dilbert/project.status.is.doomed.last.panel.bm')
+
# this is just a line
Command_button.menu.add('separator')
# change the color
- Command_button.menu.add_command(label='Quit', underline=0,
- background='red',
- activebackground='green',
- command=Command_button.quit)
+ Command_button.menu.add_command(label='Quit', underline=0,
+ background='red',
+ activebackground='green',
+ command=Command_button.quit)
# set up a pointer from the file menubutton back to the file menu
Command_button['menu'] = Command_button.menu
@@ -99,10 +99,10 @@
def makeCascadeMenu():
- # make menu button
+ # make menu button
Cascade_button = Menubutton(mBar, text='Cascading Menus', underline=0)
Cascade_button.pack(side=LEFT, padx="2m")
-
+
# the primary pulldown
Cascade_button.menu = Menu(Cascade_button)
@@ -125,12 +125,12 @@
Cascade_button.menu.choices.add_command(label='Rocky Road')
Cascade_button.menu.choices.add_command(label='BubbleGum')
Cascade_button.menu.choices.add_cascade(
- label='Wierd Flavors',
- menu=Cascade_button.menu.choices.wierdones)
+ label='Wierd Flavors',
+ menu=Cascade_button.menu.choices.wierdones)
# and finally, the definition for the top level
- Cascade_button.menu.add_cascade(label='more choices',
- menu=Cascade_button.menu.choices)
+ Cascade_button.menu.add_cascade(label='more choices',
+ menu=Cascade_button.menu.choices)
Cascade_button['menu'] = Cascade_button.menu
@@ -138,39 +138,39 @@
def makeCheckbuttonMenu():
global fred
- # make menu button
- Checkbutton_button = Menubutton(mBar, text='Checkbutton Menus',
- underline=0)
+ # make menu button
+ Checkbutton_button = Menubutton(mBar, text='Checkbutton Menus',
+ underline=0)
Checkbutton_button.pack(side=LEFT, padx='2m')
-
+
# the primary pulldown
Checkbutton_button.menu = Menu(Checkbutton_button)
# and all the check buttons. Note that the "variable" "onvalue" and "offvalue" options
- # are not supported correctly at present. You have to do all your application
+ # are not supported correctly at present. You have to do all your application
# work through the calback.
Checkbutton_button.menu.add_checkbutton(label='Pepperoni')
Checkbutton_button.menu.add_checkbutton(label='Sausage')
Checkbutton_button.menu.add_checkbutton(label='Extra Cheese')
# so here's a callback
- Checkbutton_button.menu.add_checkbutton(label='Anchovy',
- command=print_anchovies)
+ Checkbutton_button.menu.add_checkbutton(label='Anchovy',
+ command=print_anchovies)
- # and start with anchovies selected to be on. Do this by
+ # and start with anchovies selected to be on. Do this by
# calling invoke on this menu option. To refer to the "anchovy" menu
# entry we need to know it's index. To do this, we use the index method
- # which takes arguments of several forms:
+ # which takes arguments of several forms:
#
# argument what it does
# -----------------------------------
- # a number -- this is useless.
+ # a number -- this is useless.
# "last" -- last option in the menu
# "none" -- used with the activate command. see the man page on menus
# "active" -- the currently active menu option. A menu option is made active
# with the 'activate' method
# "@number" -- where 'number' is an integer and is treated like a y coordinate in pixels
- # string pattern -- this is the option used below, and attempts to match "labels" using the
+ # string pattern -- this is the option used below, and attempts to match "labels" using the
# rules of Tcl_StringMatch
Checkbutton_button.menu.invoke(Checkbutton_button.menu.index('Anchovy'))
@@ -181,16 +181,16 @@
def makeRadiobuttonMenu():
- # make menu button
- Radiobutton_button = Menubutton(mBar, text='Radiobutton Menus',
- underline=0)
+ # make menu button
+ Radiobutton_button = Menubutton(mBar, text='Radiobutton Menus',
+ underline=0)
Radiobutton_button.pack(side=LEFT, padx='2m')
-
+
# the primary pulldown
Radiobutton_button.menu = Menu(Radiobutton_button)
# and all the Radio buttons. Note that the "variable" "onvalue" and "offvalue" options
- # are not supported correctly at present. You have to do all your application
+ # are not supported correctly at present. You have to do all your application
# work through the calback.
Radiobutton_button.menu.add_radiobutton(label='Republican')
Radiobutton_button.menu.add_radiobutton(label='Democrat')
@@ -209,7 +209,7 @@
return Radiobutton_button
-def makeDisabledMenu():
+def makeDisabledMenu():
Dummy_button = Menubutton(mBar, text='Dead Menu', underline=0)
Dummy_button.pack(side=LEFT, padx='2m')
@@ -233,7 +233,7 @@
Radiobutton_button = makeRadiobuttonMenu()
NoMenu = makeDisabledMenu()
-# finally, install the buttons in the menu bar.
+# finally, install the buttons in the menu bar.
# This allows for scanning from one menubutton to the next.
mBar.tk_menuBar(Command_button, Cascade_button, Checkbutton_button, Radiobutton_button, NoMenu)
@@ -242,9 +242,3 @@
root.iconname('menu demo')
root.mainloop()
-
-
-
-
-
-
diff --git a/Demo/tkinter/matt/menu-simple.py b/Demo/tkinter/matt/menu-simple.py
index 28f2c9e..46b5364 100644
--- a/Demo/tkinter/matt/menu-simple.py
+++ b/Demo/tkinter/matt/menu-simple.py
@@ -1,16 +1,16 @@
from Tkinter import *
-# some vocabulary to keep from getting confused. This terminology
-# is something I cooked up for this file, but follows the man pages
+# some vocabulary to keep from getting confused. This terminology
+# is something I cooked up for this file, but follows the man pages
# pretty closely
-#
-#
-#
+#
+#
+#
# This is a MENUBUTTON
# V
# +-------------+
# | |
-#
+#
# +------------++------------++------------+
# | || || |
# | File || Edit || Options | <-------- the MENUBAR
@@ -22,7 +22,7 @@
# | | <------ This is a MENU. The lines of text in the menu are
# | | MENU ENTRIES
# | +---------------+
-# | Open Files > | file1 |
+# | Open Files > | file1 |
# | | file2 |
# | | another file | <------ this cascading part is also a MENU
# +----------------| |
@@ -46,19 +46,19 @@
File_button = Menubutton(mBar, text='File', underline=0)
File_button.pack(side=LEFT, padx="1m")
File_button.menu = Menu(File_button)
-
- # add an item. The first param is a menu entry type,
+
+ # add an item. The first param is a menu entry type,
# must be one of: "cascade", "checkbutton", "command", "radiobutton", "seperator"
# see menu-demo-2.py for examples of use
- File_button.menu.add_command(label='New...', underline=0,
- command=new_file)
-
-
- File_button.menu.add_command(label='Open...', underline=0,
- command=open_file)
-
- File_button.menu.add_command(label='Quit', underline=0,
- command='exit')
+ File_button.menu.add_command(label='New...', underline=0,
+ command=new_file)
+
+
+ File_button.menu.add_command(label='Open...', underline=0,
+ command=open_file)
+
+ File_button.menu.add_command(label='Quit', underline=0,
+ command='exit')
# set up a pointer from the file menubutton back to the file menu
File_button['menu'] = File_button.menu
@@ -102,7 +102,7 @@
File_button = makeFileMenu()
Edit_button = makeEditMenu()
-# finally, install the buttons in the menu bar.
+# finally, install the buttons in the menu bar.
# This allows for scanning from one menubutton to the next.
mBar.tk_menuBar(File_button, Edit_button)
@@ -110,9 +110,3 @@
root.iconname('packer')
root.mainloop()
-
-
-
-
-
-
diff --git a/Demo/tkinter/matt/not-what-you-might-think-1.py b/Demo/tkinter/matt/not-what-you-might-think-1.py
index 24de2ef..7b20f02 100644
--- a/Demo/tkinter/matt/not-what-you-might-think-1.py
+++ b/Demo/tkinter/matt/not-what-you-might-think-1.py
@@ -4,21 +4,21 @@
class Test(Frame):
def createWidgets(self):
- self.Gpanel = Frame(self, width='1i', height='1i',
- background='green')
- self.Gpanel.pack(side=LEFT)
+ self.Gpanel = Frame(self, width='1i', height='1i',
+ background='green')
+ self.Gpanel.pack(side=LEFT)
- # a QUIT button
- self.Gpanel.QUIT = Button(self.Gpanel, text='QUIT',
- foreground='red',
- command=self.quit)
- self.Gpanel.QUIT.pack(side=LEFT)
+ # a QUIT button
+ self.Gpanel.QUIT = Button(self.Gpanel, text='QUIT',
+ foreground='red',
+ command=self.quit)
+ self.Gpanel.QUIT.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
diff --git a/Demo/tkinter/matt/not-what-you-might-think-2.py b/Demo/tkinter/matt/not-what-you-might-think-2.py
index c01854e..9ee197c 100644
--- a/Demo/tkinter/matt/not-what-you-might-think-2.py
+++ b/Demo/tkinter/matt/not-what-you-might-think-2.py
@@ -4,23 +4,23 @@
class Test(Frame):
def createWidgets(self):
- self.Gpanel = Frame(self, width='1i', height='1i',
- background='green')
+ self.Gpanel = Frame(self, width='1i', height='1i',
+ background='green')
- # this line turns off the recalculation of geometry by masters.
- self.Gpanel.propagate(0)
+ # this line turns off the recalculation of geometry by masters.
+ self.Gpanel.propagate(0)
- self.Gpanel.pack(side=LEFT)
+ self.Gpanel.pack(side=LEFT)
- # a QUIT button
- self.Gpanel.QUIT = Button(self.Gpanel, text='QUIT', foreground='red',
- command=self.quit)
- self.Gpanel.QUIT.pack(side=LEFT)
+ # a QUIT button
+ self.Gpanel.QUIT = Button(self.Gpanel, text='QUIT', foreground='red',
+ command=self.quit)
+ self.Gpanel.QUIT.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
diff --git a/Demo/tkinter/matt/packer-and-placer-together.py b/Demo/tkinter/matt/packer-and-placer-together.py
index 4ceec54..184d56b 100644
--- a/Demo/tkinter/matt/packer-and-placer-together.py
+++ b/Demo/tkinter/matt/packer-and-placer-together.py
@@ -1,6 +1,6 @@
from Tkinter import *
-# This is a program that tests the placer geom manager in conjunction with
+# This is a program that tests the placer geom manager in conjunction with
# the packer. The background (green) is packed, while the widget inside is placed
@@ -17,15 +17,15 @@
# area is inaccesssible.
f = Frame(top, width=200, height=200, background='green')
- # note that we use a different manager here.
- # This way, the top level frame widget resizes when the
- # application window does.
+ # note that we use a different manager here.
+ # This way, the top level frame widget resizes when the
+ # application window does.
f.pack(fill=BOTH, expand=1)
# now make a button
f.button = Button(f, foreground='red', text='amazing', command=dothis)
- # and place it so that the nw corner is
+ # and place it so that the nw corner is
# 1/2 way along the top X edge of its' parent
f.button.place(relx=0.5, rely=0.0, anchor=NW)
@@ -39,4 +39,3 @@
root.geometry("400x400")
root.maxsize(1000, 1000)
root.mainloop()
-
diff --git a/Demo/tkinter/matt/packer-simple.py b/Demo/tkinter/matt/packer-simple.py
index 7773cae..f55f1be 100644
--- a/Demo/tkinter/matt/packer-simple.py
+++ b/Demo/tkinter/matt/packer-simple.py
@@ -3,30 +3,30 @@
class Test(Frame):
def printit(self):
- print self.hi_there["command"]
+ print self.hi_there["command"]
def createWidgets(self):
- # a hello button
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=LEFT, fill=BOTH)
+ # a hello button
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
- self.hi_there = Button(self, text='Hello',
- command=self.printit)
- self.hi_there.pack(side=LEFT)
+ self.hi_there = Button(self, text='Hello',
+ command=self.printit)
+ self.hi_there.pack(side=LEFT)
- # note how Packer defaults to side=TOP
+ # note how Packer defaults to side=TOP
- self.guy2 = Button(self, text='button 2')
- self.guy2.pack()
+ self.guy2 = Button(self, text='button 2')
+ self.guy2.pack()
- self.guy3 = Button(self, text='button 3')
- self.guy3.pack()
+ self.guy3 = Button(self, text='button 3')
+ self.guy3.pack()
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
test.mainloop()
diff --git a/Demo/tkinter/matt/placer-simple.py b/Demo/tkinter/matt/placer-simple.py
index b7cae7e..30d9e9e 100644
--- a/Demo/tkinter/matt/placer-simple.py
+++ b/Demo/tkinter/matt/placer-simple.py
@@ -15,7 +15,7 @@
# area is inaccesssible.
f = Frame(top, width=200, height=200, background='green')
- # place it so the upper left hand corner of
+ # place it so the upper left hand corner of
# the frame is in the upper left corner of
# the parent
f.place(relx=0.0, rely=0.0)
@@ -23,7 +23,7 @@
# now make a button
f.button = Button(f, foreground='red', text='amazing', command=dothis)
- # and place it so that the nw corner is
+ # and place it so that the nw corner is
# 1/2 way along the top X edge of its' parent
f.button.place(relx=0.5, rely=0.0, anchor=NW)
@@ -37,4 +37,3 @@
root.geometry("400x400")
root.maxsize(1000, 1000)
root.mainloop()
-
diff --git a/Demo/tkinter/matt/pong-demo-1.py b/Demo/tkinter/matt/pong-demo-1.py
index a27f334..7fcf800 100644
--- a/Demo/tkinter/matt/pong-demo-1.py
+++ b/Demo/tkinter/matt/pong-demo-1.py
@@ -5,48 +5,48 @@
class Pong(Frame):
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=LEFT, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
- ## The playing field
- self.draw = Canvas(self, width="5i", height="5i")
+ ## The playing field
+ self.draw = Canvas(self, width="5i", height="5i")
- ## The speed control for the ball
- self.speed = Scale(self, orient=HORIZONTAL, label="ball speed",
- from_=-100, to=100)
+ ## The speed control for the ball
+ self.speed = Scale(self, orient=HORIZONTAL, label="ball speed",
+ from_=-100, to=100)
- self.speed.pack(side=BOTTOM, fill=X)
+ self.speed.pack(side=BOTTOM, fill=X)
- # The ball
- self.ball = self.draw.create_oval("0i", "0i", "0.10i", "0.10i",
- fill="red")
- self.x = 0.05
- self.y = 0.05
- self.velocity_x = 0.3
- self.velocity_y = 0.5
+ # The ball
+ self.ball = self.draw.create_oval("0i", "0i", "0.10i", "0.10i",
+ fill="red")
+ self.x = 0.05
+ self.y = 0.05
+ self.velocity_x = 0.3
+ self.velocity_y = 0.5
- self.draw.pack(side=LEFT)
+ self.draw.pack(side=LEFT)
def moveBall(self, *args):
- if (self.x > 5.0) or (self.x < 0.0):
- self.velocity_x = -1.0 * self.velocity_x
- if (self.y > 5.0) or (self.y < 0.0):
- self.velocity_y = -1.0 * self.velocity_y
+ if (self.x > 5.0) or (self.x < 0.0):
+ self.velocity_x = -1.0 * self.velocity_x
+ if (self.y > 5.0) or (self.y < 0.0):
+ self.velocity_y = -1.0 * self.velocity_y
- deltax = (self.velocity_x * self.speed.get() / 100.0)
- deltay = (self.velocity_y * self.speed.get() / 100.0)
- self.x = self.x + deltax
- self.y = self.y + deltay
+ deltax = (self.velocity_x * self.speed.get() / 100.0)
+ deltay = (self.velocity_y * self.speed.get() / 100.0)
+ self.x = self.x + deltax
+ self.y = self.y + deltay
- self.draw.move(self.ball, "%ri" % deltax, "%ri" % deltay)
- self.after(10, self.moveBall)
+ self.draw.move(self.ball, "%ri" % deltax, "%ri" % deltay)
+ self.after(10, self.moveBall)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
- self.after(10, self.moveBall)
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
+ self.after(10, self.moveBall)
game = Pong()
diff --git a/Demo/tkinter/matt/printing-coords-of-items.py b/Demo/tkinter/matt/printing-coords-of-items.py
index 6400fd8..a37733d 100644
--- a/Demo/tkinter/matt/printing-coords-of-items.py
+++ b/Demo/tkinter/matt/printing-coords-of-items.py
@@ -7,58 +7,55 @@
###### Event callbacks for THE CANVAS (not the stuff drawn on it)
###################################################################
def mouseDown(self, event):
- # see if we're inside a dot. If we are, it
- # gets tagged as CURRENT for free by tk.
+ # see if we're inside a dot. If we are, it
+ # gets tagged as CURRENT for free by tk.
- if not event.widget.find_withtag(CURRENT):
- # there is no dot here, so we can make one,
- # and bind some interesting behavior to it.
- # ------
- # create a dot, and mark it as current
- fred = self.draw.create_oval(
- event.x - 10, event.y -10, event.x +10, event.y + 10,
- fill="green")
- self.draw.tag_bind(fred, "<Enter>", self.mouseEnter)
- self.draw.tag_bind(fred, "<Leave>", self.mouseLeave)
- self.lastx = event.x
- self.lasty = event.y
+ if not event.widget.find_withtag(CURRENT):
+ # there is no dot here, so we can make one,
+ # and bind some interesting behavior to it.
+ # ------
+ # create a dot, and mark it as current
+ fred = self.draw.create_oval(
+ event.x - 10, event.y -10, event.x +10, event.y + 10,
+ fill="green")
+ self.draw.tag_bind(fred, "<Enter>", self.mouseEnter)
+ self.draw.tag_bind(fred, "<Leave>", self.mouseLeave)
+ self.lastx = event.x
+ self.lasty = event.y
def mouseMove(self, event):
- self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
- self.lastx = event.x
- self.lasty = event.y
+ self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
+ self.lastx = event.x
+ self.lasty = event.y
###################################################################
###### Event callbacks for canvas ITEMS (stuff drawn on the canvas)
###################################################################
def mouseEnter(self, event):
# the "current" tag is applied to the object the cursor is over.
- # this happens automatically.
- self.draw.itemconfig(CURRENT, fill="red")
- print self.draw.coords(CURRENT)
-
+ # this happens automatically.
+ self.draw.itemconfig(CURRENT, fill="red")
+ print self.draw.coords(CURRENT)
+
def mouseLeave(self, event):
- # the "current" tag is applied to the object the cursor is over.
- # this happens automatically.
- self.draw.itemconfig(CURRENT, fill="blue")
+ # the "current" tag is applied to the object the cursor is over.
+ # this happens automatically.
+ self.draw.itemconfig(CURRENT, fill="blue")
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=LEFT, fill=BOTH)
- self.draw = Canvas(self, width="5i", height="5i")
- self.draw.pack(side=LEFT)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
+ self.draw = Canvas(self, width="5i", height="5i")
+ self.draw.pack(side=LEFT)
- Widget.bind(self.draw, "<1>", self.mouseDown)
- Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
+ Widget.bind(self.draw, "<1>", self.mouseDown)
+ Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
test.mainloop()
-
-
-
diff --git a/Demo/tkinter/matt/radiobutton-simple.py b/Demo/tkinter/matt/radiobutton-simple.py
index 65dfe52..e9d6afe 100644
--- a/Demo/tkinter/matt/radiobutton-simple.py
+++ b/Demo/tkinter/matt/radiobutton-simple.py
@@ -1,10 +1,10 @@
from Tkinter import *
-# This is a demo program that shows how to
-# create radio buttons and how to get other widgets to
-# share the information in a radio button.
-#
-# There are other ways of doing this too, but
+# This is a demo program that shows how to
+# create radio buttons and how to get other widgets to
+# share the information in a radio button.
+#
+# There are other ways of doing this too, but
# the "variable" option of radiobuttons seems to be the easiest.
#
# note how each button has a value it sets the variable to as it gets hit.
@@ -12,50 +12,50 @@
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def createWidgets(self):
- self.flavor = StringVar()
- self.flavor.set("chocolate")
+ self.flavor = StringVar()
+ self.flavor.set("chocolate")
- self.radioframe = Frame(self)
- self.radioframe.pack()
+ self.radioframe = Frame(self)
+ self.radioframe.pack()
- # 'text' is the label
- # 'variable' is the name of the variable that all these radio buttons share
- # 'value' is the value this variable takes on when the radio button is selected
- # 'anchor' makes the text appear left justified (default is centered. ick)
- self.radioframe.choc = Radiobutton(
- self.radioframe, text="Chocolate Flavor",
- variable=self.flavor, value="chocolate",
- anchor=W)
- self.radioframe.choc.pack(fill=X)
+ # 'text' is the label
+ # 'variable' is the name of the variable that all these radio buttons share
+ # 'value' is the value this variable takes on when the radio button is selected
+ # 'anchor' makes the text appear left justified (default is centered. ick)
+ self.radioframe.choc = Radiobutton(
+ self.radioframe, text="Chocolate Flavor",
+ variable=self.flavor, value="chocolate",
+ anchor=W)
+ self.radioframe.choc.pack(fill=X)
- self.radioframe.straw = Radiobutton(
- self.radioframe, text="Strawberry Flavor",
- variable=self.flavor, value="strawberry",
- anchor=W)
- self.radioframe.straw.pack(fill=X)
+ self.radioframe.straw = Radiobutton(
+ self.radioframe, text="Strawberry Flavor",
+ variable=self.flavor, value="strawberry",
+ anchor=W)
+ self.radioframe.straw.pack(fill=X)
- self.radioframe.lemon = Radiobutton(
- self.radioframe, text="Lemon Flavor",
- variable=self.flavor, value="lemon",
- anchor=W)
- self.radioframe.lemon.pack(fill=X)
-
- # this is a text entry that lets you type in the name of a flavor too.
- self.entry = Entry(self, textvariable=self.flavor)
- self.entry.pack(fill=X)
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=BOTTOM, fill=BOTH)
+ self.radioframe.lemon = Radiobutton(
+ self.radioframe, text="Lemon Flavor",
+ variable=self.flavor, value="lemon",
+ anchor=W)
+ self.radioframe.lemon.pack(fill=X)
+
+ # this is a text entry that lets you type in the name of a flavor too.
+ self.entry = Entry(self, textvariable=self.flavor)
+ self.entry.pack(fill=X)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=BOTTOM, fill=BOTH)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
diff --git a/Demo/tkinter/matt/rubber-band-box-demo-1.py b/Demo/tkinter/matt/rubber-band-box-demo-1.py
index 5196bf7..b00518e 100644
--- a/Demo/tkinter/matt/rubber-band-box-demo-1.py
+++ b/Demo/tkinter/matt/rubber-band-box-demo-1.py
@@ -2,55 +2,55 @@
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT',
- background='red',
- foreground='white',
- height=3,
- command=self.quit)
- self.QUIT.pack(side=BOTTOM, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT',
+ background='red',
+ foreground='white',
+ height=3,
+ command=self.quit)
+ self.QUIT.pack(side=BOTTOM, fill=BOTH)
- self.canvasObject = Canvas(self, width="5i", height="5i")
- self.canvasObject.pack(side=LEFT)
+ self.canvasObject = Canvas(self, width="5i", height="5i")
+ self.canvasObject.pack(side=LEFT)
def mouseDown(self, event):
- # canvas x and y take the screen coords from the event and translate
- # them into the coordinate system of the canvas object
- self.startx = self.canvasObject.canvasx(event.x)
- self.starty = self.canvasObject.canvasy(event.y)
+ # canvas x and y take the screen coords from the event and translate
+ # them into the coordinate system of the canvas object
+ self.startx = self.canvasObject.canvasx(event.x)
+ self.starty = self.canvasObject.canvasy(event.y)
def mouseMotion(self, event):
- # canvas x and y take the screen coords from the event and translate
- # them into the coordinate system of the canvas object
- x = self.canvasObject.canvasx(event.x)
- y = self.canvasObject.canvasy(event.y)
+ # canvas x and y take the screen coords from the event and translate
+ # them into the coordinate system of the canvas object
+ x = self.canvasObject.canvasx(event.x)
+ y = self.canvasObject.canvasy(event.y)
- if (self.startx != event.x) and (self.starty != event.y) :
- self.canvasObject.delete(self.rubberbandBox)
- self.rubberbandBox = self.canvasObject.create_rectangle(
- self.startx, self.starty, x, y)
- # this flushes the output, making sure that
- # the rectangle makes it to the screen
- # before the next event is handled
- self.update_idletasks()
+ if (self.startx != event.x) and (self.starty != event.y) :
+ self.canvasObject.delete(self.rubberbandBox)
+ self.rubberbandBox = self.canvasObject.create_rectangle(
+ self.startx, self.starty, x, y)
+ # this flushes the output, making sure that
+ # the rectangle makes it to the screen
+ # before the next event is handled
+ self.update_idletasks()
def mouseUp(self, event):
- self.canvasObject.delete(self.rubberbandBox)
-
- def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ self.canvasObject.delete(self.rubberbandBox)
- # this is a "tagOrId" for the rectangle we draw on the canvas
- self.rubberbandBox = None
-
- # and the bindings that make it work..
- Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
- Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
- Widget.bind(self.canvasObject, "<Button1-ButtonRelease>", self.mouseUp)
+ def __init__(self, master=None):
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
+
+ # this is a "tagOrId" for the rectangle we draw on the canvas
+ self.rubberbandBox = None
+
+ # and the bindings that make it work..
+ Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
+ Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
+ Widget.bind(self.canvasObject, "<Button1-ButtonRelease>", self.mouseUp)
test = Test()
diff --git a/Demo/tkinter/matt/rubber-line-demo-1.py b/Demo/tkinter/matt/rubber-line-demo-1.py
index f6d8535..59b8bd9 100644
--- a/Demo/tkinter/matt/rubber-line-demo-1.py
+++ b/Demo/tkinter/matt/rubber-line-demo-1.py
@@ -2,49 +2,49 @@
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT',
- background='red',
- foreground='white',
- height=3,
- command=self.quit)
- self.QUIT.pack(side=BOTTOM, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT',
+ background='red',
+ foreground='white',
+ height=3,
+ command=self.quit)
+ self.QUIT.pack(side=BOTTOM, fill=BOTH)
- self.canvasObject = Canvas(self, width="5i", height="5i")
- self.canvasObject.pack(side=LEFT)
+ self.canvasObject = Canvas(self, width="5i", height="5i")
+ self.canvasObject.pack(side=LEFT)
def mouseDown(self, event):
- # canvas x and y take the screen coords from the event and translate
- # them into the coordinate system of the canvas object
- self.startx = self.canvasObject.canvasx(event.x)
- self.starty = self.canvasObject.canvasy(event.y)
+ # canvas x and y take the screen coords from the event and translate
+ # them into the coordinate system of the canvas object
+ self.startx = self.canvasObject.canvasx(event.x)
+ self.starty = self.canvasObject.canvasy(event.y)
def mouseMotion(self, event):
- # canvas x and y take the screen coords from the event and translate
- # them into the coordinate system of the canvas object
- x = self.canvasObject.canvasx(event.x)
- y = self.canvasObject.canvasy(event.y)
+ # canvas x and y take the screen coords from the event and translate
+ # them into the coordinate system of the canvas object
+ x = self.canvasObject.canvasx(event.x)
+ y = self.canvasObject.canvasy(event.y)
- if (self.startx != event.x) and (self.starty != event.y) :
- self.canvasObject.delete(self.rubberbandLine)
- self.rubberbandLine = self.canvasObject.create_line(
- self.startx, self.starty, x, y)
- # this flushes the output, making sure that
- # the rectangle makes it to the screen
- # before the next event is handled
- self.update_idletasks()
+ if (self.startx != event.x) and (self.starty != event.y) :
+ self.canvasObject.delete(self.rubberbandLine)
+ self.rubberbandLine = self.canvasObject.create_line(
+ self.startx, self.starty, x, y)
+ # this flushes the output, making sure that
+ # the rectangle makes it to the screen
+ # before the next event is handled
+ self.update_idletasks()
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
- # this is a "tagOrId" for the rectangle we draw on the canvas
- self.rubberbandLine = None
- Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
- Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
-
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
+ # this is a "tagOrId" for the rectangle we draw on the canvas
+ self.rubberbandLine = None
+ Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
+ Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
+
test = Test()
diff --git a/Demo/tkinter/matt/slider-demo-1.py b/Demo/tkinter/matt/slider-demo-1.py
index 40395df..db6114b 100644
--- a/Demo/tkinter/matt/slider-demo-1.py
+++ b/Demo/tkinter/matt/slider-demo-1.py
@@ -5,32 +5,32 @@
class Test(Frame):
def print_value(self, val):
- print "slider now at", val
+ print "slider now at", val
- def reset(self):
- self.slider.set(0)
+ def reset(self):
+ self.slider.set(0)
def createWidgets(self):
- self.slider = Scale(self, from_=0, to=100,
- orient=HORIZONTAL,
- length="3i",
- label="happy slider",
- command=self.print_value)
+ self.slider = Scale(self, from_=0, to=100,
+ orient=HORIZONTAL,
+ length="3i",
+ label="happy slider",
+ command=self.print_value)
- self.reset = Button(self, text='reset slider',
- command=self.reset)
+ self.reset = Button(self, text='reset slider',
+ command=self.reset)
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
- self.slider.pack(side=LEFT)
- self.reset.pack(side=LEFT)
- self.QUIT.pack(side=LEFT, fill=BOTH)
+ self.slider.pack(side=LEFT)
+ self.reset.pack(side=LEFT)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
test.mainloop()
diff --git a/Demo/tkinter/matt/subclass-existing-widgets.py b/Demo/tkinter/matt/subclass-existing-widgets.py
index e79dd5c..0e08f92 100644
--- a/Demo/tkinter/matt/subclass-existing-widgets.py
+++ b/Demo/tkinter/matt/subclass-existing-widgets.py
@@ -5,9 +5,9 @@
class New_Button(Button):
def callback(self):
- print self.counter
- self.counter = self.counter + 1
-
+ print self.counter
+ self.counter = self.counter + 1
+
def createWidgets(top):
f = Frame(top)
f.pack()
@@ -26,4 +26,3 @@
root = Tk()
createWidgets(root)
root.mainloop()
-
diff --git a/Demo/tkinter/matt/two-radio-groups.py b/Demo/tkinter/matt/two-radio-groups.py
index 5c17333..9fd8f4f 100644
--- a/Demo/tkinter/matt/two-radio-groups.py
+++ b/Demo/tkinter/matt/two-radio-groups.py
@@ -1,44 +1,44 @@
from Tkinter import *
-# The way to think about this is that each radio button menu
-# controls a different variable -- clicking on one of the
-# mutually exclusive choices in a radiobutton assigns some value
-# to an application variable you provide. When you define a
-# radiobutton menu choice, you have the option of specifying the
-# name of a varaible and value to assign to that variable when
-# that choice is selected. This clever mechanism relieves you,
-# the programmer, from having to write a dumb callback that
-# probably wouldn't have done anything more than an assignment
-# anyway. The Tkinter options for this follow their Tk
-# counterparts:
-# {"variable" : my_flavor_variable, "value" : "strawberry"}
+# The way to think about this is that each radio button menu
+# controls a different variable -- clicking on one of the
+# mutually exclusive choices in a radiobutton assigns some value
+# to an application variable you provide. When you define a
+# radiobutton menu choice, you have the option of specifying the
+# name of a varaible and value to assign to that variable when
+# that choice is selected. This clever mechanism relieves you,
+# the programmer, from having to write a dumb callback that
+# probably wouldn't have done anything more than an assignment
+# anyway. The Tkinter options for this follow their Tk
+# counterparts:
+# {"variable" : my_flavor_variable, "value" : "strawberry"}
# where my_flavor_variable is an instance of one of the
# subclasses of Variable, provided in Tkinter.py (there is
-# StringVar(), IntVar(), DoubleVar() and BooleanVar() to choose
-# from)
+# StringVar(), IntVar(), DoubleVar() and BooleanVar() to choose
+# from)
def makePoliticalParties(var):
- # make menu button
- Radiobutton_button = Menubutton(mBar, text='Political Party',
- underline=0)
+ # make menu button
+ Radiobutton_button = Menubutton(mBar, text='Political Party',
+ underline=0)
Radiobutton_button.pack(side=LEFT, padx='2m')
-
+
# the primary pulldown
Radiobutton_button.menu = Menu(Radiobutton_button)
- Radiobutton_button.menu.add_radiobutton(label='Republican',
- variable=var, value=1)
+ Radiobutton_button.menu.add_radiobutton(label='Republican',
+ variable=var, value=1)
- Radiobutton_button.menu.add('radiobutton', {'label': 'Democrat',
- 'variable' : var,
- 'value' : 2})
+ Radiobutton_button.menu.add('radiobutton', {'label': 'Democrat',
+ 'variable' : var,
+ 'value' : 2})
- Radiobutton_button.menu.add('radiobutton', {'label': 'Libertarian',
- 'variable' : var,
- 'value' : 3})
-
+ Radiobutton_button.menu.add('radiobutton', {'label': 'Libertarian',
+ 'variable' : var,
+ 'value' : 3})
+
var.set(2)
# set up a pointer from the file menubutton back to the file menu
@@ -48,22 +48,22 @@
def makeFlavors(var):
- # make menu button
- Radiobutton_button = Menubutton(mBar, text='Flavors',
- underline=0)
+ # make menu button
+ Radiobutton_button = Menubutton(mBar, text='Flavors',
+ underline=0)
Radiobutton_button.pack(side=LEFT, padx='2m')
# the primary pulldown
Radiobutton_button.menu = Menu(Radiobutton_button)
Radiobutton_button.menu.add_radiobutton(label='Strawberry',
- variable=var, value='Strawberry')
+ variable=var, value='Strawberry')
Radiobutton_button.menu.add_radiobutton(label='Chocolate',
- variable=var, value='Chocolate')
+ variable=var, value='Chocolate')
Radiobutton_button.menu.add_radiobutton(label='Rocky Road',
- variable=var, value='Rocky Road')
+ variable=var, value='Rocky Road')
# choose a default
var.set("Chocolate")
@@ -88,7 +88,7 @@
mBar = Frame(root, relief=RAISED, borderwidth=2)
mBar.pack(fill=X)
-# make two application variables,
+# make two application variables,
# one to control each radio button set
party = IntVar()
flavor = StringVar()
@@ -96,12 +96,12 @@
Radiobutton_button = makePoliticalParties(party)
Radiobutton_button2 = makeFlavors(flavor)
-# finally, install the buttons in the menu bar.
+# finally, install the buttons in the menu bar.
# This allows for scanning from one menubutton to the next.
mBar.tk_menuBar(Radiobutton_button, Radiobutton_button2)
b = Button(root, text="print party and flavor", foreground="red",
- command=printStuff)
+ command=printStuff)
b.pack(side=TOP)
root.title('menu demo')
diff --git a/Demo/tkinter/matt/window-creation-more.py b/Demo/tkinter/matt/window-creation-more.py
index 492027a..eb0eb6f 100644
--- a/Demo/tkinter/matt/window-creation-more.py
+++ b/Demo/tkinter/matt/window-creation-more.py
@@ -5,31 +5,31 @@
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def makeWindow(self):
- fred = Toplevel()
- fred.label = Button(fred,
- text="This is window number %d." % self.windownum,
- command=self.makeWindow)
- fred.label.pack()
- self.windownum = self.windownum + 1
+ fred = Toplevel()
+ fred.label = Button(fred,
+ text="This is window number %d." % self.windownum,
+ command=self.makeWindow)
+ fred.label.pack()
+ self.windownum = self.windownum + 1
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
- self.QUIT.pack(side=LEFT, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
- # a hello button
- self.hi_there = Button(self, text='Make a New Window',
- command=self.makeWindow)
- self.hi_there.pack(side=LEFT)
+ # a hello button
+ self.hi_there = Button(self, text='Make a New Window',
+ command=self.makeWindow)
+ self.hi_there.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.windownum = 0
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.windownum = 0
+ self.createWidgets()
test = Test()
test.mainloop()
diff --git a/Demo/tkinter/matt/window-creation-simple.py b/Demo/tkinter/matt/window-creation-simple.py
index 969fefb..c990ed9 100644
--- a/Demo/tkinter/matt/window-creation-simple.py
+++ b/Demo/tkinter/matt/window-creation-simple.py
@@ -4,28 +4,28 @@
class Test(Frame):
def printit(self):
- print "hi"
+ print "hi"
def makeWindow(self):
- fred = Toplevel()
- fred.label = Label(fred, text="Here's a new window")
- fred.label.pack()
+ fred = Toplevel()
+ fred.label = Label(fred, text="Here's a new window")
+ fred.label.pack()
def createWidgets(self):
- self.QUIT = Button(self, text='QUIT', foreground='red',
- command=self.quit)
-
- self.QUIT.pack(side=LEFT, fill=BOTH)
+ self.QUIT = Button(self, text='QUIT', foreground='red',
+ command=self.quit)
- # a hello button
- self.hi_there = Button(self, text='Make a New Window',
- command=self.makeWindow)
- self.hi_there.pack(side=LEFT)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
+
+ # a hello button
+ self.hi_there = Button(self, text='Make a New Window',
+ command=self.makeWindow)
+ self.hi_there.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
test.mainloop()
diff --git a/Demo/tkinter/matt/window-creation-w-location.py b/Demo/tkinter/matt/window-creation-w-location.py
index 0ec4e09..3f2b5b0 100644
--- a/Demo/tkinter/matt/window-creation-w-location.py
+++ b/Demo/tkinter/matt/window-creation-w-location.py
@@ -17,29 +17,29 @@
class Test(Frame):
def makeWindow(self, *args):
- fred = Toplevel()
+ fred = Toplevel()
- fred.label = Canvas (fred, width="2i", height="2i")
+ fred.label = Canvas (fred, width="2i", height="2i")
- fred.label.create_line("0", "0", "2i", "2i")
- fred.label.create_line("0", "2i", "2i", "0")
- fred.label.pack()
+ fred.label.create_line("0", "0", "2i", "2i")
+ fred.label.create_line("0", "2i", "2i", "0")
+ fred.label.pack()
- ##centerWindow(fred, self.master)
+ ##centerWindow(fred, self.master)
def createWidgets(self):
- self.QUIT = QuitButton(self)
- self.QUIT.pack(side=LEFT, fill=BOTH)
+ self.QUIT = QuitButton(self)
+ self.QUIT.pack(side=LEFT, fill=BOTH)
- self.makeWindow = Button(self, text='Make a New Window',
- width=50, height=20,
- command=self.makeWindow)
- self.makeWindow.pack(side=LEFT)
+ self.makeWindow = Button(self, text='Make a New Window',
+ width=50, height=20,
+ command=self.makeWindow)
+ self.makeWindow.pack(side=LEFT)
def __init__(self, master=None):
- Frame.__init__(self, master)
- Pack.config(self)
- self.createWidgets()
+ Frame.__init__(self, master)
+ Pack.config(self)
+ self.createWidgets()
test = Test()
test.mainloop()