Whitespace normalization, via reindent.py.

21 files changed, 2620 insertions, 2621 deletions

diff --git a/Demo/tkinter/guido/AttrDialog.py b/Demo/tkinter/guido/AttrDialog.py
index 4878cb5..86333ad 100755
--- a/Demo/tkinter/guido/AttrDialog.py
+++ b/Demo/tkinter/guido/AttrDialog.py
@@ -16,437 +16,437 @@ from Tkinter import *
 
 class Option:
 
-	varclass = StringVar		# May be overridden
-
-	def __init__(self, dialog, option):
-		self.dialog = dialog
-		self.option = option
-		self.master = dialog.top
-		self.default, self.klass = dialog.options[option]
-		self.var = self.varclass(self.master)
-		self.frame = Frame(self.master)
-		self.frame.pack(fill=X)
-		self.label = Label(self.frame, text=(option + ":"))
-		self.label.pack(side=LEFT)
-		self.update()
-		self.addoption()
-
-	def refresh(self):
-		self.dialog.refresh()
-		self.update()
-
-	def update(self):
-		try:
-			self.current = self.dialog.current[self.option]
-		except KeyError:
-			self.current = self.default
-		self.var.set(self.current)
-
-	def set(self, e=None):		# Should be overridden
-		pass
+    varclass = StringVar            # May be overridden
+
+    def __init__(self, dialog, option):
+        self.dialog = dialog
+        self.option = option
+        self.master = dialog.top
+        self.default, self.klass = dialog.options[option]
+        self.var = self.varclass(self.master)
+        self.frame = Frame(self.master)
+        self.frame.pack(fill=X)
+        self.label = Label(self.frame, text=(option + ":"))
+        self.label.pack(side=LEFT)
+        self.update()
+        self.addoption()
+
+    def refresh(self):
+        self.dialog.refresh()
+        self.update()
+
+    def update(self):
+        try:
+            self.current = self.dialog.current[self.option]
+        except KeyError:
+            self.current = self.default
+        self.var.set(self.current)
+
+    def set(self, e=None):          # Should be overridden
+        pass
 
 class BooleanOption(Option):
 
-	varclass = BooleanVar
+    varclass = BooleanVar
 
-	def addoption(self):
-		self.button = Checkbutton(self.frame,
-					 text='on/off',
-					 onvalue=1,
-					 offvalue=0,
-					 variable=self.var,
-					 relief=RAISED,
-					 borderwidth=2,
-					 command=self.set)
-		self.button.pack(side=RIGHT)
+    def addoption(self):
+        self.button = Checkbutton(self.frame,
+                                 text='on/off',
+                                 onvalue=1,
+                                 offvalue=0,
+                                 variable=self.var,
+                                 relief=RAISED,
+                                 borderwidth=2,
+                                 command=self.set)
+        self.button.pack(side=RIGHT)
 
 class EnumOption(Option):
 
-	def addoption(self):
-		self.button = Menubutton(self.frame,
-					 textvariable=self.var,
-					 relief=RAISED, borderwidth=2)
-		self.button.pack(side=RIGHT)
-		self.menu = Menu(self.button)
-		self.button['menu'] = self.menu
-		for v in self.dialog.classes[self.klass]:
-			self.menu.add_radiobutton(
-			    label=v,
-			    variable=self.var,
-			    value=v,
-			    command=self.set)
+    def addoption(self):
+        self.button = Menubutton(self.frame,
+                                 textvariable=self.var,
+                                 relief=RAISED, borderwidth=2)
+        self.button.pack(side=RIGHT)
+        self.menu = Menu(self.button)
+        self.button['menu'] = self.menu
+        for v in self.dialog.classes[self.klass]:
+            self.menu.add_radiobutton(
+                label=v,
+                variable=self.var,
+                value=v,
+                command=self.set)
 
 class StringOption(Option):
 
-	def addoption(self):
-		self.entry = Entry(self.frame,
-				   textvariable=self.var,
-				   width=10,
-				   relief=SUNKEN,
-				   borderwidth=2)
-		self.entry.pack(side=RIGHT, fill=X, expand=1)
-		self.entry.bind('<Return>', self.set)
+    def addoption(self):
+        self.entry = Entry(self.frame,
+                           textvariable=self.var,
+                           width=10,
+                           relief=SUNKEN,
+                           borderwidth=2)
+        self.entry.pack(side=RIGHT, fill=X, expand=1)
+        self.entry.bind('<Return>', self.set)
 
 class ReadonlyOption(Option):
 
-	def addoption(self):
-		self.label = Label(self.frame, textvariable=self.var,
-				   anchor=E)
-		self.label.pack(side=RIGHT)
+    def addoption(self):
+        self.label = Label(self.frame, textvariable=self.var,
+                           anchor=E)
+        self.label.pack(side=RIGHT)
 
 class Dialog:
 
-	def __init__(self, master):
-		self.master = master
-		self.fixclasses()
-		self.refresh()
-		self.top = Toplevel(self.master)
-		self.top.title(self.__class__.__name__)
-		self.top.minsize(1, 1)
-		self.addchoices()
-
-	def refresh(self): pass		# Must override
-
-	def fixclasses(self): pass	# May override
-
-	def addchoices(self):
-		self.choices = {}
-		list = []
-		for k, dc in self.options.items():
-			list.append((k, dc))
-		list.sort()
-		for k, (d, c) in list:
-			try:
-				cl = self.classes[c]
-			except KeyError:
-				cl = 'unknown'
-			if type(cl) == TupleType:
-				cl = self.enumoption
-			elif cl == 'boolean':
-				cl = self.booleanoption
-			elif cl == 'readonly':
-				cl = self.readonlyoption
-			else:
-				cl = self.stringoption
-			self.choices[k] = cl(self, k)
-
-	# Must override:
-	options = {}
-	classes = {}
-
-	# May override:
-	booleanoption = BooleanOption
-	stringoption = StringOption
-	enumoption = EnumOption
-	readonlyoption = ReadonlyOption
+    def __init__(self, master):
+        self.master = master
+        self.fixclasses()
+        self.refresh()
+        self.top = Toplevel(self.master)
+        self.top.title(self.__class__.__name__)
+        self.top.minsize(1, 1)
+        self.addchoices()
+
+    def refresh(self): pass         # Must override
+
+    def fixclasses(self): pass      # May override
+
+    def addchoices(self):
+        self.choices = {}
+        list = []
+        for k, dc in self.options.items():
+            list.append((k, dc))
+        list.sort()
+        for k, (d, c) in list:
+            try:
+                cl = self.classes[c]
+            except KeyError:
+                cl = 'unknown'
+            if type(cl) == TupleType:
+                cl = self.enumoption
+            elif cl == 'boolean':
+                cl = self.booleanoption
+            elif cl == 'readonly':
+                cl = self.readonlyoption
+            else:
+                cl = self.stringoption
+            self.choices[k] = cl(self, k)
+
+    # Must override:
+    options = {}
+    classes = {}
+
+    # May override:
+    booleanoption = BooleanOption
+    stringoption = StringOption
+    enumoption = EnumOption
+    readonlyoption = ReadonlyOption
 
 class PackDialog(Dialog):
 
-	def __init__(self, widget):
-		self.widget = widget
-		Dialog.__init__(self, widget)
-
-	def refresh(self):
-		self.current = self.widget.info()
-		self.current['.class'] = self.widget.winfo_class()
-		self.current['.name'] = self.widget._w
-
-	class packoption: # Mix-in class
-		def set(self, e=None):
-			self.current = self.var.get()
-			try:
-				apply(self.dialog.widget.pack, (),
-				      {self.option: self.current})
-			except TclError, msg:
-				print msg
-				self.refresh()
-
-	class booleanoption(packoption, BooleanOption): pass
-	class enumoption(packoption, EnumOption): pass
-	class stringoption(packoption, StringOption): pass
-	class readonlyoption(packoption, ReadonlyOption): pass
-
-	options = {
-		'.class': (None, 'Class'),
-		'.name': (None, 'Name'),
-		'after': (None, 'Widget'),
-		'anchor': ('center', 'Anchor'),
-		'before': (None, 'Widget'),
-		'expand': ('no', 'Boolean'),
-		'fill': ('none', 'Fill'),
-		'in': (None, 'Widget'),
-		'ipadx': (0, 'Pad'),
-		'ipady': (0, 'Pad'),
-		'padx': (0, 'Pad'),
-		'pady': (0, 'Pad'),
-		'side': ('top', 'Side'),
-		}
-
-	classes = {
-		'Anchor': (N, NE, E, SE, S, SW, W, NW, CENTER),
-		'Boolean': 'boolean',
-		'Class': 'readonly',
-		'Expand': 'boolean',
-		'Fill': (NONE, X, Y, BOTH),
-		'Name': 'readonly',
-		'Pad': 'pixel',
-		'Side': (TOP, RIGHT, BOTTOM, LEFT),
-		'Widget': 'readonly',
-		}
+    def __init__(self, widget):
+        self.widget = widget
+        Dialog.__init__(self, widget)
+
+    def refresh(self):
+        self.current = self.widget.info()
+        self.current['.class'] = self.widget.winfo_class()
+        self.current['.name'] = self.widget._w
+
+    class packoption: # Mix-in class
+        def set(self, e=None):
+            self.current = self.var.get()
+            try:
+                apply(self.dialog.widget.pack, (),
+                      {self.option: self.current})
+            except TclError, msg:
+                print msg
+                self.refresh()
+
+    class booleanoption(packoption, BooleanOption): pass
+    class enumoption(packoption, EnumOption): pass
+    class stringoption(packoption, StringOption): pass
+    class readonlyoption(packoption, ReadonlyOption): pass
+
+    options = {
+            '.class': (None, 'Class'),
+            '.name': (None, 'Name'),
+            'after': (None, 'Widget'),
+            'anchor': ('center', 'Anchor'),
+            'before': (None, 'Widget'),
+            'expand': ('no', 'Boolean'),
+            'fill': ('none', 'Fill'),
+            'in': (None, 'Widget'),
+            'ipadx': (0, 'Pad'),
+            'ipady': (0, 'Pad'),
+            'padx': (0, 'Pad'),
+            'pady': (0, 'Pad'),
+            'side': ('top', 'Side'),
+            }
+
+    classes = {
+            'Anchor': (N, NE, E, SE, S, SW, W, NW, CENTER),
+            'Boolean': 'boolean',
+            'Class': 'readonly',
+            'Expand': 'boolean',
+            'Fill': (NONE, X, Y, BOTH),
+            'Name': 'readonly',
+            'Pad': 'pixel',
+            'Side': (TOP, RIGHT, BOTTOM, LEFT),
+            'Widget': 'readonly',
+            }
 
 class RemotePackDialog(PackDialog):
 
-	def __init__(self, master, app, widget):
-		self.master = master
-		self.app = app
-		self.widget = widget
-		self.refresh()
-		self.top = Toplevel(self.master)
-		self.top.title(self.app + ' PackDialog')
-		self.top.minsize(1, 1)
-		self.addchoices()
-
-	def refresh(self):
-		try:
-			words = self.master.tk.splitlist(
-				self.master.send(self.app,
-						 'pack',
-						 'info',
-						 self.widget))
-		except TclError, msg:
-			print msg
-			return
-		dict = {}
-		for i in range(0, len(words), 2):
-			key = words[i][1:]
-			value = words[i+1]
-			dict[key] = value
-		dict['.class'] = self.master.send(self.app,
-						  'winfo',
-						  'class',
-						  self.widget)
-		dict['.name'] = self.widget
-		self.current = dict
-
-	class remotepackoption: # Mix-in class
-		def set(self, e=None):
-			self.current = self.var.get()
-			try:
-				self.dialog.master.send(
-					self.dialog.app,
-					'pack',
-					'config',
-					self.dialog.widget,
-					'-'+self.option,
-					self.dialog.master.tk.merge(
-						self.current))
-			except TclError, msg:
-				print msg
-				self.refresh()
-
-	class booleanoption(remotepackoption, BooleanOption): pass
-	class enumoption(remotepackoption, EnumOption): pass
-	class stringoption(remotepackoption, StringOption): pass
-	class readonlyoption(remotepackoption, ReadonlyOption): pass
+    def __init__(self, master, app, widget):
+        self.master = master
+        self.app = app
+        self.widget = widget
+        self.refresh()
+        self.top = Toplevel(self.master)
+        self.top.title(self.app + ' PackDialog')
+        self.top.minsize(1, 1)
+        self.addchoices()
+
+    def refresh(self):
+        try:
+            words = self.master.tk.splitlist(
+                    self.master.send(self.app,
+                                     'pack',
+                                     'info',
+                                     self.widget))
+        except TclError, msg:
+            print msg
+            return
+        dict = {}
+        for i in range(0, len(words), 2):
+            key = words[i][1:]
+            value = words[i+1]
+            dict[key] = value
+        dict['.class'] = self.master.send(self.app,
+                                          'winfo',
+                                          'class',
+                                          self.widget)
+        dict['.name'] = self.widget
+        self.current = dict
+
+    class remotepackoption: # Mix-in class
+        def set(self, e=None):
+            self.current = self.var.get()
+            try:
+                self.dialog.master.send(
+                        self.dialog.app,
+                        'pack',
+                        'config',
+                        self.dialog.widget,
+                        '-'+self.option,
+                        self.dialog.master.tk.merge(
+                                self.current))
+            except TclError, msg:
+                print msg
+                self.refresh()
+
+    class booleanoption(remotepackoption, BooleanOption): pass
+    class enumoption(remotepackoption, EnumOption): pass
+    class stringoption(remotepackoption, StringOption): pass
+    class readonlyoption(remotepackoption, ReadonlyOption): pass
 
 class WidgetDialog(Dialog):
 
-	def __init__(self, widget):
-		self.widget = widget
-		self.klass = widget.winfo_class()
-		Dialog.__init__(self, widget)
-
-	def fixclasses(self):
-		if self.addclasses.has_key(self.klass):
-			classes = {}
-			for c in (self.classes,
-				  self.addclasses[self.klass]):
-				for k in c.keys():
-					classes[k] = c[k]
-			self.classes = classes
-
-	def refresh(self):
-		self.configuration = self.widget.config()
-		self.update()
-		self.current['.class'] = self.widget.winfo_class()
-		self.current['.name'] = self.widget._w
-
-	def update(self):
-		self.current = {}
-		self.options = {}
-		for k, v in self.configuration.items():
-			if len(v) > 4:
-				self.current[k] = v[4]
-				self.options[k] = v[3], v[2] # default, klass
-		self.options['.class'] = (None, 'Class')
-		self.options['.name'] = (None, 'Name')
-
-	class widgetoption: # Mix-in class
-		def set(self, e=None):
-			self.current = self.var.get()
-			try:
-				self.dialog.widget[self.option] = self.current
-			except TclError, msg:
-				print msg
-				self.refresh()
-
-	class booleanoption(widgetoption, BooleanOption): pass
-	class enumoption(widgetoption, EnumOption): pass
-	class stringoption(widgetoption, StringOption): pass
-	class readonlyoption(widgetoption, ReadonlyOption): pass
-
-	# Universal classes
-	classes = {
-		'Anchor': (N, NE, E, SE, S, SW, W, NW, CENTER),
-		'Aspect': 'integer',
-		'Background': 'color',
-		'Bitmap': 'bitmap',
-		'BorderWidth': 'pixel',
-		'Class': 'readonly',
-		'CloseEnough': 'double',
-		'Command': 'command',
-		'Confine': 'boolean',
-		'Cursor': 'cursor',
-		'CursorWidth': 'pixel',
-		'DisabledForeground': 'color',
-		'ExportSelection': 'boolean',
-		'Font': 'font',
-		'Foreground': 'color',
-		'From': 'integer',
-		'Geometry': 'geometry',
-		'Height': 'pixel',
-		'InsertWidth': 'time',
-		'Justify': (LEFT, CENTER, RIGHT),
-		'Label': 'string',
-		'Length': 'pixel',
-		'MenuName': 'widget',
-		'Name': 'readonly',
-		'OffTime': 'time',
-		'OnTime': 'time',
-		'Orient': (HORIZONTAL, VERTICAL),
-		'Pad': 'pixel',
-		'Relief': (RAISED, SUNKEN, FLAT, RIDGE, GROOVE),
-		'RepeatDelay': 'time',
-		'RepeatInterval': 'time',
-		'ScrollCommand': 'command',
-		'ScrollIncrement': 'pixel',
-		'ScrollRegion': 'rectangle',
-		'ShowValue': 'boolean',
-		'SetGrid': 'boolean',
-		'Sliderforeground': 'color',
-		'SliderLength': 'pixel',
-		'Text': 'string',
-		'TickInterval': 'integer',
-		'To': 'integer',
-		'Underline': 'index',
-		'Variable': 'variable',
-		'Value': 'string',
-		'Width': 'pixel',
-		'Wrap': (NONE, CHAR, WORD),
-		}
-
-	# Classes that (may) differ per widget type
-	_tristate = {'State': (NORMAL, ACTIVE, DISABLED)}
-	_bistate = {'State': (NORMAL, DISABLED)}
-	addclasses = {
-		'Button': _tristate,
-		'Radiobutton': _tristate,
-		'Checkbutton': _tristate,
-		'Entry': _bistate,
-		'Text': _bistate,
-		'Menubutton': _tristate,
-		'Slider': _bistate,
-		}
+    def __init__(self, widget):
+        self.widget = widget
+        self.klass = widget.winfo_class()
+        Dialog.__init__(self, widget)
+
+    def fixclasses(self):
+        if self.addclasses.has_key(self.klass):
+            classes = {}
+            for c in (self.classes,
+                      self.addclasses[self.klass]):
+                for k in c.keys():
+                    classes[k] = c[k]
+            self.classes = classes
+
+    def refresh(self):
+        self.configuration = self.widget.config()
+        self.update()
+        self.current['.class'] = self.widget.winfo_class()
+        self.current['.name'] = self.widget._w
+
+    def update(self):
+        self.current = {}
+        self.options = {}
+        for k, v in self.configuration.items():
+            if len(v) > 4:
+                self.current[k] = v[4]
+                self.options[k] = v[3], v[2] # default, klass
+        self.options['.class'] = (None, 'Class')
+        self.options['.name'] = (None, 'Name')
+
+    class widgetoption: # Mix-in class
+        def set(self, e=None):
+            self.current = self.var.get()
+            try:
+                self.dialog.widget[self.option] = self.current
+            except TclError, msg:
+                print msg
+                self.refresh()
+
+    class booleanoption(widgetoption, BooleanOption): pass
+    class enumoption(widgetoption, EnumOption): pass
+    class stringoption(widgetoption, StringOption): pass
+    class readonlyoption(widgetoption, ReadonlyOption): pass
+
+    # Universal classes
+    classes = {
+            'Anchor': (N, NE, E, SE, S, SW, W, NW, CENTER),
+            'Aspect': 'integer',
+            'Background': 'color',
+            'Bitmap': 'bitmap',
+            'BorderWidth': 'pixel',
+            'Class': 'readonly',
+            'CloseEnough': 'double',
+            'Command': 'command',
+            'Confine': 'boolean',
+            'Cursor': 'cursor',
+            'CursorWidth': 'pixel',
+            'DisabledForeground': 'color',
+            'ExportSelection': 'boolean',
+            'Font': 'font',
+            'Foreground': 'color',
+            'From': 'integer',
+            'Geometry': 'geometry',
+            'Height': 'pixel',
+            'InsertWidth': 'time',
+            'Justify': (LEFT, CENTER, RIGHT),
+            'Label': 'string',
+            'Length': 'pixel',
+            'MenuName': 'widget',
+            'Name': 'readonly',
+            'OffTime': 'time',
+            'OnTime': 'time',
+            'Orient': (HORIZONTAL, VERTICAL),
+            'Pad': 'pixel',
+            'Relief': (RAISED, SUNKEN, FLAT, RIDGE, GROOVE),
+            'RepeatDelay': 'time',
+            'RepeatInterval': 'time',
+            'ScrollCommand': 'command',
+            'ScrollIncrement': 'pixel',
+            'ScrollRegion': 'rectangle',
+            'ShowValue': 'boolean',
+            'SetGrid': 'boolean',
+            'Sliderforeground': 'color',
+            'SliderLength': 'pixel',
+            'Text': 'string',
+            'TickInterval': 'integer',
+            'To': 'integer',
+            'Underline': 'index',
+            'Variable': 'variable',
+            'Value': 'string',
+            'Width': 'pixel',
+            'Wrap': (NONE, CHAR, WORD),
+            }
+
+    # Classes that (may) differ per widget type
+    _tristate = {'State': (NORMAL, ACTIVE, DISABLED)}
+    _bistate = {'State': (NORMAL, DISABLED)}
+    addclasses = {
+            'Button': _tristate,
+            'Radiobutton': _tristate,
+            'Checkbutton': _tristate,
+            'Entry': _bistate,
+            'Text': _bistate,
+            'Menubutton': _tristate,
+            'Slider': _bistate,
+            }
 
 class RemoteWidgetDialog(WidgetDialog):
 
-	def __init__(self, master, app, widget):
-		self.app = app
-		self.widget = widget
-		self.klass = master.send(self.app,
-					 'winfo',
-					 'class',
-					 self.widget)
-		Dialog.__init__(self, master)
-
-	def refresh(self):
-		try:
-			items = self.master.tk.splitlist(
-				self.master.send(self.app,
-						 self.widget,
-						 'config'))
-		except TclError, msg:
-			print msg
-			return
-		dict = {}
-		for item in items:
-			words = self.master.tk.splitlist(item)
-			key = words[0][1:]
-			value = (key,) + words[1:]
-			dict[key] = value
-		self.configuration = dict
-		self.update()
-		self.current['.class'] = self.klass
-		self.current['.name'] = self.widget
-
-	class remotewidgetoption: # Mix-in class
-		def set(self, e=None):
-			self.current = self.var.get()
-			try:
-				self.dialog.master.send(
-					self.dialog.app,
-					self.dialog.widget,
-					'config',
-					'-'+self.option,
-					self.current)
-			except TclError, msg:
-				print msg
-				self.refresh()
-
-	class booleanoption(remotewidgetoption, BooleanOption): pass
-	class enumoption(remotewidgetoption, EnumOption): pass
-	class stringoption(remotewidgetoption, StringOption): pass
-	class readonlyoption(remotewidgetoption, ReadonlyOption): pass
+    def __init__(self, master, app, widget):
+        self.app = app
+        self.widget = widget
+        self.klass = master.send(self.app,
+                                 'winfo',
+                                 'class',
+                                 self.widget)
+        Dialog.__init__(self, master)
+
+    def refresh(self):
+        try:
+            items = self.master.tk.splitlist(
+                    self.master.send(self.app,
+                                     self.widget,
+                                     'config'))
+        except TclError, msg:
+            print msg
+            return
+        dict = {}
+        for item in items:
+            words = self.master.tk.splitlist(item)
+            key = words[0][1:]
+            value = (key,) + words[1:]
+            dict[key] = value
+        self.configuration = dict
+        self.update()
+        self.current['.class'] = self.klass
+        self.current['.name'] = self.widget
+
+    class remotewidgetoption: # Mix-in class
+        def set(self, e=None):
+            self.current = self.var.get()
+            try:
+                self.dialog.master.send(
+                        self.dialog.app,
+                        self.dialog.widget,
+                        'config',
+                        '-'+self.option,
+                        self.current)
+            except TclError, msg:
+                print msg
+                self.refresh()
+
+    class booleanoption(remotewidgetoption, BooleanOption): pass
+    class enumoption(remotewidgetoption, EnumOption): pass
+    class stringoption(remotewidgetoption, StringOption): pass
+    class readonlyoption(remotewidgetoption, ReadonlyOption): pass
 
 def test():
-	import sys
-	root = Tk()
-	root.minsize(1, 1)
-	if sys.argv[1:]:
-		remotetest(root, sys.argv[1])
-	else:
-		frame = Frame(root, name='frame')
-		frame.pack(expand=1, fill=BOTH)
-		button = Button(frame, name='button', text='button')
-		button.pack(expand=1)
-		canvas = Canvas(frame, name='canvas')
-		canvas.pack()
-		fpd = PackDialog(frame)
-		fwd = WidgetDialog(frame)
-		bpd = PackDialog(button)
-		bwd = WidgetDialog(button)
-		cpd = PackDialog(canvas)
-		cwd = WidgetDialog(canvas)
-	root.mainloop()
+    import sys
+    root = Tk()
+    root.minsize(1, 1)
+    if sys.argv[1:]:
+        remotetest(root, sys.argv[1])
+    else:
+        frame = Frame(root, name='frame')
+        frame.pack(expand=1, fill=BOTH)
+        button = Button(frame, name='button', text='button')
+        button.pack(expand=1)
+        canvas = Canvas(frame, name='canvas')
+        canvas.pack()
+        fpd = PackDialog(frame)
+        fwd = WidgetDialog(frame)
+        bpd = PackDialog(button)
+        bwd = WidgetDialog(button)
+        cpd = PackDialog(canvas)
+        cwd = WidgetDialog(canvas)
+    root.mainloop()
 
 def remotetest(root, app):
-	from listtree import listtree
-	list = listtree(root, app)
-	list.bind('<Any-Double-1>', opendialogs)
-	list.app = app			# Pass it on to handler
+    from listtree import listtree
+    list = listtree(root, app)
+    list.bind('<Any-Double-1>', opendialogs)
+    list.app = app                  # Pass it on to handler
 
 def opendialogs(e):
-	import string
-	list = e.widget
-	sel = list.curselection()
-	for i in sel:
-		item = list.get(i)
-		widget = string.split(item)[0]
-		RemoteWidgetDialog(list, list.app, widget)
-		if widget == '.': continue
-		try:
-			RemotePackDialog(list, list.app, widget)
-		except TclError, msg:
-			print msg
+    import string
+    list = e.widget
+    sel = list.curselection()
+    for i in sel:
+        item = list.get(i)
+        widget = string.split(item)[0]
+        RemoteWidgetDialog(list, list.app, widget)
+        if widget == '.': continue
+        try:
+            RemotePackDialog(list, list.app, widget)
+        except TclError, msg:
+            print msg
 
 test()
diff --git a/Demo/tkinter/guido/ManPage.py b/Demo/tkinter/guido/ManPage.py
index ccd21b4..7d6fe00 100755
--- a/Demo/tkinter/guido/ManPage.py
+++ b/Demo/tkinter/guido/ManPage.py
@@ -12,173 +12,173 @@ ITALICFONT = '*-Courier-Medium-O-Normal-*-120-*'
 # XXX Recognizing footers is system dependent
 # (This one works for IRIX 5.2 and Solaris 2.2)
 footerprog = regex.compile(
-	'^     Page [1-9][0-9]*[ \t]+\|^.*Last change:.*[1-9][0-9]*\n')
+        '^     Page [1-9][0-9]*[ \t]+\|^.*Last change:.*[1-9][0-9]*\n')
 emptyprog = regex.compile('^[ \t]*\n')
 ulprog = regex.compile('^[ \t]*[Xv!_][Xv!_ \t]*\n')
 
 # Basic Man Page class -- does not disable editing
 class EditableManPage(ScrolledText):
 
-	# Initialize instance
-	def __init__(self, master=None, **cnf):
-		# Initialize base class
-		apply(ScrolledText.__init__, (self, master), cnf)
-
-		# Define tags for formatting styles
-		self.tag_config('X', underline=1)
-		self.tag_config('!', font=BOLDFONT)
-		self.tag_config('_', font=ITALICFONT)
-
-		# Set state to idle
-		self.fp = None
-		self.lineno = 0
-
-	# Test whether we are busy parsing a file
-	def busy(self):
-		return self.fp != None
-
-	# Ensure we're not busy
-	def kill(self):
-		if self.busy():
-			self._endparser()
-
-	# Parse a file, in the background
-	def asyncparsefile(self, fp):
-		self._startparser(fp)
-		self.tk.createfilehandler(fp, _tkinter.READABLE,
-					  self._filehandler)
-
-	parsefile = asyncparsefile	# Alias
-
-	# I/O handler used by background parsing
-	def _filehandler(self, fp, mask):
-		nextline = self.fp.readline()
-		if not nextline:
-			self._endparser()
-			return
-		self._parseline(nextline)
-
-	# Parse a file, now (cannot be aborted)
-	def syncparsefile(self, fp):
-		from select import select
-		def avail(fp=fp, tout=0.0, select=select):
-			return select([fp], [], [], tout)[0]
-		height = self.getint(self['height'])
-		self._startparser(fp)
-		while 1:
-			nextline = fp.readline()
-			if not nextline:
-				break
-			self._parseline(nextline)
-		self._endparser()
-
-	# Initialize parsing from a particular file -- must not be busy
-	def _startparser(self, fp):
-		if self.busy():
-			raise RuntimeError, 'startparser: still busy'
-		fp.fileno()		# Test for file-ness
-		self.fp = fp
-		self.lineno = 0
-		self.ok = 0
-		self.empty = 0
-		self.buffer = None
-		savestate = self['state']
-		self['state'] = NORMAL
-		self.delete('1.0', END)
-		self['state'] = savestate
-
-	# End parsing -- must be busy, need not be at EOF
-	def _endparser(self):
-		if not self.busy():
-			raise RuntimeError, 'endparser: not busy'
-		if self.buffer:
-			self._parseline('')
-		try:
-			self.tk.deletefilehandler(self.fp)
-		except TclError, msg:
-			pass
-		self.fp.close()
-		self.fp = None
-		del self.ok, self.empty, self.buffer
-
-	# Parse a single line
-	def _parseline(self, nextline):
-		if not self.buffer:
-			# Save this line -- we need one line read-ahead
-			self.buffer = nextline
-			return
-		if emptyprog.match(self.buffer) >= 0:
-			# Buffered line was empty -- set a flag
-			self.empty = 1
-			self.buffer = nextline
-			return
-		textline = self.buffer
-		if ulprog.match(nextline) >= 0:
-			# Next line is properties for buffered line
-			propline = nextline
-			self.buffer = None
-		else:
-			# Next line is read-ahead
-			propline = None
-			self.buffer = nextline
-		if not self.ok:
-			# First non blank line after footer must be header
-			# -- skip that too
-			self.ok = 1
-			self.empty = 0
-			return
-		if footerprog.match(textline) >= 0:
-			# Footer -- start skipping until next non-blank line
-			self.ok = 0
-			self.empty = 0
-			return
-		savestate = self['state']
-		self['state'] = NORMAL
-		if TkVersion >= 4.0:
-			self.mark_set('insert', 'end-1c')
-		else:
-			self.mark_set('insert', END)
-		if self.empty:
-			# One or more previous lines were empty
-			# -- insert one blank line in the text
-			self._insert_prop('\n')
-			self.lineno = self.lineno + 1
-			self.empty = 0
-		if not propline:
-			# No properties
-			self._insert_prop(textline)
-		else:
-			# Search for properties
-			p = ''
-			j = 0
-			for i in range(min(len(propline), len(textline))):
-				if propline[i] != p:
-					if j < i:
-					    self._insert_prop(textline[j:i], p)
-					    j = i
-					p = propline[i]
-			self._insert_prop(textline[j:])
-		self.lineno = self.lineno + 1
-		self['state'] = savestate
-
-	# Insert a string at the end, with at most one property (tag)
-	def _insert_prop(self, str, prop = ' '):
-		here = self.index(AtInsert())
-		self.insert(AtInsert(), str)
-		if TkVersion <= 4.0:
-			tags = self.tag_names(here)
-			for tag in tags:
-				self.tag_remove(tag, here, AtInsert())
-		if prop != ' ':
-			self.tag_add(prop, here, AtInsert())
+    # Initialize instance
+    def __init__(self, master=None, **cnf):
+        # Initialize base class
+        apply(ScrolledText.__init__, (self, master), cnf)
+
+        # Define tags for formatting styles
+        self.tag_config('X', underline=1)
+        self.tag_config('!', font=BOLDFONT)
+        self.tag_config('_', font=ITALICFONT)
+
+        # Set state to idle
+        self.fp = None
+        self.lineno = 0
+
+    # Test whether we are busy parsing a file
+    def busy(self):
+        return self.fp != None
+
+    # Ensure we're not busy
+    def kill(self):
+        if self.busy():
+            self._endparser()
+
+    # Parse a file, in the background
+    def asyncparsefile(self, fp):
+        self._startparser(fp)
+        self.tk.createfilehandler(fp, _tkinter.READABLE,
+                                  self._filehandler)
+
+    parsefile = asyncparsefile      # Alias
+
+    # I/O handler used by background parsing
+    def _filehandler(self, fp, mask):
+        nextline = self.fp.readline()
+        if not nextline:
+            self._endparser()
+            return
+        self._parseline(nextline)
+
+    # Parse a file, now (cannot be aborted)
+    def syncparsefile(self, fp):
+        from select import select
+        def avail(fp=fp, tout=0.0, select=select):
+            return select([fp], [], [], tout)[0]
+        height = self.getint(self['height'])
+        self._startparser(fp)
+        while 1:
+            nextline = fp.readline()
+            if not nextline:
+                break
+            self._parseline(nextline)
+        self._endparser()
+
+    # Initialize parsing from a particular file -- must not be busy
+    def _startparser(self, fp):
+        if self.busy():
+            raise RuntimeError, 'startparser: still busy'
+        fp.fileno()             # Test for file-ness
+        self.fp = fp
+        self.lineno = 0
+        self.ok = 0
+        self.empty = 0
+        self.buffer = None
+        savestate = self['state']
+        self['state'] = NORMAL
+        self.delete('1.0', END)
+        self['state'] = savestate
+
+    # End parsing -- must be busy, need not be at EOF
+    def _endparser(self):
+        if not self.busy():
+            raise RuntimeError, 'endparser: not busy'
+        if self.buffer:
+            self._parseline('')
+        try:
+            self.tk.deletefilehandler(self.fp)
+        except TclError, msg:
+            pass
+        self.fp.close()
+        self.fp = None
+        del self.ok, self.empty, self.buffer
+
+    # Parse a single line
+    def _parseline(self, nextline):
+        if not self.buffer:
+            # Save this line -- we need one line read-ahead
+            self.buffer = nextline
+            return
+        if emptyprog.match(self.buffer) >= 0:
+            # Buffered line was empty -- set a flag
+            self.empty = 1
+            self.buffer = nextline
+            return
+        textline = self.buffer
+        if ulprog.match(nextline) >= 0:
+            # Next line is properties for buffered line
+            propline = nextline
+            self.buffer = None
+        else:
+            # Next line is read-ahead
+            propline = None
+            self.buffer = nextline
+        if not self.ok:
+            # First non blank line after footer must be header
+            # -- skip that too
+            self.ok = 1
+            self.empty = 0
+            return
+        if footerprog.match(textline) >= 0:
+            # Footer -- start skipping until next non-blank line
+            self.ok = 0
+            self.empty = 0
+            return
+        savestate = self['state']
+        self['state'] = NORMAL
+        if TkVersion >= 4.0:
+            self.mark_set('insert', 'end-1c')
+        else:
+            self.mark_set('insert', END)
+        if self.empty:
+            # One or more previous lines were empty
+            # -- insert one blank line in the text
+            self._insert_prop('\n')
+            self.lineno = self.lineno + 1
+            self.empty = 0
+        if not propline:
+            # No properties
+            self._insert_prop(textline)
+        else:
+            # Search for properties
+            p = ''
+            j = 0
+            for i in range(min(len(propline), len(textline))):
+                if propline[i] != p:
+                    if j < i:
+                        self._insert_prop(textline[j:i], p)
+                        j = i
+                    p = propline[i]
+            self._insert_prop(textline[j:])
+        self.lineno = self.lineno + 1
+        self['state'] = savestate
+
+    # Insert a string at the end, with at most one property (tag)
+    def _insert_prop(self, str, prop = ' '):
+        here = self.index(AtInsert())
+        self.insert(AtInsert(), str)
+        if TkVersion <= 4.0:
+            tags = self.tag_names(here)
+            for tag in tags:
+                self.tag_remove(tag, here, AtInsert())
+        if prop != ' ':
+            self.tag_add(prop, here, AtInsert())
 
 # Readonly Man Page class -- disables editing, otherwise the same
 class ReadonlyManPage(EditableManPage):
 
-	# Initialize instance
-	def __init__(self, master=None, **cnf):
-		cnf['state'] = DISABLED
-		apply(EditableManPage.__init__, (self, master), cnf)
+    # Initialize instance
+    def __init__(self, master=None, **cnf):
+        cnf['state'] = DISABLED
+        apply(EditableManPage.__init__, (self, master), cnf)
 
 # Alias
 ManPage = ReadonlyManPage
@@ -187,34 +187,34 @@ ManPage = ReadonlyManPage
 # usage: ManPage [manpage]; or ManPage [-f] file
 # -f means that the file is nroff -man output run through ul -i
 def test():
-	import os
-	import sys
-	# XXX This directory may be different on your system
-	MANDIR = '/usr/local/man/mann'
-	DEFAULTPAGE = 'Tcl'
-	formatted = 0
-	if sys.argv[1:] and sys.argv[1] == '-f':
-		formatted = 1
-		del sys.argv[1]
-	if sys.argv[1:]:
-		name = sys.argv[1]
-	else:
-		name = DEFAULTPAGE
-	if not formatted:
-		if name[-2:-1] != '.':
-			name = name + '.n'
-		name = os.path.join(MANDIR, name)
-	root = Tk()
-	root.minsize(1, 1)
-	manpage = ManPage(root, relief=SUNKEN, borderwidth=2)
-	manpage.pack(expand=1, fill=BOTH)
-	if formatted:
-		fp = open(name, 'r')
-	else:
-		fp = os.popen('nroff -man %s | ul -i' % name, 'r')
-	manpage.parsefile(fp)
-	root.mainloop()
+    import os
+    import sys
+    # XXX This directory may be different on your system
+    MANDIR = '/usr/local/man/mann'
+    DEFAULTPAGE = 'Tcl'
+    formatted = 0
+    if sys.argv[1:] and sys.argv[1] == '-f':
+        formatted = 1
+        del sys.argv[1]
+    if sys.argv[1:]:
+        name = sys.argv[1]
+    else:
+        name = DEFAULTPAGE
+    if not formatted:
+        if name[-2:-1] != '.':
+            name = name + '.n'
+        name = os.path.join(MANDIR, name)
+    root = Tk()
+    root.minsize(1, 1)
+    manpage = ManPage(root, relief=SUNKEN, borderwidth=2)
+    manpage.pack(expand=1, fill=BOTH)
+    if formatted:
+        fp = open(name, 'r')
+    else:
+        fp = os.popen('nroff -man %s | ul -i' % name, 'r')
+    manpage.parsefile(fp)
+    root.mainloop()
 
 # Run the test program when called as a script
 if __name__ == '__main__':
-	test()
+    test()
diff --git a/Demo/tkinter/guido/MimeViewer.py b/Demo/tkinter/guido/MimeViewer.py
index 2b98579..7494425 100755
--- a/Demo/tkinter/guido/MimeViewer.py
+++ b/Demo/tkinter/guido/MimeViewer.py
@@ -9,135 +9,135 @@ from Tkinter import *
 from ScrolledText import ScrolledText
 
 class MimeViewer:
-	def __init__(self, parent, title, msg):
-		self.title = title
-		self.msg = msg
-		self.frame = Frame(parent, {'relief': 'raised', 'bd': 2})
-		self.frame.packing = {'expand': 0, 'fill': 'both'}
-		self.button = Checkbutton(self.frame,
-				     {'text': title,
-				      'command': self.toggle})
-		self.button.pack({'anchor': 'w'})
-		headertext = msg.getheadertext(
-			lambda x: x != 'received' and x[:5] != 'x400-')
-		height = countlines(headertext, 4)
-		if height:
-			self.htext = ScrolledText(self.frame,
-					  {'height': height,
-					   'width': 80,
-					   'wrap': 'none',
-					   'relief': 'raised',
-					   'bd': 2})
-			self.htext.packing = {'expand': 1, 'fill': 'both',
-					      'after': self.button}
-			self.htext.insert('end', headertext)
-		else:
-			self.htext = Frame(self.frame,
-					   {'relief': 'raised', 'bd': 2})
-			self.htext.packing = {'side': 'top',
-					      'ipady': 2,
-					      'fill': 'x',
-					      'after': self.button}
-		body = msg.getbody()
-		if type(body) == StringType:
-			self.pad = None
-			height = countlines(body, 10)
-			if height:
-				self.btext = ScrolledText(self.frame,
-						  {'height': height,
-						   'width': 80,
-						   'wrap': 'none',
-						   'relief': 'raised',
-						   'bd': 2})
-				self.btext.packing = {'expand': 1,
-						      'fill': 'both'}
-				self.btext.insert('end', body)
-			else:
-				self.btext = None
-			self.parts = None
-		else:
-			self.pad = Frame(self.frame,
-					 {'relief': 'flat', 'bd': 2})
-			self.pad.packing = {'side': 'left', 'ipadx': 10,
-					    'fill': 'y', 'after': self.htext}
-			self.parts = []
-			for i in range(len(body)):
-				p = MimeViewer(self.frame,
-					       '%s.%d' % (title, i+1),
-					       body[i])
-				self.parts.append(p)
-			self.btext = None
-		self.collapsed = 1
-	def pack(self):
-		self.frame.pack(self.frame.packing)
-	def destroy(self):
-		self.frame.destroy()
-	def show(self):
-		if self.collapsed:
-			self.button.invoke()
-	def toggle(self):
-		if self.collapsed:
-			self.explode()
-		else:
-			self.collapse()
-	def collapse(self):
-		self.collapsed = 1
-		for comp in self.htext, self.btext, self.pad:
-			if comp:
-				comp.forget()
-		if self.parts:
-			for part in self.parts:
-				part.frame.forget()
-		self.frame.pack({'expand': 0})
-	def explode(self):
-		self.collapsed = 0
-		for comp in self.htext, self.btext, self.pad:
-			if comp: comp.pack(comp.packing)
-		if self.parts:
-			for part in self.parts:
-				part.pack()
-		self.frame.pack({'expand': 1})
+    def __init__(self, parent, title, msg):
+        self.title = title
+        self.msg = msg
+        self.frame = Frame(parent, {'relief': 'raised', 'bd': 2})
+        self.frame.packing = {'expand': 0, 'fill': 'both'}
+        self.button = Checkbutton(self.frame,
+                             {'text': title,
+                              'command': self.toggle})
+        self.button.pack({'anchor': 'w'})
+        headertext = msg.getheadertext(
+                lambda x: x != 'received' and x[:5] != 'x400-')
+        height = countlines(headertext, 4)
+        if height:
+            self.htext = ScrolledText(self.frame,
+                              {'height': height,
+                               'width': 80,
+                               'wrap': 'none',
+                               'relief': 'raised',
+                               'bd': 2})
+            self.htext.packing = {'expand': 1, 'fill': 'both',
+                                  'after': self.button}
+            self.htext.insert('end', headertext)
+        else:
+            self.htext = Frame(self.frame,
+                               {'relief': 'raised', 'bd': 2})
+            self.htext.packing = {'side': 'top',
+                                  'ipady': 2,
+                                  'fill': 'x',
+                                  'after': self.button}
+        body = msg.getbody()
+        if type(body) == StringType:
+            self.pad = None
+            height = countlines(body, 10)
+            if height:
+                self.btext = ScrolledText(self.frame,
+                                  {'height': height,
+                                   'width': 80,
+                                   'wrap': 'none',
+                                   'relief': 'raised',
+                                   'bd': 2})
+                self.btext.packing = {'expand': 1,
+                                      'fill': 'both'}
+                self.btext.insert('end', body)
+            else:
+                self.btext = None
+            self.parts = None
+        else:
+            self.pad = Frame(self.frame,
+                             {'relief': 'flat', 'bd': 2})
+            self.pad.packing = {'side': 'left', 'ipadx': 10,
+                                'fill': 'y', 'after': self.htext}
+            self.parts = []
+            for i in range(len(body)):
+                p = MimeViewer(self.frame,
+                               '%s.%d' % (title, i+1),
+                               body[i])
+                self.parts.append(p)
+            self.btext = None
+        self.collapsed = 1
+    def pack(self):
+        self.frame.pack(self.frame.packing)
+    def destroy(self):
+        self.frame.destroy()
+    def show(self):
+        if self.collapsed:
+            self.button.invoke()
+    def toggle(self):
+        if self.collapsed:
+            self.explode()
+        else:
+            self.collapse()
+    def collapse(self):
+        self.collapsed = 1
+        for comp in self.htext, self.btext, self.pad:
+            if comp:
+                comp.forget()
+        if self.parts:
+            for part in self.parts:
+                part.frame.forget()
+        self.frame.pack({'expand': 0})
+    def explode(self):
+        self.collapsed = 0
+        for comp in self.htext, self.btext, self.pad:
+            if comp: comp.pack(comp.packing)
+        if self.parts:
+            for part in self.parts:
+                part.pack()
+        self.frame.pack({'expand': 1})
 
 def countlines(str, limit):
-	i = 0
-	n = 0
-	while  n < limit:
-		i = string.find(str, '\n', i)
-		if i < 0: break
-		n = n+1
-		i = i+1
-	return n
+    i = 0
+    n = 0
+    while  n < limit:
+        i = string.find(str, '\n', i)
+        if i < 0: break
+        n = n+1
+        i = i+1
+    return n
 
 def main():
-	import sys
-	import getopt
-	import mhlib
-	opts, args = getopt.getopt(sys.argv[1:], '')
-	for o, a in opts:
-		pass
-	message = None
-	folder = 'inbox'
-	for arg in args:
-		if arg[:1] == '+':
-			folder = arg[1:]
-		else:
-			message = string.atoi(arg)
+    import sys
+    import getopt
+    import mhlib
+    opts, args = getopt.getopt(sys.argv[1:], '')
+    for o, a in opts:
+        pass
+    message = None
+    folder = 'inbox'
+    for arg in args:
+        if arg[:1] == '+':
+            folder = arg[1:]
+        else:
+            message = string.atoi(arg)
 
-	mh = mhlib.MH()
-	f = mh.openfolder(folder)
-	if not message:
-		message = f.getcurrent()
-	m = f.openmessage(message)
+    mh = mhlib.MH()
+    f = mh.openfolder(folder)
+    if not message:
+        message = f.getcurrent()
+    m = f.openmessage(message)
 
-	root = Tk()
-	tk = root.tk
+    root = Tk()
+    tk = root.tk
 
-	top = MimeViewer(root, '+%s/%d' % (folder, message), m)
-	top.pack()
-	top.show()
+    top = MimeViewer(root, '+%s/%d' % (folder, message), m)
+    top.pack()
+    top.show()
 
-	root.minsize(1, 1)
+    root.minsize(1, 1)
 
-	tk.mainloop()
+    tk.mainloop()
 
 if __name__ == '__main__': main()
diff --git a/Demo/tkinter/guido/ShellWindow.py b/Demo/tkinter/guido/ShellWindow.py
index 98fe30f..609101b 100755
--- a/Demo/tkinter/guido/ShellWindow.py
+++ b/Demo/tkinter/guido/ShellWindow.py
@@ -10,142 +10,142 @@ BUFSIZE = 512
 
 class ShellWindow(ScrolledText):
 
-	def __init__(self, master=None, shell=None, **cnf):
-		if not shell:
-			try:
-				shell = os.environ['SHELL']
-			except KeyError:
-				shell = '/bin/sh'
-			shell = shell + ' -i'
-		args = string.split(shell)
-		shell = args[0]
-
-		apply(ScrolledText.__init__, (self, master), cnf)
-		self.pos = '1.0'
-		self.bind('<Return>', self.inputhandler)
-		self.bind('<Control-c>', self.sigint)
-		self.bind('<Control-t>', self.sigterm)
-		self.bind('<Control-k>', self.sigkill)
-		self.bind('<Control-d>', self.sendeof)
-
-		self.pid, self.fromchild, self.tochild = spawn(shell, args)
-		self.tk.createfilehandler(self.fromchild, READABLE,
-					  self.outputhandler)
-
-	def outputhandler(self, file, mask):
-		data = os.read(file, BUFSIZE)
-		if not data:
-			self.tk.deletefilehandler(file)
-			pid, sts = os.waitpid(self.pid, 0)
-			print 'pid', pid, 'status', sts
-			self.pid = None
-			detail = sts>>8
-			cause = sts & 0xff
-			if cause == 0:
-				msg = "exit status %d" % detail
-			else:
-				msg = "killed by signal %d" % (cause & 0x7f)
-				if cause & 0x80:
-					msg = msg + " -- core dumped"
-			Dialog(self.master,
-			       text=msg,
-			       title="Exit status",
-			       bitmap='warning',
-			       default=0,
-			       strings=('OK',))
-			return
-		self.insert(END, data)
-		self.pos = self.index("end - 1 char")
-		self.yview_pickplace(END)
-
-	def inputhandler(self, *args):
-		if not self.pid:
-			self.no_process()
-			return "break"
-		self.insert(END, "\n")
-		line = self.get(self.pos, "end - 1 char")
-		self.pos = self.index(END)
-		os.write(self.tochild, line)
-		return "break"
-
-	def sendeof(self, *args):
-		if not self.pid:
-			self.no_process()
-			return "break"
-		os.close(self.tochild)
-		return "break"
-
-	def sendsig(self, sig):
-		if not self.pid:
-			self.no_process()
-			return "break"
-		os.kill(self.pid, sig)
-		return "break"
-
-	def sigint(self, *args):
-		return self.sendsig(signal.SIGINT)
-
-	def sigquit(self, *args):
-		return self.sendsig(signal.SIGQUIT)
-
-	def sigterm(self, *args):
-		return self.sendsig(signal.SIGTERM)
-
-	def sigkill(self, *args):
-		return self.sendsig(signal.SIGKILL)
-
-	def no_process(self):
-		Dialog(self.master,
-		       text="No active process",
-		       title="No process",
-		       bitmap='error',
-		       default=0,
-		       strings=('OK',))
-
-MAXFD = 100	# Max number of file descriptors (os.getdtablesize()???)
+    def __init__(self, master=None, shell=None, **cnf):
+        if not shell:
+            try:
+                shell = os.environ['SHELL']
+            except KeyError:
+                shell = '/bin/sh'
+            shell = shell + ' -i'
+        args = string.split(shell)
+        shell = args[0]
+
+        apply(ScrolledText.__init__, (self, master), cnf)
+        self.pos = '1.0'
+        self.bind('<Return>', self.inputhandler)
+        self.bind('<Control-c>', self.sigint)
+        self.bind('<Control-t>', self.sigterm)
+        self.bind('<Control-k>', self.sigkill)
+        self.bind('<Control-d>', self.sendeof)
+
+        self.pid, self.fromchild, self.tochild = spawn(shell, args)
+        self.tk.createfilehandler(self.fromchild, READABLE,
+                                  self.outputhandler)
+
+    def outputhandler(self, file, mask):
+        data = os.read(file, BUFSIZE)
+        if not data:
+            self.tk.deletefilehandler(file)
+            pid, sts = os.waitpid(self.pid, 0)
+            print 'pid', pid, 'status', sts
+            self.pid = None
+            detail = sts>>8
+            cause = sts & 0xff
+            if cause == 0:
+                msg = "exit status %d" % detail
+            else:
+                msg = "killed by signal %d" % (cause & 0x7f)
+                if cause & 0x80:
+                    msg = msg + " -- core dumped"
+            Dialog(self.master,
+                   text=msg,
+                   title="Exit status",
+                   bitmap='warning',
+                   default=0,
+                   strings=('OK',))
+            return
+        self.insert(END, data)
+        self.pos = self.index("end - 1 char")
+        self.yview_pickplace(END)
+
+    def inputhandler(self, *args):
+        if not self.pid:
+            self.no_process()
+            return "break"
+        self.insert(END, "\n")
+        line = self.get(self.pos, "end - 1 char")
+        self.pos = self.index(END)
+        os.write(self.tochild, line)
+        return "break"
+
+    def sendeof(self, *args):
+        if not self.pid:
+            self.no_process()
+            return "break"
+        os.close(self.tochild)
+        return "break"
+
+    def sendsig(self, sig):
+        if not self.pid:
+            self.no_process()
+            return "break"
+        os.kill(self.pid, sig)
+        return "break"
+
+    def sigint(self, *args):
+        return self.sendsig(signal.SIGINT)
+
+    def sigquit(self, *args):
+        return self.sendsig(signal.SIGQUIT)
+
+    def sigterm(self, *args):
+        return self.sendsig(signal.SIGTERM)
+
+    def sigkill(self, *args):
+        return self.sendsig(signal.SIGKILL)
+
+    def no_process(self):
+        Dialog(self.master,
+               text="No active process",
+               title="No process",
+               bitmap='error',
+               default=0,
+               strings=('OK',))
+
+MAXFD = 100     # Max number of file descriptors (os.getdtablesize()???)
 
 def spawn(prog, args):
-	p2cread, p2cwrite = os.pipe()
-	c2pread, c2pwrite = os.pipe()
-	pid = os.fork()
-	if pid == 0:
-		# Child
-		for i in 0, 1, 2:
-		    try:
-			os.close(i)
-		    except os.error:
-			pass
-		if os.dup(p2cread) <> 0:
-			sys.stderr.write('popen2: bad read dup\n')
-		if os.dup(c2pwrite) <> 1:
-			sys.stderr.write('popen2: bad write dup\n')
-		if os.dup(c2pwrite) <> 2:
-			sys.stderr.write('popen2: bad write dup\n')
-		for i in range(3, MAXFD):
-			try:
-				os.close(i)
-			except:
-				pass
-		try:
-			os.execvp(prog, args)
-		finally:
-			sys.stderr.write('execvp failed\n')
-			os._exit(1)
-	os.close(p2cread)
-	os.close(c2pwrite)
-	return pid, c2pread, p2cwrite
+    p2cread, p2cwrite = os.pipe()
+    c2pread, c2pwrite = os.pipe()
+    pid = os.fork()
+    if pid == 0:
+        # Child
+        for i in 0, 1, 2:
+            try:
+                os.close(i)
+            except os.error:
+                pass
+        if os.dup(p2cread) <> 0:
+            sys.stderr.write('popen2: bad read dup\n')
+        if os.dup(c2pwrite) <> 1:
+            sys.stderr.write('popen2: bad write dup\n')
+        if os.dup(c2pwrite) <> 2:
+            sys.stderr.write('popen2: bad write dup\n')
+        for i in range(3, MAXFD):
+            try:
+                os.close(i)
+            except:
+                pass
+        try:
+            os.execvp(prog, args)
+        finally:
+            sys.stderr.write('execvp failed\n')
+            os._exit(1)
+    os.close(p2cread)
+    os.close(c2pwrite)
+    return pid, c2pread, p2cwrite
 
 def test():
-	shell = string.join(sys.argv[1:])
-	root = Tk()
-	root.minsize(1, 1)
-	if shell:
-	    w = ShellWindow(root, shell=shell)
-	else:
-	    w = ShellWindow(root)
-	w.pack(expand=1, fill=BOTH)
-	w.focus_set()
-	w.tk.mainloop()
+    shell = string.join(sys.argv[1:])
+    root = Tk()
+    root.minsize(1, 1)
+    if shell:
+        w = ShellWindow(root, shell=shell)
+    else:
+        w = ShellWindow(root)
+    w.pack(expand=1, fill=BOTH)
+    w.focus_set()
+    w.tk.mainloop()
 
 if __name__ == '__main__':
-	test()
+    test()
diff --git a/Demo/tkinter/guido/canvasevents.py b/Demo/tkinter/guido/canvasevents.py
index 60f4096..74ed76f 100644
--- a/Demo/tkinter/guido/canvasevents.py
+++ b/Demo/tkinter/guido/canvasevents.py
@@ -9,7 +9,7 @@ from Canvas import Oval, Group, CanvasText
 
 class Group(Group):
     def bind(self, sequence=None, command=None):
-	return self.canvas.tag_bind(self.id, sequence, command)
+        return self.canvas.tag_bind(self.id, sequence, command)
 
 class Object:
 
@@ -33,45 +33,45 @@ class Object:
     """
 
     def __init__(self, canvas, x=0, y=0, fill='red', text='object'):
-	self.canvas = canvas
-	self.x = x
-	self.y = y
-	self.pile = None
-	self.group = Group(self.canvas)
-	self.createitems(fill, text)
+        self.canvas = canvas
+        self.x = x
+        self.y = y
+        self.pile = None
+        self.group = Group(self.canvas)
+        self.createitems(fill, text)
 
     def __str__(self):
-	return str(self.group)
+        return str(self.group)
 
     def createitems(self, fill, text):
-	self.__oval = Oval(self.canvas,
-			   self.x-20, self.y-10, self.x+20, self.y+10,
-			   fill=fill, width=3)
-	self.group.addtag_withtag(self.__oval)
-	self.__text = CanvasText(self.canvas,
-			   self.x, self.y, text=text)
-	self.group.addtag_withtag(self.__text)
+        self.__oval = Oval(self.canvas,
+                           self.x-20, self.y-10, self.x+20, self.y+10,
+                           fill=fill, width=3)
+        self.group.addtag_withtag(self.__oval)
+        self.__text = CanvasText(self.canvas,
+                           self.x, self.y, text=text)
+        self.group.addtag_withtag(self.__text)
 
     def moveby(self, dx, dy):
-	if dx == dy == 0:
-	    return
-	self.group.move(dx, dy)
-	self.x = self.x + dx
-	self.y = self.y + dy
+        if dx == dy == 0:
+            return
+        self.group.move(dx, dy)
+        self.x = self.x + dx
+        self.y = self.y + dy
 
     def moveto(self, x, y):
-	self.moveby(x - self.x, y - self.y)
+        self.moveby(x - self.x, y - self.y)
 
     def transfer(self, pile):
-	if self.pile:
-	    self.pile.delete(self)
-	    self.pile = None
-	self.pile = pile
-	if self.pile:
-	    self.pile.add(self)
+        if self.pile:
+            self.pile.delete(self)
+            self.pile = None
+        self.pile = pile
+        if self.pile:
+            self.pile.add(self)
 
     def tkraise(self):
-	self.group.tkraise()
+        self.group.tkraise()
 
 
 class Bottom(Object):
@@ -79,10 +79,10 @@ class Bottom(Object):
     """An object to serve as the bottom of a pile."""
 
     def createitems(self, *args):
-	self.__oval = Oval(self.canvas,
-			   self.x-20, self.y-10, self.x+20, self.y+10,
-			   fill='gray', outline='')
-	self.group.addtag_withtag(self.__oval)
+        self.__oval = Oval(self.canvas,
+                           self.x-20, self.y-10, self.x+20, self.y+10,
+                           fill='gray', outline='')
+        self.group.addtag_withtag(self.__oval)
 
 
 class Pile:
@@ -90,86 +90,86 @@ class Pile:
     """A group of graphical objects."""
 
     def __init__(self, canvas, x, y, tag=None):
-	self.canvas = canvas
-	self.x = x
-	self.y = y
-	self.objects = []
-	self.bottom = Bottom(self.canvas, self.x, self.y)
-	self.group = Group(self.canvas, tag=tag)
-	self.group.addtag_withtag(self.bottom.group)
-	self.bindhandlers()
+        self.canvas = canvas
+        self.x = x
+        self.y = y
+        self.objects = []
+        self.bottom = Bottom(self.canvas, self.x, self.y)
+        self.group = Group(self.canvas, tag=tag)
+        self.group.addtag_withtag(self.bottom.group)
+        self.bindhandlers()
 
     def bindhandlers(self):
-	self.group.bind('<1>', self.clickhandler)
- 	self.group.bind('<Double-1>', self.doubleclickhandler)
+        self.group.bind('<1>', self.clickhandler)
+        self.group.bind('<Double-1>', self.doubleclickhandler)
 
     def add(self, object):
-	self.objects.append(object)
-	self.group.addtag_withtag(object.group)
-	self.position(object)
+        self.objects.append(object)
+        self.group.addtag_withtag(object.group)
+        self.position(object)
 
     def delete(self, object):
-	object.group.dtag(self.group)
-	self.objects.remove(object)
+        object.group.dtag(self.group)
+        self.objects.remove(object)
 
     def position(self, object):
-	object.tkraise()
-	i = self.objects.index(object)
-	object.moveto(self.x + i*4, self.y + i*8)
+        object.tkraise()
+        i = self.objects.index(object)
+        object.moveto(self.x + i*4, self.y + i*8)
 
     def clickhandler(self, event):
-	pass
+        pass
 
     def doubleclickhandler(self, event):
-	pass
+        pass
 
 
 class MovingPile(Pile):
 
     def bindhandlers(self):
-	Pile.bindhandlers(self)
-	self.group.bind('<B1-Motion>', self.motionhandler)
-	self.group.bind('<ButtonRelease-1>', self.releasehandler)
+        Pile.bindhandlers(self)
+        self.group.bind('<B1-Motion>', self.motionhandler)
+        self.group.bind('<ButtonRelease-1>', self.releasehandler)
 
     movethis = None
 
     def clickhandler(self, event):
-	tags = self.canvas.gettags('current')
-	for i in range(len(self.objects)):
-	    o = self.objects[i]
-	    if o.group.tag in tags:
-		break
-	else:
-	    self.movethis = None
-	    return
-	self.movethis = self.objects[i:]
-	for o in self.movethis:
-	    o.tkraise()
-	self.lastx = event.x
-	self.lasty = event.y
+        tags = self.canvas.gettags('current')
+        for i in range(len(self.objects)):
+            o = self.objects[i]
+            if o.group.tag in tags:
+                break
+        else:
+            self.movethis = None
+            return
+        self.movethis = self.objects[i:]
+        for o in self.movethis:
+            o.tkraise()
+        self.lastx = event.x
+        self.lasty = event.y
 
     doubleclickhandler = clickhandler
 
     def motionhandler(self, event):
-	if not self.movethis:
-	    return
-	dx = event.x - self.lastx
-	dy = event.y - self.lasty
-	self.lastx = event.x
-	self.lasty = event.y
-	for o in self.movethis:
-	    o.moveby(dx, dy)
+        if not self.movethis:
+            return
+        dx = event.x - self.lastx
+        dy = event.y - self.lasty
+        self.lastx = event.x
+        self.lasty = event.y
+        for o in self.movethis:
+            o.moveby(dx, dy)
 
     def releasehandler(self, event):
-	objects = self.movethis
-	if not objects:
-	    return
-	self.movethis = None
-	self.finishmove(objects)
+        objects = self.movethis
+        if not objects:
+            return
+        self.movethis = None
+        self.finishmove(objects)
 
     def finishmove(self, objects):
-	for o in objects:
-	    self.position(o)
+        for o in objects:
+            self.position(o)
 
 
 class Pile1(MovingPile):
@@ -179,29 +179,29 @@ class Pile1(MovingPile):
     tag = 'p1'
 
     def __init__(self, demo):
-	self.demo = demo
-	MovingPile.__init__(self, self.demo.canvas, self.x, self.y, self.tag)
+        self.demo = demo
+        MovingPile.__init__(self, self.demo.canvas, self.x, self.y, self.tag)
 
     def doubleclickhandler(self, event):
-	try:
-	    o = self.objects[-1]
-	except IndexError:
-	    return
-	o.transfer(self.other())
-	MovingPile.doubleclickhandler(self, event)
+        try:
+            o = self.objects[-1]
+        except IndexError:
+            return
+        o.transfer(self.other())
+        MovingPile.doubleclickhandler(self, event)
 
     def other(self):
-	return self.demo.p2
+        return self.demo.p2
 
     def finishmove(self, objects):
-	o = objects[0]
-	p = self.other()
-	x, y = o.x, o.y
-	if (x-p.x)**2 + (y-p.y)**2 < (x-self.x)**2 + (y-self.y)**2:
-	    for o in objects:
-		o.transfer(p)
-	else:
-	    MovingPile.finishmove(self, objects)
+        o = objects[0]
+        p = self.other()
+        x, y = o.x, o.y
+        if (x-p.x)**2 + (y-p.y)**2 < (x-self.x)**2 + (y-self.y)**2:
+            for o in objects:
+                o.transfer(p)
+        else:
+            MovingPile.finishmove(self, objects)
 
 class Pile2(Pile1):
 
@@ -210,26 +210,26 @@ class Pile2(Pile1):
     tag = 'p2'
 
     def other(self):
-	return self.demo.p1
+        return self.demo.p1
 
 
 class Demo:
 
     def __init__(self, master):
-	self.master = master
-	self.canvas = Canvas(master,
-			     width=200, height=200,
-			     background='yellow',
-			     relief=SUNKEN, borderwidth=2)
-	self.canvas.pack(expand=1, fill=BOTH)
-	self.p1 = Pile1(self)
-	self.p2 = Pile2(self)
-	o1 = Object(self.canvas, fill='red', text='o1')
-	o2 = Object(self.canvas, fill='green', text='o2')
-	o3 = Object(self.canvas, fill='light blue', text='o3')
-	o1.transfer(self.p1)
-	o2.transfer(self.p1)
-	o3.transfer(self.p2)
+        self.master = master
+        self.canvas = Canvas(master,
+                             width=200, height=200,
+                             background='yellow',
+                             relief=SUNKEN, borderwidth=2)
+        self.canvas.pack(expand=1, fill=BOTH)
+        self.p1 = Pile1(self)
+        self.p2 = Pile2(self)
+        o1 = Object(self.canvas, fill='red', text='o1')
+        o2 = Object(self.canvas, fill='green', text='o2')
+        o3 = Object(self.canvas, fill='light blue', text='o3')
+        o1.transfer(self.p1)
+        o2.transfer(self.p1)
+        o3.transfer(self.p2)
 
 
 # Main function, run when invoked as a stand-alone Python program.
diff --git a/Demo/tkinter/guido/dialog.py b/Demo/tkinter/guido/dialog.py
index 1f794ae..50d84b9 100755
--- a/Demo/tkinter/guido/dialog.py
+++ b/Demo/tkinter/guido/dialog.py
@@ -25,11 +25,11 @@ def dialog(master, title, text, bitmap, default, *args):
     # 2. Fill the top part with the bitmap and message.
 
     msg = Message(top, width='3i', text=text,
-		  font='-Adobe-Times-Medium-R-Normal-*-180-*')
+                  font='-Adobe-Times-Medium-R-Normal-*-180-*')
     msg.pack(side=RIGHT, expand=1, fill=BOTH, padx='3m', pady='3m')
     if bitmap:
-	bm = Label(top, bitmap=bitmap)
-	bm.pack(side=LEFT, padx='3m', pady='3m')
+        bm = Label(top, bitmap=bitmap)
+        bm.pack(side=LEFT, padx='3m', pady='3m')
 
     # 3. Create a row of buttons at the bottom of the dialog.
 
@@ -37,27 +37,27 @@ def dialog(master, title, text, bitmap, default, *args):
     buttons = []
     i = 0
     for but in args:
-	b = Button(bot, text=but, command=lambda v=var,i=i: v.set(i))
-	buttons.append(b)
-	if i == default:
-	    bd = Frame(bot, relief=SUNKEN, borderwidth=1)
-	    bd.pack(side=LEFT, expand=1, padx='3m', pady='2m')
-	    b.lift()
-	    b.pack (in_=bd, side=LEFT,
-		    padx='2m', pady='2m', ipadx='2m', ipady='1m')
-	else:
-	    b.pack (side=LEFT, expand=1,
-		    padx='3m', pady='3m', ipadx='2m', ipady='1m')
-	i = i+1
+        b = Button(bot, text=but, command=lambda v=var,i=i: v.set(i))
+        buttons.append(b)
+        if i == default:
+            bd = Frame(bot, relief=SUNKEN, borderwidth=1)
+            bd.pack(side=LEFT, expand=1, padx='3m', pady='2m')
+            b.lift()
+            b.pack (in_=bd, side=LEFT,
+                    padx='2m', pady='2m', ipadx='2m', ipady='1m')
+        else:
+            b.pack (side=LEFT, expand=1,
+                    padx='3m', pady='3m', ipadx='2m', ipady='1m')
+        i = i+1
 
     # 4. Set up a binding for <Return>, if there's a default,
     # set a grab, and claim the focus too.
 
     if default >= 0:
-	w.bind('<Return>',
-	       lambda e, b=buttons[default], v=var, i=default:
-	       (b.flash(),
-		v.set(i)))
+        w.bind('<Return>',
+               lambda e, b=buttons[default], v=var, i=default:
+               (b.flash(),
+                v.set(i)))
 
     oldFocus = w.focus_get()
     w.grab_set()
@@ -75,23 +75,23 @@ def dialog(master, title, text, bitmap, default, *args):
 
 def go():
     i = dialog(mainWidget,
-	       'Not Responding',
-	       "The file server isn't responding right now; "
-	       "I'll keep trying.",
-	       '',
-	       -1,
-	       'OK')
+               'Not Responding',
+               "The file server isn't responding right now; "
+               "I'll keep trying.",
+               '',
+               -1,
+               'OK')
     print 'pressed button', i
     i = dialog(mainWidget,
-	       'File Modified',
-	       'File "tcl.h" has been modified since '
-	       'the last time it was saved. '
-	       'Do you want to save it before exiting the application?',
-	       'warning',
-	       0,
-	       'Save File',
-	       'Discard Changes',
-	       'Return To Editor')
+               'File Modified',
+               'File "tcl.h" has been modified since '
+               'the last time it was saved. '
+               'Do you want to save it before exiting the application?',
+               'warning',
+               0,
+               'Save File',
+               'Discard Changes',
+               'Return To Editor')
     print 'pressed button', i
 
 def test():
diff --git a/Demo/tkinter/guido/electrons.py b/Demo/tkinter/guido/electrons.py
index 97dad2d7..fdc558f 100755
--- a/Demo/tkinter/guido/electrons.py
+++ b/Demo/tkinter/guido/electrons.py
@@ -1,6 +1,6 @@
 #! /usr/bin/env python
 
-# Simulate "electrons" migrating across the screen.  
+# Simulate "electrons" migrating across the screen.
 # An optional bitmap file in can be in the background.
 #
 # Usage: electrons [n [bitmapfile]]
@@ -18,74 +18,74 @@ import random
 # The graphical interface
 class Electrons:
 
-	# Create our objects
-	def __init__(self, n, bitmap = None):
-		self.n = n
-		self.tk = tk = Tk()
-		self.canvas = c = Canvas(tk)
-		c.pack()
-		width, height = tk.getint(c['width']), tk.getint(c['height'])
-
-		# Add background bitmap
-		if bitmap:
-			self.bitmap = c.create_bitmap(width/2, height/2,
-						      bitmap=bitmap,
-						      foreground='blue')
-
-		self.pieces = []
-		x1, y1, x2, y2 = 10,70,14,74
-		for i in range(n):
-			p = c.create_oval(x1, y1, x2, y2, fill='red')
-			self.pieces.append(p)
-			y1, y2 = y1 +2, y2 + 2
-		self.tk.update()
-
-	def random_move(self, n):
-		c = self.canvas
-		for p in self.pieces:
-			x = random.choice(range(-2,4))
-			y = random.choice(range(-3,4))
-			c.move(p, x, y)
-		self.tk.update()
-
-	# Run -- allow 500 movemens
-	def run(self):
-		try:
-			for i in range(500):
-				self.random_move(self.n)
-		except TclError:
-			try:
-				self.tk.destroy()
-			except TclError:
-				pass
+    # Create our objects
+    def __init__(self, n, bitmap = None):
+        self.n = n
+        self.tk = tk = Tk()
+        self.canvas = c = Canvas(tk)
+        c.pack()
+        width, height = tk.getint(c['width']), tk.getint(c['height'])
+
+        # Add background bitmap
+        if bitmap:
+            self.bitmap = c.create_bitmap(width/2, height/2,
+                                          bitmap=bitmap,
+                                          foreground='blue')
+
+        self.pieces = []
+        x1, y1, x2, y2 = 10,70,14,74
+        for i in range(n):
+            p = c.create_oval(x1, y1, x2, y2, fill='red')
+            self.pieces.append(p)
+            y1, y2 = y1 +2, y2 + 2
+        self.tk.update()
+
+    def random_move(self, n):
+        c = self.canvas
+        for p in self.pieces:
+            x = random.choice(range(-2,4))
+            y = random.choice(range(-3,4))
+            c.move(p, x, y)
+        self.tk.update()
+
+    # Run -- allow 500 movemens
+    def run(self):
+        try:
+            for i in range(500):
+                self.random_move(self.n)
+        except TclError:
+            try:
+                self.tk.destroy()
+            except TclError:
+                pass
 
 
 # Main program
 def main():
-	import sys, string
+    import sys, string
 
-	# First argument is number of electrons, default 30
-	if sys.argv[1:]:
-		n = string.atoi(sys.argv[1])
-	else:
-		n = 30
+    # First argument is number of electrons, default 30
+    if sys.argv[1:]:
+        n = string.atoi(sys.argv[1])
+    else:
+        n = 30
 
-	# Second argument is bitmap file, default none
-	if sys.argv[2:]:
-		bitmap = sys.argv[2]
-		# Reverse meaning of leading '@' compared to Tk
-		if bitmap[0] == '@': bitmap = bitmap[1:]
-		else: bitmap = '@' + bitmap
-	else:
-		bitmap = None
+    # Second argument is bitmap file, default none
+    if sys.argv[2:]:
+        bitmap = sys.argv[2]
+        # Reverse meaning of leading '@' compared to Tk
+        if bitmap[0] == '@': bitmap = bitmap[1:]
+        else: bitmap = '@' + bitmap
+    else:
+        bitmap = None
 
-	# Create the graphical objects...
-	h = Electrons(n, bitmap)
+    # Create the graphical objects...
+    h = Electrons(n, bitmap)
 
-	# ...and run!
-	h.run()
+    # ...and run!
+    h.run()
 
 
 # Call main when run as script
 if __name__ == '__main__':
-	main()
+    main()
diff --git a/Demo/tkinter/guido/hanoi.py b/Demo/tkinter/guido/hanoi.py
index 9e566c4..078c246 100755
--- a/Demo/tkinter/guido/hanoi.py
+++ b/Demo/tkinter/guido/hanoi.py
@@ -16,139 +16,139 @@ from Tkinter import *
 # Basic Towers-of-Hanoi algorithm: move n pieces from a to b, using c
 # as temporary.  For each move, call report()
 def hanoi(n, a, b, c, report):
-	if n <= 0: return
-	hanoi(n-1, a, c, b, report)
-	report(n, a, b)
-	hanoi(n-1, c, b, a, report)
+    if n <= 0: return
+    hanoi(n-1, a, c, b, report)
+    report(n, a, b)
+    hanoi(n-1, c, b, a, report)
 
 
 # The graphical interface
 class Tkhanoi:
 
-	# Create our objects
-	def __init__(self, n, bitmap = None):
-		self.n = n
-		self.tk = tk = Tk()
-		self.canvas = c = Canvas(tk)
-		c.pack()
-		width, height = tk.getint(c['width']), tk.getint(c['height'])
-
-		# Add background bitmap
-		if bitmap:
-			self.bitmap = c.create_bitmap(width/2, height/2,
-						      bitmap=bitmap,
-						      foreground='blue')
-
-		# Generate pegs
-		pegwidth = 10
-		pegheight = height/2
-		pegdist = width/3
-		x1, y1 = (pegdist-pegwidth)/2, height*1/3
-		x2, y2 = x1+pegwidth, y1+pegheight
-		self.pegs = []
-		p = c.create_rectangle(x1, y1, x2, y2, fill='black')
-		self.pegs.append(p)
-		x1, x2 = x1+pegdist, x2+pegdist
-		p = c.create_rectangle(x1, y1, x2, y2, fill='black')
-		self.pegs.append(p)
-		x1, x2 = x1+pegdist, x2+pegdist
-		p = c.create_rectangle(x1, y1, x2, y2, fill='black')
-		self.pegs.append(p)
-		self.tk.update()
-
-		# Generate pieces
-		pieceheight = pegheight/16
-		maxpiecewidth = pegdist*2/3
-		minpiecewidth = 2*pegwidth
-		self.pegstate = [[], [], []]
-		self.pieces = {}
-		x1, y1 = (pegdist-maxpiecewidth)/2, y2-pieceheight-2
-		x2, y2 = x1+maxpiecewidth, y1+pieceheight
-		dx = (maxpiecewidth-minpiecewidth) / (2*max(1, n-1))
-		for i in range(n, 0, -1):
-			p = c.create_rectangle(x1, y1, x2, y2, fill='red')
-			self.pieces[i] = p
-			self.pegstate[0].append(i)
-			x1, x2 = x1 + dx, x2-dx
-			y1, y2 = y1 - pieceheight-2, y2-pieceheight-2
-			self.tk.update()
-			self.tk.after(25)
-
-	# Run -- never returns
-	def run(self):
-		while 1:
-			hanoi(self.n, 0, 1, 2, self.report)
-			hanoi(self.n, 1, 2, 0, self.report)
-			hanoi(self.n, 2, 0, 1, self.report)
-			hanoi(self.n, 0, 2, 1, self.report)
-			hanoi(self.n, 2, 1, 0, self.report)
-			hanoi(self.n, 1, 0, 2, self.report)
-
-	# Reporting callback for the actual hanoi function
-	def report(self, i, a, b):
-		if self.pegstate[a][-1] != i: raise RuntimeError # Assertion
-		del self.pegstate[a][-1]
-		p = self.pieces[i]
-		c = self.canvas
-
-		# Lift the piece above peg a
-		ax1, ay1, ax2, ay2 = c.bbox(self.pegs[a])
-		while 1:
-			x1, y1, x2, y2 = c.bbox(p)
-			if y2 < ay1: break
-			c.move(p, 0, -1)
-			self.tk.update()
-
-		# Move it towards peg b
-		bx1, by1, bx2, by2 = c.bbox(self.pegs[b])
-		newcenter = (bx1+bx2)/2
-		while 1:
-			x1, y1, x2, y2 = c.bbox(p)
-			center = (x1+x2)/2
-			if center == newcenter: break
-			if center > newcenter: c.move(p, -1, 0)
-			else: c.move(p, 1, 0)
-			self.tk.update()
-
-		# Move it down on top of the previous piece
-		pieceheight = y2-y1
-		newbottom = by2 - pieceheight*len(self.pegstate[b]) - 2
-		while 1:
-			x1, y1, x2, y2 = c.bbox(p)
-			if y2 >= newbottom: break
-			c.move(p, 0, 1)
-			self.tk.update()
-
-		# Update peg state
-		self.pegstate[b].append(i)
+    # Create our objects
+    def __init__(self, n, bitmap = None):
+        self.n = n
+        self.tk = tk = Tk()
+        self.canvas = c = Canvas(tk)
+        c.pack()
+        width, height = tk.getint(c['width']), tk.getint(c['height'])
+
+        # Add background bitmap
+        if bitmap:
+            self.bitmap = c.create_bitmap(width/2, height/2,
+                                          bitmap=bitmap,
+                                          foreground='blue')
+
+        # Generate pegs
+        pegwidth = 10
+        pegheight = height/2
+        pegdist = width/3
+        x1, y1 = (pegdist-pegwidth)/2, height*1/3
+        x2, y2 = x1+pegwidth, y1+pegheight
+        self.pegs = []
+        p = c.create_rectangle(x1, y1, x2, y2, fill='black')
+        self.pegs.append(p)
+        x1, x2 = x1+pegdist, x2+pegdist
+        p = c.create_rectangle(x1, y1, x2, y2, fill='black')
+        self.pegs.append(p)
+        x1, x2 = x1+pegdist, x2+pegdist
+        p = c.create_rectangle(x1, y1, x2, y2, fill='black')
+        self.pegs.append(p)
+        self.tk.update()
+
+        # Generate pieces
+        pieceheight = pegheight/16
+        maxpiecewidth = pegdist*2/3
+        minpiecewidth = 2*pegwidth
+        self.pegstate = [[], [], []]
+        self.pieces = {}
+        x1, y1 = (pegdist-maxpiecewidth)/2, y2-pieceheight-2
+        x2, y2 = x1+maxpiecewidth, y1+pieceheight
+        dx = (maxpiecewidth-minpiecewidth) / (2*max(1, n-1))
+        for i in range(n, 0, -1):
+            p = c.create_rectangle(x1, y1, x2, y2, fill='red')
+            self.pieces[i] = p
+            self.pegstate[0].append(i)
+            x1, x2 = x1 + dx, x2-dx
+            y1, y2 = y1 - pieceheight-2, y2-pieceheight-2
+            self.tk.update()
+            self.tk.after(25)
+
+    # Run -- never returns
+    def run(self):
+        while 1:
+            hanoi(self.n, 0, 1, 2, self.report)
+            hanoi(self.n, 1, 2, 0, self.report)
+            hanoi(self.n, 2, 0, 1, self.report)
+            hanoi(self.n, 0, 2, 1, self.report)
+            hanoi(self.n, 2, 1, 0, self.report)
+            hanoi(self.n, 1, 0, 2, self.report)
+
+    # Reporting callback for the actual hanoi function
+    def report(self, i, a, b):
+        if self.pegstate[a][-1] != i: raise RuntimeError # Assertion
+        del self.pegstate[a][-1]
+        p = self.pieces[i]
+        c = self.canvas
+
+        # Lift the piece above peg a
+        ax1, ay1, ax2, ay2 = c.bbox(self.pegs[a])
+        while 1:
+            x1, y1, x2, y2 = c.bbox(p)
+            if y2 < ay1: break
+            c.move(p, 0, -1)
+            self.tk.update()
+
+        # Move it towards peg b
+        bx1, by1, bx2, by2 = c.bbox(self.pegs[b])
+        newcenter = (bx1+bx2)/2
+        while 1:
+            x1, y1, x2, y2 = c.bbox(p)
+            center = (x1+x2)/2
+            if center == newcenter: break
+            if center > newcenter: c.move(p, -1, 0)
+            else: c.move(p, 1, 0)
+            self.tk.update()
+
+        # Move it down on top of the previous piece
+        pieceheight = y2-y1
+        newbottom = by2 - pieceheight*len(self.pegstate[b]) - 2
+        while 1:
+            x1, y1, x2, y2 = c.bbox(p)
+            if y2 >= newbottom: break
+            c.move(p, 0, 1)
+            self.tk.update()
+
+        # Update peg state
+        self.pegstate[b].append(i)
 
 
 # Main program
 def main():
-	import sys, string
+    import sys, string
 
-	# First argument is number of pegs, default 4
-	if sys.argv[1:]:
-		n = string.atoi(sys.argv[1])
-	else:
-		n = 4
+    # First argument is number of pegs, default 4
+    if sys.argv[1:]:
+        n = string.atoi(sys.argv[1])
+    else:
+        n = 4
 
-	# Second argument is bitmap file, default none
-	if sys.argv[2:]:
-		bitmap = sys.argv[2]
-		# Reverse meaning of leading '@' compared to Tk
-		if bitmap[0] == '@': bitmap = bitmap[1:]
-		else: bitmap = '@' + bitmap
-	else:
-		bitmap = None
+    # Second argument is bitmap file, default none
+    if sys.argv[2:]:
+        bitmap = sys.argv[2]
+        # Reverse meaning of leading '@' compared to Tk
+        if bitmap[0] == '@': bitmap = bitmap[1:]
+        else: bitmap = '@' + bitmap
+    else:
+        bitmap = None
 
-	# Create the graphical objects...
-	h = Tkhanoi(n, bitmap)
+    # Create the graphical objects...
+    h = Tkhanoi(n, bitmap)
 
-	# ...and run!
-	h.run()
+    # ...and run!
+    h.run()
 
 
 # Call main when run as script
 if __name__ == '__main__':
-	main()
+    main()
diff --git a/Demo/tkinter/guido/hello.py b/Demo/tkinter/guido/hello.py
index 237204f..358a7ec 100755
--- a/Demo/tkinter/guido/hello.py
+++ b/Demo/tkinter/guido/hello.py
@@ -4,14 +4,14 @@ import sys
 from Tkinter import *
 
 def main():
-	root = Tk()
-	button = Button(root)
-	button['text'] = 'Hello, world'
-	button['command'] = quit_callback	# See below
-	button.pack()
-	root.mainloop()
+    root = Tk()
+    button = Button(root)
+    button['text'] = 'Hello, world'
+    button['command'] = quit_callback       # See below
+    button.pack()
+    root.mainloop()
 
 def quit_callback():
-	sys.exit(0)
+    sys.exit(0)
 
 main()
diff --git a/Demo/tkinter/guido/kill.py b/Demo/tkinter/guido/kill.py
index 577af8b..e7df261 100755
--- a/Demo/tkinter/guido/kill.py
+++ b/Demo/tkinter/guido/kill.py
@@ -8,92 +8,91 @@ import commands
 import os
 
 class BarButton(Menubutton):
-	def __init__(self, master=None, **cnf):
-		apply(Menubutton.__init__, (self, master), cnf)
-		self.pack(side=LEFT)
-		self.menu = Menu(self, name='menu')
-		self['menu'] = self.menu
+    def __init__(self, master=None, **cnf):
+        apply(Menubutton.__init__, (self, master), cnf)
+        self.pack(side=LEFT)
+        self.menu = Menu(self, name='menu')
+        self['menu'] = self.menu
 
 class Kill(Frame):
-	# List of (name, option, pid_column)
-	format_list = [('Default', '', 0),
-		       ('Long', '-l', 2),
-		       ('User', '-u', 1),
-		       ('Jobs', '-j', 1),
-		       ('Signal', '-s', 1),
-		       ('Memory', '-m', 0),
-		       ('VM', '-v', 0),
-		       ('Hex', '-X', 0)]
-	def kill(self, selected):
-		c = self.format_list[self.format.get()][2]
-		pid = split(selected)[c]
-		os.system('kill -9 ' + pid)
-		self.do_update()
-	def do_update(self):
-		name, option, column = self.format_list[self.format.get()]
-		s = commands.getoutput('ps -w ' + option)
-		list = splitfields(s, '\n')
-		self.header.set(list[0])
-		del list[0]
-		y = self.frame.vscroll.get()[0]
-		self.frame.list.delete(0, AtEnd())
-		for line in list:
-			self.frame.list.insert(0, line)
-		self.frame.list.yview(int(y))
-	def do_motion(self, e):
-		e.widget.select_clear(0, END)
-		e.widget.select_set(e.widget.nearest(e.y))
-	def do_leave(self, e):
-		e.widget.select_clear(0, END)
-	def do_1(self, e):
-		self.kill(e.widget.get(e.widget.nearest(e.y)))
-	def __init__(self, master=None, **cnf):
-		Frame.__init__(self, master, cnf)
-		self.pack(expand=1, fill=BOTH)
-		self.bar = Frame(self, name='bar', relief=RAISED,
-				 borderwidth=2)
-		self.bar.pack(fill=X)
-		self.bar.file = BarButton(self.bar, text='File')
-		self.bar.file.menu.add_command(
-			label='Quit', command=self.quit)
-		self.bar.view = BarButton(self.bar, text='View')
-		self.format = IntVar(self)
-		self.format.set(2)
-		for num in range(len(self.format_list)):
-			self.bar.view.menu.add_radiobutton(
-				label=self.format_list[num][0], 
-				command=self.do_update,
-				variable=self.format,
-				value=num)
-		#self.bar.view.menu.add_separator()
-		#XXX ...
-		self.bar.tk_menuBar(self.bar.file, self.bar.view)
-		self.frame = Frame(self, relief=RAISED, borderwidth=2)
-		self.frame.pack(expand=1, fill=BOTH)
-		self.header = StringVar(self)
-		self.frame.label = Label(self.frame, relief=FLAT, anchor=NW,
-					 borderwidth=0,
-					 textvariable=self.header)
-		self.frame.label.pack(fill=X)
-		self.frame.vscroll = Scrollbar(self.frame, orient=VERTICAL)
-		self.frame.list = Listbox(self.frame, relief=SUNKEN,
-					  selectbackground='#eed5b7',
-					  selectborderwidth=0,
-					  yscroll=self.frame.vscroll.set)
-		self.frame.vscroll['command'] = self.frame.list.yview
-		self.frame.vscroll.pack(side=RIGHT, fill=Y)
-		self.frame.list.pack(expand=1, fill=BOTH)
-		self.update = Button(self, text="Update",
-				     command=self.do_update)
-		self.update.pack(expand=1, fill=X)
-		self.frame.list.bind('<Motion>', self.do_motion)
-		self.frame.list.bind('<Leave>', self.do_leave)
-		self.frame.list.bind('<1>', self.do_1)
-		self.do_update()
+    # List of (name, option, pid_column)
+    format_list = [('Default', '', 0),
+                   ('Long', '-l', 2),
+                   ('User', '-u', 1),
+                   ('Jobs', '-j', 1),
+                   ('Signal', '-s', 1),
+                   ('Memory', '-m', 0),
+                   ('VM', '-v', 0),
+                   ('Hex', '-X', 0)]
+    def kill(self, selected):
+        c = self.format_list[self.format.get()][2]
+        pid = split(selected)[c]
+        os.system('kill -9 ' + pid)
+        self.do_update()
+    def do_update(self):
+        name, option, column = self.format_list[self.format.get()]
+        s = commands.getoutput('ps -w ' + option)
+        list = splitfields(s, '\n')
+        self.header.set(list[0])
+        del list[0]
+        y = self.frame.vscroll.get()[0]
+        self.frame.list.delete(0, AtEnd())
+        for line in list:
+            self.frame.list.insert(0, line)
+        self.frame.list.yview(int(y))
+    def do_motion(self, e):
+        e.widget.select_clear(0, END)
+        e.widget.select_set(e.widget.nearest(e.y))
+    def do_leave(self, e):
+        e.widget.select_clear(0, END)
+    def do_1(self, e):
+        self.kill(e.widget.get(e.widget.nearest(e.y)))
+    def __init__(self, master=None, **cnf):
+        Frame.__init__(self, master, cnf)
+        self.pack(expand=1, fill=BOTH)
+        self.bar = Frame(self, name='bar', relief=RAISED,
+                         borderwidth=2)
+        self.bar.pack(fill=X)
+        self.bar.file = BarButton(self.bar, text='File')
+        self.bar.file.menu.add_command(
+                label='Quit', command=self.quit)
+        self.bar.view = BarButton(self.bar, text='View')
+        self.format = IntVar(self)
+        self.format.set(2)
+        for num in range(len(self.format_list)):
+            self.bar.view.menu.add_radiobutton(
+                    label=self.format_list[num][0],
+                    command=self.do_update,
+                    variable=self.format,
+                    value=num)
+        #self.bar.view.menu.add_separator()
+        #XXX ...
+        self.bar.tk_menuBar(self.bar.file, self.bar.view)
+        self.frame = Frame(self, relief=RAISED, borderwidth=2)
+        self.frame.pack(expand=1, fill=BOTH)
+        self.header = StringVar(self)
+        self.frame.label = Label(self.frame, relief=FLAT, anchor=NW,
+                                 borderwidth=0,
+                                 textvariable=self.header)
+        self.frame.label.pack(fill=X)
+        self.frame.vscroll = Scrollbar(self.frame, orient=VERTICAL)
+        self.frame.list = Listbox(self.frame, relief=SUNKEN,
+                                  selectbackground='#eed5b7',
+                                  selectborderwidth=0,
+                                  yscroll=self.frame.vscroll.set)
+        self.frame.vscroll['command'] = self.frame.list.yview
+        self.frame.vscroll.pack(side=RIGHT, fill=Y)
+        self.frame.list.pack(expand=1, fill=BOTH)
+        self.update = Button(self, text="Update",
+                             command=self.do_update)
+        self.update.pack(expand=1, fill=X)
+        self.frame.list.bind('<Motion>', self.do_motion)
+        self.frame.list.bind('<Leave>', self.do_leave)
+        self.frame.list.bind('<1>', self.do_1)
+        self.do_update()
 
 if __name__ == '__main__':
-	kill = Kill(None, borderwidth=5)
-	kill.winfo_toplevel().title('Tkinter Process Killer')
-	kill.winfo_toplevel().minsize(1, 1)
-	kill.mainloop()
-
+    kill = Kill(None, borderwidth=5)
+    kill.winfo_toplevel().title('Tkinter Process Killer')
+    kill.winfo_toplevel().minsize(1, 1)
+    kill.mainloop()
diff --git a/Demo/tkinter/guido/listtree.py b/Demo/tkinter/guido/listtree.py
index 523f209..d28ce49 100755
--- a/Demo/tkinter/guido/listtree.py
+++ b/Demo/tkinter/guido/listtree.py
@@ -6,32 +6,32 @@ import string
 from Tkinter import *
 
 def listtree(master, app):
-	list = Listbox(master, name='list')
-	list.pack(expand=1, fill=BOTH)
-	listnodes(list, app, '.', 0)
-	return list
+    list = Listbox(master, name='list')
+    list.pack(expand=1, fill=BOTH)
+    listnodes(list, app, '.', 0)
+    return list
 
 def listnodes(list, app, widget, level):
-	klass = list.send(app, 'winfo', 'class', widget)
-##	i = string.rindex(widget, '.')
-##	list.insert(END, '%s%s (%s)' % ((level-1)*'.   ', widget[i:], klass))
-	list.insert(END, '%s (%s)' % (widget, klass))
-	children = list.tk.splitlist(
-		list.send(app, 'winfo', 'children', widget))
-	for c in children:
-		listnodes(list, app, c, level+1)
+    klass = list.send(app, 'winfo', 'class', widget)
+##      i = string.rindex(widget, '.')
+##      list.insert(END, '%s%s (%s)' % ((level-1)*'.   ', widget[i:], klass))
+    list.insert(END, '%s (%s)' % (widget, klass))
+    children = list.tk.splitlist(
+            list.send(app, 'winfo', 'children', widget))
+    for c in children:
+        listnodes(list, app, c, level+1)
 
 def main():
-	if not sys.argv[1:]:
-		sys.stderr.write('Usage: listtree appname\n')
-		sys.exit(2)
-	app = sys.argv[1]
-	tk = Tk()
-	tk.minsize(1, 1)
-	f = Frame(tk, name='f')
-	f.pack(expand=1, fill=BOTH)
-	list = listtree(f, app)
-	tk.mainloop()
+    if not sys.argv[1:]:
+        sys.stderr.write('Usage: listtree appname\n')
+        sys.exit(2)
+    app = sys.argv[1]
+    tk = Tk()
+    tk.minsize(1, 1)
+    f = Frame(tk, name='f')
+    f.pack(expand=1, fill=BOTH)
+    list = listtree(f, app)
+    tk.mainloop()
 
 if __name__ == '__main__':
-	main()
+    main()
diff --git a/Demo/tkinter/guido/mbox.py b/Demo/tkinter/guido/mbox.py
index 6d7a410..9b16f6b 100755
--- a/Demo/tkinter/guido/mbox.py
+++ b/Demo/tkinter/guido/mbox.py
@@ -16,270 +16,270 @@ from dialog import dialog
 mailbox = os.environ['HOME'] + '/Mail'
 
 def main():
-	global root, tk, top, mid, bot
-	global folderbox, foldermenu, scanbox, scanmenu, viewer
-	global folder, seq
-	global mh, mhf
-
-	# Parse command line options
+    global root, tk, top, mid, bot
+    global folderbox, foldermenu, scanbox, scanmenu, viewer
+    global folder, seq
+    global mh, mhf
+
+    # Parse command line options
 
-	folder = 'inbox'
-	seq = 'all'
-	try:
-		opts, args = getopt.getopt(sys.argv[1:], '')
-	except getopt.error, msg:
-		print msg
-		sys.exit(2)
-	for arg in args:
-		if arg[:1] == '+':
-			folder = arg[1:]
-		else:
-			seq = arg
+    folder = 'inbox'
+    seq = 'all'
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], '')
+    except getopt.error, msg:
+        print msg
+        sys.exit(2)
+    for arg in args:
+        if arg[:1] == '+':
+            folder = arg[1:]
+        else:
+            seq = arg
 
-	# Initialize MH
+    # Initialize MH
 
-	mh = mhlib.MH()
-	mhf = mh.openfolder(folder)
+    mh = mhlib.MH()
+    mhf = mh.openfolder(folder)
 
-	# Build widget hierarchy
+    # Build widget hierarchy
 
-	root = Tk()
-	tk = root.tk
+    root = Tk()
+    tk = root.tk
 
-	top = Frame(root)
-	top.pack({'expand': 1, 'fill': 'both'})
+    top = Frame(root)
+    top.pack({'expand': 1, 'fill': 'both'})
 
-	# Build right part: folder list
+    # Build right part: folder list
 
-	right = Frame(top)
-	right.pack({'fill': 'y', 'side': 'right'})
+    right = Frame(top)
+    right.pack({'fill': 'y', 'side': 'right'})
 
-	folderbar = Scrollbar(right, {'relief': 'sunken', 'bd': 2})
-	folderbar.pack({'fill': 'y', 'side': 'right'})
+    folderbar = Scrollbar(right, {'relief': 'sunken', 'bd': 2})
+    folderbar.pack({'fill': 'y', 'side': 'right'})
 
-	folderbox = Listbox(right, {'exportselection': 0})
-	folderbox.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
+    folderbox = Listbox(right, {'exportselection': 0})
+    folderbox.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
 
-	foldermenu = Menu(root)
-	foldermenu.add('command',
-		       {'label': 'Open Folder',
-			'command': open_folder})
-	foldermenu.add('separator')
-	foldermenu.add('command',
-		       {'label': 'Quit',
-			'command': 'exit'})
-	foldermenu.bind('<ButtonRelease-3>', folder_unpost)
+    foldermenu = Menu(root)
+    foldermenu.add('command',
+                   {'label': 'Open Folder',
+                    'command': open_folder})
+    foldermenu.add('separator')
+    foldermenu.add('command',
+                   {'label': 'Quit',
+                    'command': 'exit'})
+    foldermenu.bind('<ButtonRelease-3>', folder_unpost)
 
-	folderbox['yscrollcommand'] = (folderbar, 'set')
-	folderbar['command'] = (folderbox, 'yview')
-	folderbox.bind('<Double-1>', open_folder, 1)
-	folderbox.bind('<3>', folder_post)
+    folderbox['yscrollcommand'] = (folderbar, 'set')
+    folderbar['command'] = (folderbox, 'yview')
+    folderbox.bind('<Double-1>', open_folder, 1)
+    folderbox.bind('<3>', folder_post)
 
-	# Build left part: scan list
+    # Build left part: scan list
 
-	left = Frame(top)
-	left.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
+    left = Frame(top)
+    left.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
 
-	scanbar = Scrollbar(left, {'relief': 'sunken', 'bd': 2})
-	scanbar.pack({'fill': 'y', 'side': 'right'})
+    scanbar = Scrollbar(left, {'relief': 'sunken', 'bd': 2})
+    scanbar.pack({'fill': 'y', 'side': 'right'})
 
-	scanbox = Listbox(left, {'font': 'fixed'})
-	scanbox.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
+    scanbox = Listbox(left, {'font': 'fixed'})
+    scanbox.pack({'expand': 1, 'fill': 'both', 'side': 'left'})
 
-	scanmenu = Menu(root)
-	scanmenu.add('command',
-		     {'label': 'Open Message',
-		      'command': open_message})
-	scanmenu.add('command',
-		     {'label': 'Remove Message',
-		      'command': remove_message})
-	scanmenu.add('command',
-		     {'label': 'Refile Message',
-		      'command': refile_message})
-	scanmenu.add('separator')
-	scanmenu.add('command',
-		     {'label': 'Quit',
-		      'command': 'exit'})
-	scanmenu.bind('<ButtonRelease-3>', scan_unpost)
+    scanmenu = Menu(root)
+    scanmenu.add('command',
+                 {'label': 'Open Message',
+                  'command': open_message})
+    scanmenu.add('command',
+                 {'label': 'Remove Message',
+                  'command': remove_message})
+    scanmenu.add('command',
+                 {'label': 'Refile Message',
+                  'command': refile_message})
+    scanmenu.add('separator')
+    scanmenu.add('command',
+                 {'label': 'Quit',
+                  'command': 'exit'})
+    scanmenu.bind('<ButtonRelease-3>', scan_unpost)
 
-	scanbox['yscrollcommand'] = (scanbar, 'set')
-	scanbar['command'] = (scanbox, 'yview')
-	scanbox.bind('<Double-1>', open_message)
-	scanbox.bind('<3>', scan_post)
+    scanbox['yscrollcommand'] = (scanbar, 'set')
+    scanbar['command'] = (scanbox, 'yview')
+    scanbox.bind('<Double-1>', open_message)
+    scanbox.bind('<3>', scan_post)
 
-	# Separator between middle and bottom part
+    # Separator between middle and bottom part
 
-	rule2 = Frame(root, {'bg': 'black'})
-	rule2.pack({'fill': 'x'})
+    rule2 = Frame(root, {'bg': 'black'})
+    rule2.pack({'fill': 'x'})
 
-	# Build bottom part: current message
+    # Build bottom part: current message
 
-	bot = Frame(root)
-	bot.pack({'expand': 1, 'fill': 'both'})
-	#
-	viewer = None
+    bot = Frame(root)
+    bot.pack({'expand': 1, 'fill': 'both'})
+    #
+    viewer = None
 
-	# Window manager commands
+    # Window manager commands
 
-	root.minsize(800, 1) # Make window resizable
+    root.minsize(800, 1) # Make window resizable
 
-	# Fill folderbox with text
+    # Fill folderbox with text
 
-	setfolders()
+    setfolders()
 
-	# Fill scanbox with text
+    # Fill scanbox with text
 
-	rescan()
+    rescan()
 
-	# Enter mainloop
+    # Enter mainloop
 
-	root.mainloop()
+    root.mainloop()
 
 def folder_post(e):
-	x, y = e.x_root, e.y_root
-	foldermenu.post(x - 10, y - 10)
-	foldermenu.grab_set()
+    x, y = e.x_root, e.y_root
+    foldermenu.post(x - 10, y - 10)
+    foldermenu.grab_set()
 
 def folder_unpost(e):
-	tk.call('update', 'idletasks')
-	foldermenu.grab_release()
-	foldermenu.unpost()
-	foldermenu.invoke('active')
+    tk.call('update', 'idletasks')
+    foldermenu.grab_release()
+    foldermenu.unpost()
+    foldermenu.invoke('active')
 
 def scan_post(e):
-	x, y = e.x_root, e.y_root
-	scanmenu.post(x - 10, y - 10)
-	scanmenu.grab_set()
+    x, y = e.x_root, e.y_root
+    scanmenu.post(x - 10, y - 10)
+    scanmenu.grab_set()
 
 def scan_unpost(e):
-	tk.call('update', 'idletasks')
-	scanmenu.grab_release()
-	scanmenu.unpost()
-	scanmenu.invoke('active')
+    tk.call('update', 'idletasks')
+    scanmenu.grab_release()
+    scanmenu.unpost()
+    scanmenu.invoke('active')
 
 scanparser = regex.compile('^ *\([0-9]+\)')
 
 def open_folder(e=None):
-	global folder, mhf
-	sel = folderbox.curselection()
-	if len(sel) != 1:
-		if len(sel) > 1:
-			msg = "Please open one folder at a time"
-		else:
-			msg = "Please select a folder to open"
-		dialog(root, "Can't Open Folder", msg, "", 0, "OK")
-		return
-	i = sel[0]
-	folder = folderbox.get(i)
-	mhf = mh.openfolder(folder)
-	rescan()
+    global folder, mhf
+    sel = folderbox.curselection()
+    if len(sel) != 1:
+        if len(sel) > 1:
+            msg = "Please open one folder at a time"
+        else:
+            msg = "Please select a folder to open"
+        dialog(root, "Can't Open Folder", msg, "", 0, "OK")
+        return
+    i = sel[0]
+    folder = folderbox.get(i)
+    mhf = mh.openfolder(folder)
+    rescan()
 
 def open_message(e=None):
-	global viewer
-	sel = scanbox.curselection()
-	if len(sel) != 1:
-		if len(sel) > 1:
-			msg = "Please open one message at a time"
-		else:
-			msg = "Please select a message to open"
-		dialog(root, "Can't Open Message", msg, "", 0, "OK")
-		return
-	cursor = scanbox['cursor']
-	scanbox['cursor'] = 'watch'
-	tk.call('update', 'idletasks')
-	i = sel[0]
-	line = scanbox.get(i)
-	if scanparser.match(line) >= 0:
-		num = string.atoi(scanparser.group(1))
-		m = mhf.openmessage(num)
-		if viewer: viewer.destroy()
-		from MimeViewer import MimeViewer
-		viewer = MimeViewer(bot, '+%s/%d' % (folder, num), m)
-		viewer.pack()
-		viewer.show()
-	scanbox['cursor'] = cursor
+    global viewer
+    sel = scanbox.curselection()
+    if len(sel) != 1:
+        if len(sel) > 1:
+            msg = "Please open one message at a time"
+        else:
+            msg = "Please select a message to open"
+        dialog(root, "Can't Open Message", msg, "", 0, "OK")
+        return
+    cursor = scanbox['cursor']
+    scanbox['cursor'] = 'watch'
+    tk.call('update', 'idletasks')
+    i = sel[0]
+    line = scanbox.get(i)
+    if scanparser.match(line) >= 0:
+        num = string.atoi(scanparser.group(1))
+        m = mhf.openmessage(num)
+        if viewer: viewer.destroy()
+        from MimeViewer import MimeViewer
+        viewer = MimeViewer(bot, '+%s/%d' % (folder, num), m)
+        viewer.pack()
+        viewer.show()
+    scanbox['cursor'] = cursor
 
 def interestingheader(header):
-	return header != 'received'
+    return header != 'received'
 
 def remove_message(e=None):
-	itop = scanbox.nearest(0)
-	sel = scanbox.curselection()
-	if not sel:
-		dialog(root, "No Message To Remove",
-		       "Please select a message to remove", "", 0, "OK")
-		return
-	todo = []
-	for i in sel:
-		line = scanbox.get(i)
-		if scanparser.match(line) >= 0:
-			todo.append(string.atoi(scanparser.group(1)))
-	mhf.removemessages(todo)
-	rescan()
-	fixfocus(min(todo), itop)
+    itop = scanbox.nearest(0)
+    sel = scanbox.curselection()
+    if not sel:
+        dialog(root, "No Message To Remove",
+               "Please select a message to remove", "", 0, "OK")
+        return
+    todo = []
+    for i in sel:
+        line = scanbox.get(i)
+        if scanparser.match(line) >= 0:
+            todo.append(string.atoi(scanparser.group(1)))
+    mhf.removemessages(todo)
+    rescan()
+    fixfocus(min(todo), itop)
 
 lastrefile = ''
 tofolder = None
 def refile_message(e=None):
-	global lastrefile, tofolder
-	itop = scanbox.nearest(0)
-	sel = scanbox.curselection()
-	if not sel:
-		dialog(root, "No Message To Refile",
-		       "Please select a message to refile", "", 0, "OK")
-		return
-	foldersel = folderbox.curselection()
-	if len(foldersel) != 1:
-		if not foldersel:
-			msg = "Please select a folder to refile to"
-		else:
-			msg = "Please select exactly one folder to refile to"
-		dialog(root, "No Folder To Refile", msg, "", 0, "OK")
-		return
-	refileto = folderbox.get(foldersel[0])
-	todo = []
-	for i in sel:
-		line = scanbox.get(i)
-		if scanparser.match(line) >= 0:
-			todo.append(string.atoi(scanparser.group(1)))
-	if lastrefile != refileto or not tofolder:
-		lastrefile = refileto
-		tofolder = None
-		tofolder = mh.openfolder(lastrefile)
-	mhf.refilemessages(todo, tofolder)
-	rescan()
-	fixfocus(min(todo), itop)
+    global lastrefile, tofolder
+    itop = scanbox.nearest(0)
+    sel = scanbox.curselection()
+    if not sel:
+        dialog(root, "No Message To Refile",
+               "Please select a message to refile", "", 0, "OK")
+        return
+    foldersel = folderbox.curselection()
+    if len(foldersel) != 1:
+        if not foldersel:
+            msg = "Please select a folder to refile to"
+        else:
+            msg = "Please select exactly one folder to refile to"
+        dialog(root, "No Folder To Refile", msg, "", 0, "OK")
+        return
+    refileto = folderbox.get(foldersel[0])
+    todo = []
+    for i in sel:
+        line = scanbox.get(i)
+        if scanparser.match(line) >= 0:
+            todo.append(string.atoi(scanparser.group(1)))
+    if lastrefile != refileto or not tofolder:
+        lastrefile = refileto
+        tofolder = None
+        tofolder = mh.openfolder(lastrefile)
+    mhf.refilemessages(todo, tofolder)
+    rescan()
+    fixfocus(min(todo), itop)
 
 def fixfocus(near, itop):
-	n = scanbox.size()
-	for i in range(n):
-		line = scanbox.get(repr(i))
-		if scanparser.match(line) >= 0:
-			num = string.atoi(scanparser.group(1))
-			if num >= near:
-				break
-	else:
-		i = 'end'
-	scanbox.select_from(i)
-	scanbox.yview(itop)
+    n = scanbox.size()
+    for i in range(n):
+        line = scanbox.get(repr(i))
+        if scanparser.match(line) >= 0:
+            num = string.atoi(scanparser.group(1))
+            if num >= near:
+                break
+    else:
+        i = 'end'
+    scanbox.select_from(i)
+    scanbox.yview(itop)
 
 def setfolders():
-	folderbox.delete(0, 'end')
-	for fn in mh.listallfolders():
-		folderbox.insert('end', fn)
+    folderbox.delete(0, 'end')
+    for fn in mh.listallfolders():
+        folderbox.insert('end', fn)
 
 def rescan():
-	global viewer
-	if viewer:
-		viewer.destroy()
-		viewer = None
-	scanbox.delete(0, 'end')
-	for line in scanfolder(folder, seq):
-		scanbox.insert('end', line)
+    global viewer
+    if viewer:
+        viewer.destroy()
+        viewer = None
+    scanbox.delete(0, 'end')
+    for line in scanfolder(folder, seq):
+        scanbox.insert('end', line)
 
 def scanfolder(folder = 'inbox', sequence = 'all'):
-	return map(
-		lambda line: line[:-1],
-		os.popen('scan +%s %s' % (folder, sequence), 'r').readlines())
+    return map(
+            lambda line: line[:-1],
+            os.popen('scan +%s %s' % (folder, sequence), 'r').readlines())
 
 main()
diff --git a/Demo/tkinter/guido/newmenubardemo.py b/Demo/tkinter/guido/newmenubardemo.py
index cafbf63..57bf13c 100644
--- a/Demo/tkinter/guido/newmenubardemo.py
+++ b/Demo/tkinter/guido/newmenubardemo.py
@@ -7,35 +7,35 @@ from Tkinter import *
 class App:
 
     def __init__(self, master):
-	self.master = master
+        self.master = master
 
-	self.menubar = Menu(self.master)
+        self.menubar = Menu(self.master)
 
- 	self.filemenu = Menu(self.menubar)
-	
- 	self.filemenu.add_command(label="New")
- 	self.filemenu.add_command(label="Open...")
- 	self.filemenu.add_command(label="Close")
- 	self.filemenu.add_separator()
- 	self.filemenu.add_command(label="Quit", command=self.master.quit)
+        self.filemenu = Menu(self.menubar)
 
-	self.editmenu = Menu(self.menubar)
+        self.filemenu.add_command(label="New")
+        self.filemenu.add_command(label="Open...")
+        self.filemenu.add_command(label="Close")
+        self.filemenu.add_separator()
+        self.filemenu.add_command(label="Quit", command=self.master.quit)
 
- 	self.editmenu.add_command(label="Cut")
- 	self.editmenu.add_command(label="Copy")
- 	self.editmenu.add_command(label="Paste")
+        self.editmenu = Menu(self.menubar)
+
+        self.editmenu.add_command(label="Cut")
+        self.editmenu.add_command(label="Copy")
+        self.editmenu.add_command(label="Paste")
 
         self.helpmenu = Menu(self.menubar, name='help')
 
         self.helpmenu.add_command(label="About...")
 
-	self.menubar.add_cascade(label="File", menu=self.filemenu)
-	self.menubar.add_cascade(label="Edit", menu=self.editmenu)
-	self.menubar.add_cascade(label="Help", menu=self.helpmenu)
+        self.menubar.add_cascade(label="File", menu=self.filemenu)
+        self.menubar.add_cascade(label="Edit", menu=self.editmenu)
+        self.menubar.add_cascade(label="Help", menu=self.helpmenu)
 
-	self.top = Toplevel(menu=self.menubar)
+        self.top = Toplevel(menu=self.menubar)
 
-	# Rest of app goes here...
+        # Rest of app goes here...
 
 def main():
     root = Tk()
diff --git a/Demo/tkinter/guido/paint.py b/Demo/tkinter/guido/paint.py
index 743d500..d46e20b 100644
--- a/Demo/tkinter/guido/paint.py
+++ b/Demo/tkinter/guido/paint.py
@@ -12,12 +12,12 @@ here and hope that the person who requested it sees this!
 
   All this does is put up a canvas and draw a smooth black line
 whenever you have the mouse button down, but hopefully it will
-be enough to start with.. It would be easy enough to add some 
+be enough to start with.. It would be easy enough to add some
 options like other shapes or colors...
 
-						yours,
-						dave mitchell
-						davem@magnet.com
+                                                yours,
+                                                dave mitchell
+                                                davem@magnet.com
 """
 
 from Tkinter import *
@@ -28,33 +28,33 @@ b1 = "up"
 xold, yold = None, None
 
 def main():
-  root = Tk()
-  drawing_area = Canvas(root)
-  drawing_area.pack()
-  drawing_area.bind("<Motion>", motion)
-  drawing_area.bind("<ButtonPress-1>", b1down)
-  drawing_area.bind("<ButtonRelease-1>", b1up)
-  root.mainloop()
+    root = Tk()
+    drawing_area = Canvas(root)
+    drawing_area.pack()
+    drawing_area.bind("<Motion>", motion)
+    drawing_area.bind("<ButtonPress-1>", b1down)
+    drawing_area.bind("<ButtonRelease-1>", b1up)
+    root.mainloop()
 
 def b1down(event):
-  global b1
-  b1 = "down"		# you only want to draw when the button is down
-			# because "Motion" events happen -all the time-
+    global b1
+    b1 = "down"           # you only want to draw when the button is down
+                          # because "Motion" events happen -all the time-
 
 def b1up(event):
-  global b1, xold, yold
-  b1 = "up"
-  xold = None		# reset the line when you let go of the button
-  yold = None
+    global b1, xold, yold
+    b1 = "up"
+    xold = None           # reset the line when you let go of the button
+    yold = None
 
 def motion(event):
-  if b1 == "down":
-    global xold, yold
-    if xold != None and yold != None:
-      event.widget.create_line(xold,yold,event.x,event.y,smooth=TRUE)
-			# here's where you draw it. smooth. neat.
-    xold = event.x
-    yold = event.y
+    if b1 == "down":
+        global xold, yold
+        if xold != None and yold != None:
+            event.widget.create_line(xold,yold,event.x,event.y,smooth=TRUE)
+                          # here's where you draw it. smooth. neat.
+        xold = event.x
+        yold = event.y
 
 if __name__ == "__main__":
-  main()
+    main()
diff --git a/Demo/tkinter/guido/rmt.py b/Demo/tkinter/guido/rmt.py
index 6e9a828..440650c 100755
--- a/Demo/tkinter/guido/rmt.py
+++ b/Demo/tkinter/guido/rmt.py
@@ -28,7 +28,7 @@ s = Scrollbar(f, relief=FLAT)
 s.pack(side=RIGHT, fill=Y)
 t = Text(f, relief=RAISED, borderwidth=2, yscrollcommand=s.set, setgrid=1)
 t.pack(side=LEFT, fill=BOTH, expand=1)
-t.tag_config('bold', font='-Adobe-Courier-Bold-R-Normal-*-120-*') 
+t.tag_config('bold', font='-Adobe-Courier-Bold-R-Normal-*-120-*')
 s['command'] = t.yview
 
 root.title('Tk Remote Controller')
@@ -42,7 +42,7 @@ file_m = Menu(file)
 file['menu'] = file_m
 file_m_apps = Menu(file_m, tearoff=0)
 file_m.add_cascade(label='Select Application', underline=0,
-		   menu=file_m_apps)
+                   menu=file_m_apps)
 file_m.add_command(label='Quit', underline=0, command=sys.exit)
 
 # 3. Create bindings for text widget to allow commands to be
@@ -51,46 +51,46 @@ file_m.add_command(label='Quit', underline=0, command=sys.exit)
 # insertion point).
 
 def single1(e):
-	x = e.x
-	y = e.y
-	t.setvar('tk_priv(selectMode)', 'char')
-	t.mark_set('anchor', At(x, y))
-	# Should focus W
+    x = e.x
+    y = e.y
+    t.setvar('tk_priv(selectMode)', 'char')
+    t.mark_set('anchor', At(x, y))
+    # Should focus W
 t.bind('<1>', single1)
 
 def double1(e):
-	x = e.x
-	y = e.y
-	t.setvar('tk_priv(selectMode)', 'word')
-	t.tk_textSelectTo(At(x, y))
+    x = e.x
+    y = e.y
+    t.setvar('tk_priv(selectMode)', 'word')
+    t.tk_textSelectTo(At(x, y))
 t.bind('<Double-1>', double1)
 
 def triple1(e):
-	x = e.x
-	y = e.y
-	t.setvar('tk_priv(selectMode)', 'line')
-	t.tk_textSelectTo(At(x, y))
+    x = e.x
+    y = e.y
+    t.setvar('tk_priv(selectMode)', 'line')
+    t.tk_textSelectTo(At(x, y))
 t.bind('<Triple-1>', triple1)
 
 def returnkey(e):
-	t.insert(AtInsert(), '\n')
-	invoke()
+    t.insert(AtInsert(), '\n')
+    invoke()
 t.bind('<Return>', returnkey)
 
 def controlv(e):
-	t.insert(AtInsert(), t.selection_get())
-	t.yview_pickplace(AtInsert())
-	if t.index(AtInsert())[-2:] == '.0':
-		invoke()
+    t.insert(AtInsert(), t.selection_get())
+    t.yview_pickplace(AtInsert())
+    if t.index(AtInsert())[-2:] == '.0':
+        invoke()
 t.bind('<Control-v>', controlv)
 
 # 4. Procedure to backspace over one character, as long as
 # the character isn't part of the prompt.
 
 def backspace(e):
-	if t.index('promptEnd') != t.index('insert - 1 char'):
-		t.delete('insert - 1 char', AtInsert())
-		t.yview_pickplace(AtInsert())
+    if t.index('promptEnd') != t.index('insert - 1 char'):
+        t.delete('insert - 1 char', AtInsert())
+        t.yview_pickplace(AtInsert())
 t.bind('<BackSpace>', backspace)
 t.bind('<Control-h>', backspace)
 t.bind('<Delete>', backspace)
@@ -103,49 +103,49 @@ t.bind('<Delete>', backspace)
 # a new prompt.
 
 def invoke():
-	cmd = t.get('promptEnd + 1 char', AtInsert())
-	if t.getboolean(tk.call('info', 'complete', cmd)): # XXX
-		if app == root.winfo_name():
-			msg = tk.call('eval', cmd) # XXX
-		else:
-			msg = t.send(app, cmd)
-		if msg:
-			t.insert(AtInsert(), msg + '\n')
-		prompt()
-	t.yview_pickplace(AtInsert())
+    cmd = t.get('promptEnd + 1 char', AtInsert())
+    if t.getboolean(tk.call('info', 'complete', cmd)): # XXX
+        if app == root.winfo_name():
+            msg = tk.call('eval', cmd) # XXX
+        else:
+            msg = t.send(app, cmd)
+        if msg:
+            t.insert(AtInsert(), msg + '\n')
+        prompt()
+    t.yview_pickplace(AtInsert())
 
 def prompt():
-	t.insert(AtInsert(), app + ': ')
-	t.mark_set('promptEnd', 'insert - 1 char')
-	t.tag_add('bold', 'insert linestart', 'promptEnd')
+    t.insert(AtInsert(), app + ': ')
+    t.mark_set('promptEnd', 'insert - 1 char')
+    t.tag_add('bold', 'insert linestart', 'promptEnd')
 
 # 6. Procedure to select a new application.  Also changes
 # the prompt on the current command line to reflect the new
 # name.
 
 def newApp(appName):
-	global app
-	app = appName
-	t.delete('promptEnd linestart', 'promptEnd')
-	t.insert('promptEnd', appName + ':')
-	t.tag_add('bold', 'promptEnd linestart', 'promptEnd')
+    global app
+    app = appName
+    t.delete('promptEnd linestart', 'promptEnd')
+    t.insert('promptEnd', appName + ':')
+    t.tag_add('bold', 'promptEnd linestart', 'promptEnd')
 
 def fillAppsMenu():
-	file_m_apps.add('command')
-	file_m_apps.delete(0, 'last')
-	names = root.winfo_interps()
-	names = map(None, names) # convert tuple to list
-	names.sort()
-	for name in names:
-		try:
-			root.send(name, 'winfo name .')
-		except TclError:
-			# Inoperative window -- ignore it
-			pass
-		else:
-			file_m_apps.add_command(
-			    label=name,
-			    command=lambda name=name: newApp(name))
+    file_m_apps.add('command')
+    file_m_apps.delete(0, 'last')
+    names = root.winfo_interps()
+    names = map(None, names) # convert tuple to list
+    names.sort()
+    for name in names:
+        try:
+            root.send(name, 'winfo name .')
+        except TclError:
+            # Inoperative window -- ignore it
+            pass
+        else:
+            file_m_apps.add_command(
+                label=name,
+                command=lambda name=name: newApp(name))
 
 file_m_apps['postcommand'] = fillAppsMenu
 mBar.tk_menuBar(file)
diff --git a/Demo/tkinter/guido/solitaire.py b/Demo/tkinter/guido/solitaire.py
index a205afd..50a8b26 100755
--- a/Demo/tkinter/guido/solitaire.py
+++ b/Demo/tkinter/guido/solitaire.py
@@ -11,7 +11,7 @@ Limitations:
 - No keyboard shortcuts.
 - Less fancy animation when you win.
 - The determination of which stack you drag to is more relaxed.
-  
+
 Apology:
 
 I'm not much of a card player, so my terminology in these comments may
@@ -35,7 +35,7 @@ from Canvas import Rectangle, CanvasText, Group, Window
 
 class Group(Group):
     def bind(self, sequence=None, command=None):
-	return self.canvas.tag_bind(self.id, sequence, command)
+        return self.canvas.tag_bind(self.id, sequence, command)
 
 
 # Constants determining the size and lay-out of cards and stacks.  We
@@ -135,7 +135,7 @@ class Card:
 
     Semi-public read-only instance variables (XXX should be made
     private):
-    
+
     group -- the Canvas.Group representing the card
     x, y -- the position of the card's top left corner
 
@@ -150,68 +150,68 @@ class Card:
     """
 
     def __init__(self, suit, value, canvas):
-	"""Card constructor.
+        """Card constructor.
 
-	Arguments are the card's suit and value, and the canvas widget.
+        Arguments are the card's suit and value, and the canvas widget.
 
-	The card is created at position (0, 0), with its face down
-	(adding it to a stack will position it according to that
-	stack's rules).
+        The card is created at position (0, 0), with its face down
+        (adding it to a stack will position it according to that
+        stack's rules).
 
-	"""
-	self.suit = suit
-	self.value = value
-	self.color = COLOR[suit]
-	self.face_shown = 0
+        """
+        self.suit = suit
+        self.value = value
+        self.color = COLOR[suit]
+        self.face_shown = 0
 
-	self.x = self.y = 0
-	self.group = Group(canvas)
+        self.x = self.y = 0
+        self.group = Group(canvas)
 
-	text = "%s  %s" % (VALNAMES[value], suit)
-	self.__text = CanvasText(canvas, CARDWIDTH/2, 0,
-			       anchor=N, fill=self.color, text=text)
-	self.group.addtag_withtag(self.__text)
+        text = "%s  %s" % (VALNAMES[value], suit)
+        self.__text = CanvasText(canvas, CARDWIDTH/2, 0,
+                               anchor=N, fill=self.color, text=text)
+        self.group.addtag_withtag(self.__text)
 
-	self.__rect = Rectangle(canvas, 0, 0, CARDWIDTH, CARDHEIGHT,
-			      outline='black', fill='white')
-	self.group.addtag_withtag(self.__rect)
+        self.__rect = Rectangle(canvas, 0, 0, CARDWIDTH, CARDHEIGHT,
+                              outline='black', fill='white')
+        self.group.addtag_withtag(self.__rect)
 
-	self.__back = Rectangle(canvas, MARGIN, MARGIN,
-			      CARDWIDTH-MARGIN, CARDHEIGHT-MARGIN,
-			      outline='black', fill='blue')
-	self.group.addtag_withtag(self.__back)
+        self.__back = Rectangle(canvas, MARGIN, MARGIN,
+                              CARDWIDTH-MARGIN, CARDHEIGHT-MARGIN,
+                              outline='black', fill='blue')
+        self.group.addtag_withtag(self.__back)
 
     def __repr__(self):
-	"""Return a string for debug print statements."""
-	return "Card(%r, %r)" % (self.suit, self.value)
+        """Return a string for debug print statements."""
+        return "Card(%r, %r)" % (self.suit, self.value)
 
     def moveto(self, x, y):
-	"""Move the card to absolute position (x, y)."""
-	self.moveby(x - self.x, y - self.y)
+        """Move the card to absolute position (x, y)."""
+        self.moveby(x - self.x, y - self.y)
 
     def moveby(self, dx, dy):
-	"""Move the card by (dx, dy)."""
-	self.x = self.x + dx
-	self.y = self.y + dy
-	self.group.move(dx, dy)
+        """Move the card by (dx, dy)."""
+        self.x = self.x + dx
+        self.y = self.y + dy
+        self.group.move(dx, dy)
 
     def tkraise(self):
-	"""Raise the card above all other objects in its canvas."""
-	self.group.tkraise()
+        """Raise the card above all other objects in its canvas."""
+        self.group.tkraise()
 
     def showface(self):
-	"""Turn the card's face up."""
-	self.tkraise()
-	self.__rect.tkraise()
-	self.__text.tkraise()
-	self.face_shown = 1
+        """Turn the card's face up."""
+        self.tkraise()
+        self.__rect.tkraise()
+        self.__text.tkraise()
+        self.face_shown = 1
 
     def showback(self):
-	"""Turn the card's face down."""
-	self.tkraise()
-	self.__rect.tkraise()
-	self.__back.tkraise()
-	self.face_shown = 0
+        """Turn the card's face down."""
+        self.tkraise()
+        self.__rect.tkraise()
+        self.__back.tkraise()
+        self.face_shown = 0
 
 
 class Stack:
@@ -240,7 +240,7 @@ class Stack:
 
         The default user (single) click handler shows the top card
         face up.  The default user double click handler calls the user
-	single click handler.
+        single click handler.
 
     usermovehandler(cards) -- called to complete a subpile move
 
@@ -255,133 +255,133 @@ class Stack:
         The default event handlers turn the top card of the stack with
         its face up on a (single or double) click, and also support
         moving a subpile around.
-    
+
     startmoving(event) -- begin a move operation
     finishmoving() -- finish a move operation
 
     """
 
     def __init__(self, x, y, game=None):
-	"""Stack constructor.
-
-	Arguments are the stack's nominal x and y position (the top
-	left corner of the first card placed in the stack), and the
-	game object (which is used to get the canvas; subclasses use
-	the game object to find other stacks).
-
-	"""
-	self.x = x
-	self.y = y
-	self.game = game
-	self.cards = []
-	self.group = Group(self.game.canvas)
-	self.group.bind('<1>', self.clickhandler)
- 	self.group.bind('<Double-1>', self.doubleclickhandler)
-	self.group.bind('<B1-Motion>', self.motionhandler)
-	self.group.bind('<ButtonRelease-1>', self.releasehandler)
-	self.makebottom()
+        """Stack constructor.
+
+        Arguments are the stack's nominal x and y position (the top
+        left corner of the first card placed in the stack), and the
+        game object (which is used to get the canvas; subclasses use
+        the game object to find other stacks).
+
+        """
+        self.x = x
+        self.y = y
+        self.game = game
+        self.cards = []
+        self.group = Group(self.game.canvas)
+        self.group.bind('<1>', self.clickhandler)
+        self.group.bind('<Double-1>', self.doubleclickhandler)
+        self.group.bind('<B1-Motion>', self.motionhandler)
+        self.group.bind('<ButtonRelease-1>', self.releasehandler)
+        self.makebottom()
 
     def makebottom(self):
-	pass
+        pass
 
     def __repr__(self):
-	"""Return a string for debug print statements."""
-	return "%s(%d, %d)" % (self.__class__.__name__, self.x, self.y)
+        """Return a string for debug print statements."""
+        return "%s(%d, %d)" % (self.__class__.__name__, self.x, self.y)
 
     # Public methods
 
     def add(self, card):
-	self.cards.append(card)
-	card.tkraise()
-	self.position(card)
-	self.group.addtag_withtag(card.group)
+        self.cards.append(card)
+        card.tkraise()
+        self.position(card)
+        self.group.addtag_withtag(card.group)
 
     def delete(self, card):
-	self.cards.remove(card)
-	card.group.dtag(self.group)
+        self.cards.remove(card)
+        card.group.dtag(self.group)
 
     def showtop(self):
-	if self.cards:
-	    self.cards[-1].showface()
+        if self.cards:
+            self.cards[-1].showface()
 
     def deal(self):
-	if not self.cards:
-	    return None
-	card = self.cards[-1]
-	self.delete(card)
-	return card
+        if not self.cards:
+            return None
+        card = self.cards[-1]
+        self.delete(card)
+        return card
 
     # Subclass overridable methods
 
     def position(self, card):
-	card.moveto(self.x, self.y)
+        card.moveto(self.x, self.y)
 
     def userclickhandler(self):
-	self.showtop()
+        self.showtop()
 
     def userdoubleclickhandler(self):
-	self.userclickhandler()
+        self.userclickhandler()
 
     def usermovehandler(self, cards):
-	for card in cards:
-	    self.position(card)
+        for card in cards:
+            self.position(card)
 
     # Event handlers
 
     def clickhandler(self, event):
-	self.finishmoving()		# In case we lost an event
-	self.userclickhandler()
-	self.startmoving(event)
+        self.finishmoving()             # In case we lost an event
+        self.userclickhandler()
+        self.startmoving(event)
 
     def motionhandler(self, event):
-	self.keepmoving(event)
+        self.keepmoving(event)
 
     def releasehandler(self, event):
-	self.keepmoving(event)
-	self.finishmoving()
+        self.keepmoving(event)
+        self.finishmoving()
 
     def doubleclickhandler(self, event):
-	self.finishmoving()		# In case we lost an event
-	self.userdoubleclickhandler()
-	self.startmoving(event)
+        self.finishmoving()             # In case we lost an event
+        self.userdoubleclickhandler()
+        self.startmoving(event)
 
     # Move internals
 
     moving = None
 
     def startmoving(self, event):
-	self.moving = None
-	tags = self.game.canvas.gettags('current')
-	for i in range(len(self.cards)):
-	    card = self.cards[i]
-	    if card.group.tag in tags:
-		break
-	else:
-	    return
-	if not card.face_shown:
-	    return
-	self.moving = self.cards[i:]
-	self.lastx = event.x
-	self.lasty = event.y
-	for card in self.moving:
-	    card.tkraise()
+        self.moving = None
+        tags = self.game.canvas.gettags('current')
+        for i in range(len(self.cards)):
+            card = self.cards[i]
+            if card.group.tag in tags:
+                break
+        else:
+            return
+        if not card.face_shown:
+            return
+        self.moving = self.cards[i:]
+        self.lastx = event.x
+        self.lasty = event.y
+        for card in self.moving:
+            card.tkraise()
 
     def keepmoving(self, event):
-	if not self.moving:
-	    return
-	dx = event.x - self.lastx
-	dy = event.y - self.lasty
-	self.lastx = event.x
-	self.lasty = event.y
-	if dx or dy:
-	    for card in self.moving:
-		card.moveby(dx, dy)
+        if not self.moving:
+            return
+        dx = event.x - self.lastx
+        dy = event.y - self.lasty
+        self.lastx = event.x
+        self.lasty = event.y
+        if dx or dy:
+            for card in self.moving:
+                card.moveby(dx, dy)
 
     def finishmoving(self):
-	cards = self.moving
-	self.moving = None
-	if cards:
-	    self.usermovehandler(cards)
+        cards = self.moving
+        self.moving = None
+        if cards:
+            self.usermovehandler(cards)
 
 
 class Deck(Stack):
@@ -400,37 +400,37 @@ class Deck(Stack):
     """
 
     def makebottom(self):
-	bottom = Rectangle(self.game.canvas,
-			   self.x, self.y,
-			   self.x+CARDWIDTH, self.y+CARDHEIGHT,
-			   outline='black', fill=BACKGROUND)
- 	self.group.addtag_withtag(bottom)
+        bottom = Rectangle(self.game.canvas,
+                           self.x, self.y,
+                           self.x+CARDWIDTH, self.y+CARDHEIGHT,
+                           outline='black', fill=BACKGROUND)
+        self.group.addtag_withtag(bottom)
 
     def fill(self):
-	for suit in ALLSUITS:
-	    for value in ALLVALUES:
-		self.add(Card(suit, value, self.game.canvas))
+        for suit in ALLSUITS:
+            for value in ALLVALUES:
+                self.add(Card(suit, value, self.game.canvas))
 
     def shuffle(self):
-	n = len(self.cards)
-	newcards = []
-	for i in randperm(n):
-	    newcards.append(self.cards[i])
-	self.cards = newcards
+        n = len(self.cards)
+        newcards = []
+        for i in randperm(n):
+            newcards.append(self.cards[i])
+        self.cards = newcards
 
     def userclickhandler(self):
-	opendeck = self.game.opendeck
-	card = self.deal()
-	if not card:
-	    while 1:
-		card = opendeck.deal()
-		if not card:
-		    break
-		self.add(card)
-		card.showback()
-	else:
-	    self.game.opendeck.add(card)
-	    card.showface()
+        opendeck = self.game.opendeck
+        card = self.deal()
+        if not card:
+            while 1:
+                card = opendeck.deal()
+                if not card:
+                    break
+                self.add(card)
+                card.showback()
+        else:
+            self.game.opendeck.add(card)
+            card.showface()
 
 
 def randperm(n):
@@ -438,191 +438,191 @@ def randperm(n):
     r = range(n)
     x = []
     while r:
-	i = random.choice(r)
-	x.append(i)
-	r.remove(i)
+        i = random.choice(r)
+        x.append(i)
+        r.remove(i)
     return x
 
 
 class OpenStack(Stack):
 
     def acceptable(self, cards):
-	return 0
+        return 0
 
     def usermovehandler(self, cards):
-	card = cards[0]
-	stack = self.game.closeststack(card)
-	if not stack or stack is self or not stack.acceptable(cards):
-	    Stack.usermovehandler(self, cards)
-	else:
-	    for card in cards:
-		self.delete(card)
-		stack.add(card)
-	    self.game.wincheck()
+        card = cards[0]
+        stack = self.game.closeststack(card)
+        if not stack or stack is self or not stack.acceptable(cards):
+            Stack.usermovehandler(self, cards)
+        else:
+            for card in cards:
+                self.delete(card)
+                stack.add(card)
+            self.game.wincheck()
 
     def userdoubleclickhandler(self):
-	if not self.cards:
-	    return
-	card = self.cards[-1]
-	if not card.face_shown:
-	    self.userclickhandler()
-	    return
-	for s in self.game.suits:
-	    if s.acceptable([card]):
-		self.delete(card)
-		s.add(card)
-		self.game.wincheck()
-		break
+        if not self.cards:
+            return
+        card = self.cards[-1]
+        if not card.face_shown:
+            self.userclickhandler()
+            return
+        for s in self.game.suits:
+            if s.acceptable([card]):
+                self.delete(card)
+                s.add(card)
+                self.game.wincheck()
+                break
 
 
 class SuitStack(OpenStack):
 
     def makebottom(self):
-	bottom = Rectangle(self.game.canvas,
-			   self.x, self.y,
-			   self.x+CARDWIDTH, self.y+CARDHEIGHT,
-			   outline='black', fill='')
+        bottom = Rectangle(self.game.canvas,
+                           self.x, self.y,
+                           self.x+CARDWIDTH, self.y+CARDHEIGHT,
+                           outline='black', fill='')
 
     def userclickhandler(self):
-	pass
+        pass
 
     def userdoubleclickhandler(self):
-	pass
+        pass
 
     def acceptable(self, cards):
-	if len(cards) != 1:
-	    return 0
-	card = cards[0]
-	if not self.cards:
-	    return card.value == ACE
-	topcard = self.cards[-1]
-	return card.suit == topcard.suit and card.value == topcard.value + 1
+        if len(cards) != 1:
+            return 0
+        card = cards[0]
+        if not self.cards:
+            return card.value == ACE
+        topcard = self.cards[-1]
+        return card.suit == topcard.suit and card.value == topcard.value + 1
 
 
 class RowStack(OpenStack):
 
     def acceptable(self, cards):
-	card = cards[0]
-	if not self.cards:
-	    return card.value == KING
-	topcard = self.cards[-1]
-	if not topcard.face_shown:
-	    return 0
-	return card.color != topcard.color and card.value == topcard.value - 1
+        card = cards[0]
+        if not self.cards:
+            return card.value == KING
+        topcard = self.cards[-1]
+        if not topcard.face_shown:
+            return 0
+        return card.color != topcard.color and card.value == topcard.value - 1
 
     def position(self, card):
-	y = self.y
-	for c in self.cards:
-	    if c == card:
-		break
-	    if c.face_shown:
-		y = y + 2*MARGIN
-	    else:
-		y = y + OFFSET
-	card.moveto(self.x, y)
+        y = self.y
+        for c in self.cards:
+            if c == card:
+                break
+            if c.face_shown:
+                y = y + 2*MARGIN
+            else:
+                y = y + OFFSET
+        card.moveto(self.x, y)
 
 
 class Solitaire:
 
     def __init__(self, master):
-	self.master = master
-
-	self.canvas = Canvas(self.master,
-			     background=BACKGROUND,
-			     highlightthickness=0,
-			     width=NROWS*XSPACING,
-			     height=3*YSPACING + 20 + MARGIN)
-	self.canvas.pack(fill=BOTH, expand=TRUE)
-
-	self.dealbutton = Button(self.canvas,
-				 text="Deal",
-				 highlightthickness=0,
-				 background=BACKGROUND,
-				 activebackground="green",
-				 command=self.deal)
-	Window(self.canvas, MARGIN, 3*YSPACING + 20,
-	       window=self.dealbutton, anchor=SW)
-
-	x = MARGIN
-	y = MARGIN
-
-	self.deck = Deck(x, y, self)
-
-	x = x + XSPACING
-	self.opendeck = OpenStack(x, y, self)
-	
-	x = x + XSPACING
-	self.suits = []
-	for i in range(NSUITS):
-	    x = x + XSPACING
-	    self.suits.append(SuitStack(x, y, self))
-
-	x = MARGIN
-	y = y + YSPACING
-
-	self.rows = []
-	for i in range(NROWS):
-	    self.rows.append(RowStack(x, y, self))
-	    x = x + XSPACING
-
-	self.openstacks = [self.opendeck] + self.suits + self.rows
-	
-	self.deck.fill()
-	self.deal()
+        self.master = master
+
+        self.canvas = Canvas(self.master,
+                             background=BACKGROUND,
+                             highlightthickness=0,
+                             width=NROWS*XSPACING,
+                             height=3*YSPACING + 20 + MARGIN)
+        self.canvas.pack(fill=BOTH, expand=TRUE)
+
+        self.dealbutton = Button(self.canvas,
+                                 text="Deal",
+                                 highlightthickness=0,
+                                 background=BACKGROUND,
+                                 activebackground="green",
+                                 command=self.deal)
+        Window(self.canvas, MARGIN, 3*YSPACING + 20,
+               window=self.dealbutton, anchor=SW)
+
+        x = MARGIN
+        y = MARGIN
+
+        self.deck = Deck(x, y, self)
+
+        x = x + XSPACING
+        self.opendeck = OpenStack(x, y, self)
+
+        x = x + XSPACING
+        self.suits = []
+        for i in range(NSUITS):
+            x = x + XSPACING
+            self.suits.append(SuitStack(x, y, self))
+
+        x = MARGIN
+        y = y + YSPACING
+
+        self.rows = []
+        for i in range(NROWS):
+            self.rows.append(RowStack(x, y, self))
+            x = x + XSPACING
+
+        self.openstacks = [self.opendeck] + self.suits + self.rows
+
+        self.deck.fill()
+        self.deal()
 
     def wincheck(self):
-	for s in self.suits:
-	    if len(s.cards) != NVALUES:
-		return
-	self.win()
-	self.deal()
+        for s in self.suits:
+            if len(s.cards) != NVALUES:
+                return
+        self.win()
+        self.deal()
 
     def win(self):
-	"""Stupid animation when you win."""
-	cards = []
-	for s in self.openstacks:
-	    cards = cards + s.cards
-	while cards:
-	    card = random.choice(cards)
-	    cards.remove(card)
-	    self.animatedmoveto(card, self.deck)
+        """Stupid animation when you win."""
+        cards = []
+        for s in self.openstacks:
+            cards = cards + s.cards
+        while cards:
+            card = random.choice(cards)
+            cards.remove(card)
+            self.animatedmoveto(card, self.deck)
 
     def animatedmoveto(self, card, dest):
-	for i in range(10, 0, -1):
-	    dx, dy = (dest.x-card.x)/i, (dest.y-card.y)/i
-	    card.moveby(dx, dy)
-	    self.master.update_idletasks()
+        for i in range(10, 0, -1):
+            dx, dy = (dest.x-card.x)/i, (dest.y-card.y)/i
+            card.moveby(dx, dy)
+            self.master.update_idletasks()
 
     def closeststack(self, card):
-	closest = None
-	cdist = 999999999
-	# Since we only compare distances,
-	# we don't bother to take the square root.
-	for stack in self.openstacks:
-	    dist = (stack.x - card.x)**2 + (stack.y - card.y)**2
-	    if dist < cdist:
-		closest = stack
-		cdist = dist
-	return closest
+        closest = None
+        cdist = 999999999
+        # Since we only compare distances,
+        # we don't bother to take the square root.
+        for stack in self.openstacks:
+            dist = (stack.x - card.x)**2 + (stack.y - card.y)**2
+            if dist < cdist:
+                closest = stack
+                cdist = dist
+        return closest
 
     def deal(self):
-	self.reset()
-	self.deck.shuffle()
-	for i in range(NROWS):
-	    for r in self.rows[i:]:
-		card = self.deck.deal()
-		r.add(card)
-	for r in self.rows:
-	    r.showtop()
+        self.reset()
+        self.deck.shuffle()
+        for i in range(NROWS):
+            for r in self.rows[i:]:
+                card = self.deck.deal()
+                r.add(card)
+        for r in self.rows:
+            r.showtop()
 
     def reset(self):
-	for stack in self.openstacks:
-	    while 1:
-		card = stack.deal()
-		if not card:
-		    break
-		self.deck.add(card)
-		card.showback()
+        for stack in self.openstacks:
+            while 1:
+                card = stack.deal()
+                if not card:
+                    break
+                self.deck.add(card)
+                card.showback()
 
 
 # Main function, run when invoked as a stand-alone Python program.
diff --git a/Demo/tkinter/guido/sortvisu.py b/Demo/tkinter/guido/sortvisu.py
index 6fe4002..f18f2c1 100644
--- a/Demo/tkinter/guido/sortvisu.py
+++ b/Demo/tkinter/guido/sortvisu.py
@@ -32,302 +32,302 @@ WIDTH = 6
 class Array:
 
     def __init__(self, master, data=None):
-	self.master = master
-	self.frame = Frame(self.master)
-	self.frame.pack(fill=X)
-	self.label = Label(self.frame)
-	self.label.pack()
-	self.canvas = Canvas(self.frame)
-	self.canvas.pack()
-	self.report = Label(self.frame)
-	self.report.pack()
-	self.left = Line(self.canvas, 0, 0, 0, 0)
-	self.right = Line(self.canvas, 0, 0, 0, 0)
-	self.pivot = Line(self.canvas, 0, 0, 0, 0)
-	self.items = []
-	self.size = self.maxvalue = 0
-	if data:
-	    self.setdata(data)
+        self.master = master
+        self.frame = Frame(self.master)
+        self.frame.pack(fill=X)
+        self.label = Label(self.frame)
+        self.label.pack()
+        self.canvas = Canvas(self.frame)
+        self.canvas.pack()
+        self.report = Label(self.frame)
+        self.report.pack()
+        self.left = Line(self.canvas, 0, 0, 0, 0)
+        self.right = Line(self.canvas, 0, 0, 0, 0)
+        self.pivot = Line(self.canvas, 0, 0, 0, 0)
+        self.items = []
+        self.size = self.maxvalue = 0
+        if data:
+            self.setdata(data)
 
     def setdata(self, data):
-	olditems = self.items
-	self.items = []
-	for item in olditems:
-	    item.delete()
-	self.size = len(data)
-	self.maxvalue = max(data)
-	self.canvas.config(width=(self.size+1)*XGRID,
-			   height=(self.maxvalue+1)*YGRID)
-	for i in range(self.size):
-	    self.items.append(ArrayItem(self, i, data[i]))
-	self.reset("Sort demo, size %d" % self.size)
+        olditems = self.items
+        self.items = []
+        for item in olditems:
+            item.delete()
+        self.size = len(data)
+        self.maxvalue = max(data)
+        self.canvas.config(width=(self.size+1)*XGRID,
+                           height=(self.maxvalue+1)*YGRID)
+        for i in range(self.size):
+            self.items.append(ArrayItem(self, i, data[i]))
+        self.reset("Sort demo, size %d" % self.size)
 
     speed = "normal"
 
     def setspeed(self, speed):
-	self.speed = speed
+        self.speed = speed
 
     def destroy(self):
-	self.frame.destroy()
+        self.frame.destroy()
 
     in_mainloop = 0
     stop_mainloop = 0
 
     def cancel(self):
-	self.stop_mainloop = 1
-	if self.in_mainloop:
-	    self.master.quit()
+        self.stop_mainloop = 1
+        if self.in_mainloop:
+            self.master.quit()
 
     def step(self):
-	if self.in_mainloop:
-	    self.master.quit()
+        if self.in_mainloop:
+            self.master.quit()
 
-    Cancelled = "Array.Cancelled"	# Exception
+    Cancelled = "Array.Cancelled"       # Exception
 
     def wait(self, msecs):
-	if self.speed == "fastest":
-	    msecs = 0
-	elif self.speed == "fast":
-	    msecs = msecs/10
-	elif self.speed == "single-step":
-	    msecs = 1000000000
-	if not self.stop_mainloop:
-	    self.master.update()
-	    id = self.master.after(msecs, self.master.quit)
-	    self.in_mainloop = 1
-	    self.master.mainloop()
-	    self.master.after_cancel(id)
-	    self.in_mainloop = 0
-	if self.stop_mainloop:
-	    self.stop_mainloop = 0
-	    self.message("Cancelled")
-	    raise Array.Cancelled
+        if self.speed == "fastest":
+            msecs = 0
+        elif self.speed == "fast":
+            msecs = msecs/10
+        elif self.speed == "single-step":
+            msecs = 1000000000
+        if not self.stop_mainloop:
+            self.master.update()
+            id = self.master.after(msecs, self.master.quit)
+            self.in_mainloop = 1
+            self.master.mainloop()
+            self.master.after_cancel(id)
+            self.in_mainloop = 0
+        if self.stop_mainloop:
+            self.stop_mainloop = 0
+            self.message("Cancelled")
+            raise Array.Cancelled
 
     def getsize(self):
-	return self.size
+        return self.size
 
     def show_partition(self, first, last):
-	for i in range(self.size):
-	    item = self.items[i]
-	    if first <= i < last:
-		item.item.config(fill='red')
-	    else:
-		item.item.config(fill='orange')
-	self.hide_left_right_pivot()
+        for i in range(self.size):
+            item = self.items[i]
+            if first <= i < last:
+                item.item.config(fill='red')
+            else:
+                item.item.config(fill='orange')
+        self.hide_left_right_pivot()
 
     def hide_partition(self):
-	for i in range(self.size):
-	    item = self.items[i]
-	    item.item.config(fill='red')
-	self.hide_left_right_pivot()
+        for i in range(self.size):
+            item = self.items[i]
+            item.item.config(fill='red')
+        self.hide_left_right_pivot()
 
     def show_left(self, left):
-	if not 0 <= left < self.size:
-	    self.hide_left()
-	    return
-	x1, y1, x2, y2 = self.items[left].position()
-##	top, bot = HIRO
-	self.left.coords([(x1-2, 0), (x1-2, 9999)])
-	self.master.update()
+        if not 0 <= left < self.size:
+            self.hide_left()
+            return
+        x1, y1, x2, y2 = self.items[left].position()
+##      top, bot = HIRO
+        self.left.coords([(x1-2, 0), (x1-2, 9999)])
+        self.master.update()
 
     def show_right(self, right):
-	if not 0 <= right < self.size:
-	    self.hide_right()
-	    return
-	x1, y1, x2, y2 = self.items[right].position()
-	self.right.coords(((x2+2, 0), (x2+2, 9999)))
-	self.master.update()
+        if not 0 <= right < self.size:
+            self.hide_right()
+            return
+        x1, y1, x2, y2 = self.items[right].position()
+        self.right.coords(((x2+2, 0), (x2+2, 9999)))
+        self.master.update()
 
     def hide_left_right_pivot(self):
-	self.hide_left()
-	self.hide_right()
-	self.hide_pivot()
+        self.hide_left()
+        self.hide_right()
+        self.hide_pivot()
 
     def hide_left(self):
-	self.left.coords(((0, 0), (0, 0)))
+        self.left.coords(((0, 0), (0, 0)))
 
     def hide_right(self):
-	self.right.coords(((0, 0), (0, 0)))
+        self.right.coords(((0, 0), (0, 0)))
 
     def show_pivot(self, pivot):
-	x1, y1, x2, y2 = self.items[pivot].position()
-	self.pivot.coords(((0, y1-2), (9999, y1-2)))
+        x1, y1, x2, y2 = self.items[pivot].position()
+        self.pivot.coords(((0, y1-2), (9999, y1-2)))
 
     def hide_pivot(self):
-	self.pivot.coords(((0, 0), (0, 0)))
+        self.pivot.coords(((0, 0), (0, 0)))
 
     def swap(self, i, j):
-	if i == j: return
-	self.countswap()
-	item = self.items[i]
-	other = self.items[j]
-	self.items[i], self.items[j] = other, item
-	item.swapwith(other)
+        if i == j: return
+        self.countswap()
+        item = self.items[i]
+        other = self.items[j]
+        self.items[i], self.items[j] = other, item
+        item.swapwith(other)
 
     def compare(self, i, j):
-	self.countcompare()
-	item = self.items[i]
-	other = self.items[j]
-	return item.compareto(other)
+        self.countcompare()
+        item = self.items[i]
+        other = self.items[j]
+        return item.compareto(other)
 
     def reset(self, msg):
-	self.ncompares = 0
-	self.nswaps = 0
-	self.message(msg)
-	self.updatereport()
-	self.hide_partition()
+        self.ncompares = 0
+        self.nswaps = 0
+        self.message(msg)
+        self.updatereport()
+        self.hide_partition()
 
     def message(self, msg):
-	self.label.config(text=msg)
+        self.label.config(text=msg)
 
     def countswap(self):
-	self.nswaps = self.nswaps + 1
-	self.updatereport()
+        self.nswaps = self.nswaps + 1
+        self.updatereport()
 
     def countcompare(self):
-	self.ncompares = self.ncompares + 1
-	self.updatereport()
+        self.ncompares = self.ncompares + 1
+        self.updatereport()
 
     def updatereport(self):
-	text = "%d cmps, %d swaps" % (self.ncompares, self.nswaps)
-	self.report.config(text=text)
+        text = "%d cmps, %d swaps" % (self.ncompares, self.nswaps)
+        self.report.config(text=text)
 
 
 class ArrayItem:
 
     def __init__(self, array, index, value):
-	self.array = array
-	self.index = index
-	self.value = value
-	x1, y1, x2, y2 = self.position()
-	self.item = Rectangle(array.canvas, x1, y1, x2, y2,
-			      fill='red', outline='black', width=1)
-	self.item.bind('<Button-1>', self.mouse_down)
-	self.item.bind('<Button1-Motion>', self.mouse_move)
-	self.item.bind('<ButtonRelease-1>', self.mouse_up)
+        self.array = array
+        self.index = index
+        self.value = value
+        x1, y1, x2, y2 = self.position()
+        self.item = Rectangle(array.canvas, x1, y1, x2, y2,
+                              fill='red', outline='black', width=1)
+        self.item.bind('<Button-1>', self.mouse_down)
+        self.item.bind('<Button1-Motion>', self.mouse_move)
+        self.item.bind('<ButtonRelease-1>', self.mouse_up)
 
     def delete(self):
-	item = self.item
-	self.array = None
-	self.item = None
-	item.delete()
+        item = self.item
+        self.array = None
+        self.item = None
+        item.delete()
 
     def mouse_down(self, event):
-	self.lastx = event.x
-	self.lasty = event.y
-	self.origx = event.x
-	self.origy = event.y
-	self.item.tkraise()
-    	
+        self.lastx = event.x
+        self.lasty = event.y
+        self.origx = event.x
+        self.origy = event.y
+        self.item.tkraise()
+
     def mouse_move(self, event):
-	self.item.move(event.x - self.lastx, event.y - self.lasty)
-	self.lastx = event.x
-	self.lasty = event.y
+        self.item.move(event.x - self.lastx, event.y - self.lasty)
+        self.lastx = event.x
+        self.lasty = event.y
 
     def mouse_up(self, event):
-	i = self.nearestindex(event.x)
-	if i >= self.array.getsize():
-	    i = self.array.getsize() - 1
-	if i < 0:
-	    i = 0
-	other = self.array.items[i]
-	here = self.index
-	self.array.items[here], self.array.items[i] = other, self
-	self.index = i
-	x1, y1, x2, y2 = self.position()
-	self.item.coords(((x1, y1), (x2, y2)))
-	other.setindex(here)
+        i = self.nearestindex(event.x)
+        if i >= self.array.getsize():
+            i = self.array.getsize() - 1
+        if i < 0:
+            i = 0
+        other = self.array.items[i]
+        here = self.index
+        self.array.items[here], self.array.items[i] = other, self
+        self.index = i
+        x1, y1, x2, y2 = self.position()
+        self.item.coords(((x1, y1), (x2, y2)))
+        other.setindex(here)
 
     def setindex(self, index):
-	nsteps = steps(self.index, index)
-	if not nsteps: return
-	if self.array.speed == "fastest":
-	    nsteps = 0
-	oldpts = self.position()
-	self.index = index
-	newpts = self.position()
-	trajectory = interpolate(oldpts, newpts, nsteps)
-	self.item.tkraise()
-	for pts in trajectory:
-	    self.item.coords((pts[:2], pts[2:]))
-	    self.array.wait(50)
+        nsteps = steps(self.index, index)
+        if not nsteps: return
+        if self.array.speed == "fastest":
+            nsteps = 0
+        oldpts = self.position()
+        self.index = index
+        newpts = self.position()
+        trajectory = interpolate(oldpts, newpts, nsteps)
+        self.item.tkraise()
+        for pts in trajectory:
+            self.item.coords((pts[:2], pts[2:]))
+            self.array.wait(50)
 
     def swapwith(self, other):
-	nsteps = steps(self.index, other.index)
-	if not nsteps: return
-	if self.array.speed == "fastest":
-	    nsteps = 0
-	myoldpts = self.position()
-	otheroldpts = other.position()
-	self.index, other.index = other.index, self.index
-	mynewpts = self.position()
-	othernewpts = other.position()
-	myfill = self.item['fill']
-	otherfill = other.item['fill']
-	self.item.config(fill='green')
-	other.item.config(fill='yellow')
-	self.array.master.update()
-	if self.array.speed == "single-step":
-	    self.item.coords((mynewpts[:2], mynewpts[2:]))
-	    other.item.coords((othernewpts[:2], othernewpts[2:]))
-	    self.array.master.update()
-	    self.item.config(fill=myfill)
-	    other.item.config(fill=otherfill)
-	    self.array.wait(0)
-	    return
-	mytrajectory = interpolate(myoldpts, mynewpts, nsteps)
-	othertrajectory = interpolate(otheroldpts, othernewpts, nsteps)
-	if self.value > other.value:
-	    self.item.tkraise()
-	    other.item.tkraise()
-	else:
-	    other.item.tkraise()
-	    self.item.tkraise()
-	try:
-	    for i in range(len(mytrajectory)):
-		mypts = mytrajectory[i]
-		otherpts = othertrajectory[i]
-		self.item.coords((mypts[:2], mypts[2:]))
-		other.item.coords((otherpts[:2], otherpts[2:]))
-		self.array.wait(50)
-	finally:
-	    mypts = mytrajectory[-1]
-	    otherpts = othertrajectory[-1]
-	    self.item.coords((mypts[:2], mypts[2:]))
-	    other.item.coords((otherpts[:2], otherpts[2:]))
-	    self.item.config(fill=myfill)
-	    other.item.config(fill=otherfill)
+        nsteps = steps(self.index, other.index)
+        if not nsteps: return
+        if self.array.speed == "fastest":
+            nsteps = 0
+        myoldpts = self.position()
+        otheroldpts = other.position()
+        self.index, other.index = other.index, self.index
+        mynewpts = self.position()
+        othernewpts = other.position()
+        myfill = self.item['fill']
+        otherfill = other.item['fill']
+        self.item.config(fill='green')
+        other.item.config(fill='yellow')
+        self.array.master.update()
+        if self.array.speed == "single-step":
+            self.item.coords((mynewpts[:2], mynewpts[2:]))
+            other.item.coords((othernewpts[:2], othernewpts[2:]))
+            self.array.master.update()
+            self.item.config(fill=myfill)
+            other.item.config(fill=otherfill)
+            self.array.wait(0)
+            return
+        mytrajectory = interpolate(myoldpts, mynewpts, nsteps)
+        othertrajectory = interpolate(otheroldpts, othernewpts, nsteps)
+        if self.value > other.value:
+            self.item.tkraise()
+            other.item.tkraise()
+        else:
+            other.item.tkraise()
+            self.item.tkraise()
+        try:
+            for i in range(len(mytrajectory)):
+                mypts = mytrajectory[i]
+                otherpts = othertrajectory[i]
+                self.item.coords((mypts[:2], mypts[2:]))
+                other.item.coords((otherpts[:2], otherpts[2:]))
+                self.array.wait(50)
+        finally:
+            mypts = mytrajectory[-1]
+            otherpts = othertrajectory[-1]
+            self.item.coords((mypts[:2], mypts[2:]))
+            other.item.coords((otherpts[:2], otherpts[2:]))
+            self.item.config(fill=myfill)
+            other.item.config(fill=otherfill)
 
     def compareto(self, other):
-	myfill = self.item['fill']
-	otherfill = other.item['fill']
-	outcome = cmp(self.value, other.value)
-	if outcome < 0:
-	    myflash = 'white'
-	    otherflash = 'black'
-	elif outcome > 0:
-	    myflash = 'black'
-	    otherflash = 'white'
-	else:
-	    myflash = otherflash = 'grey'
-	try:
-	    self.item.config(fill=myflash)
-	    other.item.config(fill=otherflash)
-	    self.array.wait(500)
-	finally:
-	    self.item.config(fill=myfill)
-	    other.item.config(fill=otherfill)
-	return outcome
+        myfill = self.item['fill']
+        otherfill = other.item['fill']
+        outcome = cmp(self.value, other.value)
+        if outcome < 0:
+            myflash = 'white'
+            otherflash = 'black'
+        elif outcome > 0:
+            myflash = 'black'
+            otherflash = 'white'
+        else:
+            myflash = otherflash = 'grey'
+        try:
+            self.item.config(fill=myflash)
+            other.item.config(fill=otherflash)
+            self.array.wait(500)
+        finally:
+            self.item.config(fill=myfill)
+            other.item.config(fill=otherfill)
+        return outcome
 
     def position(self):
-	x1 = (self.index+1)*XGRID - WIDTH/2
-	x2 = x1+WIDTH
-	y2 = (self.array.maxvalue+1)*YGRID
-	y1 = y2 - (self.value)*YGRID
-	return x1, y1, x2, y2
+        x1 = (self.index+1)*XGRID - WIDTH/2
+        x2 = x1+WIDTH
+        y2 = (self.array.maxvalue+1)*YGRID
+        y1 = y2 - (self.value)*YGRID
+        return x1, y1, x2, y2
 
     def nearestindex(self, x):
-	return int(round(float(x)/XGRID)) - 1
+        return int(round(float(x)/XGRID)) - 1
 
 
 # Subroutines that don't need an object
@@ -335,22 +335,22 @@ class ArrayItem:
 def steps(here, there):
     nsteps = abs(here - there)
     if nsteps <= 3:
-	nsteps = nsteps * 3
+        nsteps = nsteps * 3
     elif nsteps <= 5:
-	nsteps = nsteps * 2
+        nsteps = nsteps * 2
     elif nsteps > 10:
-	nsteps = 10
+        nsteps = 10
     return nsteps
 
 def interpolate(oldpts, newpts, n):
     if len(oldpts) != len(newpts):
-	raise ValueError, "can't interpolate arrays of different length"
+        raise ValueError, "can't interpolate arrays of different length"
     pts = [0]*len(oldpts)
     res = [tuple(oldpts)]
     for i in range(1, n):
-	for k in range(len(pts)):
-	    pts[k] = oldpts[k] + (newpts[k] - oldpts[k])*i/n
-	res.append(tuple(pts))
+        for k in range(len(pts)):
+            pts[k] = oldpts[k] + (newpts[k] - oldpts[k])*i/n
+        res.append(tuple(pts))
     res.append(tuple(newpts))
     return res
 
@@ -371,110 +371,110 @@ def randomize(array):
     array.reset("Randomizing")
     n = array.getsize()
     for i in range(n):
-	j = random.randint(0, n-1)
-	array.swap(i, j)
+        j = random.randint(0, n-1)
+        array.swap(i, j)
     array.message("Randomized")
 
 def insertionsort(array):
     size = array.getsize()
     array.reset("Insertion sort")
     for i in range(1, size):
-	j = i-1
-	while j >= 0:
-	    if array.compare(j, j+1) <= 0:
-		break
-	    array.swap(j, j+1)
-	    j = j-1
+        j = i-1
+        while j >= 0:
+            if array.compare(j, j+1) <= 0:
+                break
+            array.swap(j, j+1)
+            j = j-1
     array.message("Sorted")
 
 def selectionsort(array):
     size = array.getsize()
     array.reset("Selection sort")
     try:
-	for i in range(size):
-	    array.show_partition(i, size)
-	    for j in range(i+1, size):
-		if array.compare(i, j) > 0:
-		    array.swap(i, j)
-	array.message("Sorted")
+        for i in range(size):
+            array.show_partition(i, size)
+            for j in range(i+1, size):
+                if array.compare(i, j) > 0:
+                    array.swap(i, j)
+        array.message("Sorted")
     finally:
-	array.hide_partition()
+        array.hide_partition()
 
 def bubblesort(array):
     size = array.getsize()
     array.reset("Bubble sort")
     for i in range(size):
-	for j in range(1, size):
-	    if array.compare(j-1, j) > 0:
-		array.swap(j-1, j)
+        for j in range(1, size):
+            if array.compare(j-1, j) > 0:
+                array.swap(j-1, j)
     array.message("Sorted")
 
 def quicksort(array):
     size = array.getsize()
     array.reset("Quicksort")
     try:
-	stack = [(0, size)]
-	while stack:
-	    first, last = stack[-1]
-	    del stack[-1]
-	    array.show_partition(first, last)
-	    if last-first < 5:
-		array.message("Insertion sort")
-		for i in range(first+1, last):
-		    j = i-1
-		    while j >= first:
-			if array.compare(j, j+1) <= 0:
-			    break
-			array.swap(j, j+1)
-			j = j-1
-		continue
-	    array.message("Choosing pivot")
-	    j, i, k = first, (first+last)/2, last-1
-	    if array.compare(k, i) < 0:
-		array.swap(k, i)
-	    if array.compare(k, j) < 0:
-		array.swap(k, j)
-	    if array.compare(j, i) < 0:
-		array.swap(j, i)
-	    pivot = j
-	    array.show_pivot(pivot)
-	    array.message("Pivot at left of partition")
-	    array.wait(1000)
-	    left = first
-	    right = last
-	    while 1:
-		array.message("Sweep right pointer")
-		right = right-1
-		array.show_right(right)
-		while right > first and array.compare(right, pivot) >= 0:
-		    right = right-1
-		    array.show_right(right)
-		array.message("Sweep left pointer")
-		left = left+1
-		array.show_left(left)
-		while left < last and array.compare(left, pivot) <= 0:
-		    left = left+1
-		    array.show_left(left)
-		if left > right:
-		    array.message("End of partition")
-		    break
-		array.message("Swap items")
-		array.swap(left, right)
-	    array.message("Swap pivot back")
-	    array.swap(pivot, right)
-	    n1 = right-first
-	    n2 = last-left
-	    if n1 > 1: stack.append((first, right))
-	    if n2 > 1: stack.append((left, last))
-	array.message("Sorted")
+        stack = [(0, size)]
+        while stack:
+            first, last = stack[-1]
+            del stack[-1]
+            array.show_partition(first, last)
+            if last-first < 5:
+                array.message("Insertion sort")
+                for i in range(first+1, last):
+                    j = i-1
+                    while j >= first:
+                        if array.compare(j, j+1) <= 0:
+                            break
+                        array.swap(j, j+1)
+                        j = j-1
+                continue
+            array.message("Choosing pivot")
+            j, i, k = first, (first+last)/2, last-1
+            if array.compare(k, i) < 0:
+                array.swap(k, i)
+            if array.compare(k, j) < 0:
+                array.swap(k, j)
+            if array.compare(j, i) < 0:
+                array.swap(j, i)
+            pivot = j
+            array.show_pivot(pivot)
+            array.message("Pivot at left of partition")
+            array.wait(1000)
+            left = first
+            right = last
+            while 1:
+                array.message("Sweep right pointer")
+                right = right-1
+                array.show_right(right)
+                while right > first and array.compare(right, pivot) >= 0:
+                    right = right-1
+                    array.show_right(right)
+                array.message("Sweep left pointer")
+                left = left+1
+                array.show_left(left)
+                while left < last and array.compare(left, pivot) <= 0:
+                    left = left+1
+                    array.show_left(left)
+                if left > right:
+                    array.message("End of partition")
+                    break
+                array.message("Swap items")
+                array.swap(left, right)
+            array.message("Swap pivot back")
+            array.swap(pivot, right)
+            n1 = right-first
+            n2 = last-left
+            if n1 > 1: stack.append((first, right))
+            if n2 > 1: stack.append((left, last))
+        array.message("Sorted")
     finally:
-	array.hide_partition()
+        array.hide_partition()
 
 def demosort(array):
     while 1:
-	for alg in [quicksort, insertionsort, selectionsort, bubblesort]:
-	    randomize(array)
-	    alg(array)
+        for alg in [quicksort, insertionsort, selectionsort, bubblesort]:
+            randomize(array)
+            alg(array)
 
 
 # Sort demo class -- usable as a Grail applet
@@ -482,144 +482,144 @@ def demosort(array):
 class SortDemo:
 
     def __init__(self, master, size=15):
-	self.master = master
-	self.size = size
-	self.busy = 0
-	self.array = Array(self.master)
-
-	self.botframe = Frame(master)
-	self.botframe.pack(side=BOTTOM)
-	self.botleftframe = Frame(self.botframe)
-	self.botleftframe.pack(side=LEFT, fill=Y)
-	self.botrightframe = Frame(self.botframe)
-	self.botrightframe.pack(side=RIGHT, fill=Y)
-
-	self.b_qsort = Button(self.botleftframe,
-			      text="Quicksort", command=self.c_qsort)
-	self.b_qsort.pack(fill=X)
-	self.b_isort = Button(self.botleftframe,
-			      text="Insertion sort", command=self.c_isort)
-	self.b_isort.pack(fill=X)
-	self.b_ssort = Button(self.botleftframe,
-			      text="Selection sort", command=self.c_ssort)
-	self.b_ssort.pack(fill=X)
-	self.b_bsort = Button(self.botleftframe,
-			      text="Bubble sort", command=self.c_bsort)
-	self.b_bsort.pack(fill=X)
-
-	# Terrible hack to overcome limitation of OptionMenu...
-	class MyIntVar(IntVar):
-	    def __init__(self, master, demo):
-		self.demo = demo
-		IntVar.__init__(self, master)
-	    def set(self, value):
-		IntVar.set(self, value)
-		if str(value) != '0':
-		    self.demo.resize(value)
-
-	self.v_size = MyIntVar(self.master, self)
-	self.v_size.set(size)
-	sizes = [1, 2, 3, 4] + range(5, 55, 5)
-	if self.size not in sizes:
-	    sizes.append(self.size)
-	    sizes.sort()
-	self.m_size = apply(OptionMenu,
-			    (self.botleftframe, self.v_size) + tuple(sizes))
-	self.m_size.pack(fill=X)
-	
-	self.v_speed = StringVar(self.master)
-	self.v_speed.set("normal")
-	self.m_speed = OptionMenu(self.botleftframe, self.v_speed,
-				  "single-step", "normal", "fast", "fastest")
-	self.m_speed.pack(fill=X)
-	
-	self.b_step = Button(self.botleftframe,
-			     text="Step", command=self.c_step)
-	self.b_step.pack(fill=X)
-	
-	self.b_randomize = Button(self.botrightframe,
-				  text="Randomize", command=self.c_randomize)
-	self.b_randomize.pack(fill=X)
-	self.b_uniform = Button(self.botrightframe,
-				  text="Uniform", command=self.c_uniform)
-	self.b_uniform.pack(fill=X)
-	self.b_distinct = Button(self.botrightframe,
-				  text="Distinct", command=self.c_distinct)
-	self.b_distinct.pack(fill=X)
-	self.b_demo = Button(self.botrightframe,
-			     text="Demo", command=self.c_demo)
-	self.b_demo.pack(fill=X)
- 	self.b_cancel = Button(self.botrightframe,
-			       text="Cancel", command=self.c_cancel)
- 	self.b_cancel.pack(fill=X)
-	self.b_cancel.config(state=DISABLED)
-	self.b_quit = Button(self.botrightframe,
-			     text="Quit", command=self.c_quit)
-	self.b_quit.pack(fill=X)
+        self.master = master
+        self.size = size
+        self.busy = 0
+        self.array = Array(self.master)
+
+        self.botframe = Frame(master)
+        self.botframe.pack(side=BOTTOM)
+        self.botleftframe = Frame(self.botframe)
+        self.botleftframe.pack(side=LEFT, fill=Y)
+        self.botrightframe = Frame(self.botframe)
+        self.botrightframe.pack(side=RIGHT, fill=Y)
+
+        self.b_qsort = Button(self.botleftframe,
+                              text="Quicksort", command=self.c_qsort)
+        self.b_qsort.pack(fill=X)
+        self.b_isort = Button(self.botleftframe,
+                              text="Insertion sort", command=self.c_isort)
+        self.b_isort.pack(fill=X)
+        self.b_ssort = Button(self.botleftframe,
+                              text="Selection sort", command=self.c_ssort)
+        self.b_ssort.pack(fill=X)
+        self.b_bsort = Button(self.botleftframe,
+                              text="Bubble sort", command=self.c_bsort)
+        self.b_bsort.pack(fill=X)
+
+        # Terrible hack to overcome limitation of OptionMenu...
+        class MyIntVar(IntVar):
+            def __init__(self, master, demo):
+                self.demo = demo
+                IntVar.__init__(self, master)
+            def set(self, value):
+                IntVar.set(self, value)
+                if str(value) != '0':
+                    self.demo.resize(value)
+
+        self.v_size = MyIntVar(self.master, self)
+        self.v_size.set(size)
+        sizes = [1, 2, 3, 4] + range(5, 55, 5)
+        if self.size not in sizes:
+            sizes.append(self.size)
+            sizes.sort()
+        self.m_size = apply(OptionMenu,
+                            (self.botleftframe, self.v_size) + tuple(sizes))
+        self.m_size.pack(fill=X)
+
+        self.v_speed = StringVar(self.master)
+        self.v_speed.set("normal")
+        self.m_speed = OptionMenu(self.botleftframe, self.v_speed,
+                                  "single-step", "normal", "fast", "fastest")
+        self.m_speed.pack(fill=X)
+
+        self.b_step = Button(self.botleftframe,
+                             text="Step", command=self.c_step)
+        self.b_step.pack(fill=X)
+
+        self.b_randomize = Button(self.botrightframe,
+                                  text="Randomize", command=self.c_randomize)
+        self.b_randomize.pack(fill=X)
+        self.b_uniform = Button(self.botrightframe,
+                                  text="Uniform", command=self.c_uniform)
+        self.b_uniform.pack(fill=X)
+        self.b_distinct = Button(self.botrightframe,
+                                  text="Distinct", command=self.c_distinct)
+        self.b_distinct.pack(fill=X)
+        self.b_demo = Button(self.botrightframe,
+                             text="Demo", command=self.c_demo)
+        self.b_demo.pack(fill=X)
+        self.b_cancel = Button(self.botrightframe,
+                               text="Cancel", command=self.c_cancel)
+        self.b_cancel.pack(fill=X)
+        self.b_cancel.config(state=DISABLED)
+        self.b_quit = Button(self.botrightframe,
+                             text="Quit", command=self.c_quit)
+        self.b_quit.pack(fill=X)
 
     def resize(self, newsize):
-	if self.busy:
-	    self.master.bell()
-	    return
-	self.size = newsize
-	self.array.setdata(range(1, self.size+1))
+        if self.busy:
+            self.master.bell()
+            return
+        self.size = newsize
+        self.array.setdata(range(1, self.size+1))
 
     def c_qsort(self):
-	self.run(quicksort)
+        self.run(quicksort)
 
     def c_isort(self):
-	self.run(insertionsort)
+        self.run(insertionsort)
 
     def c_ssort(self):
-	self.run(selectionsort)
+        self.run(selectionsort)
 
     def c_bsort(self):
-	self.run(bubblesort)
+        self.run(bubblesort)
 
     def c_demo(self):
-	self.run(demosort)
+        self.run(demosort)
 
     def c_randomize(self):
-	self.run(randomize)
+        self.run(randomize)
 
     def c_uniform(self):
-	self.run(uniform)
+        self.run(uniform)
 
     def c_distinct(self):
-	self.run(distinct)
+        self.run(distinct)
 
     def run(self, func):
-	if self.busy:
-	    self.master.bell()
-	    return
-	self.busy = 1
-	self.array.setspeed(self.v_speed.get())
-	self.b_cancel.config(state=NORMAL)
-	try:
-	    func(self.array)
-	except Array.Cancelled:
-	    pass
-	self.b_cancel.config(state=DISABLED)
-	self.busy = 0
+        if self.busy:
+            self.master.bell()
+            return
+        self.busy = 1
+        self.array.setspeed(self.v_speed.get())
+        self.b_cancel.config(state=NORMAL)
+        try:
+            func(self.array)
+        except Array.Cancelled:
+            pass
+        self.b_cancel.config(state=DISABLED)
+        self.busy = 0
 
     def c_cancel(self):
-	if not self.busy:
-	    self.master.bell()
-	    return
-	self.array.cancel()
+        if not self.busy:
+            self.master.bell()
+            return
+        self.array.cancel()
 
     def c_step(self):
-	if not self.busy:
-	    self.master.bell()
-	    return
-	self.v_speed.set("single-step")
-	self.array.setspeed("single-step")
-	self.array.step()
+        if not self.busy:
+            self.master.bell()
+            return
+        self.v_speed.set("single-step")
+        self.array.setspeed("single-step")
+        self.array.step()
 
     def c_quit(self):
-	if self.busy:
-	    self.array.cancel()
-	self.master.after_idle(self.master.quit)
+        if self.busy:
+            self.array.cancel()
+        self.master.after_idle(self.master.quit)
 
 
 # Main program -- for stand-alone operation outside Grail
diff --git a/Demo/tkinter/guido/ss1.py b/Demo/tkinter/guido/ss1.py
index 95b3d81..8935475 100644
--- a/Demo/tkinter/guido/ss1.py
+++ b/Demo/tkinter/guido/ss1.py
@@ -315,7 +315,7 @@ class BaseCell:
     """Abstract base class for sheet cells.
 
     Subclasses may but needn't provide the following APIs:
-    
+
     cell.reset() -- prepare for recalculation
     cell.recalc(rexec) -> value -- recalculate formula
     cell.format() -> (value, alignment) -- return formatted value
diff --git a/Demo/tkinter/guido/svkill.py b/Demo/tkinter/guido/svkill.py
index 1c54e4b..69f7f3b 100755
--- a/Demo/tkinter/guido/svkill.py
+++ b/Demo/tkinter/guido/svkill.py
@@ -5,7 +5,7 @@
 from Tkinter import *
 
 if TkVersion < 4.0:
-	raise ImportError, "This version of svkill requires Tk 4.0 or later"
+    raise ImportError, "This version of svkill requires Tk 4.0 or later"
 
 from string import splitfields
 from string import split
@@ -15,114 +15,114 @@ import os
 user = os.environ['LOGNAME']
 
 class BarButton(Menubutton):
-	def __init__(self, master=None, **cnf):
-		apply(Menubutton.__init__, (self, master), cnf)
-		self.pack(side=LEFT)
-		self.menu = Menu(self, name='menu')
-		self['menu'] = self.menu		
+    def __init__(self, master=None, **cnf):
+        apply(Menubutton.__init__, (self, master), cnf)
+        self.pack(side=LEFT)
+        self.menu = Menu(self, name='menu')
+        self['menu'] = self.menu
 
 class Kill(Frame):
-	# List of (name, option, pid_column)
-	view_list = [
-		('Default', ''),
-		('Every (-e)', '-e'),
-		('Non process group leaders (-d)', '-d'),
-		('Non leaders with tty (-a)', '-a'),
-		('For this user (-u %s)' % user, '-u %s' % user),
-		]
-	format_list = [
-		('Default', '', 0),
-		('Long (-l)', '-l', 3),
-		('Full (-f)', '-f', 1),
-		('Full Long (-f -l)', '-l -f', 3),
-		('Session and group ID (-j)', '-j', 0),
-		('Scheduler properties (-c)', '-c', 0),
-		]
-	def kill(self, selected):
-		c = self.format_list[self.format.get()][2]
-		pid = split(selected)[c]
-		os.system('kill -9 ' + pid)
-		self.do_update()
-	def do_update(self):
-		format = self.format_list[self.format.get()][1]
-		view = self.view_list[self.view.get()][1]
-		s = commands.getoutput('ps %s %s' % (view, format))
-		list = splitfields(s, '\n')
-		self.header.set(list[0] + '          ')
-		del list[0]
-		self.frame.list.delete(0, AtEnd())
-		for line in list:
-			self.frame.list.insert(0, line)
-	def do_motion(self, e):
-		e.widget.select_clear('0', 'end')
-		e.widget.select_set(e.widget.nearest(e.y))
-	def do_leave(self, e):
-		e.widget.select_clear('0', 'end')
-	def do_1(self, e):
-		self.kill(e.widget.get(e.widget.nearest(e.y)))
-	def __init__(self, master=None, **cnf):
-		apply(Frame.__init__, (self, master), cnf)
-		self.pack(expand=1, fill=BOTH)
-		self.bar = Frame(self, name='bar', relief=RAISED,
-				 borderwidth=2)
-		self.bar.pack(fill=X)
-		self.bar.file = BarButton(self.bar, text='File')
-		self.bar.file.menu.add_command(
-			label='Quit', command=self.quit)
-		self.bar.view = BarButton(self.bar, text='View')
-		self.bar.format = BarButton(self.bar, text='Format')
-		self.view = IntVar(self)
-		self.view.set(0)
-		self.format = IntVar(self)
-		self.format.set(0)
-		for num in range(len(self.view_list)):
-			label, option = self.view_list[num]
-			self.bar.view.menu.add_radiobutton(
-				label=label,
-				command=self.do_update,
-				variable=self.view,
-				value=num)
-		for num in range(len(self.format_list)):
-			label, option, col = self.format_list[num]
-			self.bar.format.menu.add_radiobutton(
-				label=label,
-				command=self.do_update,
-				variable=self.format,
-				value=num)
-		self.bar.tk_menuBar(self.bar.file,
-				    self.bar.view,
-				    self.bar.format)
-		self.frame = Frame(self, relief=RAISED, borderwidth=2)
-		self.frame.pack(expand=1, fill=BOTH)
-		self.header = StringVar(self)
-		self.frame.label = Label(
-			self.frame, relief=FLAT, anchor=NW, borderwidth=0,
-			font='*-Courier-Bold-R-Normal-*-120-*',
-			textvariable=self.header)
-		self.frame.label.pack(fill=Y, anchor=W)
-		self.frame.vscroll = Scrollbar(self.frame, orient=VERTICAL)
-		self.frame.list = Listbox(
-			self.frame, 
-			relief=SUNKEN,
-			font='*-Courier-Medium-R-Normal-*-120-*',
-			width=40, height=10,
-			selectbackground='#eed5b7',
-			selectborderwidth=0,
-			selectmode=BROWSE,
-			yscroll=self.frame.vscroll.set)
-		self.frame.vscroll['command'] = self.frame.list.yview
-		self.frame.vscroll.pack(side=RIGHT, fill=Y)
-		self.frame.list.pack(expand=1, fill=BOTH)
-		self.update = Button(self, text='Update',
-				     command=self.do_update)
-		self.update.pack(fill=X)
-		self.frame.list.bind('<Motion>', self.do_motion)
-		self.frame.list.bind('<Leave>', self.do_leave)
-		self.frame.list.bind('<1>', self.do_1)
-		self.do_update()
+    # List of (name, option, pid_column)
+    view_list = [
+            ('Default', ''),
+            ('Every (-e)', '-e'),
+            ('Non process group leaders (-d)', '-d'),
+            ('Non leaders with tty (-a)', '-a'),
+            ('For this user (-u %s)' % user, '-u %s' % user),
+            ]
+    format_list = [
+            ('Default', '', 0),
+            ('Long (-l)', '-l', 3),
+            ('Full (-f)', '-f', 1),
+            ('Full Long (-f -l)', '-l -f', 3),
+            ('Session and group ID (-j)', '-j', 0),
+            ('Scheduler properties (-c)', '-c', 0),
+            ]
+    def kill(self, selected):
+        c = self.format_list[self.format.get()][2]
+        pid = split(selected)[c]
+        os.system('kill -9 ' + pid)
+        self.do_update()
+    def do_update(self):
+        format = self.format_list[self.format.get()][1]
+        view = self.view_list[self.view.get()][1]
+        s = commands.getoutput('ps %s %s' % (view, format))
+        list = splitfields(s, '\n')
+        self.header.set(list[0] + '          ')
+        del list[0]
+        self.frame.list.delete(0, AtEnd())
+        for line in list:
+            self.frame.list.insert(0, line)
+    def do_motion(self, e):
+        e.widget.select_clear('0', 'end')
+        e.widget.select_set(e.widget.nearest(e.y))
+    def do_leave(self, e):
+        e.widget.select_clear('0', 'end')
+    def do_1(self, e):
+        self.kill(e.widget.get(e.widget.nearest(e.y)))
+    def __init__(self, master=None, **cnf):
+        apply(Frame.__init__, (self, master), cnf)
+        self.pack(expand=1, fill=BOTH)
+        self.bar = Frame(self, name='bar', relief=RAISED,
+                         borderwidth=2)
+        self.bar.pack(fill=X)
+        self.bar.file = BarButton(self.bar, text='File')
+        self.bar.file.menu.add_command(
+                label='Quit', command=self.quit)
+        self.bar.view = BarButton(self.bar, text='View')
+        self.bar.format = BarButton(self.bar, text='Format')
+        self.view = IntVar(self)
+        self.view.set(0)
+        self.format = IntVar(self)
+        self.format.set(0)
+        for num in range(len(self.view_list)):
+            label, option = self.view_list[num]
+            self.bar.view.menu.add_radiobutton(
+                    label=label,
+                    command=self.do_update,
+                    variable=self.view,
+                    value=num)
+        for num in range(len(self.format_list)):
+            label, option, col = self.format_list[num]
+            self.bar.format.menu.add_radiobutton(
+                    label=label,
+                    command=self.do_update,
+                    variable=self.format,
+                    value=num)
+        self.bar.tk_menuBar(self.bar.file,
+                            self.bar.view,
+                            self.bar.format)
+        self.frame = Frame(self, relief=RAISED, borderwidth=2)
+        self.frame.pack(expand=1, fill=BOTH)
+        self.header = StringVar(self)
+        self.frame.label = Label(
+                self.frame, relief=FLAT, anchor=NW, borderwidth=0,
+                font='*-Courier-Bold-R-Normal-*-120-*',
+                textvariable=self.header)
+        self.frame.label.pack(fill=Y, anchor=W)
+        self.frame.vscroll = Scrollbar(self.frame, orient=VERTICAL)
+        self.frame.list = Listbox(
+                self.frame,
+                relief=SUNKEN,
+                font='*-Courier-Medium-R-Normal-*-120-*',
+                width=40, height=10,
+                selectbackground='#eed5b7',
+                selectborderwidth=0,
+                selectmode=BROWSE,
+                yscroll=self.frame.vscroll.set)
+        self.frame.vscroll['command'] = self.frame.list.yview
+        self.frame.vscroll.pack(side=RIGHT, fill=Y)
+        self.frame.list.pack(expand=1, fill=BOTH)
+        self.update = Button(self, text='Update',
+                             command=self.do_update)
+        self.update.pack(fill=X)
+        self.frame.list.bind('<Motion>', self.do_motion)
+        self.frame.list.bind('<Leave>', self.do_leave)
+        self.frame.list.bind('<1>', self.do_1)
+        self.do_update()
 
 if __name__ == '__main__':
-	kill = Kill(None, borderwidth=5)
-	kill.winfo_toplevel().title('Tkinter Process Killer (SYSV)')
-	kill.winfo_toplevel().minsize(1, 1)
-	kill.mainloop()
+    kill = Kill(None, borderwidth=5)
+    kill.winfo_toplevel().title('Tkinter Process Killer (SYSV)')
+    kill.winfo_toplevel().minsize(1, 1)
+    kill.mainloop()
diff --git a/Demo/tkinter/guido/tkman.py b/Demo/tkinter/guido/tkman.py
index 84672fc..11d9690 100755
--- a/Demo/tkinter/guido/tkman.py
+++ b/Demo/tkinter/guido/tkman.py
@@ -15,253 +15,253 @@ MAN3DIRLIST = ['/depot/sundry/man/man3','/usr/local/man/man3']
 foundmanndir = 0
 for dir in MANNDIRLIST:
     if os.path.exists(dir):
-	MANNDIR = dir
-	foundmanndir = 1
+        MANNDIR = dir
+        foundmanndir = 1
 
 foundman3dir = 0
 for dir in MAN3DIRLIST:
     if os.path.exists(dir):
-	MAN3DIR = dir
-	foundman3dir =  1
+        MAN3DIR = dir
+        foundman3dir =  1
 
 if not foundmanndir or not foundman3dir:
     sys.stderr.write('\n')
     if not foundmanndir:
-	msg = """\
+        msg = """\
 Failed to find mann directory.
-Please add the correct entry to the MANNDIRLIST 
+Please add the correct entry to the MANNDIRLIST
 at the top of %s script.""" % \
 sys.argv[0]
-	sys.stderr.write("%s\n\n" % msg)
+        sys.stderr.write("%s\n\n" % msg)
     if not foundman3dir:
-	msg = """\
+        msg = """\
 Failed to find man3 directory.
-Please add the correct entry to the MAN3DIRLIST 
+Please add the correct entry to the MAN3DIRLIST
 at the top of %s script.""" % \
 sys.argv[0]
-	sys.stderr.write("%s\n\n" % msg)
+        sys.stderr.write("%s\n\n" % msg)
     sys.exit(1)
 
 del foundmanndir
 del foundman3dir
 
 def listmanpages(mandir):
-	files = os.listdir(mandir)
-	names = []
-	for file in files:
-		if file[-2:-1] == '.' and  (file[-1] in 'ln123456789'):
-			names.append(file[:-2])
-	names.sort()
-	return names
+    files = os.listdir(mandir)
+    names = []
+    for file in files:
+        if file[-2:-1] == '.' and  (file[-1] in 'ln123456789'):
+            names.append(file[:-2])
+    names.sort()
+    return names
 
 class SelectionBox:
 
-	def __init__(self, master=None):
-		self.choices = []
+    def __init__(self, master=None):
+        self.choices = []
 
-		self.frame = Frame(master, name="frame")
-		self.frame.pack(expand=1, fill=BOTH)
-		self.master = self.frame.master
-		self.subframe = Frame(self.frame, name="subframe")
-		self.subframe.pack(expand=0, fill=BOTH)
-		self.leftsubframe = Frame(self.subframe, name='leftsubframe')
-		self.leftsubframe.pack(side=LEFT, expand=1, fill=BOTH)
-		self.rightsubframe = Frame(self.subframe, name='rightsubframe')
-		self.rightsubframe.pack(side=RIGHT, expand=1, fill=BOTH)
-		self.chaptervar = StringVar(master)
-		self.chapter = Menubutton(self.rightsubframe, name='chapter',
-					  text='Directory', relief=RAISED,
-					  borderwidth=2)
-		self.chapter.pack(side=TOP)
-		self.chaptermenu = Menu(self.chapter, name='chaptermenu')
-		self.chaptermenu.add_radiobutton(label='C functions',
-						 value=MAN3DIR,
-						 variable=self.chaptervar,
-						 command=self.newchapter)
-		self.chaptermenu.add_radiobutton(label='Tcl/Tk functions',
-						 value=MANNDIR,
-						 variable=self.chaptervar,
-						 command=self.newchapter)
-		self.chapter['menu'] = self.chaptermenu
-		self.listbox = Listbox(self.rightsubframe, name='listbox',
-				       relief=SUNKEN, borderwidth=2,
-				       width=20, height=5)
-		self.listbox.pack(expand=1, fill=BOTH)
-		self.l1 = Button(self.leftsubframe, name='l1',
-				 text='Display manual page named:',
-				 command=self.entry_cb)
-		self.l1.pack(side=TOP)
-		self.entry = Entry(self.leftsubframe, name='entry',
-				    relief=SUNKEN, borderwidth=2,
-				    width=20)
-		self.entry.pack(expand=0, fill=X)
-		self.l2frame = Frame(self.leftsubframe, name='l2frame')
-		self.l2frame.pack(expand=0, fill=NONE)
-		self.l2 = Button(self.l2frame, name='l2',
-				 text='Search regexp:',
-				 command=self.search_cb)
-		self.l2.pack(side=LEFT)
-		self.casevar = BooleanVar()
-		self.casesense = Checkbutton(self.l2frame, name='casesense',
-					     text='Case sensitive',
-					     variable=self.casevar,
-					     relief=FLAT)
-		self.casesense.pack(side=LEFT)
-		self.search = Entry(self.leftsubframe, name='search',
-				    relief=SUNKEN, borderwidth=2,
-				    width=20)
-		self.search.pack(expand=0, fill=X)
-		self.title = Label(self.leftsubframe, name='title',
-				   text='(none)')
-		self.title.pack(side=BOTTOM)
-		self.text = ManPage(self.frame, name='text',
-				    relief=SUNKEN, borderwidth=2,
-				    wrap=NONE, width=72,
-				    selectbackground='pink')
-		self.text.pack(expand=1, fill=BOTH)
+        self.frame = Frame(master, name="frame")
+        self.frame.pack(expand=1, fill=BOTH)
+        self.master = self.frame.master
+        self.subframe = Frame(self.frame, name="subframe")
+        self.subframe.pack(expand=0, fill=BOTH)
+        self.leftsubframe = Frame(self.subframe, name='leftsubframe')
+        self.leftsubframe.pack(side=LEFT, expand=1, fill=BOTH)
+        self.rightsubframe = Frame(self.subframe, name='rightsubframe')
+        self.rightsubframe.pack(side=RIGHT, expand=1, fill=BOTH)
+        self.chaptervar = StringVar(master)
+        self.chapter = Menubutton(self.rightsubframe, name='chapter',
+                                  text='Directory', relief=RAISED,
+                                  borderwidth=2)
+        self.chapter.pack(side=TOP)
+        self.chaptermenu = Menu(self.chapter, name='chaptermenu')
+        self.chaptermenu.add_radiobutton(label='C functions',
+                                         value=MAN3DIR,
+                                         variable=self.chaptervar,
+                                         command=self.newchapter)
+        self.chaptermenu.add_radiobutton(label='Tcl/Tk functions',
+                                         value=MANNDIR,
+                                         variable=self.chaptervar,
+                                         command=self.newchapter)
+        self.chapter['menu'] = self.chaptermenu
+        self.listbox = Listbox(self.rightsubframe, name='listbox',
+                               relief=SUNKEN, borderwidth=2,
+                               width=20, height=5)
+        self.listbox.pack(expand=1, fill=BOTH)
+        self.l1 = Button(self.leftsubframe, name='l1',
+                         text='Display manual page named:',
+                         command=self.entry_cb)
+        self.l1.pack(side=TOP)
+        self.entry = Entry(self.leftsubframe, name='entry',
+                            relief=SUNKEN, borderwidth=2,
+                            width=20)
+        self.entry.pack(expand=0, fill=X)
+        self.l2frame = Frame(self.leftsubframe, name='l2frame')
+        self.l2frame.pack(expand=0, fill=NONE)
+        self.l2 = Button(self.l2frame, name='l2',
+                         text='Search regexp:',
+                         command=self.search_cb)
+        self.l2.pack(side=LEFT)
+        self.casevar = BooleanVar()
+        self.casesense = Checkbutton(self.l2frame, name='casesense',
+                                     text='Case sensitive',
+                                     variable=self.casevar,
+                                     relief=FLAT)
+        self.casesense.pack(side=LEFT)
+        self.search = Entry(self.leftsubframe, name='search',
+                            relief=SUNKEN, borderwidth=2,
+                            width=20)
+        self.search.pack(expand=0, fill=X)
+        self.title = Label(self.leftsubframe, name='title',
+                           text='(none)')
+        self.title.pack(side=BOTTOM)
+        self.text = ManPage(self.frame, name='text',
+                            relief=SUNKEN, borderwidth=2,
+                            wrap=NONE, width=72,
+                            selectbackground='pink')
+        self.text.pack(expand=1, fill=BOTH)
 
-		self.entry.bind('<Return>', self.entry_cb)
-		self.search.bind('<Return>', self.search_cb)
-		self.listbox.bind('<Double-1>', self.listbox_cb)
+        self.entry.bind('<Return>', self.entry_cb)
+        self.search.bind('<Return>', self.search_cb)
+        self.listbox.bind('<Double-1>', self.listbox_cb)
 
-		self.entry.bind('<Tab>', self.entry_tab)
-		self.search.bind('<Tab>', self.search_tab)
-		self.text.bind('<Tab>', self.text_tab)
+        self.entry.bind('<Tab>', self.entry_tab)
+        self.search.bind('<Tab>', self.search_tab)
+        self.text.bind('<Tab>', self.text_tab)
 
-		self.entry.focus_set()
+        self.entry.focus_set()
 
-		self.chaptervar.set(MANNDIR)
-		self.newchapter()
+        self.chaptervar.set(MANNDIR)
+        self.newchapter()
 
-	def newchapter(self):
-		mandir = self.chaptervar.get()
-		self.choices = []
-		self.addlist(listmanpages(mandir))
+    def newchapter(self):
+        mandir = self.chaptervar.get()
+        self.choices = []
+        self.addlist(listmanpages(mandir))
 
-	def addchoice(self, choice):
-		if choice not in self.choices:
-			self.choices.append(choice)
-			self.choices.sort()
-		self.update()
+    def addchoice(self, choice):
+        if choice not in self.choices:
+            self.choices.append(choice)
+            self.choices.sort()
+        self.update()
 
-	def addlist(self, list):
-		self.choices[len(self.choices):] = list
-		self.choices.sort()
-		self.update()
+    def addlist(self, list):
+        self.choices[len(self.choices):] = list
+        self.choices.sort()
+        self.update()
 
-	def entry_cb(self, *e):
-		self.update()
+    def entry_cb(self, *e):
+        self.update()
 
-	def listbox_cb(self, e):
-		selection = self.listbox.curselection()
-		if selection and len(selection) == 1:
-			name = self.listbox.get(selection[0])
-			self.show_page(name)
+    def listbox_cb(self, e):
+        selection = self.listbox.curselection()
+        if selection and len(selection) == 1:
+            name = self.listbox.get(selection[0])
+            self.show_page(name)
 
-	def search_cb(self, *e):
-		self.search_string(self.search.get())
+    def search_cb(self, *e):
+        self.search_string(self.search.get())
 
-	def entry_tab(self, e):
-		self.search.focus_set()
+    def entry_tab(self, e):
+        self.search.focus_set()
 
-	def search_tab(self, e):
-		self.entry.focus_set()
+    def search_tab(self, e):
+        self.entry.focus_set()
 
-	def text_tab(self, e):
-		self.entry.focus_set()
+    def text_tab(self, e):
+        self.entry.focus_set()
 
-	def updatelist(self):
-		key = self.entry.get()
-		ok = filter(lambda name, key=key, n=len(key): name[:n]==key,
-			 self.choices)
-		if not ok:
-			self.frame.bell()
-		self.listbox.delete(0, AtEnd())
-		exactmatch = 0
-		for item in ok:
-			if item == key: exactmatch = 1
-			self.listbox.insert(AtEnd(), item)
-		if exactmatch:
-			return key
-		n = self.listbox.size()
-		if n == 1:
-			return self.listbox.get(0)
-		# Else return None, meaning not a unique selection
+    def updatelist(self):
+        key = self.entry.get()
+        ok = filter(lambda name, key=key, n=len(key): name[:n]==key,
+                 self.choices)
+        if not ok:
+            self.frame.bell()
+        self.listbox.delete(0, AtEnd())
+        exactmatch = 0
+        for item in ok:
+            if item == key: exactmatch = 1
+            self.listbox.insert(AtEnd(), item)
+        if exactmatch:
+            return key
+        n = self.listbox.size()
+        if n == 1:
+            return self.listbox.get(0)
+        # Else return None, meaning not a unique selection
 
-	def update(self):
-		name = self.updatelist()
-		if name:
-			self.show_page(name)
-			self.entry.delete(0, AtEnd())
-			self.updatelist()
+    def update(self):
+        name = self.updatelist()
+        if name:
+            self.show_page(name)
+            self.entry.delete(0, AtEnd())
+            self.updatelist()
 
-	def show_page(self, name):
-		file = '%s/%s.?' % (self.chaptervar.get(), name)
-		fp = os.popen('nroff -man %s | ul -i' % file, 'r')
-		self.text.kill()
-		self.title['text'] = name
-		self.text.parsefile(fp)
+    def show_page(self, name):
+        file = '%s/%s.?' % (self.chaptervar.get(), name)
+        fp = os.popen('nroff -man %s | ul -i' % file, 'r')
+        self.text.kill()
+        self.title['text'] = name
+        self.text.parsefile(fp)
 
-	def search_string(self, search):
-		if not search:
-			self.frame.bell()
-			print 'Empty search string'
-			return
-		if not self.casevar.get():
-			map = regex.casefold
-		else:
-			map = None
-		try:
-			if map:
-				prog = regex.compile(search, map)
-			else:
-				prog = regex.compile(search)
-		except regex.error, msg:
-			self.frame.bell()
-			print 'Regex error:', msg
-			return
-		here = self.text.index(AtInsert())
-		lineno = string.atoi(here[:string.find(here, '.')])
-		end = self.text.index(AtEnd())
-		endlineno = string.atoi(end[:string.find(end, '.')])
-		wraplineno = lineno
-		found = 0
-		while 1:
-			lineno = lineno + 1
-			if lineno > endlineno:
-				if wraplineno <= 0:
-					break
-				endlineno = wraplineno
-				lineno = 0
-				wraplineno = 0
-			line = self.text.get('%d.0 linestart' % lineno,
-					     '%d.0 lineend' % lineno)
-			i = prog.search(line)
-			if i >= 0:
-				found = 1
-				n = max(1, len(prog.group(0)))
-				try:
-					self.text.tag_remove('sel',
-							     AtSelFirst(),
-							     AtSelLast())
-				except TclError:
-					pass
-				self.text.tag_add('sel',
-						  '%d.%d' % (lineno, i),
-						  '%d.%d' % (lineno, i+n))
-				self.text.mark_set(AtInsert(),
-						   '%d.%d' % (lineno, i))
-				self.text.yview_pickplace(AtInsert())
-				break
-		if not found:
-			self.frame.bell()
+    def search_string(self, search):
+        if not search:
+            self.frame.bell()
+            print 'Empty search string'
+            return
+        if not self.casevar.get():
+            map = regex.casefold
+        else:
+            map = None
+        try:
+            if map:
+                prog = regex.compile(search, map)
+            else:
+                prog = regex.compile(search)
+        except regex.error, msg:
+            self.frame.bell()
+            print 'Regex error:', msg
+            return
+        here = self.text.index(AtInsert())
+        lineno = string.atoi(here[:string.find(here, '.')])
+        end = self.text.index(AtEnd())
+        endlineno = string.atoi(end[:string.find(end, '.')])
+        wraplineno = lineno
+        found = 0
+        while 1:
+            lineno = lineno + 1
+            if lineno > endlineno:
+                if wraplineno <= 0:
+                    break
+                endlineno = wraplineno
+                lineno = 0
+                wraplineno = 0
+            line = self.text.get('%d.0 linestart' % lineno,
+                                 '%d.0 lineend' % lineno)
+            i = prog.search(line)
+            if i >= 0:
+                found = 1
+                n = max(1, len(prog.group(0)))
+                try:
+                    self.text.tag_remove('sel',
+                                         AtSelFirst(),
+                                         AtSelLast())
+                except TclError:
+                    pass
+                self.text.tag_add('sel',
+                                  '%d.%d' % (lineno, i),
+                                  '%d.%d' % (lineno, i+n))
+                self.text.mark_set(AtInsert(),
+                                   '%d.%d' % (lineno, i))
+                self.text.yview_pickplace(AtInsert())
+                break
+        if not found:
+            self.frame.bell()
 
 def main():
-	root = Tk()
-	sb = SelectionBox(root)
-	if sys.argv[1:]:
-		sb.show_page(sys.argv[1])
-	root.minsize(1, 1)
-	root.mainloop()
+    root = Tk()
+    sb = SelectionBox(root)
+    if sys.argv[1:]:
+        sb.show_page(sys.argv[1])
+    root.minsize(1, 1)
+    root.mainloop()
 
 main()
diff --git a/Demo/tkinter/guido/wish.py b/Demo/tkinter/guido/wish.py
index 4f6fdee..0a61ad8 100755
--- a/Demo/tkinter/guido/wish.py
+++ b/Demo/tkinter/guido/wish.py
@@ -9,19 +9,19 @@ tk.call('update')
 cmd = ''
 
 while 1:
-	if cmd: prompt = ''
-	else: prompt = '% '
-	try:
-		line = raw_input(prompt)
-	except EOFError:
-		break
-	cmd = cmd + (line + '\n')
-	if tk.getboolean(tk.call('info', 'complete', cmd)):
-		tk.record(line)
-		try:
-			result = tk.call('eval', cmd)
-		except _tkinter.TclError, msg:
-			print 'TclError:', msg
-		else:
-			if result: print result
-		cmd = ''
+    if cmd: prompt = ''
+    else: prompt = '% '
+    try:
+        line = raw_input(prompt)
+    except EOFError:
+        break
+    cmd = cmd + (line + '\n')
+    if tk.getboolean(tk.call('info', 'complete', cmd)):
+        tk.record(line)
+        try:
+            result = tk.call('eval', cmd)
+        except _tkinter.TclError, msg:
+            print 'TclError:', msg
+        else:
+            if result: print result
+        cmd = ''