Add back files that were accidentally deleted on the trunk rather than

on the idlefork-merge-branch as intended.

14 files changed, 1865 insertions, 0 deletions

diff --git a/Tools/idle/AutoIndent.py b/Tools/idle/AutoIndent.py
new file mode 100644
index 0000000..7bc195b
--- /dev/null
+++ b/Tools/idle/AutoIndent.py
@@ -0,0 +1,551 @@
+#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/FrameViewer.py b/Tools/idle/FrameViewer.py
new file mode 100644
index 0000000..2ce0935
--- /dev/null
+++ b/Tools/idle/FrameViewer.py
@@ -0,0 +1,38 @@
+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/IdleConf.py b/Tools/idle/IdleConf.py
new file mode 100644
index 0000000..8eaa8e0
--- /dev/null
+++ b/Tools/idle/IdleConf.py
@@ -0,0 +1,113 @@
+"""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/MultiScrolledLists.py b/Tools/idle/MultiScrolledLists.py
new file mode 100644
index 0000000..6398b86
--- /dev/null
+++ b/Tools/idle/MultiScrolledLists.py
@@ -0,0 +1,137 @@
+# 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
new file mode 100644
index 0000000..4f295e8
--- /dev/null
+++ b/Tools/idle/OldStackViewer.py
@@ -0,0 +1,275 @@
+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/RemoteInterp.py b/Tools/idle/RemoteInterp.py
new file mode 100644
index 0000000..e6f7671
--- /dev/null
+++ b/Tools/idle/RemoteInterp.py
@@ -0,0 +1,341 @@
+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/SearchBinding.py b/Tools/idle/SearchBinding.py
new file mode 100644
index 0000000..5943e3b
--- /dev/null
+++ b/Tools/idle/SearchBinding.py
@@ -0,0 +1,97 @@
+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
new file mode 100644
index 0000000..7145559
--- /dev/null
+++ b/Tools/idle/Separator.py
@@ -0,0 +1,92 @@
+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/config-mac.txt b/Tools/idle/config-mac.txt
new file mode 100644
index 0000000..ee36e13
--- /dev/null
+++ b/Tools/idle/config-mac.txt
@@ -0,0 +1,3 @@
+[EditorWindow]
+font-name= monaco
+font-size= 9
diff --git a/Tools/idle/config-unix.txt b/Tools/idle/config-unix.txt
new file mode 100644
index 0000000..782965f
--- /dev/null
+++ b/Tools/idle/config-unix.txt
@@ -0,0 +1,4 @@
+[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
new file mode 100644
index 0000000..aeb6ab9
--- /dev/null
+++ b/Tools/idle/config-win.txt
@@ -0,0 +1,4 @@
+[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
new file mode 100644
index 0000000..6f98a3e
--- /dev/null
+++ b/Tools/idle/config.txt
@@ -0,0 +1,64 @@
+# 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/eventparse.py b/Tools/idle/eventparse.py
new file mode 100644
index 0000000..f253b2a
--- /dev/null
+++ b/Tools/idle/eventparse.py
@@ -0,0 +1,89 @@
+#! /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/keydefs.py b/Tools/idle/keydefs.py
new file mode 100644
index 0000000..9761258
--- /dev/null
+++ b/Tools/idle/keydefs.py
@@ -0,0 +1,57 @@
+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>']}