Matt's examples

Demo/tkinter/matt/00-HELLO-WORLD.py

+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. 
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': 'red', 
+				  'command': self.quit})
+	
+	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()
+
+test = Test()
+test.mainloop()

Demo/tkinter/matt/README

+This directory contains some ad-hoc examples of Tkinter widget
+creation. The files named 
+
+		*-simple.py
+
+are the ones to start with if you're looking for a bare-bones usage of
+a widget. The other files are meant to show common usage patters that
+are a tad more involved. 
+
+If you have a suggestion for an example program, please send mail to 
+	
+	conway@virginia.edu
+
+and I'll include it.
+
+
+matt
+
+TODO
+-------
+The X selection
+Dialog Boxes
+More canvas examples
+Message widgets
+Text Editors
+Scrollbars
+Listboxes
+
+
+

Demo/tkinter/matt/animation-simple.py

+from Tkinter import *
+
+# This program shows how to use the "after" function to make animation.
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': 'red', 
+				  'command': self.quit})
+	self.QUIT.pack({'side': 'left', 'fill': 'both'})	
+
+	self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
+
+	# all of these work..
+	self.draw.create_polygon("0", "0", "10", "0", "10", "10", "0" , "10", {"tags" : "thing"})
+	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)
+
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+	self.after(10, self.moveThing)
+
+
+test = Test()
+
+test.mainloop()

Demo/tkinter/matt/animation-w-velocity-ctrl.py

+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. 
+
+
+
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': 'red', 
+				  'command': self.quit})
+	self.QUIT.pack({'side': 'bottom', 'fill': 'both'})	
+
+	self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
+
+	self.speed = Scale(self, {"orient":  "horiz", 
+				  "from" : -100, 
+				  "to" : 100})
+
+	self.speed.pack({'side': 'bottom', "fill" : "x"})
+
+	# all of these work..
+	self.draw.create_polygon("0", "0", "10", "0", "10", "10", "0" , "10", {"tags" : "thing"})
+	self.draw.pack({'side': 'left'})
+
+    def moveThing(self, *args):
+	velocity = self.speed.get()
+	str = float(velocity) / 1000.0
+	str = `str` + "i"
+	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)
+
+
+test = Test()
+
+test.mainloop()

Demo/tkinter/matt/canvas-demo-simple.py

+from Tkinter import *
+
+# this program creates a canvas and puts a single polygon on the canvas
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': 'red', 
+				  'command': self.quit})
+	self.QUIT.pack({'side': 'bottom', 'fill': 'both'})	
+
+	self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
+
+	# see the other demos for other ways of specifying coords for a polygon
+	self.draw.create_polygon("0i", "0i", "3i", "0i", "3i", "3i", "0i" , "3i")
+
+	self.draw.pack({'side': 'left'})
+
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+
+test = Test()
+
+test.mainloop()

Demo/tkinter/matt/canvas-gridding.py

+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. 
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'bg': 'red', 
+				  'fg': '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'})
+
+    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)
+
+    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)
+
+	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()
+
+	# 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
+
+	Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
+	Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
+	
+
+test = Test()
+
+test.mainloop()

Demo/tkinter/matt/canvas-moving-or-creating.py

+from Tkinter import *
+
+# this file demonstrates a more sophisticated movement -- 
+# move dots or create new ones if you click outside the dots
+
+class Test(Frame):
+    ###################################################################
+    ###### 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", "tag" : "current"})
+
+	    self.draw.bind(fred, "<Any-Enter>", self.mouseEnter)
+	    self.draw.bind(fred, "<Any-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
+
+    ###################################################################
+    ###### 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"})
+	
+    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"})
+
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': '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)
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+
+test = Test()
+test.mainloop()
+
+
+

Demo/tkinter/matt/canvas-moving-w-mouse.py

+from Tkinter import *
+
+# this file demonstrates the movement of a single canvas item under mouse control
+
+class Test(Frame):
+    ###################################################################
+    ###### 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
+		
+	
+    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
+
+    ###################################################################
+    ###### 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"})
+	
+    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"})
+
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': '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", "tag" : "selected"})
+
+	self.draw.bind(fred, "<Any-Enter>", self.mouseEnter)
+	self.draw.bind(fred, "<Any-Leave>", self.mouseLeave)
+	    
+
+	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()
+
+test = Test()
+test.mainloop()

Demo/tkinter/matt/canvas-mult-item-sel.py

+from Tkinter import *
+
+# allows moving dots with multiple selection. 
+
+SELECTED_COLOR = "red"
+UNSELECTED_COLOR = "blue"
+
+class Test(Frame):
+    ###################################################################
+    ###### 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"):
+	    # 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})
+
+	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
+
+    def makeNewDot(self):
+	# create a dot, and mark it as current
+	fred = self.draw.create_oval(0, 0, 20, 20, 
+				     {"fill" : SELECTED_COLOR, "tag" : "current"})
+	# and make it selected
+	self.draw.addtag("selected", "withtag", "current")
+	
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': '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)
+
+
+	# and other things.....
+	self.button = Button(self, {"text" : "make a new dot",
+				    "command" : self.makeNewDot,
+				    "fg" : "blue"})
+
+	self.label = Message(self,
+			     {"width" : "5i", 
+			      "text" : SELECTED_COLOR + " dots are selected and can be dragged.\n" +
+   			               UNSELECTED_COLOR + " are not selected.\n" +
+				             "Click in a dot to select it.\n" +
+				             "Click on empty space to deselect all dots." })
+
+	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()
+
+test = Test()
+test.mainloop()
+
+
+

Demo/tkinter/matt/canvas-reading-tag-info.py

+from Tkinter import *
+
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': 'red', 
+				  'command': self.quit})
+	self.QUIT.pack({'side': 'bottom', 'fill': 'both'})	
+
+	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"})
+
+	# 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], "<-- 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]
+
+	self.drawing.pack({'side': 'left'})
+
+
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+
+test = Test()
+
+test.mainloop()

Demo/tkinter/matt/canvas-w-widget-draw-el.py

+from Tkinter import *
+
+# this file demonstrates the creation of widgets as part of a canvas object
+
+class Test(Frame):
+    def printhi(self):
+	print "hi"
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': 'red', 
+				  'command': self.quit})
+	self.QUIT.pack({'side': 'bottom', 'fill': 'both'})	
+
+	self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
+
+	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})
+
+	self.draw.pack({'side': 'left'})
+
+
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+
+test = Test()
+
+test.mainloop()

Demo/tkinter/matt/canvas-with-scrollbars.py

+from Tkinter import *
+
+# 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"
+
+    def createWidgets(self):
+	self.question = Label(self, {"text":  "Can Find The BLUE Square??????", 
+				     Pack : {"side" : "top"}})
+	
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'bg': 'red', 
+				  "height" : "3", 
+				  'command': self.quit})
+	self.QUIT.pack({'side': 'bottom', 'fill': 'both'})	
+	spacer = Frame(self, {"height" : "0.25i", 
+			      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", 
+				  "bg" : "white", 
+				  "scrollregion" : "0i 0i 20i 20i"})
+
+	
+	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['xscroll'] = self.draw.scrollX.set
+	self.draw['yscroll'] = 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_polygon("0i", "0i", "3.5i", "0i", "3.5i", "3.5i", "0i" , "3.5i")
+	self.draw.create_polygon("10i", "10i", "13.5i", "10i", "13.5i", "13.5i", "10i" , "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'})
+
+
+    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()
+
+test = Test()
+
+test.mainloop()

Demo/tkinter/matt/dialog-box.py

+from Tkinter import *
+
+# this shows how to create a new window with a button in it that can create new windows
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def makeWindow(self):
+	# there is no Tkinter interface to the dialog box. Making one would mean putting 
+	# a few wrapper functions in the Tkinter.py file.
+	# even better is to put in a SUIT-like selection of commonly-used dialogs.
+	# the parameters to this call are as follows: 
+
+	fred = Toplevel()               # a toplevel window that the dialog goes into
+
+
+	# this function returns the index of teh button chosen. In this case, 0 for "yes" and 1 for "no"
+
+	print self.tk.call("tk_dialog",           # the command name
+			   fred,                  # the name of a toplevel window
+			   "fred the dialog box", # the title on the window
+			   "click on a choice",   # the message to appear in the window
+			   "info",                # the bitmap (if any) to appear. If no bitmap is desired, pass ""
+			                          #     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      any X bitmap where fname is the path to the file  
+			                          #
+			   "0",                   # the index of the default button choice. hitting return selects this
+			   "yes", "no")           # all remaining parameters are the labels for the 
+	                                          # buttons that appear left to right in the dialog box
+
+      
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': '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'})
+
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.windownum = 0 
+	self.createWidgets()
+
+test = Test()
+test.mainloop()

Demo/tkinter/matt/entry-simple.py

+from Tkinter import *
+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()
+
+	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)
+
+    def print_contents(self, event):
+	print "hi. contents of entry is now ---->", self.entrythingy.get()
+
+root = App()
+root.master.title("Foo")
+root.mainloop()
+

Demo/tkinter/matt/entry-with-shared-variable.py

+from Tkinter import *
+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()
+
+	self.entrythingy = Entry()
+	self.entrythingy.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})
+
+	# 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 
+        # 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)
+
+    def print_contents(self, event):
+	print "hi. contents of entry is now ---->", self.contents.get()
+
+root = App()
+root.master.title("Foo")
+root.mainloop()
+

Demo/tkinter/matt/killing-window-w-wm.py

+from Tkinter import *
+
+# 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). 
+
+
+### ******* this isn't really called -- read the comments
+def my_delete_callback():
+    print "whoops -- tried to delete me!"
+
+class Test(Frame):
+    def deathHandler(self, event):
+	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'})
+
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+
+	###
+	###  PREVENT WM kills from happening
+	###
+
+	# the docs would have you do this: 
+
+#	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)
+
+
+test = Test()
+test.mainloop()

Demo/tkinter/matt/menu-all-types-of-entries.py

+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 
+# pretty closely
+# 
+# 
+# 
+#       This is a MENUBUTTON
+#       V
+# +-------------+
+# |             |
+# 
+# +------------++------------++------------+
+# |            ||            ||            |
+# |  File      ||  Edit      || Options    |   <-------- the MENUBAR
+# |            ||            ||            |
+# +------------++------------++------------+
+# | New...         |
+# | Open...        |
+# | Print          |
+# |                |  <-------- This is a MENU. The lines of text in the menu are
+# |                |                            MENU ENTRIES
+# |                +---------------+
+# | Open Files >   | file1         |               
+# |                | file2         |
+# |                | another file  | <------ this cascading part is also a MENU
+# +----------------|               |
+#                  |               |
+#                  |               |
+#                  |               |
+#                  +---------------+
+
+
+
+# some miscellaneous callbacks
+def new_file():
+    print "opening new file"
+
+
+def open_file():
+    print "opening OLD file"
+
+def print_something():
+    print "picked a menu item"
+
+
+
+anchovies = 0
+
+def print_anchovies():
+    global anchovies
+    anchovies = not anchovies
+    print "anchovies?", anchovies
+
+def makeCommandMenu():
+    # make menu button 
+    Command_button = Menubutton(mBar, {'text': 'Simple Button Commands', 
+				    'underline': 0,
+				    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...
+    Command_button.menu = Menu(Command_button)
+    
+
+    # just to be cute, let's disable the undo option:
+    Command_button.menu.add('command', {"label" : "Undo"} )
+    # 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': 'Different Font', 
+					'underline': 0, 
+					'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' : '@/home/mjc4y/ftp/tcl/tk3.6/library/demos/bitmaps/face'})
+    Command_button.menu.add('command', {'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': 'exit'})
+    
+    
+    # set up a pointer from the file menubutton back to the file menu
+    Command_button['menu'] = Command_button.menu
+
+    return Command_button
+
+
+
+def makeCascadeMenu():
+    # make menu button 
+    Cascade_button = Menubutton(mBar, {'text': 'Cascading Menus', 
+				       'underline': 0,
+				       Pack: {'side': 'left', 
+					      'padx': '2m'}})
+    
+    # the primary pulldown
+    Cascade_button.menu = Menu(Cascade_button)
+
+    # this is the menu that cascades from the primary pulldown....
+    Cascade_button.menu.choices = Menu(Cascade_button.menu)
+
+    # ...and this is a menu that cascades from that.
+    Cascade_button.menu.choices.wierdones = Menu(Cascade_button.menu.choices)
+
+    # then you define the menus from the deepest level on up.
+    Cascade_button.menu.choices.wierdones.add('command', {'label' : 'avacado'})
+    Cascade_button.menu.choices.wierdones.add('command', {'label' : 'belgian endive'})
+    Cascade_button.menu.choices.wierdones.add('command', {'label' : 'beefaroni'})
+
+    # definition of the menu one level up...
+    Cascade_button.menu.choices.add('command', {'label' : 'Chocolate'})
+    Cascade_button.menu.choices.add('command', {'label' : 'Vanilla'})
+    Cascade_button.menu.choices.add('command', {'label' : 'TuttiFruiti'})
+    Cascade_button.menu.choices.add('command', {'label' : 'WopBopaLoopBapABopBamBoom'})
+    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})
+
+    # and finally, the definition for the top level
+    Cascade_button.menu.add('cascade', {'label' : 'more choices', 
+					'menu' : Cascade_button.menu.choices})
+
+
+    Cascade_button['menu'] = Cascade_button.menu
+
+    return Cascade_button
+
+def makeCheckbuttonMenu():
+    global fred
+    # make menu button 
+    Checkbutton_button = Menubutton(mBar, {'text': 'Checkbutton Menus', 
+					   'underline': 0,
+					   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 
+    # 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})
+
+    # 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: 
+    #
+    # argument        what it does
+    # -----------------------------------
+    # 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 
+    #                    rules of Tcl_StringMatch
+    Checkbutton_button.menu.invoke(Checkbutton_button.menu.index('Anchovy'))
+
+    # set up a pointer from the file menubutton back to the file menu
+    Checkbutton_button['menu'] = Checkbutton_button.menu
+
+    return Checkbutton_button
+
+
+def makeRadiobuttonMenu():
+    # make menu button 
+    Radiobutton_button = Menubutton(mBar, {'text': 'Radiobutton Menus', 
+					   'underline': 0,
+					   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 
+    # work through the calback.
+    Radiobutton_button.menu.add('radiobutton', {'label': 'Republican'})
+    Radiobutton_button.menu.add('radiobutton', {'label': 'Democrat'})
+    Radiobutton_button.menu.add('radiobutton', {'label': 'Libertarian'})
+    Radiobutton_button.menu.add('radiobutton', {'label': 'Commie'})
+    Radiobutton_button.menu.add('radiobutton', {'label': 'Facist'})
+    Radiobutton_button.menu.add('radiobutton', {'label': 'Labor Party'})
+    Radiobutton_button.menu.add('radiobutton', {'label': 'Torie'})
+    Radiobutton_button.menu.add('radiobutton', {'label': 'Independent'})
+    Radiobutton_button.menu.add('radiobutton', {'label': 'Anarchist'})
+    Radiobutton_button.menu.add('radiobutton', {'label': 'No Opinion'})
+
+    # set up a pointer from the file menubutton back to the file menu
+    Radiobutton_button['menu'] = Radiobutton_button.menu
+
+    return Radiobutton_button
+
+
+def makeDisabledMenu(): 
+    Dummy_button = Menubutton(mBar, {'text': 'Dead Menu', 
+				     'underline': 0,
+				     Pack: {'side': 'left', 
+					    'padx': '2m'}})
+
+    # this is the standard way of turning off a whole menu
+    Dummy_button["state"] = "disabled"
+    return Dummy_button
+
+#################################################
+#### Main starts here ...
+root = Tk()
+
+
+# make a menu bar
+mBar = Frame(root, {'relief': 'raised', 
+		    'bd': 2,
+		    Pack: {'side': 'top', 
+			   'fill': 'x'}})
+
+Command_button     = makeCommandMenu()
+Cascade_button     = makeCascadeMenu()
+Checkbutton_button = makeCheckbuttonMenu()
+Radiobutton_button = makeRadiobuttonMenu()
+NoMenu             = makeDisabledMenu()
+
+# 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)
+
+
+root.title('menu demo')
+root.iconname('menu demo')
+
+root.mainloop()
+
+
+
+
+
+

Demo/tkinter/matt/menu-simple.py

+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 
+# pretty closely
+# 
+# 
+# 
+#       This is a MENUBUTTON
+#       V
+# +-------------+
+# |             |
+# 
+# +------------++------------++------------+
+# |            ||            ||            |
+# |  File      ||  Edit      || Options    |   <-------- the MENUBAR
+# |            ||            ||            |
+# +------------++------------++------------+
+# | New...         |
+# | Open...        |
+# | Print          |
+# |                |  <-------- This is a MENU. The lines of text in the menu are
+# |                |                            MENU ENTRIES
+# |                +---------------+
+# | Open Files >   | file1         |               
+# |                | file2         |
+# |                | another file  | <------ this cascading part is also a MENU
+# +----------------|               |
+#                  |               |
+#                  |               |
+#                  |               |
+#                  +---------------+
+
+
+
+def new_file():
+    print "opening new file"
+
+
+def open_file():
+    print "opening OLD file"
+
+
+def makeFileMenu():
+    # make menu button : "File"
+    File_button = Menubutton(mBar, {'text': 'File', 
+				    'underline': 0,
+				    Pack: {'side': 'left', 
+					   'padx': '1m'}})
+    
+    # make the pulldown part of the File menu. The parameter passed is the master.
+    # we attach it to the File button as a python attribute called "menu" by convention.
+    # hopefully this isn't too confusing...
+    File_button.menu = Menu(File_button)
+    
+    # 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'})
+    
+    
+    # set up a pointer from the file menubutton back to the file menu
+    File_button['menu'] = File_button.menu
+
+    return File_button
+
+
+
+def makeEditMenu():
+    Edit_button = Menubutton(mBar, {'text': 'Edit', 
+				    'underline': 0,
+				    Pack: {'side': 'left', 
+					   'padx' : '1m'}})
+    Edit_button.menu = Menu(Edit_button)
+
+    # just to be cute, let's disable the undo option:
+    Edit_button.menu.add('command', {"label" : "Undo"} )
+    # undo is the 0th entry...
+    Edit_button.menu.entryconfig(0, {"state" : "disabled"})
+
+    # and these are just for show. No "command" callbacks attached.
+    Edit_button.menu.add('command', {"label" : "Cut"} )
+    Edit_button.menu.add('command', {"label" : "Copy"} )
+    Edit_button.menu.add('command', {"label" : "Paste"} )
+					
+    # set up a pointer from the file menubutton back to the file menu
+    Edit_button['menu'] = Edit_button.menu
+
+    return Edit_button
+
+
+#################################################
+
+#### Main starts here ...
+root = Tk()
+
+
+# make a menu bar
+mBar = Frame(root, {'relief': 'raised', 
+		    'bd': 2,
+		    Pack: {'side': 'top', 
+			   'fill': 'x'}})
+
+File_button = makeFileMenu()
+Edit_button = makeEditMenu()
+
+# 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)
+
+
+root.title('menu demo')
+root.iconname('packer')
+
+root.mainloop()
+
+
+
+
+
+

Demo/tkinter/matt/not-what-you-might-think-1.py

+from Tkinter import *
+
+
+class Test(Frame):
+    def createWidgets(self):
+
+	self.Gpanel = Frame(self, {'width': '1i', 
+				   'height' : '1i',
+				   'bg' : 'green'}) 
+	self.Gpanel.pack({'side' : 'left'})
+
+
+	# a QUIT button
+	self.Gpanel.QUIT = Button(self.Gpanel, {'text': 'QUIT', 
+						'fg': 'red',
+						'command': self.quit})
+	self.Gpanel.QUIT.pack( {'side': 'left'})
+
+
+
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+
+test = Test()
+
+test.master.title('packer demo')
+test.master.iconname('packer')
+
+test.mainloop()

Demo/tkinter/matt/not-what-you-might-think-2.py

+from Tkinter import *
+
+
+class Test(Frame):
+    def createWidgets(self):
+
+	self.Gpanel = Frame(self, {'width': '1i', 
+				   'height' : '1i',
+				   'bg' : 'green'})
+
+	# this line turns off the recalculation of geometry by masters.
+	self.Gpanel.tk.call('pack', 'propagate', str(self.Gpanel), "0")
+
+	self.Gpanel.pack({'side' : 'left'})
+
+
+
+	# a QUIT button
+	self.Gpanel.QUIT = Button(self.Gpanel, {'text': 'QUIT', 
+						'fg': 'red',
+						'command': self.quit})
+	self.Gpanel.QUIT.pack( {'side': 'left'})
+
+	
+
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+
+test = Test()
+
+test.master.title('packer demo')
+test.master.iconname('packer')
+
+test.mainloop()

Demo/tkinter/matt/packer-and-placer-together.py

+from Tkinter import *
+
+# 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
+
+
+def do_motion(event):
+    app.button.place({'x' : event.x, 
+		      'y' : event.y})
+
+def dothis():
+    print 'calling me!'
+
+def createWidgets(top):
+    # make a frame. Note that the widget is 200 x 200
+    # and the window containing is 400x400. We do this
+    # simply to show that this is possible. The rest of the
+    # area is inaccesssible.
+    f = Frame(top, {'width' : '200', 
+		    'height' : '200',
+		    'bg' : 'green'})
+
+    # 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, {'fg' : 'red', 
+			  'text' : 'amazing', 
+			  'command' : dothis})
+    
+    # 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'})
+    
+    # allow the user to move the button SUIT-style.
+    f.bind('<Control-Shift-Motion>', do_motion)
+
+    return f
+
+root = Tk()
+app = createWidgets(root)
+root.geometry("400x400")
+root.maxsize(1000, 1000)
+root.mainloop()
+

Demo/tkinter/matt/packer-simple.py

+from Tkinter import *
+
+
+class Test(Frame):
+    def printit(self):
+	print self.hi_there["command"]
+
+    def createWidgets(self):
+	# a hello button
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': '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'})
+
+	# note how Packer defaults to {'side': 'top'}
+
+	self.guy2 = Button(self, {'text': 'button 2'})
+	self.guy2.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()
+
+test = Test()
+test.mainloop()

Demo/tkinter/matt/placer-simple.py

+from Tkinter import *
+
+# This is a program that tests the placer geom manager
+
+def do_motion(event):
+    app.button.place({'x' : event.x, 
+		      'y' : event.y})
+
+def dothis():
+    print 'calling me!'
+
+def createWidgets(top):
+    # make a frame. Note that the widget is 200 x 200
+    # and the window containing is 400x400. We do this
+    # simply to show that this is possible. The rest of the
+    # area is inaccesssible.
+    f = Frame(top, {'width' : '200', 
+		    'height' : '200',
+		    'bg' : 'green'})
+
+    # 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'})
+
+    # now make a button
+    f.button = Button(f, {'fg' : 'red', 
+			  'text' : 'amazing', 
+			  'command' : dothis})
+    
+    # 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'})
+    
+    # allow the user to move the button SUIT-style.
+    f.bind('<Control-Shift-Motion>', do_motion)
+
+    return f
+
+root = Tk()
+app = createWidgets(root)
+root.geometry("400x400")
+root.maxsize(1000, 1000)
+root.mainloop()
+

Demo/tkinter/matt/pong-demo-1.py

+from Tkinter import *
+
+import string
+
+
+class Pong(Frame):
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': 'red', 
+				  'command': self.quit})
+	self.QUIT.pack({'side': 'left', 'fill': 'both'})	
+
+	## The playing field
+	self.draw = Canvas(self, {"width" : "5i", "height" : "5i"})
+
+	## The speed control for the ball
+	self.speed = Scale(self, {"orient":  "horiz", 
+				  "label" : "ball speed", 
+				  "from" : -100, 
+				  "to" : 100})
+
+	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
+
+	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
+
+	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,  `deltax` + "i", `deltay` + "i")
+	self.after(10, self.moveBall)
+	
+
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+	self.after(10, self.moveBall)
+
+
+game = Pong()
+
+game.mainloop()

Demo/tkinter/matt/printing-coords-of-items.py

+from Tkinter import *
+
+# this file demonstrates the creation of widgets as part of a canvas object
+
+class Test(Frame):
+    ###################################################################
+    ###### 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", "tag" : "current"})
+
+	    self.draw.bind(fred, "<Any-Enter>", self.mouseEnter)
+	    self.draw.bind(fred, "<Any-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
+
+    ###################################################################
+    ###### 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.tk.splitlist(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"})
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': '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)
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+
+test = Test()
+test.mainloop()
+
+
+

Demo/tkinter/matt/radiobutton-simple.py

+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 
+# 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.
+
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def createWidgets(self):
+
+	self.flavor = StringVar()
+	self.flavor.set("chocolate")
+
+	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", 
+							      Pack : {"side" : "top", "fill" : "x"}})
+
+	self.radioframe.straw = Radiobutton (self.radioframe, {"text" : "Strawberry Flavor", 
+							       "variable" : self.flavor,
+							      "anchor" : "w", 
+							       "value" : "strawberry", 
+							       Pack : {"side" : "top", "fill" : "x"}})
+
+	self.radioframe.lemon = Radiobutton (self.radioframe, {"text" : "Lemon Flavor", 
+							      "anchor" : "w", 
+							       "variable" : self.flavor,
+							       "value" : "lemon", 
+							       Pack : {"side" : "top", "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, 
+				  Pack : {"side" : "top", "fill" : "x"}})
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': '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()
+
+test = Test()
+
+test.mainloop()

Demo/tkinter/matt/rubber-band-box-demo-1.py

+from Tkinter import *
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'bg': 'red', 
+				  'fg': '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'})
+
+    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)
+
+    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)
+
+	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()
+
+	# 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()
+
+test.mainloop()

Demo/tkinter/matt/rubber-line-demo-1.py

+from Tkinter import *
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'bg': 'red', 
+				  'fg': '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'})
+
+    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)
+
+    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)
+
+	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)
+	
+
+test = Test()
+
+test.mainloop()

Demo/tkinter/matt/slider-demo-1.py

+from Tkinter import *
+
+# shows how to make a slider, set and get its value under program control
+
+
+class Test(Frame):
+    def print_value(self, val):
+	print "slider now at", val
+
+    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.reset = Button(self, {'text': 'reset slider', 
+				  'command': self.reset})
+	
+
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': 'red', 
+				  'command': self.quit})
+	
+
+	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()
+
+test = Test()
+test.mainloop()

Demo/tkinter/matt/subclass-existing-widgets.py

+from Tkinter import *
+
+# This is a program that makes a simple two button application
+
+
+class New_Button(Button):
+    def callback(self):
+	print self.counter
+	self.counter = self.counter + 1
+    
+def createWidgets(top):
+    f = Frame(top)
+    f.pack()
+    f.QUIT = Button(f, {'text': 'QUIT', 
+			    'fg': 'red', 
+			    'command': top.quit})
+	
+    f.QUIT.pack({'side': 'left', 'fill': 'both'})
+
+
+    # a hello button
+    f.hi_there = New_Button(f, {'text': 'Hello'})
+    # we do this on a different line because we need to reference f.hi_there
+    f.hi_there.config({'command' : f.hi_there.callback})
+    f.hi_there.pack({'side': 'left'})
+    f.hi_there.counter = 43
+
+
+
+root = Tk()
+createWidgets(root)
+root.mainloop()
+

Demo/tkinter/matt/window-creation-more.py

+from Tkinter import *
+
+# this shows how to create a new window with a button in it that can create new windows
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def makeWindow(self):
+	fred = Toplevel()
+	fred.label = Button(fred, {'text': "This is window number " + `self.windownum` + "." , 
+				   'command' : self.makeWindow})
+	fred.label.pack()
+	self.windownum = self.windownum + 1
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': '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'})
+
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.windownum = 0 
+	self.createWidgets()
+
+test = Test()
+test.mainloop()

Demo/tkinter/matt/window-creation-simple.py

+from Tkinter import *
+
+# this shows how to spawn off new windows at a button press
+
+class Test(Frame):
+    def printit(self):
+	print "hi"
+
+    def makeWindow(self):
+	fred = Toplevel()
+	fred.label = Label(fred, {'text': "Here's a new window",})
+	fred.label.pack()
+
+    def createWidgets(self):
+	self.QUIT = Button(self, {'text': 'QUIT', 
+				  'fg': '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'})
+
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+
+test = Test()
+test.mainloop()

Demo/tkinter/matt/window-creation-w-location.py

+from Tkinter import *
+
+import sys
+sys.path.append("/users/mjc4y/projects/python/tkinter/utils")
+from TkinterUtils  import *
+
+# this shows how to create a new window with a button in it that can create new windows
+
+
+class Test(Frame):
+    def makeWindow(self, *args):
+	fred = Toplevel()
+
+	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()
+
+	centerWindow(fred, self.master)
+
+    def createWidgets(self):
+	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'})
+
+    def __init__(self, master=None):
+	Frame.__init__(self, master)
+	Pack.config(self)
+	self.createWidgets()
+
+test = Test()
+test.mainloop()