Checking in IDLEFORK exactly as it appears in the idlefork CVS.

On a branch, for now.

40 files changed, 4632 insertions, 1865 deletions

diff --git a/Tools/idle/AutoIndent.py b/Tools/idle/AutoIndent.py
deleted file mode 100644
index 7bc195b..0000000
--- a/Tools/idle/AutoIndent.py
+++ /dev/null
@@ -1,551 +0,0 @@
-#from Tkinter import TclError
-#import tkMessageBox
-#import tkSimpleDialog
-
-###$ event <<newline-and-indent>>
-###$ win <Key-Return>
-###$ win <KP_Enter>
-###$ unix <Key-Return>
-###$ unix <KP_Enter>
-
-###$ event <<indent-region>>
-###$ win <Control-bracketright>
-###$ unix <Alt-bracketright>
-###$ unix <Control-bracketright>
-
-###$ event <<dedent-region>>
-###$ win <Control-bracketleft>
-###$ unix <Alt-bracketleft>
-###$ unix <Control-bracketleft>
-
-###$ event <<comment-region>>
-###$ win <Alt-Key-3>
-###$ unix <Alt-Key-3>
-
-###$ event <<uncomment-region>>
-###$ win <Alt-Key-4>
-###$ unix <Alt-Key-4>
-
-###$ event <<tabify-region>>
-###$ win <Alt-Key-5>
-###$ unix <Alt-Key-5>
-
-###$ event <<untabify-region>>
-###$ win <Alt-Key-6>
-###$ unix <Alt-Key-6>
-
-import PyParse
-
-class AutoIndent:
-
-    menudefs = [
-        ('edit', [
-            None,
-            ('_Indent region', '<<indent-region>>'),
-            ('_Dedent region', '<<dedent-region>>'),
-            ('Comment _out region', '<<comment-region>>'),
-            ('U_ncomment region', '<<uncomment-region>>'),
-            ('Tabify region', '<<tabify-region>>'),
-            ('Untabify region', '<<untabify-region>>'),
-            ('Toggle tabs', '<<toggle-tabs>>'),
-            ('New indent width', '<<change-indentwidth>>'),
-        ]),
-    ]
-
-    keydefs = {
-        '<<smart-backspace>>': ['<Key-BackSpace>'],
-        '<<newline-and-indent>>': ['<Key-Return>', '<KP_Enter>'],
-        '<<smart-indent>>': ['<Key-Tab>']
-    }
-
-    windows_keydefs = {
-        '<<indent-region>>': ['<Control-bracketright>'],
-        '<<dedent-region>>': ['<Control-bracketleft>'],
-        '<<comment-region>>': ['<Alt-Key-3>'],
-        '<<uncomment-region>>': ['<Alt-Key-4>'],
-        '<<tabify-region>>': ['<Alt-Key-5>'],
-        '<<untabify-region>>': ['<Alt-Key-6>'],
-        '<<toggle-tabs>>': ['<Alt-Key-t>'],
-        '<<change-indentwidth>>': ['<Alt-Key-u>'],
-    }
-
-    unix_keydefs = {
-        '<<indent-region>>': ['<Alt-bracketright>',
-                              '<Meta-bracketright>',
-                              '<Control-bracketright>'],
-        '<<dedent-region>>': ['<Alt-bracketleft>',
-                              '<Meta-bracketleft>',
-                              '<Control-bracketleft>'],
-        '<<comment-region>>': ['<Alt-Key-3>', '<Meta-Key-3>'],
-        '<<uncomment-region>>': ['<Alt-Key-4>', '<Meta-Key-4>'],
-        '<<tabify-region>>': ['<Alt-Key-5>', '<Meta-Key-5>'],
-        '<<untabify-region>>': ['<Alt-Key-6>', '<Meta-Key-6>'],
-        '<<toggle-tabs>>': ['<Alt-Key-t>'],
-        '<<change-indentwidth>>': ['<Alt-Key-u>'],
-    }
-
-    # usetabs true  -> literal tab characters are used by indent and
-    #                  dedent cmds, possibly mixed with spaces if
-    #                  indentwidth is not a multiple of tabwidth
-    #         false -> tab characters are converted to spaces by indent
-    #                  and dedent cmds, and ditto TAB keystrokes
-    # indentwidth is the number of characters per logical indent level.
-    # tabwidth is the display width of a literal tab character.
-    # CAUTION:  telling Tk to use anything other than its default
-    # tab setting causes it to use an entirely different tabbing algorithm,
-    # treating tab stops as fixed distances from the left margin.
-    # Nobody expects this, so for now tabwidth should never be changed.
-    usetabs = 1
-    indentwidth = 4
-    tabwidth = 8    # for IDLE use, must remain 8 until Tk is fixed
-
-    # If context_use_ps1 is true, parsing searches back for a ps1 line;
-    # else searches for a popular (if, def, ...) Python stmt.
-    context_use_ps1 = 0
-
-    # When searching backwards for a reliable place to begin parsing,
-    # first start num_context_lines[0] lines back, then
-    # num_context_lines[1] lines back if that didn't work, and so on.
-    # The last value should be huge (larger than the # of lines in a
-    # conceivable file).
-    # Making the initial values larger slows things down more often.
-    num_context_lines = 50, 500, 5000000
-
-    def __init__(self, editwin):
-        self.editwin = editwin
-        self.text = editwin.text
-
-    def config(self, **options):
-        for key, value in options.items():
-            if key == 'usetabs':
-                self.usetabs = value
-            elif key == 'indentwidth':
-                self.indentwidth = value
-            elif key == 'tabwidth':
-                self.tabwidth = value
-            elif key == 'context_use_ps1':
-                self.context_use_ps1 = value
-            else:
-                raise KeyError, "bad option name: %s" % `key`
-
-    # If ispythonsource and guess are true, guess a good value for
-    # indentwidth based on file content (if possible), and if
-    # indentwidth != tabwidth set usetabs false.
-    # In any case, adjust the Text widget's view of what a tab
-    # character means.
-
-    def set_indentation_params(self, ispythonsource, guess=1):
-        if guess and ispythonsource:
-            i = self.guess_indent()
-            if 2 <= i <= 8:
-                self.indentwidth = i
-            if self.indentwidth != self.tabwidth:
-                self.usetabs = 0
-
-        self.editwin.set_tabwidth(self.tabwidth)
-
-    def smart_backspace_event(self, event):
-        text = self.text
-        first, last = self.editwin.get_selection_indices()
-        if first and last:
-            text.delete(first, last)
-            text.mark_set("insert", first)
-            return "break"
-        # Delete whitespace left, until hitting a real char or closest
-        # preceding virtual tab stop.
-        chars = text.get("insert linestart", "insert")
-        if chars == '':
-            if text.compare("insert", ">", "1.0"):
-                # easy: delete preceding newline
-                text.delete("insert-1c")
-            else:
-                text.bell()     # at start of buffer
-            return "break"
-        if  chars[-1] not in " \t":
-            # easy: delete preceding real char
-            text.delete("insert-1c")
-            return "break"
-        # Ick.  It may require *inserting* spaces if we back up over a
-        # tab character!  This is written to be clear, not fast.
-        tabwidth = self.tabwidth
-        have = len(chars.expandtabs(tabwidth))
-        assert have > 0
-        want = ((have - 1) // self.indentwidth) * self.indentwidth
-        ncharsdeleted = 0
-        while 1:
-            chars = chars[:-1]
-            ncharsdeleted = ncharsdeleted + 1
-            have = len(chars.expandtabs(tabwidth))
-            if have <= want or chars[-1] not in " \t":
-                break
-        text.undo_block_start()
-        text.delete("insert-%dc" % ncharsdeleted, "insert")
-        if have < want:
-            text.insert("insert", ' ' * (want - have))
-        text.undo_block_stop()
-        return "break"
-
-    def smart_indent_event(self, event):
-        # if intraline selection:
-        #     delete it
-        # elif multiline selection:
-        #     do indent-region & return
-        # indent one level
-        text = self.text
-        first, last = self.editwin.get_selection_indices()
-        text.undo_block_start()
-        try:
-            if first and last:
-                if index2line(first) != index2line(last):
-                    return self.indent_region_event(event)
-                text.delete(first, last)
-                text.mark_set("insert", first)
-            prefix = text.get("insert linestart", "insert")
-            raw, effective = classifyws(prefix, self.tabwidth)
-            if raw == len(prefix):
-                # only whitespace to the left
-                self.reindent_to(effective + self.indentwidth)
-            else:
-                if self.usetabs:
-                    pad = '\t'
-                else:
-                    effective = len(prefix.expandtabs(self.tabwidth))
-                    n = self.indentwidth
-                    pad = ' ' * (n - effective % n)
-                text.insert("insert", pad)
-            text.see("insert")
-            return "break"
-        finally:
-            text.undo_block_stop()
-
-    def newline_and_indent_event(self, event):
-        text = self.text
-        first, last = self.editwin.get_selection_indices()
-        text.undo_block_start()
-        try:
-            if first and last:
-                text.delete(first, last)
-                text.mark_set("insert", first)
-            line = text.get("insert linestart", "insert")
-            i, n = 0, len(line)
-            while i < n and line[i] in " \t":
-                i = i+1
-            if i == n:
-                # the cursor is in or at leading indentation; just inject
-                # an empty line at the start
-                text.insert("insert linestart", '\n')
-                return "break"
-            indent = line[:i]
-            # strip whitespace before insert point
-            i = 0
-            while line and line[-1] in " \t":
-                line = line[:-1]
-                i = i+1
-            if i:
-                text.delete("insert - %d chars" % i, "insert")
-            # strip whitespace after insert point
-            while text.get("insert") in " \t":
-                text.delete("insert")
-            # start new line
-            text.insert("insert", '\n')
-
-            # adjust indentation for continuations and block
-            # open/close first need to find the last stmt
-            lno = index2line(text.index('insert'))
-            y = PyParse.Parser(self.indentwidth, self.tabwidth)
-            for context in self.num_context_lines:
-                startat = max(lno - context, 1)
-                startatindex = `startat` + ".0"
-                rawtext = text.get(startatindex, "insert")
-                y.set_str(rawtext)
-                bod = y.find_good_parse_start(
-                          self.context_use_ps1,
-                          self._build_char_in_string_func(startatindex))
-                if bod is not None or startat == 1:
-                    break
-            y.set_lo(bod or 0)
-            c = y.get_continuation_type()
-            if c != PyParse.C_NONE:
-                # The current stmt hasn't ended yet.
-                if c == PyParse.C_STRING:
-                    # inside a string; just mimic the current indent
-                    text.insert("insert", indent)
-                elif c == PyParse.C_BRACKET:
-                    # line up with the first (if any) element of the
-                    # last open bracket structure; else indent one
-                    # level beyond the indent of the line with the
-                    # last open bracket
-                    self.reindent_to(y.compute_bracket_indent())
-                elif c == PyParse.C_BACKSLASH:
-                    # if more than one line in this stmt already, just
-                    # mimic the current indent; else if initial line
-                    # has a start on an assignment stmt, indent to
-                    # beyond leftmost =; else to beyond first chunk of
-                    # non-whitespace on initial line
-                    if y.get_num_lines_in_stmt() > 1:
-                        text.insert("insert", indent)
-                    else:
-                        self.reindent_to(y.compute_backslash_indent())
-                else:
-                    assert 0, "bogus continuation type " + `c`
-                return "break"
-
-            # This line starts a brand new stmt; indent relative to
-            # indentation of initial line of closest preceding
-            # interesting stmt.
-            indent = y.get_base_indent_string()
-            text.insert("insert", indent)
-            if y.is_block_opener():
-                self.smart_indent_event(event)
-            elif indent and y.is_block_closer():
-                self.smart_backspace_event(event)
-            return "break"
-        finally:
-            text.see("insert")
-            text.undo_block_stop()
-
-    auto_indent = newline_and_indent_event
-
-    # Our editwin provides a is_char_in_string function that works
-    # with a Tk text index, but PyParse only knows about offsets into
-    # a string. This builds a function for PyParse that accepts an
-    # offset.
-
-    def _build_char_in_string_func(self, startindex):
-        def inner(offset, _startindex=startindex,
-                  _icis=self.editwin.is_char_in_string):
-            return _icis(_startindex + "+%dc" % offset)
-        return inner
-
-    def indent_region_event(self, event):
-        head, tail, chars, lines = self.get_region()
-        for pos in range(len(lines)):
-            line = lines[pos]
-            if line:
-                raw, effective = classifyws(line, self.tabwidth)
-                effective = effective + self.indentwidth
-                lines[pos] = self._make_blanks(effective) + line[raw:]
-        self.set_region(head, tail, chars, lines)
-        return "break"
-
-    def dedent_region_event(self, event):
-        head, tail, chars, lines = self.get_region()
-        for pos in range(len(lines)):
-            line = lines[pos]
-            if line:
-                raw, effective = classifyws(line, self.tabwidth)
-                effective = max(effective - self.indentwidth, 0)
-                lines[pos] = self._make_blanks(effective) + line[raw:]
-        self.set_region(head, tail, chars, lines)
-        return "break"
-
-    def comment_region_event(self, event):
-        head, tail, chars, lines = self.get_region()
-        for pos in range(len(lines) - 1):
-            line = lines[pos]
-            lines[pos] = '##' + line
-        self.set_region(head, tail, chars, lines)
-
-    def uncomment_region_event(self, event):
-        head, tail, chars, lines = self.get_region()
-        for pos in range(len(lines)):
-            line = lines[pos]
-            if not line:
-                continue
-            if line[:2] == '##':
-                line = line[2:]
-            elif line[:1] == '#':
-                line = line[1:]
-            lines[pos] = line
-        self.set_region(head, tail, chars, lines)
-
-    def tabify_region_event(self, event):
-        head, tail, chars, lines = self.get_region()
-        tabwidth = self._asktabwidth()
-        for pos in range(len(lines)):
-            line = lines[pos]
-            if line:
-                raw, effective = classifyws(line, tabwidth)
-                ntabs, nspaces = divmod(effective, tabwidth)
-                lines[pos] = '\t' * ntabs + ' ' * nspaces + line[raw:]
-        self.set_region(head, tail, chars, lines)
-
-    def untabify_region_event(self, event):
-        head, tail, chars, lines = self.get_region()
-        tabwidth = self._asktabwidth()
-        for pos in range(len(lines)):
-            lines[pos] = lines[pos].expandtabs(tabwidth)
-        self.set_region(head, tail, chars, lines)
-
-    def toggle_tabs_event(self, event):
-        if self.editwin.askyesno(
-              "Toggle tabs",
-              "Turn tabs " + ("on", "off")[self.usetabs] + "?",
-              parent=self.text):
-            self.usetabs = not self.usetabs
-        return "break"
-
-    # XXX this isn't bound to anything -- see class tabwidth comments
-    def change_tabwidth_event(self, event):
-        new = self._asktabwidth()
-        if new != self.tabwidth:
-            self.tabwidth = new
-            self.set_indentation_params(0, guess=0)
-        return "break"
-
-    def change_indentwidth_event(self, event):
-        new = self.editwin.askinteger(
-                  "Indent width",
-                  "New indent width (1-16)",
-                  parent=self.text,
-                  initialvalue=self.indentwidth,
-                  minvalue=1,
-                  maxvalue=16)
-        if new and new != self.indentwidth:
-            self.indentwidth = new
-        return "break"
-
-    def get_region(self):
-        text = self.text
-        first, last = self.editwin.get_selection_indices()
-        if first and last:
-            head = text.index(first + " linestart")
-            tail = text.index(last + "-1c lineend +1c")
-        else:
-            head = text.index("insert linestart")
-            tail = text.index("insert lineend +1c")
-        chars = text.get(head, tail)
-        lines = chars.split("\n")
-        return head, tail, chars, lines
-
-    def set_region(self, head, tail, chars, lines):
-        text = self.text
-        newchars = "\n".join(lines)
-        if newchars == chars:
-            text.bell()
-            return
-        text.tag_remove("sel", "1.0", "end")
-        text.mark_set("insert", head)
-        text.undo_block_start()
-        text.delete(head, tail)
-        text.insert(head, newchars)
-        text.undo_block_stop()
-        text.tag_add("sel", head, "insert")
-
-    # Make string that displays as n leading blanks.
-
-    def _make_blanks(self, n):
-        if self.usetabs:
-            ntabs, nspaces = divmod(n, self.tabwidth)
-            return '\t' * ntabs + ' ' * nspaces
-        else:
-            return ' ' * n
-
-    # Delete from beginning of line to insert point, then reinsert
-    # column logical (meaning use tabs if appropriate) spaces.
-
-    def reindent_to(self, column):
-        text = self.text
-        text.undo_block_start()
-        if text.compare("insert linestart", "!=", "insert"):
-            text.delete("insert linestart", "insert")
-        if column:
-            text.insert("insert", self._make_blanks(column))
-        text.undo_block_stop()
-
-    def _asktabwidth(self):
-        return self.editwin.askinteger(
-            "Tab width",
-            "Spaces per tab?",
-            parent=self.text,
-            initialvalue=self.tabwidth,
-            minvalue=1,
-            maxvalue=16) or self.tabwidth
-
-    # Guess indentwidth from text content.
-    # Return guessed indentwidth.  This should not be believed unless
-    # it's in a reasonable range (e.g., it will be 0 if no indented
-    # blocks are found).
-
-    def guess_indent(self):
-        opener, indented = IndentSearcher(self.text, self.tabwidth).run()
-        if opener and indented:
-            raw, indentsmall = classifyws(opener, self.tabwidth)
-            raw, indentlarge = classifyws(indented, self.tabwidth)
-        else:
-            indentsmall = indentlarge = 0
-        return indentlarge - indentsmall
-
-# "line.col" -> line, as an int
-def index2line(index):
-    return int(float(index))
-
-# Look at the leading whitespace in s.
-# Return pair (# of leading ws characters,
-#              effective # of leading blanks after expanding
-#              tabs to width tabwidth)
-
-def classifyws(s, tabwidth):
-    raw = effective = 0
-    for ch in s:
-        if ch == ' ':
-            raw = raw + 1
-            effective = effective + 1
-        elif ch == '\t':
-            raw = raw + 1
-            effective = (effective // tabwidth + 1) * tabwidth
-        else:
-            break
-    return raw, effective
-
-import tokenize
-_tokenize = tokenize
-del tokenize
-
-class IndentSearcher:
-
-    # .run() chews over the Text widget, looking for a block opener
-    # and the stmt following it.  Returns a pair,
-    #     (line containing block opener, line containing stmt)
-    # Either or both may be None.
-
-    def __init__(self, text, tabwidth):
-        self.text = text
-        self.tabwidth = tabwidth
-        self.i = self.finished = 0
-        self.blkopenline = self.indentedline = None
-
-    def readline(self):
-        if self.finished:
-            return ""
-        i = self.i = self.i + 1
-        mark = `i` + ".0"
-        if self.text.compare(mark, ">=", "end"):
-            return ""
-        return self.text.get(mark, mark + " lineend+1c")
-
-    def tokeneater(self, type, token, start, end, line,
-                   INDENT=_tokenize.INDENT,
-                   NAME=_tokenize.NAME,
-                   OPENERS=('class', 'def', 'for', 'if', 'try', 'while')):
-        if self.finished:
-            pass
-        elif type == NAME and token in OPENERS:
-            self.blkopenline = line
-        elif type == INDENT and self.blkopenline:
-            self.indentedline = line
-            self.finished = 1
-
-    def run(self):
-        save_tabsize = _tokenize.tabsize
-        _tokenize.tabsize = self.tabwidth
-        try:
-            try:
-                _tokenize.tokenize(self.readline, self.tokeneater)
-            except _tokenize.TokenError:
-                # since we cut off the tokenizer early, we can trigger
-                # spurious errors
-                pass
-        finally:
-            _tokenize.tabsize = save_tabsize
-        return self.blkopenline, self.indentedline
diff --git a/Tools/idle/CREDITS.txt b/Tools/idle/CREDITS.txt
new file mode 100644
index 0000000..fd7af95
--- /dev/null
+++ b/Tools/idle/CREDITS.txt
@@ -0,0 +1,36 @@
+IDLEfork Credits
+==================
+
+Guido van Rossum, as well as being the creator of the Python language, is
+the original creator of IDLE.  He also developed the RPC code and Remote
+Debugger extension used in IDLEfork.
+
+The IDLEfork project was initiated and brought up to version 0.7.1 primarily
+by David Scherer, with help from Peter Schneider-Kamp and Nicholas Riley.
+Bruce Sherwood has contributed considerable time testing and suggesting
+improvements.
+
+Besides Guido, the main developers who have been active on IDLEfork version
+0.8.1 and later are Stephen M. Gava, who implemented the Configuration GUI, the
+new configuration system, and the new About menu, and Kurt B. Kaiser, who
+completed the integration of the RPC and remote debugger, and made a number of
+usability enhancements.
+
+Other contributors include Raymond Hettinger, Tony Lownds (Mac integration),
+Neal Norwitz (code check and clean-up), and Chui Tey (RPC integration, debugger
+integration and persistent breakpoints).
+
+Hernan Foffani, Christos Georgiou, Jason Orendorff, Josh Robb, and Bruce
+Sherwood have submitted useful patches.  Thanks, guys!
+
+There are others who should be included here, especially those who contributed
+to IDLE versions prior to 0.8, principally Mark Hammond, Jeremy Hylton,
+Tim Peters, and Moshe Zadka.  For additional details refer to NEWS.txt and
+Changelog.
+
+Please contact the IDLEfork maintainer to have yourself included here if you
+are one of those we missed! 
+
+Contact details at http://idlefork.sourceforge.net
+
+
diff --git a/Tools/idle/FrameViewer.py b/Tools/idle/FrameViewer.py
deleted file mode 100644
index 2ce0935..0000000
--- a/Tools/idle/FrameViewer.py
+++ /dev/null
@@ -1,38 +0,0 @@
-from repr import Repr
-from Tkinter import *
-
-class FrameViewer:
-
-    def __init__(self, root, frame):
-        self.root = root
-        self.frame = frame
-        self.top = Toplevel(self.root)
-        self.repr = Repr()
-        self.repr.maxstring = 60
-        self.load_variables()
-
-    def load_variables(self):
-        row = 0
-        if self.frame.f_locals is not self.frame.f_globals:
-            l = Label(self.top, text="Local Variables",
-                      borderwidth=2, relief="raised")
-            l.grid(row=row, column=0, columnspan=2, sticky="ew")
-            row = self.load_names(self.frame.f_locals, row+1)
-        l = Label(self.top, text="Global Variables",
-                  borderwidth=2, relief="raised")
-        l.grid(row=row, column=0, columnspan=2, sticky="ew")
-        row = self.load_names(self.frame.f_globals, row+1)
-
-    def load_names(self, dict, row):
-        names = dict.keys()
-        names.sort()
-        for name in names:
-            value = dict[name]
-            svalue = self.repr.repr(value)
-            l = Label(self.top, text=name)
-            l.grid(row=row, column=0, sticky="w")
-            l = Entry(self.top, width=60, borderwidth=0)
-            l.insert(0, svalue)
-            l.grid(row=row, column=1, sticky="w")
-            row = row+1
-        return row
diff --git a/Tools/idle/HISTORY.txt b/Tools/idle/HISTORY.txt
new file mode 100644
index 0000000..9312f32
--- /dev/null
+++ b/Tools/idle/HISTORY.txt
@@ -0,0 +1,180 @@
+IDLE History
+============
+
+This file contains the release messages for previous IDLE releases.
+As you read on you go back to the dark ages of IDLE's history.
+
+
+IDLE 0.5 - February 2000 - Release Notes
+----------------------------------------
+
+This is an early release of IDLE, my own attempt at a Tkinter-based
+IDE for Python.
+
+(For a more detailed change log, see the file ChangeLog.)
+
+FEATURES
+
+IDLE has the following features:
+
+- coded in 100% pure Python, using the Tkinter GUI toolkit (i.e. Tcl/Tk)
+
+- cross-platform: works on Windows and Unix (on the Mac, there are
+currently problems with Tcl/Tk)
+
+- multi-window text editor with multiple undo, Python colorizing
+and many other features, e.g. smart indent and call tips
+
+- Python shell window (a.k.a. interactive interpreter)
+
+- debugger (not complete, but you can set breakpoints, view  and step)
+
+USAGE
+
+The main program is in the file "idle.py"; on Unix, you should be able
+to run it by typing "./idle.py" to your shell.  On Windows, you can
+run it by double-clicking it; you can use idle.pyw to avoid popping up
+a DOS console.  If you want to pass command line arguments on Windows,
+use the batch file idle.bat.
+
+Command line arguments: files passed on the command line are executed,
+not opened for editing, unless you give the -e command line option.
+Try "./idle.py -h" to see other command line options.
+
+IDLE requires Python 1.5.2, so it is currently only usable with a
+Python 1.5.2 distribution.  (An older version of IDLE is distributed
+with Python 1.5.2; you can drop this version on top of it.)
+
+COPYRIGHT
+
+IDLE is covered by the standard Python copyright notice
+(http://www.python.org/doc/Copyright.html).
+
+
+New in IDLE 0.5 (2/15/2000)
+---------------------------
+
+Tons of stuff, much of it contributed by Tim Peters and Mark Hammond:
+
+- Status bar, displaying current line/column (Moshe Zadka).
+
+- Better stack viewer, using tree widget.  (XXX Only used by Stack
+Viewer menu, not by the debugger.)
+
+- Format paragraph now recognizes Python block comments and reformats
+them correctly (MH)
+
+- New version of pyclbr.py parses top-level functions and understands
+much more of Python's syntax; this is reflected in the class and path
+browsers (TP)
+
+- Much better auto-indent; knows how to indent the insides of
+multi-line statements (TP)
+
+- Call tip window pops up when you type the name of a known function
+followed by an open parenthesis.  Hit ESC or click elsewhere in the
+window to close the tip window (MH)
+
+- Comment out region now inserts ## to make it stand out more (TP)
+
+- New path and class browsers based on a tree widget that looks
+familiar to Windows users
+
+- Reworked script running commands to be more intuitive: I/O now
+always goes to the *Python Shell* window, and raw_input() works
+correctly.  You use F5 to import/reload a module: this adds the module
+name to the __main__ namespace.  You use Control-F5 to run a script:
+this runs the script *in* the __main__ namespace.  The latter also
+sets sys.argv[] to the script name
+
+
+New in IDLE 0.4 (4/7/99)
+------------------------
+
+Most important change: a new menu entry "File -> Path browser", shows
+a 4-column hierarchical browser which lets you browse sys.path,
+directories, modules, and classes.  Yes, it's a superset of the Class
+browser menu entry.  There's also a new internal module,
+MultiScrolledLists.py, which provides the framework for this dialog.
+
+
+New in IDLE 0.3 (2/17/99)
+-------------------------
+
+Most important changes:
+
+- Enabled support for running a module, with or without the debugger.
+Output goes to a new window.  Pressing F5 in a module is effectively a
+reload of that module; Control-F5 loads it under the debugger.
+
+- Re-enable tearing off the Windows menu, and make a torn-off Windows
+menu update itself whenever a window is opened or closed.
+
+- Menu items can now be have a checkbox (when the menu label starts
+with "!"); use this for the Debugger and "Auto-open stack viewer"
+(was: JIT stack viewer) menu items.
+
+- Added a Quit button to the Debugger API.
+
+- The current directory is explicitly inserted into sys.path.
+
+- Fix the debugger (when using Python 1.5.2b2) to use canonical
+filenames for breakpoints, so these actually work.  (There's still a
+lot of work to be done to the management of breakpoints in the
+debugger though.)
+
+- Closing a window that is still colorizing now actually works.
+
+- Allow dragging of the separator between the two list boxes in the
+class browser.
+
+- Bind ESC to "close window" of the debugger, stack viewer and class
+browser.  It removes the selection highlighting in regular text
+windows.  (These are standard Windows conventions.)
+
+
+New in IDLE 0.2 (1/8/99)
+------------------------
+
+Lots of changes; here are the highlights:
+
+General:
+
+- You can now write and configure your own IDLE extension modules; see
+extend.txt.
+
+
+File menu:
+
+The command to open the Python shell window is now in the File menu.
+
+
+Edit menu:
+
+New Find dialog with more options; replace dialog; find in files dialog.
+
+Commands to tabify or untabify a region.
+
+Command to format a paragraph.
+
+
+Debug menu:
+
+JIT (Just-In-Time) stack viewer toggle -- if set, the stack viewer
+automaticall pops up when you get a traceback.
+
+Windows menu:
+
+Zoom height -- make the window full height.
+
+
+Help menu:
+
+The help text now show up in a regular window so you can search and
+even edit it if you like.
+
+
+
+IDLE 0.1 was distributed with the Python 1.5.2b1 release on 12/22/98.
+
+======================================================================
diff --git a/Tools/idle/INSTALL.txt b/Tools/idle/INSTALL.txt
new file mode 100644
index 0000000..ed7ac69
--- /dev/null
+++ b/Tools/idle/INSTALL.txt
@@ -0,0 +1,51 @@
+IDLEfork Installation Notes
+===========================
+
+IDLEfork requires Python Version 2.2 or later.
+
+There are several distribution files (where xx is the subversion):
+
+IDLEfork-0.9xx.win32.exe
+	This is a Windows installer which will install IDLEfork in 
+	..../site-packages/idleforklib/ and place the idefork startup script
+	at ..../scripts/idlefork.  Rename this to idlefork.pyw and
+	point your launcher icons at it.  Installation is as idlefork
+	to avoid conflict with the original Python IDLE.
+
+IDLEfork-0.9xx-1.noarch.rpm
+ 	This is an rpm which is designed to install as idleforklib in an
+	existing /usr/lib/python2.2 tree.  It installs as idlefork to avoid
+	conflict with Python IDLE.
+
+	Python rpms are available at http://www.python.org/2.2.2/rpms.html and
+	http://www.python.org/2.2.1/rpms.html.
+
+IDLEfork-0.9xx.tar.gz
+	This is a distutils sdist (source) tarfile which can be used to make 
+	installations on platforms not supported by the above files.
+	** It remains configured to install as idlelib, not idleforklib. **
+
+	Unpack in ..../Tools/, cd to the IDLEfork directory created, and
+	"python setup.py install" to install in ....site-packages/idlelib.
+	This will overwrite the Python IDLE installation.  
+
+        If you don't want to overwrite Python IDLE, it is also possible to
+	simply call "python idle.py" to run from the IDLEfork source directory
+	without making an installation.  In this case, IDLE will not be on
+	your PATH unless you are in the source directory.  Also, it is then
+	advisable to remove any Python IDLE installation by removing
+	..../site-packages/idlelib so the two identically named packages don't
+	conflict.
+
+	On Redhat Linux systems prior to 8.0, /usr/bin/python may be pointing
+	at python1.5.  If so, change the first line in the /usr/bin/idle 
+	script to read:
+	       !# /usr/bin/python2.2
+	       
+See README.txt for more details on this version of IDLEfork. 
+
+
+
+
+
+
diff --git a/Tools/idle/IdleConf.py b/Tools/idle/IdleConf.py
deleted file mode 100644
index 8eaa8e0..0000000
--- a/Tools/idle/IdleConf.py
+++ /dev/null
@@ -1,113 +0,0 @@
-"""Provides access to configuration information"""
-
-import os
-import sys
-from ConfigParser import ConfigParser, NoOptionError, NoSectionError
-
-class IdleConfParser(ConfigParser):
-
-    # these conf sections do not define extensions!
-    builtin_sections = {}
-    for section in ('EditorWindow', 'Colors'):
-        builtin_sections[section] = section
-
-    def getcolor(self, sec, name):
-        """Return a dictionary with foreground and background colors
-
-        The return value is appropriate for passing to Tkinter in, e.g.,
-        a tag_config call.
-        """
-        fore = self.getdef(sec, name + "-foreground")
-        back = self.getdef(sec, name + "-background")
-        return {"foreground": fore,
-                "background": back}
-
-    def getdef(self, sec, options, raw=0, vars=None, default=None):
-        """Get an option value for given section or return default"""
-        try:
-            return self.get(sec, options, raw, vars)
-        except (NoSectionError, NoOptionError):
-            return default
-
-    def getsection(self, section):
-        """Return a SectionConfigParser object"""
-        return SectionConfigParser(section, self)
-
-    def getextensions(self):
-        exts = []
-        for sec in self.sections():
-            if self.builtin_sections.has_key(sec):
-                continue
-            # enable is a bool, but it may not be defined
-            if self.getdef(sec, 'enable') != '0':
-                exts.append(sec)
-        return exts
-
-    def reload(self):
-        global idleconf
-        idleconf = IdleConfParser()
-        load(_dir) # _dir is a global holding the last directory loaded
-
-class SectionConfigParser:
-    """A ConfigParser object specialized for one section
-
-    This class has all the get methods that a regular ConfigParser does,
-    but without requiring a section argument.
-    """
-    def __init__(self, section, config):
-        self.section = section
-        self.config = config
-
-    def options(self):
-        return self.config.options(self.section)
-
-    def get(self, options, raw=0, vars=None):
-        return self.config.get(self.section, options, raw, vars)
-
-    def getdef(self, options, raw=0, vars=None, default=None):
-        return self.config.getdef(self.section, options, raw, vars, default)
-
-    def getint(self, option):
-        return self.config.getint(self.section, option)
-
-    def getfloat(self, option):
-        return self.config.getint(self.section, option)
-
-    def getboolean(self, option):
-        return self.config.getint(self.section, option)
-
-    def getcolor(self, option):
-        return self.config.getcolor(self.section, option)
-
-def load(dir):
-    """Load IDLE configuration files based on IDLE install in dir
-
-    Attempts to load two config files:
-    dir/config.txt
-    dir/config-[win/mac/unix].txt
-    dir/config-%(sys.platform)s.txt
-    ~/.idle
-    """
-    global _dir
-    _dir = dir
-
-    if sys.platform[:3] == 'win':
-        genplatfile = os.path.join(dir, "config-win.txt")
-    # XXX don't know what the platform string is on a Mac
-    elif sys.platform[:3] == 'mac':
-        genplatfile = os.path.join(dir, "config-mac.txt")
-    else:
-        genplatfile = os.path.join(dir, "config-unix.txt")
-
-    platfile = os.path.join(dir, "config-%s.txt" % sys.platform)
-
-    try:
-        homedir = os.environ['HOME']
-    except KeyError:
-        homedir = os.getcwd()
-
-    idleconf.read((os.path.join(dir, "config.txt"), genplatfile, platfile,
-                   os.path.join(homedir, ".idle")))
-
-idleconf = IdleConfParser()
-load(os.path.dirname(__file__))
diff --git a/Tools/idle/LICENSE.txt b/Tools/idle/LICENSE.txt
new file mode 100644
index 0000000..f7a8395
--- /dev/null
+++ b/Tools/idle/LICENSE.txt
@@ -0,0 +1,50 @@
+To apply this license to IDLE or IDLEfork, read 'IDLE' or 'IDLEfork'
+for every occurence of 'Python 2.1.1' in the text below.
+
+PSF LICENSE AGREEMENT
+---------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using Python 2.1.1 software in source or binary form and its
+associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 2.1.1
+alone or in any derivative version, provided, however, that PSF's
+License Agreement and PSF's notice of copyright, i.e., "Copyright (c)
+2001 Python Software Foundation; All Rights Reserved" are retained in
+Python 2.1.1 alone or in any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 2.1.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 2.1.1.
+
+4. PSF is making Python 2.1.1 available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.1.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+2.1.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.1.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python 2.1.1, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
diff --git a/Tools/idle/Makefile b/Tools/idle/Makefile
new file mode 100644
index 0000000..f118ebf
--- /dev/null
+++ b/Tools/idle/Makefile
@@ -0,0 +1,8 @@
+# Makefile to build the interrupt module, which is a C extension
+
+PYTHON=python2.3
+
+all: interrupt.so
+
+interrupt.so: interruptmodule.c
+	$(PYTHON) setup.py build_ext -i
diff --git a/Tools/idle/MultiScrolledLists.py b/Tools/idle/MultiScrolledLists.py
deleted file mode 100644
index 6398b86..0000000
--- a/Tools/idle/MultiScrolledLists.py
+++ /dev/null
@@ -1,137 +0,0 @@
-# One or more ScrolledLists with HSeparators between them.
-# There is a hierarchical relationship between them:
-# the right list displays the substructure of the selected item
-# in the left list.
-
-from Tkinter import *
-from WindowList import ListedToplevel
-from Separator import HSeparator
-from ScrolledList import ScrolledList
-
-class MultiScrolledLists:
-
-    def __init__(self, root, nlists=2):
-        assert nlists >= 1
-        self.root = root
-        self.nlists = nlists
-        self.path = []
-        # create top
-        self.top = top = ListedToplevel(root)
-        top.protocol("WM_DELETE_WINDOW", self.close)
-        top.bind("<Escape>", self.close)
-        self.settitle()
-        # create frames and separators in between
-        self.frames = []
-        self.separators = []
-        last = top
-        for i in range(nlists-1):
-            sepa = HSeparator(last)
-            self.separators.append(sepa)
-            frame, last = sepa.parts()
-            self.frames.append(frame)
-        self.frames.append(last)
-        # create labels and lists
-        self.labels = []
-        self.lists = []
-        for i in range(nlists):
-            frame = self.frames[i]
-            label = Label(frame, text=self.subtitle(i),
-                relief="groove", borderwidth=2)
-            label.pack(fill="x")
-            self.labels.append(label)
-            list = ScrolledList(frame, width=self.width(i),
-                height=self.height(i))
-            self.lists.append(list)
-            list.on_select = \
-                lambda index, i=i, self=self: self.on_select(index, i)
-            list.on_double = \
-                lambda index, i=i, self=self: self.on_double(index, i)
-        # fill leftmost list (rest get filled on demand)
-        self.fill(0)
-        # XXX one after_idle isn't enough; two are...
-        top.after_idle(self.call_pack_propagate_1)
-
-    def call_pack_propagate_1(self):
-        self.top.after_idle(self.call_pack_propagate)
-
-    def call_pack_propagate(self):
-        for frame in self.frames:
-            frame.pack_propagate(0)
-
-    def close(self, event=None):
-        self.top.destroy()
-
-    def settitle(self):
-        short = self.shorttitle()
-        long = self.longtitle()
-        if short and long:
-            title = short + " - " + long
-        elif short:
-            title = short
-        elif long:
-            title = long
-        else:
-            title = "Untitled"
-        icon = short or long or title
-        self.top.wm_title(title)
-        self.top.wm_iconname(icon)
-
-    def longtitle(self):
-        # override this
-        return "Multi Scrolled Lists"
-
-    def shorttitle(self):
-        # override this
-        return None
-
-    def width(self, i):
-        # override this
-        return 20
-
-    def height(self, i):
-        # override this
-        return 10
-
-    def subtitle(self, i):
-        # override this
-        return "Column %d" % i
-
-    def fill(self, i):
-        for k in range(i, self.nlists):
-            self.lists[k].clear()
-            self.labels[k].configure(text=self.subtitle(k))
-        list = self.lists[i]
-        l = self.items(i)
-        for s in l:
-            list.append(s)
-
-    def on_select(self, index, i):
-        item = self.lists[i].get(index)
-        del self.path[i:]
-        self.path.append(item)
-        if i+1 < self.nlists:
-            self.fill(i+1)
-
-    def items(self, i):
-        # override this
-        l = []
-        for k in range(10):
-            s = str(k)
-            if i > 0:
-                s = self.path[i-1] + "." + s
-            l.append(s)
-        return l
-
-    def on_double(self, index, i):
-        pass
-
-
-def main():
-    root = Tk()
-    quit = Button(root, text="Exit", command=root.destroy)
-    quit.pack()
-    MultiScrolledLists(root, 4)
-    root.mainloop()
-
-if __name__ == "__main__":
-    main()
diff --git a/Tools/idle/OldStackViewer.py b/Tools/idle/OldStackViewer.py
deleted file mode 100644
index 4f295e8..0000000
--- a/Tools/idle/OldStackViewer.py
+++ /dev/null
@@ -1,275 +0,0 @@
-import sys
-import os
-from Tkinter import *
-import linecache
-from repr import Repr
-from WindowList import ListedToplevel
-
-from ScrolledList import ScrolledList
-
-
-class StackBrowser:
-
-    def __init__(self, root, flist, stack=None):
-        self.top = top = ListedToplevel(root)
-        top.protocol("WM_DELETE_WINDOW", self.close)
-        top.bind("<Key-Escape>", self.close)
-        top.wm_title("Stack viewer")
-        top.wm_iconname("Stack")
-        # Create help label
-        self.helplabel = Label(top,
-            text="Click once to view variables; twice for source",
-            borderwidth=2, relief="groove")
-        self.helplabel.pack(fill="x")
-        #
-        self.sv = StackViewer(top, flist, self)
-        if stack is None:
-            stack = get_stack()
-        self.sv.load_stack(stack)
-
-    def close(self, event=None):
-        self.top.destroy()
-
-    localsframe = None
-    localsviewer = None
-    localsdict = None
-    globalsframe = None
-    globalsviewer = None
-    globalsdict = None
-    curframe = None
-
-    def show_frame(self, (frame, lineno)):
-        if frame is self.curframe:
-            return
-        self.curframe = None
-        if frame.f_globals is not self.globalsdict:
-            self.show_globals(frame)
-        self.show_locals(frame)
-        self.curframe = frame
-
-    def show_globals(self, frame):
-        title = "Global Variables"
-        if frame.f_globals.has_key("__name__"):
-            try:
-                name = str(frame.f_globals["__name__"]) + ""
-            except:
-                name = ""
-            if name:
-                title = title + " in module " + name
-        self.globalsdict = None
-        if self.globalsviewer:
-            self.globalsviewer.close()
-        self.globalsviewer = None
-        if not self.globalsframe:
-            self.globalsframe = Frame(self.top)
-        self.globalsdict = frame.f_globals
-        self.globalsviewer = NamespaceViewer(
-            self.globalsframe,
-            title,
-            self.globalsdict)
-        self.globalsframe.pack(fill="both", side="bottom")
-
-    def show_locals(self, frame):
-        self.localsdict = None
-        if self.localsviewer:
-            self.localsviewer.close()
-        self.localsviewer = None
-        if frame.f_locals is not frame.f_globals:
-            title = "Local Variables"
-            code = frame.f_code
-            funcname = code.co_name
-            if funcname not in ("?", "", None):
-                title = title + " in " + funcname
-            if not self.localsframe:
-                self.localsframe = Frame(self.top)
-            self.localsdict = frame.f_locals
-            self.localsviewer = NamespaceViewer(
-                self.localsframe,
-                title,
-                self.localsdict)
-            self.localsframe.pack(fill="both", side="top")
-        else:
-            if self.localsframe:
-                self.localsframe.forget()
-
-
-class StackViewer(ScrolledList):
-
-    def __init__(self, master, flist, browser):
-        ScrolledList.__init__(self, master, width=80)
-        self.flist = flist
-        self.browser = browser
-        self.stack = []
-
-    def load_stack(self, stack, index=None):
-        self.stack = stack
-        self.clear()
-##        if len(stack) > 10:
-##            l["height"] = 10
-##            self.topframe.pack(expand=1)
-##        else:
-##            l["height"] = len(stack)
-##            self.topframe.pack(expand=0)
-        for i in range(len(stack)):
-            frame, lineno = stack[i]
-            try:
-                modname = frame.f_globals["__name__"]
-            except:
-                modname = "?"
-            code = frame.f_code
-            filename = code.co_filename
-            funcname = code.co_name
-            sourceline = linecache.getline(filename, lineno)
-            sourceline = sourceline.strip()
-            if funcname in ("?", "", None):
-                item = "%s, line %d: %s" % (modname, lineno, sourceline)
-            else:
-                item = "%s.%s(), line %d: %s" % (modname, funcname,
-                                                 lineno, sourceline)
-            if i == index:
-                item = "> " + item
-            self.append(item)
-        if index is not None:
-            self.select(index)
-
-    def popup_event(self, event):
-        if self.stack:
-            return ScrolledList.popup_event(self, event)
-
-    def fill_menu(self):
-        menu = self.menu
-        menu.add_command(label="Go to source line",
-                         command=self.goto_source_line)
-        menu.add_command(label="Show stack frame",
-                         command=self.show_stack_frame)
-
-    def on_select(self, index):
-        if 0 <= index < len(self.stack):
-            self.browser.show_frame(self.stack[index])
-
-    def on_double(self, index):
-        self.show_source(index)
-
-    def goto_source_line(self):
-        index = self.listbox.index("active")
-        self.show_source(index)
-
-    def show_stack_frame(self):
-        index = self.listbox.index("active")
-        if 0 <= index < len(self.stack):
-            self.browser.show_frame(self.stack[index])
-
-    def show_source(self, index):
-        if not (0 <= index < len(self.stack)):
-            return
-        frame, lineno = self.stack[index]
-        code = frame.f_code
-        filename = code.co_filename
-        if os.path.isfile(filename):
-            edit = self.flist.open(filename)
-            if edit:
-                edit.gotoline(lineno)
-
-
-def get_stack(t=None, f=None):
-    if t is None:
-        t = sys.last_traceback
-    stack = []
-    if t and t.tb_frame is f:
-        t = t.tb_next
-    while f is not None:
-        stack.append((f, f.f_lineno))
-        if f is self.botframe:
-            break
-        f = f.f_back
-    stack.reverse()
-    while t is not None:
-        stack.append((t.tb_frame, t.tb_lineno))
-        t = t.tb_next
-    return stack
-
-
-def getexception(type=None, value=None):
-    if type is None:
-        type = sys.last_type
-        value = sys.last_value
-    if hasattr(type, "__name__"):
-        type = type.__name__
-    s = str(type)
-    if value is not None:
-        s = s + ": " + str(value)
-    return s
-
-
-class NamespaceViewer:
-
-    def __init__(self, master, title, dict=None):
-        width = 0
-        height = 40
-        if dict:
-            height = 20*len(dict) # XXX 20 == observed height of Entry widget
-        self.master = master
-        self.title = title
-        self.repr = Repr()
-        self.repr.maxstring = 60
-        self.repr.maxother = 60
-        self.frame = frame = Frame(master)
-        self.frame.pack(expand=1, fill="both")
-        self.label = Label(frame, text=title, borderwidth=2, relief="groove")
-        self.label.pack(fill="x")
-        self.vbar = vbar = Scrollbar(frame, name="vbar")
-        vbar.pack(side="right", fill="y")
-        self.canvas = canvas = Canvas(frame,
-                                      height=min(300, max(40, height)),
-                                      scrollregion=(0, 0, width, height))
-        canvas.pack(side="left", fill="both", expand=1)
-        vbar["command"] = canvas.yview
-        canvas["yscrollcommand"] = vbar.set
-        self.subframe = subframe = Frame(canvas)
-        self.sfid = canvas.create_window(0, 0, window=subframe, anchor="nw")
-        self.load_dict(dict)
-
-    dict = -1
-
-    def load_dict(self, dict, force=0):
-        if dict is self.dict and not force:
-            return
-        subframe = self.subframe
-        frame = self.frame
-        for c in subframe.children.values():
-            c.destroy()
-        self.dict = None
-        if not dict:
-            l = Label(subframe, text="None")
-            l.grid(row=0, column=0)
-        else:
-            names = dict.keys()
-            names.sort()
-            row = 0
-            for name in names:
-                value = dict[name]
-                svalue = self.repr.repr(value) # repr(value)
-                l = Label(subframe, text=name)
-                l.grid(row=row, column=0, sticky="nw")
-    ##            l = Label(subframe, text=svalue, justify="l", wraplength=300)
-                l = Entry(subframe, width=0, borderwidth=0)
-                l.insert(0, svalue)
-    ##            l["state"] = "disabled"
-                l.grid(row=row, column=1, sticky="nw")
-                row = row+1
-        self.dict = dict
-        # XXX Could we use a <Configure> callback for the following?
-        subframe.update_idletasks() # Alas!
-        width = subframe.winfo_reqwidth()
-        height = subframe.winfo_reqheight()
-        canvas = self.canvas
-        self.canvas["scrollregion"] = (0, 0, width, height)
-        if height > 300:
-            canvas["height"] = 300
-            frame.pack(expand=1)
-        else:
-            canvas["height"] = height
-            frame.pack(expand=0)
-
-    def close(self):
-        self.frame.destroy()
diff --git a/Tools/idle/RemoteDebugger.py b/Tools/idle/RemoteDebugger.py
new file mode 100644
index 0000000..41f910f
--- /dev/null
+++ b/Tools/idle/RemoteDebugger.py
@@ -0,0 +1,381 @@
+"""Support for remote Python debugging.
+
+Some ASCII art to describe the structure:
+
+       IN PYTHON SUBPROCESS          #             IN IDLE PROCESS
+                                     #
+                                     #        oid='gui_adapter'
+                 +----------+        #       +------------+          +-----+
+                 | GUIProxy |--remote#call-->| GUIAdapter |--calls-->| GUI |
++-----+--calls-->+----------+        #       +------------+          +-----+
+| Idb |                               #                             /
++-----+<-calls--+------------+         #      +----------+<--calls-/
+                | IdbAdapter |<--remote#call--| IdbProxy |
+                +------------+         #      +----------+
+                oid='idb_adapter'      #
+
+The purpose of the Proxy and Adapter classes is to translate certain
+arguments and return values that cannot be transported through the RPC
+barrier, in particular frame and traceback objects.
+
+"""
+
+import sys
+import types
+import rpc
+import Debugger
+
+debugging = 0
+
+idb_adap_oid = "idb_adapter"
+gui_adap_oid = "gui_adapter"
+
+#=======================================
+#
+# In the PYTHON subprocess:
+
+frametable = {}
+dicttable = {}
+codetable = {}
+tracebacktable = {}
+
+def wrap_frame(frame):
+    fid = id(frame)
+    frametable[fid] = frame
+    return fid
+
+def wrap_info(info):
+    "replace info[2], a traceback instance, by its ID"
+    if info is None:
+        return None
+    else:
+        traceback = info[2]
+        assert isinstance(traceback, types.TracebackType)
+        traceback_id = id(traceback)
+        tracebacktable[traceback_id] = traceback
+        modified_info = (info[0], info[1], traceback_id)
+        return modified_info
+
+class GUIProxy:
+
+    def __init__(self, conn, gui_adap_oid):
+        self.conn = conn
+        self.oid = gui_adap_oid
+
+    def interaction(self, message, frame, info=None):
+        # calls rpc.SocketIO.remotecall() via run.MyHandler instance
+        # pass frame and traceback object IDs instead of the objects themselves
+        self.conn.remotecall(self.oid, "interaction",
+                             (message, wrap_frame(frame), wrap_info(info)),
+                             {})
+
+class IdbAdapter:
+
+    def __init__(self, idb):
+        self.idb = idb
+
+    #----------called by an IdbProxy----------
+
+    def set_step(self):
+        self.idb.set_step()
+
+    def set_quit(self):
+        self.idb.set_quit()
+
+    def set_continue(self):
+        self.idb.set_continue()
+
+    def set_next(self, fid):
+        frame = frametable[fid]
+        self.idb.set_next(frame)
+
+    def set_return(self, fid):
+        frame = frametable[fid]
+        self.idb.set_return(frame)
+
+    def get_stack(self, fid, tbid):
+        ##print >>sys.__stderr__, "get_stack(%s, %s)" % (`fid`, `tbid`)
+        frame = frametable[fid]
+        if tbid is None:
+            tb = None
+        else:
+            tb = tracebacktable[tbid]
+        stack, i = self.idb.get_stack(frame, tb)
+        ##print >>sys.__stderr__, "get_stack() ->", stack
+        stack = [(wrap_frame(frame), k) for frame, k in stack]
+        ##print >>sys.__stderr__, "get_stack() ->", stack
+        return stack, i
+
+    def run(self, cmd):
+        import __main__
+        self.idb.run(cmd, __main__.__dict__)
+
+    def set_break(self, filename, lineno):
+        msg = self.idb.set_break(filename, lineno)
+        return msg
+
+    def clear_break(self, filename, lineno):
+        msg = self.idb.clear_break(filename, lineno)
+        return msg
+
+    def clear_all_file_breaks(self, filename):
+        msg = self.idb.clear_all_file_breaks(filename)
+        return msg
+
+    #----------called by a FrameProxy----------
+
+    def frame_attr(self, fid, name):
+        frame = frametable[fid]
+        return getattr(frame, name)
+
+    def frame_globals(self, fid):
+        frame = frametable[fid]
+        dict = frame.f_globals
+        did = id(dict)
+        dicttable[did] = dict
+        return did
+
+    def frame_locals(self, fid):
+        frame = frametable[fid]
+        dict = frame.f_locals
+        did = id(dict)
+        dicttable[did] = dict
+        return did
+
+    def frame_code(self, fid):
+        frame = frametable[fid]
+        code = frame.f_code
+        cid = id(code)
+        codetable[cid] = code
+        return cid
+
+    #----------called by a CodeProxy----------
+
+    def code_name(self, cid):
+        code = codetable[cid]
+        return code.co_name
+
+    def code_filename(self, cid):
+        code = codetable[cid]
+        return code.co_filename
+
+    #----------called by a DictProxy----------
+
+    def dict_keys(self, did):
+        dict = dicttable[did]
+        return dict.keys()
+
+    def dict_item(self, did, key):
+        dict = dicttable[did]
+        value = dict[key]
+        value = repr(value)
+        return value
+
+#----------end class IdbAdapter----------
+
+
+def start_debugger(rpchandler, gui_adap_oid):
+    """Start the debugger and its RPC link in the Python subprocess
+
+    Start the subprocess side of the split debugger and set up that side of the
+    RPC link by instantiating the GUIProxy, Idb debugger, and IdbAdapter
+    objects and linking them together.  Register the IdbAdapter with the
+    RPCServer to handle RPC requests from the split debugger GUI via the
+    IdbProxy.
+
+    """
+    gui_proxy = GUIProxy(rpchandler, gui_adap_oid)
+    idb = Debugger.Idb(gui_proxy)
+    idb_adap = IdbAdapter(idb)
+    rpchandler.register(idb_adap_oid, idb_adap)
+    return idb_adap_oid
+
+
+#=======================================
+#
+# In the IDLE process:
+
+
+class FrameProxy:
+
+    def __init__(self, conn, fid):
+        self._conn = conn
+        self._fid = fid
+        self._oid = "idb_adapter"
+        self._dictcache = {}
+
+    def __getattr__(self, name):
+        if name[:1] == "_":
+            raise AttributeError, name
+        if name == "f_code":
+            return self._get_f_code()
+        if name == "f_globals":
+            return self._get_f_globals()
+        if name == "f_locals":
+            return self._get_f_locals()
+        return self._conn.remotecall(self._oid, "frame_attr",
+                                     (self._fid, name), {})
+
+    def _get_f_code(self):
+        cid = self._conn.remotecall(self._oid, "frame_code", (self._fid,), {})
+        return CodeProxy(self._conn, self._oid, cid)
+
+    def _get_f_globals(self):
+        did = self._conn.remotecall(self._oid, "frame_globals",
+                                    (self._fid,), {})
+        return self._get_dict_proxy(did)
+
+    def _get_f_locals(self):
+        did = self._conn.remotecall(self._oid, "frame_locals",
+                                    (self._fid,), {})
+        return self._get_dict_proxy(did)
+
+    def _get_dict_proxy(self, did):
+        if self._dictcache.has_key(did):
+            return self._dictcache[did]
+        dp = DictProxy(self._conn, self._oid, did)
+        self._dictcache[did] = dp
+        return dp
+
+
+class CodeProxy:
+
+    def __init__(self, conn, oid, cid):
+        self._conn = conn
+        self._oid = oid
+        self._cid = cid
+
+    def __getattr__(self, name):
+        if name == "co_name":
+            return self._conn.remotecall(self._oid, "code_name",
+                                         (self._cid,), {})
+        if name == "co_filename":
+            return self._conn.remotecall(self._oid, "code_filename",
+                                         (self._cid,), {})
+
+
+class DictProxy:
+
+    def __init__(self, conn, oid, did):
+        self._conn = conn
+        self._oid = oid
+        self._did = did
+
+    def keys(self):
+        return self._conn.remotecall(self._oid, "dict_keys", (self._did,), {})
+
+    def __getitem__(self, key):
+        return self._conn.remotecall(self._oid, "dict_item",
+                                     (self._did, key), {})
+
+    def __getattr__(self, name):
+        ##print >>sys.__stderr__, "failed DictProxy.__getattr__:", name
+        raise AttributeError, name
+
+
+class GUIAdapter:
+
+    def __init__(self, conn, gui):
+        self.conn = conn
+        self.gui = gui
+
+    def interaction(self, message, fid, modified_info):
+        ##print "interaction: (%s, %s, %s)" % (message, fid, modified_info)
+        frame = FrameProxy(self.conn, fid)
+        self.gui.interaction(message, frame, modified_info)
+
+
+class IdbProxy:
+
+    def __init__(self, conn, shell, oid):
+        self.oid = oid
+        self.conn = conn
+        self.shell = shell
+
+    def call(self, methodname, *args, **kwargs):
+        ##print "**IdbProxy.call %s %s %s" % (methodname, args, kwargs)
+        value = self.conn.remotecall(self.oid, methodname, args, kwargs)
+        ##print "**IdbProxy.call %s returns %s" % (methodname, `value`)
+        return value
+
+    def run(self, cmd, locals):
+        # Ignores locals on purpose!
+        seq = self.conn.asynccall(self.oid, "run", (cmd,), {})
+        self.shell.interp.active_seq = seq
+
+    def get_stack(self, frame, tbid):
+        # passing frame and traceback IDs, not the objects themselves
+        stack, i = self.call("get_stack", frame._fid, tbid)
+        stack = [(FrameProxy(self.conn, fid), k) for fid, k in stack]
+        return stack, i
+
+    def set_continue(self):
+        self.call("set_continue")
+
+    def set_step(self):
+        self.call("set_step")
+
+    def set_next(self, frame):
+        self.call("set_next", frame._fid)
+
+    def set_return(self, frame):
+        self.call("set_return", frame._fid)
+
+    def set_quit(self):
+        self.call("set_quit")
+
+    def set_break(self, filename, lineno):
+        msg = self.call("set_break", filename, lineno)
+        return msg
+
+    def clear_break(self, filename, lineno):
+        msg = self.call("clear_break", filename, lineno)
+        return msg
+
+    def clear_all_file_breaks(self, filename):
+        msg = self.call("clear_all_file_breaks", filename)
+        return msg
+
+def start_remote_debugger(rpcclt, pyshell):
+    """Start the subprocess debugger, initialize the debugger GUI and RPC link
+
+    Request the RPCServer start the Python subprocess debugger and link.  Set
+    up the Idle side of the split debugger by instantiating the IdbProxy,
+    debugger GUI, and debugger GUIAdapter objects and linking them together.
+
+    Register the GUIAdapter with the RPCClient to handle debugger GUI
+    interaction requests coming from the subprocess debugger via the GUIProxy.
+
+    The IdbAdapter will pass execution and environment requests coming from the
+    Idle debugger GUI to the subprocess debugger via the IdbProxy.
+
+    """
+    global idb_adap_oid
+
+    idb_adap_oid = rpcclt.remotecall("exec", "start_the_debugger",\
+                                   (gui_adap_oid,), {})
+    idb_proxy = IdbProxy(rpcclt, pyshell, idb_adap_oid)
+    gui = Debugger.Debugger(pyshell, idb_proxy)
+    gui_adap = GUIAdapter(rpcclt, gui)
+    rpcclt.register(gui_adap_oid, gui_adap)
+    return gui
+
+def close_remote_debugger(rpcclt):
+    """Shut down subprocess debugger and Idle side of debugger RPC link
+
+    Request that the RPCServer shut down the subprocess debugger and link.
+    Unregister the GUIAdapter, which will cause a GC on the Idle process
+    debugger and RPC link objects.  (The second reference to the debugger GUI
+    is deleted in PyShell.close_remote_debugger().)
+
+    """
+    close_subprocess_debugger(rpcclt)
+    rpcclt.unregister(gui_adap_oid)
+
+def close_subprocess_debugger(rpcclt):
+    rpcclt.remotecall("exec", "stop_the_debugger", (idb_adap_oid,), {})
+
+def restart_subprocess_debugger(rpcclt):
+    idb_adap_oid_ret = rpcclt.remotecall("exec", "start_the_debugger",\
+                                         (gui_adap_oid,), {})
+    assert idb_adap_oid_ret == idb_adap_oid, 'Idb restarted with different oid'
diff --git a/Tools/idle/RemoteInterp.py b/Tools/idle/RemoteInterp.py
deleted file mode 100644
index e6f7671..0000000
--- a/Tools/idle/RemoteInterp.py
+++ /dev/null
@@ -1,341 +0,0 @@
-import select
-import socket
-import struct
-import sys
-import types
-
-VERBOSE = None
-
-class SocketProtocol:
-    """A simple protocol for sending strings across a socket"""
-    BUF_SIZE = 8192
-
-    def __init__(self, sock):
-        self.sock = sock
-        self._buffer = ''
-        self._closed = 0
-
-    def close(self):
-        self._closed = 1
-        self.sock.close()
-
-    def send(self, buf):
-        """Encode buf and write it on the socket"""
-        if VERBOSE:
-            VERBOSE.write('send %d:%s\n' % (len(buf), `buf`))
-        self.sock.send('%d:%s' % (len(buf), buf))
-
-    def receive(self, timeout=0):
-        """Get next complete string from socket or return None
-
-        Raise EOFError on EOF
-        """
-        buf = self._read_from_buffer()
-        if buf is not None:
-            return buf
-        recvbuf = self._read_from_socket(timeout)
-        if recvbuf is None:
-            return None
-        if recvbuf == '' and self._buffer == '':
-            raise EOFError
-        if VERBOSE:
-            VERBOSE.write('recv %s\n' % `recvbuf`)
-        self._buffer = self._buffer + recvbuf
-        r = self._read_from_buffer()
-        return r
-
-    def _read_from_socket(self, timeout):
-        """Does not block"""
-        if self._closed:
-            return ''
-        if timeout is not None:
-            r, w, x = select.select([self.sock], [], [], timeout)
-        if timeout is None or r:
-            return self.sock.recv(self.BUF_SIZE)
-        else:
-            return None
-
-    def _read_from_buffer(self):
-        buf = self._buffer
-        i = buf.find(':')
-        if i == -1:
-            return None
-        buflen = int(buf[:i])
-        enclen = i + 1 + buflen
-        if len(buf) >= enclen:
-            s = buf[i+1:enclen]
-            self._buffer = buf[enclen:]
-            return s
-        else:
-            self._buffer = buf
-        return None
-
-# helpers for registerHandler method below
-
-def get_methods(obj):
-    methods = []
-    for name in dir(obj):
-        attr = getattr(obj, name)
-        if callable(attr):
-            methods.append(name)
-    if type(obj) == types.InstanceType:
-        methods = methods + get_methods(obj.__class__)
-    if type(obj) == types.ClassType:
-        for super in obj.__bases__:
-            methods = methods + get_methods(super)
-    return methods
-
-class CommandProtocol:
-    def __init__(self, sockp):
-        self.sockp = sockp
-        self.seqno = 0
-        self.handlers = {}
-
-    def close(self):
-        self.sockp.close()
-        self.handlers.clear()
-
-    def registerHandler(self, handler):
-        """A Handler is an object with handle_XXX methods"""
-        for methname in get_methods(handler):
-            if methname[:7] == "handle_":
-                name = methname[7:]
-                self.handlers[name] = getattr(handler, methname)
-
-    def send(self, cmd, arg='', seqno=None):
-        if arg:
-            msg = "%s %s" % (cmd, arg)
-        else:
-            msg = cmd
-        if seqno is None:
-            seqno = self.get_seqno()
-        msgbuf = self.encode_seqno(seqno) + msg
-        self.sockp.send(msgbuf)
-        if cmd == "reply":
-            return
-        reply = self.sockp.receive(timeout=None)
-        r_cmd, r_arg, r_seqno = self._decode_msg(reply)
-        assert r_seqno == seqno and r_cmd == "reply", "bad reply"
-        return r_arg
-
-    def _decode_msg(self, msg):
-        seqno = self.decode_seqno(msg[:self.SEQNO_ENC_LEN])
-        msg = msg[self.SEQNO_ENC_LEN:]
-        parts = msg.split(" ", 2)
-        if len(parts) == 1:
-            cmd = msg
-            arg = ''
-        else:
-            cmd = parts[0]
-            arg = parts[1]
-        return cmd, arg, seqno
-
-    def dispatch(self):
-        msg = self.sockp.receive()
-        if msg is None:
-            return
-        cmd, arg, seqno = self._decode_msg(msg)
-        self._current_reply = seqno
-        h = self.handlers.get(cmd, self.default_handler)
-        try:
-            r = h(arg)
-        except TypeError, msg:
-            raise TypeError, "handle_%s: %s" % (cmd, msg)
-        if self._current_reply is None:
-            if r is not None:
-                sys.stderr.write("ignoring %s return value type %s\n" % \
-                                 (cmd, type(r).__name__))
-            return
-        if r is None:
-            r = ''
-        if type(r) != types.StringType:
-            raise ValueError, "invalid return type for %s" % cmd
-        self.send("reply", r, seqno=seqno)
-
-    def reply(self, arg=''):
-        """Send a reply immediately
-
-        otherwise reply will be sent when handler returns
-        """
-        self.send("reply", arg, self._current_reply)
-        self._current_reply = None
-
-    def default_handler(self, arg):
-        sys.stderr.write("WARNING: unhandled message %s\n" % arg)
-        return ''
-
-    SEQNO_ENC_LEN = 4
-
-    def get_seqno(self):
-        seqno = self.seqno
-        self.seqno = seqno + 1
-        return seqno
-
-    def encode_seqno(self, seqno):
-        return struct.pack("I", seqno)
-
-    def decode_seqno(self, buf):
-        return struct.unpack("I", buf)[0]
-
-
-class StdioRedirector:
-    """Redirect sys.std{in,out,err} to a set of file-like objects"""
-
-    def __init__(self, stdin, stdout, stderr):
-        self.stdin = stdin
-        self.stdout = stdout
-        self.stderr = stderr
-
-    def redirect(self):
-        self.save()
-        sys.stdin = self.stdin
-        sys.stdout = self.stdout
-        sys.stderr = self.stderr
-
-    def save(self):
-        self._stdin = sys.stdin
-        self._stdout = sys.stdout
-        self._stderr = sys.stderr
-
-    def restore(self):
-        sys.stdin = self._stdin
-        sys.stdout = self._stdout
-        sys.stderr = self._stderr
-
-class IOWrapper:
-    """Send output from a file-like object across a SocketProtocol
-
-    XXX Should this be more tightly integrated with the CommandProtocol?
-    """
-
-    def __init__(self, name, cmdp):
-        self.name = name
-        self.cmdp = cmdp
-        self.buffer = []
-
-class InputWrapper(IOWrapper):
-    def write(self, buf):
-        # XXX what should this do on Windows?
-        raise IOError, (9, '[Errno 9] Bad file descriptor')
-
-    def read(self, arg=None):
-        if arg is not None:
-            if arg <= 0:
-                return ''
-        else:
-            arg = 0
-        return self.cmdp.send(self.name, "read,%s" % arg)
-
-    def readline(self):
-        return self.cmdp.send(self.name, "readline")
-
-class OutputWrapper(IOWrapper):
-    def write(self, buf):
-        self.cmdp.send(self.name, buf)
-
-    def read(self, arg=None):
-        return ''
-
-class RemoteInterp:
-    def __init__(self, sock):
-        self._sock = SocketProtocol(sock)
-        self._cmd = CommandProtocol(self._sock)
-        self._cmd.registerHandler(self)
-
-    def run(self):
-        try:
-            while 1:
-                self._cmd.dispatch()
-        except EOFError:
-            pass
-
-    def handle_execfile(self, arg):
-        self._cmd.reply()
-        io = StdioRedirector(InputWrapper("stdin", self._cmd),
-                             OutputWrapper("stdout", self._cmd),
-                             OutputWrapper("stderr", self._cmd))
-        io.redirect()
-        execfile(arg, {'__name__':'__main__'})
-        io.restore()
-        self._cmd.send("terminated")
-
-    def handle_quit(self, arg):
-        self._cmd.reply()
-        self._cmd.close()
-
-def startRemoteInterp(id):
-    import os
-    # UNIX domain sockets are simpler for starters
-    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-    sock.bind("/var/tmp/ri.%s" % id)
-    try:
-        sock.listen(1)
-        cli, addr = sock.accept()
-        rinterp = RemoteInterp(cli)
-        rinterp.run()
-    finally:
-        os.unlink("/var/tmp/ri.%s" % id)
-
-class RIClient:
-    """Client of the remote interpreter"""
-    def __init__(self, sock):
-        self._sock = SocketProtocol(sock)
-        self._cmd = CommandProtocol(self._sock)
-        self._cmd.registerHandler(self)
-
-    def execfile(self, file):
-        self._cmd.send("execfile", file)
-
-    def run(self):
-        try:
-            while 1:
-                self._cmd.dispatch()
-        except EOFError:
-            pass
-
-    def handle_stdout(self, buf):
-        sys.stdout.write(buf)
-##        sys.stdout.flush()
-
-    def handle_stderr(self, buf):
-        sys.stderr.write(buf)
-
-    def handle_stdin(self, arg):
-        if arg == "readline":
-            return sys.stdin.readline()
-        i = arg.find(",") + 1
-        bytes = int(arg[i:])
-        if bytes == 0:
-            return sys.stdin.read()
-        else:
-            return sys.stdin.read(bytes)
-
-    def handle_terminated(self, arg):
-        self._cmd.reply()
-        self._cmd.send("quit")
-        self._cmd.close()
-
-def riExec(id, file):
-    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-    sock.connect("/var/tmp/ri.%s" % id)
-    cli = RIClient(sock)
-    cli.execfile(file)
-    cli.run()
-
-if __name__ == "__main__":
-    import getopt
-
-    SERVER = 1
-    opts, args = getopt.getopt(sys.argv[1:], 'cv')
-    for o, v in opts:
-        if o == '-c':
-            SERVER = 0
-        elif o == '-v':
-            VERBOSE = sys.stderr
-    id = args[0]
-
-    if SERVER:
-        startRemoteInterp(id)
-    else:
-        file = args[1]
-        riExec(id, file)
diff --git a/Tools/idle/RemoteObjectBrowser.py b/Tools/idle/RemoteObjectBrowser.py
new file mode 100644
index 0000000..6ba3391
--- /dev/null
+++ b/Tools/idle/RemoteObjectBrowser.py
@@ -0,0 +1,36 @@
+import rpc
+
+def remote_object_tree_item(item):
+    wrapper = WrappedObjectTreeItem(item)
+    oid = id(wrapper)
+    rpc.objecttable[oid] = wrapper
+    return oid
+
+class WrappedObjectTreeItem:
+    # Lives in PYTHON subprocess
+
+    def __init__(self, item):
+        self.__item = item
+
+    def __getattr__(self, name):
+        value = getattr(self.__item, name)
+        return value
+
+    def _GetSubList(self):
+        list = self.__item._GetSubList()
+        return map(remote_object_tree_item, list)
+
+class StubObjectTreeItem:
+    # Lives in IDLE process
+
+    def __init__(self, sockio, oid):
+        self.sockio = sockio
+        self.oid = oid
+
+    def __getattr__(self, name):
+        value = rpc.MethodProxy(self.sockio, self.oid, name)
+        return value
+
+    def _GetSubList(self):
+        list = self.sockio.remotecall(self.oid, "_GetSubList", (), {})
+        return [StubObjectTreeItem(self.sockio, oid) for oid in list]
diff --git a/Tools/idle/SearchBinding.py b/Tools/idle/SearchBinding.py
deleted file mode 100644
index 5943e3b..0000000
--- a/Tools/idle/SearchBinding.py
+++ /dev/null
@@ -1,97 +0,0 @@
-import tkSimpleDialog
-
-###$ event <<find>>
-###$ win <Control-f>
-###$ unix <Control-u><Control-u><Control-s>
-
-###$ event <<find-again>>
-###$ win <Control-g>
-###$ win <F3>
-###$ unix <Control-u><Control-s>
-
-###$ event <<find-selection>>
-###$ win <Control-F3>
-###$ unix <Control-s>
-
-###$ event <<find-in-files>>
-###$ win <Alt-F3>
-
-###$ event <<replace>>
-###$ win <Control-h>
-
-###$ event <<goto-line>>
-###$ win <Alt-g>
-###$ unix <Alt-g>
-
-class SearchBinding:
-
-    windows_keydefs = {
-        '<<find-again>>': ['<Control-g>', '<F3>'],
-        '<<find-in-files>>': ['<Alt-F3>'],
-        '<<find-selection>>': ['<Control-F3>'],
-        '<<find>>': ['<Control-f>'],
-        '<<replace>>': ['<Control-h>'],
-        '<<goto-line>>': ['<Alt-g>'],
-    }
-
-    unix_keydefs = {
-        '<<find-again>>': ['<Control-u><Control-s>'],
-        '<<find-in-files>>': ['<Alt-s>', '<Meta-s>'],
-        '<<find-selection>>': ['<Control-s>'],
-        '<<find>>': ['<Control-u><Control-u><Control-s>'],
-        '<<replace>>': ['<Control-r>'],
-        '<<goto-line>>': ['<Alt-g>', '<Meta-g>'],
-    }
-
-    menudefs = [
-        ('edit', [
-            None,
-            ('_Find...', '<<find>>'),
-            ('Find a_gain', '<<find-again>>'),
-            ('Find _selection', '<<find-selection>>'),
-            ('Find in Files...', '<<find-in-files>>'),
-            ('R_eplace...', '<<replace>>'),
-            ('Go to _line', '<<goto-line>>'),
-         ]),
-    ]
-
-    def __init__(self, editwin):
-        self.editwin = editwin
-
-    def find_event(self, event):
-        import SearchDialog
-        SearchDialog.find(self.editwin.text)
-        return "break"
-
-    def find_again_event(self, event):
-        import SearchDialog
-        SearchDialog.find_again(self.editwin.text)
-        return "break"
-
-    def find_selection_event(self, event):
-        import SearchDialog
-        SearchDialog.find_selection(self.editwin.text)
-        return "break"
-
-    def find_in_files_event(self, event):
-        import GrepDialog
-        GrepDialog.grep(self.editwin.text, self.editwin.io, self.editwin.flist)
-        return "break"
-
-    def replace_event(self, event):
-        import ReplaceDialog
-        ReplaceDialog.replace(self.editwin.text)
-        return "break"
-
-    def goto_line_event(self, event):
-        text = self.editwin.text
-        lineno = tkSimpleDialog.askinteger("Goto",
-                                           "Go to line number:",
-                                           parent=text)
-        if lineno is None:
-            return "break"
-        if lineno <= 0:
-            text.bell()
-            return "break"
-        text.mark_set("insert", "%d.0" % lineno)
-        text.see("insert")
diff --git a/Tools/idle/Separator.py b/Tools/idle/Separator.py
deleted file mode 100644
index 7145559..0000000
--- a/Tools/idle/Separator.py
+++ /dev/null
@@ -1,92 +0,0 @@
-from Tkinter import *
-
-class Separator:
-
-    def __init__(self, master, orient, min=10, thickness=5, bg=None):
-        self.min = max(1, min)
-        self.thickness = max(1, thickness)
-        if orient in ("h", "horizontal"):
-            self.side = "left"
-            self.dim = "width"
-            self.dir = "x"
-            self.cursor = "sb_h_double_arrow"
-        elif orient in ("v", "vertical"):
-            self.side = "top"
-            self.dim = "height"
-            self.dir = "y"
-            self.cursor = "sb_v_double_arrow"
-        else:
-            raise ValueError, "Separator: orient should be h or v"
-        self.winfo_dim = "winfo_" + self.dim
-        self.master = master = Frame(master)
-        master.pack(expand=1, fill="both")
-        self.f1 = Frame(master)
-        self.f1.pack(expand=1, fill="both", side=self.side)
-        self.div = Frame(master, cursor=self.cursor)
-        self.div[self.dim] = self.thickness
-        self.div.pack(fill="both", side=self.side)
-        self.f2 = Frame(master)
-        self.f2.pack(expand=1, fill="both", side=self.side)
-        self.div.bind("<ButtonPress-1>", self.divider_press)
-        if bg:
-            ##self.f1["bg"] = bg
-            ##self.f2["bg"] = bg
-            self.div["bg"] = bg
-
-    def parts(self):
-        return self.f1, self.f2
-
-    def divider_press(self, event):
-        self.press_event = event
-        self.f1.pack_propagate(0)
-        self.f2.pack_propagate(0)
-        for f in self.f1, self.f2:
-            for dim in "width", "height":
-                f[dim] = getattr(f, "winfo_"+dim)()
-        self.div.bind("<Motion>", self.div_motion)
-        self.div.bind("<ButtonRelease-1>", self.div_release)
-        self.div.grab_set()
-
-    def div_motion(self, event):
-        delta = getattr(event, self.dir) - getattr(self.press_event, self.dir)
-        if delta:
-            dim1 = getattr(self.f1, self.winfo_dim)()
-            dim2 = getattr(self.f2, self.winfo_dim)()
-            delta = max(delta, self.min-dim1)
-            delta = min(delta, dim2-self.min)
-            dim1 = dim1 + delta
-            dim2 = dim2 - delta
-            self.f1[self.dim] = dim1
-            self.f2[self.dim] = dim2
-
-    def div_release(self, event):
-        self.div_motion(event)
-        self.div.unbind("<Motion>")
-        self.div.grab_release()
-
-class VSeparator(Separator):
-
-    def __init__(self, master, min=10, thickness=5, bg=None):
-        Separator.__init__(self, master, "v", min, thickness, bg)
-
-class HSeparator(Separator):
-
-    def __init__(self, master, min=10, thickness=5, bg=None):
-        Separator.__init__(self, master, "h", min, thickness, bg)
-
-def main():
-    root = Tk()
-    tlist = []
-    outer = HSeparator(root, bg="red")
-    for part in outer.parts():
-        inner = VSeparator(part, bg="blue")
-        for f in inner.parts():
-            t = Text(f, width=40, height=10, borderwidth=0)
-            t.pack(fill="both", expand=1)
-            tlist.append(t)
-    tlist[0].insert("1.0", "Make your own Mondrian!")
-    tlist[1].insert("1.0", "Move the colored dividers...")
-    root.mainloop()
-
-if __name__ == '__main__':
-    main()
diff --git a/Tools/idle/aboutDialog.py b/Tools/idle/aboutDialog.py
new file mode 100644
index 0000000..2fc4a42
--- /dev/null
+++ b/Tools/idle/aboutDialog.py
@@ -0,0 +1,126 @@
+"""
+about box for idle
+"""
+
+from Tkinter import *
+import string, os
+import textView
+import idlever
+
+class AboutDialog(Toplevel):
+    """
+    modal about dialog for idle
+    """
+    def __init__(self,parent,title):
+        Toplevel.__init__(self, parent)
+        self.configure(borderwidth=5)
+        self.geometry("+%d+%d" % (parent.winfo_rootx()+30,
+                parent.winfo_rooty()+30))
+        self.bg="#707070"
+        self.fg="#ffffff"
+
+        self.CreateWidgets()
+        self.resizable(height=FALSE,width=FALSE)
+        self.title(title)
+        self.transient(parent)
+        self.grab_set()
+        self.protocol("WM_DELETE_WINDOW", self.Ok)
+        self.parent = parent
+        self.buttonOk.focus_set()
+        #key bindings for this dialog
+        self.bind('<Alt-c>',self.CreditsButtonBinding) #credits button
+        self.bind('<Alt-l>',self.LicenseButtonBinding) #license button
+        self.bind('<Return>',self.Ok) #dismiss dialog
+        self.bind('<Escape>',self.Ok) #dismiss dialog
+        self.wait_window()
+
+    def CreateWidgets(self):
+        frameMain = Frame(self,borderwidth=2,relief=SUNKEN)
+        frameButtons = Frame(self)
+        frameButtons.pack(side=BOTTOM,fill=X)
+        frameMain.pack(side=TOP,expand=TRUE,fill=BOTH)
+        self.buttonOk = Button(frameButtons,text='Ok',
+                command=self.Ok)#,default=ACTIVE
+        self.buttonOk.pack(padx=5,pady=5)
+        #self.picture = Image('photo',data=self.pictureData)
+        frameBg = Frame(frameMain,bg=self.bg)
+        frameBg.pack(expand=TRUE,fill=BOTH)
+        labelTitle = Label(frameBg,text='IDLEfork',fg=self.fg,bg=self.bg,
+                font=('courier', 24, 'bold'))
+        labelTitle.grid(row=0,column=0,sticky=W,padx=10,pady=10)
+        #labelPicture = Label(frameBg,text='[picture]')
+        #image=self.picture,bg=self.bg)
+        #labelPicture.grid(row=0,column=1,sticky=W,rowspan=2,padx=0,pady=3)
+        labelVersion = Label(frameBg,text='version  '+idlever.IDLE_VERSION,
+                fg=self.fg,bg=self.bg)
+        labelVersion.grid(row=1,column=0,sticky=W,padx=10,pady=5)
+        labelDesc = Label(frameBg,
+                text="A development version of Python's lightweight\n"+
+                'Integrated DeveLopment Environment, IDLE.',
+                justify=LEFT,fg=self.fg,bg=self.bg)
+        labelDesc.grid(row=2,column=0,sticky=W,columnspan=3,padx=10,pady=5)
+        labelCopyright = Label(frameBg,
+                text="Copyright (c) 2001 Python Software Foundation;\nAll Rights Reserved",
+                justify=LEFT,fg=self.fg,bg=self.bg)
+        labelCopyright.grid(row=3,column=0,sticky=W,columnspan=3,padx=10,pady=5)
+        labelLicense = Label(frameBg,
+                text='Released under the Python 2.1.1 PSF Licence',
+                justify=LEFT,fg=self.fg,bg=self.bg)
+        labelLicense.grid(row=4,column=0,sticky=W,columnspan=3,padx=10,pady=5)
+        Frame(frameBg,height=5,bg=self.bg).grid(row=5,column=0)
+        labelEmail = Label(frameBg,text='email:  idle-dev@python.org',
+                justify=LEFT,fg=self.fg,bg=self.bg)
+        labelEmail.grid(row=6,column=0,columnspan=2,sticky=W,padx=10,pady=0)
+        labelWWW = Label(frameBg,text='www:  http://idlefork.sourceforge.net',
+                justify=LEFT,fg=self.fg,bg=self.bg)
+        labelWWW.grid(row=7,column=0,columnspan=2,sticky=W,padx=10,pady=0)
+        Frame(frameBg,borderwidth=1,relief=SUNKEN,
+                height=2,bg=self.bg).grid(row=8,column=0,sticky=EW,
+                                          columnspan=3, padx=5, pady=5)
+        labelPythonVer = Label(frameBg,text='Python version:  '+
+                sys.version.split()[0],fg=self.fg,bg=self.bg)
+        labelPythonVer.grid(row=9,column=0,sticky=W,padx=10,pady=0)
+        #handle weird tk version num in windoze python >= 1.6 (?!?)
+        tkVer = `TkVersion`.split('.')
+        tkVer[len(tkVer)-1] = str('%.3g' % (float('.'+tkVer[len(tkVer)-1])))[2:]
+        if tkVer[len(tkVer)-1] == '':
+            tkVer[len(tkVer)-1] = '0'
+        tkVer = string.join(tkVer,'.')
+        labelTkVer = Label(frameBg,text='Tk version:  '+
+                tkVer,fg=self.fg,bg=self.bg)
+        labelTkVer.grid(row=9,column=1,sticky=W,padx=2,pady=0)
+
+        self.buttonLicense = Button(frameBg,text='View License',underline=5,
+                width=14,highlightbackground=self.bg,command=self.ShowLicense)#takefocus=FALSE
+        self.buttonLicense.grid(row=10,column=0,sticky=W,padx=10,pady=10)
+        self.buttonCredits = Button(frameBg,text='View Credits',underline=5,
+                width=14,highlightbackground=self.bg,command=self.ShowCredits)#takefocus=FALSE
+        self.buttonCredits.grid(row=10,column=1,columnspan=2,sticky=E,padx=10,pady=10)
+
+    def CreditsButtonBinding(self,event):
+        self.buttonCredits.invoke()
+
+    def LicenseButtonBinding(self,event):
+        self.buttonLicense.invoke()
+
+    def ShowLicense(self):
+        self.ViewFile('About - License','LICENSE.txt')
+
+    def ShowCredits(self):
+        self.ViewFile('About - Credits','CREDITS.txt')
+
+    def ViewFile(self,viewTitle,viewFile):
+        fn=os.path.join(os.path.abspath(os.path.dirname(__file__)),viewFile)
+        textView.TextViewer(self,viewTitle,fn)
+
+    def Ok(self, event=None):
+        self.destroy()
+
+if __name__ == '__main__':
+    #test the dialog
+    root=Tk()
+    def run():
+        import aboutDialog
+        aboutDialog.AboutDialog(root,'About')
+    Button(root,text='Dialog',command=run).pack()
+    root.mainloop()
diff --git a/Tools/idle/boolcheck.py b/Tools/idle/boolcheck.py
new file mode 100644
index 0000000..f682232
--- /dev/null
+++ b/Tools/idle/boolcheck.py
@@ -0,0 +1,9 @@
+"boolcheck - import this module to ensure True, False, bool() builtins exist."
+try:
+    True
+except NameError:
+    import __builtin__
+    __builtin__.True = 1
+    __builtin__.False = 0
+    from operator import truth
+    __builtin__.bool = truth
diff --git a/Tools/idle/config-extensions.def b/Tools/idle/config-extensions.def
new file mode 100644
index 0000000..d4905e8
--- /dev/null
+++ b/Tools/idle/config-extensions.def
@@ -0,0 +1,54 @@
+# IDLE reads several config files to determine user preferences.  This 
+# file is the default config file for idle extensions settings.  
+#
+# Each extension must have at least one section, named after the extension
+# module. This section must contain an 'enable' item (=1 to enable the
+# extension, =0 to disable it) and also contains any other general
+# configuration items for the extension. Each extension may also define up to
+# two optional sections named ExtensionName_bindings and
+# ExtensionName_cfgBindings. If present, ExtensionName_bindings defines virtual
+# event bindings for the extension that are not sensibly re-configurable. If
+# present, ExtensionName_cfgBindings defines virtual event bindings for the
+# extension that may be sensibly re-configured.
+
+# See config-keys.def for notes on specifying keys.
+
+[FormatParagraph]
+enable=1
+[FormatParagraph_cfgBindings]
+format-paragraph=<Alt-Key-q>
+
+[AutoExpand]
+enable=1
+[AutoExpand_cfgBindings]
+expand-word=<Alt-Key-slash>
+
+[ZoomHeight]
+enable=1
+[ZoomHeight_cfgBindings]
+zoom-height=<Alt-Key-2>
+
+[ScriptBinding]
+enable=1
+[ScriptBinding_cfgBindings]
+run-module=<Key-F5>
+check-module=<Alt-Key-x>
+
+[CallTips]
+enable=1
+[CallTips_bindings]
+paren-open=<Key-parenleft>
+paren-close=<Key-parenright>
+check-calltip-cancel=<KeyRelease>
+calltip-cancel=<ButtonPress> <Key-Escape>
+
+[ParenMatch]
+enable=0
+style= expression
+flash-delay= 500
+bell= 1
+hilite-foreground= black
+hilite-background= #43cd80
+[ParenMatch_bindings]
+flash-open-paren=<KeyRelease-parenright> <KeyRelease-bracketright> <KeyRelease-braceright>
+check-restore=<KeyPress>
diff --git a/Tools/idle/config-highlight.def b/Tools/idle/config-highlight.def
new file mode 100644
index 0000000..2b7deab
--- /dev/null
+++ b/Tools/idle/config-highlight.def
@@ -0,0 +1,60 @@
+# IDLE reads several config files to determine user preferences.  This 
+# file is the default config file for idle highlight theme settings.  
+
+[IDLE Classic]
+normal-foreground= #000000
+normal-background= #ffffff
+keyword-foreground= #ff7700
+keyword-background= #ffffff
+comment-foreground= #dd0000
+comment-background= #ffffff
+string-foreground= #00aa00
+string-background= #ffffff
+definition-foreground= #0000ff
+definition-background= #ffffff
+hilite-foreground= #000000
+hilite-background= gray
+break-foreground= black
+break-background= #ffff55
+hit-foreground= #ffffff
+hit-background= #000000
+error-foreground= #000000
+error-background= #ff7777
+#cursor (only foreground can be set) 
+cursor-foreground= black
+#shell window
+stdout-foreground= blue
+stdout-background= #ffffff
+stderr-foreground= red
+stderr-background= #ffffff
+console-foreground= #770000
+console-background= #ffffff
+
+[IDLE New]
+normal-foreground= #000000
+normal-background= #ffffff
+keyword-foreground= #ff7700
+keyword-background= #ffffff
+comment-foreground= #dd0000
+comment-background= #ffffff
+string-foreground= #00aa00
+string-background= #ffffff
+definition-foreground= #0000ff
+definition-background= #ffffff
+hilite-foreground= #000000
+hilite-background= gray
+break-foreground= black
+break-background= #ffff55
+hit-foreground= #ffffff
+hit-background= #000000
+error-foreground= #000000
+error-background= #ff7777
+#cursor (only foreground can be set) 
+cursor-foreground= black
+#shell window
+stdout-foreground= blue
+stdout-background= #ffffff
+stderr-foreground= red
+stderr-background= #ffffff
+console-foreground= #770000
+console-background= #ffffff
diff --git a/Tools/idle/config-keys.def b/Tools/idle/config-keys.def
new file mode 100644
index 0000000..4f2be59
--- /dev/null
+++ b/Tools/idle/config-keys.def
@@ -0,0 +1,155 @@
+# IDLE reads several config files to determine user preferences.  This 
+# file is the default config file for idle key binding settings.  
+# Where multiple keys are specified for an action: if they are separated
+# by a space (eg. action=<key1> <key2>) then the keys are altenatives, if
+# there is no space (eg. action=<key1><key2>) then the keys comprise a
+# single 'emacs style' multi-keystoke binding. The tk event specifier 'Key'
+# is used in all cases, for consistency in auto key conflict checking in the
+# configuration gui.
+
+[IDLE Classic Windows]
+copy=<Control-Key-c>
+cut=<Control-Key-x>
+paste=<Control-Key-v>
+beginning-of-line= <Key-Home>
+center-insert=<Control-Key-l>
+close-all-windows=<Control-Key-q>
+close-window=<Alt-Key-F4> <Meta-Key-F4>
+do-nothing=<Control-Key-F12>
+end-of-file=<Control-Key-d>
+python-docs=<Key-F1>
+python-context-help=<Shift-Key-F1> 
+history-next=<Alt-Key-n> <Meta-Key-n>
+history-previous=<Alt-Key-p> <Meta-Key-p>
+interrupt-execution=<Control-Key-c>
+view-restart=<Key-F6>
+restart-shell=<Control-Key-F6>
+open-class-browser=<Alt-Key-c> <Meta-Key-c>
+open-module=<Alt-Key-m> <Meta-Key-m>
+open-new-window=<Control-Key-n>
+open-window-from-file=<Control-Key-o>
+plain-newline-and-indent=<Control-Key-j>
+print-window=<Control-Key-p>
+redo=<Control-Shift-Key-z>
+remove-selection=<Key-Escape>
+save-copy-of-window-as-file=<Alt-Shift-Key-s>
+save-window-as-file=<Control-Shift-Key-s>
+save-window=<Control-Key-s>
+select-all=<Control-Key-a>
+toggle-auto-coloring=<Control-Key-slash>
+undo=<Control-Key-z>
+find=<Control-Key-f>
+find-again=<Control-Key-g> <Key-F3>
+find-in-files=<Alt-Key-F3> <Meta-Key-F3>
+find-selection=<Control-Key-F3>
+replace=<Control-Key-h>
+goto-line=<Alt-Key-g> <Meta-Key-g>
+smart-backspace=<Key-BackSpace>
+newline-and-indent=<Key-Return> <Key-KP_Enter>
+smart-indent=<Key-Tab>
+indent-region=<Control-Key-bracketright>
+dedent-region=<Control-Key-bracketleft>
+comment-region=<Alt-Key-3> <Meta-Key-3>
+uncomment-region=<Alt-Key-4> <Meta-Key-4>
+tabify-region=<Alt-Key-5> <Meta-Key-5>
+untabify-region=<Alt-Key-6> <Meta-Key-6>
+toggle-tabs=<Alt-Key-t> <Meta-Key-t>
+change-indentwidth=<Alt-Key-u> <Meta-Key-u>
+
+[IDLE Classic Unix]
+copy=<Alt-Key-w> <Meta-Key-w>
+cut=<Control-Key-w>
+paste=<Control-Key-y>
+beginning-of-line=<Control-Key-a> <Key-Home>
+center-insert=<Control-Key-l>
+close-all-windows=<Control-Key-x><Control-Key-c>
+close-window=<Control-Key-x><Control-Key-0>
+do-nothing=<Control-Key-x>
+end-of-file=<Control-Key-d>
+history-next=<Alt-Key-n> <Meta-Key-n>
+history-previous=<Alt-Key-p> <Meta-Key-p>
+interrupt-execution=<Control-Key-c>
+view-restart=<Key-F6>
+restart-shell=<Control-Key-F6>
+open-class-browser=<Control-Key-x><Control-Key-b>
+open-module=<Control-Key-x><Control-Key-m>
+open-new-window=<Control-Key-x><Control-Key-n>
+open-window-from-file=<Control-Key-x><Control-Key-f>
+plain-newline-and-indent=<Control-Key-j>
+print-window=<Control-x><Control-Key-p>
+python-docs=<Control-Key-h> 
+python-context-help=<Control-Shift-Key-h> 
+redo=<Alt-Key-z> <Meta-Key-z>
+remove-selection=<Key-Escape>
+save-copy-of-window-as-file=<Control-Key-x><Control-Key-y>
+save-window-as-file=<Control-Key-x><Control-Key-w>
+save-window=<Control-Key-x><Control-Key-s>
+select-all=<Alt-Key-a> <Meta-Key-a>
+toggle-auto-coloring=<Control-Key-slash>
+undo=<Control-Key-z>
+find=<Control-Key-u><Control-Key-u><Control-Key-s>
+find-again=<Control-Key-u><Control-Key-s>
+find-in-files=<Alt-Key-s> <Meta-Key-s>
+find-selection=<Control-Key-s>
+replace=<Control-Key-r>
+goto-line=<Alt-Key-g> <Meta-Key-g>
+smart-backspace=<Key-BackSpace>
+newline-and-indent=<Key-Return> <Key-KP_Enter>
+smart-indent=<Key-Tab>
+indent-region=<Control-Key-bracketright>
+dedent-region=<Control-Key-bracketleft>
+comment-region=<Alt-Key-3>
+uncomment-region=<Alt-Key-4>
+tabify-region=<Alt-Key-5>
+untabify-region=<Alt-Key-6>
+toggle-tabs=<Alt-Key-t>
+change-indentwidth=<Alt-Key-u>
+
+[IDLE Classic Mac]
+copy=<Command-Key-c>
+cut=<Command-Key-x>
+paste=<Command-Key-v>
+beginning-of-line= <Key-Home>
+center-insert=<Control-Key-l>
+close-all-windows=<Command-Key-q>
+close-window=<Command-Key-w>
+do-nothing=<Control-Key-F12>
+end-of-file=<Control-Key-d>
+python-docs=<Key-F1>
+python-context-help=<Shift-Key-F1> 
+history-next=<Control-Key-n>
+history-previous=<Control-Key-p>
+interrupt-execution=<Control-Key-c>
+view-restart=<Key-F6>
+restart-shell=<Control-Key-F6>
+open-class-browser=<Command-Key-b>
+open-module=<Command-Key-m>
+open-new-window=<Command-Key-n>
+open-window-from-file=<Command-Key-o>
+plain-newline-and-indent=<Control-Key-j>
+print-window=<Command-Key-p>
+redo=<Shift-Command-Key-z> 
+remove-selection=<Key-Escape>
+save-window-as-file=<Shift-Command-Key-s>
+save-window=<Command-Key-s>
+save-copy-of-window-as-file=<Option-Command-Key-s>
+select-all=<Command-Key-a>
+toggle-auto-coloring=<Control-Key-slash>
+undo=<Command-Key-z>
+find=<Command-Key-f>
+find-again=<Command-Key-g> <Key-F3>
+find-in-files=<Command-Key-F3>
+find-selection=<Shift-Command-Key-F3>
+replace=<Command-Key-r>
+goto-line=<Command-Key-j>
+smart-backspace=<Key-BackSpace>
+newline-and-indent=<Key-Return> <Key-KP_Enter>
+smart-indent=<Key-Tab>
+indent-region=<Command-Key-bracketright>
+dedent-region=<Command-Key-bracketleft>
+comment-region=<Control-Key-3>
+uncomment-region=<Control-Key-4>
+tabify-region=<Control-Key-5>
+untabify-region=<Control-Key-6>
+toggle-tabs=<Control-Key-t>
+change-indentwidth=<Control-Key-u>
diff --git a/Tools/idle/config-mac.txt b/Tools/idle/config-mac.txt
deleted file mode 100644
index ee36e13..0000000
--- a/Tools/idle/config-mac.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-[EditorWindow]
-font-name= monaco
-font-size= 9
diff --git a/Tools/idle/config-main.def b/Tools/idle/config-main.def
new file mode 100644
index 0000000..9d520c1
--- /dev/null
+++ b/Tools/idle/config-main.def
@@ -0,0 +1,65 @@
+# IDLE reads several config files to determine user preferences.  This 
+# file is the default config file for general idle settings.
+#  
+# When IDLE starts, it will look in
+# the following two sets of files, in order:
+#
+#     default configuration
+#     ---------------------
+#     config-main.def         the default general config file
+#     config-extensions.def   the default extension config file
+#     config-highlight.def    the default highlighting config file
+#     config-keys.def         the default keybinding config file
+#
+#     user configuration
+#     -------------------
+#     ~/.idlerc/idle-main.cfg            the user general config file
+#     ~/.idlerc/idle-extensions.cfg      the user extension config file
+#     ~/.idlerc/idle-highlight.cfg       the user highlighting config file
+#     ~/.idlerc/idle-keys.cfg            the user keybinding config file
+#
+# Any options the user saves through the config dialog will be saved to
+# the relevant user config file. Reverting any general setting to the 
+# default causes that entry to be wiped from the user file and re-read 
+# from the default file. User highlighting themes or keybinding sets are
+# retained unless specifically deleted within the config dialog. Choosing
+# one of the default themes or keysets just applies the relevant settings 
+# from the default file. 
+#
+# Additional help sources are listed in the [HelpFiles] section and must be
+# viewable by a web browser (or the Windows Help viewer in the case of .chm
+# files). These sources will be listed on the Help menu.  The pattern is 
+# <sequence_number = menu item;/path/to/help/source> 
+# You can't use a semi-colon in a menu item or path.  The path will be platform
+# specific because of path separators, drive specs etc.
+#
+# It is best to use the Configuration GUI to set up additional help sources!
+# Example:
+#1 = My Extra Help Source;/usr/share/doc/foo/index.html
+#2 = Another Help Source;/path/to/another.pdf
+
+[General]
+editor-on-startup= 0
+print-command-posix=lpr %s
+print-command-win=start /min notepad /p %s
+
+[EditorWindow]
+width= 80
+height= 30
+font= courier
+font-size= 12
+font-bold= 0
+
+[Indent]
+use-spaces= 1
+num-spaces= 4
+
+[Theme]
+default= 1  
+name= IDLE Classic
+
+[Keys]
+default= 1  
+name= IDLE Classic Windows
+
+[HelpFiles]
diff --git a/Tools/idle/config-unix.txt b/Tools/idle/config-unix.txt
deleted file mode 100644
index 782965f..0000000
--- a/Tools/idle/config-unix.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-[EditorWindow]
-font-name= courier
-font-size= 10
-print-command=lpr %s
diff --git a/Tools/idle/config-win.txt b/Tools/idle/config-win.txt
deleted file mode 100644
index aeb6ab9..0000000
--- a/Tools/idle/config-win.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-[EditorWindow]
-font-name: courier new
-font-size: 10
-print-command=start /min notepad /p %s
diff --git a/Tools/idle/config.txt b/Tools/idle/config.txt
deleted file mode 100644
index 6f98a3e..0000000
--- a/Tools/idle/config.txt
+++ /dev/null
@@ -1,64 +0,0 @@
-# IDLE reads several config files to determine user preferences.  This 
-# file is the default config file.  When IDLE starts, it will look in
-# the following four files in order:
-#     config.txt                      the default config file
-#     config-[win/unix/mac].txt       the generic platform config file
-#     config-[sys.platform].txt       the specific platform config file
-#     ~/.idle                         the user config file
-# XXX what about Windows?
-#
-# The last definition of each option is used.  For example, you can
-# override the default window size (80x24) by defining width and
-# height options in the EditorWindow section of your ~/.idle file
-#
-# IDLE extensions can be enabled and disabled by adding them to one of
-# the config files.  To enable an extension, create a section with the
-# same name as the extension, e.g. the [ParenMatch] section below.  To
-# disable an extension, either remove the section or add the 'enable'
-# option with the value 0.  
-
-[EditorWindow]
-width= 80
-height= 24
-# fonts defined in config-[win/unix].txt
-
-[Colors]
-normal-foreground= black
-normal-background= white
-# These color types are not explicitly defined= sync, todo, stdin
-keyword-foreground= #ff7700
-comment-foreground= #dd0000
-string-foreground= #00aa00
-definition-foreground= #0000ff
-hilite-foreground= #000068
-hilite-background= #006868
-break-foreground= #ff7777
-hit-foreground= #ffffff
-hit-background= #000000
-stdout-foreground= blue
-stderr-foreground= red
-console-foreground= #770000
-error-background= #ff7777
-cursor-background= black
-
-[SearchBinding]
-
-[AutoIndent]
-
-[AutoExpand]
-
-[FormatParagraph]
-
-[ZoomHeight]
-
-[ScriptBinding]
-
-[CallTips]
-
-[ParenMatch]
-enable= 0
-style= expression
-flash-delay= 500
-bell= 1
-hilite-foreground= black
-hilite-background= #43cd80
diff --git a/Tools/idle/configDialog.py b/Tools/idle/configDialog.py
new file mode 100644
index 0000000..814689c
--- /dev/null
+++ b/Tools/idle/configDialog.py
@@ -0,0 +1,1134 @@
+"""IDLE Configuration Dialog: support user customization of IDLE by GUI
+
+Customize font faces, sizes, and colorization attributes.  Set indentation
+defaults.  Customize keybindings.  Colorization and keybindings can be
+saved as user defined sets.  Select startup options including shell/editor
+and default window size.  Define additional help sources.
+
+Note that tab width in IDLE is currently fixed at eight due to Tk issues.
+Refer to comment in EditorWindow autoindent code for details.
+
+"""
+from Tkinter import *
+import tkMessageBox, tkColorChooser, tkFont
+import string, copy
+
+from configHandler import idleConf
+from dynOptionMenuWidget import DynOptionMenu
+from tabpage import TabPageSet
+from keybindingDialog import GetKeysDialog
+from configSectionNameDialog import GetCfgSectionNameDialog
+from configHelpSourceEdit import GetHelpSourceDialog
+
+class ConfigDialog(Toplevel):
+    """
+    configuration dialog for idle
+    """
+    def __init__(self,parent,title):
+        Toplevel.__init__(self, parent)
+        self.configure(borderwidth=5)
+        self.geometry("+%d+%d" % (parent.winfo_rootx()+20,
+                parent.winfo_rooty()+30))
+        #Theme Elements. Each theme element key is it's display name.
+        #The first value of the tuple is the sample area tag name.
+        #The second value is the display name list sort index.
+        self.themeElements={'Normal Text':('normal','00'),
+            'Python Keywords':('keyword','01'),
+            'Python Definitions':('definition','02'),
+            'Python Comments':('comment','03'),
+            'Python Strings':('string','04'),
+            'Selected Text':('hilite','05'),
+            'Found Text':('hit','06'),
+            'Cursor':('cursor','07'),
+            'Error Text':('error','08'),
+            'Shell Normal Text':('console','09'),
+            'Shell Stdout Text':('stdout','10'),
+            'Shell Stderr Text':('stderr','11')}
+        self.ResetChangedItems() #load initial values in changed items dict
+        self.CreateWidgets()
+        self.resizable(height=FALSE,width=FALSE)
+        self.transient(parent)
+        self.grab_set()
+        self.protocol("WM_DELETE_WINDOW", self.Cancel)
+        self.parent = parent
+        self.tabPages.focus_set()
+        #key bindings for this dialog
+        #self.bind('<Escape>',self.Cancel) #dismiss dialog, no save
+        #self.bind('<Alt-a>',self.Apply) #apply changes, save
+        #self.bind('<F1>',self.Help) #context help
+        self.LoadConfigs()
+        self.AttachVarCallbacks() #avoid callbacks during LoadConfigs
+        self.wait_window()
+
+    def CreateWidgets(self):
+        self.tabPages = TabPageSet(self,
+                pageNames=['Fonts/Tabs','Highlighting','Keys','General'])
+        self.tabPages.ChangePage()#activates default (first) page
+        frameActionButtons = Frame(self)
+        #action buttons
+        self.buttonHelp = Button(frameActionButtons,text='Help',
+                command=self.Help,takefocus=FALSE)
+        self.buttonOk = Button(frameActionButtons,text='Ok',
+                command=self.Ok,takefocus=FALSE)
+        self.buttonApply = Button(frameActionButtons,text='Apply',
+                command=self.Apply,takefocus=FALSE)
+        self.buttonCancel = Button(frameActionButtons,text='Cancel',
+                command=self.Cancel,takefocus=FALSE)
+        self.CreatePageFontTab()
+        self.CreatePageHighlight()
+        self.CreatePageKeys()
+        self.CreatePageGeneral()
+        self.buttonHelp.pack(side=RIGHT,padx=5,pady=5)
+        self.buttonOk.pack(side=LEFT,padx=5,pady=5)
+        self.buttonApply.pack(side=LEFT,padx=5,pady=5)
+        self.buttonCancel.pack(side=LEFT,padx=5,pady=5)
+        frameActionButtons.pack(side=BOTTOM)
+        self.tabPages.pack(side=TOP,expand=TRUE,fill=BOTH)
+
+    def CreatePageFontTab(self):
+        #tkVars
+        self.fontSize=StringVar(self)
+        self.fontBold=BooleanVar(self)
+        self.fontName=StringVar(self)
+        self.spaceNum=IntVar(self)
+        #self.tabCols=IntVar(self)
+        self.indentBySpaces=BooleanVar(self)
+        self.editFont=tkFont.Font(self,('courier',12,'normal'))
+        ##widget creation
+        #body frame
+        frame=self.tabPages.pages['Fonts/Tabs']['page']
+        #body section frames
+        frameFont=Frame(frame,borderwidth=2,relief=GROOVE)
+        frameIndent=Frame(frame,borderwidth=2,relief=GROOVE)
+        #frameFont
+        labelFontTitle=Label(frameFont,text='Set Base Editor Font')
+        frameFontName=Frame(frameFont)
+        frameFontParam=Frame(frameFont)
+        labelFontNameTitle=Label(frameFontName,justify=LEFT,
+                text='Font :')
+        self.listFontName=Listbox(frameFontName,height=5,takefocus=FALSE,
+                exportselection=FALSE)
+        self.listFontName.bind('<ButtonRelease-1>',self.OnListFontButtonRelease)
+        scrollFont=Scrollbar(frameFontName)
+        scrollFont.config(command=self.listFontName.yview)
+        self.listFontName.config(yscrollcommand=scrollFont.set)
+        labelFontSizeTitle=Label(frameFontParam,text='Size :')
+        self.optMenuFontSize=DynOptionMenu(frameFontParam,self.fontSize,None,
+            command=self.SetFontSample)
+        checkFontBold=Checkbutton(frameFontParam,variable=self.fontBold,
+            onvalue=1,offvalue=0,text='Bold',command=self.SetFontSample)
+        frameFontSample=Frame(frameFont,relief=SOLID,borderwidth=1)
+        self.labelFontSample=Label(frameFontSample,
+                text='AaBbCcDdEe\nFfGgHhIiJjK\n1234567890\n#:+=(){}[]',
+                justify=LEFT,font=self.editFont)
+        #frameIndent
+        labelIndentTitle=Label(frameIndent,text='Set Indentation Defaults')
+        frameIndentType=Frame(frameIndent)
+        frameIndentSize=Frame(frameIndent)
+        labelIndentTypeTitle=Label(frameIndentType,
+                text='Choose indentation type :')
+        radioUseSpaces=Radiobutton(frameIndentType,variable=self.indentBySpaces,
+            value=1,text='Tab key inserts spaces')
+        radioUseTabs=Radiobutton(frameIndentType,variable=self.indentBySpaces,
+            value=0,text='Tab key inserts tabs')
+        labelIndentSizeTitle=Label(frameIndentSize,
+                text='Choose indentation size :')
+        labelSpaceNumTitle=Label(frameIndentSize,justify=LEFT,
+                text='indent width')
+        self.scaleSpaceNum=Scale(frameIndentSize,variable=self.spaceNum,
+                orient='horizontal',tickinterval=2,from_=2,to=16)
+        #labeltabColsTitle=Label(frameIndentSize,justify=LEFT,
+        #        text='when tab key inserts tabs,\ncolumns per tab')
+        #self.scaleTabCols=Scale(frameIndentSize,variable=self.tabCols,
+        #        orient='horizontal',tickinterval=2,from_=2,to=8)
+        #widget packing
+        #body
+        frameFont.pack(side=LEFT,padx=5,pady=10,expand=TRUE,fill=BOTH)
+        frameIndent.pack(side=LEFT,padx=5,pady=10,fill=Y)
+        #frameFont
+        labelFontTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        frameFontName.pack(side=TOP,padx=5,pady=5,fill=X)
+        frameFontParam.pack(side=TOP,padx=5,pady=5,fill=X)
+        labelFontNameTitle.pack(side=TOP,anchor=W)
+        self.listFontName.pack(side=LEFT,expand=TRUE,fill=X)
+        scrollFont.pack(side=LEFT,fill=Y)
+        labelFontSizeTitle.pack(side=LEFT,anchor=W)
+        self.optMenuFontSize.pack(side=LEFT,anchor=W)
+        checkFontBold.pack(side=LEFT,anchor=W,padx=20)
+        frameFontSample.pack(side=TOP,padx=5,pady=5,expand=TRUE,fill=BOTH)
+        self.labelFontSample.pack(expand=TRUE,fill=BOTH)
+        #frameIndent
+        labelIndentTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        frameIndentType.pack(side=TOP,padx=5,fill=X)
+        frameIndentSize.pack(side=TOP,padx=5,pady=5,fill=BOTH)
+        labelIndentTypeTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        radioUseSpaces.pack(side=TOP,anchor=W,padx=5)
+        radioUseTabs.pack(side=TOP,anchor=W,padx=5)
+        labelIndentSizeTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        labelSpaceNumTitle.pack(side=TOP,anchor=W,padx=5)
+        self.scaleSpaceNum.pack(side=TOP,padx=5,fill=X)
+        #labeltabColsTitle.pack(side=TOP,anchor=W,padx=5)
+        #self.scaleTabCols.pack(side=TOP,padx=5,fill=X)
+        return frame
+
+    def CreatePageHighlight(self):
+        self.builtinTheme=StringVar(self)
+        self.customTheme=StringVar(self)
+        self.fgHilite=BooleanVar(self)
+        self.colour=StringVar(self)
+        self.fontName=StringVar(self)
+        self.themeIsBuiltin=BooleanVar(self)
+        self.highlightTarget=StringVar(self)
+        ##widget creation
+        #body frame
+        frame=self.tabPages.pages['Highlighting']['page']
+        #body section frames
+        frameCustom=Frame(frame,borderwidth=2,relief=GROOVE)
+        frameTheme=Frame(frame,borderwidth=2,relief=GROOVE)
+        #frameCustom
+        self.textHighlightSample=Text(frameCustom,relief=SOLID,borderwidth=1,
+            font=('courier',12,''),cursor='hand2',width=21,height=10,
+            takefocus=FALSE,highlightthickness=0,wrap=NONE)
+        text=self.textHighlightSample
+        text.bind('<Double-Button-1>',lambda e: 'break')
+        text.bind('<B1-Motion>',lambda e: 'break')
+        textAndTags=(('#you can click here','comment'),('\n','normal'),
+            ('#to choose items','comment'),('\n','normal'),('def','keyword'),
+            (' ','normal'),('func','definition'),('(param):','normal'),
+            ('\n  ','normal'),('"""string"""','string'),('\n  var0 = ','normal'),
+            ("'string'",'string'),('\n  var1 = ','normal'),("'selected'",'hilite'),
+            ('\n  var2 = ','normal'),("'found'",'hit'),('\n\n','normal'),
+            (' error ','error'),(' ','normal'),('cursor |','cursor'),
+            ('\n ','normal'),('shell','console'),(' ','normal'),('stdout','stdout'),
+            (' ','normal'),('stderr','stderr'),('\n','normal'))
+        for txTa in textAndTags:
+            text.insert(END,txTa[0],txTa[1])
+        for element in self.themeElements.keys():
+            text.tag_bind(self.themeElements[element][0],'<ButtonPress-1>',
+                lambda event,elem=element: event.widget.winfo_toplevel()
+                .highlightTarget.set(elem))
+        text.config(state=DISABLED)
+        self.frameColourSet=Frame(frameCustom,relief=SOLID,borderwidth=1)
+        frameFgBg=Frame(frameCustom)
+        labelCustomTitle=Label(frameCustom,text='Set Custom Highlighting')
+        buttonSetColour=Button(self.frameColourSet,text='Choose Colour for :',
+            command=self.GetColour,highlightthickness=0)
+        self.optMenuHighlightTarget=DynOptionMenu(self.frameColourSet,
+            self.highlightTarget,None,highlightthickness=0)#,command=self.SetHighlightTargetBinding
+        self.radioFg=Radiobutton(frameFgBg,variable=self.fgHilite,
+            value=1,text='Foreground',command=self.SetColourSampleBinding)
+        self.radioBg=Radiobutton(frameFgBg,variable=self.fgHilite,
+            value=0,text='Background',command=self.SetColourSampleBinding)
+        self.fgHilite.set(1)
+        buttonSaveCustomTheme=Button(frameCustom,
+            text='Save as New Custom Theme',command=self.SaveAsNewTheme)
+        #frameTheme
+        labelThemeTitle=Label(frameTheme,text='Select a Highlighting Theme')
+        labelTypeTitle=Label(frameTheme,text='Select : ')
+        self.radioThemeBuiltin=Radiobutton(frameTheme,variable=self.themeIsBuiltin,
+            value=1,command=self.SetThemeType,text='a Built-in Theme')
+        self.radioThemeCustom=Radiobutton(frameTheme,variable=self.themeIsBuiltin,
+            value=0,command=self.SetThemeType,text='a Custom Theme')
+        self.optMenuThemeBuiltin=DynOptionMenu(frameTheme,
+            self.builtinTheme,None,command=None)
+        self.optMenuThemeCustom=DynOptionMenu(frameTheme,
+            self.customTheme,None,command=None)
+        self.buttonDeleteCustomTheme=Button(frameTheme,text='Delete Custom Theme',
+                command=self.DeleteCustomTheme)
+        ##widget packing
+        #body
+        frameCustom.pack(side=LEFT,padx=5,pady=10,expand=TRUE,fill=BOTH)
+        frameTheme.pack(side=LEFT,padx=5,pady=10,fill=Y)
+        #frameCustom
+        labelCustomTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        self.frameColourSet.pack(side=TOP,padx=5,pady=5,expand=TRUE,fill=X)
+        frameFgBg.pack(side=TOP,padx=5,pady=0)
+        self.textHighlightSample.pack(side=TOP,padx=5,pady=5,expand=TRUE,
+            fill=BOTH)
+        buttonSetColour.pack(side=TOP,expand=TRUE,fill=X,padx=8,pady=4)
+        self.optMenuHighlightTarget.pack(side=TOP,expand=TRUE,fill=X,padx=8,pady=3)
+        self.radioFg.pack(side=LEFT,anchor=E)
+        self.radioBg.pack(side=RIGHT,anchor=W)
+        buttonSaveCustomTheme.pack(side=BOTTOM,fill=X,padx=5,pady=5)
+        #frameTheme
+        labelThemeTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        labelTypeTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        self.radioThemeBuiltin.pack(side=TOP,anchor=W,padx=5)
+        self.radioThemeCustom.pack(side=TOP,anchor=W,padx=5,pady=2)
+        self.optMenuThemeBuiltin.pack(side=TOP,fill=X,padx=5,pady=5)
+        self.optMenuThemeCustom.pack(side=TOP,fill=X,anchor=W,padx=5,pady=5)
+        self.buttonDeleteCustomTheme.pack(side=TOP,fill=X,padx=5,pady=5)
+        return frame
+
+    def CreatePageKeys(self):
+        #tkVars
+        self.bindingTarget=StringVar(self)
+        self.builtinKeys=StringVar(self)
+        self.customKeys=StringVar(self)
+        self.keysAreBuiltin=BooleanVar(self)
+        self.keyBinding=StringVar(self)
+        ##widget creation
+        #body frame
+        frame=self.tabPages.pages['Keys']['page']
+        #body section frames
+        frameCustom=Frame(frame,borderwidth=2,relief=GROOVE)
+        frameKeySets=Frame(frame,borderwidth=2,relief=GROOVE)
+        #frameCustom
+        frameTarget=Frame(frameCustom)
+        labelCustomTitle=Label(frameCustom,text='Set Custom Key Bindings')
+        labelTargetTitle=Label(frameTarget,text='Action - Key(s)')
+        scrollTargetY=Scrollbar(frameTarget)
+        scrollTargetX=Scrollbar(frameTarget,orient=HORIZONTAL)
+        self.listBindings=Listbox(frameTarget,takefocus=FALSE,
+                exportselection=FALSE)
+        self.listBindings.bind('<ButtonRelease-1>',self.KeyBindingSelected)
+        scrollTargetY.config(command=self.listBindings.yview)
+        scrollTargetX.config(command=self.listBindings.xview)
+        self.listBindings.config(yscrollcommand=scrollTargetY.set)
+        self.listBindings.config(xscrollcommand=scrollTargetX.set)
+        self.buttonNewKeys=Button(frameCustom,text='Get New Keys for Selection',
+            command=self.GetNewKeys,state=DISABLED)
+        buttonSaveCustomKeys=Button(frameCustom,
+                text='Save as New Custom Key Set',command=self.SaveAsNewKeySet)
+        #frameKeySets
+        labelKeysTitle=Label(frameKeySets,text='Select a Key Set')
+        labelTypeTitle=Label(frameKeySets,text='Select : ')
+        self.radioKeysBuiltin=Radiobutton(frameKeySets,variable=self.keysAreBuiltin,
+            value=1,command=self.SetKeysType,text='a Built-in Key Set')
+        self.radioKeysCustom=Radiobutton(frameKeySets,variable=self.keysAreBuiltin,
+            value=0,command=self.SetKeysType,text='a Custom Key Set')
+        self.optMenuKeysBuiltin=DynOptionMenu(frameKeySets,
+            self.builtinKeys,None,command=None)
+        self.optMenuKeysCustom=DynOptionMenu(frameKeySets,
+            self.customKeys,None,command=None)
+        self.buttonDeleteCustomKeys=Button(frameKeySets,text='Delete Custom Key Set',
+                command=self.DeleteCustomKeys)
+        ##widget packing
+        #body
+        frameCustom.pack(side=LEFT,padx=5,pady=5,expand=TRUE,fill=BOTH)
+        frameKeySets.pack(side=LEFT,padx=5,pady=5,fill=Y)
+        #frameCustom
+        labelCustomTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        buttonSaveCustomKeys.pack(side=BOTTOM,fill=X,padx=5,pady=5)
+        self.buttonNewKeys.pack(side=BOTTOM,fill=X,padx=5,pady=5)
+        frameTarget.pack(side=LEFT,padx=5,pady=5,expand=TRUE,fill=BOTH)
+        #frame target
+        frameTarget.columnconfigure(0,weight=1)
+        frameTarget.rowconfigure(1,weight=1)
+        labelTargetTitle.grid(row=0,column=0,columnspan=2,sticky=W)
+        self.listBindings.grid(row=1,column=0,sticky=NSEW)
+        scrollTargetY.grid(row=1,column=1,sticky=NS)
+        scrollTargetX.grid(row=2,column=0,sticky=EW)
+        #frameKeySets
+        labelKeysTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        labelTypeTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        self.radioKeysBuiltin.pack(side=TOP,anchor=W,padx=5)
+        self.radioKeysCustom.pack(side=TOP,anchor=W,padx=5,pady=2)
+        self.optMenuKeysBuiltin.pack(side=TOP,fill=X,padx=5,pady=5)
+        self.optMenuKeysCustom.pack(side=TOP,fill=X,anchor=W,padx=5,pady=5)
+        self.buttonDeleteCustomKeys.pack(side=TOP,fill=X,padx=5,pady=5)
+        return frame
+
+    def CreatePageGeneral(self):
+        #tkVars
+        self.winWidth=StringVar(self)
+        self.winHeight=StringVar(self)
+        self.startupEdit=IntVar(self)
+        self.userHelpBrowser=BooleanVar(self)
+        self.helpBrowser=StringVar(self)
+        #widget creation
+        #body
+        frame=self.tabPages.pages['General']['page']
+        #body section frames
+        frameRun=Frame(frame,borderwidth=2,relief=GROOVE)
+        frameWinSize=Frame(frame,borderwidth=2,relief=GROOVE)
+        frameHelp=Frame(frame,borderwidth=2,relief=GROOVE)
+        #frameRun
+        labelRunTitle=Label(frameRun,text='Startup Preferences')
+        labelRunChoiceTitle=Label(frameRun,text='On Startup : ')
+        radioStartupEdit=Radiobutton(frameRun,variable=self.startupEdit,
+            value=1,command=self.SetKeysType,text="Open Edit Window")
+        radioStartupShell=Radiobutton(frameRun,variable=self.startupEdit,
+            value=0,command=self.SetKeysType,text='Open Shell Window')
+        #frameWinSize
+        labelWinSizeTitle=Label(frameWinSize,text='Initial Window Size'+
+                '  (in characters)')
+        labelWinWidthTitle=Label(frameWinSize,text='Width')
+        entryWinWidth=Entry(frameWinSize,textvariable=self.winWidth,
+                width=3)
+        labelWinHeightTitle=Label(frameWinSize,text='Height')
+        entryWinHeight=Entry(frameWinSize,textvariable=self.winHeight,
+                width=3)
+        #frameHelp
+        labelHelpTitle=Label(frameHelp,text='Help Options')
+        frameHelpList=Frame(frameHelp)
+        frameHelpListButtons=Frame(frameHelpList)
+        labelHelpListTitle=Label(frameHelpList,text='Additional Help Sources:')
+        scrollHelpList=Scrollbar(frameHelpList)
+        self.listHelp=Listbox(frameHelpList,height=5,takefocus=FALSE,
+                exportselection=FALSE)
+        scrollHelpList.config(command=self.listHelp.yview)
+        self.listHelp.config(yscrollcommand=scrollHelpList.set)
+        self.listHelp.bind('<ButtonRelease-1>',self.HelpSourceSelected)
+        self.buttonHelpListEdit=Button(frameHelpListButtons,text='Edit',
+                state=DISABLED,width=8,command=self.HelpListItemEdit)
+        self.buttonHelpListAdd=Button(frameHelpListButtons,text='Add',
+                width=8,command=self.HelpListItemAdd)
+        self.buttonHelpListRemove=Button(frameHelpListButtons,text='Remove',
+                state=DISABLED,width=8,command=self.HelpListItemRemove)
+        # the following is better handled by the BROWSER environment
+        # variable under unix/linux
+        #checkHelpBrowser=Checkbutton(frameHelp,variable=self.userHelpBrowser,
+        #    onvalue=1,offvalue=0,text='user specified (html) help browser:',
+        #    command=self.OnCheckUserHelpBrowser)
+        #self.entryHelpBrowser=Entry(frameHelp,textvariable=self.helpBrowser,
+        #        width=40)
+        #widget packing
+        #body
+        frameRun.pack(side=TOP,padx=5,pady=5,fill=X)
+        frameWinSize.pack(side=TOP,padx=5,pady=5,fill=X)
+        frameHelp.pack(side=TOP,padx=5,pady=5,expand=TRUE,fill=BOTH)
+        #frameRun
+        labelRunTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        labelRunChoiceTitle.pack(side=LEFT,anchor=W,padx=5,pady=5)
+        radioStartupEdit.pack(side=LEFT,anchor=W,padx=5,pady=5)
+        radioStartupShell.pack(side=LEFT,anchor=W,padx=5,pady=5)
+        #frameWinSize
+        labelWinSizeTitle.pack(side=LEFT,anchor=W,padx=5,pady=5)
+        entryWinHeight.pack(side=RIGHT,anchor=E,padx=10,pady=5)
+        labelWinHeightTitle.pack(side=RIGHT,anchor=E,pady=5)
+        entryWinWidth.pack(side=RIGHT,anchor=E,padx=10,pady=5)
+        labelWinWidthTitle.pack(side=RIGHT,anchor=E,pady=5)
+        #frameHelp
+        labelHelpTitle.pack(side=TOP,anchor=W,padx=5,pady=5)
+        frameHelpListButtons.pack(side=RIGHT,padx=5,pady=5,fill=Y)
+        frameHelpList.pack(side=TOP,padx=5,pady=5,expand=TRUE,fill=BOTH)
+        labelHelpListTitle.pack(side=TOP,anchor=W)
+        scrollHelpList.pack(side=RIGHT,anchor=W,fill=Y)
+        self.listHelp.pack(side=LEFT,anchor=E,expand=TRUE,fill=BOTH)
+        self.buttonHelpListEdit.pack(side=TOP,anchor=W,pady=5)
+        self.buttonHelpListAdd.pack(side=TOP,anchor=W)
+        self.buttonHelpListRemove.pack(side=TOP,anchor=W,pady=5)
+        #checkHelpBrowser.pack(side=TOP,anchor=W,padx=5)
+        #self.entryHelpBrowser.pack(side=TOP,anchor=W,padx=5,pady=5)
+        return frame
+
+    def AttachVarCallbacks(self):
+        self.fontSize.trace_variable('w',self.VarChanged_fontSize)
+        self.fontName.trace_variable('w',self.VarChanged_fontName)
+        self.fontBold.trace_variable('w',self.VarChanged_fontBold)
+        self.spaceNum.trace_variable('w',self.VarChanged_spaceNum)
+        #self.tabCols.trace_variable('w',self.VarChanged_tabCols)
+        self.indentBySpaces.trace_variable('w',self.VarChanged_indentBySpaces)
+        self.colour.trace_variable('w',self.VarChanged_colour)
+        self.builtinTheme.trace_variable('w',self.VarChanged_builtinTheme)
+        self.customTheme.trace_variable('w',self.VarChanged_customTheme)
+        self.themeIsBuiltin.trace_variable('w',self.VarChanged_themeIsBuiltin)
+        self.highlightTarget.trace_variable('w',self.VarChanged_highlightTarget)
+        self.keyBinding.trace_variable('w',self.VarChanged_keyBinding)
+        self.builtinKeys.trace_variable('w',self.VarChanged_builtinKeys)
+        self.customKeys.trace_variable('w',self.VarChanged_customKeys)
+        self.keysAreBuiltin.trace_variable('w',self.VarChanged_keysAreBuiltin)
+        self.winWidth.trace_variable('w',self.VarChanged_winWidth)
+        self.winHeight.trace_variable('w',self.VarChanged_winHeight)
+        self.startupEdit.trace_variable('w',self.VarChanged_startupEdit)
+
+    def VarChanged_fontSize(self,*params):
+        value=self.fontSize.get()
+        self.AddChangedItem('main','EditorWindow','font-size',value)
+
+    def VarChanged_fontName(self,*params):
+        value=self.fontName.get()
+        self.AddChangedItem('main','EditorWindow','font',value)
+
+    def VarChanged_fontBold(self,*params):
+        value=self.fontBold.get()
+        self.AddChangedItem('main','EditorWindow','font-bold',value)
+
+    def VarChanged_indentBySpaces(self,*params):
+        value=self.indentBySpaces.get()
+        self.AddChangedItem('main','Indent','use-spaces',value)
+
+    def VarChanged_spaceNum(self,*params):
+        value=self.spaceNum.get()
+        self.AddChangedItem('main','Indent','num-spaces',value)
+
+    #def VarChanged_tabCols(self,*params):
+    #    value=self.tabCols.get()
+    #    self.AddChangedItem('main','Indent','tab-cols',value)
+
+    def VarChanged_colour(self,*params):
+        self.OnNewColourSet()
+
+    def VarChanged_builtinTheme(self,*params):
+        value=self.builtinTheme.get()
+        self.AddChangedItem('main','Theme','name',value)
+        self.PaintThemeSample()
+
+    def VarChanged_customTheme(self,*params):
+        value=self.customTheme.get()
+        if value != '- no custom themes -':
+            self.AddChangedItem('main','Theme','name',value)
+            self.PaintThemeSample()
+
+    def VarChanged_themeIsBuiltin(self,*params):
+        value=self.themeIsBuiltin.get()
+        self.AddChangedItem('main','Theme','default',value)
+        if value:
+            self.VarChanged_builtinTheme()
+        else:
+            self.VarChanged_customTheme()
+
+    def VarChanged_highlightTarget(self,*params):
+        self.SetHighlightTarget()
+
+    def VarChanged_keyBinding(self,*params):
+        value=self.keyBinding.get()
+        keySet=self.customKeys.get()
+        event=self.listBindings.get(ANCHOR).split()[0]
+        if idleConf.IsCoreBinding(event):
+            #this is a core keybinding
+            self.AddChangedItem('keys',keySet,event,value)
+        else: #this is an extension key binding
+            extName=idleConf.GetExtnNameForEvent(event)
+            extKeybindSection=extName+'_cfgBindings'
+            self.AddChangedItem('extensions',extKeybindSection,event,value)
+
+    def VarChanged_builtinKeys(self,*params):
+        value=self.builtinKeys.get()
+        self.AddChangedItem('main','Keys','name',value)
+        self.LoadKeysList(value)
+
+    def VarChanged_customKeys(self,*params):
+        value=self.customKeys.get()
+        if value != '- no custom keys -':
+            self.AddChangedItem('main','Keys','name',value)
+            self.LoadKeysList(value)
+
+    def VarChanged_keysAreBuiltin(self,*params):
+        value=self.keysAreBuiltin.get()
+        self.AddChangedItem('main','Keys','default',value)
+        if value:
+            self.VarChanged_builtinKeys()
+        else:
+            self.VarChanged_customKeys()
+
+    def VarChanged_winWidth(self,*params):
+        value=self.winWidth.get()
+        self.AddChangedItem('main','EditorWindow','width',value)
+
+    def VarChanged_winHeight(self,*params):
+        value=self.winHeight.get()
+        self.AddChangedItem('main','EditorWindow','height',value)
+
+    def VarChanged_startupEdit(self,*params):
+        value=self.startupEdit.get()
+        self.AddChangedItem('main','General','editor-on-startup',value)
+
+    def ResetChangedItems(self):
+        #When any config item is changed in this dialog, an entry
+        #should be made in the relevant section (config type) of this
+        #dictionary. The key should be the config file section name and the
+        #value a dictionary, whose key:value pairs are item=value pairs for
+        #that config file section.
+        self.changedItems={'main':{},'highlight':{},'keys':{},'extensions':{}}
+
+    def AddChangedItem(self,type,section,item,value):
+        value=str(value) #make sure we use a string
+        if not self.changedItems[type].has_key(section):
+            self.changedItems[type][section]={}
+        self.changedItems[type][section][item]=value
+
+    def GetDefaultItems(self):
+        dItems={'main':{},'highlight':{},'keys':{},'extensions':{}}
+        for configType in dItems.keys():
+            sections=idleConf.GetSectionList('default',configType)
+            for section in sections:
+                dItems[configType][section]={}
+                options=idleConf.defaultCfg[configType].GetOptionList(section)
+                for option in options:
+                    dItems[configType][section][option]=(
+                            idleConf.defaultCfg[configType].Get(section,option))
+        return dItems
+
+    def SetThemeType(self):
+        if self.themeIsBuiltin.get():
+            self.optMenuThemeBuiltin.config(state=NORMAL)
+            self.optMenuThemeCustom.config(state=DISABLED)
+            self.buttonDeleteCustomTheme.config(state=DISABLED)
+        else:
+            self.optMenuThemeBuiltin.config(state=DISABLED)
+            self.radioThemeCustom.config(state=NORMAL)
+            self.optMenuThemeCustom.config(state=NORMAL)
+            self.buttonDeleteCustomTheme.config(state=NORMAL)
+
+    def SetKeysType(self):
+        if self.keysAreBuiltin.get():
+            self.optMenuKeysBuiltin.config(state=NORMAL)
+            self.optMenuKeysCustom.config(state=DISABLED)
+            self.buttonDeleteCustomKeys.config(state=DISABLED)
+        else:
+            self.optMenuKeysBuiltin.config(state=DISABLED)
+            self.radioKeysCustom.config(state=NORMAL)
+            self.optMenuKeysCustom.config(state=NORMAL)
+            self.buttonDeleteCustomKeys.config(state=NORMAL)
+
+    def GetNewKeys(self):
+        listIndex=self.listBindings.index(ANCHOR)
+        binding=self.listBindings.get(listIndex)
+        bindName=binding.split()[0] #first part, up to first space
+        if self.keysAreBuiltin.get():
+            currentKeySetName=self.builtinKeys.get()
+        else:
+            currentKeySetName=self.customKeys.get()
+        currentBindings=idleConf.GetCurrentKeySet()
+        if currentKeySetName in self.changedItems['keys'].keys(): #unsaved changes
+            keySetChanges=self.changedItems['keys'][currentKeySetName]
+            for event in keySetChanges.keys():
+                currentBindings[event]=keySetChanges[event].split()
+        currentKeySequences=currentBindings.values()
+        newKeys=GetKeysDialog(self,'Get New Keys',bindName,
+                currentKeySequences).result
+        if newKeys: #new keys were specified
+            if self.keysAreBuiltin.get(): #current key set is a built-in
+                message=('Your changes will be saved as a new Custom Key Set. '+
+                        'Enter a name for your new Custom Key Set below.')
+                newKeySet=self.GetNewKeysName(message)
+                if not newKeySet: #user cancelled custom key set creation
+                    self.listBindings.select_set(listIndex)
+                    self.listBindings.select_anchor(listIndex)
+                    return
+                else: #create new custom key set based on previously active key set
+                    self.CreateNewKeySet(newKeySet)
+            self.listBindings.delete(listIndex)
+            self.listBindings.insert(listIndex,bindName+' - '+newKeys)
+            self.listBindings.select_set(listIndex)
+            self.listBindings.select_anchor(listIndex)
+            self.keyBinding.set(newKeys)
+        else:
+            self.listBindings.select_set(listIndex)
+            self.listBindings.select_anchor(listIndex)
+
+    def GetNewKeysName(self,message):
+        usedNames=(idleConf.GetSectionList('user','keys')+
+                idleConf.GetSectionList('default','keys'))
+        newKeySet=GetCfgSectionNameDialog(self,'New Custom Key Set',
+                message,usedNames).result
+        return newKeySet
+
+    def SaveAsNewKeySet(self):
+        newKeysName=self.GetNewKeysName('New Key Set Name:')
+        if newKeysName:
+            self.CreateNewKeySet(newKeysName)
+
+    def KeyBindingSelected(self,event):
+        self.buttonNewKeys.config(state=NORMAL)
+
+    def CreateNewKeySet(self,newKeySetName):
+        #creates new custom key set based on the previously active key set,
+        #and makes the new key set active
+        if self.keysAreBuiltin.get():
+            prevKeySetName=self.builtinKeys.get()
+        else:
+            prevKeySetName=self.customKeys.get()
+        prevKeys=idleConf.GetCoreKeys(prevKeySetName)
+        newKeys={}
+        for event in prevKeys.keys(): #add key set to changed items
+            eventName=event[2:-2] #trim off the angle brackets
+            binding=string.join(prevKeys[event])
+            newKeys[eventName]=binding
+        #handle any unsaved changes to prev key set
+        if prevKeySetName in self.changedItems['keys'].keys():
+            keySetChanges=self.changedItems['keys'][prevKeySetName]
+            for event in keySetChanges.keys():
+                newKeys[event]=keySetChanges[event]
+        #save the new theme
+        self.SaveNewKeySet(newKeySetName,newKeys)
+        #change gui over to the new key set
+        customKeyList=idleConf.GetSectionList('user','keys')
+        customKeyList.sort()
+        self.optMenuKeysCustom.SetMenu(customKeyList,newKeySetName)
+        self.keysAreBuiltin.set(0)
+        self.SetKeysType()
+
+    def LoadKeysList(self,keySetName):
+        reselect=0
+        newKeySet=0
+        if self.listBindings.curselection():
+            reselect=1
+            listIndex=self.listBindings.index(ANCHOR)
+        keySet=idleConf.GetKeySet(keySetName)
+        bindNames=keySet.keys()
+        bindNames.sort()
+        self.listBindings.delete(0,END)
+        for bindName in bindNames:
+            key=string.join(keySet[bindName]) #make key(s) into a string
+            bindName=bindName[2:-2] #trim off the angle brackets
+            if keySetName in self.changedItems['keys'].keys():
+                #handle any unsaved changes to this key set
+                if bindName in self.changedItems['keys'][keySetName].keys():
+                    key=self.changedItems['keys'][keySetName][bindName]
+            self.listBindings.insert(END, bindName+' - '+key)
+        if reselect:
+            self.listBindings.see(listIndex)
+            self.listBindings.select_set(listIndex)
+            self.listBindings.select_anchor(listIndex)
+
+    def DeleteCustomKeys(self):
+        keySetName=self.customKeys.get()
+        if not tkMessageBox.askyesno('Delete Key Set','Are you sure you wish '+
+                                     'to delete the key set '+`keySetName`+' ?',
+                                     parent=self):
+            return
+        #remove key set from config
+        idleConf.userCfg['keys'].remove_section(keySetName)
+        if self.changedItems['keys'].has_key(keySetName):
+            del(self.changedItems['keys'][keySetName])
+        #write changes
+        idleConf.userCfg['keys'].Save()
+        #reload user key set list
+        itemList=idleConf.GetSectionList('user','keys')
+        itemList.sort()
+        if not itemList:
+            self.radioKeysCustom.config(state=DISABLED)
+            self.optMenuKeysCustom.SetMenu(itemList,'- no custom keys -')
+        else:
+            self.optMenuKeysCustom.SetMenu(itemList,itemList[0])
+        #revert to default key set
+        self.keysAreBuiltin.set(idleConf.defaultCfg['main'].Get('Keys','default'))
+        self.builtinKeys.set(idleConf.defaultCfg['main'].Get('Keys','name'))
+        #user can't back out of these changes, they must be applied now
+        self.Apply()
+        self.SetKeysType()
+
+    def DeleteCustomTheme(self):
+        themeName=self.customTheme.get()
+        if not tkMessageBox.askyesno('Delete Theme','Are you sure you wish '+
+                                     'to delete the theme '+`themeName`+' ?',
+                                     parent=self):
+            return
+        #remove theme from config
+        idleConf.userCfg['highlight'].remove_section(themeName)
+        if self.changedItems['highlight'].has_key(themeName):
+            del(self.changedItems['highlight'][themeName])
+        #write changes
+        idleConf.userCfg['highlight'].Save()
+        #reload user theme list
+        itemList=idleConf.GetSectionList('user','highlight')
+        itemList.sort()
+        if not itemList:
+            self.radioThemeCustom.config(state=DISABLED)
+            self.optMenuThemeCustom.SetMenu(itemList,'- no custom themes -')
+        else:
+            self.optMenuThemeCustom.SetMenu(itemList,itemList[0])
+        #revert to default theme
+        self.themeIsBuiltin.set(idleConf.defaultCfg['main'].Get('Theme','default'))
+        self.builtinTheme.set(idleConf.defaultCfg['main'].Get('Theme','name'))
+        #user can't back out of these changes, they must be applied now
+        self.Apply()
+        self.SetThemeType()
+
+    def GetColour(self):
+        target=self.highlightTarget.get()
+        prevColour=self.frameColourSet.cget('bg')
+        rgbTuplet, colourString = tkColorChooser.askcolor(parent=self,
+            title='Pick new colour for : '+target,initialcolor=prevColour)
+        if colourString and (colourString!=prevColour):
+            #user didn't cancel, and they chose a new colour
+            if self.themeIsBuiltin.get(): #current theme is a built-in
+                message=('Your changes will be saved as a new Custom Theme. '+
+                        'Enter a name for your new Custom Theme below.')
+                newTheme=self.GetNewThemeName(message)
+                if not newTheme: #user cancelled custom theme creation
+                    return
+                else: #create new custom theme based on previously active theme
+                    self.CreateNewTheme(newTheme)
+                    self.colour.set(colourString)
+            else: #current theme is user defined
+                self.colour.set(colourString)
+
+    def OnNewColourSet(self):
+        newColour=self.colour.get()
+        self.frameColourSet.config(bg=newColour)#set sample
+        if self.fgHilite.get(): plane='foreground'
+        else: plane='background'
+        sampleElement=self.themeElements[self.highlightTarget.get()][0]
+        apply(self.textHighlightSample.tag_config,
+                (sampleElement,),{plane:newColour})
+        theme=self.customTheme.get()
+        themeElement=sampleElement+'-'+plane
+        self.AddChangedItem('highlight',theme,themeElement,newColour)
+
+    def GetNewThemeName(self,message):
+        usedNames=(idleConf.GetSectionList('user','highlight')+
+                idleConf.GetSectionList('default','highlight'))
+        newTheme=GetCfgSectionNameDialog(self,'New Custom Theme',
+                message,usedNames).result
+        return newTheme
+
+    def SaveAsNewTheme(self):
+        newThemeName=self.GetNewThemeName('New Theme Name:')
+        if newThemeName:
+            self.CreateNewTheme(newThemeName)
+
+    def CreateNewTheme(self,newThemeName):
+        #creates new custom theme based on the previously active theme,
+        #and makes the new theme active
+        if self.themeIsBuiltin.get():
+            themeType='default'
+            themeName=self.builtinTheme.get()
+        else:
+            themeType='user'
+            themeName=self.customTheme.get()
+        newTheme=idleConf.GetThemeDict(themeType,themeName)
+        #apply any of the old theme's unsaved changes to the new theme
+        if themeName in self.changedItems['highlight'].keys():
+            themeChanges=self.changedItems['highlight'][themeName]
+            for element in themeChanges.keys():
+                newTheme[element]=themeChanges[element]
+        #save the new theme
+        self.SaveNewTheme(newThemeName,newTheme)
+        #change gui over to the new theme
+        customThemeList=idleConf.GetSectionList('user','highlight')
+        customThemeList.sort()
+        self.optMenuThemeCustom.SetMenu(customThemeList,newThemeName)
+        self.themeIsBuiltin.set(0)
+        self.SetThemeType()
+
+    def OnListFontButtonRelease(self,event):
+        self.fontName.set(self.listFontName.get(ANCHOR))
+        self.SetFontSample()
+
+    def SetFontSample(self,event=None):
+        fontName=self.fontName.get()
+        if self.fontBold.get():
+            fontWeight=tkFont.BOLD
+        else:
+            fontWeight=tkFont.NORMAL
+        self.editFont.config(size=self.fontSize.get(),
+                weight=fontWeight,family=fontName)
+
+    def SetHighlightTarget(self):
+        if self.highlightTarget.get()=='Cursor': #bg not possible
+            self.radioFg.config(state=DISABLED)
+            self.radioBg.config(state=DISABLED)
+            self.fgHilite.set(1)
+        else: #both fg and bg can be set
+            self.radioFg.config(state=NORMAL)
+            self.radioBg.config(state=NORMAL)
+            self.fgHilite.set(1)
+        self.SetColourSample()
+
+    def SetColourSampleBinding(self,*args):
+        self.SetColourSample()
+
+    def SetColourSample(self):
+        #set the colour smaple area
+        tag=self.themeElements[self.highlightTarget.get()][0]
+        if self.fgHilite.get(): plane='foreground'
+        else: plane='background'
+        colour=self.textHighlightSample.tag_cget(tag,plane)
+        self.frameColourSet.config(bg=colour)
+
+    def PaintThemeSample(self):
+        if self.themeIsBuiltin.get(): #a default theme
+            theme=self.builtinTheme.get()
+        else: #a user theme
+            theme=self.customTheme.get()
+        for elementTitle in self.themeElements.keys():
+            element=self.themeElements[elementTitle][0]
+            colours=idleConf.GetHighlight(theme,element)
+            if element=='cursor': #cursor sample needs special painting
+                colours['background']=idleConf.GetHighlight(theme,
+                        'normal', fgBg='bg')
+            #handle any unsaved changes to this theme
+            if theme in self.changedItems['highlight'].keys():
+                themeDict=self.changedItems['highlight'][theme]
+                if themeDict.has_key(element+'-foreground'):
+                    colours['foreground']=themeDict[element+'-foreground']
+                if themeDict.has_key(element+'-background'):
+                    colours['background']=themeDict[element+'-background']
+            apply(self.textHighlightSample.tag_config,(element,),colours)
+        self.SetColourSample()
+
+##     def OnCheckUserHelpBrowser(self):
+##         if self.userHelpBrowser.get():
+##             self.entryHelpBrowser.config(state=NORMAL)
+##         else:
+##             self.entryHelpBrowser.config(state=DISABLED)
+
+    def HelpSourceSelected(self,event):
+        self.SetHelpListButtonStates()
+
+    def SetHelpListButtonStates(self):
+        if self.listHelp.size()<1: #no entries in list
+            self.buttonHelpListEdit.config(state=DISABLED)
+            self.buttonHelpListRemove.config(state=DISABLED)
+        else: #there are some entries
+            if self.listHelp.curselection(): #there currently is a selection
+                self.buttonHelpListEdit.config(state=NORMAL)
+                self.buttonHelpListRemove.config(state=NORMAL)
+            else:  #there currently is not a selection
+                self.buttonHelpListEdit.config(state=DISABLED)
+                self.buttonHelpListRemove.config(state=DISABLED)
+
+    def HelpListItemAdd(self):
+        helpSource=GetHelpSourceDialog(self,'New Help Source').result
+        if helpSource:
+            self.userHelpList.append( (helpSource[0],helpSource[1]) )
+            self.listHelp.insert(END,helpSource[0])
+            self.UpdateUserHelpChangedItems()
+        self.SetHelpListButtonStates()
+
+    def HelpListItemEdit(self):
+        itemIndex=self.listHelp.index(ANCHOR)
+        helpSource=self.userHelpList[itemIndex]
+        newHelpSource=GetHelpSourceDialog(self,'Edit Help Source',
+                menuItem=helpSource[0],filePath=helpSource[1]).result
+        if (not newHelpSource) or (newHelpSource==helpSource):
+            return #no changes
+        self.userHelpList[itemIndex]=newHelpSource
+        self.listHelp.delete(itemIndex)
+        self.listHelp.insert(itemIndex,newHelpSource[0])
+        self.UpdateUserHelpChangedItems()
+        self.SetHelpListButtonStates()
+
+    def HelpListItemRemove(self):
+        itemIndex=self.listHelp.index(ANCHOR)
+        del(self.userHelpList[itemIndex])
+        self.listHelp.delete(itemIndex)
+        self.UpdateUserHelpChangedItems()
+        self.SetHelpListButtonStates()
+
+    def UpdateUserHelpChangedItems(self):
+        "Clear and rebuild the HelpFiles section in self.changedItems"
+        self.changedItems['main']['HelpFiles'] = {}
+        for num in range(1,len(self.userHelpList)+1):
+            self.AddChangedItem('main','HelpFiles',str(num),
+                    string.join(self.userHelpList[num-1][:2],';'))
+
+    def LoadFontCfg(self):
+        ##base editor font selection list
+        fonts=list(tkFont.families(self))
+        fonts.sort()
+        for font in fonts:
+            self.listFontName.insert(END,font)
+        configuredFont=idleConf.GetOption('main','EditorWindow','font',
+                default='courier')
+        self.fontName.set(configuredFont)
+        if configuredFont in fonts:
+            currentFontIndex=fonts.index(configuredFont)
+            self.listFontName.see(currentFontIndex)
+            self.listFontName.select_set(currentFontIndex)
+            self.listFontName.select_anchor(currentFontIndex)
+        ##font size dropdown
+        fontSize=idleConf.GetOption('main','EditorWindow','font-size',
+                default='12')
+        self.optMenuFontSize.SetMenu(('7','8','9','10','11','12','13','14',
+                '16','18','20','22'),fontSize )
+        ##fontWeight
+        self.fontBold.set(idleConf.GetOption('main','EditorWindow',
+                'font-bold',default=0,type='bool'))
+        ##font sample
+        self.SetFontSample()
+
+    def LoadTabCfg(self):
+        ##indent type radiobuttons
+        spaceIndent=idleConf.GetOption('main','Indent','use-spaces',
+                default=1,type='bool')
+        self.indentBySpaces.set(spaceIndent)
+        ##indent sizes
+        spaceNum=idleConf.GetOption('main','Indent','num-spaces',
+                default=4,type='int')
+        #tabCols=idleConf.GetOption('main','Indent','tab-cols',
+        #        default=4,type='int')
+        self.spaceNum.set(spaceNum)
+        #self.tabCols.set(tabCols)
+
+    def LoadThemeCfg(self):
+        ##current theme type radiobutton
+        self.themeIsBuiltin.set(idleConf.GetOption('main','Theme','default',
+            type='bool',default=1))
+        ##currently set theme
+        currentOption=idleConf.CurrentTheme()
+        ##load available theme option menus
+        if self.themeIsBuiltin.get(): #default theme selected
+            itemList=idleConf.GetSectionList('default','highlight')
+            itemList.sort()
+            self.optMenuThemeBuiltin.SetMenu(itemList,currentOption)
+            itemList=idleConf.GetSectionList('user','highlight')
+            itemList.sort()
+            if not itemList:
+                self.radioThemeCustom.config(state=DISABLED)
+                self.customTheme.set('- no custom themes -')
+            else:
+                self.optMenuThemeCustom.SetMenu(itemList,itemList[0])
+        else: #user theme selected
+            itemList=idleConf.GetSectionList('user','highlight')
+            itemList.sort()
+            self.optMenuThemeCustom.SetMenu(itemList,currentOption)
+            itemList=idleConf.GetSectionList('default','highlight')
+            itemList.sort()
+            self.optMenuThemeBuiltin.SetMenu(itemList,itemList[0])
+        self.SetThemeType()
+        ##load theme element option menu
+        themeNames=self.themeElements.keys()
+        themeNames.sort(self.__ThemeNameIndexCompare)
+        self.optMenuHighlightTarget.SetMenu(themeNames,themeNames[0])
+        self.PaintThemeSample()
+        self.SetHighlightTarget()
+
+    def __ThemeNameIndexCompare(self,a,b):
+        if self.themeElements[a][1]<self.themeElements[b][1]: return -1
+        elif self.themeElements[a][1]==self.themeElements[b][1]: return 0
+        else: return 1
+
+    def LoadKeyCfg(self):
+        ##current keys type radiobutton
+        self.keysAreBuiltin.set(idleConf.GetOption('main','Keys','default',
+            type='bool',default=1))
+        ##currently set keys
+        currentOption=idleConf.CurrentKeys()
+        ##load available keyset option menus
+        if self.keysAreBuiltin.get(): #default theme selected
+            itemList=idleConf.GetSectionList('default','keys')
+            itemList.sort()
+            self.optMenuKeysBuiltin.SetMenu(itemList,currentOption)
+            itemList=idleConf.GetSectionList('user','keys')
+            itemList.sort()
+            if not itemList:
+                self.radioKeysCustom.config(state=DISABLED)
+                self.customKeys.set('- no custom keys -')
+            else:
+                self.optMenuKeysCustom.SetMenu(itemList,itemList[0])
+        else: #user key set selected
+            itemList=idleConf.GetSectionList('user','keys')
+            itemList.sort()
+            self.optMenuKeysCustom.SetMenu(itemList,currentOption)
+            itemList=idleConf.GetSectionList('default','keys')
+            itemList.sort()
+            self.optMenuKeysBuiltin.SetMenu(itemList,itemList[0])
+        self.SetKeysType()
+        ##load keyset element list
+        keySetName=idleConf.CurrentKeys()
+        self.LoadKeysList(keySetName)
+
+    def LoadGeneralCfg(self):
+        #startup state
+        self.startupEdit.set(idleConf.GetOption('main','General',
+                'editor-on-startup',default=1,type='bool'))
+        #initial window size
+        self.winWidth.set(idleConf.GetOption('main','EditorWindow','width'))
+        self.winHeight.set(idleConf.GetOption('main','EditorWindow','height'))
+        # additional help sources
+        self.userHelpList = idleConf.GetAllExtraHelpSourcesList()
+        for helpItem in self.userHelpList:
+            self.listHelp.insert(END,helpItem[0])
+        self.SetHelpListButtonStates()
+        #self.userHelpBrowser.set(idleConf.GetOption('main','General',
+        #        'user-help-browser',default=0,type='bool'))
+        #self.helpBrowser.set(idleConf.GetOption('main','General',
+        #        'user-help-browser-command',default=''))
+        #self.OnCheckUserHelpBrowser()
+
+    def LoadConfigs(self):
+        """
+        load configuration from default and user config files and populate
+        the widgets on the config dialog pages.
+        """
+        ### fonts / tabs page
+        self.LoadFontCfg()
+        self.LoadTabCfg()
+        ### highlighting page
+        self.LoadThemeCfg()
+        ### keys page
+        self.LoadKeyCfg()
+        ### general page
+        self.LoadGeneralCfg()
+
+    def SaveNewKeySet(self,keySetName,keySet):
+        """
+        save a newly created core key set.
+        keySetName - string, the name of the new key set
+        keySet - dictionary containing the new key set
+        """
+        if not idleConf.userCfg['keys'].has_section(keySetName):
+            idleConf.userCfg['keys'].add_section(keySetName)
+        for event in keySet.keys():
+            value=keySet[event]
+            idleConf.userCfg['keys'].SetOption(keySetName,event,value)
+
+    def SaveNewTheme(self,themeName,theme):
+        """
+        save a newly created theme.
+        themeName - string, the name of the new theme
+        theme - dictionary containing the new theme
+        """
+        if not idleConf.userCfg['highlight'].has_section(themeName):
+            idleConf.userCfg['highlight'].add_section(themeName)
+        for element in theme.keys():
+            value=theme[element]
+            idleConf.userCfg['highlight'].SetOption(themeName,element,value)
+
+    def SetUserValue(self,configType,section,item,value):
+        if idleConf.defaultCfg[configType].has_option(section,item):
+            if idleConf.defaultCfg[configType].Get(section,item)==value:
+                #the setting equals a default setting, remove it from user cfg
+                return idleConf.userCfg[configType].RemoveOption(section,item)
+        #if we got here set the option
+        return idleConf.userCfg[configType].SetOption(section,item,value)
+
+    def SaveAllChangedConfigs(self):
+        "Save configuration changes to the user config file."
+        idleConf.userCfg['main'].Save()
+        for configType in self.changedItems.keys():
+            cfgTypeHasChanges = False
+            for section in self.changedItems[configType].keys():
+                if section == 'HelpFiles':
+                    #this section gets completely replaced
+                    idleConf.userCfg['main'].remove_section('HelpFiles')
+                    cfgTypeHasChanges = True
+                for item in self.changedItems[configType][section].keys():
+                    value = self.changedItems[configType][section][item]
+                    if self.SetUserValue(configType,section,item,value):
+                        cfgTypeHasChanges = True
+            if cfgTypeHasChanges:
+                idleConf.userCfg[configType].Save()
+        self.ResetChangedItems() #clear the changed items dict
+
+    def ActivateConfigChanges(self):
+        #things that need to be done to make
+        #applied config changes dynamic:
+        #update editor/shell font and repaint
+        #dynamically update indentation setttings
+        #update theme and repaint
+        #update keybindings and re-bind
+        #update user help sources menu
+        winInstances=self.parent.instanceDict.keys()
+        for instance in winInstances:
+            instance.ResetColorizer()
+            instance.ResetFont()
+            instance.ResetKeybindings()
+            instance.reset_help_menu_entries()
+
+    def Cancel(self):
+        self.destroy()
+
+    def Ok(self):
+        self.Apply()
+        self.destroy()
+
+    def Apply(self):
+        self.SaveAllChangedConfigs()
+        self.ActivateConfigChanges()
+
+    def Help(self):
+        pass
+
+if __name__ == '__main__':
+    #test the dialog
+    root=Tk()
+    Button(root,text='Dialog',
+            command=lambda:ConfigDialog(root,'Settings')).pack()
+    root.instanceDict={}
+    root.mainloop()
diff --git a/Tools/idle/configHandler.py b/Tools/idle/configHandler.py
new file mode 100644
index 0000000..fd9cbc4
--- /dev/null
+++ b/Tools/idle/configHandler.py
@@ -0,0 +1,655 @@
+"""Provides access to stored IDLE configuration information.
+
+Refer to the comments at the beginning of config-main.def for a description of
+the available configuration files and the design implemented to update user
+configuration information.  In particular, user configuration choices which
+duplicate the defaults will be removed from the user's configuration files,
+and if a file becomes empty, it will be deleted.
+
+The contents of the user files may be altered using the Options/Configure IDLE
+menu to access the configuration GUI (configDialog.py), or manually.
+
+Throughout this module there is an emphasis on returning useable defaults
+when a problem occurs in returning a requested configuration value back to
+idle. This is to allow IDLE to continue to function in spite of errors in
+the retrieval of config information. When a default is returned instead of
+a requested config value, a message is printed to stderr to aid in
+configuration problem notification and resolution.
+
+"""
+import os
+import sys
+import string
+from ConfigParser import ConfigParser, NoOptionError, NoSectionError
+
+class InvalidConfigType(Exception): pass
+class InvalidConfigSet(Exception): pass
+class InvalidFgBg(Exception): pass
+class InvalidTheme(Exception): pass
+
+class IdleConfParser(ConfigParser):
+    """
+    A ConfigParser specialised for idle configuration file handling
+    """
+    def __init__(self, cfgFile, cfgDefaults=None):
+        """
+        cfgFile - string, fully specified configuration file name
+        """
+        self.file=cfgFile
+        ConfigParser.__init__(self,defaults=cfgDefaults)
+
+    def Get(self, section, option, type=None, default=None):
+        """
+        Get an option value for given section/option or return default.
+        If type is specified, return as type.
+        """
+        if type=='bool':
+            getVal=self.getboolean
+        elif type=='int':
+            getVal=self.getint
+        else:
+            getVal=self.get
+        if self.has_option(section,option):
+            #return getVal(section, option, raw, vars, default)
+            return getVal(section, option)
+        else:
+            return default
+
+    def GetOptionList(self,section):
+        """
+        Get an option list for given section
+        """
+        if self.has_section(section):
+            return self.options(section)
+        else:  #return a default value
+            return []
+
+    def Load(self):
+        """
+        Load the configuration file from disk
+        """
+        self.read(self.file)
+
+class IdleUserConfParser(IdleConfParser):
+    """
+    IdleConfigParser specialised for user configuration handling.
+    """
+
+    def AddSection(self,section):
+        """
+        if section doesn't exist, add it
+        """
+        if not self.has_section(section):
+            self.add_section(section)
+
+    def RemoveEmptySections(self):
+        """
+        remove any sections that have no options
+        """
+        for section in self.sections():
+            if not self.GetOptionList(section):
+                self.remove_section(section)
+
+    def IsEmpty(self):
+        """
+        Remove empty sections and then return 1 if parser has no sections
+        left, else return 0.
+        """
+        self.RemoveEmptySections()
+        if self.sections():
+            return 0
+        else:
+            return 1
+
+    def RemoveOption(self,section,option):
+        """
+        If section/option exists, remove it.
+        Returns 1 if option was removed, 0 otherwise.
+        """
+        if self.has_section(section):
+            return self.remove_option(section,option)
+
+    def SetOption(self,section,option,value):
+        """
+        Sets option to value, adding section if required.
+        Returns 1 if option was added or changed, otherwise 0.
+        """
+        if self.has_option(section,option):
+            if self.get(section,option)==value:
+                return 0
+            else:
+                self.set(section,option,value)
+                return 1
+        else:
+            if not self.has_section(section):
+                self.add_section(section)
+            self.set(section,option,value)
+            return 1
+
+    def RemoveFile(self):
+        """
+        Removes the user config file from disk if it exists.
+        """
+        if os.path.exists(self.file):
+            os.remove(self.file)
+
+    def Save(self):
+        """Update user configuration file.
+
+        Remove empty sections. If resulting config isn't empty, write the file
+        to disk. If config is empty, remove the file from disk if it exists.
+
+        """
+        if not self.IsEmpty():
+            cfgFile=open(self.file,'w')
+            self.write(cfgFile)
+        else:
+            self.RemoveFile()
+
+class IdleConf:
+    """
+    holds config parsers for all idle config files:
+    default config files
+        (idle install dir)/config-main.def
+        (idle install dir)/config-extensions.def
+        (idle install dir)/config-highlight.def
+        (idle install dir)/config-keys.def
+    user config  files
+        (user home dir)/.idlerc/config-main.cfg
+        (user home dir)/.idlerc/config-extensions.cfg
+        (user home dir)/.idlerc/config-highlight.cfg
+        (user home dir)/.idlerc/config-keys.cfg
+    """
+    def __init__(self):
+        self.defaultCfg={}
+        self.userCfg={}
+        self.cfg={}
+        self.CreateConfigHandlers()
+        self.LoadCfgFiles()
+        #self.LoadCfg()
+
+    def CreateConfigHandlers(self):
+        """
+        set up a dictionary of config parsers for default and user
+        configurations respectively
+        """
+        #build idle install path
+        if __name__ != '__main__': # we were imported
+            idleDir=os.path.dirname(__file__)
+        else: # we were exec'ed (for testing only)
+            idleDir=os.path.abspath(sys.path[0])
+        userDir=self.GetUserCfgDir()
+        configTypes=('main','extensions','highlight','keys')
+        defCfgFiles={}
+        usrCfgFiles={}
+        for cfgType in configTypes: #build config file names
+            defCfgFiles[cfgType]=os.path.join(idleDir,'config-'+cfgType+'.def')
+            usrCfgFiles[cfgType]=os.path.join(userDir,'config-'+cfgType+'.cfg')
+        for cfgType in configTypes: #create config parsers
+            self.defaultCfg[cfgType]=IdleConfParser(defCfgFiles[cfgType])
+            self.userCfg[cfgType]=IdleUserConfParser(usrCfgFiles[cfgType])
+
+    def GetUserCfgDir(self):
+        """
+        Creates (if required) and returns a filesystem directory for storing
+        user config files.
+        """
+        cfgDir='.idlerc'
+        userDir=os.path.expanduser('~')
+        if userDir != '~': #'HOME' exists as a key in os.environ
+            if not os.path.exists(userDir):
+                warn=('\n Warning: HOME environment variable points to\n '+
+                        userDir+'\n but the path does not exist.\n')
+                sys.stderr.write(warn)
+                userDir='~'
+        if userDir=='~': #we still don't have a home directory
+            #traditionally idle has defaulted to os.getcwd(), is this adeqate?
+            userDir = os.getcwd() #hack for no real homedir
+        userDir=os.path.join(userDir,cfgDir)
+        if not os.path.exists(userDir):
+            try: #make the config dir if it doesn't exist yet
+                os.mkdir(userDir)
+            except IOError:
+                warn=('\n Warning: unable to create user config directory\n '+
+                        userDir+'\n')
+                sys.stderr.write(warn)
+        return userDir
+
+    def GetOption(self, configType, section, option, default=None, type=None):
+        """
+        Get an option value for given config type and given general
+        configuration section/option or return a default. If type is specified,
+        return as type. Firstly the user configuration is checked, with a
+        fallback to the default configuration, and a final 'catch all'
+        fallback to a useable passed-in default if the option isn't present in
+        either the user or the default configuration.
+        configType must be one of ('main','extensions','highlight','keys')
+        If a default is returned a warning is printed to stderr.
+        """
+        if self.userCfg[configType].has_option(section,option):
+            return self.userCfg[configType].Get(section, option, type=type)
+        elif self.defaultCfg[configType].has_option(section,option):
+            return self.defaultCfg[configType].Get(section, option, type=type)
+        else: #returning default, print warning
+            warning=('\n Warning: configHandler.py - IdleConf.GetOption -\n'+
+                       ' problem retrieving configration option '+`option`+'\n'+
+                       ' from section '+`section`+'.\n'+
+                       ' returning default value: '+`default`+'\n')
+            sys.stderr.write(warning)
+            return default
+
+    def GetSectionList(self, configSet, configType):
+        """
+        Get a list of sections from either the user or default config for
+        the given config type.
+        configSet must be either 'user' or 'default'
+        configType must be one of ('main','extensions','highlight','keys')
+        """
+        if not (configType in ('main','extensions','highlight','keys')):
+            raise InvalidConfigType, 'Invalid configType specified'
+        if configSet == 'user':
+            cfgParser=self.userCfg[configType]
+        elif configSet == 'default':
+            cfgParser=self.defaultCfg[configType]
+        else:
+            raise InvalidConfigSet, 'Invalid configSet specified'
+        return cfgParser.sections()
+
+    def GetHighlight(self, theme, element, fgBg=None):
+        """
+        return individual highlighting theme elements.
+        fgBg - string ('fg'or'bg') or None, if None return a dictionary
+        containing fg and bg colours (appropriate for passing to Tkinter in,
+        e.g., a tag_config call), otherwise fg or bg colour only as specified.
+        """
+        if self.defaultCfg['highlight'].has_section(theme):
+            themeDict=self.GetThemeDict('default',theme)
+        else:
+            themeDict=self.GetThemeDict('user',theme)
+        fore=themeDict[element+'-foreground']
+        if element=='cursor': #there is no config value for cursor bg
+            back=themeDict['normal-background']
+        else:
+            back=themeDict[element+'-background']
+        highlight={"foreground": fore,"background": back}
+        if not fgBg: #return dict of both colours
+            return highlight
+        else: #return specified colour only
+            if fgBg == 'fg':
+                return highlight["foreground"]
+            if fgBg == 'bg':
+                return highlight["background"]
+            else:
+                raise InvalidFgBg, 'Invalid fgBg specified'
+
+    def GetThemeDict(self,type,themeName):
+        """
+        type - string, 'default' or 'user' theme type
+        themeName - string, theme name
+        Returns a dictionary which holds {option:value} for each element
+        in the specified theme. Values are loaded over a set of ultimate last
+        fallback defaults to guarantee that all theme elements are present in
+        a newly created theme.
+        """
+        if type == 'user':
+            cfgParser=self.userCfg['highlight']
+        elif type == 'default':
+            cfgParser=self.defaultCfg['highlight']
+        else:
+            raise InvalidTheme, 'Invalid theme type specified'
+        #foreground and background values are provded for each theme element
+        #(apart from cursor) even though all these values are not yet used
+        #by idle, to allow for their use in the future. Default values are
+        #generally black and white.
+        theme={ 'normal-foreground':'#000000',
+                'normal-background':'#ffffff',
+                'keyword-foreground':'#000000',
+                'keyword-background':'#ffffff',
+                'comment-foreground':'#000000',
+                'comment-background':'#ffffff',
+                'string-foreground':'#000000',
+                'string-background':'#ffffff',
+                'definition-foreground':'#000000',
+                'definition-background':'#ffffff',
+                'hilite-foreground':'#000000',
+                'hilite-background':'gray',
+                'break-foreground':'#ffffff',
+                'break-background':'#000000',
+                'hit-foreground':'#ffffff',
+                'hit-background':'#000000',
+                'error-foreground':'#ffffff',
+                'error-background':'#000000',
+                #cursor (only foreground can be set)
+                'cursor-foreground':'#000000',
+                #shell window
+                'stdout-foreground':'#000000',
+                'stdout-background':'#ffffff',
+                'stderr-foreground':'#000000',
+                'stderr-background':'#ffffff',
+                'console-foreground':'#000000',
+                'console-background':'#ffffff' }
+        for element in theme.keys():
+            if not cfgParser.has_option(themeName,element):
+                #we are going to return a default, print warning
+                warning=('\n Warning: configHandler.py - IdleConf.GetThemeDict'+
+                           ' -\n problem retrieving theme element '+`element`+
+                           '\n from theme '+`themeName`+'.\n'+
+                           ' returning default value: '+`theme[element]`+'\n')
+                sys.stderr.write(warning)
+            colour=cfgParser.Get(themeName,element,default=theme[element])
+            theme[element]=colour
+        return theme
+
+    def CurrentTheme(self):
+        """
+        Returns the name of the currently active theme
+        """
+        return self.GetOption('main','Theme','name',default='')
+
+    def CurrentKeys(self):
+        """
+        Returns the name of the currently active key set
+        """
+        return self.GetOption('main','Keys','name',default='')
+
+    def GetExtensions(self, activeOnly=1):
+        """
+        Gets a list of all idle extensions declared in the config files.
+        activeOnly - boolean, if true only return active (enabled) extensions
+        """
+        extns=self.RemoveKeyBindNames(
+                self.GetSectionList('default','extensions'))
+        userExtns=self.RemoveKeyBindNames(
+                self.GetSectionList('user','extensions'))
+        for extn in userExtns:
+            if extn not in extns: #user has added own extension
+                extns.append(extn)
+        if activeOnly:
+            activeExtns=[]
+            for extn in extns:
+                if self.GetOption('extensions',extn,'enable',default=1,
+                    type='bool'):
+                    #the extension is enabled
+                    activeExtns.append(extn)
+            return activeExtns
+        else:
+            return extns
+
+    def RemoveKeyBindNames(self,extnNameList):
+        #get rid of keybinding section names
+        names=extnNameList
+        kbNameIndicies=[]
+        for name in names:
+            if name.endswith('_bindings') or name.endswith('_cfgBindings'):
+                kbNameIndicies.append(names.index(name))
+        kbNameIndicies.sort()
+        kbNameIndicies.reverse()
+        for index in kbNameIndicies: #delete each keybinding section name
+            del(names[index])
+        return names
+
+    def GetExtnNameForEvent(self,virtualEvent):
+        """
+        Returns the name of the extension that virtualEvent is bound in, or
+        None if not bound in any extension.
+        virtualEvent - string, name of the virtual event to test for, without
+                       the enclosing '<< >>'
+        """
+        extName=None
+        vEvent='<<'+virtualEvent+'>>'
+        for extn in self.GetExtensions(activeOnly=0):
+            for event in self.GetExtensionKeys(extn).keys():
+                if event == vEvent:
+                    extName=extn
+        return extName
+
+    def GetExtensionKeys(self,extensionName):
+        """
+        returns a dictionary of the configurable keybindings for a particular
+        extension,as they exist in the dictionary returned by GetCurrentKeySet;
+        that is, where previously used bindings are disabled.
+        """
+        keysName=extensionName+'_cfgBindings'
+        activeKeys=self.GetCurrentKeySet()
+        extKeys={}
+        if self.defaultCfg['extensions'].has_section(keysName):
+            eventNames=self.defaultCfg['extensions'].GetOptionList(keysName)
+            for eventName in eventNames:
+                event='<<'+eventName+'>>'
+                binding=activeKeys[event]
+                extKeys[event]=binding
+        return extKeys
+
+    def __GetRawExtensionKeys(self,extensionName):
+        """
+        returns a dictionary of the configurable keybindings for a particular
+        extension, as defined in the configuration files, or an empty dictionary
+        if no bindings are found
+        """
+        keysName=extensionName+'_cfgBindings'
+        extKeys={}
+        if self.defaultCfg['extensions'].has_section(keysName):
+            eventNames=self.defaultCfg['extensions'].GetOptionList(keysName)
+            for eventName in eventNames:
+                binding=self.GetOption('extensions',keysName,
+                        eventName,default='').split()
+                event='<<'+eventName+'>>'
+                extKeys[event]=binding
+        return extKeys
+
+    def GetExtensionBindings(self,extensionName):
+        """
+        Returns a dictionary of all the event bindings for a particular
+        extension. The configurable keybindings are returned as they exist in
+        the dictionary returned by GetCurrentKeySet; that is, where re-used
+        keybindings are disabled.
+        """
+        bindsName=extensionName+'_bindings'
+        extBinds=self.GetExtensionKeys(extensionName)
+        #add the non-configurable bindings
+        if self.defaultCfg['extensions'].has_section(bindsName):
+            eventNames=self.defaultCfg['extensions'].GetOptionList(bindsName)
+            for eventName in eventNames:
+                binding=self.GetOption('extensions',bindsName,
+                        eventName,default='').split()
+                event='<<'+eventName+'>>'
+                extBinds[event]=binding
+
+        return extBinds
+
+    def GetKeyBinding(self, keySetName, eventStr):
+        """
+        returns the keybinding for a specific event.
+        keySetName - string, name of key binding set
+        eventStr - string, the virtual event we want the binding for,
+                   represented as a string, eg. '<<event>>'
+        """
+        eventName=eventStr[2:-2] #trim off the angle brackets
+        binding=self.GetOption('keys',keySetName,eventName,default='').split()
+        return binding
+
+    def GetCurrentKeySet(self):
+        return self.GetKeySet(self.CurrentKeys())
+
+    def GetKeySet(self,keySetName):
+        """
+        Returns a dictionary of: all requested core keybindings, plus the
+        keybindings for all currently active extensions. If a binding defined
+        in an extension is already in use, that binding is disabled.
+        """
+        keySet=self.GetCoreKeys(keySetName)
+        activeExtns=self.GetExtensions(activeOnly=1)
+        for extn in activeExtns:
+            extKeys=self.__GetRawExtensionKeys(extn)
+            if extKeys: #the extension defines keybindings
+                for event in extKeys.keys():
+                    if extKeys[event] in keySet.values():
+                        #the binding is already in use
+                        extKeys[event]='' #disable this binding
+                    keySet[event]=extKeys[event] #add binding
+        return keySet
+
+    def IsCoreBinding(self,virtualEvent):
+        """
+        returns true if the virtual event is bound in the core idle keybindings.
+        virtualEvent - string, name of the virtual event to test for, without
+                       the enclosing '<< >>'
+        """
+        return ('<<'+virtualEvent+'>>') in self.GetCoreKeys().keys()
+
+    def GetCoreKeys(self, keySetName=None):
+        """
+        returns the requested set of core keybindings, with fallbacks if
+        required.
+        Keybindings loaded from the config file(s) are loaded _over_ these
+        defaults, so if there is a problem getting any core binding there will
+        be an 'ultimate last resort fallback' to the CUA-ish bindings
+        defined here.
+        """
+        keyBindings={
+            '<<copy>>': ['<Control-c>', '<Control-C>'],
+            '<<cut>>': ['<Control-x>', '<Control-X>'],
+            '<<paste>>': ['<Control-v>', '<Control-V>'],
+            '<<beginning-of-line>>': ['<Control-a>', '<Home>'],
+            '<<center-insert>>': ['<Control-l>'],
+            '<<close-all-windows>>': ['<Control-q>'],
+            '<<close-window>>': ['<Alt-F4>'],
+            '<<do-nothing>>': ['<Control-x>'],
+            '<<end-of-file>>': ['<Control-d>'],
+            '<<python-docs>>': ['<F1>'],
+            '<<python-context-help>>': ['<Shift-F1>'],
+            '<<history-next>>': ['<Alt-n>'],
+            '<<history-previous>>': ['<Alt-p>'],
+            '<<interrupt-execution>>': ['<Control-c>'],
+            '<<view-restart>>': ['<F6>'],
+            '<<restart-shell>>': ['<Control-F6>'],
+            '<<open-class-browser>>': ['<Alt-c>'],
+            '<<open-module>>': ['<Alt-m>'],
+            '<<open-new-window>>': ['<Control-n>'],
+            '<<open-window-from-file>>': ['<Control-o>'],
+            '<<plain-newline-and-indent>>': ['<Control-j>'],
+            '<<print-window>>': ['<Control-p>'],
+            '<<redo>>': ['<Control-y>'],
+            '<<remove-selection>>': ['<Escape>'],
+            '<<save-copy-of-window-as-file>>': ['<Alt-Shift-s>'],
+            '<<save-window-as-file>>': ['<Alt-s>'],
+            '<<save-window>>': ['<Control-s>'],
+            '<<select-all>>': ['<Alt-a>'],
+            '<<toggle-auto-coloring>>': ['<Control-slash>'],
+            '<<undo>>': ['<Control-z>'],
+            '<<find-again>>': ['<Control-g>', '<F3>'],
+            '<<find-in-files>>': ['<Alt-F3>'],
+            '<<find-selection>>': ['<Control-F3>'],
+            '<<find>>': ['<Control-f>'],
+            '<<replace>>': ['<Control-h>'],
+            '<<goto-line>>': ['<Alt-g>'],
+            '<<smart-backspace>>': ['<Key-BackSpace>'],
+            '<<newline-and-indent>>': ['<Key-Return> <Key-KP_Enter>'],
+            '<<smart-indent>>': ['<Key-Tab>'],
+            '<<indent-region>>': ['<Control-Key-bracketright>'],
+            '<<dedent-region>>': ['<Control-Key-bracketleft>'],
+            '<<comment-region>>': ['<Alt-Key-3>'],
+            '<<uncomment-region>>': ['<Alt-Key-4>'],
+            '<<tabify-region>>': ['<Alt-Key-5>'],
+            '<<untabify-region>>': ['<Alt-Key-6>'],
+            '<<toggle-tabs>>': ['<Alt-Key-t>'],
+            '<<change-indentwidth>>': ['<Alt-Key-u>']
+            }
+        if keySetName:
+            for event in keyBindings.keys():
+                binding=self.GetKeyBinding(keySetName,event)
+                if binding:
+                    keyBindings[event]=binding
+                else: #we are going to return a default, print warning
+                    warning=('\n Warning: configHandler.py - IdleConf.GetCoreKeys'+
+                               ' -\n problem retrieving key binding for event '+
+                               `event`+'\n from key set '+`keySetName`+'.\n'+
+                               ' returning default value: '+`keyBindings[event]`+'\n')
+                    sys.stderr.write(warning)
+        return keyBindings
+
+    def GetExtraHelpSourceList(self,configSet):
+        """Fetch list of extra help sources from a given configSet.
+
+        Valid configSets are 'user' or 'default'.  Return a list of tuples of
+        the form (menu_item , path_to_help_file , option), or return the empty
+        list.  'option' is the sequence number of the help resource.  'option'
+        values determine the position of the menu items on the Help menu,
+        therefore the returned list must be sorted by 'option'.
+
+        """
+        helpSources=[]
+        if configSet=='user':
+            cfgParser=self.userCfg['main']
+        elif configSet=='default':
+            cfgParser=self.defaultCfg['main']
+        else:
+            raise InvalidConfigSet, 'Invalid configSet specified'
+        options=cfgParser.GetOptionList('HelpFiles')
+        for option in options:
+            value=cfgParser.Get('HelpFiles',option,default=';')
+            if value.find(';')==-1: #malformed config entry with no ';'
+                menuItem='' #make these empty
+                helpPath='' #so value won't be added to list
+            else: #config entry contains ';' as expected
+                value=string.split(value,';')
+                menuItem=value[0].strip()
+                helpPath=value[1].strip()
+            if menuItem and helpPath: #neither are empty strings
+                helpSources.append( (menuItem,helpPath,option) )
+        helpSources.sort(self.__helpsort)
+        return helpSources
+
+    def __helpsort(self, h1, h2):
+        if int(h1[2]) < int(h2[2]):
+            return -1
+        elif int(h1[2]) > int(h2[2]):
+            return 1
+        else:
+            return 0
+
+    def GetAllExtraHelpSourcesList(self):
+        """
+        Returns a list of tuples containing the details of all additional help
+        sources configured, or an empty list if there are none. Tuples are of
+        the format returned by GetExtraHelpSourceList.
+        """
+        allHelpSources=( self.GetExtraHelpSourceList('default')+
+                self.GetExtraHelpSourceList('user') )
+        return allHelpSources
+
+    def LoadCfgFiles(self):
+        """
+        load all configuration files.
+        """
+        for key in self.defaultCfg.keys():
+            self.defaultCfg[key].Load()
+            self.userCfg[key].Load() #same keys
+
+    def SaveUserCfgFiles(self):
+        """
+        write all loaded user configuration files back to disk
+        """
+        for key in self.userCfg.keys():
+            self.userCfg[key].Save()
+
+idleConf=IdleConf()
+
+### module test
+if __name__ == '__main__':
+    def dumpCfg(cfg):
+        print '\n',cfg,'\n'
+        for key in cfg.keys():
+            sections=cfg[key].sections()
+            print key
+            print sections
+            for section in sections:
+                options=cfg[key].options(section)
+                print section
+                print options
+                for option in options:
+                    print option, '=', cfg[key].Get(section,option)
+    dumpCfg(idleConf.defaultCfg)
+    dumpCfg(idleConf.userCfg)
+    print idleConf.userCfg['main'].Get('Theme','name')
+    #print idleConf.userCfg['highlight'].GetDefHighlight('Foo','normal')
diff --git a/Tools/idle/configHelpSourceEdit.py b/Tools/idle/configHelpSourceEdit.py
new file mode 100644
index 0000000..b781884
--- /dev/null
+++ b/Tools/idle/configHelpSourceEdit.py
@@ -0,0 +1,157 @@
+"Dialog to specify or edit the parameters for a user configured help source."
+
+import os
+
+from Tkinter import *
+import tkMessageBox
+import tkFileDialog
+
+class GetHelpSourceDialog(Toplevel):
+    def __init__(self, parent, title, menuItem='', filePath=''):
+        """Get menu entry and url/ local file location for Additional Help
+
+        User selects a name for the Help resource and provides a web url
+        or a local file as its source.  The user can enter a url or browse
+        for the file.
+
+        """
+        Toplevel.__init__(self, parent)
+        self.configure(borderwidth=5)
+        self.resizable(height=FALSE, width=FALSE)
+        self.title(title)
+        self.transient(parent)
+        self.grab_set()
+        self.protocol("WM_DELETE_WINDOW", self.Cancel)
+        self.parent = parent
+        self.result = None
+        self.CreateWidgets()
+        self.menu.set(menuItem)
+        self.path.set(filePath)
+        self.withdraw() #hide while setting geometry
+        #needs to be done here so that the winfo_reqwidth is valid
+        self.update_idletasks()
+        #centre dialog over parent:
+        self.geometry("+%d+%d" %
+                      ((parent.winfo_rootx() + ((parent.winfo_width()/2)
+                                                -(self.winfo_reqwidth()/2)),
+                        parent.winfo_rooty() + ((parent.winfo_height()/2)
+                                                -(self.winfo_reqheight()/2)))))
+        self.deiconify() #geometry set, unhide
+        self.bind('<Return>', self.Ok)
+        self.wait_window()
+
+    def CreateWidgets(self):
+        self.menu = StringVar(self)
+        self.path = StringVar(self)
+        self.fontSize = StringVar(self)
+        self.frameMain = Frame(self, borderwidth=2, relief=GROOVE)
+        self.frameMain.pack(side=TOP, expand=TRUE, fill=BOTH)
+        labelMenu = Label(self.frameMain, anchor=W, justify=LEFT,
+                          text='Menu Item:')
+        self.entryMenu = Entry(self.frameMain, textvariable=self.menu,
+                               width=30)
+        self.entryMenu.focus_set()
+        labelPath = Label(self.frameMain, anchor=W, justify=LEFT,
+                          text='Help File Path: Enter URL or browse for file')
+        self.entryPath = Entry(self.frameMain, textvariable=self.path,
+                               width=40)
+        self.entryMenu.focus_set()
+        labelMenu.pack(anchor=W, padx=5, pady=3)
+        self.entryMenu.pack(anchor=W, padx=5, pady=3)
+        labelPath.pack(anchor=W, padx=5, pady=3)
+        self.entryPath.pack(anchor=W, padx=5, pady=3)
+        browseButton = Button(self.frameMain, text='Browse', width=8,
+                              command=self.browseFile)
+        browseButton.pack(pady=3)
+        frameButtons = Frame(self)
+        frameButtons.pack(side=BOTTOM, fill=X)
+        self.buttonOk = Button(frameButtons, text='OK',
+                               width=8, default=ACTIVE,  command=self.Ok)
+        self.buttonOk.grid(row=0, column=0, padx=5,pady=5)
+        self.buttonCancel = Button(frameButtons, text='Cancel',
+                                   width=8, command=self.Cancel)
+        self.buttonCancel.grid(row=0, column=1, padx=5, pady=5)
+
+    def browseFile(self):
+        filetypes = [
+            ("HTML Files", "*.htm *.html", "TEXT"),
+            ("PDF Files", "*.pdf", "TEXT"),
+            ("Windows Help Files", "*.chm"),
+            ("Text Files", "*.txt", "TEXT"),
+            ("All Files", "*")]
+        path = self.path.get()
+        if path:
+            dir, base = os.path.split(path)
+        else:
+            base = None
+            if sys.platform.count('win') or sys.platform.count('nt'):
+                dir = os.path.join(os.path.dirname(sys.executable), 'Doc')
+                if not os.path.isdir(dir):
+                    dir = os.getcwd()
+            else:
+                dir = os.getcwd()
+        opendialog = tkFileDialog.Open(parent=self, filetypes=filetypes)
+        file = opendialog.show(initialdir=dir, initialfile=base)
+        if file:
+            self.path.set(file)
+
+    def MenuOk(self):
+        "Simple validity check for a sensible menu item name"
+        menuOk = True
+        menu = self.menu.get()
+        menu.strip()
+        if not menu:
+            tkMessageBox.showerror(title='Menu Item Error',
+                                   message='No menu item specified',
+                                   parent=self)
+            self.entryMenu.focus_set()
+            menuOk = False
+        elif len(menu) > 30:
+            tkMessageBox.showerror(title='Menu Item Error',
+                                   message='Menu item too long:'
+                                           '\nLimit 30 characters.',
+                                   parent=self)
+            self.entryMenu.focus_set()
+            menuOk = False
+        return menuOk
+
+    def PathOk(self):
+        "Simple validity check for menu file path"
+        pathOk = True
+        path = self.path.get()
+        path.strip()
+        if not path: #no path specified
+            tkMessageBox.showerror(title='File Path Error',
+                                   message='No help file path specified.',
+                                   parent=self)
+            self.entryPath.focus_set()
+            pathOk = False
+        elif path.startswith('www.') or path.startswith('http'):
+            pathOk = True
+        elif not os.path.exists(path):
+            tkMessageBox.showerror(title='File Path Error',
+                                   message='Help file path does not exist.',
+                                   parent=self)
+            self.entryPath.focus_set()
+            pathOk = False
+        return pathOk
+
+    def Ok(self, event=None):
+        if self.MenuOk() and self.PathOk():
+            self.result = (self.menu.get().strip(),
+                           self.path.get().strip())
+            self.destroy()
+
+    def Cancel(self, event=None):
+        self.result = None
+        self.destroy()
+
+if __name__ == '__main__':
+    #test the dialog
+    root = Tk()
+    def run():
+        keySeq = ''
+        dlg = GetHelpSourceDialog(root, 'Get Help Source')
+        print dlg.result
+    Button(root,text='Dialog', command=run).pack()
+    root.mainloop()
diff --git a/Tools/idle/configSectionNameDialog.py b/Tools/idle/configSectionNameDialog.py
new file mode 100644
index 0000000..4f1b002
--- /dev/null
+++ b/Tools/idle/configSectionNameDialog.py
@@ -0,0 +1,97 @@
+"""
+Dialog that allows user to specify a new config file section name.
+Used to get new highlight theme and keybinding set names.
+"""
+from Tkinter import *
+import tkMessageBox
+
+class GetCfgSectionNameDialog(Toplevel):
+    def __init__(self,parent,title,message,usedNames):
+        """
+        message - string, informational message to display
+        usedNames - list, list of names already in use for validity check
+        """
+        Toplevel.__init__(self, parent)
+        self.configure(borderwidth=5)
+        self.resizable(height=FALSE,width=FALSE)
+        self.title(title)
+        self.transient(parent)
+        self.grab_set()
+        self.protocol("WM_DELETE_WINDOW", self.Cancel)
+        self.parent = parent
+        self.message=message
+        self.usedNames=usedNames
+        self.result=''
+        self.CreateWidgets()
+        self.withdraw() #hide while setting geometry
+        self.update_idletasks()
+        #needs to be done here so that the winfo_reqwidth is valid
+        self.messageInfo.config(width=self.frameMain.winfo_reqwidth())
+        self.geometry("+%d+%d" %
+            ((parent.winfo_rootx()+((parent.winfo_width()/2)
+                -(self.winfo_reqwidth()/2)),
+              parent.winfo_rooty()+((parent.winfo_height()/2)
+                -(self.winfo_reqheight()/2)) )) ) #centre dialog over parent
+        self.deiconify() #geometry set, unhide
+        self.wait_window()
+
+    def CreateWidgets(self):
+        self.name=StringVar(self)
+        self.fontSize=StringVar(self)
+        self.frameMain = Frame(self,borderwidth=2,relief=SUNKEN)
+        self.frameMain.pack(side=TOP,expand=TRUE,fill=BOTH)
+        self.messageInfo=Message(self.frameMain,anchor=W,justify=LEFT,padx=5,pady=5,
+                text=self.message)#,aspect=200)
+        entryName=Entry(self.frameMain,textvariable=self.name,width=30)
+        entryName.focus_set()
+        self.messageInfo.pack(padx=5,pady=5)#,expand=TRUE,fill=BOTH)
+        entryName.pack(padx=5,pady=5)
+        frameButtons=Frame(self)
+        frameButtons.pack(side=BOTTOM,fill=X)
+        self.buttonOk = Button(frameButtons,text='Ok',
+                width=8,command=self.Ok)
+        self.buttonOk.grid(row=0,column=0,padx=5,pady=5)
+        self.buttonCancel = Button(frameButtons,text='Cancel',
+                width=8,command=self.Cancel)
+        self.buttonCancel.grid(row=0,column=1,padx=5,pady=5)
+
+    def NameOk(self):
+        #simple validity check for a sensible
+        #ConfigParser file section name
+        nameOk=1
+        name=self.name.get()
+        name.strip()
+        if not name: #no name specified
+            tkMessageBox.showerror(title='Name Error',
+                    message='No name specified.', parent=self)
+            nameOk=0
+        elif len(name)>30: #name too long
+            tkMessageBox.showerror(title='Name Error',
+                    message='Name too long. It should be no more than '+
+                    '30 characters.', parent=self)
+            nameOk=0
+        elif name in self.usedNames:
+            tkMessageBox.showerror(title='Name Error',
+                    message='This name is already in use.', parent=self)
+            nameOk=0
+        return nameOk
+
+    def Ok(self, event=None):
+        if self.NameOk():
+            self.result=self.name.get().strip()
+            self.destroy()
+
+    def Cancel(self, event=None):
+        self.result=''
+        self.destroy()
+
+if __name__ == '__main__':
+    #test the dialog
+    root=Tk()
+    def run():
+        keySeq=''
+        dlg=GetCfgSectionNameDialog(root,'Get Name',
+                'The information here should need to be word wrapped. Test.')
+        print dlg.result
+    Button(root,text='Dialog',command=run).pack()
+    root.mainloop()
diff --git a/Tools/idle/dynOptionMenuWidget.py b/Tools/idle/dynOptionMenuWidget.py
new file mode 100644
index 0000000..e81f7ba
--- /dev/null
+++ b/Tools/idle/dynOptionMenuWidget.py
@@ -0,0 +1,35 @@
+"""
+OptionMenu widget modified to allow dynamic menu reconfiguration
+and setting of highlightthickness
+"""
+from Tkinter import OptionMenu
+from Tkinter import _setit
+import copy
+
+class DynOptionMenu(OptionMenu):
+    """
+    unlike OptionMenu, our kwargs can include highlightthickness
+    """
+    def __init__(self, master, variable, value, *values, **kwargs):
+        #get a copy of kwargs before OptionMenu.__init__ munges them
+        kwargsCopy=copy.copy(kwargs)
+        if 'highlightthickness' in kwargs.keys():
+            del(kwargs['highlightthickness'])
+        OptionMenu.__init__(self, master, variable, value, *values, **kwargs)
+        self.config(highlightthickness=kwargsCopy.get('highlightthickness'))
+        #self.menu=self['menu']
+        self.variable=variable
+        self.command=kwargs.get('command')
+
+    def SetMenu(self,valueList,value=None):
+        """
+        clear and reload the menu with a new set of options.
+        valueList - list of new options
+        value - initial value to set the optionmenu's menubutton to
+        """
+        self['menu'].delete(0,'end')
+        for item in valueList:
+            self['menu'].add_command(label=item,
+                    command=_setit(self.variable,item,self.command))
+        if value:
+            self.variable.set(value)
diff --git a/Tools/idle/eventparse.py b/Tools/idle/eventparse.py
deleted file mode 100644
index f253b2a..0000000
--- a/Tools/idle/eventparse.py
+++ /dev/null
@@ -1,89 +0,0 @@
-#! /usr/bin/env python
-
-"""Parse event definitions out of comments in source files."""
-
-import sys
-import glob
-import fileinput
-import pprint
-
-def main():
-    hits = []
-    sublist = []
-    args = sys.argv[1:]
-    if not args:
-        args = filter(lambda s: 'A' <= s[0] <= 'Z', glob.glob("*.py"))
-        if not args:
-            print "No arguments, no [A-Z]*.py files."
-            return 1
-    for line in fileinput.input(args):
-        if line[:2] == '#$':
-            if not sublist:
-                sublist.append('file %s' % fileinput.filename())
-                sublist.append('line %d' % fileinput.lineno())
-            sublist.append(line[2:-1].strip())
-        else:
-            if sublist:
-                hits.append(sublist)
-                sublist = []
-    if sublist:
-        hits.append(sublist)
-        sublist = []
-    dd = {}
-    for sublist in hits:
-        d = {}
-        for line in sublist:
-            words = line.split(None, 1)
-            if len(words) != 2:
-                continue
-            tag = words[0]
-            l = d.get(tag, [])
-            l.append(words[1])
-            d[tag] = l
-        if d.has_key('event'):
-            keys = d['event']
-            if len(keys) != 1:
-                print "Multiple event keys in", d
-                print 'File "%s", line %d' % (d['file'], d['line'])
-            key = keys[0]
-            if dd.has_key(key):
-                print "Duplicate event in", d
-                print 'File "%s", line %d' % (d['file'], d['line'])
-                return
-            dd[key] = d
-        else:
-            print "No event key in", d
-            print 'File "%s", line %d' % (d['file'], d['line'])
-    winevents = getevents(dd, "win")
-    unixevents = getevents(dd, "unix")
-    save = sys.stdout
-    f = open("keydefs.py", "w")
-    try:
-        sys.stdout = f
-        print "windows_keydefs = \\"
-        pprint.pprint(winevents)
-        print
-        print "unix_keydefs = \\"
-        pprint.pprint(unixevents)
-    finally:
-        sys.stdout = save
-    f.close()
-
-def getevents(dd, key):
-    res = {}
-    events = dd.keys()
-    events.sort()
-    for e in events:
-        d = dd[e]
-        if d.has_key(key) or d.has_key("all"):
-            list = []
-            for x in d.get(key, []) + d.get("all", []):
-                list.append(x)
-                if key == "unix" and x[:5] == "<Alt-":
-                    x = "<Meta-" + x[5:]
-                    list.append(x)
-            res[e] = list
-    return res
-
-if __name__ == '__main__':
-    sys.exit(main())
diff --git a/Tools/idle/interruptmodule.c b/Tools/idle/interruptmodule.c
new file mode 100644
index 0000000..8e18d5a
--- /dev/null
+++ b/Tools/idle/interruptmodule.c
@@ -0,0 +1,49 @@
+/***********************************************************************
+ *  interruptmodule.c
+ *
+ *  Python extension implementing the interrupt module.
+ *  
+ **********************************************************************/
+
+#include "Python.h"
+
+#ifndef PyDoc_STR
+#define PyDoc_VAR(name) static char name[]
+#define PyDoc_STR(str) str
+#define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str)
+#endif
+
+/* module documentation */
+
+PyDoc_STRVAR(module_doc,
+"Provide a way to interrupt the main thread from a subthread.\n\n\
+In threaded Python code the KeyboardInterrupt is always directed to\n\
+the thread which raised it.  This extension provides a method,\n\
+interrupt_main, which a subthread can use to raise a KeyboardInterrupt\n\
+in the main thread.");
+
+/* module functions */
+
+static PyObject *
+setinterrupt(PyObject * self, PyObject * args)
+{
+	PyErr_SetInterrupt();
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* registration table */
+
+static struct PyMethodDef methods[] = {
+	{"interrupt_main", setinterrupt, METH_VARARGS,
+	 PyDoc_STR("Interrupt the main thread")},
+	{NULL, NULL}
+};
+
+/* module initialization */
+
+void
+initinterrupt(void)
+{
+	(void) Py_InitModule3("interrupt", methods, module_doc);
+}
diff --git a/Tools/idle/keybindingDialog.py b/Tools/idle/keybindingDialog.py
new file mode 100644
index 0000000..df024e7
--- /dev/null
+++ b/Tools/idle/keybindingDialog.py
@@ -0,0 +1,262 @@
+"""
+dialog for building tkinter accelerator key bindings
+"""
+from Tkinter import *
+import tkMessageBox
+import string, os
+
+class GetKeysDialog(Toplevel):
+    def __init__(self,parent,title,action,currentKeySequences):
+        """
+        action - string, the name of the virtual event these keys will be
+                 mapped to
+        currentKeys - list, a list of all key sequence lists currently mapped
+                 to virtual events, for overlap checking
+        """
+        Toplevel.__init__(self, parent)
+        self.configure(borderwidth=5)
+        self.resizable(height=FALSE,width=FALSE)
+        self.title(title)
+        self.transient(parent)
+        self.grab_set()
+        self.protocol("WM_DELETE_WINDOW", self.Cancel)
+        self.parent = parent
+        self.action=action
+        self.currentKeySequences=currentKeySequences
+        self.result=''
+        self.keyString=StringVar(self)
+        self.keyString.set('')
+        self.SetModifiersForPlatform()
+        self.modifier_vars = []
+        for modifier in self.modifiers:
+            variable = StringVar(self)
+            variable.set('')
+            self.modifier_vars.append(variable)
+        self.CreateWidgets()
+        self.LoadFinalKeyList()
+        self.withdraw() #hide while setting geometry
+        self.update_idletasks()
+        self.geometry("+%d+%d" %
+            ((parent.winfo_rootx()+((parent.winfo_width()/2)
+                -(self.winfo_reqwidth()/2)),
+              parent.winfo_rooty()+((parent.winfo_height()/2)
+                -(self.winfo_reqheight()/2)) )) ) #centre dialog over parent
+        self.deiconify() #geometry set, unhide
+        self.wait_window()
+
+    def CreateWidgets(self):
+        frameMain = Frame(self,borderwidth=2,relief=SUNKEN)
+        frameMain.pack(side=TOP,expand=TRUE,fill=BOTH)
+        frameButtons=Frame(self)
+        frameButtons.pack(side=BOTTOM,fill=X)
+        self.buttonOk = Button(frameButtons,text='Ok',
+                width=8,command=self.Ok)
+        self.buttonOk.grid(row=0,column=0,padx=5,pady=5)
+        self.buttonCancel = Button(frameButtons,text='Cancel',
+                width=8,command=self.Cancel)
+        self.buttonCancel.grid(row=0,column=1,padx=5,pady=5)
+        self.frameKeySeqBasic = Frame(frameMain)
+        self.frameKeySeqAdvanced = Frame(frameMain)
+        self.frameControlsBasic = Frame(frameMain)
+        self.frameHelpAdvanced = Frame(frameMain)
+        self.frameKeySeqAdvanced.grid(row=0,column=0,sticky=NSEW,padx=5,pady=5)
+        self.frameKeySeqBasic.grid(row=0,column=0,sticky=NSEW,padx=5,pady=5)
+        self.frameKeySeqBasic.lift()
+        self.frameHelpAdvanced.grid(row=1,column=0,sticky=NSEW,padx=5)
+        self.frameControlsBasic.grid(row=1,column=0,sticky=NSEW,padx=5)
+        self.frameControlsBasic.lift()
+        self.buttonLevel = Button(frameMain,command=self.ToggleLevel,
+                text='Advanced Key Binding Entry >>')
+        self.buttonLevel.grid(row=2,column=0,stick=EW,padx=5,pady=5)
+        labelTitleBasic = Label(self.frameKeySeqBasic,
+                text="New keys for  '"+self.action+"' :")
+        labelTitleBasic.pack(anchor=W)
+        labelKeysBasic = Label(self.frameKeySeqBasic,justify=LEFT,
+                textvariable=self.keyString,relief=GROOVE,borderwidth=2)
+        labelKeysBasic.pack(ipadx=5,ipady=5,fill=X)
+        self.modifier_checkbuttons = {}
+        column = 0
+        for modifier, variable in zip(self.modifiers, self.modifier_vars):
+            label = self.modifier_label.get(modifier, modifier)
+            check=Checkbutton(self.frameControlsBasic,
+                command=self.BuildKeyString,
+                text=label,variable=variable,onvalue=modifier,offvalue='')
+            check.grid(row=0,column=column,padx=2,sticky=W)
+            self.modifier_checkbuttons[modifier] = check
+            column += 1
+        labelFnAdvice=Label(self.frameControlsBasic,justify=LEFT,
+                text="Select the desired modifier\n"+
+                     "keys above, and final key\n"+
+                     "from the list on the right.")
+        labelFnAdvice.grid(row=1,column=0,columnspan=4,padx=2,sticky=W)
+        self.listKeysFinal=Listbox(self.frameControlsBasic,width=15,height=10,
+                selectmode=SINGLE)
+        self.listKeysFinal.bind('<ButtonRelease-1>',self.FinalKeySelected)
+        self.listKeysFinal.grid(row=0,column=4,rowspan=4,sticky=NS)
+        scrollKeysFinal=Scrollbar(self.frameControlsBasic,orient=VERTICAL,
+                command=self.listKeysFinal.yview)
+        self.listKeysFinal.config(yscrollcommand=scrollKeysFinal.set)
+        scrollKeysFinal.grid(row=0,column=5,rowspan=4,sticky=NS)
+        self.buttonClear=Button(self.frameControlsBasic,
+                text='Clear Keys',command=self.ClearKeySeq)
+        self.buttonClear.grid(row=2,column=0,columnspan=4)
+        labelTitleAdvanced = Label(self.frameKeySeqAdvanced,justify=LEFT,
+                text="Enter new binding(s) for  '"+self.action+"' :\n"+
+                "(will not be checked for validity)")
+        labelTitleAdvanced.pack(anchor=W)
+        self.entryKeysAdvanced=Entry(self.frameKeySeqAdvanced,
+                textvariable=self.keyString)
+        self.entryKeysAdvanced.pack(fill=X)
+        labelHelpAdvanced=Label(self.frameHelpAdvanced,justify=LEFT,
+            text="Key bindings are specified using tkinter key id's as\n"+
+                 "in these samples: <Control-f>, <Shift-F2>, <F12>,\n"
+                 "<Control-space>, <Meta-less>, <Control-Alt-Shift-x>.\n\n"+
+                 "'Emacs style' multi-keystroke bindings are specified as\n"+
+                 "follows: <Control-x><Control-y> or <Meta-f><Meta-g>.\n\n"+
+                 "Multiple separate bindings for one action should be\n"+
+                 "separated by a space, eg., <Alt-v> <Meta-v>." )
+        labelHelpAdvanced.grid(row=0,column=0,sticky=NSEW)
+
+    def SetModifiersForPlatform(self):
+        """Determine list of names of key modifiers for this platform.
+
+        The names are used to build Tk bindings -- it doesn't matter if the
+        keyboard has these keys, it matters if Tk understands them. The
+        order is also important: key binding equality depends on it, so
+        config-keys.def must use the same ordering.
+        """
+        import sys
+        if sys.platform == 'darwin' and sys.executable.count('.app'):
+            self.modifiers = ['Shift', 'Control', 'Option', 'Command']
+        else:
+            self.modifiers = ['Control', 'Alt', 'Shift']
+        self.modifier_label = {'Control': 'Ctrl'}
+
+    def ToggleLevel(self):
+        if  self.buttonLevel.cget('text')[:8]=='Advanced':
+            self.ClearKeySeq()
+            self.buttonLevel.config(text='<< Basic Key Binding Entry')
+            self.frameKeySeqAdvanced.lift()
+            self.frameHelpAdvanced.lift()
+            self.entryKeysAdvanced.focus_set()
+        else:
+            self.ClearKeySeq()
+            self.buttonLevel.config(text='Advanced Key Binding Entry >>')
+            self.frameKeySeqBasic.lift()
+            self.frameControlsBasic.lift()
+
+    def FinalKeySelected(self,event):
+        self.BuildKeyString()
+
+    def BuildKeyString(self):
+        keyList=[]
+        modifiers=self.GetModifiers()
+        finalKey=self.listKeysFinal.get(ANCHOR)
+        if modifiers: modifiers[0]='<'+modifiers[0]
+        keyList=keyList+modifiers
+        if finalKey:
+            if (not modifiers) and (finalKey not
+                    in self.alphanumKeys+self.punctuationKeys):
+                finalKey='<'+self.TranslateKey(finalKey)
+            else:
+                finalKey=self.TranslateKey(finalKey)
+            keyList.append(finalKey+'>')
+        keyStr=string.join(keyList,'-')
+        self.keyString.set(keyStr)
+
+    def GetModifiers(self):
+        modList = [variable.get() for variable in self.modifier_vars]
+        return filter(None, modList)
+
+    def ClearKeySeq(self):
+        self.listKeysFinal.select_clear(0,END)
+        self.listKeysFinal.yview(MOVETO, '0.0')
+        for variable in self.modifier_vars:
+            variable.set('')
+        self.keyString.set('')
+
+    def LoadFinalKeyList(self):
+        #these tuples are also available for use in validity checks
+        self.functionKeys=('F1','F2','F2','F4','F5','F6','F7','F8','F9',
+                'F10','F11','F12')
+        self.alphanumKeys=tuple(string.ascii_lowercase+string.digits)
+        self.punctuationKeys=tuple('~!@#%^&*()_-+={}[]|;:,.<>/?')
+        self.whitespaceKeys=('Tab','Space','Return')
+        self.editKeys=('BackSpace','Delete','Insert')
+        self.moveKeys=('Home','End','Page Up','Page Down','Left Arrow',
+                'Right Arrow','Up Arrow','Down Arrow')
+        #make a tuple of most of the useful common 'final' keys
+        keys=(self.alphanumKeys+self.punctuationKeys+self.functionKeys+
+                self.whitespaceKeys+self.editKeys+self.moveKeys)
+        apply(self.listKeysFinal.insert,
+            (END,)+keys)
+
+    def TranslateKey(self,key):
+        #translate from key list value to tkinter key-id
+        translateDict={'~':'asciitilde','!':'exclam','@':'at','#':'numbersign',
+                '%':'percent','^':'asciicircum','&':'ampersand','*':'asterisk',
+                '(':'parenleft',')':'parenright','_':'underscore','-':'minus',
+                '+':'plus','=':'equal','{':'braceleft','}':'braceright',
+                '[':'bracketleft',']':'bracketright','|':'bar',';':'semicolon',
+                ':':'colon',',':'comma','.':'period','<':'less','>':'greater',
+                '/':'slash','?':'question','Page Up':'Prior','Page Down':'Next',
+                'Left Arrow':'Left','Right Arrow':'Right','Up Arrow':'Up',
+                'Down Arrow': 'Down'}
+        if key in translateDict.keys():
+            key=translateDict[key]
+        key='Key-'+key
+        return key
+
+    def Ok(self, event=None):
+        if self.KeysOk():
+            self.result=self.keyString.get()
+            self.destroy()
+
+    def Cancel(self, event=None):
+        self.result=''
+        self.destroy()
+
+    def KeysOk(self):
+        #simple validity check
+        keysOk=1
+        keys=self.keyString.get()
+        keys.strip()
+        finalKey=self.listKeysFinal.get(ANCHOR)
+        modifiers=self.GetModifiers()
+        keySequence=keys.split()#make into a key sequence list for overlap check
+        if not keys: #no keys specified
+            tkMessageBox.showerror(title='Key Sequence Error',
+                    message='No keys specified.')
+            keysOk=0
+        elif not keys.endswith('>'): #no final key specified
+            tkMessageBox.showerror(title='Key Sequence Error',
+                    message='No final key specified.')
+            keysOk=0
+        elif (not modifiers) and (finalKey in
+                self.alphanumKeys+self.punctuationKeys):
+            #modifier required
+            tkMessageBox.showerror(title='Key Sequence Error',
+                    message='No modifier key(s) specified.')
+            keysOk=0
+        elif (modifiers==['Shift']) and (finalKey not
+                in self.functionKeys+('Tab',)):
+            #shift alone is only a useful modifier with a function key
+            tkMessageBox.showerror(title='Key Sequence Error',
+                    message='Shift alone is not a useful modifier '+
+                            'when used with this final key key.')
+            keysOk=0
+        elif keySequence in self.currentKeySequences: #keys combo already in use
+            tkMessageBox.showerror(title='Key Sequence Error',
+                    message='This key combination is already in use.')
+            keysOk=0
+        return keysOk
+
+if __name__ == '__main__':
+    #test the dialog
+    root=Tk()
+    def run():
+        keySeq=''
+        dlg=GetKeysDialog(root,'Get Keys','find-again',[])
+        print dlg.result
+    Button(root,text='Dialog',command=run).pack()
+    root.mainloop()
diff --git a/Tools/idle/keydefs.py b/Tools/idle/keydefs.py
deleted file mode 100644
index 9761258..0000000
--- a/Tools/idle/keydefs.py
+++ /dev/null
@@ -1,57 +0,0 @@
-windows_keydefs = \
-{'<<Copy>>': ['<Control-c>', '<Control-C>'],
- '<<Cut>>': ['<Control-x>', '<Control-X>'],
- '<<Paste>>': ['<Control-v>', '<Control-V>'],
- '<<beginning-of-line>>': ['<Control-a>', '<Home>'],
- '<<center-insert>>': ['<Control-l>'],
- '<<close-all-windows>>': ['<Control-q>'],
- '<<close-window>>': ['<Alt-F4>'],
- '<<dump-undo-state>>': ['<Control-backslash>'],
- '<<end-of-file>>': ['<Control-d>'],
- '<<help>>': ['<F1>'],
- '<<history-next>>': ['<Alt-n>'],
- '<<history-previous>>': ['<Alt-p>'],
- '<<interrupt-execution>>': ['<Control-c>'],
- '<<open-class-browser>>': ['<Alt-c>'],
- '<<open-module>>': ['<Alt-m>'],
- '<<open-new-window>>': ['<Control-n>'],
- '<<open-window-from-file>>': ['<Control-o>'],
- '<<plain-newline-and-indent>>': ['<Control-j>'],
- '<<print-window>>': ['<Control-p>'],
- '<<redo>>': ['<Control-y>'],
- '<<remove-selection>>': ['<Escape>'],
- '<<save-copy-of-window-as-file>>': ['<Alt-Shift-s>'],
- '<<save-window-as-file>>': ['<Alt-s>'],
- '<<save-window>>': ['<Control-s>'],
- '<<select-all>>': ['<Control-a>'],
- '<<toggle-auto-coloring>>': ['<Control-slash>'],
- '<<undo>>': ['<Control-z>']}
-
-unix_keydefs = \
-{'<<Copy>>': ['<Alt-w>', '<Meta-w>'],
- '<<Cut>>': ['<Control-w>'],
- '<<Paste>>': ['<Control-y>'],
- '<<beginning-of-line>>': ['<Control-a>', '<Home>'],
- '<<center-insert>>': ['<Control-l>'],
- '<<close-all-windows>>': ['<Control-x><Control-c>'],
- '<<close-window>>': ['<Control-x><Control-0>', '<Control-x><Key-0>'],
- '<<do-nothing>>': ['<Control-x>'],
- '<<dump-undo-state>>': ['<Control-backslash>'],
- '<<end-of-file>>': ['<Control-d>'],
- '<<help>>': ['<F1>'],
- '<<history-next>>': ['<Alt-n>', '<Meta-n>'],
- '<<history-previous>>': ['<Alt-p>', '<Meta-p>'],
- '<<interrupt-execution>>': ['<Control-c>'],
- '<<open-class-browser>>': ['<Control-x><Control-b>'],
- '<<open-module>>': ['<Control-x><Control-m>'],
- '<<open-new-window>>': ['<Control-x><Control-n>'],
- '<<open-window-from-file>>': ['<Control-x><Control-f>'],
- '<<plain-newline-and-indent>>': ['<Control-j>'],
- '<<print-window>>': ['<Control-x><Control-p>'],
- '<<redo>>': ['<Alt-z>', '<Meta-z>'],
- '<<save-copy-of-window-as-file>>': ['<Control-x><w>'],
- '<<save-window-as-file>>': ['<Control-x><Control-w>'],
- '<<save-window>>': ['<Control-x><Control-s>'],
- '<<select-all>>': ['<Alt-a>', '<Meta-a>'],
- '<<toggle-auto-coloring>>': ['<Control-slash>'],
- '<<undo>>': ['<Control-z>']}
diff --git a/Tools/idle/macosx_main.py b/Tools/idle/macosx_main.py
new file mode 100644
index 0000000..bc91a0b
--- /dev/null
+++ b/Tools/idle/macosx_main.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env pythonw
+# IDLE.app
+#
+# Installation:
+#   see the install_IDLE target in python/dist/src/Mac/OSX/Makefile
+#
+# Usage:
+#
+# 1. Double clicking IDLE icon will open IDLE.
+# 2. Dropping file on IDLE icon will open that file in IDLE.
+# 3. Launch from command line with files with this command-line:
+#
+#     /Applications/Python/IDLE.app/Contents/MacOS/python file1 file2 file3
+#
+#
+
+# Add IDLE.app/Contents/Resources/idlelib to path.
+# __file__ refers to this file when it is used as a module, sys.argv[0]
+# refers to this file when it is used as a script (pythonw macosx_main.py)
+import sys
+
+from os.path import split, join, isdir
+try:
+    __file__
+except NameError:
+    __file__ = sys.argv[0]
+idlelib = join(split(__file__)[0], 'idlelib')
+if isdir(idlelib):
+    sys.path.append(idlelib)
+
+# see if we are being asked to execute the subprocess code
+if '-p' in sys.argv:
+    # run expects only the port number in sys.argv
+    sys.argv.remove('-p')
+
+    # this module will become the namespace used by the interactive
+    # interpreter; remove all variables we have defined.
+    del sys, __file__, split, join, isdir, idlelib
+    __import__('run').main()
+else:
+    # Load idlelib/idle.py which starts the application.
+    import idle
diff --git a/Tools/idle/rpc.py b/Tools/idle/rpc.py
new file mode 100644
index 0000000..15946a6
--- /dev/null
+++ b/Tools/idle/rpc.py
@@ -0,0 +1,580 @@
+"""RPC Implemention, originally written for the Python Idle IDE
+
+For security reasons, GvR requested that Idle's Python execution server process
+connect to the Idle process, which listens for the connection.  Since Idle has
+has only one client per server, this was not a limitation.
+
+   +---------------------------------+ +-------------+
+   | SocketServer.BaseRequestHandler | | SocketIO    |
+   +---------------------------------+ +-------------+
+                   ^                   | register()  |
+                   |                   | unregister()|
+                   |                   +-------------+
+                   |                      ^  ^
+                   |                      |  |
+                   | + -------------------+  |
+                   | |                       |
+   +-------------------------+        +-----------------+
+   | RPCHandler              |        | RPCClient       |
+   | [attribute of RPCServer]|        |                 |
+   +-------------------------+        +-----------------+
+
+The RPCServer handler class is expected to provide register/unregister methods.
+RPCHandler inherits the mix-in class SocketIO, which provides these methods.
+
+See the Idle run.main() docstring for further information on how this was
+accomplished in Idle.
+
+"""
+
+import sys
+import socket
+import select
+import SocketServer
+import struct
+import cPickle as pickle
+import threading
+import traceback
+import copy_reg
+import types
+import marshal
+
+def unpickle_code(ms):
+    co = marshal.loads(ms)
+    assert isinstance(co, types.CodeType)
+    return co
+
+def pickle_code(co):
+    assert isinstance(co, types.CodeType)
+    ms = marshal.dumps(co)
+    return unpickle_code, (ms,)
+
+# XXX KBK 24Aug02 function pickling capability not used in Idle
+#  def unpickle_function(ms):
+#      return ms
+
+#  def pickle_function(fn):
+#      assert isinstance(fn, type.FunctionType)
+#      return `fn`
+
+copy_reg.pickle(types.CodeType, pickle_code, unpickle_code)
+# copy_reg.pickle(types.FunctionType, pickle_function, unpickle_function)
+
+BUFSIZE = 8*1024
+
+class RPCServer(SocketServer.TCPServer):
+
+    def __init__(self, addr, handlerclass=None):
+        if handlerclass is None:
+            handlerclass = RPCHandler
+        SocketServer.TCPServer.__init__(self, addr, handlerclass)
+
+    def server_bind(self):
+        "Override TCPServer method, no bind() phase for connecting entity"
+        pass
+
+    def server_activate(self):
+        """Override TCPServer method, connect() instead of listen()
+
+        Due to the reversed connection, self.server_address is actually the
+        address of the Idle Client to which we are connecting.
+
+        """
+        self.socket.connect(self.server_address)
+
+    def get_request(self):
+        "Override TCPServer method, return already connected socket"
+        return self.socket, self.server_address
+
+    def handle_error(self, request, client_address):
+        """Override TCPServer method
+
+        Error message goes to __stderr__.  No error message if exiting
+        normally or socket raised EOF.  Other exceptions not handled in
+        server code will cause os._exit.
+
+        """
+        try:
+            raise
+        except SystemExit:
+            raise
+        except EOFError:
+            pass
+        except:
+            erf = sys.__stderr__
+            print>>erf, '\n' + '-'*40
+            print>>erf, 'Unhandled server exception!'
+            print>>erf, 'Thread: %s' % threading.currentThread().getName()
+            print>>erf, 'Client Address: ', client_address
+            print>>erf, 'Request: ', repr(request)
+            traceback.print_exc(file=erf)
+            print>>erf, '\n*** Unrecoverable, server exiting!'
+            print>>erf, '-'*40
+            import os
+            os._exit(0)
+
+
+objecttable = {}
+
+class SocketIO:
+
+    nextseq = 0
+
+    def __init__(self, sock, objtable=None, debugging=None):
+        self.mainthread = threading.currentThread()
+        if debugging is not None:
+            self.debugging = debugging
+        self.sock = sock
+        if objtable is None:
+            objtable = objecttable
+        self.objtable = objtable
+        self.cvar = threading.Condition()
+        self.responses = {}
+        self.cvars = {}
+        self.interrupted = False
+
+    def close(self):
+        sock = self.sock
+        self.sock = None
+        if sock is not None:
+            sock.close()
+
+    def debug(self, *args):
+        if not self.debugging:
+            return
+        s = self.location + " " + str(threading.currentThread().getName())
+        for a in args:
+            s = s + " " + str(a)
+        print>>sys.__stderr__, s
+
+    def register(self, oid, object):
+        self.objtable[oid] = object
+
+    def unregister(self, oid):
+        try:
+            del self.objtable[oid]
+        except KeyError:
+            pass
+
+    def localcall(self, request):
+        self.debug("localcall:", request)
+        try:
+            how, (oid, methodname, args, kwargs) = request
+        except TypeError:
+            return ("ERROR", "Bad request format")
+        assert how == "call"
+        if not self.objtable.has_key(oid):
+            return ("ERROR", "Unknown object id: %s" % `oid`)
+        obj = self.objtable[oid]
+        if methodname == "__methods__":
+            methods = {}
+            _getmethods(obj, methods)
+            return ("OK", methods)
+        if methodname == "__attributes__":
+            attributes = {}
+            _getattributes(obj, attributes)
+            return ("OK", attributes)
+        if not hasattr(obj, methodname):
+            return ("ERROR", "Unsupported method name: %s" % `methodname`)
+        method = getattr(obj, methodname)
+        try:
+            ret = method(*args, **kwargs)
+            if isinstance(ret, RemoteObject):
+                ret = remoteref(ret)
+            return ("OK", ret)
+        except SystemExit:
+            raise
+        except socket.error:
+            pass
+        except:
+            self.debug("localcall:EXCEPTION")
+            traceback.print_exc(file=sys.__stderr__)
+            return ("EXCEPTION", None)
+
+    def remotecall(self, oid, methodname, args, kwargs):
+        self.debug("remotecall:asynccall: ", oid, methodname)
+        # XXX KBK 06Feb03 self.interrupted logic may not be necessary if
+        #                 subprocess is threaded.
+        if self.interrupted:
+            self.interrupted = False
+            raise KeyboardInterrupt
+        seq = self.asynccall(oid, methodname, args, kwargs)
+        return self.asyncreturn(seq)
+
+    def asynccall(self, oid, methodname, args, kwargs):
+        request = ("call", (oid, methodname, args, kwargs))
+        seq = self.newseq()
+        self.debug(("asynccall:%d:" % seq), oid, methodname, args, kwargs)
+        self.putmessage((seq, request))
+        return seq
+
+    def asyncreturn(self, seq):
+        self.debug("asyncreturn:%d:call getresponse(): " % seq)
+        response = self.getresponse(seq, wait=None)
+        self.debug(("asyncreturn:%d:response: " % seq), response)
+        return self.decoderesponse(response)
+
+    def decoderesponse(self, response):
+        how, what = response
+        if how == "OK":
+            return what
+        if how == "EXCEPTION":
+            self.debug("decoderesponse: EXCEPTION")
+            return None
+        if how == "ERROR":
+            self.debug("decoderesponse: Internal ERROR:", what)
+            raise RuntimeError, what
+        raise SystemError, (how, what)
+
+    def mainloop(self):
+        """Listen on socket until I/O not ready or EOF
+
+        Main thread pollresponse() will loop looking for seq number None, which
+        never comes, and exit on EOFError.
+
+        """
+        try:
+            self.getresponse(myseq=None, wait=None)
+        except EOFError:
+            pass
+
+    def getresponse(self, myseq, wait):
+        response = self._getresponse(myseq, wait)
+        if response is not None:
+            how, what = response
+            if how == "OK":
+                response = how, self._proxify(what)
+        return response
+
+    def _proxify(self, obj):
+        if isinstance(obj, RemoteProxy):
+            return RPCProxy(self, obj.oid)
+        if isinstance(obj, types.ListType):
+            return map(self._proxify, obj)
+        # XXX Check for other types -- not currently needed
+        return obj
+
+    def _getresponse(self, myseq, wait):
+        self.debug("_getresponse:myseq:", myseq)
+        if threading.currentThread() is self.mainthread:
+            # Main thread: does all reading of requests or responses
+            # Loop here, blocking each time until socket is ready.
+            while 1:
+                response = self.pollresponse(myseq, wait)
+                if response is not None:
+                    return response
+        else:
+            # Auxiliary thread: wait for notification from main thread
+            self.cvar.acquire()
+            self.cvars[myseq] = self.cvar
+            while not self.responses.has_key(myseq):
+                self.cvar.wait()
+            response = self.responses[myseq]
+            del self.responses[myseq]
+            del self.cvars[myseq]
+            self.cvar.release()
+            return response
+
+    def newseq(self):
+        self.nextseq = seq = self.nextseq + 2
+        return seq
+
+    def putmessage(self, message):
+        self.debug("putmessage:%d:" % message[0])
+        try:
+            s = pickle.dumps(message)
+        except:
+            print >>sys.__stderr__, "Cannot pickle:", `message`
+            raise
+        s = struct.pack("<i", len(s)) + s
+        while len(s) > 0:
+            try:
+                n = self.sock.send(s)
+            except AttributeError:
+                # socket was closed
+                raise IOError
+            else:
+                s = s[n:]
+
+    def ioready(self, wait=0.0):
+        r, w, x = select.select([self.sock.fileno()], [], [], wait)
+        return len(r)
+
+    buffer = ""
+    bufneed = 4
+    bufstate = 0 # meaning: 0 => reading count; 1 => reading data
+
+    def pollpacket(self, wait=0.0):
+        self._stage0()
+        if len(self.buffer) < self.bufneed:
+            if not self.ioready(wait):
+                return None
+            try:
+                s = self.sock.recv(BUFSIZE)
+            except socket.error:
+                raise EOFError
+            if len(s) == 0:
+                raise EOFError
+            self.buffer += s
+            self._stage0()
+        return self._stage1()
+
+    def _stage0(self):
+        if self.bufstate == 0 and len(self.buffer) >= 4:
+            s = self.buffer[:4]
+            self.buffer = self.buffer[4:]
+            self.bufneed = struct.unpack("<i", s)[0]
+            self.bufstate = 1
+
+    def _stage1(self):
+        if self.bufstate == 1 and len(self.buffer) >= self.bufneed:
+            packet = self.buffer[:self.bufneed]
+            self.buffer = self.buffer[self.bufneed:]
+            self.bufneed = 4
+            self.bufstate = 0
+            return packet
+
+    def pollmessage(self, wait=0.0):
+        packet = self.pollpacket(wait)
+        if packet is None:
+            return None
+        try:
+            message = pickle.loads(packet)
+        except:
+            print >>sys.__stderr__, "-----------------------"
+            print >>sys.__stderr__, "cannot unpickle packet:", `packet`
+            traceback.print_stack(file=sys.__stderr__)
+            print >>sys.__stderr__, "-----------------------"
+            raise
+        return message
+
+    def pollresponse(self, myseq, wait=0.0):
+        """Handle messages received on the socket.
+
+        Some messages received may be asynchronous 'call' commands, and
+        some may be responses intended for other threads.
+
+        Loop until message with myseq sequence number is received.  Save others
+        in self.responses and notify the owning thread, except that 'call'
+        commands are handed off to localcall() and the response sent back
+        across the link with the appropriate sequence number.
+
+        """
+        while 1:
+            message = self.pollmessage(wait)
+            if message is None:  # socket not ready
+                return None
+            #wait = 0.0  # poll on subsequent passes instead of blocking
+            seq, resq = message
+            self.debug("pollresponse:%d:myseq:%s" % (seq, myseq))
+            if resq[0] == "call":
+                self.debug("pollresponse:%d:localcall:call:" % seq)
+                response = self.localcall(resq)
+                self.debug("pollresponse:%d:localcall:response:%s"
+                           % (seq, response))
+                self.putmessage((seq, response))
+                continue
+            elif seq == myseq:
+                return resq
+            else:
+                self.cvar.acquire()
+                cv = self.cvars.get(seq)
+                # response involving unknown sequence number is discarded,
+                # probably intended for prior incarnation
+                if cv is not None:
+                    self.responses[seq] = resq
+                    cv.notify()
+                self.cvar.release()
+                continue
+
+#----------------- end class SocketIO --------------------
+
+class RemoteObject:
+    # Token mix-in class
+    pass
+
+def remoteref(obj):
+    oid = id(obj)
+    objecttable[oid] = obj
+    return RemoteProxy(oid)
+
+class RemoteProxy:
+
+    def __init__(self, oid):
+        self.oid = oid
+
+class RPCHandler(SocketServer.BaseRequestHandler, SocketIO):
+
+    debugging = False
+    location = "#S"  # Server
+
+    def __init__(self, sock, addr, svr):
+        svr.current_handler = self ## cgt xxx
+        SocketIO.__init__(self, sock)
+        SocketServer.BaseRequestHandler.__init__(self, sock, addr, svr)
+
+    def handle(self):
+        "handle() method required by SocketServer"
+        self.mainloop()
+
+    def get_remote_proxy(self, oid):
+        return RPCProxy(self, oid)
+
+class RPCClient(SocketIO):
+
+    debugging = False
+    location = "#C"  # Client
+
+    nextseq = 1 # Requests coming from the client are odd numbered
+
+    def __init__(self, address, family=socket.AF_INET, type=socket.SOCK_STREAM):
+        self.listening_sock = socket.socket(family, type)
+        self.listening_sock.setsockopt(socket.SOL_SOCKET,
+                                       socket.SO_REUSEADDR, 1)
+        self.listening_sock.bind(address)
+        self.listening_sock.listen(1)
+
+    def accept(self):
+        working_sock, address = self.listening_sock.accept()
+        if self.debugging:
+            print>>sys.__stderr__, "****** Connection request from ", address
+        if address[0] == '127.0.0.1':
+            SocketIO.__init__(self, working_sock)
+        else:
+            print>>sys.__stderr__, "** Invalid host: ", address
+            raise socket.error
+
+    def get_remote_proxy(self, oid):
+        return RPCProxy(self, oid)
+
+class RPCProxy:
+
+    __methods = None
+    __attributes = None
+
+    def __init__(self, sockio, oid):
+        self.sockio = sockio
+        self.oid = oid
+
+    def __getattr__(self, name):
+        if self.__methods is None:
+            self.__getmethods()
+        if self.__methods.get(name):
+            return MethodProxy(self.sockio, self.oid, name)
+        if self.__attributes is None:
+            self.__getattributes()
+        if not self.__attributes.has_key(name):
+            raise AttributeError, name
+    __getattr__.DebuggerStepThrough=1
+
+    def __getattributes(self):
+        self.__attributes = self.sockio.remotecall(self.oid,
+                                                "__attributes__", (), {})
+
+    def __getmethods(self):
+        self.__methods = self.sockio.remotecall(self.oid,
+                                                "__methods__", (), {})
+
+def _getmethods(obj, methods):
+    # Helper to get a list of methods from an object
+    # Adds names to dictionary argument 'methods'
+    for name in dir(obj):
+        attr = getattr(obj, name)
+        if callable(attr):
+            methods[name] = 1
+    if type(obj) == types.InstanceType:
+        _getmethods(obj.__class__, methods)
+    if type(obj) == types.ClassType:
+        for super in obj.__bases__:
+            _getmethods(super, methods)
+
+def _getattributes(obj, attributes):
+    for name in dir(obj):
+        attr = getattr(obj, name)
+        if not callable(attr):
+            attributes[name] = 1
+
+class MethodProxy:
+
+    def __init__(self, sockio, oid, name):
+        self.sockio = sockio
+        self.oid = oid
+        self.name = name
+
+    def __call__(self, *args, **kwargs):
+        value = self.sockio.remotecall(self.oid, self.name, args, kwargs)
+        return value
+
+#
+# Self Test
+#
+
+def testServer(addr):
+    # XXX 25 Jul 02 KBK needs update to use rpc.py register/unregister methods
+    class RemotePerson:
+        def __init__(self,name):
+            self.name = name
+        def greet(self, name):
+            print "(someone called greet)"
+            print "Hello %s, I am %s." % (name, self.name)
+            print
+        def getName(self):
+            print "(someone called getName)"
+            print
+            return self.name
+        def greet_this_guy(self, name):
+            print "(someone called greet_this_guy)"
+            print "About to greet %s ..." % name
+            remote_guy = self.server.current_handler.get_remote_proxy(name)
+            remote_guy.greet("Thomas Edison")
+            print "Done."
+            print
+
+    person = RemotePerson("Thomas Edison")
+    svr = RPCServer(addr)
+    svr.register('thomas', person)
+    person.server = svr # only required if callbacks are used
+
+    # svr.serve_forever()
+    svr.handle_request()  # process once only
+
+def testClient(addr):
+    "demonstrates RPC Client"
+    # XXX 25 Jul 02 KBK needs update to use rpc.py register/unregister methods
+    import time
+    clt=RPCClient(addr)
+    thomas = clt.get_remote_proxy("thomas")
+    print "The remote person's name is ..."
+    print thomas.getName()
+    # print clt.remotecall("thomas", "getName", (), {})
+    print
+    time.sleep(1)
+    print "Getting remote thomas to say hi..."
+    thomas.greet("Alexander Bell")
+    #clt.remotecall("thomas","greet",("Alexander Bell",), {})
+    print "Done."
+    print
+    time.sleep(2)
+    # demonstrates remote server calling local instance
+    class LocalPerson:
+        def __init__(self,name):
+            self.name = name
+        def greet(self, name):
+            print "You've greeted me!"
+        def getName(self):
+            return self.name
+    person = LocalPerson("Alexander Bell")
+    clt.register("alexander",person)
+    thomas.greet_this_guy("alexander")
+    # clt.remotecall("thomas","greet_this_guy",("alexander",), {})
+
+def test():
+    addr=("localhost",8833)
+    if len(sys.argv) == 2:
+        if sys.argv[1]=='-server':
+            testServer(addr)
+            return
+    testClient(addr)
+
+if __name__ == '__main__':
+    test()
diff --git a/Tools/idle/run.py b/Tools/idle/run.py
new file mode 100644
index 0000000..497cbbd
--- /dev/null
+++ b/Tools/idle/run.py
@@ -0,0 +1,216 @@
+import sys
+import time
+import socket
+import traceback
+import threading
+import Queue
+
+import boolcheck
+
+import CallTips
+import RemoteDebugger
+import RemoteObjectBrowser
+import StackViewer
+import rpc
+import interrupt
+
+import __main__
+
+# Thread shared globals: Establish a queue between a subthread (which handles
+# the socket) and the main thread (which runs user code), plus global
+# completion and exit flags:
+
+server = None                # RPCServer instance
+queue = Queue.Queue(0)
+execution_finished = False
+exit_requested = False
+
+
+def main():
+    """Start the Python execution server in a subprocess
+
+    In the Python subprocess, RPCServer is instantiated with handlerclass
+    MyHandler, which inherits register/unregister methods from RPCHandler via
+    the mix-in class SocketIO.
+
+    When the RPCServer 'server' is instantiated, the TCPServer initialization
+    creates an instance of run.MyHandler and calls its handle() method.
+    handle() instantiates a run.Executive object, passing it a reference to the
+    MyHandler object.  That reference is saved as attribute rpchandler of the
+    Executive instance.  The Executive methods have access to the reference and
+    can pass it on to entities that they command
+    (e.g. RemoteDebugger.Debugger.start_debugger()).  The latter, in turn, can
+    call MyHandler(SocketIO) register/unregister methods via the reference to
+    register and unregister themselves.
+
+    """
+    global queue, execution_finished, exit_requested
+
+    port = 8833
+    if sys.argv[1:]:
+        port = int(sys.argv[1])
+    sys.argv[:] = [""]
+    sockthread = threading.Thread(target=manage_socket,
+                                  name='SockThread',
+                                  args=(('localhost', port),))
+    sockthread.setDaemon(True)
+    sockthread.start()
+    while 1:
+        try:
+            if exit_requested:
+                sys.exit()
+            # XXX KBK 22Mar03 eventually check queue here!
+            pass
+            time.sleep(0.05)
+        except KeyboardInterrupt:
+            ##execution_finished = True
+            continue
+
+def manage_socket(address):
+    global server, exit_requested
+
+    for i in range(6):
+        time.sleep(i)
+        try:
+            server = rpc.RPCServer(address, MyHandler)
+            break
+        except socket.error, err:
+            if i < 3:
+                print>>sys.__stderr__, ".. ",
+            else:
+                print>>sys.__stderr__,"\nPython subprocess socket error: "\
+                                              + err[1] + ", retrying...."
+    else:
+        print>>sys.__stderr__, "\nConnection to Idle failed, exiting."
+        exit_requested = True
+    server.handle_request() # A single request only
+
+
+class MyHandler(rpc.RPCHandler):
+
+    def handle(self):
+        """Override base method"""
+        executive = Executive(self)
+        self.register("exec", executive)
+        sys.stdin = self.get_remote_proxy("stdin")
+        sys.stdout = self.get_remote_proxy("stdout")
+        sys.stderr = self.get_remote_proxy("stderr")
+        rpc.RPCHandler.getresponse(self, myseq=None, wait=0.5)
+
+
+class Executive:
+
+    def __init__(self, rpchandler):
+        self.rpchandler = rpchandler
+        self.locals = __main__.__dict__
+        self.calltip = CallTips.CallTips()
+
+    def runcode(self, code):
+        global queue, execution_finished
+
+        execution_finished = False
+        queue.put(code)
+        # dequeue and run in subthread
+        self.runcode_from_queue()
+        while not execution_finished:
+            time.sleep(0.05)
+
+    def runcode_from_queue(self):
+        global queue, execution_finished
+
+        # poll until queue has code object, using threads, just block?
+        while True:
+            try:
+                code = queue.get(0)
+                break
+            except Queue.Empty:
+                time.sleep(0.05)
+        try:
+            exec code in self.locals
+        except:
+            self.flush_stdout()
+            efile = sys.stderr
+            typ, val, tb = info = sys.exc_info()
+            sys.last_type, sys.last_value, sys.last_traceback = info
+            tbe = traceback.extract_tb(tb)
+            print >>efile, 'Traceback (most recent call last):'
+            exclude = ("run.py", "rpc.py", "RemoteDebugger.py", "bdb.py")
+            self.cleanup_traceback(tbe, exclude)
+            traceback.print_list(tbe, file=efile)
+            lines = traceback.format_exception_only(typ, val)
+            for line in lines:
+                print>>efile, line,
+            execution_finished = True
+        else:
+            self.flush_stdout()
+            execution_finished = True
+
+    def flush_stdout(self):
+        try:
+            if sys.stdout.softspace:
+                sys.stdout.softspace = 0
+                sys.stdout.write("\n")
+        except (AttributeError, EOFError):
+            pass
+
+    def cleanup_traceback(self, tb, exclude):
+        "Remove excluded traces from beginning/end of tb; get cached lines"
+        orig_tb = tb[:]
+        while tb:
+            for rpcfile in exclude:
+                if tb[0][0].count(rpcfile):
+                    break    # found an exclude, break for: and delete tb[0]
+            else:
+                break        # no excludes, have left RPC code, break while:
+            del tb[0]
+        while tb:
+            for rpcfile in exclude:
+                if tb[-1][0].count(rpcfile):
+                    break
+            else:
+                break
+            del tb[-1]
+        if len(tb) == 0:
+            # exception was in IDLE internals, don't prune!
+            tb[:] = orig_tb[:]
+            print>>sys.stderr, "** IDLE Internal Exception: "
+        for i in range(len(tb)):
+            fn, ln, nm, line = tb[i]
+            if nm == '?':
+                nm = "-toplevel-"
+            if not line and fn.startswith("<pyshell#"):
+                line = self.rpchandler.remotecall('linecache', 'getline',
+                                                  (fn, ln), {})
+            tb[i] = fn, ln, nm, line
+
+    def interrupt_the_server(self):
+        self.rpchandler.interrupted = True
+        ##print>>sys.__stderr__, "** Interrupt main!"
+        interrupt.interrupt_main()
+
+    def shutdown_the_server(self):
+        global exit_requested
+
+        exit_requested = True
+
+    def start_the_debugger(self, gui_adap_oid):
+        return RemoteDebugger.start_debugger(self.rpchandler, gui_adap_oid)
+
+    def stop_the_debugger(self, idb_adap_oid):
+        "Unregister the Idb Adapter.  Link objects and Idb then subject to GC"
+        self.rpchandler.unregister(idb_adap_oid)
+
+    def get_the_calltip(self, name):
+        return self.calltip.fetch_tip(name)
+
+    def stackviewer(self, flist_oid=None):
+        if not hasattr(sys, "last_traceback"):
+            return None
+        flist = None
+        if flist_oid is not None:
+            flist = self.rpchandler.get_remote_proxy(flist_oid)
+        tb = sys.last_traceback
+        while tb and tb.tb_frame.f_globals["__name__"] in ["rpc", "run"]:
+            tb = tb.tb_next
+        item = StackViewer.StackTreeItem(flist, tb)
+        return RemoteObjectBrowser.remote_object_tree_item(item)
diff --git a/Tools/idle/setup.cfg b/Tools/idle/setup.cfg
new file mode 100644
index 0000000..c4b5729
--- /dev/null
+++ b/Tools/idle/setup.cfg
@@ -0,0 +1,4 @@
+[bdist_rpm]
+release = 1
+packager = Kurt B. Kaiser <kbk@shore.net>
+
diff --git a/Tools/idle/tabpage.py b/Tools/idle/tabpage.py
new file mode 100644
index 0000000..12f8929
--- /dev/null
+++ b/Tools/idle/tabpage.py
@@ -0,0 +1,113 @@
+"""
+a couple of classes for implementing partial tabbed-page like behaviour
+"""
+
+from Tkinter import *
+
+class InvalidTabPage(Exception): pass
+class AlreadyExists(Exception): pass
+
+class PageTab(Frame):
+    """
+    a 'page tab' like framed button
+    """
+    def __init__(self,parent):
+        Frame.__init__(self, parent,borderwidth=2,relief=RIDGE)
+        self.button=Radiobutton(self,padx=5,pady=5,takefocus=FALSE,
+                indicatoron=FALSE,highlightthickness=0,
+                borderwidth=0,selectcolor=self.cget('bg'))
+        self.button.pack()
+
+class TabPageSet(Frame):
+    """
+    a set of 'pages' with TabButtons for controlling their display
+    """
+    def __init__(self,parent,pageNames=[],**kw):
+        """
+        pageNames - a list of strings, each string will be the dictionary key
+        to a page's data, and the name displayed on the page's tab. Should be
+        specified in desired page order. The first page will be the default
+        and first active page.
+        """
+        Frame.__init__(self, parent, kw)
+        self.grid_location(0,0)
+        self.columnconfigure(0,weight=1)
+        self.rowconfigure(1,weight=1)
+        self.tabBar=Frame(self)
+        self.tabBar.grid(row=0,column=0,sticky=EW)
+        self.activePage=StringVar(self)
+        self.defaultPage=''
+        self.pages={}
+        for name in pageNames:
+            self.AddPage(name)
+
+    def ChangePage(self,pageName=None):
+        if pageName:
+            if pageName in self.pages.keys():
+                self.activePage.set(pageName)
+            else:
+                raise InvalidTabPage, 'Invalid TabPage Name'
+        ## pop up the active 'tab' only
+        for page in self.pages.keys():
+            self.pages[page]['tab'].config(relief=RIDGE)
+        self.pages[self.GetActivePage()]['tab'].config(relief=RAISED)
+        ## switch page
+        self.pages[self.GetActivePage()]['page'].lift()
+
+    def GetActivePage(self):
+        return self.activePage.get()
+
+    def AddPage(self,pageName):
+        if pageName in self.pages.keys():
+            raise AlreadyExists, 'TabPage Name Already Exists'
+        self.pages[pageName]={'tab':PageTab(self.tabBar),
+                'page':Frame(self,borderwidth=2,relief=RAISED)}
+        self.pages[pageName]['tab'].button.config(text=pageName,
+                command=self.ChangePage,variable=self.activePage,
+                value=pageName)
+        self.pages[pageName]['tab'].pack(side=LEFT)
+        self.pages[pageName]['page'].grid(row=1,column=0,sticky=NSEW)
+        if len(self.pages)==1: # adding first page
+            self.defaultPage=pageName
+            self.activePage.set(self.defaultPage)
+            self.ChangePage()
+
+    def RemovePage(self,pageName):
+        if not pageName in self.pages.keys():
+            raise InvalidTabPage, 'Invalid TabPage Name'
+        self.pages[pageName]['tab'].pack_forget()
+        self.pages[pageName]['page'].grid_forget()
+        self.pages[pageName]['tab'].destroy()
+        self.pages[pageName]['page'].destroy()
+        del(self.pages[pageName])
+        # handle removing last remaining, or default, or active page
+        if not self.pages: # removed last remaining page
+            self.defaultPage=''
+            return
+        if pageName==self.defaultPage: # set a new default page
+            self.defaultPage=\
+                self.tabBar.winfo_children()[0].button.cget('text')
+        if pageName==self.GetActivePage(): # set a new active page
+            self.activePage.set(self.defaultPage)
+        self.ChangePage()
+
+if __name__ == '__main__':
+    #test dialog
+    root=Tk()
+    tabPage=TabPageSet(root,pageNames=['Foobar','Baz'])
+    tabPage.pack(expand=TRUE,fill=BOTH)
+    Label(tabPage.pages['Foobar']['page'],text='Foo',pady=20).pack()
+    Label(tabPage.pages['Foobar']['page'],text='Bar',pady=20).pack()
+    Label(tabPage.pages['Baz']['page'],text='Baz').pack()
+    entryPgName=Entry(root)
+    buttonAdd=Button(root,text='Add Page',
+            command=lambda:tabPage.AddPage(entryPgName.get()))
+    buttonRemove=Button(root,text='Remove Page',
+            command=lambda:tabPage.RemovePage(entryPgName.get()))
+    labelPgName=Label(root,text='name of page to add/remove:')
+    buttonAdd.pack(padx=5,pady=5)
+    buttonRemove.pack(padx=5,pady=5)
+    labelPgName.pack(padx=5)
+    entryPgName.pack(padx=5)
+    tabPage.ChangePage()
+    root.mainloop()
diff --git a/Tools/idle/textView.py b/Tools/idle/textView.py
new file mode 100644
index 0000000..23e8bed
--- /dev/null
+++ b/Tools/idle/textView.py
@@ -0,0 +1,77 @@
+##---------------------------------------------------------------------------##
+##
+## idle - simple text view dialog
+## elguavas
+##
+##---------------------------------------------------------------------------##
+"""
+simple text browser for idle
+"""
+from Tkinter import *
+import tkMessageBox
+
+class TextViewer(Toplevel):
+    """
+    simple text viewer dialog for idle
+    """
+    def __init__(self,parent,title,fileName):
+        """
+        fileName - string,should be an absoulute filename
+        """
+        Toplevel.__init__(self, parent)
+        self.configure(borderwidth=5)
+        self.geometry("+%d+%d" % (parent.winfo_rootx()+10,
+                parent.winfo_rooty()+10))
+        #elguavas - config placeholders til config stuff completed
+        self.bg=None
+        self.fg=None
+
+        self.CreateWidgets()
+        self.title(title)
+        self.transient(parent)
+        self.grab_set()
+        self.protocol("WM_DELETE_WINDOW", self.Ok)
+        self.parent = parent
+        self.textView.focus_set()
+        #key bindings for this dialog
+        self.bind('<Return>',self.Ok) #dismiss dialog
+        self.bind('<Escape>',self.Ok) #dismiss dialog
+        self.LoadTextFile(fileName)
+        self.textView.config(state=DISABLED)
+        self.wait_window()
+
+    def LoadTextFile(self, fileName):
+        textFile = None
+        try:
+            textFile = open(fileName, 'r')
+        except IOError:
+            tkMessageBox.showerror(title='File Load Error',
+                    message='Unable to load file '+`fileName`+' .')
+        else:
+            self.textView.insert(0.0,textFile.read())
+
+    def CreateWidgets(self):
+        frameText = Frame(self)
+        frameButtons = Frame(self)
+        self.buttonOk = Button(frameButtons,text='Ok',
+                command=self.Ok,takefocus=FALSE,default=ACTIVE)
+        self.scrollbarView = Scrollbar(frameText,orient=VERTICAL,
+                takefocus=FALSE,highlightthickness=0)
+        self.textView = Text(frameText,wrap=WORD,highlightthickness=0)
+        self.scrollbarView.config(command=self.textView.yview)
+        self.textView.config(yscrollcommand=self.scrollbarView.set)
+        self.buttonOk.pack(padx=5,pady=5)
+        self.scrollbarView.pack(side=RIGHT,fill=Y)
+        self.textView.pack(side=LEFT,expand=TRUE,fill=BOTH)
+        frameButtons.pack(side=BOTTOM,fill=X)
+        frameText.pack(side=TOP,expand=TRUE,fill=BOTH)
+
+    def Ok(self, event=None):
+        self.destroy()
+
+if __name__ == '__main__':
+    #test the dialog
+    root=Tk()
+    Button(root,text='View',
+            command=lambda:TextViewer(root,'Text','./textView.py')).pack()
+    root.mainloop()