Whitespace normalization, via reindent.py.

34 files changed, 836 insertions, 862 deletions

diff --git a/Demo/tkinter/matt/00-HELLO-WORLD.py b/Demo/tkinter/matt/00-HELLO-WORLD.py
index a32941b..1c3151b 100644
--- a/Demo/tkinter/matt/00-HELLO-WORLD.py
+++ b/Demo/tkinter/matt/00-HELLO-WORLD.py
@@ -1,27 +1,27 @@
 from Tkinter import *
 
-# note that there is no explicit call to start Tk. 
-# Tkinter is smart enough to start the system if it's not already going. 
+# note that there is no explicit call to start Tk.
+# Tkinter is smart enough to start the system if it's not already going.
 
 class Test(Frame):
     def printit(self):
-	print "hi"
+        print "hi"
 
     def createWidgets(self):
-	self.QUIT = Button(self, text='QUIT', foreground='red', 
-			   command=self.quit)
-	
-	self.QUIT.pack(side=LEFT, fill=BOTH)
+        self.QUIT = Button(self, text='QUIT', foreground='red',
+                           command=self.quit)
 
-	# a hello button
-	self.hi_there = Button(self, text='Hello', 
-			       command=self.printit)
-	self.hi_there.pack(side=LEFT)
+        self.QUIT.pack(side=LEFT, fill=BOTH)
+
+        # a hello button
+        self.hi_there = Button(self, text='Hello',
+                               command=self.printit)
+        self.hi_there.pack(side=LEFT)
 
     def __init__(self, master=None):
-	Frame.__init__(self, master)
-	Pack.config(self)
-	self.createWidgets()
+        Frame.__init__(self, master)
+        Pack.config(self)
+        self.createWidgets()
 
 test = Test()
 test.mainloop()
diff --git a/Demo/tkinter/matt/animation-simple.py b/Demo/tkinter/matt/animation-simple.py
index 435d6fa..b52e1dc 100644
--- a/Demo/tkinter/matt/animation-simple.py
+++ b/Demo/tkinter/matt/animation-simple.py
@@ -4,30 +4,30 @@ 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()
diff --git a/Demo/tkinter/matt/animation-w-velocity-ctrl.py b/Demo/tkinter/matt/animation-w-velocity-ctrl.py
index f3332f2..e676338 100644
--- a/Demo/tkinter/matt/animation-w-velocity-ctrl.py
+++ b/Demo/tkinter/matt/animation-w-velocity-ctrl.py
@@ -1,42 +1,42 @@
 from Tkinter import *
 
-# this is the same as simple-demo-1.py, but uses 
-# subclassing. 
-# note that there is no explicit call to start Tk. 
-# Tkinter is smart enough to start the system if it's not already going. 
+# this is the same as simple-demo-1.py, but uses
+# subclassing.
+# note that there is no explicit call to start Tk.
+# Tkinter is smart enough to start the system if it's not already going.
 
 
 class Test(Frame):
     def printit(self):
-	print "hi"
+        print "hi"
 
     def createWidgets(self):
-	self.QUIT = Button(self, text='QUIT', foreground='red', 
-			   command=self.quit)
-	self.QUIT.pack(side=BOTTOM, fill=BOTH)
+        self.QUIT = Button(self, text='QUIT', foreground='red',
+                           command=self.quit)
+        self.QUIT.pack(side=BOTTOM, fill=BOTH)
 
-	self.draw = Canvas(self, width="5i", height="5i")
+        self.draw = Canvas(self, width="5i", height="5i")
 
-	self.speed = Scale(self, orient=HORIZONTAL, from_=-100, to=100)
+        self.speed = Scale(self, orient=HORIZONTAL, from_=-100, to=100)
 
-	self.speed.pack(side=BOTTOM, fill=X)
+        self.speed.pack(side=BOTTOM, fill=X)
 
-	# all of these work..
-	self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
-	self.draw.pack(side=LEFT)
+        # all of these work..
+        self.draw.create_rectangle(0, 0, 10, 10, tags="thing", fill="blue")
+        self.draw.pack(side=LEFT)
 
     def moveThing(self, *args):
-	velocity = self.speed.get()
-	str = float(velocity) / 1000.0
-	str = "%ri" % (str,)
-	self.draw.move("thing",  str, str)
-	self.after(10, self.moveThing)
+        velocity = self.speed.get()
+        str = float(velocity) / 1000.0
+        str = "%ri" % (str,)
+        self.draw.move("thing",  str, str)
+        self.after(10, self.moveThing)
 
     def __init__(self, master=None):
-	Frame.__init__(self, master)
-	Pack.config(self)
-	self.createWidgets()
-	self.after(10, self.moveThing)
+        Frame.__init__(self, master)
+        Pack.config(self)
+        self.createWidgets()
+        self.after(10, self.moveThing)
 
 
 test = Test()
diff --git a/Demo/tkinter/matt/bind-w-mult-calls-p-type.py b/Demo/tkinter/matt/bind-w-mult-calls-p-type.py
index 0907e41..f3220da 100644
--- a/Demo/tkinter/matt/bind-w-mult-calls-p-type.py
+++ b/Demo/tkinter/matt/bind-w-mult-calls-p-type.py
@@ -1,34 +1,34 @@
 from Tkinter import *
-import string 
+import string
 
 # This program  shows how to use a simple type-in box
 
 class App(Frame):
     def __init__(self, master=None):
-	Frame.__init__(self, master)
-	self.pack()
+        Frame.__init__(self, master)
+        self.pack()
 
-	self.entrythingy = Entry()
-	self.entrythingy.pack()
+        self.entrythingy = Entry()
+        self.entrythingy.pack()
 
-	# and here we get a callback when the user hits return. we could
-	# make the key that triggers the callback anything we wanted to.
-	# other typical options might be <Key-Tab> or <Key> (for anything)
-	self.entrythingy.bind('<Key-Return>', self.print_contents)
+        # and here we get a callback when the user hits return. we could
+        # make the key that triggers the callback anything we wanted to.
+        # other typical options might be <Key-Tab> or <Key> (for anything)
+        self.entrythingy.bind('<Key-Return>', self.print_contents)
 
-	# Note that here is where we bind a completely different callback to 
-	# the same event. We pass "+" here to indicate that we wish to ADD 
-	# this callback to the list associated with this event type.
-	# Not specifying "+" would simply override whatever callback was
-	# defined on this event.
-	self.entrythingy.bind('<Key-Return>', self.print_something_else, "+")
+        # Note that here is where we bind a completely different callback to
+        # the same event. We pass "+" here to indicate that we wish to ADD
+        # this callback to the list associated with this event type.
+        # Not specifying "+" would simply override whatever callback was
+        # defined on this event.
+        self.entrythingy.bind('<Key-Return>', self.print_something_else, "+")
 
     def print_contents(self, event):
-	print "hi. contents of entry is now ---->", self.entrythingy.get()
+        print "hi. contents of entry is now ---->", self.entrythingy.get()
 
 
     def print_something_else(self, event):
-	print "hi. Now doing something completely different"
+        print "hi. Now doing something completely different"
 
 
 root = App()
@@ -37,8 +37,8 @@ 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.
diff --git a/Demo/tkinter/matt/canvas-demo-simple.py b/Demo/tkinter/matt/canvas-demo-simple.py
index d989626..a01679a 100644
--- a/Demo/tkinter/matt/canvas-demo-simple.py
+++ b/Demo/tkinter/matt/canvas-demo-simple.py
@@ -4,24 +4,24 @@ 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()
 
diff --git a/Demo/tkinter/matt/canvas-gridding.py b/Demo/tkinter/matt/canvas-gridding.py
index b200ea4..3c52b91 100644
--- a/Demo/tkinter/matt/canvas-gridding.py
+++ b/Demo/tkinter/matt/canvas-gridding.py
@@ -1,60 +1,60 @@
 from Tkinter import *
 
-# this is the same as simple-demo-1.py, but uses 
-# subclassing. 
-# note that there is no explicit call to start Tk. 
-# Tkinter is smart enough to start the system if it's not already going. 
+# this is the same as simple-demo-1.py, but uses
+# subclassing.
+# note that there is no explicit call to start Tk.
+# Tkinter is smart enough to start the system if it's not already going.
 
 class Test(Frame):
     def printit(self):
-	print "hi"
+        print "hi"
 
     def createWidgets(self):
-	self.QUIT = Button(self, text='QUIT', 
-				  background='red', 
-				  foreground='white', 
-				  height=3, 
-				  command=self.quit)
-	self.QUIT.pack(side=BOTTOM, fill=BOTH)	
+        self.QUIT = Button(self, text='QUIT',
+                                  background='red',
+                                  foreground='white',
+                                  height=3,
+                                  command=self.quit)
+        self.QUIT.pack(side=BOTTOM, fill=BOTH)
 
-	self.canvasObject = Canvas(self, width="5i", height="5i")
-	self.canvasObject.pack(side=LEFT)
+        self.canvasObject = Canvas(self, width="5i", height="5i")
+        self.canvasObject.pack(side=LEFT)
 
     def mouseDown(self, event):
-	# canvas x and y take the screen coords from the event and translate
-	# them into the coordinate system of the canvas object
-	self.startx = self.canvasObject.canvasx(event.x, self.griddingSize)
-	self.starty = self.canvasObject.canvasy(event.y, self.griddingSize)
+        # canvas x and y take the screen coords from the event and translate
+        # them into the coordinate system of the canvas object
+        self.startx = self.canvasObject.canvasx(event.x, self.griddingSize)
+        self.starty = self.canvasObject.canvasy(event.y, self.griddingSize)
 
     def mouseMotion(self, event):
-	# canvas x and y take the screen coords from the event and translate
-	# them into the coordinate system of the canvas object
-	x = self.canvasObject.canvasx(event.x, self.griddingSize)
-	y = self.canvasObject.canvasy(event.y, self.griddingSize)
-
-	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()
+        # 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()
+        Frame.__init__(self, master)
+        Pack.config(self)
+        self.createWidgets()
 
-	# this is a "tagOrId" for the rectangle we draw on the canvas
-	self.rubberbandBox = None
+        # this is a "tagOrId" for the rectangle we draw on the canvas
+        self.rubberbandBox = None
 
-	# this is the size of the gridding squares
-	self.griddingSize = 50
+        # this is the size of the gridding squares
+        self.griddingSize = 50
+
+        Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
+        Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
 
-	Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
-	Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
-	
 
 test = Test()
 
diff --git a/Demo/tkinter/matt/canvas-moving-or-creating.py b/Demo/tkinter/matt/canvas-moving-or-creating.py
index 74729a6..5327c08 100644
--- a/Demo/tkinter/matt/canvas-moving-or-creating.py
+++ b/Demo/tkinter/matt/canvas-moving-or-creating.py
@@ -1,6 +1,6 @@
 from Tkinter import *
 
-# this file demonstrates a more sophisticated movement -- 
+# this file demonstrates a more sophisticated movement --
 # move dots or create new ones if you click outside the dots
 
 class Test(Frame):
@@ -8,58 +8,55 @@ 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)
-
-	    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
+        # 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.lastx = event.x
+        self.lasty = event.y
 
     def mouseMove(self, event):
-	self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
-	self.lastx = event.x
-	self.lasty = event.y
+        self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
+        self.lastx = event.x
+        self.lasty = event.y
 
     ###################################################################
     ###### Event callbacks for canvas ITEMS (stuff drawn on the canvas)
     ###################################################################
     def mouseEnter(self, event):
         # the CURRENT tag is applied to the object the cursor is over.
-	# this happens automatically.
-	self.draw.itemconfig(CURRENT, fill="red")
+        # this happens automatically.
+        self.draw.itemconfig(CURRENT, fill="red")
 
     def mouseLeave(self, event):
-	# the CURRENT tag is applied to the object the cursor is over.
-	# this happens automatically.
-	self.draw.itemconfig(CURRENT, fill="blue")
+        # the CURRENT tag is applied to the object the cursor is over.
+        # this happens automatically.
+        self.draw.itemconfig(CURRENT, fill="blue")
 
     def createWidgets(self):
-	self.QUIT = Button(self, text='QUIT', foreground='red', 
-			   command=self.quit)
-	self.QUIT.pack(side=LEFT, fill=BOTH)
-	self.draw = Canvas(self, width="5i", height="5i")
-	self.draw.pack(side=LEFT)
+        self.QUIT = Button(self, text='QUIT', foreground='red',
+                           command=self.quit)
+        self.QUIT.pack(side=LEFT, fill=BOTH)
+        self.draw = Canvas(self, width="5i", height="5i")
+        self.draw.pack(side=LEFT)
 
-	Widget.bind(self.draw, "<1>", self.mouseDown)
-	Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
+        Widget.bind(self.draw, "<1>", self.mouseDown)
+        Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
 
     def __init__(self, master=None):
-	Frame.__init__(self, master)
-	Pack.config(self)
-	self.createWidgets()
+        Frame.__init__(self, master)
+        Pack.config(self)
+        self.createWidgets()
 
 test = Test()
 test.mainloop()
-
-
-
diff --git a/Demo/tkinter/matt/canvas-moving-w-mouse.py b/Demo/tkinter/matt/canvas-moving-w-mouse.py
index 447e290..81785d8 100644
--- a/Demo/tkinter/matt/canvas-moving-w-mouse.py
+++ b/Demo/tkinter/matt/canvas-moving-w-mouse.py
@@ -7,49 +7,49 @@ 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()
diff --git a/Demo/tkinter/matt/canvas-mult-item-sel.py b/Demo/tkinter/matt/canvas-mult-item-sel.py
index 2368733..a4f267c 100644
--- a/Demo/tkinter/matt/canvas-mult-item-sel.py
+++ b/Demo/tkinter/matt/canvas-mult-item-sel.py
@@ -1,6 +1,6 @@
 from Tkinter import *
 
-# allows moving dots with multiple selection. 
+# allows moving dots with multiple selection.
 
 SELECTED_COLOR = "red"
 UNSELECTED_COLOR = "blue"
@@ -10,72 +10,69 @@ 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
-		
-	
+        # 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
+        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)
-
-	################
-	# 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)
-
-	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 = Button(self, text='QUIT', foreground='red',
+                           command=self.quit)
 
-    def __init__(self, master=None):
-	Frame.__init__(self, master)
-	Pack.config(self)
-	self.createWidgets()
+        ################
+        # 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)
 
-test = Test()
-test.mainloop()
+        # 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)
 
+        self.QUIT.pack(side=BOTTOM, fill=BOTH)
+        self.label.pack(side=BOTTOM, fill=X, expand=1)
+        self.button.pack(side=BOTTOM, fill=X)
+        self.draw.pack(side=LEFT)
 
+    def __init__(self, master=None):
+        Frame.__init__(self, master)
+        Pack.config(self)
+        self.createWidgets()
 
+test = Test()
+test.mainloop()
diff --git a/Demo/tkinter/matt/canvas-reading-tag-info.py b/Demo/tkinter/matt/canvas-reading-tag-info.py
index 7044691..f57ea18 100644
--- a/Demo/tkinter/matt/canvas-reading-tag-info.py
+++ b/Demo/tkinter/matt/canvas-reading-tag-info.py
@@ -3,46 +3,46 @@ 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.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], "<--"
-	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]
-
-	self.drawing.pack(side=LEFT)
+        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")
+
+        # 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], "<--"
+
+        ## 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()
+        Frame.__init__(self, master)
+        Pack.config(self)
+        self.createWidgets()
 
 test = Test()
 
diff --git a/Demo/tkinter/matt/canvas-w-widget-draw-el.py b/Demo/tkinter/matt/canvas-w-widget-draw-el.py
index a1bb3b5..5b26210 100644
--- a/Demo/tkinter/matt/canvas-w-widget-draw-el.py
+++ b/Demo/tkinter/matt/canvas-w-widget-draw-el.py
@@ -4,32 +4,32 @@ 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()
 
diff --git a/Demo/tkinter/matt/canvas-with-scrollbars.py b/Demo/tkinter/matt/canvas-with-scrollbars.py
index 60c7b13..81ef25a 100644
--- a/Demo/tkinter/matt/canvas-with-scrollbars.py
+++ b/Demo/tkinter/matt/canvas-with-scrollbars.py
@@ -1,59 +1,59 @@
 from Tkinter import *
 
-# This example program creates a scroling canvas, and demonstrates 
+# This example program creates a scroling canvas, and demonstrates
 # how to tie scrollbars and canvses together. The mechanism
 # is analogus for listboxes and other widgets with
 # "xscroll" and "yscroll" configuration options.
 
 class Test(Frame):
     def printit(self):
-	print "hi"
+        print "hi"
 
     def createWidgets(self):
-	self.question = Label(self, text="Can Find The BLUE Square??????")
-	self.question.pack()
+        self.question = Label(self, text="Can Find The BLUE Square??????")
+        self.question.pack()
 
-	self.QUIT = Button(self, text='QUIT', background='red', 
-			   height=3, command=self.quit)
-	self.QUIT.pack(side=BOTTOM, fill=BOTH)	
-	spacer = Frame(self, height="0.25i")
-	spacer.pack(side=BOTTOM)
+        self.QUIT = Button(self, text='QUIT', background='red',
+                           height=3, command=self.quit)
+        self.QUIT.pack(side=BOTTOM, fill=BOTH)
+        spacer = Frame(self, height="0.25i")
+        spacer.pack(side=BOTTOM)
 
-	# notice that the scroll region (20" x 20") is larger than 
-	# displayed size of the widget (5" x 5")
-	self.draw = Canvas(self, width="5i", height="5i",
-			   background="white",
-			   scrollregion=(0, 0, "20i", "20i"))
+        # notice that the scroll region (20" x 20") is larger than
+        # displayed size of the widget (5" x 5")
+        self.draw = Canvas(self, width="5i", height="5i",
+                           background="white",
+                           scrollregion=(0, 0, "20i", "20i"))
 
-	self.draw.scrollX = Scrollbar(self, orient=HORIZONTAL)
-	self.draw.scrollY = Scrollbar(self, orient=VERTICAL)
+        self.draw.scrollX = Scrollbar(self, orient=HORIZONTAL)
+        self.draw.scrollY = Scrollbar(self, orient=VERTICAL)
 
-	# now tie the three together. This is standard boilerplate text
-	self.draw['xscrollcommand'] = self.draw.scrollX.set
-	self.draw['yscrollcommand'] = self.draw.scrollY.set
-	self.draw.scrollX['command'] = self.draw.xview
-	self.draw.scrollY['command'] = self.draw.yview
+        # now tie the three together. This is standard boilerplate text
+        self.draw['xscrollcommand'] = self.draw.scrollX.set
+        self.draw['yscrollcommand'] = self.draw.scrollY.set
+        self.draw.scrollX['command'] = self.draw.xview
+        self.draw.scrollY['command'] = self.draw.yview
 
-	# draw something. Note that the first square 
-	# is visible, but you need to scroll to see the second one.
-	self.draw.create_rectangle(0, 0, "3.5i", "3.5i", fill="black")
-	self.draw.create_rectangle("10i", "10i", "13.5i", "13.5i", fill="blue")
+        # draw something. Note that the first square
+        # is visible, but you need to scroll to see the second one.
+        self.draw.create_rectangle(0, 0, "3.5i", "3.5i", fill="black")
+        self.draw.create_rectangle("10i", "10i", "13.5i", "13.5i", fill="blue")
 
-	# pack 'em up
-	self.draw.scrollX.pack(side=BOTTOM, fill=X)
-	self.draw.scrollY.pack(side=RIGHT, fill=Y)
-	self.draw.pack(side=LEFT)
+        # pack 'em up
+        self.draw.scrollX.pack(side=BOTTOM, fill=X)
+        self.draw.scrollY.pack(side=RIGHT, fill=Y)
+        self.draw.pack(side=LEFT)
 
 
-    def scrollCanvasX(self, *args): 
-	print "scrolling", args
-	print self.draw.scrollX.get()
+    def scrollCanvasX(self, *args):
+        print "scrolling", args
+        print self.draw.scrollX.get()
 
 
     def __init__(self, master=None):
-	Frame.__init__(self, master)
-	Pack.config(self)
-	self.createWidgets()
+        Frame.__init__(self, master)
+        Pack.config(self)
+        self.createWidgets()
 
 test = Test()
 
diff --git a/Demo/tkinter/matt/dialog-box.py b/Demo/tkinter/matt/dialog-box.py
index cbfe29f..dea8f39 100644
--- a/Demo/tkinter/matt/dialog-box.py
+++ b/Demo/tkinter/matt/dialog-box.py
@@ -6,59 +6,59 @@ 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()
diff --git a/Demo/tkinter/matt/entry-simple.py b/Demo/tkinter/matt/entry-simple.py
index cf82b89..5146e6f 100644
--- a/Demo/tkinter/matt/entry-simple.py
+++ b/Demo/tkinter/matt/entry-simple.py
@@ -1,25 +1,24 @@
 from Tkinter import *
-import string 
+import string
 
 # This program  shows how to use a simple type-in box
 
 class App(Frame):
     def __init__(self, master=None):
-	Frame.__init__(self, master)
-	self.pack()
+        Frame.__init__(self, master)
+        self.pack()
 
-	self.entrythingy = Entry()
-	self.entrythingy.pack()
+        self.entrythingy = Entry()
+        self.entrythingy.pack()
 
-	# and here we get a callback when the user hits return. we could
-	# make the key that triggers the callback anything we wanted to.
-	# other typical options might be <Key-Tab> or <Key> (for anything)
-	self.entrythingy.bind('<Key-Return>', self.print_contents)
+        # and here we get a callback when the user hits return. we could
+        # make the key that triggers the callback anything we wanted to.
+        # other typical options might be <Key-Tab> or <Key> (for anything)
+        self.entrythingy.bind('<Key-Return>', self.print_contents)
 
     def print_contents(self, event):
-	print "hi. contents of entry is now ---->", self.entrythingy.get()
+        print "hi. contents of entry is now ---->", self.entrythingy.get()
 
 root = App()
 root.master.title("Foo")
 root.mainloop()
-
diff --git a/Demo/tkinter/matt/entry-with-shared-variable.py b/Demo/tkinter/matt/entry-with-shared-variable.py
index 360f973..2b76162 100644
--- a/Demo/tkinter/matt/entry-with-shared-variable.py
+++ b/Demo/tkinter/matt/entry-with-shared-variable.py
@@ -1,47 +1,46 @@
 from Tkinter import *
-import string 
+import string
 
 # This program  shows how to make a typein box shadow a program variable.
 
 class App(Frame):
     def __init__(self, master=None):
-	Frame.__init__(self, master)
-	self.pack()
-
-	self.entrythingy = Entry(self)
-	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)
+        Frame.__init__(self, master)
+        self.pack()
+
+        self.entrythingy = Entry(self)
+        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 
+        # notice here, we don't actually refer to the entry box.
+        # we just operate on the string variable and we
         # because it's being looked at by the entry widget, changing
-	# the variable changes the entry widget display automatically.
-	# the strange get/set operators are clunky, true...
-	str = string.upper(self.contents.get())
-	self.contents.set(str)
+        # the variable changes the entry widget display automatically.
+        # the strange get/set operators are clunky, true...
+        str = string.upper(self.contents.get())
+        self.contents.set(str)
 
     def print_contents(self, event):
-	print "hi. contents of entry is now ---->", self.contents.get()
+        print "hi. contents of entry is now ---->", self.contents.get()
 
 root = App()
 root.master.title("Foo")
 root.mainloop()
-
diff --git a/Demo/tkinter/matt/killing-window-w-wm.py b/Demo/tkinter/matt/killing-window-w-wm.py
index 805a6bc..6a0e2fe 100644
--- a/Demo/tkinter/matt/killing-window-w-wm.py
+++ b/Demo/tkinter/matt/killing-window-w-wm.py
@@ -1,8 +1,8 @@
 from Tkinter import *
 
-# This file shows how to trap the killing of a window 
+# This file shows how to trap the killing of a window
 # when the user uses window manager menus (typ. upper left hand corner
-# menu in the decoration border). 
+# menu in the decoration border).
 
 
 ### ******* this isn't really called -- read the comments
@@ -11,31 +11,31 @@ 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()
diff --git a/Demo/tkinter/matt/menu-all-types-of-entries.py b/Demo/tkinter/matt/menu-all-types-of-entries.py
index 1ac51c8..f4afe4a 100644
--- a/Demo/tkinter/matt/menu-all-types-of-entries.py
+++ b/Demo/tkinter/matt/menu-all-types-of-entries.py
@@ -1,16 +1,16 @@
 from Tkinter import *
 
-# some vocabulary to keep from getting confused. This terminology 
-# is something I cooked up for this file, but follows the man pages 
+# some vocabulary to keep from getting confused. This terminology
+# is something I cooked up for this file, but follows the man pages
 # pretty closely
-# 
-# 
-# 
+#
+#
+#
 #       This is a MENUBUTTON
 #       V
 # +-------------+
 # |             |
-# 
+#
 # +------------++------------++------------+
 # |            ||            ||            |
 # |  File      ||  Edit      || Options    |   <-------- the MENUBAR
@@ -22,7 +22,7 @@ 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()
-
-
-
-
-
-
diff --git a/Demo/tkinter/matt/menu-simple.py b/Demo/tkinter/matt/menu-simple.py
index 28f2c9e..46b5364 100644
--- a/Demo/tkinter/matt/menu-simple.py
+++ b/Demo/tkinter/matt/menu-simple.py
@@ -1,16 +1,16 @@
 from Tkinter import *
 
-# some vocabulary to keep from getting confused. This terminology 
-# is something I cooked up for this file, but follows the man pages 
+# some vocabulary to keep from getting confused. This terminology
+# is something I cooked up for this file, but follows the man pages
 # pretty closely
-# 
-# 
-# 
+#
+#
+#
 #       This is a MENUBUTTON
 #       V
 # +-------------+
 # |             |
-# 
+#
 # +------------++------------++------------+
 # |            ||            ||            |
 # |  File      ||  Edit      || Options    |   <-------- the MENUBAR
@@ -22,7 +22,7 @@ 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()
-
-
-
-
-
-
diff --git a/Demo/tkinter/matt/not-what-you-might-think-1.py b/Demo/tkinter/matt/not-what-you-might-think-1.py
index 24de2ef..7b20f02 100644
--- a/Demo/tkinter/matt/not-what-you-might-think-1.py
+++ b/Demo/tkinter/matt/not-what-you-might-think-1.py
@@ -4,21 +4,21 @@ 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()
 
diff --git a/Demo/tkinter/matt/not-what-you-might-think-2.py b/Demo/tkinter/matt/not-what-you-might-think-2.py
index c01854e..9ee197c 100644
--- a/Demo/tkinter/matt/not-what-you-might-think-2.py
+++ b/Demo/tkinter/matt/not-what-you-might-think-2.py
@@ -4,23 +4,23 @@ 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()
 
diff --git a/Demo/tkinter/matt/packer-and-placer-together.py b/Demo/tkinter/matt/packer-and-placer-together.py
index 4ceec54..184d56b 100644
--- a/Demo/tkinter/matt/packer-and-placer-together.py
+++ b/Demo/tkinter/matt/packer-and-placer-together.py
@@ -1,6 +1,6 @@
 from Tkinter import *
 
-# This is a program that tests the placer geom manager in conjunction with 
+# This is a program that tests the placer geom manager in conjunction with
 # the packer. The background (green) is packed, while the widget inside is placed
 
 
@@ -17,15 +17,15 @@ 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()
-
diff --git a/Demo/tkinter/matt/packer-simple.py b/Demo/tkinter/matt/packer-simple.py
index 7773cae..f55f1be 100644
--- a/Demo/tkinter/matt/packer-simple.py
+++ b/Demo/tkinter/matt/packer-simple.py
@@ -3,30 +3,30 @@ 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()
diff --git a/Demo/tkinter/matt/placer-simple.py b/Demo/tkinter/matt/placer-simple.py
index b7cae7e..30d9e9e 100644
--- a/Demo/tkinter/matt/placer-simple.py
+++ b/Demo/tkinter/matt/placer-simple.py
@@ -15,7 +15,7 @@ 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()
-
diff --git a/Demo/tkinter/matt/pong-demo-1.py b/Demo/tkinter/matt/pong-demo-1.py
index a27f334..7fcf800 100644
--- a/Demo/tkinter/matt/pong-demo-1.py
+++ b/Demo/tkinter/matt/pong-demo-1.py
@@ -5,48 +5,48 @@ 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()
diff --git a/Demo/tkinter/matt/printing-coords-of-items.py b/Demo/tkinter/matt/printing-coords-of-items.py
index 6400fd8..a37733d 100644
--- a/Demo/tkinter/matt/printing-coords-of-items.py
+++ b/Demo/tkinter/matt/printing-coords-of-items.py
@@ -7,58 +7,55 @@ 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")
-	    self.draw.tag_bind(fred, "<Enter>", self.mouseEnter)
-	    self.draw.tag_bind(fred, "<Leave>", self.mouseLeave)
-	self.lastx = event.x
-	self.lasty = event.y
+        # 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
 
     def mouseMove(self, event):
-	self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
-	self.lastx = event.x
-	self.lasty = event.y
+        self.draw.move(CURRENT, event.x - self.lastx, event.y - self.lasty)
+        self.lastx = event.x
+        self.lasty = event.y
 
     ###################################################################
     ###### Event callbacks for canvas ITEMS (stuff drawn on the canvas)
     ###################################################################
     def mouseEnter(self, event):
         # the "current" tag is applied to the object the cursor is over.
-	# this happens automatically.
-	self.draw.itemconfig(CURRENT, fill="red")
-	print self.draw.coords(CURRENT)
-	
+        # this happens automatically.
+        self.draw.itemconfig(CURRENT, fill="red")
+        print self.draw.coords(CURRENT)
+
     def mouseLeave(self, event):
-	# the "current" tag is applied to the object the cursor is over.
-	# this happens automatically.
-	self.draw.itemconfig(CURRENT, fill="blue")
+        # the "current" tag is applied to the object the cursor is over.
+        # this happens automatically.
+        self.draw.itemconfig(CURRENT, fill="blue")
 
     def createWidgets(self):
-	self.QUIT = Button(self, text='QUIT', foreground='red',
-			   command=self.quit)
-	self.QUIT.pack(side=LEFT, fill=BOTH)	
-	self.draw = Canvas(self, width="5i", height="5i")
-	self.draw.pack(side=LEFT)
+        self.QUIT = Button(self, text='QUIT', foreground='red',
+                           command=self.quit)
+        self.QUIT.pack(side=LEFT, fill=BOTH)
+        self.draw = Canvas(self, width="5i", height="5i")
+        self.draw.pack(side=LEFT)
 
-	Widget.bind(self.draw, "<1>", self.mouseDown)
-	Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
+        Widget.bind(self.draw, "<1>", self.mouseDown)
+        Widget.bind(self.draw, "<B1-Motion>", self.mouseMove)
 
     def __init__(self, master=None):
-	Frame.__init__(self, master)
-	Pack.config(self)
-	self.createWidgets()
+        Frame.__init__(self, master)
+        Pack.config(self)
+        self.createWidgets()
 
 test = Test()
 test.mainloop()
-
-
-
diff --git a/Demo/tkinter/matt/radiobutton-simple.py b/Demo/tkinter/matt/radiobutton-simple.py
index 65dfe52..e9d6afe 100644
--- a/Demo/tkinter/matt/radiobutton-simple.py
+++ b/Demo/tkinter/matt/radiobutton-simple.py
@@ -1,10 +1,10 @@
 from Tkinter import *
 
-# This is a demo program that shows how to 
-# create radio buttons and how to get other widgets to 
-# share the information in a radio button. 
-# 
-# There are other ways of doing this too, but 
+# This is a demo program that shows how to
+# create radio buttons and how to get other widgets to
+# share the information in a radio button.
+#
+# There are other ways of doing this too, but
 # the "variable" option of radiobuttons seems to be the easiest.
 #
 # note how each button has a value it sets the variable to as it gets hit.
@@ -12,50 +12,50 @@ from Tkinter import *
 
 class Test(Frame):
     def printit(self):
-	print "hi"
+        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)
-	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.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.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)
+        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.lemon = Radiobutton(
+            self.radioframe, text="Lemon Flavor",
+            variable=self.flavor, value="lemon",
+            anchor=W)
+        self.radioframe.lemon.pack(fill=X)
+
+        # this is a text entry that lets you type in the name of a flavor too.
+        self.entry = Entry(self, textvariable=self.flavor)
+        self.entry.pack(fill=X)
+        self.QUIT = Button(self, text='QUIT', foreground='red',
+                           command=self.quit)
+        self.QUIT.pack(side=BOTTOM, fill=BOTH)
 
 
     def __init__(self, master=None):
-	Frame.__init__(self, master)
-	Pack.config(self)
-	self.createWidgets()
+        Frame.__init__(self, master)
+        Pack.config(self)
+        self.createWidgets()
 
 test = Test()
 
diff --git a/Demo/tkinter/matt/rubber-band-box-demo-1.py b/Demo/tkinter/matt/rubber-band-box-demo-1.py
index 5196bf7..b00518e 100644
--- a/Demo/tkinter/matt/rubber-band-box-demo-1.py
+++ b/Demo/tkinter/matt/rubber-band-box-demo-1.py
@@ -2,55 +2,55 @@ 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)
-
-	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()
+        # 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)
-	
+        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)
+        Frame.__init__(self, master)
+        Pack.config(self)
+        self.createWidgets()
+
+        # this is a "tagOrId" for the rectangle we draw on the canvas
+        self.rubberbandBox = None
+
+        # and the bindings that make it work..
+        Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
+        Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
+        Widget.bind(self.canvasObject, "<Button1-ButtonRelease>", self.mouseUp)
 
 
 test = Test()
diff --git a/Demo/tkinter/matt/rubber-line-demo-1.py b/Demo/tkinter/matt/rubber-line-demo-1.py
index f6d8535..59b8bd9 100644
--- a/Demo/tkinter/matt/rubber-line-demo-1.py
+++ b/Demo/tkinter/matt/rubber-line-demo-1.py
@@ -2,49 +2,49 @@ 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)
-
-	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()
+        # 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)
-	
+        Frame.__init__(self, master)
+        Pack.config(self)
+        self.createWidgets()
+        # this is a "tagOrId" for the rectangle we draw on the canvas
+        self.rubberbandLine = None
+        Widget.bind(self.canvasObject, "<Button-1>", self.mouseDown)
+        Widget.bind(self.canvasObject, "<Button1-Motion>", self.mouseMotion)
+
 
 test = Test()
 
diff --git a/Demo/tkinter/matt/slider-demo-1.py b/Demo/tkinter/matt/slider-demo-1.py
index 40395df..db6114b 100644
--- a/Demo/tkinter/matt/slider-demo-1.py
+++ b/Demo/tkinter/matt/slider-demo-1.py
@@ -5,32 +5,32 @@ 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()
diff --git a/Demo/tkinter/matt/subclass-existing-widgets.py b/Demo/tkinter/matt/subclass-existing-widgets.py
index e79dd5c..0e08f92 100644
--- a/Demo/tkinter/matt/subclass-existing-widgets.py
+++ b/Demo/tkinter/matt/subclass-existing-widgets.py
@@ -5,9 +5,9 @@ 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()
-
diff --git a/Demo/tkinter/matt/two-radio-groups.py b/Demo/tkinter/matt/two-radio-groups.py
index 5c17333..9fd8f4f 100644
--- a/Demo/tkinter/matt/two-radio-groups.py
+++ b/Demo/tkinter/matt/two-radio-groups.py
@@ -1,44 +1,44 @@
 from Tkinter import *
 
-#	The way to think about this is that each radio button menu
-#	controls a different variable -- clicking on one of the
-#	mutually exclusive choices in a radiobutton assigns some value
-#	to an application variable you provide. When you define a
-#	radiobutton menu choice, you have the option of specifying the
-#	name of a varaible and value to assign to that variable when
-#	that choice is selected. This clever mechanism relieves you,
-#	the programmer, from having to write a dumb callback that
-#	probably wouldn't have done anything more than an assignment
-#	anyway. The Tkinter options for this follow their Tk
-#	counterparts: 
-#	{"variable" : my_flavor_variable, "value" : "strawberry"}
+#       The way to think about this is that each radio button menu
+#       controls a different variable -- clicking on one of the
+#       mutually exclusive choices in a radiobutton assigns some value
+#       to an application variable you provide. When you define a
+#       radiobutton menu choice, you have the option of specifying the
+#       name of a varaible and value to assign to that variable when
+#       that choice is selected. This clever mechanism relieves you,
+#       the programmer, from having to write a dumb callback that
+#       probably wouldn't have done anything more than an assignment
+#       anyway. The Tkinter options for this follow their Tk
+#       counterparts:
+#       {"variable" : my_flavor_variable, "value" : "strawberry"}
 #       where my_flavor_variable is an instance of one of the
 #       subclasses of Variable, provided in Tkinter.py (there is
-#	StringVar(), IntVar(), DoubleVar() and BooleanVar() to choose
-#	from) 
+#       StringVar(), IntVar(), DoubleVar() and BooleanVar() to choose
+#       from)
 
 
 
 def makePoliticalParties(var):
-    # make menu button 
-    Radiobutton_button = Menubutton(mBar, text='Political Party', 
-				    underline=0)
+    # make menu button
+    Radiobutton_button = Menubutton(mBar, text='Political Party',
+                                    underline=0)
     Radiobutton_button.pack(side=LEFT, padx='2m')
-    
+
     # the primary pulldown
     Radiobutton_button.menu = Menu(Radiobutton_button)
 
-    Radiobutton_button.menu.add_radiobutton(label='Republican', 
-					    variable=var, value=1)
+    Radiobutton_button.menu.add_radiobutton(label='Republican',
+                                            variable=var, value=1)
+
+    Radiobutton_button.menu.add('radiobutton', {'label': 'Democrat',
+                                                'variable' : var,
+                                                'value' : 2})
 
-    Radiobutton_button.menu.add('radiobutton', {'label': 'Democrat', 
-						'variable' : var, 
-						'value' : 2})
+    Radiobutton_button.menu.add('radiobutton', {'label': 'Libertarian',
+                                                'variable' : var,
+                                                'value' : 3})
 
-    Radiobutton_button.menu.add('radiobutton', {'label': 'Libertarian', 
-						'variable' : var, 
-						'value' : 3})
-    
     var.set(2)
 
     # set up a pointer from the file menubutton back to the file menu
@@ -48,22 +48,22 @@ def 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')
diff --git a/Demo/tkinter/matt/window-creation-more.py b/Demo/tkinter/matt/window-creation-more.py
index 492027a..eb0eb6f 100644
--- a/Demo/tkinter/matt/window-creation-more.py
+++ b/Demo/tkinter/matt/window-creation-more.py
@@ -5,31 +5,31 @@ 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()
diff --git a/Demo/tkinter/matt/window-creation-simple.py b/Demo/tkinter/matt/window-creation-simple.py
index 969fefb..c990ed9 100644
--- a/Demo/tkinter/matt/window-creation-simple.py
+++ b/Demo/tkinter/matt/window-creation-simple.py
@@ -4,28 +4,28 @@ 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()
diff --git a/Demo/tkinter/matt/window-creation-w-location.py b/Demo/tkinter/matt/window-creation-w-location.py
index 0ec4e09..3f2b5b0 100644
--- a/Demo/tkinter/matt/window-creation-w-location.py
+++ b/Demo/tkinter/matt/window-creation-w-location.py
@@ -17,29 +17,29 @@ class 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()