diff options
Diffstat (limited to 'Demo/tkinter')
33 files changed, 1876 insertions, 0 deletions
diff --git a/Demo/tkinter/matt/00-HELLO-WORLD.py b/Demo/tkinter/matt/00-HELLO-WORLD.py new file mode 100644 index 0000000..9e8ccf4 --- /dev/null +++ b/Demo/tkinter/matt/00-HELLO-WORLD.py @@ -0,0 +1,30 @@ +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() diff --git a/Demo/tkinter/matt/README b/Demo/tkinter/matt/README new file mode 100644 index 0000000..eb9d302 --- /dev/null +++ b/Demo/tkinter/matt/README @@ -0,0 +1,30 @@ +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 + + + diff --git a/Demo/tkinter/matt/animation-simple.py b/Demo/tkinter/matt/animation-simple.py new file mode 100644 index 0000000..0158793 --- /dev/null +++ b/Demo/tkinter/matt/animation-simple.py @@ -0,0 +1,36 @@ +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() diff --git a/Demo/tkinter/matt/animation-w-velocity-ctrl.py b/Demo/tkinter/matt/animation-w-velocity-ctrl.py new file mode 100644 index 0000000..d16e8a0 --- /dev/null +++ b/Demo/tkinter/matt/animation-w-velocity-ctrl.py @@ -0,0 +1,51 @@ +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() diff --git a/Demo/tkinter/matt/canvas-demo-simple.py b/Demo/tkinter/matt/canvas-demo-simple.py new file mode 100644 index 0000000..c8ebfa7 --- /dev/null +++ b/Demo/tkinter/matt/canvas-demo-simple.py @@ -0,0 +1,30 @@ +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() diff --git a/Demo/tkinter/matt/canvas-gridding.py b/Demo/tkinter/matt/canvas-gridding.py new file mode 100644 index 0000000..3524084 --- /dev/null +++ b/Demo/tkinter/matt/canvas-gridding.py @@ -0,0 +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. + +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() diff --git a/Demo/tkinter/matt/canvas-moving-or-creating.py b/Demo/tkinter/matt/canvas-moving-or-creating.py new file mode 100644 index 0000000..f58cc97 --- /dev/null +++ b/Demo/tkinter/matt/canvas-moving-or-creating.py @@ -0,0 +1,70 @@ +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() + + + diff --git a/Demo/tkinter/matt/canvas-moving-w-mouse.py b/Demo/tkinter/matt/canvas-moving-w-mouse.py new file mode 100644 index 0000000..fab480b --- /dev/null +++ b/Demo/tkinter/matt/canvas-moving-w-mouse.py @@ -0,0 +1,60 @@ +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() diff --git a/Demo/tkinter/matt/canvas-mult-item-sel.py b/Demo/tkinter/matt/canvas-mult-item-sel.py new file mode 100644 index 0000000..1e49ba6 --- /dev/null +++ b/Demo/tkinter/matt/canvas-mult-item-sel.py @@ -0,0 +1,85 @@ +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() + + + diff --git a/Demo/tkinter/matt/canvas-reading-tag-info.py b/Demo/tkinter/matt/canvas-reading-tag-info.py new file mode 100644 index 0000000..1478621 --- /dev/null +++ b/Demo/tkinter/matt/canvas-reading-tag-info.py @@ -0,0 +1,51 @@ +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() diff --git a/Demo/tkinter/matt/canvas-w-widget-draw-el.py b/Demo/tkinter/matt/canvas-w-widget-draw-el.py new file mode 100644 index 0000000..5453859 --- /dev/null +++ b/Demo/tkinter/matt/canvas-w-widget-draw-el.py @@ -0,0 +1,39 @@ +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() diff --git a/Demo/tkinter/matt/canvas-with-scrollbars.py b/Demo/tkinter/matt/canvas-with-scrollbars.py new file mode 100644 index 0000000..fcbcd15 --- /dev/null +++ b/Demo/tkinter/matt/canvas-with-scrollbars.py @@ -0,0 +1,67 @@ +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() diff --git a/Demo/tkinter/matt/dialog-box.py b/Demo/tkinter/matt/dialog-box.py new file mode 100644 index 0000000..e40c72e --- /dev/null +++ b/Demo/tkinter/matt/dialog-box.py @@ -0,0 +1,65 @@ +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() diff --git a/Demo/tkinter/matt/entry-simple.py b/Demo/tkinter/matt/entry-simple.py new file mode 100644 index 0000000..cf82b89 --- /dev/null +++ b/Demo/tkinter/matt/entry-simple.py @@ -0,0 +1,25 @@ +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() + diff --git a/Demo/tkinter/matt/entry-with-shared-variable.py b/Demo/tkinter/matt/entry-with-shared-variable.py new file mode 100644 index 0000000..5eb8c5a --- /dev/null +++ b/Demo/tkinter/matt/entry-with-shared-variable.py @@ -0,0 +1,47 @@ +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() + diff --git a/Demo/tkinter/matt/killing-window-w-wm.py b/Demo/tkinter/matt/killing-window-w-wm.py new file mode 100644 index 0000000..6ec3464 --- /dev/null +++ b/Demo/tkinter/matt/killing-window-w-wm.py @@ -0,0 +1,43 @@ +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() diff --git a/Demo/tkinter/matt/menu-all-types-of-entries.py b/Demo/tkinter/matt/menu-all-types-of-entries.py new file mode 100644 index 0000000..5341ca2 --- /dev/null +++ b/Demo/tkinter/matt/menu-all-types-of-entries.py @@ -0,0 +1,268 @@ +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() + + + + + + diff --git a/Demo/tkinter/matt/menu-simple.py b/Demo/tkinter/matt/menu-simple.py new file mode 100644 index 0000000..a1fc2fb --- /dev/null +++ b/Demo/tkinter/matt/menu-simple.py @@ -0,0 +1,132 @@ +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() + + + + + + diff --git a/Demo/tkinter/matt/not-what-you-might-think-1.py b/Demo/tkinter/matt/not-what-you-might-think-1.py new file mode 100644 index 0000000..6f5481e --- /dev/null +++ b/Demo/tkinter/matt/not-what-you-might-think-1.py @@ -0,0 +1,32 @@ +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() diff --git a/Demo/tkinter/matt/not-what-you-might-think-2.py b/Demo/tkinter/matt/not-what-you-might-think-2.py new file mode 100644 index 0000000..dd6c2ec --- /dev/null +++ b/Demo/tkinter/matt/not-what-you-might-think-2.py @@ -0,0 +1,37 @@ +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() diff --git a/Demo/tkinter/matt/packer-and-placer-together.py b/Demo/tkinter/matt/packer-and-placer-together.py new file mode 100644 index 0000000..64b3821 --- /dev/null +++ b/Demo/tkinter/matt/packer-and-placer-together.py @@ -0,0 +1,50 @@ +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() + diff --git a/Demo/tkinter/matt/packer-simple.py b/Demo/tkinter/matt/packer-simple.py new file mode 100644 index 0000000..4519a72 --- /dev/null +++ b/Demo/tkinter/matt/packer-simple.py @@ -0,0 +1,35 @@ +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() diff --git a/Demo/tkinter/matt/placer-simple.py b/Demo/tkinter/matt/placer-simple.py new file mode 100644 index 0000000..724cb97 --- /dev/null +++ b/Demo/tkinter/matt/placer-simple.py @@ -0,0 +1,48 @@ +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() + diff --git a/Demo/tkinter/matt/pong-demo-1.py b/Demo/tkinter/matt/pong-demo-1.py new file mode 100644 index 0000000..7d405c1 --- /dev/null +++ b/Demo/tkinter/matt/pong-demo-1.py @@ -0,0 +1,59 @@ +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() diff --git a/Demo/tkinter/matt/printing-coords-of-items.py b/Demo/tkinter/matt/printing-coords-of-items.py new file mode 100644 index 0000000..2440378 --- /dev/null +++ b/Demo/tkinter/matt/printing-coords-of-items.py @@ -0,0 +1,69 @@ +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() + + + diff --git a/Demo/tkinter/matt/radiobutton-simple.py b/Demo/tkinter/matt/radiobutton-simple.py new file mode 100644 index 0000000..a94a74c --- /dev/null +++ b/Demo/tkinter/matt/radiobutton-simple.py @@ -0,0 +1,66 @@ +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() diff --git a/Demo/tkinter/matt/rubber-band-box-demo-1.py b/Demo/tkinter/matt/rubber-band-box-demo-1.py new file mode 100644 index 0000000..8d382ca --- /dev/null +++ b/Demo/tkinter/matt/rubber-band-box-demo-1.py @@ -0,0 +1,57 @@ +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() diff --git a/Demo/tkinter/matt/rubber-line-demo-1.py b/Demo/tkinter/matt/rubber-line-demo-1.py new file mode 100644 index 0000000..8dd1070 --- /dev/null +++ b/Demo/tkinter/matt/rubber-line-demo-1.py @@ -0,0 +1,50 @@ +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() diff --git a/Demo/tkinter/matt/slider-demo-1.py b/Demo/tkinter/matt/slider-demo-1.py new file mode 100644 index 0000000..0d487ab --- /dev/null +++ b/Demo/tkinter/matt/slider-demo-1.py @@ -0,0 +1,40 @@ +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() diff --git a/Demo/tkinter/matt/subclass-existing-widgets.py b/Demo/tkinter/matt/subclass-existing-widgets.py new file mode 100644 index 0000000..3a0e196 --- /dev/null +++ b/Demo/tkinter/matt/subclass-existing-widgets.py @@ -0,0 +1,33 @@ +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() + diff --git a/Demo/tkinter/matt/window-creation-more.py b/Demo/tkinter/matt/window-creation-more.py new file mode 100644 index 0000000..e8d4a35 --- /dev/null +++ b/Demo/tkinter/matt/window-creation-more.py @@ -0,0 +1,37 @@ +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() diff --git a/Demo/tkinter/matt/window-creation-simple.py b/Demo/tkinter/matt/window-creation-simple.py new file mode 100644 index 0000000..d881abe --- /dev/null +++ b/Demo/tkinter/matt/window-creation-simple.py @@ -0,0 +1,34 @@ +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() diff --git a/Demo/tkinter/matt/window-creation-w-location.py b/Demo/tkinter/matt/window-creation-w-location.py new file mode 100644 index 0000000..8f9ad47 --- /dev/null +++ b/Demo/tkinter/matt/window-creation-w-location.py @@ -0,0 +1,40 @@ +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() |