--- /dev/null
+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()
--- /dev/null
+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
+
+
+
--- /dev/null
+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()
--- /dev/null
+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()
--- /dev/null
+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()
--- /dev/null
+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()
--- /dev/null
+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()
+
+
+
--- /dev/null
+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()
--- /dev/null
+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()
+
+
+
--- /dev/null
+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()
--- /dev/null
+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()
--- /dev/null
+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()
--- /dev/null
+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()
--- /dev/null
+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()
+
--- /dev/null
+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()
+
--- /dev/null
+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()
--- /dev/null
+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()
+
+
+
+
+
+
--- /dev/null
+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()
+
+
+
+
+
+
--- /dev/null
+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()
--- /dev/null
+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()
--- /dev/null
+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()
+
--- /dev/null
+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()
--- /dev/null
+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()
+
--- /dev/null
+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()
--- /dev/null
+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()
+
+
+
--- /dev/null
+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()
--- /dev/null
+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()
--- /dev/null
+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()
--- /dev/null
+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()
--- /dev/null
+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()
+
--- /dev/null
+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()
--- /dev/null
+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()
--- /dev/null
+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()
projects / thirdparty / Python / cpython.git / commitdiff
