mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-07-24 03:35:53 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

Whitespace normalization, via reindent.py.

Browse source
This commit is contained in:
Tim Peters 2004-07-18 06:16:08 +00:00
parent e6ddc8b20b
commit 182b5aca27
453 changed files with 31318 additions and 31452 deletions
Download patch file Download diff file Expand all files Collapse all files

28
Demo/tkinter/matt/00-HELLO-WORLD.py
View file

@ -1,27 +1,27 @@
from Tkinter import *
# note that there is no explicit call to start Tk.
# Tkinter is smart enough to start the system if it's not already going.
# note that there is no explicit call to start Tk.
# Tkinter is smart enough to start the system if it's not already going.
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
# a hello button
self.hi_there = Button(self, text='Hello',
command=self.printit)
self.hi_there.pack(side=LEFT)
self.QUIT.pack(side=LEFT, fill=BOTH)
# a hello button
self.hi_there = Button(self, text='Hello',
command=self.printit)
self.hi_there.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()
test.mainloop()

30
Demo/tkinter/matt/animation-simple.py
View file

@ -4,30 +4,30 @@ from Tkinter import *
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.draw = Canvas(self, width="5i", height="5i")
self.draw = Canvas(self, width="5i", height="5i")
# all of these work..
self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
self.draw.pack(side=LEFT)
# all of these work..
self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
self.draw.pack(side=LEFT)
def moveThing(self, *args):
# move 1/10 of an inch every 1/10 sec (1" per second, smoothly)
self.draw.move("thing", "0.01i", "0.01i")
self.after(10, self.moveThing)
# move 1/10 of an inch every 1/10 sec (1" per second, smoothly)
self.draw.move("thing", "0.01i", "0.01i")
self.after(10, self.moveThing)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
self.after(10, self.moveThing)
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
self.after(10, self.moveThing)
test = Test()

46
Demo/tkinter/matt/animation-w-velocity-ctrl.py
View file

@ -1,42 +1,42 @@
from Tkinter import *
# this is the same as simple-demo-1.py, but uses
# subclassing.
# note that there is no explicit call to start Tk.
# Tkinter is smart enough to start the system if it's not already going.
# this is the same as simple-demo-1.py, but uses
# subclassing.
# note that there is no explicit call to start Tk.
# Tkinter is smart enough to start the system if it's not already going.
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.draw = Canvas(self, width="5i", height="5i")
self.draw = Canvas(self, width="5i", height="5i")
self.speed = Scale(self, orient=HORIZONTAL, from_=-100, to=100)
self.speed = Scale(self, orient=HORIZONTAL, from_=-100, to=100)
self.speed.pack(side=BOTTOM, fill=X)
self.speed.pack(side=BOTTOM, fill=X)
# all of these work..
self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
self.draw.pack(side=LEFT)
# all of these work..
self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
self.draw.pack(side=LEFT)
def moveThing(self, *args):
velocity = self.speed.get()
str = float(velocity) / 1000.0
str = "%ri" % (str,)
self.draw.move("thing", str, str)
self.after(10, self.moveThing)
velocity = self.speed.get()
str = float(velocity) / 1000.0
str = "%ri" % (str,)
self.draw.move("thing", str, str)
self.after(10, self.moveThing)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
self.after(10, self.moveThing)
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
self.after(10, self.moveThing)
test = Test()

40
Demo/tkinter/matt/bind-w-mult-calls-p-type.py
View file

@ -1,34 +1,34 @@
from Tkinter import *
import string
import string
# This program shows how to use a simple type-in box
class App(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.pack()
Frame.__init__(self, master)
self.pack()
self.entrythingy = Entry()
self.entrythingy.pack()
self.entrythingy = Entry()
self.entrythingy.pack()
# and here we get a callback when the user hits return. we could
# make the key that triggers the callback anything we wanted to.
# other typical options might be <Key-Tab> or <Key> (for anything)
self.entrythingy.bind('<Key-Return>', self.print_contents)
# and here we get a callback when the user hits return. we could
# make the key that triggers the callback anything we wanted to.
# other typical options might be <Key-Tab> or <Key> (for anything)
self.entrythingy.bind('<Key-Return>', self.print_contents)
# Note that here is where we bind a completely different callback to
# the same event. We pass "+" here to indicate that we wish to ADD
# this callback to the list associated with this event type.
# Not specifying "+" would simply override whatever callback was
# defined on this event.
self.entrythingy.bind('<Key-Return>', self.print_something_else, "+")
# Note that here is where we bind a completely different callback to
# the same event. We pass "+" here to indicate that we wish to ADD
# this callback to the list associated with this event type.
# Not specifying "+" would simply override whatever callback was
# defined on this event.
self.entrythingy.bind('<Key-Return>', self.print_something_else, "+")
def print_contents(self, event):
print "hi. contents of entry is now ---->", self.entrythingy.get()
print "hi. contents of entry is now ---->", self.entrythingy.get()
def print_something_else(self, event):
print "hi. Now doing something completely different"
print "hi. Now doing something completely different"
root = App()
@ -37,8 +37,8 @@ root.mainloop()
# secret tip for experts: if you pass *any* non-false value as
# the third parameter to bind(), Tkinter.py will accumulate
# secret tip for experts: if you pass *any* non-false value as
# the third parameter to bind(), Tkinter.py will accumulate
# callbacks instead of overwriting. I use "+" here because that's
# the Tk notation for getting this sort of behavior. The perfect GUI
# the Tk notation for getting this sort of behavior. The perfect GUI
# interface would use a less obscure notation.

22
Demo/tkinter/matt/canvas-demo-simple.py
View file

@ -4,24 +4,24 @@ from Tkinter import *
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.draw = Canvas(self, width="5i", height="5i")
self.draw = Canvas(self, width="5i", height="5i")
# see the other demos for other ways of specifying coords for a polygon
self.draw.create_rectangle(0, 0, "3i", "3i", fill="black")
# see the other demos for other ways of specifying coords for a polygon
self.draw.create_rectangle(0, 0, "3i", "3i", fill="black")
self.draw.pack(side=LEFT)
self.draw.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()

78
Demo/tkinter/matt/canvas-gridding.py
View file

@ -1,60 +1,60 @@
from Tkinter import *
# this is the same as simple-demo-1.py, but uses
# subclassing.
# note that there is no explicit call to start Tk.
# Tkinter is smart enough to start the system if it's not already going.
# this is the same as simple-demo-1.py, but uses
# subclassing.
# note that there is no explicit call to start Tk.
# Tkinter is smart enough to start the system if it's not already going.
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def createWidgets(self):
self.QUIT = Button(self, text='QUIT',
background='red',
foreground='white',
height=3,
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.QUIT = Button(self, text='QUIT',
background='red',
foreground='white',
height=3,
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.canvasObject = Canvas(self, width="5i", height="5i")
self.canvasObject.pack(side=LEFT)
self.canvasObject = Canvas(self, width="5i", height="5i")
self.canvasObject.pack(side=LEFT)
def mouseDown(self, event):
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
self.startx = self.canvasObject.canvasx(event.x, self.griddingSize)
self.starty = self.canvasObject.canvasy(event.y, self.griddingSize)
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
self.startx = self.canvasObject.canvasx(event.x, self.griddingSize)
self.starty = self.canvasObject.canvasy(event.y, self.griddingSize)
def mouseMotion(self, event):
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
x = self.canvasObject.canvasx(event.x, self.griddingSize)
y = self.canvasObject.canvasy(event.y, self.griddingSize)
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
x = self.canvasObject.canvasx(event.x, self.griddingSize)
y = self.canvasObject.canvasy(event.y, self.griddingSize)
if (self.startx != event.x) and (self.starty != event.y) :
self.canvasObject.delete(self.rubberbandBox)
self.rubberbandBox = self.canvasObject.create_rectangle(
self.startx, self.starty, x, y)
# this flushes the output, making sure that
# the rectangle makes it to the screen
# before the next event is handled
self.update_idletasks()
if (self.startx != event.x) and (self.starty != event.y) :
self.canvasObject.delete(self.rubberbandBox)
self.rubberbandBox = self.canvasObject.create_rectangle(
self.startx, self.starty, x, y)
# this flushes the output, making sure that
# the rectangle makes it to the screen
# before the next event is handled
self.update_idletasks()
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
# this is a "tagOrId" for the rectangle we draw on the canvas
self.rubberbandBox = None
# this is a "tagOrId" for the rectangle we draw on the canvas
self.rubberbandBox = None
# this is the size of the gridding squares
self.griddingSize = 50
# this is the size of the gridding squares
self.griddingSize = 50
Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
test = Test()

69
Demo/tkinter/matt/canvas-moving-or-creating.py
View file

@ -1,6 +1,6 @@
from Tkinter import *
# this file demonstrates a more sophisticated movement --
# this file demonstrates a more sophisticated movement --
# move dots or create new ones if you click outside the dots
class Test(Frame):
@ -8,58 +8,55 @@ 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", tags=CURRENT)
# see if we're inside a dot. If we are, it
# gets tagged as CURRENT for free by tk.
if not event.widget.find_withtag(CURRENT):
# there is no dot here, so we can make one,
# and bind some interesting behavior to it.
# ------
# create a dot, and mark it as CURRENT
fred = self.draw.create_oval(
event.x - 10, event.y -10, event.x +10, event.y + 10,
fill="green", tags=CURRENT)
self.draw.tag_bind(fred, "<Any-Enter>", self.mouseEnter)
self.draw.tag_bind(fred, "<Any-Leave>", self.mouseLeave)
self.draw.tag_bind(fred, "<Any-Enter>", self.mouseEnter)
self.draw.tag_bind(fred, "<Any-Leave>", self.mouseLeave)
self.lastx = event.x
self.lasty = event.y
self.lastx = event.x
self.lasty = event.y
def mouseMove(self, event):
self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
self.lastx = event.x
self.lasty = event.y
self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
self.lastx = event.x
self.lasty = event.y
###################################################################
###### Event callbacks for canvas ITEMS (stuff drawn on the canvas)
###################################################################
def mouseEnter(self, event):
# the CURRENT tag is applied to the object the cursor is over.
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="red")
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="red")
def mouseLeave(self, event):
# the CURRENT tag is applied to the object the cursor is over.
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="blue")
# the CURRENT tag is applied to the object the cursor is over.
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="blue")
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.draw = Canvas(self, width="5i", height="5i")
self.draw.pack(side=LEFT)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.draw = Canvas(self, width="5i", height="5i")
self.draw.pack(side=LEFT)
Widget.bind(self.draw, "<1>", self.mouseDown)
Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
Widget.bind(self.draw, "<1>", self.mouseDown)
Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()
test.mainloop()

54
Demo/tkinter/matt/canvas-moving-w-mouse.py
View file

@ -7,49 +7,49 @@ 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
# remember where the mouse went down
self.lastx = event.x
self.lasty = event.y
def mouseMove(self, event):
# whatever the mouse is over gets tagged as CURRENT for free by tk.
self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
self.lastx = event.x
self.lasty = event.y
# whatever the mouse is over gets tagged as CURRENT for free by tk.
self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
self.lastx = event.x
self.lasty = event.y
###################################################################
###### Event callbacks for canvas ITEMS (stuff drawn on the canvas)
###################################################################
def mouseEnter(self, event):
# the CURRENT tag is applied to the object the cursor is over.
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="red")
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="red")
def mouseLeave(self, event):
# the CURRENT tag is applied to the object the cursor is over.
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="blue")
# the CURRENT tag is applied to the object the cursor is over.
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="blue")
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.draw = Canvas(self, width="5i", height="5i")
self.draw.pack(side=LEFT)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.draw = Canvas(self, width="5i", height="5i")
self.draw.pack(side=LEFT)
fred = self.draw.create_oval(0, 0, 20, 20,
fill="green", tags="selected")
fred = self.draw.create_oval(0, 0, 20, 20,
fill="green", tags="selected")
self.draw.tag_bind(fred, "<Any-Enter>", self.mouseEnter)
self.draw.tag_bind(fred, "<Any-Leave>", self.mouseLeave)
self.draw.tag_bind(fred, "<Any-Enter>", self.mouseEnter)
self.draw.tag_bind(fred, "<Any-Leave>", self.mouseLeave)
Widget.bind(self.draw, "<1>", self.mouseDown)
Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
Widget.bind(self.draw, "<1>", self.mouseDown)
Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()
test.mainloop()

107
Demo/tkinter/matt/canvas-mult-item-sel.py
View file

@ -1,6 +1,6 @@
from Tkinter import *
# allows moving dots with multiple selection.
# allows moving dots with multiple selection.
SELECTED_COLOR = "red"
UNSELECTED_COLOR = "blue"
@ -10,72 +10,69 @@ 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.
# 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
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
self.draw.move("selected", event.x - self.lastx, event.y - self.lasty)
self.lastx = event.x
self.lasty = event.y
def makeNewDot(self):
# create a dot, and mark it as current
fred = self.draw.create_oval(0, 0, 20, 20,
fill=SELECTED_COLOR, tags=CURRENT)
# and make it selected
self.draw.addtag("selected", "withtag", CURRENT)
# create a dot, and mark it as current
fred = self.draw.create_oval(0, 0, 20, 20,
fill=SELECTED_COLOR, tags=CURRENT)
# and make it selected
self.draw.addtag("selected", "withtag", CURRENT)
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
################
# make the canvas and bind some behavior to it
################
self.draw = Canvas(self, width="5i", height="5i")
Widget.bind(self.draw, "<1>", self.mouseDown)
Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
################
# make the canvas and bind some behavior to it
################
self.draw = Canvas(self, width="5i", height="5i")
Widget.bind(self.draw, "<1>", self.mouseDown)
Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
# and other things.....
self.button = Button(self, text="make a new dot", foreground="blue",
command=self.makeNewDot)
# and other things.....
self.button = Button(self, text="make a new dot", foreground="blue",
command=self.makeNewDot)
message = ("%s dots are selected and can be dragged.\n"
"%s are not selected.\n"
"Click in a dot to select it.\n"
"Click on empty space to deselect all dots."
) % (SELECTED_COLOR, UNSELECTED_COLOR)
self.label = Message(self, width="5i", text=message)
message = ("%s dots are selected and can be dragged.\n"
"%s are not selected.\n"
"Click in a dot to select it.\n"
"Click on empty space to deselect all dots."
) % (SELECTED_COLOR, UNSELECTED_COLOR)
self.label = Message(self, width="5i", text=message)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.label.pack(side=BOTTOM, fill=X, expand=1)
self.button.pack(side=BOTTOM, fill=X)
self.draw.pack(side=LEFT)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.label.pack(side=BOTTOM, fill=X, expand=1)
self.button.pack(side=BOTTOM, fill=X)
self.draw.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()
test.mainloop()

62
Demo/tkinter/matt/canvas-reading-tag-info.py
View file

@ -3,46 +3,46 @@ from Tkinter import *
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.drawing = Canvas(self, width="5i", height="5i")
self.drawing = Canvas(self, width="5i", height="5i")
# make a shape
pgon = self.drawing.create_polygon(
10, 10, 110, 10, 110, 110, 10 , 110,
fill="red", tags=("weee", "foo", "groo"))
# make a shape
pgon = self.drawing.create_polygon(
10, 10, 110, 10, 110, 110, 10 , 110,
fill="red", tags=("weee", "foo", "groo"))
# this is how you query an object for its attributes
# config options FOR CANVAS ITEMS always come back in tuples of length 5.
# 0 attribute name
# 1 BLANK
# 2 BLANK
# 3 default value
# 4 current value
# the blank spots are for consistency with the config command that
# is used for widgets. (remember, this is for ITEMS drawn
# on a canvas widget, not widgets)
option_value = self.drawing.itemconfig(pgon, "stipple")
print "pgon's current stipple value is -->", option_value[4], "<--"
option_value = self.drawing.itemconfig(pgon, "fill")
print "pgon's current fill value is -->", option_value[4], "<--"
print " when he is usually colored -->", option_value[3], "<--"
# this is how you query an object for its attributes
# config options FOR CANVAS ITEMS always come back in tuples of length 5.
# 0 attribute name
# 1 BLANK
# 2 BLANK
# 3 default value
# 4 current value
# the blank spots are for consistency with the config command that
# is used for widgets. (remember, this is for ITEMS drawn
# on a canvas widget, not widgets)
option_value = self.drawing.itemconfig(pgon, "stipple")
print "pgon's current stipple value is -->", option_value[4], "<--"
option_value = self.drawing.itemconfig(pgon, "fill")
print "pgon's current fill value is -->", option_value[4], "<--"
print " when he is usually colored -->", option_value[3], "<--"
## here we print out all the tags associated with this object
option_value = self.drawing.itemconfig(pgon, "tags")
print "pgon's tags are", option_value[4]
## here we print out all the tags associated with this object
option_value = self.drawing.itemconfig(pgon, "tags")
print "pgon's tags are", option_value[4]
self.drawing.pack(side=LEFT)
self.drawing.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()

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

@ -4,32 +4,32 @@ from Tkinter import *
class Test(Frame):
def printhi(self):
print "hi"
print "hi"
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.draw = Canvas(self, width="5i", height="5i")
self.draw = Canvas(self, width="5i", height="5i")
self.button = Button(self, text="this is a button",
command=self.printhi)
self.button = Button(self, text="this is a button",
command=self.printhi)
# note here the coords are given in pixels (form the
# upper right and corner of the window, as usual for X)
# but might just have well been given in inches or points or
# whatever...use the "anchor" option to control what point of the
# widget (in this case the button) gets mapped to the given x, y.
# you can specify corners, edges, center, etc...
self.draw.create_window(300, 300, window=self.button)
# note here the coords are given in pixels (form the
# upper right and corner of the window, as usual for X)
# but might just have well been given in inches or points or
# whatever...use the "anchor" option to control what point of the
# widget (in this case the button) gets mapped to the given x, y.
# you can specify corners, edges, center, etc...
self.draw.create_window(300, 300, window=self.button)
self.draw.pack(side=LEFT)
self.draw.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()

70
Demo/tkinter/matt/canvas-with-scrollbars.py
View file

@ -1,59 +1,59 @@
from Tkinter import *
# This example program creates a scroling canvas, and demonstrates
# This example program creates a scroling canvas, and demonstrates
# how to tie scrollbars and canvses together. The mechanism
# is analogus for listboxes and other widgets with
# "xscroll" and "yscroll" configuration options.
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def createWidgets(self):
self.question = Label(self, text="Can Find The BLUE Square??????")
self.question.pack()
self.question = Label(self, text="Can Find The BLUE Square??????")
self.question.pack()
self.QUIT = Button(self, text='QUIT', background='red',
height=3, command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
spacer = Frame(self, height="0.25i")
spacer.pack(side=BOTTOM)
self.QUIT = Button(self, text='QUIT', background='red',
height=3, command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
spacer = Frame(self, height="0.25i")
spacer.pack(side=BOTTOM)
# notice that the scroll region (20" x 20") is larger than
# displayed size of the widget (5" x 5")
self.draw = Canvas(self, width="5i", height="5i",
background="white",
scrollregion=(0, 0, "20i", "20i"))
# notice that the scroll region (20" x 20") is larger than
# displayed size of the widget (5" x 5")
self.draw = Canvas(self, width="5i", height="5i",
background="white",
scrollregion=(0, 0, "20i", "20i"))
self.draw.scrollX = Scrollbar(self, orient=HORIZONTAL)
self.draw.scrollY = Scrollbar(self, orient=VERTICAL)
self.draw.scrollX = Scrollbar(self, orient=HORIZONTAL)
self.draw.scrollY = Scrollbar(self, orient=VERTICAL)
# now tie the three together. This is standard boilerplate text
self.draw['xscrollcommand'] = self.draw.scrollX.set
self.draw['yscrollcommand'] = self.draw.scrollY.set
self.draw.scrollX['command'] = self.draw.xview
self.draw.scrollY['command'] = self.draw.yview
# now tie the three together. This is standard boilerplate text
self.draw['xscrollcommand'] = self.draw.scrollX.set
self.draw['yscrollcommand'] = self.draw.scrollY.set
self.draw.scrollX['command'] = self.draw.xview
self.draw.scrollY['command'] = self.draw.yview
# draw something. Note that the first square
# is visible, but you need to scroll to see the second one.
self.draw.create_rectangle(0, 0, "3.5i", "3.5i", fill="black")
self.draw.create_rectangle("10i", "10i", "13.5i", "13.5i", fill="blue")
# draw something. Note that the first square
# is visible, but you need to scroll to see the second one.
self.draw.create_rectangle(0, 0, "3.5i", "3.5i", fill="black")
self.draw.create_rectangle("10i", "10i", "13.5i", "13.5i", fill="blue")
# pack 'em up
self.draw.scrollX.pack(side=BOTTOM, fill=X)
self.draw.scrollY.pack(side=RIGHT, fill=Y)
self.draw.pack(side=LEFT)
# pack 'em up
self.draw.scrollX.pack(side=BOTTOM, fill=X)
self.draw.scrollY.pack(side=RIGHT, fill=Y)
self.draw.pack(side=LEFT)
def scrollCanvasX(self, *args):
print "scrolling", args
print self.draw.scrollX.get()
def scrollCanvasX(self, *args):
print "scrolling", args
print self.draw.scrollX.get()
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()

86
Demo/tkinter/matt/dialog-box.py
View file

@ -6,59 +6,59 @@ from Dialog import Dialog
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def makeWindow(self):
"""Create a top-level dialog with some buttons.
"""Create a top-level dialog with some buttons.
This uses the Dialog class, which is a wrapper around the Tcl/Tk
tk_dialog script. The function returns 0 if the user clicks 'yes'
or 1 if the user clicks 'no'.
"""
# the parameters to this call are as follows:
d = Dialog(
self, ## name of a toplevel window
title="fred the dialog box",## title on the window
text="click on a choice", ## message to appear in window
bitmap="info", ## bitmap (if any) to appear;
## if none, use ""
# legal values here are:
# string what it looks like
# ----------------------------------------------
# error a circle with a slash through it
# grey25 grey square
# grey50 darker grey square
# hourglass use for "wait.."
# info a large, lower case "i"
# questhead a human head with a "?" in it
# question a large "?"
# warning a large "!"
# @fname X bitmap where fname is the path to the file
#
default=0, # the index of the default button choice.
# hitting return selects this
strings=("yes", "no"))
# values of the 'strings' key are the labels for the
# buttons that appear left to right in the dialog box
return d.num
This uses the Dialog class, which is a wrapper around the Tcl/Tk
tk_dialog script. The function returns 0 if the user clicks 'yes'
or 1 if the user clicks 'no'.
"""
# the parameters to this call are as follows:
d = Dialog(
self, ## name of a toplevel window
title="fred the dialog box",## title on the window
text="click on a choice", ## message to appear in window
bitmap="info", ## bitmap (if any) to appear;
## if none, use ""
# legal values here are:
# string what it looks like
# ----------------------------------------------
# error a circle with a slash through it
# grey25 grey square
# grey50 darker grey square
# hourglass use for "wait.."
# info a large, lower case "i"
# questhead a human head with a "?" in it
# question a large "?"
# warning a large "!"
# @fname X bitmap where fname is the path to the file
#
default=0, # the index of the default button choice.
# hitting return selects this
strings=("yes", "no"))
# values of the 'strings' key are the labels for the
# buttons that appear left to right in the dialog box
return d.num
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
# a hello button
self.hi_there = Button(self, text='Make a New Window',
command=self.makeWindow)
self.hi_there.pack(side=LEFT)
# a hello button
self.hi_there = Button(self, text='Make a New Window',
command=self.makeWindow)
self.hi_there.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.windownum = 0
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.windownum = 0
self.createWidgets()
test = Test()
test.mainloop()

21
Demo/tkinter/matt/entry-simple.py
View file

@ -1,25 +1,24 @@
from Tkinter import *
import string
import string
# This program shows how to use a simple type-in box
class App(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.pack()
Frame.__init__(self, master)
self.pack()
self.entrythingy = Entry()
self.entrythingy.pack()
self.entrythingy = Entry()
self.entrythingy.pack()
# and here we get a callback when the user hits return. we could
# make the key that triggers the callback anything we wanted to.
# other typical options might be <Key-Tab> or <Key> (for anything)
self.entrythingy.bind('<Key-Return>', self.print_contents)
# and here we get a callback when the user hits return. we could
# make the key that triggers the callback anything we wanted to.
# other typical options might be <Key-Tab> or <Key> (for anything)
self.entrythingy.bind('<Key-Return>', self.print_contents)
def print_contents(self, event):
print "hi. contents of entry is now ---->", self.entrythingy.get()
print "hi. contents of entry is now ---->", self.entrythingy.get()
root = App()
root.master.title("Foo")
root.mainloop()

55
Demo/tkinter/matt/entry-with-shared-variable.py
View file

@ -1,47 +1,46 @@
from Tkinter import *
import string
import string
# This program shows how to make a typein box shadow a program variable.
class App(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.pack()
Frame.__init__(self, master)
self.pack()
self.entrythingy = Entry(self)
self.entrythingy.pack()
self.entrythingy = Entry(self)
self.entrythingy.pack()
self.button = Button(self, text="Uppercase The Entry",
command=self.upper)
self.button.pack()
self.button = Button(self, text="Uppercase The Entry",
command=self.upper)
self.button.pack()
# here we have the text in the entry widget tied to a variable.
# changes in the variable are echoed in the widget and vice versa.
# Very handy.
# there are other Variable types. See Tkinter.py for all
# the other variable types that can be shadowed
self.contents = StringVar()
self.contents.set("this is a variable")
self.entrythingy.config(textvariable=self.contents)
# here we have the text in the entry widget tied to a variable.
# changes in the variable are echoed in the widget and vice versa.
# Very handy.
# there are other Variable types. See Tkinter.py for all
# the other variable types that can be shadowed
self.contents = StringVar()
self.contents.set("this is a variable")
self.entrythingy.config(textvariable=self.contents)
# and here we get a callback when the user hits return. we could
# make the key that triggers the callback anything we wanted to.
# other typical options might be <Key-Tab> or <Key> (for anything)
self.entrythingy.bind('<Key-Return>', self.print_contents)
# and here we get a callback when the user hits return. we could
# make the key that triggers the callback anything we wanted to.
# other typical options might be <Key-Tab> or <Key> (for anything)
self.entrythingy.bind('<Key-Return>', self.print_contents)
def upper(self):
# notice here, we don't actually refer to the entry box.
# we just operate on the string variable and we
# notice here, we don't actually refer to the entry box.
# we just operate on the string variable and we
# because it's being looked at by the entry widget, changing
# the variable changes the entry widget display automatically.
# the strange get/set operators are clunky, true...
str = string.upper(self.contents.get())
self.contents.set(str)
# the variable changes the entry widget display automatically.
# the strange get/set operators are clunky, true...
str = string.upper(self.contents.get())
self.contents.set(str)
def print_contents(self, event):
print "hi. contents of entry is now ---->", self.contents.get()
print "hi. contents of entry is now ---->", self.contents.get()
root = App()
root.master.title("Foo")
root.mainloop()

38
Demo/tkinter/matt/killing-window-w-wm.py
View file

@ -1,8 +1,8 @@
from Tkinter import *
# This file shows how to trap the killing of a window
# This file shows how to trap the killing of a window
# when the user uses window manager menus (typ. upper left hand corner
# menu in the decoration border).
# menu in the decoration border).
### ******* this isn't really called -- read the comments
@ -11,31 +11,31 @@ def my_delete_callback():
class Test(Frame):
def deathHandler(self, event):
print self, "is now getting nuked. performing some save here...."
print self, "is now getting nuked. performing some save here...."
def createWidgets(self):
# a hello button
self.hi_there = Button(self, text='Hello')
self.hi_there.pack(side=LEFT)
# a hello button
self.hi_there = Button(self, text='Hello')
self.hi_there.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
###
### PREVENT WM kills from happening
###
###
### PREVENT WM kills from happening
###
# the docs would have you do this:
# the docs would have you do this:
# self.master.protocol("WM_DELETE_WINDOW", my_delete_callback)
# self.master.protocol("WM_DELETE_WINDOW", my_delete_callback)
# unfortunately, some window managers will not send this request to a window.
# the "protocol" function seems incapable of trapping these "aggressive" window kills.
# this line of code catches everything, tho. The window is deleted, but you have a chance
# of cleaning up first.
self.bind_all("<Destroy>", self.deathHandler)
# unfortunately, some window managers will not send this request to a window.
# the "protocol" function seems incapable of trapping these "aggressive" window kills.
# this line of code catches everything, tho. The window is deleted, but you have a chance
# of cleaning up first.
self.bind_all("<Destroy>", self.deathHandler)
test = Test()

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

@ -1,16 +1,16 @@
from Tkinter import *
# some vocabulary to keep from getting confused. This terminology
# is something I cooked up for this file, but follows the man pages
# some vocabulary to keep from getting confused. This terminology
# is something I cooked up for this file, but follows the man pages
# pretty closely
#
#
#
#
#
#
# This is a MENUBUTTON
# V
# +-------------+
# | |
#
#
# +------------++------------++------------+
# | || || |
# | File || Edit || Options | <-------- the MENUBAR
@ -22,7 +22,7 @@ from Tkinter import *
# | | <-------- This is a MENU. The lines of text in the menu are
# | | MENU ENTRIES
# | +---------------+
# | Open Files > | file1 |
# | Open Files > | file1 |
# | | file2 |
# | | another file | <------ this cascading part is also a MENU
# +----------------| |
@ -53,11 +53,11 @@ def print_anchovies():
print "anchovies?", anchovies
def makeCommandMenu():
# make menu button
Command_button = Menubutton(mBar, text='Simple Button Commands',
underline=0)
# make menu button
Command_button = Menubutton(mBar, text='Simple Button Commands',
underline=0)
Command_button.pack(side=LEFT, padx="2m")
# make the pulldown part of the File menu. The parameter passed is the master.
# we attach it to the button as a python attribute called "menu" by convention.
# hopefully this isn't too confusing...
@ -68,28 +68,28 @@ def makeCommandMenu():
# undo is the 0th entry...
Command_button.menu.entryconfig(0, state=DISABLED)
Command_button.menu.add_command(label='New...', underline=0,
command=new_file)
Command_button.menu.add_command(label='Open...', underline=0,
command=open_file)
Command_button.menu.add_command(label='New...', underline=0,
command=new_file)
Command_button.menu.add_command(label='Open...', underline=0,
command=open_file)
Command_button.menu.add_command(label='Different Font', underline=0,
font='-*-helvetica-*-r-*-*-*-180-*-*-*-*-*-*',
command=print_something)
font='-*-helvetica-*-r-*-*-*-180-*-*-*-*-*-*',
command=print_something)
# we can make bitmaps be menu entries too. File format is X11 bitmap.
# if you use XV, save it under X11 bitmap format. duh-uh.,..
Command_button.menu.add_command(
bitmap="info")
#bitmap='@/home/mjc4y/dilbert/project.status.is.doomed.last.panel.bm')
bitmap="info")
#bitmap='@/home/mjc4y/dilbert/project.status.is.doomed.last.panel.bm')
# this is just a line
Command_button.menu.add('separator')
# change the color
Command_button.menu.add_command(label='Quit', underline=0,
background='red',
activebackground='green',
command=Command_button.quit)
Command_button.menu.add_command(label='Quit', underline=0,
background='red',
activebackground='green',
command=Command_button.quit)
# set up a pointer from the file menubutton back to the file menu
Command_button['menu'] = Command_button.menu
@ -99,10 +99,10 @@ def makeCommandMenu():
def makeCascadeMenu():
# make menu button
# make menu button
Cascade_button = Menubutton(mBar, text='Cascading Menus', underline=0)
Cascade_button.pack(side=LEFT, padx="2m")
# the primary pulldown
Cascade_button.menu = Menu(Cascade_button)
@ -125,12 +125,12 @@ def makeCascadeMenu():
Cascade_button.menu.choices.add_command(label='Rocky Road')
Cascade_button.menu.choices.add_command(label='BubbleGum')
Cascade_button.menu.choices.add_cascade(
label='Wierd Flavors',
menu=Cascade_button.menu.choices.wierdones)
label='Wierd Flavors',
menu=Cascade_button.menu.choices.wierdones)
# and finally, the definition for the top level
Cascade_button.menu.add_cascade(label='more choices',
menu=Cascade_button.menu.choices)
Cascade_button.menu.add_cascade(label='more choices',
menu=Cascade_button.menu.choices)
Cascade_button['menu'] = Cascade_button.menu
@ -138,39 +138,39 @@ def makeCascadeMenu():
def makeCheckbuttonMenu():
global fred
# make menu button
Checkbutton_button = Menubutton(mBar, text='Checkbutton Menus',
underline=0)
# make menu button
Checkbutton_button = Menubutton(mBar, text='Checkbutton Menus',
underline=0)
Checkbutton_button.pack(side=LEFT, padx='2m')
# the primary pulldown
Checkbutton_button.menu = Menu(Checkbutton_button)
# and all the check buttons. Note that the "variable" "onvalue" and "offvalue" options
# are not supported correctly at present. You have to do all your application
# are not supported correctly at present. You have to do all your application
# work through the calback.
Checkbutton_button.menu.add_checkbutton(label='Pepperoni')
Checkbutton_button.menu.add_checkbutton(label='Sausage')
Checkbutton_button.menu.add_checkbutton(label='Extra Cheese')
# so here's a callback
Checkbutton_button.menu.add_checkbutton(label='Anchovy',
command=print_anchovies)
Checkbutton_button.menu.add_checkbutton(label='Anchovy',
command=print_anchovies)
# and start with anchovies selected to be on. Do this by
# and start with anchovies selected to be on. Do this by
# calling invoke on this menu option. To refer to the "anchovy" menu
# entry we need to know it's index. To do this, we use the index method
# which takes arguments of several forms:
# which takes arguments of several forms:
#
# argument what it does
# -----------------------------------
# a number -- this is useless.
# a number -- this is useless.
# "last" -- last option in the menu
# "none" -- used with the activate command. see the man page on menus
# "active" -- the currently active menu option. A menu option is made active
# with the 'activate' method
# "@number" -- where 'number' is an integer and is treated like a y coordinate in pixels
# string pattern -- this is the option used below, and attempts to match "labels" using the
# string pattern -- this is the option used below, and attempts to match "labels" using the
# rules of Tcl_StringMatch
Checkbutton_button.menu.invoke(Checkbutton_button.menu.index('Anchovy'))
@ -181,16 +181,16 @@ def makeCheckbuttonMenu():
def makeRadiobuttonMenu():
# make menu button
Radiobutton_button = Menubutton(mBar, text='Radiobutton Menus',
underline=0)
# make menu button
Radiobutton_button = Menubutton(mBar, text='Radiobutton Menus',
underline=0)
Radiobutton_button.pack(side=LEFT, padx='2m')
# the primary pulldown
Radiobutton_button.menu = Menu(Radiobutton_button)
# and all the Radio buttons. Note that the "variable" "onvalue" and "offvalue" options
# are not supported correctly at present. You have to do all your application
# are not supported correctly at present. You have to do all your application
# work through the calback.
Radiobutton_button.menu.add_radiobutton(label='Republican')
Radiobutton_button.menu.add_radiobutton(label='Democrat')
@ -209,7 +209,7 @@ def makeRadiobuttonMenu():
return Radiobutton_button
def makeDisabledMenu():
def makeDisabledMenu():
Dummy_button = Menubutton(mBar, text='Dead Menu', underline=0)
Dummy_button.pack(side=LEFT, padx='2m')
@ -233,7 +233,7 @@ Checkbutton_button = makeCheckbuttonMenu()
Radiobutton_button = makeRadiobuttonMenu()
NoMenu = makeDisabledMenu()
# finally, install the buttons in the menu bar.
# finally, install the buttons in the menu bar.
# This allows for scanning from one menubutton to the next.
mBar.tk_menuBar(Command_button, Cascade_button, Checkbutton_button, Radiobutton_button, NoMenu)
@ -242,9 +242,3 @@ root.title('menu demo')
root.iconname('menu demo')
root.mainloop()

44
Demo/tkinter/matt/menu-simple.py
View file

@ -1,16 +1,16 @@
from Tkinter import *
# some vocabulary to keep from getting confused. This terminology
# is something I cooked up for this file, but follows the man pages
# some vocabulary to keep from getting confused. This terminology
# is something I cooked up for this file, but follows the man pages
# pretty closely
#
#
#
#
#
#
# This is a MENUBUTTON
# V
# +-------------+
# | |
#
#
# +------------++------------++------------+
# | || || |
# | File || Edit || Options | <-------- the MENUBAR
@ -22,7 +22,7 @@ from Tkinter import *
# | | <------ This is a MENU. The lines of text in the menu are
# | | MENU ENTRIES
# | +---------------+
# | Open Files > | file1 |
# | Open Files > | file1 |
# | | file2 |
# | | another file | <------ this cascading part is also a MENU
# +----------------| |
@ -46,19 +46,19 @@ def makeFileMenu():
File_button = Menubutton(mBar, text='File', underline=0)
File_button.pack(side=LEFT, padx="1m")
File_button.menu = Menu(File_button)
# add an item. The first param is a menu entry type,
# add an item. The first param is a menu entry type,
# must be one of: "cascade", "checkbutton", "command", "radiobutton", "seperator"
# see menu-demo-2.py for examples of use
File_button.menu.add_command(label='New...', underline=0,
command=new_file)
File_button.menu.add_command(label='Open...', underline=0,
command=open_file)
File_button.menu.add_command(label='Quit', underline=0,
command='exit')
File_button.menu.add_command(label='New...', underline=0,
command=new_file)
File_button.menu.add_command(label='Open...', underline=0,
command=open_file)
File_button.menu.add_command(label='Quit', underline=0,
command='exit')
# set up a pointer from the file menubutton back to the file menu
File_button['menu'] = File_button.menu
@ -102,7 +102,7 @@ mBar.pack(fill=X)
File_button = makeFileMenu()
Edit_button = makeEditMenu()
# finally, install the buttons in the menu bar.
# finally, install the buttons in the menu bar.
# This allows for scanning from one menubutton to the next.
mBar.tk_menuBar(File_button, Edit_button)
@ -110,9 +110,3 @@ root.title('menu demo')
root.iconname('packer')
root.mainloop()

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

@ -4,21 +4,21 @@ from Tkinter import *
class Test(Frame):
def createWidgets(self):
self.Gpanel = Frame(self, width='1i', height='1i',
background='green')
self.Gpanel.pack(side=LEFT)
self.Gpanel = Frame(self, width='1i', height='1i',
background='green')
self.Gpanel.pack(side=LEFT)
# a QUIT button
self.Gpanel.QUIT = Button(self.Gpanel, text='QUIT',
foreground='red',
command=self.quit)
self.Gpanel.QUIT.pack(side=LEFT)
# a QUIT button
self.Gpanel.QUIT = Button(self.Gpanel, text='QUIT',
foreground='red',
command=self.quit)
self.Gpanel.QUIT.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()

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

@ -4,23 +4,23 @@ from Tkinter import *
class Test(Frame):
def createWidgets(self):
self.Gpanel = Frame(self, width='1i', height='1i',
background='green')
self.Gpanel = Frame(self, width='1i', height='1i',
background='green')
# this line turns off the recalculation of geometry by masters.
self.Gpanel.propagate(0)
# this line turns off the recalculation of geometry by masters.
self.Gpanel.propagate(0)
self.Gpanel.pack(side=LEFT)
self.Gpanel.pack(side=LEFT)
# a QUIT button
self.Gpanel.QUIT = Button(self.Gpanel, text='QUIT', foreground='red',
command=self.quit)
self.Gpanel.QUIT.pack(side=LEFT)
# a QUIT button
self.Gpanel.QUIT = Button(self.Gpanel, text='QUIT', foreground='red',
command=self.quit)
self.Gpanel.QUIT.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()

11
Demo/tkinter/matt/packer-and-placer-together.py
View file

@ -1,6 +1,6 @@
from Tkinter import *
# This is a program that tests the placer geom manager in conjunction with
# This is a program that tests the placer geom manager in conjunction with
# the packer. The background (green) is packed, while the widget inside is placed
@ -17,15 +17,15 @@ def createWidgets(top):
# area is inaccesssible.
f = Frame(top, width=200, height=200, background='green')
# note that we use a different manager here.
# This way, the top level frame widget resizes when the
# application window does.
# note that we use a different manager here.
# This way, the top level frame widget resizes when the
# application window does.
f.pack(fill=BOTH, expand=1)
# now make a button
f.button = Button(f, foreground='red', text='amazing', command=dothis)
# and place it so that the nw corner is
# and place it so that the nw corner is
# 1/2 way along the top X edge of its' parent
f.button.place(relx=0.5, rely=0.0, anchor=NW)
@ -39,4 +39,3 @@ app = createWidgets(root)
root.geometry("400x400")
root.maxsize(1000, 1000)
root.mainloop()

32
Demo/tkinter/matt/packer-simple.py
View file

@ -3,30 +3,30 @@ from Tkinter import *
class Test(Frame):
def printit(self):
print self.hi_there["command"]
print self.hi_there["command"]
def createWidgets(self):
# a hello button
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
# a hello button
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.hi_there = Button(self, text='Hello',
command=self.printit)
self.hi_there.pack(side=LEFT)
self.hi_there = Button(self, text='Hello',
command=self.printit)
self.hi_there.pack(side=LEFT)
# note how Packer defaults to side=TOP
# note how Packer defaults to side=TOP
self.guy2 = Button(self, text='button 2')
self.guy2.pack()
self.guy2 = Button(self, text='button 2')
self.guy2.pack()
self.guy3 = Button(self, text='button 3')
self.guy3.pack()
self.guy3 = Button(self, text='button 3')
self.guy3.pack()
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()
test.mainloop()

5
Demo/tkinter/matt/placer-simple.py
View file

@ -15,7 +15,7 @@ def createWidgets(top):
# area is inaccesssible.
f = Frame(top, width=200, height=200, background='green')
# place it so the upper left hand corner of
# place it so the upper left hand corner of
# the frame is in the upper left corner of
# the parent
f.place(relx=0.0, rely=0.0)
@ -23,7 +23,7 @@ def createWidgets(top):
# now make a button
f.button = Button(f, foreground='red', text='amazing', command=dothis)
# and place it so that the nw corner is
# and place it so that the nw corner is
# 1/2 way along the top X edge of its' parent
f.button.place(relx=0.5, rely=0.0, anchor=NW)
@ -37,4 +37,3 @@ app = createWidgets(root)
root.geometry("400x400")
root.maxsize(1000, 1000)
root.mainloop()

62
Demo/tkinter/matt/pong-demo-1.py
View file

@ -5,48 +5,48 @@ import string
class Pong(Frame):
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
## The playing field
self.draw = Canvas(self, width="5i", height="5i")
## The playing field
self.draw = Canvas(self, width="5i", height="5i")
## The speed control for the ball
self.speed = Scale(self, orient=HORIZONTAL, label="ball speed",
from_=-100, to=100)
## The speed control for the ball
self.speed = Scale(self, orient=HORIZONTAL, label="ball speed",
from_=-100, to=100)
self.speed.pack(side=BOTTOM, fill=X)
self.speed.pack(side=BOTTOM, fill=X)
# The ball
self.ball = self.draw.create_oval("0i", "0i", "0.10i", "0.10i",
fill="red")
self.x = 0.05
self.y = 0.05
self.velocity_x = 0.3
self.velocity_y = 0.5
# The ball
self.ball = self.draw.create_oval("0i", "0i", "0.10i", "0.10i",
fill="red")
self.x = 0.05
self.y = 0.05
self.velocity_x = 0.3
self.velocity_y = 0.5
self.draw.pack(side=LEFT)
self.draw.pack(side=LEFT)
def moveBall(self, *args):
if (self.x > 5.0) or (self.x < 0.0):
self.velocity_x = -1.0 * self.velocity_x
if (self.y > 5.0) or (self.y < 0.0):
self.velocity_y = -1.0 * self.velocity_y
if (self.x > 5.0) or (self.x < 0.0):
self.velocity_x = -1.0 * self.velocity_x
if (self.y > 5.0) or (self.y < 0.0):
self.velocity_y = -1.0 * self.velocity_y
deltax = (self.velocity_x * self.speed.get() / 100.0)
deltay = (self.velocity_y * self.speed.get() / 100.0)
self.x = self.x + deltax
self.y = self.y + deltay
deltax = (self.velocity_x * self.speed.get() / 100.0)
deltay = (self.velocity_y * self.speed.get() / 100.0)
self.x = self.x + deltax
self.y = self.y + deltay
self.draw.move(self.ball, "%ri" % deltax, "%ri" % deltay)
self.after(10, self.moveBall)
self.draw.move(self.ball, "%ri" % deltax, "%ri" % deltay)
self.after(10, self.moveBall)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
self.after(10, self.moveBall)
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
self.after(10, self.moveBall)
game = Pong()

71
Demo/tkinter/matt/printing-coords-of-items.py
View file

@ -7,58 +7,55 @@ 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.
# see if we're inside a dot. If we are, it
# gets tagged as CURRENT for free by tk.
if not event.widget.find_withtag(CURRENT):
# there is no dot here, so we can make one,
# and bind some interesting behavior to it.
# ------
# create a dot, and mark it as current
fred = self.draw.create_oval(
event.x - 10, event.y -10, event.x +10, event.y + 10,
fill="green")
self.draw.tag_bind(fred, "<Enter>", self.mouseEnter)
self.draw.tag_bind(fred, "<Leave>", self.mouseLeave)
self.lastx = event.x
self.lasty = event.y
if not event.widget.find_withtag(CURRENT):
# there is no dot here, so we can make one,
# and bind some interesting behavior to it.
# ------
# create a dot, and mark it as current
fred = self.draw.create_oval(
event.x - 10, event.y -10, event.x +10, event.y + 10,
fill="green")
self.draw.tag_bind(fred, "<Enter>", self.mouseEnter)
self.draw.tag_bind(fred, "<Leave>", self.mouseLeave)
self.lastx = event.x
self.lasty = event.y
def mouseMove(self, event):
self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
self.lastx = event.x
self.lasty = event.y
self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
self.lastx = event.x
self.lasty = event.y
###################################################################
###### Event callbacks for canvas ITEMS (stuff drawn on the canvas)
###################################################################
def mouseEnter(self, event):
# the "current" tag is applied to the object the cursor is over.
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="red")
print self.draw.coords(CURRENT)
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="red")
print self.draw.coords(CURRENT)
def mouseLeave(self, event):
# the "current" tag is applied to the object the cursor is over.
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="blue")
# the "current" tag is applied to the object the cursor is over.
# this happens automatically.
self.draw.itemconfig(CURRENT, fill="blue")
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.draw = Canvas(self, width="5i", height="5i")
self.draw.pack(side=LEFT)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.draw = Canvas(self, width="5i", height="5i")
self.draw.pack(side=LEFT)
Widget.bind(self.draw, "<1>", self.mouseDown)
Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
Widget.bind(self.draw, "<1>", self.mouseDown)
Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()
test.mainloop()

78
Demo/tkinter/matt/radiobutton-simple.py
View file

@ -1,10 +1,10 @@
from Tkinter import *
# This is a demo program that shows how to
# create radio buttons and how to get other widgets to
# share the information in a radio button.
#
# There are other ways of doing this too, but
# This is a demo program that shows how to
# create radio buttons and how to get other widgets to
# share the information in a radio button.
#
# There are other ways of doing this too, but
# the "variable" option of radiobuttons seems to be the easiest.
#
# note how each button has a value it sets the variable to as it gets hit.
@ -12,50 +12,50 @@ from Tkinter import *
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def createWidgets(self):
self.flavor = StringVar()
self.flavor.set("chocolate")
self.flavor = StringVar()
self.flavor.set("chocolate")
self.radioframe = Frame(self)
self.radioframe.pack()
self.radioframe = Frame(self)
self.radioframe.pack()
# 'text' is the label
# 'variable' is the name of the variable that all these radio buttons share
# 'value' is the value this variable takes on when the radio button is selected
# 'anchor' makes the text appear left justified (default is centered. ick)
self.radioframe.choc = Radiobutton(
self.radioframe, text="Chocolate Flavor",
variable=self.flavor, value="chocolate",
anchor=W)
self.radioframe.choc.pack(fill=X)
# 'text' is the label
# 'variable' is the name of the variable that all these radio buttons share
# 'value' is the value this variable takes on when the radio button is selected
# 'anchor' makes the text appear left justified (default is centered. ick)
self.radioframe.choc = Radiobutton(
self.radioframe, text="Chocolate Flavor",
variable=self.flavor, value="chocolate",
anchor=W)
self.radioframe.choc.pack(fill=X)
self.radioframe.straw = Radiobutton(
self.radioframe, text="Strawberry Flavor",
variable=self.flavor, value="strawberry",
anchor=W)
self.radioframe.straw.pack(fill=X)
self.radioframe.straw = Radiobutton(
self.radioframe, text="Strawberry Flavor",
variable=self.flavor, value="strawberry",
anchor=W)
self.radioframe.straw.pack(fill=X)
self.radioframe.lemon = Radiobutton(
self.radioframe, text="Lemon Flavor",
variable=self.flavor, value="lemon",
anchor=W)
self.radioframe.lemon.pack(fill=X)
# this is a text entry that lets you type in the name of a flavor too.
self.entry = Entry(self, textvariable=self.flavor)
self.entry.pack(fill=X)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.radioframe.lemon = Radiobutton(
self.radioframe, text="Lemon Flavor",
variable=self.flavor, value="lemon",
anchor=W)
self.radioframe.lemon.pack(fill=X)
# this is a text entry that lets you type in the name of a flavor too.
self.entry = Entry(self, textvariable=self.flavor)
self.entry.pack(fill=X)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()

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

@ -2,55 +2,55 @@ from Tkinter import *
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def createWidgets(self):
self.QUIT = Button(self, text='QUIT',
background='red',
foreground='white',
height=3,
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.QUIT = Button(self, text='QUIT',
background='red',
foreground='white',
height=3,
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.canvasObject = Canvas(self, width="5i", height="5i")
self.canvasObject.pack(side=LEFT)
self.canvasObject = Canvas(self, width="5i", height="5i")
self.canvasObject.pack(side=LEFT)
def mouseDown(self, event):
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
self.startx = self.canvasObject.canvasx(event.x)
self.starty = self.canvasObject.canvasy(event.y)
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
self.startx = self.canvasObject.canvasx(event.x)
self.starty = self.canvasObject.canvasy(event.y)
def mouseMotion(self, event):
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
x = self.canvasObject.canvasx(event.x)
y = self.canvasObject.canvasy(event.y)
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
x = self.canvasObject.canvasx(event.x)
y = self.canvasObject.canvasy(event.y)
if (self.startx != event.x) and (self.starty != event.y) :
self.canvasObject.delete(self.rubberbandBox)
self.rubberbandBox = self.canvasObject.create_rectangle(
self.startx, self.starty, x, y)
# this flushes the output, making sure that
# the rectangle makes it to the screen
# before the next event is handled
self.update_idletasks()
if (self.startx != event.x) and (self.starty != event.y) :
self.canvasObject.delete(self.rubberbandBox)
self.rubberbandBox = self.canvasObject.create_rectangle(
self.startx, self.starty, x, y)
# this flushes the output, making sure that
# the rectangle makes it to the screen
# before the next event is handled
self.update_idletasks()
def mouseUp(self, event):
self.canvasObject.delete(self.rubberbandBox)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
self.canvasObject.delete(self.rubberbandBox)
# this is a "tagOrId" for the rectangle we draw on the canvas
self.rubberbandBox = None
# and the bindings that make it work..
Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
Widget.bind(self.canvasObject, "<Button1-ButtonRelease>", self.mouseUp)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
# this is a "tagOrId" for the rectangle we draw on the canvas
self.rubberbandBox = None
# and the bindings that make it work..
Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
Widget.bind(self.canvasObject, "<Button1-ButtonRelease>", self.mouseUp)
test = Test()

66
Demo/tkinter/matt/rubber-line-demo-1.py
View file

@ -2,49 +2,49 @@ from Tkinter import *
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def createWidgets(self):
self.QUIT = Button(self, text='QUIT',
background='red',
foreground='white',
height=3,
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.QUIT = Button(self, text='QUIT',
background='red',
foreground='white',
height=3,
command=self.quit)
self.QUIT.pack(side=BOTTOM, fill=BOTH)
self.canvasObject = Canvas(self, width="5i", height="5i")
self.canvasObject.pack(side=LEFT)
self.canvasObject = Canvas(self, width="5i", height="5i")
self.canvasObject.pack(side=LEFT)
def mouseDown(self, event):
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
self.startx = self.canvasObject.canvasx(event.x)
self.starty = self.canvasObject.canvasy(event.y)
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
self.startx = self.canvasObject.canvasx(event.x)
self.starty = self.canvasObject.canvasy(event.y)
def mouseMotion(self, event):
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
x = self.canvasObject.canvasx(event.x)
y = self.canvasObject.canvasy(event.y)
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
x = self.canvasObject.canvasx(event.x)
y = self.canvasObject.canvasy(event.y)
if (self.startx != event.x) and (self.starty != event.y) :
self.canvasObject.delete(self.rubberbandLine)
self.rubberbandLine = self.canvasObject.create_line(
self.startx, self.starty, x, y)
# this flushes the output, making sure that
# the rectangle makes it to the screen
# before the next event is handled
self.update_idletasks()
if (self.startx != event.x) and (self.starty != event.y) :
self.canvasObject.delete(self.rubberbandLine)
self.rubberbandLine = self.canvasObject.create_line(
self.startx, self.starty, x, y)
# this flushes the output, making sure that
# the rectangle makes it to the screen
# before the next event is handled
self.update_idletasks()
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
# this is a "tagOrId" for the rectangle we draw on the canvas
self.rubberbandLine = None
Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
# this is a "tagOrId" for the rectangle we draw on the canvas
self.rubberbandLine = None
Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
test = Test()

36
Demo/tkinter/matt/slider-demo-1.py
View file

@ -5,32 +5,32 @@ from Tkinter import *
class Test(Frame):
def print_value(self, val):
print "slider now at", val
print "slider now at", val
def reset(self):
self.slider.set(0)
def reset(self):
self.slider.set(0)
def createWidgets(self):
self.slider = Scale(self, from_=0, to=100,
orient=HORIZONTAL,
length="3i",
label="happy slider",
command=self.print_value)
self.slider = Scale(self, from_=0, to=100,
orient=HORIZONTAL,
length="3i",
label="happy slider",
command=self.print_value)
self.reset = Button(self, text='reset slider',
command=self.reset)
self.reset = Button(self, text='reset slider',
command=self.reset)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.slider.pack(side=LEFT)
self.reset.pack(side=LEFT)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.slider.pack(side=LEFT)
self.reset.pack(side=LEFT)
self.QUIT.pack(side=LEFT, fill=BOTH)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()
test.mainloop()

7
Demo/tkinter/matt/subclass-existing-widgets.py
View file

@ -5,9 +5,9 @@ from Tkinter import *
class New_Button(Button):
def callback(self):
print self.counter
self.counter = self.counter + 1
print self.counter
self.counter = self.counter + 1
def createWidgets(top):
f = Frame(top)
f.pack()
@ -26,4 +26,3 @@ def createWidgets(top):
root = Tk()
createWidgets(root)
root.mainloop()

72
Demo/tkinter/matt/two-radio-groups.py
View file

@ -1,44 +1,44 @@
from Tkinter import *
# The way to think about this is that each radio button menu
# controls a different variable -- clicking on one of the
# mutually exclusive choices in a radiobutton assigns some value
# to an application variable you provide. When you define a
# radiobutton menu choice, you have the option of specifying the
# name of a varaible and value to assign to that variable when
# that choice is selected. This clever mechanism relieves you,
# the programmer, from having to write a dumb callback that
# probably wouldn't have done anything more than an assignment
# anyway. The Tkinter options for this follow their Tk
# counterparts:
# {"variable" : my_flavor_variable, "value" : "strawberry"}
# The way to think about this is that each radio button menu
# controls a different variable -- clicking on one of the
# mutually exclusive choices in a radiobutton assigns some value
# to an application variable you provide. When you define a
# radiobutton menu choice, you have the option of specifying the
# name of a varaible and value to assign to that variable when
# that choice is selected. This clever mechanism relieves you,
# the programmer, from having to write a dumb callback that
# probably wouldn't have done anything more than an assignment
# anyway. The Tkinter options for this follow their Tk
# counterparts:
# {"variable" : my_flavor_variable, "value" : "strawberry"}
# where my_flavor_variable is an instance of one of the
# subclasses of Variable, provided in Tkinter.py (there is
# StringVar(), IntVar(), DoubleVar() and BooleanVar() to choose
# from)
# StringVar(), IntVar(), DoubleVar() and BooleanVar() to choose
# from)
def makePoliticalParties(var):
# make menu button
Radiobutton_button = Menubutton(mBar, text='Political Party',
underline=0)
# make menu button
Radiobutton_button = Menubutton(mBar, text='Political Party',
underline=0)
Radiobutton_button.pack(side=LEFT, padx='2m')
# the primary pulldown
Radiobutton_button.menu = Menu(Radiobutton_button)
Radiobutton_button.menu.add_radiobutton(label='Republican',
variable=var, value=1)
Radiobutton_button.menu.add_radiobutton(label='Republican',
variable=var, value=1)
Radiobutton_button.menu.add('radiobutton', {'label': 'Democrat',
'variable' : var,
'value' : 2})
Radiobutton_button.menu.add('radiobutton', {'label': 'Democrat',
'variable' : var,
'value' : 2})
Radiobutton_button.menu.add('radiobutton', {'label': 'Libertarian',
'variable' : var,
'value' : 3})
Radiobutton_button.menu.add('radiobutton', {'label': 'Libertarian',
'variable' : var,
'value' : 3})
var.set(2)
# set up a pointer from the file menubutton back to the file menu
@ -48,22 +48,22 @@ def makePoliticalParties(var):
def makeFlavors(var):
# make menu button
Radiobutton_button = Menubutton(mBar, text='Flavors',
underline=0)
# make menu button
Radiobutton_button = Menubutton(mBar, text='Flavors',
underline=0)
Radiobutton_button.pack(side=LEFT, padx='2m')
# the primary pulldown
Radiobutton_button.menu = Menu(Radiobutton_button)
Radiobutton_button.menu.add_radiobutton(label='Strawberry',
variable=var, value='Strawberry')
variable=var, value='Strawberry')
Radiobutton_button.menu.add_radiobutton(label='Chocolate',
variable=var, value='Chocolate')
variable=var, value='Chocolate')
Radiobutton_button.menu.add_radiobutton(label='Rocky Road',
variable=var, value='Rocky Road')
variable=var, value='Rocky Road')
# choose a default
var.set("Chocolate")
@ -88,7 +88,7 @@ root = Tk()
mBar = Frame(root, relief=RAISED, borderwidth=2)
mBar.pack(fill=X)
# make two application variables,
# make two application variables,
# one to control each radio button set
party = IntVar()
flavor = StringVar()
@ -96,12 +96,12 @@ flavor = StringVar()
Radiobutton_button = makePoliticalParties(party)
Radiobutton_button2 = makeFlavors(flavor)
# finally, install the buttons in the menu bar.
# finally, install the buttons in the menu bar.
# This allows for scanning from one menubutton to the next.
mBar.tk_menuBar(Radiobutton_button, Radiobutton_button2)
b = Button(root, text="print party and flavor", foreground="red",
command=printStuff)
command=printStuff)
b.pack(side=TOP)
root.title('menu demo')

36
Demo/tkinter/matt/window-creation-more.py
View file

@ -5,31 +5,31 @@ from Tkinter import *
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def makeWindow(self):
fred = Toplevel()
fred.label = Button(fred,
text="This is window number %d." % self.windownum,
command=self.makeWindow)
fred.label.pack()
self.windownum = self.windownum + 1
fred = Toplevel()
fred.label = Button(fred,
text="This is window number %d." % self.windownum,
command=self.makeWindow)
fred.label.pack()
self.windownum = self.windownum + 1
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
# a hello button
self.hi_there = Button(self, text='Make a New Window',
command=self.makeWindow)
self.hi_there.pack(side=LEFT)
# a hello button
self.hi_there = Button(self, text='Make a New Window',
command=self.makeWindow)
self.hi_there.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.windownum = 0
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.windownum = 0
self.createWidgets()
test = Test()
test.mainloop()

30
Demo/tkinter/matt/window-creation-simple.py
View file

@ -4,28 +4,28 @@ from Tkinter import *
class Test(Frame):
def printit(self):
print "hi"
print "hi"
def makeWindow(self):
fred = Toplevel()
fred.label = Label(fred, text="Here's a new window")
fred.label.pack()
fred = Toplevel()
fred.label = Label(fred, text="Here's a new window")
fred.label.pack()
def createWidgets(self):
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.QUIT = Button(self, text='QUIT', foreground='red',
command=self.quit)
# a hello button
self.hi_there = Button(self, text='Make a New Window',
command=self.makeWindow)
self.hi_there.pack(side=LEFT)
self.QUIT.pack(side=LEFT, fill=BOTH)
# a hello button
self.hi_there = Button(self, text='Make a New Window',
command=self.makeWindow)
self.hi_there.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()
test.mainloop()

30
Demo/tkinter/matt/window-creation-w-location.py
View file

@ -17,29 +17,29 @@ class QuitButton(Button):
class Test(Frame):
def makeWindow(self, *args):
fred = Toplevel()
fred = Toplevel()
fred.label = Canvas (fred, width="2i", height="2i")
fred.label = Canvas (fred, width="2i", height="2i")
fred.label.create_line("0", "0", "2i", "2i")
fred.label.create_line("0", "2i", "2i", "0")
fred.label.pack()
fred.label.create_line("0", "0", "2i", "2i")
fred.label.create_line("0", "2i", "2i", "0")
fred.label.pack()
##centerWindow(fred, self.master)
##centerWindow(fred, self.master)
def createWidgets(self):
self.QUIT = QuitButton(self)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.QUIT = QuitButton(self)
self.QUIT.pack(side=LEFT, fill=BOTH)
self.makeWindow = Button(self, text='Make a New Window',
width=50, height=20,
command=self.makeWindow)
self.makeWindow.pack(side=LEFT)
self.makeWindow = Button(self, text='Make a New Window',
width=50, height=20,
command=self.makeWindow)
self.makeWindow.pack(side=LEFT)
def __init__(self, master=None):
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
Frame.__init__(self, master)
Pack.config(self)
self.createWidgets()
test = Test()
test.mainloop()