diff --git a/Lib/idlelib/AutoExpand.py b/Lib/idlelib/AutoExpand.py
new file mode 100644
index 0000000..0d57be4
--- /dev/null
+++ b/Lib/idlelib/AutoExpand.py
@@ -0,0 +1,92 @@
+import string
+import re
+
+###$ event <<expand-word>>
+###$ win <Alt-slash>
+###$ unix <Alt-slash>
+
+class AutoExpand:
+
+    keydefs = {
+        '<<expand-word>>': ['<Alt-slash>'],
+    }
+
+    unix_keydefs = {
+        '<<expand-word>>': ['<Meta-slash>'],
+    }
+
+    menudefs = [
+        ('edit', [
+            ('E_xpand word', '<<expand-word>>'),
+         ]),
+    ]
+
+    wordchars = string.letters + string.digits + "_"
+
+    def __init__(self, editwin):
+        self.text = editwin.text
+        self.text.wordlist = None # XXX what is this?
+        self.state = None
+
+    def expand_word_event(self, event):
+        curinsert = self.text.index("insert")
+        curline = self.text.get("insert linestart", "insert lineend")
+        if not self.state:
+            words = self.getwords()
+            index = 0
+        else:
+            words, index, insert, line = self.state
+            if insert != curinsert or line != curline:
+                words = self.getwords()
+                index = 0
+        if not words:
+            self.text.bell()
+            return "break"
+        word = self.getprevword()
+        self.text.delete("insert - %d chars" % len(word), "insert")
+        newword = words[index]
+        index = (index + 1) % len(words)
+        if index == 0:
+            self.text.bell()            # Warn we cycled around
+        self.text.insert("insert", newword)
+        curinsert = self.text.index("insert")
+        curline = self.text.get("insert linestart", "insert lineend")
+        self.state = words, index, curinsert, curline
+        return "break"
+
+    def getwords(self):
+        word = self.getprevword()
+        if not word:
+            return []
+        before = self.text.get("1.0", "insert wordstart")
+        wbefore = re.findall(r"\b" + word + r"\w+\b", before)
+        del before
+        after = self.text.get("insert wordend", "end")
+        wafter = re.findall(r"\b" + word + r"\w+\b", after)
+        del after
+        if not wbefore and not wafter:
+            return []
+        words = []
+        dict = {}
+        # search backwards through words before
+        wbefore.reverse()
+        for w in wbefore:
+            if dict.get(w):
+                continue
+            words.append(w)
+            dict[w] = w
+        # search onwards through words after
+        for w in wafter:
+            if dict.get(w):
+                continue
+            words.append(w)
+            dict[w] = w
+        words.append(word)
+        return words
+
+    def getprevword(self):
+        line = self.text.get("insert linestart", "insert")
+        i = len(line)
+        while i > 0 and line[i-1] in self.wordchars:
+            i = i-1
+        return line[i:]
diff --git a/Lib/idlelib/AutoIndent.py b/Lib/idlelib/AutoIndent.py
new file mode 100644
index 0000000..6d38481
--- /dev/null
+++ b/Lib/idlelib/AutoIndent.py
@@ -0,0 +1,554 @@
+import string
+#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 = [
+        ('format', [       # /s/edit/format   dscherer@cmu.edu
+            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>>': ['<Shift-Tab>',     # dscherer@cmu.edu
+                              '<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.
+        expand, tabwidth = string.expandtabs, self.tabwidth
+        have = len(expand(chars, tabwidth))
+        assert have > 0
+        want = int((have - 1) / self.indentwidth) * self.indentwidth
+        ncharsdeleted = 0
+        while 1:
+            chars = chars[:-1]
+            ncharsdeleted = ncharsdeleted + 1
+            have = len(expand(chars, 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(string.expandtabs(prefix,
+                                                      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] = string.expandtabs(lines[pos], 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 = string.split(chars, "\n")
+        return head, tail, chars, lines
+
+    def set_region(self, head, tail, chars, lines):
+        text = self.text
+        newchars = string.join(lines, "\n")
+        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/Lib/idlelib/Bindings.py b/Lib/idlelib/Bindings.py
new file mode 100644
index 0000000..33c6c44
--- /dev/null
+++ b/Lib/idlelib/Bindings.py
@@ -0,0 +1,67 @@
+# This file defines the menu contents and key bindings.  Note that
+# there is additional configuration information in the EditorWindow
+# class (and subclasses): the menus are created there based on the
+# menu_specs (class) variable, and menus not created are silently
+# skipped by the code here.  This makes it possible to define the
+# Debug menu here, which is only present in the PythonShell window.
+
+# changes by dscherer@cmu.edu:
+#   - Python shell moved to 'Run' menu
+#   - "Help" renamed to "IDLE Help" to distinguish from Python help.
+#     The distinction between the environment and the language is dim
+#     or nonexistent in a novice's mind.
+#   - Silly advice added
+
+import sys
+import string
+from keydefs import *
+
+menudefs = [
+ # underscore prefixes character to underscore
+ ('file', [
+   ('_New window', '<<open-new-window>>'),
+   ('_Open...', '<<open-window-from-file>>'),
+   ('Open _module...', '<<open-module>>'),
+   ('Class _browser', '<<open-class-browser>>'),
+   ('_Path browser', '<<open-path-browser>>'),
+   None,
+   ('_Save', '<<save-window>>'),
+   ('Save _As...', '<<save-window-as-file>>'),
+   ('Save Co_py As...', '<<save-copy-of-window-as-file>>'),
+   None,
+   ('_Close', '<<close-window>>'),
+   ('E_xit', '<<close-all-windows>>'),
+  ]),
+ ('edit', [
+   ('_Undo', '<<undo>>'),
+   ('_Redo', '<<redo>>'),
+   None,
+   ('Cu_t', '<<Cut>>'),
+   ('_Copy', '<<Copy>>'),
+   ('_Paste', '<<Paste>>'),
+   ('Select _All', '<<select-all>>'),
+  ]),
+ ('run',[
+   ('Python shell', '<<open-python-shell>>'),
+ ]),
+ ('debug', [
+   ('_Go to file/line', '<<goto-file-line>>'),
+   ('_Stack viewer', '<<open-stack-viewer>>'),
+   ('!_Debugger', '<<toggle-debugger>>'),
+   ('!_Auto-open stack viewer', '<<toggle-jit-stack-viewer>>' ),
+  ]),
+ ('help', [
+   ('_IDLE Help...', '<<help>>'),
+   ('Python _Documentation...', '<<python-docs>>'),
+   ('_Advice...', '<<good-advice>>'),
+   None,
+   ('_About IDLE...', '<<about-idle>>'),
+  ]),
+]
+
+if sys.platform == 'win32':
+    default_keydefs = windows_keydefs
+else:
+    default_keydefs = unix_keydefs
+
+del sys
diff --git a/Lib/idlelib/CallTipWindow.py b/Lib/idlelib/CallTipWindow.py
new file mode 100644
index 0000000..cbeab8c
--- /dev/null
+++ b/Lib/idlelib/CallTipWindow.py
@@ -0,0 +1,71 @@
+# A CallTip window class for Tkinter/IDLE.
+# After ToolTip.py, which uses ideas gleaned from PySol
+
+# Used by the CallTips IDLE extension.
+import os
+from Tkinter import *
+
+class CallTip:
+
+    def __init__(self, widget):
+        self.widget = widget
+        self.tipwindow = None
+        self.id = None
+        self.x = self.y = 0
+
+    def showtip(self, text):
+        self.text = text
+        if self.tipwindow or not self.text:
+            return
+        self.widget.see("insert")
+        x, y, cx, cy = self.widget.bbox("insert")
+        x = x + self.widget.winfo_rootx() + 2
+        y = y + cy + self.widget.winfo_rooty()
+        self.tipwindow = tw = Toplevel(self.widget)
+        tw.wm_overrideredirect(1)
+        tw.wm_geometry("+%d+%d" % (x, y))
+        label = Label(tw, text=self.text, justify=LEFT,
+                      background="#ffffe0", relief=SOLID, borderwidth=1,
+                      font = self.widget['font'])
+        label.pack()
+                      
+    def hidetip(self):
+        tw = self.tipwindow
+        self.tipwindow = None
+        if tw:
+            tw.destroy()
+
+
+###############################
+#
+# Test Code
+#
+class container: # Conceptually an editor_window
+    def __init__(self):
+        root = Tk()
+        text = self.text = Text(root)
+        text.pack(side=LEFT, fill=BOTH, expand=1)
+        text.insert("insert", "string.split")
+        root.update()
+        self.calltip = CallTip(text)
+
+        text.event_add("<<calltip-show>>", "(")
+        text.event_add("<<calltip-hide>>", ")")
+        text.bind("<<calltip-show>>", self.calltip_show)
+        text.bind("<<calltip-hide>>", self.calltip_hide)
+        
+        text.focus_set()
+        # root.mainloop() # not in idle
+
+    def calltip_show(self, event):
+        self.calltip.showtip("Hello world")
+
+    def calltip_hide(self, event):
+        self.calltip.hidetip()
+
+def main():
+    # Test code
+    c=container()
+
+if __name__=='__main__':
+    main()
diff --git a/Lib/idlelib/CallTips.py b/Lib/idlelib/CallTips.py
new file mode 100644
index 0000000..04eccde
--- /dev/null
+++ b/Lib/idlelib/CallTips.py
@@ -0,0 +1,190 @@
+# CallTips.py - An IDLE extension that provides "Call Tips" - ie, a floating window that
+# displays parameter information as you open parens.
+
+import string
+import sys
+import types
+
+class CallTips:
+
+    menudefs = [
+    ]
+
+    keydefs = {
+        '<<paren-open>>': ['<Key-parenleft>'],
+        '<<paren-close>>': ['<Key-parenright>'],
+        '<<check-calltip-cancel>>': ['<KeyRelease>'],
+        '<<calltip-cancel>>': ['<ButtonPress>', '<Key-Escape>'],
+    }
+
+    windows_keydefs = {
+    }
+
+    unix_keydefs = {
+    }
+
+    def __init__(self, editwin):
+        self.editwin = editwin
+        self.text = editwin.text
+        self.calltip = None
+        if hasattr(self.text, "make_calltip_window"):
+            self._make_calltip_window = self.text.make_calltip_window
+        else:
+            self._make_calltip_window = self._make_tk_calltip_window
+
+    def close(self):
+        self._make_calltip_window = None
+
+    # Makes a Tk based calltip window.  Used by IDLE, but not Pythonwin.
+    # See __init__ above for how this is used.
+    def _make_tk_calltip_window(self):
+        import CallTipWindow
+        return CallTipWindow.CallTip(self.text)
+
+    def _remove_calltip_window(self):
+        if self.calltip:
+            self.calltip.hidetip()
+            self.calltip = None
+        
+    def paren_open_event(self, event):
+        self._remove_calltip_window()
+        arg_text = get_arg_text(self.get_object_at_cursor())
+        if arg_text:
+            self.calltip_start = self.text.index("insert")
+            self.calltip = self._make_calltip_window()
+            self.calltip.showtip(arg_text)
+        return "" #so the event is handled normally.
+
+    def paren_close_event(self, event):
+        # Now just hides, but later we should check if other
+        # paren'd expressions remain open.
+        self._remove_calltip_window()
+        return "" #so the event is handled normally.
+
+    def check_calltip_cancel_event(self, event):
+        if self.calltip:
+            # If we have moved before the start of the calltip,
+            # or off the calltip line, then cancel the tip.
+            # (Later need to be smarter about multi-line, etc)
+            if self.text.compare("insert", "<=", self.calltip_start) or \
+               self.text.compare("insert", ">", self.calltip_start + " lineend"):
+                self._remove_calltip_window()
+        return "" #so the event is handled normally.
+
+    def calltip_cancel_event(self, event):
+        self._remove_calltip_window()
+        return "" #so the event is handled normally.
+
+    def get_object_at_cursor(self,
+                             wordchars="._" + string.uppercase + string.lowercase + string.digits):
+        # XXX - This needs to be moved to a better place
+        # so the "." attribute lookup code can also use it.
+        text = self.text
+        chars = text.get("insert linestart", "insert")
+        i = len(chars)
+        while i and chars[i-1] in wordchars:
+            i = i-1
+        word = chars[i:]
+        if word:
+            # How is this for a hack!
+            import sys, __main__
+            namespace = sys.modules.copy()
+            namespace.update(__main__.__dict__)
+            try:
+                    return eval(word, namespace)
+            except:
+                    pass
+        return None # Can't find an object.
+
+def _find_constructor(class_ob):
+    # Given a class object, return a function object used for the
+    # constructor (ie, __init__() ) or None if we can't find one.
+    try:
+        return class_ob.__init__.im_func
+    except AttributeError:
+        for base in class_ob.__bases__:
+            rc = _find_constructor(base)
+            if rc is not None: return rc
+    return None
+
+def get_arg_text(ob):
+    # Get a string describing the arguments for the given object.
+    argText = ""
+    if ob is not None:
+        argOffset = 0
+        if type(ob)==types.ClassType:
+            # Look for the highest __init__ in the class chain.
+            fob = _find_constructor(ob)
+            if fob is None:
+                fob = lambda: None
+            else:
+                argOffset = 1
+        elif type(ob)==types.MethodType:
+            # bit of a hack for methods - turn it into a function
+            # but we drop the "self" param.
+            fob = ob.im_func
+            argOffset = 1
+        else:
+            fob = ob
+        # Try and build one for Python defined functions
+        if type(fob) in [types.FunctionType, types.LambdaType]:
+            try:
+                realArgs = fob.func_code.co_varnames[argOffset:fob.func_code.co_argcount]
+                defaults = fob.func_defaults or []
+                defaults = list(map(lambda name: "=%s" % name, defaults))
+                defaults = [""] * (len(realArgs)-len(defaults)) + defaults
+                items = map(lambda arg, dflt: arg+dflt, realArgs, defaults)
+                if fob.func_code.co_flags & 0x4:
+                    items.append("...")
+                if fob.func_code.co_flags & 0x8:
+                    items.append("***")
+                argText = string.join(items , ", ")
+                argText = "(%s)" % argText
+            except:
+                pass
+        # See if we can use the docstring
+        if hasattr(ob, "__doc__") and ob.__doc__:
+            pos = string.find(ob.__doc__, "\n")
+            if pos<0 or pos>70: pos=70
+            if argText: argText = argText + "\n"
+            argText = argText + ob.__doc__[:pos]
+
+    return argText
+
+#################################################
+#
+# Test code
+#
+if __name__=='__main__':
+
+    def t1(): "()"
+    def t2(a, b=None): "(a, b=None)"
+    def t3(a, *args): "(a, ...)"
+    def t4(*args): "(...)"
+    def t5(a, *args): "(a, ...)"
+    def t6(a, b=None, *args, **kw): "(a, b=None, ..., ***)"
+
+    class TC:
+        "(a=None, ...)"
+        def __init__(self, a=None, *b): "(a=None, ...)"
+        def t1(self): "()"
+        def t2(self, a, b=None): "(a, b=None)"
+        def t3(self, a, *args): "(a, ...)"
+        def t4(self, *args): "(...)"
+        def t5(self, a, *args): "(a, ...)"
+        def t6(self, a, b=None, *args, **kw): "(a, b=None, ..., ***)"
+
+    def test( tests ):
+        failed=[]
+        for t in tests:
+            expected = t.__doc__ + "\n" + t.__doc__
+            if get_arg_text(t) != expected:
+                failed.append(t)
+                print "%s - expected %s, but got %s" % (t, `expected`, `get_arg_text(t)`)
+        print "%d of %d tests failed" % (len(failed), len(tests))
+
+    tc = TC()
+    tests = t1, t2, t3, t4, t5, t6, \
+            TC, tc.t1, tc.t2, tc.t3, tc.t4, tc.t5, tc.t6
+
+    test(tests)
diff --git a/Lib/idlelib/ChangeLog b/Lib/idlelib/ChangeLog
new file mode 100644
index 0000000..b853a34
--- /dev/null
+++ b/Lib/idlelib/ChangeLog
@@ -0,0 +1,1017 @@
+Tue Feb 15 18:08:19 2000  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* NEWS.txt: Notice status bar and stack viewer.
+
+	* EditorWindow.py: Support for Moshe's status bar.
+
+	* MultiStatusBar.py: Status bar code -- by Moshe Zadka.
+
+	* OldStackViewer.py:
+	Adding the old stack viewer implementation back, for the debugger.
+
+	* StackViewer.py: New stack viewer, uses a tree widget.
+	(XXX: the debugger doesn't yet use this.)
+
+	* WindowList.py:
+	Correct a typo and remove an unqualified except that was hiding the error.
+
+	* ClassBrowser.py: Add an XXX comment about the ClassBrowser AIP.
+
+	* ChangeLog: Updated change log.
+
+	* NEWS.txt: News update.  Probably incomplete; what else is new?
+
+	* README.txt:
+	Updated for pending IDLE 0.5 release (still very rough -- just getting
+	it out in a more convenient format than CVS).
+
+	* TODO.txt: Tiny addition.
+
+Thu Sep  9 14:16:02 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* TODO.txt: A few new TODO entries.
+
+Thu Aug 26 23:06:22 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* Bindings.py: Add Python Documentation entry to Help menu.
+
+	* EditorWindow.py:
+	Find the help.txt file relative to __file__ or ".", not in sys.path.
+	(Suggested by Moshe Zadka, but implemented differently.)
+
+	Add <<python-docs>> event which, on Unix, brings up Netscape pointing
+	to http://www.python.doc/current/ (a local copy would be nice but its
+	location can't be predicted).  Windows solution TBD.
+
+Wed Aug 11 14:55:43 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* TreeWidget.py:
+	Moshe noticed an inconsistency in his comment, so I'm rephrasing it to
+	be clearer.
+
+	* TreeWidget.py:
+	Patch inspired by Moshe Zadka to search for the Icons directory in the
+	same directory as __file__, rather than searching for it along sys.path.
+	This works better when idle is a package.
+
+Thu Jul 15 13:11:02 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* TODO.txt: New wishes.
+
+Sat Jul 10 13:17:35 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* IdlePrefs.py:
+	Make the color for stderr red (i.e. the standard warning/danger/stop
+	color) rather than green.  Suggested by Sam Schulenburg.
+
+Fri Jun 25 17:26:34 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* PyShell.py: Close debugger when closing.  This may break a cycle.
+
+	* Debugger.py: Break cycle on close.
+
+	* ClassBrowser.py: Destroy the tree when closing.
+
+	* TreeWidget.py: Add destroy() method to recursively destroy a tree.
+
+	* PyShell.py: Extend _close() to break cycles.
+	Break some other cycles too (and destroy the root when done).
+
+	* EditorWindow.py:
+	Add _close() method that does the actual cleanup (close() asks the
+	user what they want first if there's unsaved stuff, and may cancel).
+	It closes more than before.
+
+	Add unload_extensions() method to unload all extensions; called from
+	_close().  It calls an extension's close() method if it has one.
+
+	* Percolator.py: Add close() method that breaks cycles.
+
+	* WidgetRedirector.py: Add unregister() method.
+	Unregister everything at closing.
+	Don't call close() in __del__, rely on explicit call to close().
+
+	* IOBinding.py, FormatParagraph.py, CallTips.py:
+	Add close() method that breaks a cycle.
+
+Fri Jun 11 15:03:00 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* AutoIndent.py, EditorWindow.py, FormatParagraph.py:
+	Tim Peters smart.patch:
+
+	EditorWindow.py:
+
+	+ Added get_tabwidth & set_tabwidth "virtual text" methods, that get/set the
+	widget's view of what a tab means.
+
+	+ Moved TK_TABWIDTH_DEFAULT here from AutoIndent.
+
+	+ Renamed Mark's get_selection_index to get_selection_indices (sorry, Mark,
+	but the name was plain wrong <wink>).
+
+	FormatParagraph.py:  renamed use of get_selection_index.
+
+	AutoIndent.py:
+
+	+ Moved TK_TABWIDTH_DEFAULT to EditorWindow.
+
+	+ Rewrote set_indentation_params to use new VTW get/set_tabwidth methods.
+
+	+ Changed smart_backspace_event to delete whitespace back to closest
+	preceding virtual tab stop or real character (note that this may require
+	inserting characters if backspacing over a tab!).
+
+	+ Nuked almost references to the selection tag, in favor of using
+	get_selection_indices.  The sole exception is in set_region, for which no
+	"set_selection" abstraction has yet been agreed upon.
+
+	+ Had too much fun using the spiffy new features of the format-paragraph
+	cmd.
+
+Thu Jun 10 17:48:02 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* FormatParagraph.py:
+	Code by Mark Hammond to format paragraphs embedded in comments.
+	Read the comments (which I reformatted using the new feature :-)
+	for some limitations.
+
+	* EditorWindow.py:
+	Added abstraction get_selection_index() (Mark Hammond).  Also
+	reformatted some comment blocks to show off a cool feature I'm about
+	to check in next.
+
+	* ClassBrowser.py:
+	Adapt to the new pyclbr's support of listing top-level functions.  If
+	this functionality is not present (e.g. when used with a vintage
+	Python 1.5.2 installation) top-level functions are not listed.
+
+	(Hmm...  Any distribution of IDLE 0.5 should probably include a copy
+	of the new pyclbr.py!)
+
+	* AutoIndent.py:
+	Fix off-by-one error in Tim's recent change to comment_region(): the
+	list of lines returned by get_region() contains an empty line at the
+	end representing the start of the next line, and this shouldn't be
+	commented out!
+
+	* CallTips.py:
+	Mark Hammond writes: Here is another change that allows it to work for
+	class creation - tries to locate an __init__ function.  Also updated
+	the test code to reflect your new "***" change.
+
+	* CallTipWindow.py:
+	Mark Hammond writes: Tim's suggestion of copying the font for the
+	CallTipWindow from the text control makes sense, and actually makes
+	the control look better IMO.
+
+Wed Jun  9 20:34:57 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* CallTips.py:
+	Append "..." if the appropriate flag (for varargs) in co_flags is set.
+	Ditto "***" for kwargs.
+
+Tue Jun  8 13:06:07 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* ReplaceDialog.py:
+	Hmm...  Tim didn't turn "replace all" into a single undo block.
+	I think I like it better if it os, so here.
+
+	* ReplaceDialog.py: Tim Peters: made replacement atomic for undo/redo.
+
+	* AutoIndent.py: Tim Peters:
+
+	+ Set usetabs=1.  Editing pyclbr.py was driving me nuts <0.6 wink>.
+	usetabs=1 is the Emacs pymode default too, and thanks to indentwidth !=
+	tabwidth magical usetabs disabling, new files are still created with tabs
+	turned off.  The only implication is that if you open a file whose first
+	indent is a single tab, IDLE will now magically use tabs for that file (and
+	set indentwidth to 8).  Note that the whole scheme doesn't work right for
+	PythonWin, though, since Windows users typically set tabwidth to 4; Mark
+	probably has to hide the IDLE algorithm from them (which he already knows).
+
+	+ Changed comment_region_event to stick "##" in front of every line.  The
+	"holes" previously left on blank lines were visually confusing (made it
+	needlessly hard to figure out what to uncomment later).
+
+Mon Jun  7 15:38:40 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* TreeWidget.py, ObjectBrowser.py:
+	Remove unnecessary reference to pyclbr from test() code.
+
+	* PyParse.py: Tim Peters:
+
+	Smarter logic for finding a parse synch point.
+
+	Does a half to a fifth the work in normal cases; don't notice the speedup,
+	but makes  more breathing room for other extensions.
+
+	Speeds terrible cases by at least a factor of 10. "Terrible" == e.g. you put
+	""" at the start of Tkinter.py, undo it, zoom to the bottom, and start
+	typing in code.  Used to take about 8 seconds for ENTER to respond, now some
+	large fraction of a second.  The new code gets indented correctly, despite
+	that it all remains "string colored" until the colorizer catches up (after
+	which, ENTER appears instantaneous again).
+
+Fri Jun  4 19:21:19 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* extend.py: Might as well enable CallTips by default.
+	If there are too many complaints I'll remove it again or fix it.
+
+Thu Jun  3 14:32:16 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* AutoIndent.py, EditorWindow.py, PyParse.py:
+	New offerings by Tim Peters; he writes:
+
+	IDLE is now the first Python editor in the Universe not confused by my
+	doctest.py <wink>.
+
+	As threatened, this defines IDLE's is_char_in_string function as a
+	method of EditorWindow.  You just need to define one similarly in
+	whatever it is you pass as editwin to AutoIndent; looking at the
+	EditorWindow.py part of the patch should make this clear.
+
+	* GrepDialog.py: Enclose pattern in quotes in status message.
+
+	* CallTips.py:
+	Mark Hammond fixed some comments and improved the way the tip text is
+	constructed.
+
+Wed Jun  2 18:18:57 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* CallTips.py:
+	My fix to Mark's code: restore the universal check on <KeyRelease>.
+	Always cancel on <Key-Escape> or <ButtonPress>.
+
+	* CallTips.py:
+	A version that Mark Hammond posted to the newsgroup.  Has some newer
+	stuff for getting the tip.  Had to fix the Key-( and Key-) events
+	for Unix.  Will have to re-apply my patch for catching KeyRelease and
+	ButtonRelease events.
+
+	* CallTipWindow.py, CallTips.py:
+	Call tips by Mark Hammond (plus tiny fix by me.)
+
+	* IdleHistory.py:
+	Changes by Mark Hammond: (1) support optional output_sep argument to
+	the constructor so he can eliminate the sys.ps2 that PythonWin leaves
+	in the source; (2) remove duplicate history items.
+
+	* AutoIndent.py:
+	Changes by Mark Hammond to allow using IDLE extensions in PythonWin as
+	well: make three dialog routines instance variables.
+
+	* EditorWindow.py:
+	Change by Mark Hammond to allow using IDLE extensions in PythonWin as
+	well: make three dialog routines instance variables.
+
+Tue Jun  1 20:06:44 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* AutoIndent.py: Hah!  A fix of my own to Tim's code!
+	Unix bindings for <<toggle-tabs>> and <<change-indentwidth>> were
+	missing, and somehow that meant the events were never generated,
+	even though they were in the menu.  The new Unix bindings are now
+	the same as the Windows bindings (M-t and M-u).
+
+	* AutoIndent.py, PyParse.py, PyShell.py: Tim Peters again:
+
+	The new version (attached) is fast enough all the time in every real module
+	I have <whew!>.  You can make it slow by, e.g., creating an open list with
+	5,000 90-character identifiers (+ trailing comma) each on its own line, then
+	adding an item to the end -- but that still consumes less than a second on
+	my P5-166.  Response time in real code appears instantaneous.
+
+	Fixed some bugs.
+
+	New feature:  when hitting ENTER and the cursor is beyond the line's leading
+	indentation, whitespace is removed on both sides of the cursor; before
+	whitespace was removed only on the left; e.g., assuming the cursor is
+	between the comma and the space:
+
+	def something(arg1, arg2):
+	                   ^ cursor to the left of here, and hit ENTER
+	               arg2):   # new line used to end up here
+	              arg2):    # but now lines up the way you expect
+
+	New hack:  AutoIndent has grown a context_use_ps1 Boolean config option,
+	defaulting to 0 (false) and set to 1 (only) by PyShell.  Reason:  handling
+	the fancy stuff requires looking backward for a parsing synch point; ps1
+	lines are the only sensible thing to look for in a shell window, but are a
+	bad thing to look for in a file window (ps1 lines show up in my module
+	docstrings often).  PythonWin's shell should set this true too.
+
+	Persistent problem:  strings containing def/class can still screw things up
+	completely.  No improvement.  Simplest workaround is on the user's head, and
+	consists of inserting e.g.
+
+	def _(): pass
+
+	(or any other def/class) after the end of the multiline string that's
+	screwing them up.  This is especially irksome because IDLE's syntax coloring
+	is *not* confused, so when this happens the colors don't match the
+	indentation behavior they see.
+
+	* AutoIndent.py: Tim Peters again:
+
+	[Tim, after adding some bracket smarts to AutoIndent.py]
+	> ...
+	> What it can't possibly do without reparsing large gobs of text is
+	> suggest a reasonable indent level after you've *closed* a bracket
+	> left open on some previous line.
+	> ...
+
+	The attached can, and actually fast enough to use -- most of the time.  The
+	code is tricky beyond belief to achieve that, but it works so far; e.g.,
+
+	        return len(string.expandtabs(str[self.stmt_start :
+	                                         ^ indents to caret
+	                                         i],
+	                                     ^ indents to caret
+	                                     self.tabwidth)) + 1
+	    ^ indents to caret
+
+	It's about as smart as pymode now, wrt both bracket and backslash
+	continuation rules.  It does require reparsing large gobs of text, and if it
+	happens to find something that looks like a "def" or "class" or sys.ps1
+	buried in a multiline string, but didn't suck up enough preceding text to
+	see the start of the string, it's completely hosed.  I can't repair that --
+	it's just too slow to reparse from the start of the file all the time.
+
+	AutoIndent has grown a new num_context_lines tuple attribute that controls
+	how far to look back, and-- like other params --this could/should be made
+	user-overridable at startup and per-file on the fly.
+
+	* PyParse.py: New file by Tim Peters:
+
+	One new file in the attached, PyParse.py.  The LineStudier (whatever it was
+	called <wink>) class was removed from AutoIndent; PyParse subsumes its
+	functionality.
+
+	* AutoIndent.py: Tim Peters keeps revising this module (more to come):
+
+	Removed "New tabwidth" menu binding.
+
+	Added "a tab means how many spaces?" dialog to block tabify and untabify.  I
+	think prompting for this is good now:  they're usually at-most-once-per-file
+	commands, and IDLE can't let them change tabwidth from the Tk default
+	anymore, so IDLE can no longer presume to have any idea what a tab means.
+
+	Irony:  for the purpose of keeping comments aligned via tabs, Tk's
+	non-default approach is much nicer than the Emacs/Notepad/Codewright/vi/etc
+	approach.
+
+	* EditorWindow.py:
+	1. Catch NameError on import (could be raised by case mismatch on Windows).
+	2. No longer need to reset pyclbr cache and show watch cursor when calling
+	   ClassBrowser -- the ClassBrowser takes care of pyclbr and the TreeWidget
+	   takes care of the watch cursor.
+	3. Reset the focus to the current window after error message about class
+	   browser on buffer without filename.
+
+	* Icons/minusnode.gif, Icons/plusnode.gif: Missed a few.
+
+	* ClassBrowser.py, PathBrowser.py: Rewritten based on TreeWidget.py
+
+	* ObjectBrowser.py: Object browser, based on TreeWidget.py.
+
+	* TreeWidget.py: Tree widget done right.
+
+	* ToolTip.py: As yet unused code for tool tips.
+
+	* ScriptBinding.py:
+	Ensure sys.argv[0] is the script name on Run Script.
+
+	* ZoomHeight.py: Move zoom height functionality to separate function.
+
+	* Icons/folder.gif, Icons/openfolder.gif, Icons/python.gif, Icons/tk.gif:
+	A few icons used by ../TreeWidget.py and its callers.
+
+	* AutoIndent.py: New version by Tim Peters improves block opening test.
+
+Fri May 21 04:46:17 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* Attic/History.py, PyShell.py: Rename History to IdleHistory.
+	Add isatty() to pseudo files.
+
+	* StackViewer.py: Make initial stack viewer wider
+
+	* TODO.txt: New wishes
+
+	* AutoIndent.py, EditorWindow.py, PyShell.py:
+	Much improved autoindent and handling of tabs,
+	by Tim Peters.
+
+Mon May  3 15:49:52 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* AutoIndent.py, EditorWindow.py, FormatParagraph.py, UndoDelegator.py:
+	Tim Peters writes:
+
+	I'm still unsure, but couldn't stand the virtual event trickery so tried a
+	different sin (adding undo_block_start/stop methods to the Text instance in
+	EditorWindow.py).  Like it or not, it's efficient and works <wink>.  Better
+	idea?
+
+	Give the attached a whirl.  Even if you hate the implementation, I think
+	you'll like the results.  Think I caught all the "block edit" cmds,
+	including Format Paragraph, plus subtler ones involving smart indents and
+	backspacing.
+
+	* WidgetRedirector.py: Tim Peters writes:
+
+	[W]hile trying to dope out how redirection works, stumbled into two
+	possible glitches.  In the first, it doesn't appear to make sense to try to
+	rename a command that's already been destroyed; in the second, the name
+	"previous" doesn't really bring to mind "ignore the previous value" <wink>.
+
+Fri Apr 30 19:39:25 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* __init__.py: Support for using idle as a package.
+
+	* PathBrowser.py:
+	Avoid listing files more than once (e.g. foomodule.so has two hits:
+	once for foo + module.so, once for foomodule + .so).
+
+Mon Apr 26 22:20:38 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* ChangeLog, ColorDelegator.py, PyShell.py: Tim Peters strikes again:
+
+	Ho ho ho -- that's trickier than it sounded!  The colorizer is working with
+	"line.col" strings instead of Text marks, and the absolute coordinates of
+	the point of interest can change across the self.update call (voice of
+	baffled experience, when two quick backspaces no longer fooled it, but a
+	backspace followed by a quick ENTER did <wink>).
+
+	Anyway, the attached appears to do the trick.  CPU usage goes way up when
+	typing quickly into a long triple-quoted string, but the latency is fine for
+	me (a relatively fast typist on a relatively slow machine).  Most of the
+	changes here are left over from reducing the # of vrbl names to help me
+	reason about the logic better; I hope the code is a *little* easier to
+
+Fri Apr 23 14:01:25 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* EditorWindow.py:
+	Provide full arguments to __import__ so it works in packagized IDLE.
+
+Thu Apr 22 23:20:17 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+        * help.txt:
+        Bunch of updates necessary due to recent changes; added docs for File
+        menu, command line and color preferences.
+
+        * Bindings.py: Remove obsolete 'script' menu.
+
+	* TODO.txt: Several wishes fulfilled.
+
+	* OutputWindow.py:
+	Moved classes OnDemandOutputWindow and PseudoFile here,
+	from ScriptBinding.py where they are no longer needed.
+
+	* ScriptBinding.py:
+	Mostly rewritten.  Instead of the old Run module and Debug module,
+	there are two new commands:
+
+	Import module (F5) imports or reloads the module and also adds its
+	name to the __main__ namespace.  This gets executed in the PyShell
+	window under control of its debug settings.
+
+	Run script (Control-F5) is similar but executes the contents of the
+	file directly in the __main__ namespace.
+
+	* PyShell.py: Nits: document use of $IDLESTARTUP; display idle version
+
+	* idlever.py: New version to celebrate new command line
+
+	* OutputWindow.py: Added flush(), for completeness.
+
+	* PyShell.py:
+	A lot of changes to make the command line more useful.  You can now do:
+	  idle.py -e file ...    -- to edit files
+	  idle.py script arg ... -- to run a script
+	  idle.py -c cmd arg ... -- to run a command
+	Other options, see also the usage message (also new!) for more details:
+	  -d       -- enable debugger
+	  -s       -- run $IDLESTARTUP or $PYTHONSTARTUP
+	  -t title -- set Python Shell window's title
+	sys.argv is set accordingly, unless -e is used.
+	sys.path is absolutized, and all relevant paths are inserted into it.
+
+	Other changes:
+	- the environment in which commands are executed is now the
+	  __main__ module
+	- explicitly save sys.stdout etc., don't restore from sys.__stdout__
+	- new interpreter methods execsource(), execfile(), stuffsource()
+	- a few small nits
+
+	* TODO.txt:
+	Some more TODO items.  Made up my mind about command line args,
+	Run/Import, __main__.
+
+	* ColorDelegator.py:
+	Super-elegant patch by Tim Peters that speeds up colorization
+	dramatically (up to 15 times he claims).  Works by reading more than
+	one line at a time, up to 100-line chunks (starting with one line and
+	then doubling up to the limit).  On a typical machine (e.g. Tim's
+	P5-166) this doesn't reduce interactive responsiveness in a noticeable
+	way.
+
+Wed Apr 21 15:49:34 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* ColorDelegator.py:
+	Patch by Tim Peters to speed up colorizing of big multiline strings.
+
+Tue Apr 20 17:32:52 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* extend.txt:
+	For an event 'foo-bar', the corresponding method must be called
+	foo_bar_event().  Therefore, fix the references to zoom_height() in
+	the example.
+
+	* IdlePrefs.py: Restored the original IDLE color scheme.
+
+	* PyShell.py, IdlePrefs.py, ColorDelegator.py, EditorWindow.py:
+	Color preferences code by Loren Luke (massaged by me somewhat)
+
+	* SearchEngine.py:
+	Patch by Mark Favas: it fixes the search engine behaviour where an
+	unsuccessful search wraps around and re-searches that part of the file
+	between the start of the search and the end of the file - only really
+	an issue for very large files, but... (also removes a redundant
+	m.span() call).
+
+Mon Apr 19 16:26:02 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* TODO.txt: A few wishes are now fulfilled.
+
+	* AutoIndent.py: Tim Peters implements some of my wishes:
+
+	o Makes the tab key intelligently insert spaces when appropriate
+	(see Help list banter twixt David Ascher and me; idea stolen from
+	every other editor on earth <wink>).
+
+	o newline_and_indent_event trims trailing whitespace on the old
+	line (pymode and Codewright).
+
+	o newline_and_indent_event no longer fooled by trailing whitespace or
+	comment after ":" (pymode, PTUI).
+
+	o newline_and_indent_event now reduces the new line's indentation after
+	return, break, continue, raise and pass stmts (pymode).
+
+	The last two are easy to fool in the presence of strings &
+	continuations, but pymode requires Emacs's high-powered C parsing
+	functions to avoid that in finite time.
+
+======================================================================
+	Python release 1.5.2c1, IDLE version 0.4
+======================================================================
+
+Wed Apr  7 18:41:59 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* README.txt, NEWS.txt: New version.
+
+	* idlever.py: Version bump awaiting impending new release.
+	(Not much has changed :-( )
+
+Mon Mar 29 14:52:28 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* ScriptBinding.py, PyShell.py:
+	At Tim Peters' recommendation, add a dummy flush() method to
+	PseudoFile.
+
+Thu Mar 11 23:21:23 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* PathBrowser.py: Don't crash when sys.path contains an empty string.
+
+	* Attic/Outline.py: This file was never supposed to be part of IDLE.
+
+	* PathBrowser.py:
+	- Don't crash in the case where a superclass is a string instead of a
+	pyclbr.Class object; this can happen when the superclass is
+	unrecognizable (to pyclbr), e.g. when module renaming is used.
+
+	- Show a watch cursor when calling pyclbr (since it may take a while
+	recursively parsing imported modules!).
+
+Wed Mar 10 05:18:02 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* EditorWindow.py, Bindings.py: Add PathBrowser to File module
+
+	* PathBrowser.py: "Path browser" - 4 scrolled lists displaying:
+	    directories on sys.path
+	    modules in selected directory
+	    classes in selected module
+	    methods of selected class
+
+	Sinlge clicking in a directory, module or class item updates the next
+	column with info about the selected item.  Double clicking in a
+	module, class or method item opens the file (and selects the clicked
+	item if it is a class or method).
+
+	I guess eventually I should be using a tree widget for this, but the
+	ones I've seen don't work well enough, so for now I use the old
+	Smalltalk or NeXT style multi-column hierarchical browser.
+
+	* MultiScrolledLists.py:
+	New utility: multiple scrolled lists in parallel
+
+	* ScrolledList.py: - White background.
+	- Display "(None)" (or text of your choosing) when empty.
+	- Don't set the focus.
+
+======================================================================
+	Python release 1.5.2b2, IDLE version 0.3
+======================================================================
+	
+Wed Feb 17 22:47:41 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* NEWS.txt: News in 0.3.
+
+	* README.txt, idlever.py: Bump version to 0.3.
+
+	* EditorWindow.py:
+	After all, we don't need to call the callbacks ourselves!
+
+	* WindowList.py:
+	When deleting, call the callbacks *after* deleting the window from our list!
+
+	* EditorWindow.py:
+	Fix up the Windows menu via the new callback mechanism instead of
+	depending on menu post commands (which don't work when the menu is
+	torn off).
+
+	* WindowList.py:
+	Support callbacks to patch up Windows menus everywhere.
+
+	* ChangeLog: Oh, why not.  Checking in the Emacs-generated change log.
+
+Tue Feb 16 22:34:17 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* ScriptBinding.py:
+	Only pop up the stack viewer when requested in the Debug menu.
+
+Mon Feb  8 22:27:49 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* WindowList.py: Don't crash if a window no longer exists.
+
+	* TODO.txt: Restructured a bit.
+
+Mon Feb  1 23:06:17 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* PyShell.py: Add current dir or paths of file args to sys.path.
+
+	* Debugger.py: Add canonic() function -- for brand new bdb.py feature.
+
+	* StackViewer.py: Protect against accessing an empty stack.
+
+Fri Jan 29 20:44:45 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* ZoomHeight.py:
+	Use only the height to decide whether to zoom in or out.
+
+Thu Jan 28 22:24:30 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* EditorWindow.py, FileList.py:
+	Make sure the Tcl variables are shared between windows.
+
+	* PyShell.py, EditorWindow.py, Bindings.py:
+	Move menu/key binding code from Bindings.py to EditorWindow.py,
+	with changed APIs -- it makes much more sense there.
+	Also add a new feature: if the first character of a menu label is
+	a '!', it gets a checkbox.  Checkboxes are bound to Boolean Tcl variables
+	that can be accessed through the new getvar/setvar/getrawvar API;
+	the variable is named after the event to which the menu is bound.
+
+	* Debugger.py: Add Quit button to the debugger window.
+
+	* SearchDialog.py:
+	When find_again() finds exactly the current selection, it's a failure.
+
+	* idle.py, Attic/idle: Rename idle -> idle.py
+
+Mon Jan 18 15:18:57 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* EditorWindow.py, WindowList.py: Only deiconify when iconic.
+
+	* TODO.txt: Misc
+
+Tue Jan 12 22:14:34 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* testcode.py, Attic/test.py:
+	Renamed test.py to testcode.py so one can import Python's
+	test package from inside IDLE.  (Suggested by Jack Jansen.)
+
+	* EditorWindow.py, ColorDelegator.py:
+	Hack to close a window that is colorizing.
+
+	* Separator.py: Vladimir Marangozov's patch:
+	The separator dances too much and seems to jump by arbitrary amounts
+	in arbitrary directions when I try to move it for resizing the frames.
+	This patch makes it more quiet.
+
+Mon Jan 11 14:52:40 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* TODO.txt: Some requests have been fulfilled.
+
+	* EditorWindow.py:
+	Set the cursor to a watch when opening the class browser (which may
+	take quite a while, browsing multiple files).
+
+	Newer, better center() -- but assumes no wrapping.
+
+	* SearchBinding.py:
+	Got rid of debug print statement in goto_line_event().
+
+	* ScriptBinding.py:
+	I think I like it better if it prints the traceback even when it displays
+	the stack viewer.
+
+	* Debugger.py: Bind ESC to close-window.
+
+	* ClassBrowser.py: Use a HSeparator between the classes and the items.
+	Make the list of classes wider by default (40 chars).
+	Bind ESC to close-window.
+
+	* Separator.py:
+	Separator classes (draggable divider between two panes).
+
+Sat Jan  9 22:01:33 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* WindowList.py:
+	Don't traceback when wakeup() is called when the window has been destroyed.
+	This can happen when a torn-of Windows menu references closed windows.
+	And Tim Peters claims that the Windows menu is his favorite to tear off...
+
+	* EditorWindow.py: Allow tearing off of the Windows menu.
+
+	* StackViewer.py: Close on ESC.
+
+	* help.txt: Updated a bunch of things (it was mostly still 0.1!)
+
+	* extend.py: Added ScriptBinding to standard bindings.
+
+	* ScriptBinding.py:
+	This now actually works.  See doc string.  It can run a module (i.e.
+	import or reload) or debug it (same with debugger control).  Output
+	goes to a fresh output window, only created when needed.
+
+======================================================================
+	Python release 1.5.2b1, IDLE version 0.2
+======================================================================
+	
+Fri Jan  8 17:26:02 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* README.txt, NEWS.txt: What's new in this release.
+
+	* Bindings.py, PyShell.py:
+	Paul Prescod's patches to allow the stack viewer to pop up when a
+	traceback is printed.
+
+Thu Jan  7 00:12:15 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* FormatParagraph.py:
+	Change paragraph width limit to 70 (like Emacs M-Q).
+
+	* README.txt:
+	Separating TODO from README.  Slight reformulation of features.  No
+	exact release date.
+
+	* TODO.txt: Separating TODO from README.
+
+Mon Jan  4 21:19:09 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* FormatParagraph.py:
+	Hm.  There was a boundary condition error at the end of the file too.
+
+	* SearchBinding.py: Hm.  Add Unix binding for replace, too.
+
+	* keydefs.py: Ran eventparse.py again.
+
+	* FormatParagraph.py: Added Unix Meta-q key binding;
+	fix find_paragraph when at start of file.
+
+	* AutoExpand.py: Added Meta-/ binding for Unix as alt for Alt-/.
+
+	* SearchBinding.py:
+	Add unix binding for grep (otherwise the menu entry doesn't work!)
+
+	* ZoomHeight.py: Adjusted Unix height to work with fvwm96. :=(
+
+	* GrepDialog.py: Need to import sys!
+
+	* help.txt, extend.txt, README.txt: Formatted some paragraphs
+
+	* extend.py, FormatParagraph.py:
+	Add new extension to reformat a (text) paragraph.
+
+	* ZoomHeight.py: Typo in Win specific height setting.
+
+Sun Jan  3 00:47:35 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* AutoIndent.py: Added something like Tim Peters' backspace patch.
+
+	* ZoomHeight.py: Adapted to Unix (i.e., more hardcoded constants).
+
+Sat Jan  2 21:28:54 1999  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* keydefs.py, idlever.py, idle.pyw, idle.bat, help.txt, extend.txt, extend.py, eventparse.py, ZoomHeight.py, WindowList.py, UndoDelegator.py, StackViewer.py, SearchEngine.py, SearchDialogBase.py, SearchDialog.py, ScrolledList.py, SearchBinding.py, ScriptBinding.py, ReplaceDialog.py, Attic/README, README.txt, PyShell.py, Attic/PopupMenu.py, OutputWindow.py, IOBinding.py, Attic/HelpWindow.py, History.py, GrepDialog.py, FileList.py, FrameViewer.py, EditorWindow.py, Debugger.py, Delegator.py, ColorDelegator.py, Bindings.py, ClassBrowser.py, AutoExpand.py, AutoIndent.py:
+	Checking in IDLE 0.2.
+
+	Much has changed -- too much, in fact, to write down.
+	The big news is that there's a standard way to write IDLE extensions;
+	see extend.txt.  Some sample extensions have been provided, and
+	some existing code has been converted to extensions.  Probably the
+	biggest new user feature is a new search dialog with more options,
+	search and replace, and even search in files (grep).
+
+	This is exactly as downloaded from my laptop after returning
+	from the holidays -- it hasn't even been tested on Unix yet.
+
+Fri Dec 18 15:52:54 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* FileList.py, ClassBrowser.py:
+	Fix the class browser to work even when the file is not on sys.path.
+
+Tue Dec  8 20:39:36 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* Attic/turtle.py: Moved to Python 1.5.2/Lib
+
+Fri Nov 27 03:19:20 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* help.txt: Typo
+
+	* EditorWindow.py, FileList.py: Support underlining of menu labels
+
+	* Bindings.py:
+	New approach, separate tables for menus (platform-independent) and key
+	definitions (platform-specific), and generating accelerator strings
+	automatically from the key definitions.
+
+Mon Nov 16 18:37:42 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* Attic/README: Clarify portability and main program.
+
+	* Attic/README: Added intro for 0.1 release and append Grail notes.
+
+Mon Oct 26 18:49:00 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* Attic/turtle.py: root is now a global called _root
+
+Sat Oct 24 16:38:38 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* Attic/turtle.py: Raise the root window on reset().
+	Different action on WM_DELETE_WINDOW is more likely to do the right thing,
+	allowing us to destroy old windows.
+
+	* Attic/turtle.py:
+	Split the goto() function in two: _goto() is the internal one,
+	using Canvas coordinates, and goto() uses turtle coordinates
+	and accepts variable argument lists.
+
+	* Attic/turtle.py: Cope with destruction of the window
+
+	* Attic/turtle.py: Turtle graphics
+
+	* Debugger.py: Use of Breakpoint class should be bdb.Breakpoint.
+
+Mon Oct 19 03:33:40 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* SearchBinding.py:
+	Speed up the search a bit -- don't drag a mark around...
+
+	* PyShell.py:
+	Change our special entries from <console#N> to <pyshell#N>.
+	Patch linecache.checkcache() to keep our special entries alive.
+	Add popup menu to all editor windows to set a breakpoint.
+
+	* Debugger.py:
+	Use and pass through the 'force' flag to set_dict() where appropriate.
+	Default source and globals checkboxes to false.
+	Don't interact in user_return().
+	Add primitive set_breakpoint() method.
+
+	* ColorDelegator.py:
+	Raise priority of 'sel' tag so its foreground (on Windows) will take
+	priority over text colorization (which on Windows is almost the
+	same color as the selection background).
+
+	Define a tag and color for breakpoints ("BREAK").
+
+	* Attic/PopupMenu.py: Disable "Open stack viewer" and "help" commands.
+
+	* StackViewer.py:
+	Add optional 'force' argument (default 0) to load_dict().
+	If set, redo the display even if it's the same dict.
+
+Fri Oct 16 21:10:12 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* StackViewer.py: Do nothing when loading the same dict as before.
+
+	* PyShell.py: Details for debugger interface.
+
+	* Debugger.py:
+	Restructured and more consistent.  Save checkboxes across instantiations.
+
+	* EditorWindow.py, Attic/README, Bindings.py:
+	Get rid of conflicting ^X binding.  Use ^W.
+
+	* Debugger.py, StackViewer.py:
+	Debugger can now show local and global variables.
+
+	* Debugger.py: Oops
+
+	* Debugger.py, PyShell.py: Better debugger support (show stack etc).
+
+	* Attic/PopupMenu.py: Follow renames in StackViewer module
+
+	* StackViewer.py:
+	Rename classes to StackViewer (the widget) and StackBrowser (the toplevel).
+
+	* ScrolledList.py: Add close() method
+
+	* EditorWindow.py: Clarify 'Open Module' dialog text
+
+	* StackViewer.py: Restructured into a browser and a widget.
+
+Thu Oct 15 23:27:08 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* ClassBrowser.py, ScrolledList.py:
+	Generalized the scrolled list which is the base for the class and
+	method browser into a separate class in its own module.
+
+	* Attic/test.py: Cosmetic change
+
+	* Debugger.py: Don't show function name if there is none
+
+Wed Oct 14 03:43:05 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* Debugger.py, PyShell.py: Polish the Debugger GUI a bit.
+	Closing it now also does the right thing.
+
+Tue Oct 13 23:51:13 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* Debugger.py, PyShell.py, Bindings.py:
+	Ad primitive debugger interface (so far it will step and show you the
+	source, but it doesn't yet show the stack).
+
+	* Attic/README: Misc
+
+	* StackViewer.py: Whoops -- referenced self.top before it was set.
+
+	* help.txt: Added history and completion commands.
+
+	* help.txt: Updated
+
+	* FileList.py: Add class browser functionality.
+
+	* StackViewer.py:
+	Add a close() method and bind to WM_DELETE_WINDOW protocol
+
+	* PyShell.py: Clear the linecache before printing a traceback
+
+	* Bindings.py: Added class browser binding.
+
+	* ClassBrowser.py: Much improved, much left to do.
+
+	* PyShell.py: Make the return key do what I mean more often.
+
+	* ClassBrowser.py:
+	Adding the beginnings of a Class browser.  Incomplete, yet.
+
+	* EditorWindow.py, Bindings.py:
+	Add new command, "Open module".  You select or type a module name,
+	and it opens the source.
+
+Mon Oct 12 23:59:27 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* PyShell.py: Subsume functionality from Popup menu in Debug menu.
+	Other stuff so the PyShell window can be resurrected from the Windows menu.
+
+	* FileList.py: Get rid of PopUp menu.
+	Create a simple Windows menu.  (Imperfect when Untitled windows exist.)
+	Add wakeup() method: deiconify, raise, focus.
+
+	* EditorWindow.py: Generalize menu creation.
+
+	* Bindings.py: Add Debug and Help menu items.
+
+	* EditorWindow.py: Added a menu bar to every window.
+
+	* Bindings.py: Add menu configuration to the event configuration.
+
+	* Attic/PopupMenu.py: Pass a root to the help window.
+
+	* SearchBinding.py:
+	Add parent argument to 'to to line number' dialog box.
+
+Sat Oct 10 19:15:32 1998  Guido van Rossum  <guido@cnri.reston.va.us>
+
+	* StackViewer.py:
+	Add a label at the top showing (very basic) help for the stack viewer.
+	Add a label at the bottom showing the exception info.
+
+	* Attic/test.py, Attic/idle: Add Unix main script and test program.
+
+	* idle.pyw, help.txt, WidgetRedirector.py, UndoDelegator.py, StackViewer.py, SearchBinding.py, Attic/README, PyShell.py, Attic/PopupMenu.py, Percolator.py, Outline.py, IOBinding.py, History.py, Attic/HelpWindow.py, FrameViewer.py, FileList.py, EditorWindow.py, Delegator.py, ColorDelegator.py, Bindings.py, AutoIndent.py, AutoExpand.py:
+	Initial checking of Tk-based Python IDE.
+	Features: text editor with syntax coloring and undo;
+	subclassed into interactive Python shell which adds history.
+
diff --git a/Lib/idlelib/ClassBrowser.py b/Lib/idlelib/ClassBrowser.py
new file mode 100644
index 0000000..f440164
--- /dev/null
+++ b/Lib/idlelib/ClassBrowser.py
@@ -0,0 +1,224 @@
+"""Class browser.
+
+XXX TO DO:
+
+- reparse when source changed (maybe just a button would be OK?)
+    (or recheck on window popup)
+- add popup menu with more options (e.g. doc strings, base classes, imports)
+- show function argument list? (have to do pattern matching on source)
+- should the classes and methods lists also be in the module's menu bar?
+- add base classes to class browser tree
+"""
+
+import os
+import sys
+import string
+import pyclbr
+
+# XXX Patch pyclbr with dummies if it's vintage Python 1.5.2:
+if not hasattr(pyclbr, "readmodule_ex"):
+    pyclbr.readmodule_ex = pyclbr.readmodule
+if not hasattr(pyclbr, "Function"):
+    class Function(pyclbr.Class):
+        pass
+    pyclbr.Function = Function
+
+import PyShell
+from WindowList import ListedToplevel
+from TreeWidget import TreeNode, TreeItem, ScrolledCanvas
+
+class ClassBrowser:
+
+    def __init__(self, flist, name, path):
+        # XXX This API should change, if the file doesn't end in ".py"
+        # XXX the code here is bogus!
+        self.name = name
+        self.file = os.path.join(path[0], self.name + ".py")
+        self.init(flist)
+
+    def close(self, event=None):
+        self.top.destroy()
+        self.node.destroy()
+
+    def init(self, flist):
+        self.flist = flist
+        # reset pyclbr
+        pyclbr._modules.clear()
+        # create top
+        self.top = top = ListedToplevel(flist.root)
+        top.protocol("WM_DELETE_WINDOW", self.close)
+        top.bind("<Escape>", self.close)
+        self.settitle()
+        top.focus_set()
+        # create scrolled canvas
+        sc = ScrolledCanvas(top, bg="white", highlightthickness=0, takefocus=1)
+        sc.frame.pack(expand=1, fill="both")
+        item = self.rootnode()
+        self.node = node = TreeNode(sc.canvas, None, item)
+        node.update()
+        node.expand()
+
+    def settitle(self):
+        self.top.wm_title("Class Browser - " + self.name)
+        self.top.wm_iconname("Class Browser")
+
+    def rootnode(self):
+        return ModuleBrowserTreeItem(self.file)
+
+class ModuleBrowserTreeItem(TreeItem):
+
+    def __init__(self, file):
+        self.file = file
+
+    def GetText(self):
+        return os.path.basename(self.file)
+
+    def GetIconName(self):
+        return "python"
+
+    def GetSubList(self):
+        sublist = []
+        for name in self.listclasses():
+            item = ClassBrowserTreeItem(name, self.classes, self.file)
+            sublist.append(item)
+        return sublist
+
+    def OnDoubleClick(self):
+        if os.path.normcase(self.file[-3:]) != ".py":
+            return
+        if not os.path.exists(self.file):
+            return
+        PyShell.flist.open(self.file)
+
+    def IsExpandable(self):
+        return os.path.normcase(self.file[-3:]) == ".py"
+    
+    def listclasses(self):
+        dir, file = os.path.split(self.file)
+        name, ext = os.path.splitext(file)
+        if os.path.normcase(ext) != ".py":
+            return []
+        try:
+            dict = pyclbr.readmodule_ex(name, [dir] + sys.path)
+        except ImportError, msg:
+            return []
+        items = []
+        self.classes = {}
+        for key, cl in dict.items():
+            if cl.module == name:
+                s = key
+                if cl.super:
+                    supers = []
+                    for sup in cl.super:
+                        if type(sup) is type(''):
+                            sname = sup
+                        else:
+                            sname = sup.name
+                            if sup.module != cl.module:
+                                sname = "%s.%s" % (sup.module, sname)
+                        supers.append(sname)
+                    s = s + "(%s)" % string.join(supers, ", ")
+                items.append((cl.lineno, s))
+                self.classes[s] = cl
+        items.sort()
+        list = []
+        for item, s in items:
+            list.append(s)
+        return list
+
+class ClassBrowserTreeItem(TreeItem):
+
+    def __init__(self, name, classes, file):
+        self.name = name
+        self.classes = classes
+        self.file = file
+        try:
+            self.cl = self.classes[self.name]
+        except (IndexError, KeyError):
+            self.cl = None
+        self.isfunction = isinstance(self.cl, pyclbr.Function)
+
+    def GetText(self):
+        if self.isfunction:
+            return "def " + self.name + "(...)"
+        else:
+            return "class " + self.name
+
+    def GetIconName(self):
+        if self.isfunction:
+            return "python"
+        else:
+            return "folder"
+
+    def IsExpandable(self):
+        if self.cl:
+            return not not self.cl.methods
+
+    def GetSubList(self):
+        if not self.cl:
+            return []
+        sublist = []
+        for name in self.listmethods():
+            item = MethodBrowserTreeItem(name, self.cl, self.file)
+            sublist.append(item)
+        return sublist
+
+    def OnDoubleClick(self):
+        if not os.path.exists(self.file):
+            return
+        edit = PyShell.flist.open(self.file)
+        if hasattr(self.cl, 'lineno'):
+            lineno = self.cl.lineno
+            edit.gotoline(lineno)
+
+    def listmethods(self):
+        if not self.cl:
+            return []
+        items = []
+        for name, lineno in self.cl.methods.items():
+            items.append((lineno, name))
+        items.sort()
+        list = []
+        for item, name in items:
+            list.append(name)
+        return list
+
+class MethodBrowserTreeItem(TreeItem):
+
+    def __init__(self, name, cl, file):
+        self.name = name
+        self.cl = cl
+        self.file = file
+
+    def GetText(self):
+        return "def " + self.name + "(...)"
+
+    def GetIconName(self):
+        return "python" # XXX
+
+    def IsExpandable(self):
+        return 0
+
+    def OnDoubleClick(self):
+        if not os.path.exists(self.file):
+            return
+        edit = PyShell.flist.open(self.file)
+        edit.gotoline(self.cl.methods[self.name])
+
+def main():
+    try:
+        file = __file__
+    except NameError:
+        file = sys.argv[0]
+        if sys.argv[1:]:
+            file = sys.argv[1]
+        else:
+            file = sys.argv[0]
+    dir, file = os.path.split(file)
+    name = os.path.splitext(file)[0]
+    ClassBrowser(PyShell.flist, name, [dir])
+    if sys.stdin is sys.__stdin__:
+        mainloop()
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/idlelib/ColorDelegator.py b/Lib/idlelib/ColorDelegator.py
new file mode 100644
index 0000000..77edfe8
--- /dev/null
+++ b/Lib/idlelib/ColorDelegator.py
@@ -0,0 +1,234 @@
+import time
+import string
+import re
+import keyword
+from Tkinter import *
+from Delegator import Delegator
+from IdleConf import idleconf
+
+#$ event <<toggle-auto-coloring>>
+#$ win <Control-slash>
+#$ unix <Control-slash>
+
+__debug__ = 0
+
+
+def any(name, list):
+    return "(?P<%s>" % name + string.join(list, "|") + ")"
+
+def make_pat():
+    kw = r"\b" + any("KEYWORD", keyword.kwlist) + r"\b"
+    comment = any("COMMENT", [r"#[^\n]*"])
+    sqstring = r"(\b[rR])?'[^'\\\n]*(\\.[^'\\\n]*)*'?"
+    dqstring = r'(\b[rR])?"[^"\\\n]*(\\.[^"\\\n]*)*"?'
+    sq3string = r"(\b[rR])?'''[^'\\]*((\\.|'(?!''))[^'\\]*)*(''')?"
+    dq3string = r'(\b[rR])?"""[^"\\]*((\\.|"(?!""))[^"\\]*)*(""")?'
+    string = any("STRING", [sq3string, dq3string, sqstring, dqstring])
+    return kw + "|" + comment + "|" + string + "|" + any("SYNC", [r"\n"])
+
+prog = re.compile(make_pat(), re.S)
+idprog = re.compile(r"\s+(\w+)", re.S)
+
+class ColorDelegator(Delegator):
+
+    def __init__(self):
+        Delegator.__init__(self)
+        self.prog = prog
+        self.idprog = idprog
+
+    def setdelegate(self, delegate):
+        if self.delegate is not None:
+            self.unbind("<<toggle-auto-coloring>>")
+        Delegator.setdelegate(self, delegate)
+        if delegate is not None:
+            self.config_colors()
+            self.bind("<<toggle-auto-coloring>>", self.toggle_colorize_event)
+            self.notify_range("1.0", "end")
+
+    def config_colors(self):
+        for tag, cnf in self.tagdefs.items():
+            if cnf:
+                apply(self.tag_configure, (tag,), cnf)
+        self.tag_raise('sel')
+
+    cconf = idleconf.getsection('Colors')
+
+    tagdefs = {
+        "COMMENT": cconf.getcolor("comment"),
+        "KEYWORD": cconf.getcolor("keyword"),
+        "STRING": cconf.getcolor("string"),
+        "DEFINITION": cconf.getcolor("definition"),
+        "SYNC": cconf.getcolor("sync"),
+        "TODO": cconf.getcolor("todo"),
+        "BREAK": cconf.getcolor("break"),
+        # The following is used by ReplaceDialog:
+        "hit": cconf.getcolor("hit"),
+        }
+
+    def insert(self, index, chars, tags=None):
+        index = self.index(index)
+        self.delegate.insert(index, chars, tags)
+        self.notify_range(index, index + "+%dc" % len(chars))
+
+    def delete(self, index1, index2=None):
+        index1 = self.index(index1)
+        self.delegate.delete(index1, index2)
+        self.notify_range(index1)
+
+    after_id = None
+    allow_colorizing = 1
+    colorizing = 0
+
+    def notify_range(self, index1, index2=None):
+        self.tag_add("TODO", index1, index2)
+        if self.after_id:
+            if __debug__: print "colorizing already scheduled"
+            return
+        if self.colorizing:
+            self.stop_colorizing = 1
+            if __debug__: print "stop colorizing"
+        if self.allow_colorizing:
+            if __debug__: print "schedule colorizing"
+            self.after_id = self.after(1, self.recolorize)
+
+    close_when_done = None # Window to be closed when done colorizing
+
+    def close(self, close_when_done=None):
+        if self.after_id:
+            after_id = self.after_id
+            self.after_id = None
+            if __debug__: print "cancel scheduled recolorizer"
+            self.after_cancel(after_id)
+        self.allow_colorizing = 0
+        self.stop_colorizing = 1
+        if close_when_done:
+            if not self.colorizing:
+                close_when_done.destroy()
+            else:
+                self.close_when_done = close_when_done
+
+    def toggle_colorize_event(self, event):
+        if self.after_id:
+            after_id = self.after_id
+            self.after_id = None
+            if __debug__: print "cancel scheduled recolorizer"
+            self.after_cancel(after_id)
+        if self.allow_colorizing and self.colorizing:
+            if __debug__: print "stop colorizing"
+            self.stop_colorizing = 1
+        self.allow_colorizing = not self.allow_colorizing
+        if self.allow_colorizing and not self.colorizing:
+            self.after_id = self.after(1, self.recolorize)
+        if __debug__:
+            print "auto colorizing turned", self.allow_colorizing and "on" or "off"
+        return "break"
+
+    def recolorize(self):
+        self.after_id = None
+        if not self.delegate:
+            if __debug__: print "no delegate"
+            return
+        if not self.allow_colorizing:
+            if __debug__: print "auto colorizing is off"
+            return
+        if self.colorizing:
+            if __debug__: print "already colorizing"
+            return
+        try:
+            self.stop_colorizing = 0
+            self.colorizing = 1
+            if __debug__: print "colorizing..."
+            t0 = time.clock()
+            self.recolorize_main()
+            t1 = time.clock()
+            if __debug__: print "%.3f seconds" % (t1-t0)
+        finally:
+            self.colorizing = 0
+        if self.allow_colorizing and self.tag_nextrange("TODO", "1.0"):
+            if __debug__: print "reschedule colorizing"
+            self.after_id = self.after(1, self.recolorize)
+        if self.close_when_done:
+            top = self.close_when_done
+            self.close_when_done = None
+            top.destroy()
+
+    def recolorize_main(self):
+        next = "1.0"
+        while 1:
+            item = self.tag_nextrange("TODO", next)
+            if not item:
+                break
+            head, tail = item
+            self.tag_remove("SYNC", head, tail)
+            item = self.tag_prevrange("SYNC", head)
+            if item:
+                head = item[1]
+            else:
+                head = "1.0"
+
+            chars = ""
+            next = head
+            lines_to_get = 1
+            ok = 0
+            while not ok:
+                mark = next
+                next = self.index(mark + "+%d lines linestart" %
+                                         lines_to_get)
+                lines_to_get = min(lines_to_get * 2, 100)
+                ok = "SYNC" in self.tag_names(next + "-1c")
+                line = self.get(mark, next)
+                ##print head, "get", mark, next, "->", `line`
+                if not line:
+                    return
+                for tag in self.tagdefs.keys():
+                    self.tag_remove(tag, mark, next)
+                chars = chars + line
+                m = self.prog.search(chars)
+                while m:
+                    for key, value in m.groupdict().items():
+                        if value:
+                            a, b = m.span(key)
+                            self.tag_add(key,
+                                         head + "+%dc" % a,
+                                         head + "+%dc" % b)
+                            if value in ("def", "class"):
+                                m1 = self.idprog.match(chars, b)
+                                if m1:
+                                    a, b = m1.span(1)
+                                    self.tag_add("DEFINITION",
+                                                 head + "+%dc" % a,
+                                                 head + "+%dc" % b)
+                    m = self.prog.search(chars, m.end())
+                if "SYNC" in self.tag_names(next + "-1c"):
+                    head = next
+                    chars = ""
+                else:
+                    ok = 0
+                if not ok:
+                    # We're in an inconsistent state, and the call to
+                    # update may tell us to stop.  It may also change
+                    # the correct value for "next" (since this is a
+                    # line.col string, not a true mark).  So leave a
+                    # crumb telling the next invocation to resume here
+                    # in case update tells us to leave.
+                    self.tag_add("TODO", next)
+                self.update()
+                if self.stop_colorizing:
+                    if __debug__: print "colorizing stopped"
+                    return
+
+
+def main():
+    from Percolator import Percolator
+    root = Tk()
+    root.wm_protocol("WM_DELETE_WINDOW", root.quit)
+    text = Text(background="white")
+    text.pack(expand=1, fill="both")
+    text.focus_set()
+    p = Percolator(text)
+    d = ColorDelegator()
+    p.insertfilter(d)
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/idlelib/ConfigParser.py b/Lib/idlelib/ConfigParser.py
new file mode 100644
index 0000000..e1ce9dd
--- /dev/null
+++ b/Lib/idlelib/ConfigParser.py
@@ -0,0 +1,382 @@
+"""Configuration file parser.
+
+A setup file consists of sections, lead by a "[section]" header,
+and followed by "name: value" entries, with continuations and such in
+the style of RFC 822.
+
+The option values can contain format strings which refer to other values in
+the same section, or values in a special [DEFAULT] section.
+
+For example:
+
+    something: %(dir)s/whatever
+
+would resolve the "%(dir)s" to the value of dir.  All reference
+expansions are done late, on demand.
+
+Intrinsic defaults can be specified by passing them into the
+ConfigParser constructor as a dictionary.
+
+class:
+
+ConfigParser -- responsible for for parsing a list of
+                configuration files, and managing the parsed database.
+
+    methods:
+
+    __init__(defaults=None)
+        create the parser and specify a dictionary of intrinsic defaults.  The
+        keys must be strings, the values must be appropriate for %()s string
+        interpolation.  Note that `__name__' is always an intrinsic default;
+        it's value is the section's name.
+
+    sections()
+        return all the configuration section names, sans DEFAULT
+
+    has_section(section)
+        return whether the given section exists
+
+    options(section)
+        return list of configuration options for the named section
+
+    has_option(section, option)
+        return whether the given section has the given option
+
+    read(filenames)
+        read and parse the list of named configuration files, given by
+        name.  A single filename is also allowed.  Non-existing files
+        are ignored.
+
+    readfp(fp, filename=None)
+        read and parse one configuration file, given as a file object.
+        The filename defaults to fp.name; it is only used in error
+        messages (if fp has no `name' attribute, the string `<???>' is used).
+
+    get(section, option, raw=0, vars=None)
+        return a string value for the named option.  All % interpolations are
+        expanded in the return values, based on the defaults passed into the
+        constructor and the DEFAULT section.  Additional substitutions may be
+        provided using the `vars' argument, which must be a dictionary whose
+        contents override any pre-existing defaults.
+
+    getint(section, options)
+        like get(), but convert value to an integer
+
+    getfloat(section, options)
+        like get(), but convert value to a float
+
+    getboolean(section, options)
+        like get(), but convert value to a boolean (currently defined as 0 or
+        1, only)
+"""
+
+import sys
+import string
+import re
+
+DEFAULTSECT = "DEFAULT"
+
+
+
+# exception classes
+class Error:
+    def __init__(self, msg=''):
+        self._msg = msg
+    def __repr__(self):
+        return self._msg
+
+class NoSectionError(Error):
+    def __init__(self, section):
+        Error.__init__(self, 'No section: %s' % section)
+        self.section = section
+
+class DuplicateSectionError(Error):
+    def __init__(self, section):
+        Error.__init__(self, "Section %s already exists" % section)
+        self.section = section
+
+class NoOptionError(Error):
+    def __init__(self, option, section):
+        Error.__init__(self, "No option `%s' in section: %s" %
+                       (option, section))
+        self.option = option
+        self.section = section
+
+class InterpolationError(Error):
+    def __init__(self, reference, option, section, rawval):
+        Error.__init__(self,
+                       "Bad value substitution:\n"
+                       "\tsection: [%s]\n"
+                       "\toption : %s\n"
+                       "\tkey    : %s\n"
+                       "\trawval : %s\n"
+                       % (section, option, reference, rawval))
+        self.reference = reference
+        self.option = option
+        self.section = section
+
+class MissingSectionHeaderError(Error):
+    def __init__(self, filename, lineno, line):
+        Error.__init__(
+            self,
+            'File contains no section headers.\nfile: %s, line: %d\n%s' %
+            (filename, lineno, line))
+        self.filename = filename
+        self.lineno = lineno
+        self.line = line
+
+class ParsingError(Error):
+    def __init__(self, filename):
+        Error.__init__(self, 'File contains parsing errors: %s' % filename)
+        self.filename = filename
+        self.errors = []
+
+    def append(self, lineno, line):
+        self.errors.append((lineno, line))
+        self._msg = self._msg + '\n\t[line %2d]: %s' % (lineno, line)
+
+
+
+class ConfigParser:
+    def __init__(self, defaults=None):
+        self.__sections = {}
+        if defaults is None:
+            self.__defaults = {}
+        else:
+            self.__defaults = defaults
+
+    def defaults(self):
+        return self.__defaults
+
+    def sections(self):
+        """Return a list of section names, excluding [DEFAULT]"""
+        # self.__sections will never have [DEFAULT] in it
+        return self.__sections.keys()
+
+    def add_section(self, section):
+        """Create a new section in the configuration.
+
+        Raise DuplicateSectionError if a section by the specified name
+        already exists.
+        """
+        if self.__sections.has_key(section):
+            raise DuplicateSectionError(section)
+        self.__sections[section] = {}
+
+    def has_section(self, section):
+        """Indicate whether the named section is present in the configuration.
+
+        The DEFAULT section is not acknowledged.
+        """
+        return self.__sections.has_key(section)
+
+    def options(self, section):
+        """Return a list of option names for the given section name."""
+        try:
+            opts = self.__sections[section].copy()
+        except KeyError:
+            raise NoSectionError(section)
+        opts.update(self.__defaults)
+        return opts.keys()
+
+    def has_option(self, section, option):
+        """Return whether the given section has the given option."""
+        try:
+            opts = self.__sections[section]
+        except KeyError:
+            raise NoSectionError(section)
+        return opts.has_key(option)
+
+    def read(self, filenames):
+        """Read and parse a filename or a list of filenames.
+        
+        Files that cannot be opened are silently ignored; this is
+        designed so that you can specify a list of potential
+        configuration file locations (e.g. current directory, user's
+        home directory, systemwide directory), and all existing
+        configuration files in the list will be read.  A single
+        filename may also be given.
+        """
+        if type(filenames) is type(''):
+            filenames = [filenames]
+        for filename in filenames:
+            try:
+                fp = open(filename)
+            except IOError:
+                continue
+            self.__read(fp, filename)
+            fp.close()
+
+    def readfp(self, fp, filename=None):
+        """Like read() but the argument must be a file-like object.
+
+        The `fp' argument must have a `readline' method.  Optional
+        second argument is the `filename', which if not given, is
+        taken from fp.name.  If fp has no `name' attribute, `<???>' is
+        used.
+
+        """
+        if filename is None:
+            try:
+                filename = fp.name
+            except AttributeError:
+                filename = '<???>'
+        self.__read(fp, filename)
+
+    def get(self, section, option, raw=0, vars=None):
+        """Get an option value for a given section.
+
+        All % interpolations are expanded in the return values, based on the
+        defaults passed into the constructor, unless the optional argument
+        `raw' is true.  Additional substitutions may be provided using the
+        `vars' argument, which must be a dictionary whose contents overrides
+        any pre-existing defaults.
+
+        The section DEFAULT is special.
+        """
+        try:
+            sectdict = self.__sections[section].copy()
+        except KeyError:
+            if section == DEFAULTSECT:
+                sectdict = {}
+            else:
+                raise NoSectionError(section)
+        d = self.__defaults.copy()
+        d.update(sectdict)
+        # Update with the entry specific variables
+        if vars:
+            d.update(vars)
+        option = self.optionxform(option)
+        try:
+            rawval = d[option]
+        except KeyError:
+            raise NoOptionError(option, section)
+        # do the string interpolation
+        if raw:
+            return rawval
+
+        value = rawval                  # Make it a pretty variable name
+        depth = 0                       
+        while depth < 10:               # Loop through this until it's done
+            depth = depth + 1
+            if string.find(value, "%(") >= 0:
+                try:
+                    value = value % d
+                except KeyError, key:
+                    raise InterpolationError(key, option, section, rawval)
+            else:
+                return value
+    
+    def __get(self, section, conv, option):
+        return conv(self.get(section, option))
+
+    def getint(self, section, option):
+        return self.__get(section, string.atoi, option)
+
+    def getfloat(self, section, option):
+        return self.__get(section, string.atof, option)
+
+    def getboolean(self, section, option):
+        v = self.get(section, option)
+        val = string.atoi(v)
+        if val not in (0, 1):
+            raise ValueError, 'Not a boolean: %s' % v
+        return val
+
+    def optionxform(self, optionstr):
+        return string.lower(optionstr)
+
+    #
+    # Regular expressions for parsing section headers and options.  Note a
+    # slight semantic change from the previous version, because of the use
+    # of \w, _ is allowed in section header names.
+    SECTCRE = re.compile(
+        r'\['                                 # [
+        r'(?P<header>[-\w_.*,(){}]+)'         # a lot of stuff found by IvL
+        r'\]'                                 # ]
+        )
+    OPTCRE = re.compile(
+        r'(?P<option>[-\w_.*,(){}]+)'         # a lot of stuff found by IvL
+        r'[ \t]*(?P<vi>[:=])[ \t]*'           # any number of space/tab,
+                                              # followed by separator
+                                              # (either : or =), followed
+                                              # by any # space/tab
+        r'(?P<value>.*)$'                     # everything up to eol
+        )
+
+    def __read(self, fp, fpname):
+        """Parse a sectioned setup file.
+
+        The sections in setup file contains a title line at the top,
+        indicated by a name in square brackets (`[]'), plus key/value
+        options lines, indicated by `name: value' format lines.
+        Continuation are represented by an embedded newline then
+        leading whitespace.  Blank lines, lines beginning with a '#',
+        and just about everything else is ignored.
+        """
+        cursect = None                            # None, or a dictionary
+        optname = None
+        lineno = 0
+        e = None                                  # None, or an exception
+        while 1:
+            line = fp.readline()
+            if not line:
+                break
+            lineno = lineno + 1
+            # comment or blank line?
+            if string.strip(line) == '' or line[0] in '#;':
+                continue
+            if string.lower(string.split(line)[0]) == 'rem' \
+               and line[0] in "rR":      # no leading whitespace
+                continue
+            # continuation line?
+            if line[0] in ' \t' and cursect is not None and optname:
+                value = string.strip(line)
+                if value:
+                    cursect[optname] = cursect[optname] + '\n ' + value
+            # a section header or option header?
+            else:
+                # is it a section header?
+                mo = self.SECTCRE.match(line)
+                if mo:
+                    sectname = mo.group('header')
+                    if self.__sections.has_key(sectname):
+                        cursect = self.__sections[sectname]
+                    elif sectname == DEFAULTSECT:
+                        cursect = self.__defaults
+                    else:
+                        cursect = {'__name__': sectname}
+                        self.__sections[sectname] = cursect
+                    # So sections can't start with a continuation line
+                    optname = None
+                # no section header in the file?
+                elif cursect is None:
+                    raise MissingSectionHeaderError(fpname, lineno, `line`)
+                # an option line?
+                else:
+                    mo = self.OPTCRE.match(line)
+                    if mo:
+                        optname, vi, optval = mo.group('option', 'vi', 'value')
+                        optname = string.lower(optname)
+                        if vi in ('=', ':') and ';' in optval:
+                            # ';' is a comment delimiter only if it follows
+                            # a spacing character
+                            pos = string.find(optval, ';')
+                            if pos and optval[pos-1] in string.whitespace:
+                                optval = optval[:pos]
+                        optval = string.strip(optval)
+                        # allow empty values
+                        if optval == '""':
+                            optval = ''
+                        cursect[optname] = optval
+                    else:
+                        # a non-fatal parsing error occurred.  set up the
+                        # exception but keep going. the exception will be
+                        # raised at the end of the file and will contain a
+                        # list of all bogus lines
+                        if not e:
+                            e = ParsingError(fpname)
+                        e.append(lineno, `line`)
+        # if any parsing errors occurred, raise an exception
+        if e:
+            raise e
diff --git a/Lib/idlelib/Debugger.py b/Lib/idlelib/Debugger.py
new file mode 100644
index 0000000..267d39f
--- /dev/null
+++ b/Lib/idlelib/Debugger.py
@@ -0,0 +1,308 @@
+import os
+import bdb
+import traceback
+from Tkinter import *
+from WindowList import ListedToplevel
+
+import StackViewer
+
+
+class Debugger(bdb.Bdb):
+
+    interacting = 0
+
+    vstack = vsource = vlocals = vglobals = None
+
+    def __init__(self, pyshell):
+        bdb.Bdb.__init__(self)
+        self.pyshell = pyshell
+        self.make_gui()
+    
+    def canonic(self, filename):
+        # Canonicalize filename -- called by Bdb
+        return os.path.normcase(os.path.abspath(filename))
+
+    def close(self, event=None):
+        if self.interacting:
+            self.top.bell()
+            return
+        if self.stackviewer:
+            self.stackviewer.close(); self.stackviewer = None
+        self.pyshell.close_debugger()
+        self.top.destroy()
+
+    def run(self, *args):
+        try:
+            self.interacting = 1
+            return apply(bdb.Bdb.run, (self,) + args)
+        finally:
+            self.interacting = 0
+
+    def user_line(self, frame):
+        self.interaction(frame)
+
+    def user_return(self, frame, rv):
+        # XXX show rv?
+        ##self.interaction(frame)
+        pass
+
+    def user_exception(self, frame, info):
+        self.interaction(frame, info)
+
+    def make_gui(self):
+        pyshell = self.pyshell
+        self.flist = pyshell.flist
+        self.root = root = pyshell.root
+        self.top = top =ListedToplevel(root)
+        self.top.wm_title("Debug Control")
+        self.top.wm_iconname("Debug")
+        top.wm_protocol("WM_DELETE_WINDOW", self.close)
+        self.top.bind("<Escape>", self.close)
+        #
+        self.bframe = bframe = Frame(top)
+        self.bframe.pack(anchor="w")
+        self.buttons = bl = []
+        #
+        self.bcont = b = Button(bframe, text="Go", command=self.cont)
+        bl.append(b)
+        self.bstep = b = Button(bframe, text="Step", command=self.step)
+        bl.append(b)
+        self.bnext = b = Button(bframe, text="Over", command=self.next)
+        bl.append(b)
+        self.bret = b = Button(bframe, text="Out", command=self.ret)
+        bl.append(b)
+        self.bret = b = Button(bframe, text="Quit", command=self.quit)
+        bl.append(b)
+        #
+        for b in bl:
+            b.configure(state="disabled")
+            b.pack(side="left")
+        #
+        self.cframe = cframe = Frame(bframe)
+        self.cframe.pack(side="left")
+        #
+        if not self.vstack:
+            self.__class__.vstack = BooleanVar(top)
+            self.vstack.set(1)
+        self.bstack = Checkbutton(cframe,
+            text="Stack", command=self.show_stack, variable=self.vstack)
+        self.bstack.grid(row=0, column=0)
+        if not self.vsource:
+            self.__class__.vsource = BooleanVar(top)
+            ##self.vsource.set(1)
+        self.bsource = Checkbutton(cframe,
+            text="Source", command=self.show_source, variable=self.vsource)
+        self.bsource.grid(row=0, column=1)
+        if not self.vlocals:
+            self.__class__.vlocals = BooleanVar(top)
+            self.vlocals.set(1)
+        self.blocals = Checkbutton(cframe,
+            text="Locals", command=self.show_locals, variable=self.vlocals)
+        self.blocals.grid(row=1, column=0)
+        if not self.vglobals:
+            self.__class__.vglobals = BooleanVar(top)
+            ##self.vglobals.set(1)
+        self.bglobals = Checkbutton(cframe,
+            text="Globals", command=self.show_globals, variable=self.vglobals)
+        self.bglobals.grid(row=1, column=1)
+        #
+        self.status = Label(top, anchor="w")
+        self.status.pack(anchor="w")
+        self.error = Label(top, anchor="w")
+        self.error.pack(anchor="w", fill="x")
+        self.errorbg = self.error.cget("background")
+        #
+        self.fstack = Frame(top, height=1)
+        self.fstack.pack(expand=1, fill="both")
+        self.flocals = Frame(top)
+        self.flocals.pack(expand=1, fill="both")
+        self.fglobals = Frame(top, height=1)
+        self.fglobals.pack(expand=1, fill="both")
+        #
+        if self.vstack.get():
+            self.show_stack()
+        if self.vlocals.get():
+            self.show_locals()
+        if self.vglobals.get():
+            self.show_globals()
+
+    frame = None
+
+    def interaction(self, frame, info=None):
+        self.frame = frame
+        code = frame.f_code
+        file = code.co_filename
+        base = os.path.basename(file)
+        lineno = frame.f_lineno
+        #
+        message = "%s:%s" % (base, lineno)
+        if code.co_name != "?":
+            message = "%s: %s()" % (message, code.co_name)
+        self.status.configure(text=message)
+        #
+        if info:
+            type, value, tb = info
+            try:
+                m1 = type.__name__
+            except AttributeError:
+                m1 = "%s" % str(type)
+            if value is not None:
+                try:
+                    m1 = "%s: %s" % (m1, str(value))
+                except:
+                    pass
+            bg = "yellow"
+        else:
+            m1 = ""
+            tb = None
+            bg = self.errorbg
+        self.error.configure(text=m1, background=bg)
+        #
+        sv = self.stackviewer
+        if sv:
+            stack, i = self.get_stack(self.frame, tb)
+            sv.load_stack(stack, i)
+        #
+        self.show_variables(1)
+        #
+        if self.vsource.get():
+            self.sync_source_line()
+        #
+        for b in self.buttons:
+            b.configure(state="normal")
+        #
+        self.top.tkraise()
+        self.root.mainloop()
+        #
+        for b in self.buttons:
+            b.configure(state="disabled")
+        self.status.configure(text="")
+        self.error.configure(text="", background=self.errorbg)
+        self.frame = None
+
+    def sync_source_line(self):
+        frame = self.frame
+        if not frame:
+            return
+        code = frame.f_code
+        file = code.co_filename
+        lineno = frame.f_lineno
+        if file[:1] + file[-1:] != "<>" and os.path.exists(file):
+            edit = self.flist.open(file)
+            if edit:
+                edit.gotoline(lineno)
+
+    def cont(self):
+        self.set_continue()
+        self.root.quit()
+
+    def step(self):
+        self.set_step()
+        self.root.quit()
+
+    def next(self):
+        self.set_next(self.frame)
+        self.root.quit()
+
+    def ret(self):
+        self.set_return(self.frame)
+        self.root.quit()
+
+    def quit(self):
+        self.set_quit()
+        self.root.quit()
+
+    stackviewer = None
+
+    def show_stack(self):
+        if not self.stackviewer and self.vstack.get():
+            self.stackviewer = sv = StackViewer.StackViewer(
+                self.fstack, self.flist, self)
+            if self.frame:
+                stack, i = self.get_stack(self.frame, None)
+                sv.load_stack(stack, i)
+        else:
+            sv = self.stackviewer
+            if sv and not self.vstack.get():
+                self.stackviewer = None
+                sv.close()
+            self.fstack['height'] = 1
+
+    def show_source(self):
+        if self.vsource.get():
+            self.sync_source_line()
+
+    def show_frame(self, (frame, lineno)):
+        self.frame = frame
+        self.show_variables()
+
+    localsviewer = None
+    globalsviewer = None
+
+    def show_locals(self):
+        lv = self.localsviewer
+        if self.vlocals.get():
+            if not lv:
+                self.localsviewer = StackViewer.NamespaceViewer(
+                    self.flocals, "Locals")
+        else:
+            if lv:
+                self.localsviewer = None
+                lv.close()
+                self.flocals['height'] = 1
+        self.show_variables()
+
+    def show_globals(self):
+        gv = self.globalsviewer
+        if self.vglobals.get():
+            if not gv:
+                self.globalsviewer = StackViewer.NamespaceViewer(
+                    self.fglobals, "Globals")
+        else:
+            if gv:
+                self.globalsviewer = None
+                gv.close()
+                self.fglobals['height'] = 1
+        self.show_variables()
+
+    def show_variables(self, force=0):
+        lv = self.localsviewer
+        gv = self.globalsviewer
+        frame = self.frame
+        if not frame:
+            ldict = gdict = None
+        else:
+            ldict = frame.f_locals
+            gdict = frame.f_globals
+            if lv and gv and ldict is gdict:
+                ldict = None
+        if lv:
+            lv.load_dict(ldict, force)
+        if gv:
+            gv.load_dict(gdict, force)
+
+    def set_breakpoint_here(self, edit):
+        text = edit.text
+        filename = edit.io.filename
+        if not filename:
+            text.bell()
+            return
+        lineno = int(float(text.index("insert")))
+        msg = self.set_break(filename, lineno)
+        if msg:
+            text.bell()
+            return
+        text.tag_add("BREAK", "insert linestart", "insert lineend +1char")
+
+    # A literal copy of Bdb.set_break() without the print statement at the end
+    def set_break(self, filename, lineno, temporary=0, cond = None):
+        import linecache # Import as late as possible
+        line = linecache.getline(filename, lineno)
+        if not line:
+                return 'That line does not exist!'
+        if not self.breaks.has_key(filename):
+                self.breaks[filename] = []
+        list = self.breaks[filename]
+        if not lineno in list:
+                list.append(lineno)
+        bp = bdb.Breakpoint(filename, lineno, temporary, cond)
diff --git a/Lib/idlelib/Delegator.py b/Lib/idlelib/Delegator.py
new file mode 100644
index 0000000..3665247
--- /dev/null
+++ b/Lib/idlelib/Delegator.py
@@ -0,0 +1,34 @@
+
+class Delegator:
+
+    # The cache is only used to be able to change delegates!
+
+    def __init__(self, delegate=None):
+        self.delegate = delegate
+        self.__cache = {}
+
+    def __getattr__(self, name):
+        attr = getattr(self.delegate, name) # May raise AttributeError
+        setattr(self, name, attr)
+        self.__cache[name] = attr
+        return attr
+
+    def resetcache(self):
+        for key in self.__cache.keys():
+            try:
+                delattr(self, key)
+            except AttributeError:
+                pass
+        self.__cache.clear()
+
+    def cachereport(self):
+        keys = self.__cache.keys()
+        keys.sort()
+        print keys
+
+    def setdelegate(self, delegate):
+        self.resetcache()
+        self.delegate = delegate
+
+    def getdelegate(self):
+        return self.delegate
diff --git a/Lib/idlelib/EditorWindow.py b/Lib/idlelib/EditorWindow.py
new file mode 100644
index 0000000..9f76ef7
--- /dev/null
+++ b/Lib/idlelib/EditorWindow.py
@@ -0,0 +1,749 @@
+# changes by dscherer@cmu.edu
+#   - created format and run menus
+#   - added silly advice dialog (apologies to Douglas Adams)
+#   - made Python Documentation work on Windows (requires win32api to
+#     do a ShellExecute(); other ways of starting a web browser are awkward)
+
+import sys
+import os
+import string
+import re
+import imp
+from Tkinter import *
+import tkSimpleDialog
+import tkMessageBox
+import idlever
+import WindowList
+from IdleConf import idleconf
+
+# The default tab setting for a Text widget, in average-width characters.
+TK_TABWIDTH_DEFAULT = 8
+
+# File menu
+
+#$ event <<open-module>>
+#$ win <Alt-m>
+#$ unix <Control-x><Control-m>
+
+#$ event <<open-class-browser>>
+#$ win <Alt-c>
+#$ unix <Control-x><Control-b>
+
+#$ event <<open-path-browser>>
+
+#$ event <<close-window>>
+#$ unix <Control-x><Control-0>
+#$ unix <Control-x><Key-0>
+#$ win <Alt-F4>
+
+# Edit menu
+
+#$ event <<Copy>>
+#$ win <Control-c>
+#$ unix <Alt-w>
+
+#$ event <<Cut>>
+#$ win <Control-x>
+#$ unix <Control-w>
+
+#$ event <<Paste>>
+#$ win <Control-v>
+#$ unix <Control-y>
+
+#$ event <<select-all>>
+#$ win <Alt-a>
+#$ unix <Alt-a>
+
+# Help menu
+
+#$ event <<help>>
+#$ win <F1>
+#$ unix <F1>
+
+#$ event <<about-idle>>
+
+# Events without menu entries
+
+#$ event <<remove-selection>>
+#$ win <Escape>
+
+#$ event <<center-insert>>
+#$ win <Control-l>
+#$ unix <Control-l>
+
+#$ event <<do-nothing>>
+#$ unix <Control-x>
+
+
+about_title = "About IDLE"
+about_text = """\
+IDLE %s
+
+An Integrated DeveLopment Environment for Python
+
+by Guido van Rossum
+
+This version of IDLE has been modified by David Scherer
+  (dscherer@cmu.edu).  See readme.txt for details.
+""" % idlever.IDLE_VERSION
+
+class EditorWindow:
+
+    from Percolator import Percolator
+    from ColorDelegator import ColorDelegator
+    from UndoDelegator import UndoDelegator
+    from IOBinding import IOBinding
+    import Bindings
+    from Tkinter import Toplevel
+    from MultiStatusBar import MultiStatusBar
+
+    about_title = about_title
+    about_text = about_text
+
+    vars = {}
+
+    def __init__(self, flist=None, filename=None, key=None, root=None):
+        edconf = idleconf.getsection('EditorWindow')
+        coconf = idleconf.getsection('Colors')
+        self.flist = flist
+        root = root or flist.root
+        self.root = root
+        if flist:
+            self.vars = flist.vars
+        self.menubar = Menu(root)
+        self.top = top = self.Toplevel(root, menu=self.menubar)
+        self.vbar = vbar = Scrollbar(top, name='vbar')
+        self.text_frame = text_frame = Frame(top)
+        self.text = text = Text(text_frame, name='text', padx=5,
+                      foreground=coconf.getdef('normal-foreground'),
+                      background=coconf.getdef('normal-background'),
+                      highlightcolor=coconf.getdef('hilite-foreground'),
+                      highlightbackground=coconf.getdef('hilite-background'),
+                      insertbackground=coconf.getdef('cursor-background'),
+                      width=edconf.getint('width'),
+                      height=edconf.getint('height'),
+                      wrap="none")
+
+        self.createmenubar()
+        self.apply_bindings()
+
+        self.top.protocol("WM_DELETE_WINDOW", self.close)
+        self.top.bind("<<close-window>>", self.close_event)
+        text.bind("<<center-insert>>", self.center_insert_event)
+        text.bind("<<help>>", self.help_dialog)
+        text.bind("<<good-advice>>", self.good_advice)
+        text.bind("<<python-docs>>", self.python_docs)
+        text.bind("<<about-idle>>", self.about_dialog)
+        text.bind("<<open-module>>", self.open_module)
+        text.bind("<<do-nothing>>", lambda event: "break")
+        text.bind("<<select-all>>", self.select_all)
+        text.bind("<<remove-selection>>", self.remove_selection)
+        text.bind("<3>", self.right_menu_event)
+        if flist:
+            flist.inversedict[self] = key
+            if key:
+                flist.dict[key] = self
+            text.bind("<<open-new-window>>", self.flist.new_callback)
+            text.bind("<<close-all-windows>>", self.flist.close_all_callback)
+            text.bind("<<open-class-browser>>", self.open_class_browser)
+            text.bind("<<open-path-browser>>", self.open_path_browser)
+
+        vbar['command'] = text.yview
+        vbar.pack(side=RIGHT, fill=Y)
+
+        text['yscrollcommand'] = vbar.set
+        text['font'] = edconf.get('font-name'), edconf.get('font-size')
+        text_frame.pack(side=LEFT, fill=BOTH, expand=1)
+        text.pack(side=TOP, fill=BOTH, expand=1)
+        text.focus_set()
+
+        self.per = per = self.Percolator(text)
+        if self.ispythonsource(filename):
+            self.color = color = self.ColorDelegator(); per.insertfilter(color)
+            ##print "Initial colorizer"
+        else:
+            ##print "No initial colorizer"
+            self.color = None
+        self.undo = undo = self.UndoDelegator(); per.insertfilter(undo)
+        self.io = io = self.IOBinding(self)
+
+        text.undo_block_start = undo.undo_block_start
+        text.undo_block_stop = undo.undo_block_stop
+        undo.set_saved_change_hook(self.saved_change_hook)
+        io.set_filename_change_hook(self.filename_change_hook)
+
+        if filename:
+            if os.path.exists(filename):
+                io.loadfile(filename)
+            else:
+                io.set_filename(filename)
+
+        self.saved_change_hook()
+
+        self.load_extensions()
+
+        menu = self.menudict.get('windows')
+        if menu:
+            end = menu.index("end")
+            if end is None:
+                end = -1
+            if end >= 0:
+                menu.add_separator()
+                end = end + 1
+            self.wmenu_end = end
+            WindowList.register_callback(self.postwindowsmenu)
+
+        # Some abstractions so IDLE extensions are cross-IDE
+        self.askyesno = tkMessageBox.askyesno
+        self.askinteger = tkSimpleDialog.askinteger
+        self.showerror = tkMessageBox.showerror
+
+        if self.extensions.has_key('AutoIndent'):
+            self.extensions['AutoIndent'].set_indentation_params(
+                self.ispythonsource(filename))
+        self.set_status_bar()
+
+    def set_status_bar(self):
+        self.status_bar = self.MultiStatusBar(self.text_frame)
+        self.status_bar.set_label('column', 'Col: ?', side=RIGHT)
+        self.status_bar.set_label('line', 'Ln: ?', side=RIGHT)
+        self.status_bar.pack(side=BOTTOM, fill=X)
+        self.text.bind('<KeyRelease>', self.set_line_and_column)
+        self.text.bind('<ButtonRelease>', self.set_line_and_column)
+        self.text.after_idle(self.set_line_and_column)
+
+    def set_line_and_column(self, event=None):
+        line, column = string.split(self.text.index(INSERT), '.')
+        self.status_bar.set_label('column', 'Col: %s' % column)
+        self.status_bar.set_label('line', 'Ln: %s' % line)
+
+    def wakeup(self):
+        if self.top.wm_state() == "iconic":
+            self.top.wm_deiconify()
+        else:
+            self.top.tkraise()
+        self.text.focus_set()
+
+    menu_specs = [
+        ("file", "_File"),
+        ("edit", "_Edit"),
+        ("format", "F_ormat"),
+        ("run", "_Run"),
+        ("windows", "_Windows"),
+        ("help", "_Help"),
+    ]
+
+    def createmenubar(self):
+        mbar = self.menubar
+        self.menudict = menudict = {}
+        for name, label in self.menu_specs:
+            underline, label = prepstr(label)
+            menudict[name] = menu = Menu(mbar, name=name)
+            mbar.add_cascade(label=label, menu=menu, underline=underline)
+        self.fill_menus()
+
+    def postwindowsmenu(self):
+        # Only called when Windows menu exists
+        # XXX Actually, this Just-In-Time updating interferes badly
+        # XXX with the tear-off feature.  It would be better to update
+        # XXX all Windows menus whenever the list of windows changes.
+        menu = self.menudict['windows']
+        end = menu.index("end")
+        if end is None:
+            end = -1
+        if end > self.wmenu_end:
+            menu.delete(self.wmenu_end+1, end)
+        WindowList.add_windows_to_menu(menu)
+
+    rmenu = None
+
+    def right_menu_event(self, event):
+        self.text.tag_remove("sel", "1.0", "end")
+        self.text.mark_set("insert", "@%d,%d" % (event.x, event.y))
+        if not self.rmenu:
+            self.make_rmenu()
+        rmenu = self.rmenu
+        self.event = event
+        iswin = sys.platform[:3] == 'win'
+        if iswin:
+            self.text.config(cursor="arrow")
+        rmenu.tk_popup(event.x_root, event.y_root)
+        if iswin:
+            self.text.config(cursor="ibeam")
+
+    rmenu_specs = [
+        # ("Label", "<<virtual-event>>"), ...
+        ("Close", "<<close-window>>"), # Example
+    ]
+
+    def make_rmenu(self):
+        rmenu = Menu(self.text, tearoff=0)
+        for label, eventname in self.rmenu_specs:
+            def command(text=self.text, eventname=eventname):
+                text.event_generate(eventname)
+            rmenu.add_command(label=label, command=command)
+        self.rmenu = rmenu
+
+    def about_dialog(self, event=None):
+        tkMessageBox.showinfo(self.about_title, self.about_text,
+                              master=self.text)
+
+    helpfile = "help.txt"
+
+    def good_advice(self, event=None):
+        tkMessageBox.showinfo('Advice', "Don't Panic!", master=self.text)
+
+    def help_dialog(self, event=None):
+        try:
+            helpfile = os.path.join(os.path.dirname(__file__), self.helpfile)
+        except NameError:
+            helpfile = self.helpfile
+        if self.flist:
+            self.flist.open(helpfile)
+        else:
+            self.io.loadfile(helpfile)
+
+    help_viewer = "netscape -remote 'openurl(%(url)s)' 2>/dev/null || " \
+                  "netscape %(url)s &"
+    help_url = "http://www.python.org/doc/current/"
+
+    def python_docs(self, event=None):
+        if sys.platform=='win32':
+          try:
+            import win32api
+            import ExecBinding
+            doc = os.path.join( os.path.dirname( ExecBinding.pyth_exe ), "doc", "index.html" )
+            win32api.ShellExecute(0, None, doc, None, sys.path[0], 1)
+          except:
+            pass
+        else:
+          cmd = self.help_viewer % {"url": self.help_url}
+          os.system(cmd)
+
+    def select_all(self, event=None):
+        self.text.tag_add("sel", "1.0", "end-1c")
+        self.text.mark_set("insert", "1.0")
+        self.text.see("insert")
+        return "break"
+
+    def remove_selection(self, event=None):
+        self.text.tag_remove("sel", "1.0", "end")
+        self.text.see("insert")
+
+    def open_module(self, event=None):
+        # XXX Shouldn't this be in IOBinding or in FileList?
+        try:
+            name = self.text.get("sel.first", "sel.last")
+        except TclError:
+            name = ""
+        else:
+            name = string.strip(name)
+        if not name:
+            name = tkSimpleDialog.askstring("Module",
+                     "Enter the name of a Python module\n"
+                     "to search on sys.path and open:",
+                     parent=self.text)
+            if name:
+                name = string.strip(name)
+            if not name:
+                return
+        # XXX Ought to support package syntax
+        # XXX Ought to insert current file's directory in front of path
+        try:
+            (f, file, (suffix, mode, type)) = imp.find_module(name)
+        except (NameError, ImportError), msg:
+            tkMessageBox.showerror("Import error", str(msg), parent=self.text)
+            return
+        if type != imp.PY_SOURCE:
+            tkMessageBox.showerror("Unsupported type",
+                "%s is not a source module" % name, parent=self.text)
+            return
+        if f:
+            f.close()
+        if self.flist:
+            self.flist.open(file)
+        else:
+            self.io.loadfile(file)
+
+    def open_class_browser(self, event=None):
+        filename = self.io.filename
+        if not filename:
+            tkMessageBox.showerror(
+                "No filename",
+                "This buffer has no associated filename",
+                master=self.text)
+            self.text.focus_set()
+            return None
+        head, tail = os.path.split(filename)
+        base, ext = os.path.splitext(tail)
+        import ClassBrowser
+        ClassBrowser.ClassBrowser(self.flist, base, [head])
+
+    def open_path_browser(self, event=None):
+        import PathBrowser
+        PathBrowser.PathBrowser(self.flist)
+
+    def gotoline(self, lineno):
+        if lineno is not None and lineno > 0:
+            self.text.mark_set("insert", "%d.0" % lineno)
+            self.text.tag_remove("sel", "1.0", "end")
+            self.text.tag_add("sel", "insert", "insert +1l")
+            self.center()
+
+    def ispythonsource(self, filename):
+        if not filename:
+            return 1
+        base, ext = os.path.splitext(os.path.basename(filename))
+        if os.path.normcase(ext) in (".py", ".pyw"):
+            return 1
+        try:
+            f = open(filename)
+            line = f.readline()
+            f.close()
+        except IOError:
+            return 0
+        return line[:2] == '#!' and string.find(line, 'python') >= 0
+
+    def close_hook(self):
+        if self.flist:
+            self.flist.close_edit(self)
+
+    def set_close_hook(self, close_hook):
+        self.close_hook = close_hook
+
+    def filename_change_hook(self):
+        if self.flist:
+            self.flist.filename_changed_edit(self)
+        self.saved_change_hook()
+        if self.ispythonsource(self.io.filename):
+            self.addcolorizer()
+        else:
+            self.rmcolorizer()
+
+    def addcolorizer(self):
+        if self.color:
+            return
+        ##print "Add colorizer"
+        self.per.removefilter(self.undo)
+        self.color = self.ColorDelegator()
+        self.per.insertfilter(self.color)
+        self.per.insertfilter(self.undo)
+
+    def rmcolorizer(self):
+        if not self.color:
+            return
+        ##print "Remove colorizer"
+        self.per.removefilter(self.undo)
+        self.per.removefilter(self.color)
+        self.color = None
+        self.per.insertfilter(self.undo)
+
+    def saved_change_hook(self):
+        short = self.short_title()
+        long = self.long_title()
+        if short and long:
+            title = short + " - " + long
+        elif short:
+            title = short
+        elif long:
+            title = long
+        else:
+            title = "Untitled"
+        icon = short or long or title
+        if not self.get_saved():
+            title = "*%s*" % title
+            icon = "*%s" % icon
+        self.top.wm_title(title)
+        self.top.wm_iconname(icon)
+
+    def get_saved(self):
+        return self.undo.get_saved()
+
+    def set_saved(self, flag):
+        self.undo.set_saved(flag)
+
+    def reset_undo(self):
+        self.undo.reset_undo()
+
+    def short_title(self):
+        filename = self.io.filename
+        if filename:
+            filename = os.path.basename(filename)
+        return filename
+
+    def long_title(self):
+        return self.io.filename or ""
+
+    def center_insert_event(self, event):
+        self.center()
+
+    def center(self, mark="insert"):
+        text = self.text
+        top, bot = self.getwindowlines()
+        lineno = self.getlineno(mark)
+        height = bot - top
+        newtop = max(1, lineno - height/2)
+        text.yview(float(newtop))
+
+    def getwindowlines(self):
+        text = self.text
+        top = self.getlineno("@0,0")
+        bot = self.getlineno("@0,65535")
+        if top == bot and text.winfo_height() == 1:
+            # Geometry manager hasn't run yet
+            height = int(text['height'])
+            bot = top + height - 1
+        return top, bot
+
+    def getlineno(self, mark="insert"):
+        text = self.text
+        return int(float(text.index(mark)))
+
+    def close_event(self, event):
+        self.close()
+
+    def maybesave(self):
+        if self.io:
+            return self.io.maybesave()
+
+    def close(self):
+        self.top.wm_deiconify()
+        self.top.tkraise()
+        reply = self.maybesave()
+        if reply != "cancel":
+            self._close()
+        return reply
+
+    def _close(self):
+        WindowList.unregister_callback(self.postwindowsmenu)
+        if self.close_hook:
+            self.close_hook()
+        self.flist = None
+        colorizing = 0
+        self.unload_extensions()
+        self.io.close(); self.io = None
+        self.undo = None # XXX
+        if self.color:
+            colorizing = self.color.colorizing
+            doh = colorizing and self.top
+            self.color.close(doh) # Cancel colorization
+        self.text = None
+        self.vars = None
+        self.per.close(); self.per = None
+        if not colorizing:
+            self.top.destroy()
+
+    def load_extensions(self):
+        self.extensions = {}
+        self.load_standard_extensions()
+
+    def unload_extensions(self):
+        for ins in self.extensions.values():
+            if hasattr(ins, "close"):
+                ins.close()
+        self.extensions = {}
+
+    def load_standard_extensions(self):
+        for name in self.get_standard_extension_names():
+            try:
+                self.load_extension(name)
+            except:
+                print "Failed to load extension", `name`
+                import traceback
+                traceback.print_exc()
+
+    def get_standard_extension_names(self):
+        return idleconf.getextensions()
+
+    def load_extension(self, name):
+        mod = __import__(name, globals(), locals(), [])
+        cls = getattr(mod, name)
+        ins = cls(self)
+        self.extensions[name] = ins
+        kdnames = ["keydefs"]
+        if sys.platform == 'win32':
+            kdnames.append("windows_keydefs")
+        elif sys.platform == 'mac':
+            kdnames.append("mac_keydefs")
+        else:
+            kdnames.append("unix_keydefs")
+        keydefs = {}
+        for kdname in kdnames:
+            if hasattr(ins, kdname):
+                keydefs.update(getattr(ins, kdname))
+        if keydefs:
+            self.apply_bindings(keydefs)
+            for vevent in keydefs.keys():
+                methodname = string.replace(vevent, "-", "_")
+                while methodname[:1] == '<':
+                    methodname = methodname[1:]
+                while methodname[-1:] == '>':
+                    methodname = methodname[:-1]
+                methodname = methodname + "_event"
+                if hasattr(ins, methodname):
+                    self.text.bind(vevent, getattr(ins, methodname))
+        if hasattr(ins, "menudefs"):
+            self.fill_menus(ins.menudefs, keydefs)
+        return ins
+
+    def apply_bindings(self, keydefs=None):
+        if keydefs is None:
+            keydefs = self.Bindings.default_keydefs
+        text = self.text
+        text.keydefs = keydefs
+        for event, keylist in keydefs.items():
+            if keylist:
+                apply(text.event_add, (event,) + tuple(keylist))
+
+    def fill_menus(self, defs=None, keydefs=None):
+        # Fill the menus. Menus that are absent or None in
+        # self.menudict are ignored.
+        if defs is None:
+            defs = self.Bindings.menudefs
+        if keydefs is None:
+            keydefs = self.Bindings.default_keydefs
+        menudict = self.menudict
+        text = self.text
+        for mname, itemlist in defs:
+            menu = menudict.get(mname)
+            if not menu:
+                continue
+            for item in itemlist:
+                if not item:
+                    menu.add_separator()
+                else:
+                    label, event = item
+                    checkbutton = (label[:1] == '!')
+                    if checkbutton:
+                        label = label[1:]
+                    underline, label = prepstr(label)
+                    accelerator = get_accelerator(keydefs, event)
+                    def command(text=text, event=event):
+                        text.event_generate(event)
+                    if checkbutton:
+                        var = self.getrawvar(event, BooleanVar)
+                        menu.add_checkbutton(label=label, underline=underline,
+                            command=command, accelerator=accelerator,
+                            variable=var)
+                    else:
+                        menu.add_command(label=label, underline=underline,
+                            command=command, accelerator=accelerator)
+
+    def getvar(self, name):
+        var = self.getrawvar(name)
+        if var:
+            return var.get()
+
+    def setvar(self, name, value, vartype=None):
+        var = self.getrawvar(name, vartype)
+        if var:
+            var.set(value)
+
+    def getrawvar(self, name, vartype=None):
+        var = self.vars.get(name)
+        if not var and vartype:
+            self.vars[name] = var = vartype(self.text)
+        return var
+
+    # Tk implementations of "virtual text methods" -- each platform
+    # reusing IDLE's support code needs to define these for its GUI's
+    # flavor of widget.
+
+    # Is character at text_index in a Python string?  Return 0 for
+    # "guaranteed no", true for anything else.  This info is expensive
+    # to compute ab initio, but is probably already known by the
+    # platform's colorizer.
+
+    def is_char_in_string(self, text_index):
+        if self.color:
+            # Return true iff colorizer hasn't (re)gotten this far
+            # yet, or the character is tagged as being in a string
+            return self.text.tag_prevrange("TODO", text_index) or \
+                   "STRING" in self.text.tag_names(text_index)
+        else:
+            # The colorizer is missing: assume the worst
+            return 1
+
+    # If a selection is defined in the text widget, return (start,
+    # end) as Tkinter text indices, otherwise return (None, None)
+    def get_selection_indices(self):
+        try:
+            first = self.text.index("sel.first")
+            last = self.text.index("sel.last")
+            return first, last
+        except TclError:
+            return None, None
+
+    # Return the text widget's current view of what a tab stop means
+    # (equivalent width in spaces).
+
+    def get_tabwidth(self):
+        current = self.text['tabs'] or TK_TABWIDTH_DEFAULT
+        return int(current)
+
+    # Set the text widget's current view of what a tab stop means.
+
+    def set_tabwidth(self, newtabwidth):
+        text = self.text
+        if self.get_tabwidth() != newtabwidth:
+            pixels = text.tk.call("font", "measure", text["font"],
+                                  "-displayof", text.master,
+                                  "n" * newtabwith)
+            text.configure(tabs=pixels)
+
+def prepstr(s):
+    # Helper to extract the underscore from a string, e.g.
+    # prepstr("Co_py") returns (2, "Copy").
+    i = string.find(s, '_')
+    if i >= 0:
+        s = s[:i] + s[i+1:]
+    return i, s
+
+
+keynames = {
+ 'bracketleft': '[',
+ 'bracketright': ']',
+ 'slash': '/',
+}
+
+def get_accelerator(keydefs, event):
+    keylist = keydefs.get(event)
+    if not keylist:
+        return ""
+    s = keylist[0]
+    s = re.sub(r"-[a-z]\b", lambda m: string.upper(m.group()), s)
+    s = re.sub(r"\b\w+\b", lambda m: keynames.get(m.group(), m.group()), s)
+    s = re.sub("Key-", "", s)
+    s = re.sub("Cancel","Ctrl-Break",s)   # dscherer@cmu.edu
+    s = re.sub("Control-", "Ctrl-", s)
+    s = re.sub("-", "+", s)
+    s = re.sub("><", " ", s)
+    s = re.sub("<", "", s)
+    s = re.sub(">", "", s)
+    return s
+
+
+def fixwordbreaks(root):
+    # Make sure that Tk's double-click and next/previous word
+    # operations use our definition of a word (i.e. an identifier)
+    tk = root.tk
+    tk.call('tcl_wordBreakAfter', 'a b', 0) # make sure word.tcl is loaded
+    tk.call('set', 'tcl_wordchars', '[a-zA-Z0-9_]')
+    tk.call('set', 'tcl_nonwordchars', '[^a-zA-Z0-9_]')
+
+
+def test():
+    root = Tk()
+    fixwordbreaks(root)
+    root.withdraw()
+    if sys.argv[1:]:
+        filename = sys.argv[1]
+    else:
+        filename = None
+    edit = EditorWindow(root=root, filename=filename)
+    edit.set_close_hook(root.quit)
+    root.mainloop()
+    root.destroy()
+
+if __name__ == '__main__':
+    test()
diff --git a/Lib/idlelib/ExecBinding.py b/Lib/idlelib/ExecBinding.py
new file mode 100644
index 0000000..67b0822
--- /dev/null
+++ b/Lib/idlelib/ExecBinding.py
@@ -0,0 +1,198 @@
+"""Extension to execute a script in a separate process
+
+David Scherer <dscherer@cmu.edu>
+
+  The ExecBinding module, a replacement for ScriptBinding, executes
+  programs in a separate process.  Unlike previous versions, this version
+  communicates with the user process via an RPC protocol (see the 'protocol'
+  module).  The user program is loaded by the 'loader' and 'Remote'
+  modules.  Its standard output and input are directed back to the
+  ExecBinding class through the RPC mechanism and implemented here.
+
+  A "stop program" command is provided and bound to control-break.  Closing
+  the output window also stops the running program.
+"""
+
+import sys
+import os
+import imp
+import OutputWindow
+import protocol
+import spawn
+import traceback
+import tempfile
+
+# Find Python and the loader.  This should be done as early in execution
+#   as possible, because if the current directory or sys.path is changed
+#   it may no longer be possible to get correct paths for these things.
+
+pyth_exe = spawn.hardpath( sys.executable )
+load_py  = spawn.hardpath( imp.find_module("loader")[1] )
+
+# The following mechanism matches loaders up with ExecBindings that are
+#    trying to load something.
+
+waiting_for_loader = []
+
+def loader_connect(client, addr):
+    if waiting_for_loader:
+        a = waiting_for_loader.pop(0)
+        try:
+            return a.connect(client, addr)
+        except:
+            return loader_connect(client,addr)
+
+protocol.publish('ExecBinding', loader_connect)
+
+class ExecBinding:
+    keydefs = {
+        '<<run-complete-script>>': ['<F5>'],
+        '<<stop-execution>>': ['<Cancel>'],   #'<Control-c>'
+    }
+    
+    menudefs = [
+        ('run', [None,
+                  ('Run program', '<<run-complete-script>>'),
+                  ('Stop program', '<<stop-execution>>'),
+                 ]
+        ),
+    ]
+
+    delegate = 1
+
+    def __init__(self, editwin):
+        self.editwin = editwin
+        self.client = None
+        self.temp = []
+
+        if not hasattr(editwin, 'source_window'):
+            self.delegate = 0
+            self.output = OutputWindow.OnDemandOutputWindow(editwin.flist)
+            self.output.close_hook = self.stopProgram
+            self.output.source_window = editwin
+        else:
+            if (self.editwin.source_window and
+                self.editwin.source_window.extensions.has_key('ExecBinding') and
+                not self.editwin.source_window.extensions['ExecBinding'].delegate):
+                    delegate = self.editwin.source_window.extensions['ExecBinding']
+                    self.run_complete_script_event = delegate.run_complete_script_event
+                    self.stop_execution_event = delegate.stop_execution_event
+
+    def __del__(self):
+        self.stopProgram()
+
+    def stop_execution_event(self, event):
+        if self.client:
+            self.stopProgram()
+            self.write('\nProgram stopped.\n','stderr')
+
+    def run_complete_script_event(self, event):
+        filename = self.getfilename()
+        if not filename: return
+        filename = os.path.abspath(filename)
+
+        self.stopProgram()
+
+        self.commands = [ ('run', filename) ]
+        waiting_for_loader.append(self)
+        spawn.spawn( pyth_exe, load_py )
+
+    def connect(self, client, addr):
+        # Called by loader_connect() above.  It is remotely possible that
+        #   we get connected to two loaders if the user is running the
+        #   program repeatedly in a short span of time.  In this case, we
+        #   simply return None, refusing to connect and letting the redundant
+        #   loader die.
+        if self.client: return None
+
+        self.client = client
+        client.set_close_hook( self.connect_lost )
+
+        title = self.editwin.short_title()
+        if title:
+            self.output.set_title(title + " Output")
+        else:
+            self.output.set_title("Output")
+        self.output.write('\n',"stderr")
+        self.output.scroll_clear()
+
+        return self
+
+    def connect_lost(self):
+        # Called by the client's close hook when the loader closes its
+        #   socket.
+
+        # We print a disconnect message only if the output window is already
+        #   open.
+        if self.output.owin and self.output.owin.text:
+            self.output.owin.interrupt()
+            self.output.write("\nProgram disconnected.\n","stderr")
+
+        for t in self.temp:
+            try:
+                os.remove(t)
+            except:
+                pass
+        self.temp = []
+        self.client = None
+
+    def get_command(self):
+        # Called by Remote to find out what it should be executing.
+        # Later this will be used to implement debugging, interactivity, etc.
+        if self.commands:
+            return self.commands.pop(0)
+        return ('finish',)
+
+    def program_exception(self, type, value, tb, first, last):
+        if type == SystemExit: return 0
+
+        for i in range(len(tb)):
+            filename, lineno, name, line = tb[i]
+            if filename in self.temp:
+                filename = 'Untitled'
+            tb[i] = filename, lineno, name, line
+
+        list = traceback.format_list(tb[first:last])
+        exc = traceback.format_exception_only( type, value )
+
+        self.write('Traceback (innermost last)\n', 'stderr')
+        for i in (list+exc):
+            self.write(i, 'stderr')
+
+        self.commands = []
+        return 1
+
+    def write(self, text, tag):
+        self.output.write(text,tag)
+
+    def readline(self):
+        return self.output.readline()
+
+    def stopProgram(self):
+        if self.client:
+          self.client.close()
+          self.client = None
+
+    def getfilename(self):
+        # Save all files which have been named, because they might be modules
+        for edit in self.editwin.flist.inversedict.keys():
+            if edit.io and edit.io.filename and not edit.get_saved():
+                edit.io.save(None)
+
+        # Experimental: execute unnamed buffer
+        if not self.editwin.io.filename:
+            filename = os.path.normcase(os.path.abspath(tempfile.mktemp()))
+            self.temp.append(filename)
+            if self.editwin.io.writefile(filename):
+                return filename
+
+        # If the file isn't save, we save it.  If it doesn't have a filename,
+        #   the user will be prompted.
+        if self.editwin.io and not self.editwin.get_saved():
+            self.editwin.io.save(None)
+
+        # If the file *still* isn't saved, we give up.
+        if not self.editwin.get_saved():
+            return
+
+        return self.editwin.io.filename
diff --git a/Lib/idlelib/FileList.py b/Lib/idlelib/FileList.py
new file mode 100644
index 0000000..5d9aafe
--- /dev/null
+++ b/Lib/idlelib/FileList.py
@@ -0,0 +1,150 @@
+# changes by dscherer@cmu.edu
+#   - FileList.open() takes an optional 3rd parameter action, which is
+#       called instead of creating a new EditorWindow.  This enables
+#       things like 'open in same window'.
+
+import os
+from Tkinter import *
+import tkMessageBox
+
+import WindowList
+
+#$ event <<open-new-window>>
+#$ win <Control-n>
+#$ unix <Control-x><Control-n>
+
+# (This is labeled as 'Exit'in the File menu)
+#$ event <<close-all-windows>>
+#$ win <Control-q>
+#$ unix <Control-x><Control-c>
+
+class FileList:
+
+    from EditorWindow import EditorWindow
+    EditorWindow.Toplevel = WindowList.ListedToplevel # XXX Patch it!
+
+    def __init__(self, root):
+        self.root = root
+        self.dict = {}
+        self.inversedict = {}
+        self.vars = {} # For EditorWindow.getrawvar (shared Tcl variables)
+
+
+    def goodname(self, filename):
+            filename = self.canonize(filename)
+            key = os.path.normcase(filename)
+            if self.dict.has_key(key):
+                edit = self.dict[key]
+                filename = edit.io.filename or filename
+            return filename
+
+    def open(self, filename, action=None):
+        assert filename
+        filename = self.canonize(filename)
+        if os.path.isdir(filename):
+            tkMessageBox.showerror(
+                "Is A Directory",
+                "The path %s is a directory." % `filename`,
+                master=self.root)
+            return None
+        key = os.path.normcase(filename)
+        if self.dict.has_key(key):
+            edit = self.dict[key]
+            edit.wakeup()
+            return edit
+        if not os.path.exists(filename):
+            tkMessageBox.showinfo(
+                "New File",
+                "Opening non-existent file %s" % `filename`,
+                master=self.root)
+        if action is None:
+            return self.EditorWindow(self, filename, key)
+        else:
+            return action(filename)
+
+    def new(self):
+        return self.EditorWindow(self)
+
+    def new_callback(self, event):
+        self.new()
+        return "break"
+
+    def close_all_callback(self, event):
+        for edit in self.inversedict.keys():
+            reply = edit.close()
+            if reply == "cancel":
+                break
+        return "break"
+
+    def close_edit(self, edit):
+        try:
+            key = self.inversedict[edit]
+        except KeyError:
+            print "Don't know this EditorWindow object.  (close)"
+            return
+        if key:
+            del self.dict[key]
+        del self.inversedict[edit]
+        if not self.inversedict:
+            self.root.quit()
+
+    def filename_changed_edit(self, edit):
+        edit.saved_change_hook()
+        try:
+            key = self.inversedict[edit]
+        except KeyError:
+            print "Don't know this EditorWindow object.  (rename)"
+            return
+        filename = edit.io.filename
+        if not filename:
+            if key:
+                del self.dict[key]
+            self.inversedict[edit] = None
+            return
+        filename = self.canonize(filename)
+        newkey = os.path.normcase(filename)
+        if newkey == key:
+            return
+        if self.dict.has_key(newkey):
+            conflict = self.dict[newkey]
+            self.inversedict[conflict] = None
+            tkMessageBox.showerror(
+                "Name Conflict",
+                "You now have multiple edit windows open for %s" % `filename`,
+                master=self.root)
+        self.dict[newkey] = edit
+        self.inversedict[edit] = newkey
+        if key:
+            try:
+                del self.dict[key]
+            except KeyError:
+                pass
+
+    def canonize(self, filename):
+        if not os.path.isabs(filename):
+            try:
+                pwd = os.getcwd()
+            except os.error:
+                pass
+            else:
+                filename = os.path.join(pwd, filename)
+        return os.path.normpath(filename)
+
+
+def test():
+    from EditorWindow import fixwordbreaks
+    import sys
+    root = Tk()
+    fixwordbreaks(root)
+    root.withdraw()
+    flist = FileList(root)
+    if sys.argv[1:]:
+        for filename in sys.argv[1:]:
+            flist.open(filename)
+    else:
+        flist.new()
+    if flist.inversedict:
+        root.mainloop()
+
+if __name__ == '__main__':
+    test()
diff --git a/Lib/idlelib/FormatParagraph.py b/Lib/idlelib/FormatParagraph.py
new file mode 100644
index 0000000..68fe6b1
--- /dev/null
+++ b/Lib/idlelib/FormatParagraph.py
@@ -0,0 +1,155 @@
+# Extension to format a paragraph
+
+# Does basic, standard text formatting, and also understands Python
+# comment blocks.  Thus, for editing Python source code, this
+# extension is really only suitable for reformatting these comment
+# blocks or triple-quoted strings.
+
+# Known problems with comment reformatting:
+# * If there is a selection marked, and the first line of the
+#   selection is not complete, the block will probably not be detected
+#   as comments, and will have the normal "text formatting" rules
+#   applied.
+# * If a comment block has leading whitespace that mixes tabs and
+#   spaces, they will not be considered part of the same block.
+# * Fancy comments, like this bulleted list, arent handled :-)
+
+import string
+import re
+
+class FormatParagraph:
+
+    menudefs = [
+        ('format', [   # /s/edit/format   dscherer@cmu.edu
+            ('Format Paragraph', '<<format-paragraph>>'),
+         ])
+    ]
+
+    keydefs = {
+        '<<format-paragraph>>': ['<Alt-q>'],
+    }
+    
+    unix_keydefs = {
+        '<<format-paragraph>>': ['<Meta-q>'],
+    } 
+
+    def __init__(self, editwin):
+        self.editwin = editwin
+
+    def close(self):
+        self.editwin = None
+
+    def format_paragraph_event(self, event):
+        text = self.editwin.text
+        first, last = self.editwin.get_selection_indices()
+        if first and last:
+            data = text.get(first, last)
+            comment_header = ''
+        else:
+            first, last, comment_header, data = \
+                    find_paragraph(text, text.index("insert"))
+        if comment_header:
+            # Reformat the comment lines - convert to text sans header.
+            lines = string.split(data, "\n")
+            lines = map(lambda st, l=len(comment_header): st[l:], lines)
+            data = string.join(lines, "\n")
+            # Reformat to 70 chars or a 20 char width, whichever is greater.
+            format_width = max(70-len(comment_header), 20)
+            newdata = reformat_paragraph(data, format_width)
+            # re-split and re-insert the comment header.
+            newdata = string.split(newdata, "\n")
+            # If the block ends in a \n, we dont want the comment
+            # prefix inserted after it. (Im not sure it makes sense to
+            # reformat a comment block that isnt made of complete
+            # lines, but whatever!)  Can't think of a clean soltution,
+            # so we hack away
+            block_suffix = ""
+            if not newdata[-1]:
+                block_suffix = "\n"
+                newdata = newdata[:-1]
+            builder = lambda item, prefix=comment_header: prefix+item
+            newdata = string.join(map(builder, newdata), '\n') + block_suffix
+        else:
+            # Just a normal text format
+            newdata = reformat_paragraph(data)
+        text.tag_remove("sel", "1.0", "end")
+        if newdata != data:
+            text.mark_set("insert", first)
+            text.undo_block_start()
+            text.delete(first, last)
+            text.insert(first, newdata)
+            text.undo_block_stop()
+        else:
+            text.mark_set("insert", last)
+        text.see("insert")
+
+def find_paragraph(text, mark):
+    lineno, col = map(int, string.split(mark, "."))
+    line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
+    while text.compare("%d.0" % lineno, "<", "end") and is_all_white(line):
+        lineno = lineno + 1
+        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
+    first_lineno = lineno
+    comment_header = get_comment_header(line)
+    comment_header_len = len(comment_header)
+    while get_comment_header(line)==comment_header and \
+              not is_all_white(line[comment_header_len:]):
+        lineno = lineno + 1
+        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
+    last = "%d.0" % lineno
+    # Search back to beginning of paragraph
+    lineno = first_lineno - 1
+    line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
+    while lineno > 0 and \
+              get_comment_header(line)==comment_header and \
+              not is_all_white(line[comment_header_len:]):
+        lineno = lineno - 1
+        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
+    first = "%d.0" % (lineno+1)
+    return first, last, comment_header, text.get(first, last)
+
+def reformat_paragraph(data, limit=70):
+    lines = string.split(data, "\n")
+    i = 0
+    n = len(lines)
+    while i < n and is_all_white(lines[i]):
+        i = i+1
+    if i >= n:
+        return data
+    indent1 = get_indent(lines[i])
+    if i+1 < n and not is_all_white(lines[i+1]):
+        indent2 = get_indent(lines[i+1])
+    else:
+        indent2 = indent1
+    new = lines[:i]
+    partial = indent1
+    while i < n and not is_all_white(lines[i]):
+        # XXX Should take double space after period (etc.) into account
+        words = re.split("(\s+)", lines[i])
+        for j in range(0, len(words), 2):
+            word = words[j]
+            if not word:
+                continue # Can happen when line ends in whitespace
+            if len(string.expandtabs(partial + word)) > limit and \
+               partial != indent1:
+                new.append(string.rstrip(partial))
+                partial = indent2
+            partial = partial + word + " "
+            if j+1 < len(words) and words[j+1] != " ":
+                partial = partial + " "
+        i = i+1
+    new.append(string.rstrip(partial))
+    # XXX Should reformat remaining paragraphs as well
+    new.extend(lines[i:])
+    return string.join(new, "\n")
+
+def is_all_white(line):
+    return re.match(r"^\s*$", line) is not None
+
+def get_indent(line):
+    return re.match(r"^(\s*)", line).group()
+
+def get_comment_header(line):
+    m = re.match(r"^(\s*#*)", line)
+    if m is None: return ""
+    return m.group(1)
diff --git a/Lib/idlelib/FrameViewer.py b/Lib/idlelib/FrameViewer.py
new file mode 100644
index 0000000..2ce0935
--- /dev/null
+++ b/Lib/idlelib/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/Lib/idlelib/GrepDialog.py b/Lib/idlelib/GrepDialog.py
new file mode 100644
index 0000000..61c77c3
--- /dev/null
+++ b/Lib/idlelib/GrepDialog.py
@@ -0,0 +1,135 @@
+import string
+import os
+import re
+import fnmatch
+import sys
+from Tkinter import *
+import tkMessageBox
+import SearchEngine
+from SearchDialogBase import SearchDialogBase
+
+def grep(text, io=None, flist=None):
+    root = text._root()
+    engine = SearchEngine.get(root)
+    if not hasattr(engine, "_grepdialog"):
+        engine._grepdialog = GrepDialog(root, engine, flist)
+    dialog = engine._grepdialog
+    dialog.open(io)
+
+class GrepDialog(SearchDialogBase):
+
+    title = "Find in Files Dialog"
+    icon = "Grep"
+    needwrapbutton = 0
+
+    def __init__(self, root, engine, flist):
+        SearchDialogBase.__init__(self, root, engine)
+        self.flist = flist
+        self.globvar = StringVar(root)
+        self.recvar = BooleanVar(root)
+
+    def open(self, io=None):
+        SearchDialogBase.open(self, None)
+        if io:
+            path = io.filename or ""
+        else:
+            path = ""
+        dir, base = os.path.split(path)
+        head, tail = os.path.splitext(base)
+        if not tail:
+            tail = ".py"
+        self.globvar.set(os.path.join(dir, "*" + tail))
+
+    def create_entries(self):
+        SearchDialogBase.create_entries(self)
+        self.globent = self.make_entry("In files:", self.globvar)
+
+    def create_other_buttons(self):
+        f = self.make_frame()
+
+        btn = Checkbutton(f, anchor="w",
+                variable=self.recvar,
+                text="Recurse down subdirectories")
+        btn.pack(side="top", fill="both")
+        btn.select()
+
+    def create_command_buttons(self):
+        SearchDialogBase.create_command_buttons(self)
+        self.make_button("Search Files", self.default_command, 1)
+
+    def default_command(self, event=None):
+        prog = self.engine.getprog()
+        if not prog:
+            return
+        path = self.globvar.get()
+        if not path:
+            self.top.bell()
+            return
+        from OutputWindow import OutputWindow
+        save = sys.stdout
+        try:
+            sys.stdout = OutputWindow(self.flist)
+            self.grep_it(prog, path)
+        finally:
+            sys.stdout = save
+
+    def grep_it(self, prog, path):
+        dir, base = os.path.split(path)
+        list = self.findfiles(dir, base, self.recvar.get())
+        list.sort()
+        self.close()
+        pat = self.engine.getpat()
+        print "Searching %s in %s ..." % (`pat`, path)
+        hits = 0
+        for fn in list:
+            try:
+                f = open(fn)
+            except IOError, msg:
+                print msg
+                continue
+            lineno = 0
+            while 1:
+                block = f.readlines(100000)
+                if not block:
+                    break
+                for line in block:
+                    lineno = lineno + 1
+                    if line[-1:] == '\n':
+                        line = line[:-1]
+                    if prog.search(line):
+                        sys.stdout.write("%s: %s: %s\n" % (fn, lineno, line))
+                        hits = hits + 1
+        if hits:
+            if hits == 1:
+                s = ""
+            else:
+                s = "s"
+            print "Found", hits, "hit%s." % s
+            print "(Hint: right-click to open locations.)"
+        else:
+            print "No hits."
+
+    def findfiles(self, dir, base, rec):
+        try:
+            names = os.listdir(dir or os.curdir)
+        except os.error, msg:
+            print msg
+            return []
+        list = []
+        subdirs = []
+        for name in names:
+            fn = os.path.join(dir, name)
+            if os.path.isdir(fn):
+                subdirs.append(fn)
+            else:
+                if fnmatch.fnmatch(name, base):
+                    list.append(fn)
+        if rec:
+            for subdir in subdirs:
+                list.extend(self.findfiles(subdir, base, rec))
+        return list
+
+    def close(self, event=None):
+        if self.top:
+            self.top.grab_release()
+            self.top.withdraw()
diff --git a/Lib/idlelib/IOBinding.py b/Lib/idlelib/IOBinding.py
new file mode 100644
index 0000000..07b04f3
--- /dev/null
+++ b/Lib/idlelib/IOBinding.py
@@ -0,0 +1,254 @@
+# changes by dscherer@cmu.edu
+#   - IOBinding.open() replaces the current window with the opened file,
+#     if the current window is both unmodified and unnamed
+#   - IOBinding.loadfile() interprets Windows, UNIX, and Macintosh
+#     end-of-line conventions, instead of relying on the standard library,
+#     which will only understand the local convention.
+
+import os
+import tkFileDialog
+import tkMessageBox
+import re
+
+#$ event <<open-window-from-file>>
+#$ win <Control-o>
+#$ unix <Control-x><Control-f>
+
+#$ event <<save-window>>
+#$ win <Control-s>
+#$ unix <Control-x><Control-s>
+
+#$ event <<save-window-as-file>>
+#$ win <Alt-s>
+#$ unix <Control-x><Control-w>
+
+#$ event <<save-copy-of-window-as-file>>
+#$ win <Alt-Shift-s>
+#$ unix <Control-x><w>
+
+
+class IOBinding:
+
+    def __init__(self, editwin):
+        self.editwin = editwin
+        self.text = editwin.text
+        self.__id_open = self.text.bind("<<open-window-from-file>>", self.open)
+        self.__id_save = self.text.bind("<<save-window>>", self.save)
+        self.__id_saveas = self.text.bind("<<save-window-as-file>>",
+                                          self.save_as)
+        self.__id_savecopy = self.text.bind("<<save-copy-of-window-as-file>>",
+                                            self.save_a_copy)
+
+    def close(self):
+        # Undo command bindings
+        self.text.unbind("<<open-window-from-file>>", self.__id_open)
+        self.text.unbind("<<save-window>>", self.__id_save)
+        self.text.unbind("<<save-window-as-file>>",self.__id_saveas)
+        self.text.unbind("<<save-copy-of-window-as-file>>", self.__id_savecopy)
+        # Break cycles
+        self.editwin = None
+        self.text = None
+        self.filename_change_hook = None
+
+    def get_saved(self):
+        return self.editwin.get_saved()
+
+    def set_saved(self, flag):
+        self.editwin.set_saved(flag)
+
+    def reset_undo(self):
+        self.editwin.reset_undo()
+
+    filename_change_hook = None
+
+    def set_filename_change_hook(self, hook):
+        self.filename_change_hook = hook
+
+    filename = None
+
+    def set_filename(self, filename):
+        self.filename = filename
+        self.set_saved(1)
+        if self.filename_change_hook:
+            self.filename_change_hook()
+
+    def open(self, event):
+        if self.editwin.flist:
+            filename = self.askopenfile()
+            if filename:
+                # if the current window has no filename and hasn't been
+                #   modified, we replace it's contents (no loss).  Otherwise
+                #   we open a new window.
+                if not self.filename and self.get_saved():
+                    self.editwin.flist.open(filename, self.loadfile)
+                else:
+                    self.editwin.flist.open(filename)
+            else:
+                self.text.focus_set()
+
+            return "break"
+        # Code for use outside IDLE:
+        if self.get_saved():
+            reply = self.maybesave()
+            if reply == "cancel":
+                self.text.focus_set()
+                return "break"
+        filename = self.askopenfile()
+        if filename:
+            self.loadfile(filename)
+        else:
+            self.text.focus_set()
+        return "break"
+
+    def loadfile(self, filename):
+        try:
+            # open the file in binary mode so that we can handle
+            #   end-of-line convention ourselves.
+            f = open(filename,'rb')
+            chars = f.read()
+            f.close()
+        except IOError, msg:
+            tkMessageBox.showerror("I/O Error", str(msg), master=self.text)
+            return 0
+
+        # We now convert all end-of-lines to '\n's
+        eol = r"(\r\n)|\n|\r"  # \r\n (Windows), \n (UNIX), or \r (Mac)
+        chars = re.compile( eol ).sub( r"\n", chars )
+
+        self.text.delete("1.0", "end")
+        self.set_filename(None)
+        self.text.insert("1.0", chars)
+        self.reset_undo()
+        self.set_filename(filename)
+        self.text.mark_set("insert", "1.0")
+        self.text.see("insert")
+        return 1
+
+    def maybesave(self):
+        if self.get_saved():
+            return "yes"
+        message = "Do you want to save %s before closing?" % (
+            self.filename or "this untitled document")
+        m = tkMessageBox.Message(
+            title="Save On Close",
+            message=message,
+            icon=tkMessageBox.QUESTION,
+            type=tkMessageBox.YESNOCANCEL,
+            master=self.text)
+        reply = m.show()
+        if reply == "yes":
+            self.save(None)
+            if not self.get_saved():
+                reply = "cancel"
+        self.text.focus_set()
+        return reply
+
+    def save(self, event):
+        if not self.filename:
+            self.save_as(event)
+        else:
+            if self.writefile(self.filename):
+                self.set_saved(1)
+        self.text.focus_set()
+        return "break"
+
+    def save_as(self, event):
+        filename = self.asksavefile()
+        if filename:
+            if self.writefile(filename):
+                self.set_filename(filename)
+                self.set_saved(1)
+        self.text.focus_set()
+        return "break"
+
+    def save_a_copy(self, event):
+        filename = self.asksavefile()
+        if filename:
+            self.writefile(filename)
+        self.text.focus_set()
+        return "break"
+
+    def writefile(self, filename):
+        self.fixlastline()
+        try:
+            f = open(filename, "w")
+            chars = self.text.get("1.0", "end-1c")
+            f.write(chars)
+            f.close()
+            ## print "saved to", `filename`
+            return 1
+        except IOError, msg:
+            tkMessageBox.showerror("I/O Error", str(msg),
+                                   master=self.text)
+            return 0
+
+    def fixlastline(self):
+        c = self.text.get("end-2c")
+        if c != '\n':
+            self.text.insert("end-1c", "\n")
+
+    opendialog = None
+    savedialog = None
+
+    filetypes = [
+        ("Python and text files", "*.py *.pyw *.txt", "TEXT"),
+        ("All text files", "*", "TEXT"),
+        ("All files", "*"),
+        ]
+
+    def askopenfile(self):
+        dir, base = self.defaultfilename("open")
+        if not self.opendialog:
+            self.opendialog = tkFileDialog.Open(master=self.text,
+                                                filetypes=self.filetypes)
+        return self.opendialog.show(initialdir=dir, initialfile=base)
+
+    def defaultfilename(self, mode="open"):
+        if self.filename:
+            return os.path.split(self.filename)
+        else:
+            try:
+                pwd = os.getcwd()
+            except os.error:
+                pwd = ""
+            return pwd, ""
+
+    def asksavefile(self):
+        dir, base = self.defaultfilename("save")
+        if not self.savedialog:
+            self.savedialog = tkFileDialog.SaveAs(master=self.text,
+                                                  filetypes=self.filetypes)
+        return self.savedialog.show(initialdir=dir, initialfile=base)
+
+
+def test():
+    from Tkinter import *
+    root = Tk()
+    class MyEditWin:
+        def __init__(self, text):
+            self.text = text
+            self.flist = None
+            self.text.bind("<Control-o>", self.open)
+            self.text.bind("<Control-s>", self.save)
+            self.text.bind("<Alt-s>", self.save_as)
+            self.text.bind("<Alt-z>", self.save_a_copy)
+        def get_saved(self): return 0
+        def set_saved(self, flag): pass
+        def reset_undo(self): pass
+        def open(self, event):
+            self.text.event_generate("<<open-window-from-file>>")
+        def save(self, event):
+            self.text.event_generate("<<save-window>>")
+        def save_as(self, event):
+            self.text.event_generate("<<save-window-as-file>>")
+        def save_a_copy(self, event):
+            self.text.event_generate("<<save-copy-of-window-as-file>>")
+    text = Text(root)
+    text.pack()
+    text.focus_set()
+    editwin = MyEditWin(text)
+    io = IOBinding(editwin)
+    root.mainloop()
+
+if __name__ == "__main__":
+    test()
diff --git a/Lib/idlelib/Icons/folder.gif b/Lib/idlelib/Icons/folder.gif
new file mode 100644
index 0000000..effe8dc
--- /dev/null
+++ b/Lib/idlelib/Icons/folder.gif
Binary files differ
diff --git a/Lib/idlelib/Icons/minusnode.gif b/Lib/idlelib/Icons/minusnode.gif
new file mode 100644
index 0000000..6cca2bf
--- /dev/null
+++ b/Lib/idlelib/Icons/minusnode.gif
Binary files differ
diff --git a/Lib/idlelib/Icons/openfolder.gif b/Lib/idlelib/Icons/openfolder.gif
new file mode 100644
index 0000000..24aea1b
--- /dev/null
+++ b/Lib/idlelib/Icons/openfolder.gif
Binary files differ
diff --git a/Lib/idlelib/Icons/plusnode.gif b/Lib/idlelib/Icons/plusnode.gif
new file mode 100644
index 0000000..13ace90
--- /dev/null
+++ b/Lib/idlelib/Icons/plusnode.gif
Binary files differ
diff --git a/Lib/idlelib/Icons/python.gif b/Lib/idlelib/Icons/python.gif
new file mode 100644
index 0000000..a7df778
--- /dev/null
+++ b/Lib/idlelib/Icons/python.gif
Binary files differ
diff --git a/Lib/idlelib/Icons/tk.gif b/Lib/idlelib/Icons/tk.gif
new file mode 100644
index 0000000..a603f5e
--- /dev/null
+++ b/Lib/idlelib/Icons/tk.gif
Binary files differ
diff --git a/Lib/idlelib/IdleConf.py b/Lib/idlelib/IdleConf.py
new file mode 100644
index 0000000..36cad51
--- /dev/null
+++ b/Lib/idlelib/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()
+
diff --git a/Lib/idlelib/IdleHistory.py b/Lib/idlelib/IdleHistory.py
new file mode 100644
index 0000000..aa41b73
--- /dev/null
+++ b/Lib/idlelib/IdleHistory.py
@@ -0,0 +1,89 @@
+import string
+
+class History:
+
+    def __init__(self, text, output_sep = "\n"):
+        self.text = text
+        self.history = []
+        self.history_prefix = None
+        self.history_pointer = None
+        self.output_sep = output_sep
+        text.bind("<<history-previous>>", self.history_prev)
+        text.bind("<<history-next>>", self.history_next)
+
+    def history_next(self, event):
+        self.history_do(0)
+        return "break"
+
+    def history_prev(self, event):
+        self.history_do(1)
+        return "break"
+
+    def _get_source(self, start, end):
+        # Get source code from start index to end index.  Lines in the
+        # text control may be separated by sys.ps2 .
+        lines = string.split(self.text.get(start, end), self.output_sep)
+        return string.join(lines, "\n")
+
+    def _put_source(self, where, source):
+        output = string.join(string.split(source, "\n"), self.output_sep)
+        self.text.insert(where, output)
+
+    def history_do(self, reverse):
+        nhist = len(self.history)
+        pointer = self.history_pointer
+        prefix = self.history_prefix
+        if pointer is not None and prefix is not None:
+            if self.text.compare("insert", "!=", "end-1c") or \
+               self._get_source("iomark", "end-1c") != self.history[pointer]:
+                pointer = prefix = None
+        if pointer is None or prefix is None:
+            prefix = self._get_source("iomark", "end-1c")
+            if reverse:
+                pointer = nhist
+            else:
+                pointer = -1
+        nprefix = len(prefix)
+        while 1:
+            if reverse:
+                pointer = pointer - 1
+            else:
+                pointer = pointer + 1
+            if pointer < 0 or pointer >= nhist:
+                self.text.bell()
+                if self._get_source("iomark", "end-1c") != prefix:
+                    self.text.delete("iomark", "end-1c")
+                    self._put_source("iomark", prefix)
+                pointer = prefix = None
+                break
+            item = self.history[pointer]
+            if item[:nprefix] == prefix and len(item) > nprefix:
+                self.text.delete("iomark", "end-1c")
+                self._put_source("iomark", item)
+                break
+        self.text.mark_set("insert", "end-1c")
+        self.text.see("insert")
+        self.text.tag_remove("sel", "1.0", "end")
+        self.history_pointer = pointer
+        self.history_prefix = prefix
+
+    def history_store(self, source):
+        source = string.strip(source)
+        if len(source) > 2:
+            # avoid duplicates
+            try:
+                self.history.remove(source)
+            except ValueError:
+                pass
+            self.history.append(source)
+        self.history_pointer = None
+        self.history_prefix = None
+
+    def recall(self, s):
+        s = string.strip(s)
+        self.text.tag_remove("sel", "1.0", "end")
+        self.text.delete("iomark", "end-1c")
+        self.text.mark_set("insert", "end-1c")
+        self.text.insert("insert", s)
+        self.text.see("insert")
+
diff --git a/Lib/idlelib/MultiScrolledLists.py b/Lib/idlelib/MultiScrolledLists.py
new file mode 100644
index 0000000..32f6246
--- /dev/null
+++ b/Lib/idlelib/MultiScrolledLists.py
@@ -0,0 +1,138 @@
+# 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.
+
+import string
+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/Lib/idlelib/MultiStatusBar.py b/Lib/idlelib/MultiStatusBar.py
new file mode 100644
index 0000000..c11db3e
--- /dev/null
+++ b/Lib/idlelib/MultiStatusBar.py
@@ -0,0 +1,32 @@
+from Tkinter import *
+
+class MultiStatusBar(Frame):
+	
+	def __init__(self, master=None, **kw):
+		if master is None:
+			master = Tk()
+		apply(Frame.__init__, (self, master), kw)
+		self.labels = {}
+
+	def set_label(self, name, text='', side=LEFT):
+		if not self.labels.has_key(name):
+			label = Label(self, bd=1, relief=SUNKEN, anchor=W)
+			label.pack(side=side)
+			self.labels[name] = label
+		else:
+			label = self.labels[name]
+		label.config(text=text)
+
+def _test():
+	b = Frame()
+	c = Text(b)
+	c.pack(side=TOP)
+	a = MultiStatusBar(b)
+	a.set_label("one", "hello")
+	a.set_label("two", "world")
+	a.pack(side=BOTTOM, fill=X)
+	b.pack()
+	b.mainloop()
+
+if __name__ == '__main__':
+	_test()
diff --git a/Lib/idlelib/NEWS.txt b/Lib/idlelib/NEWS.txt
new file mode 100644
index 0000000..86cbc76
--- /dev/null
+++ b/Lib/idlelib/NEWS.txt
@@ -0,0 +1,130 @@
+(For a more detailed change log, see the file ChangeLog.)
+
+----------------------------------------------------------------------
+
+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/Lib/idlelib/ObjectBrowser.py b/Lib/idlelib/ObjectBrowser.py
new file mode 100644
index 0000000..94b59d6
--- /dev/null
+++ b/Lib/idlelib/ObjectBrowser.py
@@ -0,0 +1,151 @@
+# XXX TO DO:
+# - popup menu
+# - support partial or total redisplay
+# - more doc strings
+# - tooltips
+
+# object browser
+
+# XXX TO DO:
+# - for classes/modules, add "open source" to object browser
+
+from TreeWidget import TreeItem, TreeNode, ScrolledCanvas
+
+from repr import Repr
+
+myrepr = Repr()
+myrepr.maxstring = 100
+myrepr.maxother = 100
+
+class ObjectTreeItem(TreeItem):
+    def __init__(self, labeltext, object, setfunction=None):
+        self.labeltext = labeltext
+        self.object = object
+        self.setfunction = setfunction
+    def GetLabelText(self):
+        return self.labeltext
+    def GetText(self):
+        return myrepr.repr(self.object)
+    def GetIconName(self):
+        if not self.IsExpandable():
+            return "python"
+    def IsEditable(self):
+        return self.setfunction is not None
+    def SetText(self, text):
+        try:
+            value = eval(text)
+            self.setfunction(value)
+        except:
+            pass
+        else:
+            self.object = value
+    def IsExpandable(self):
+        return not not dir(self.object)
+    def GetSubList(self):
+        keys = dir(self.object)
+        sublist = []
+        for key in keys:
+            try:
+                value = getattr(self.object, key)
+            except AttributeError:
+                continue
+            item = make_objecttreeitem(
+                str(key) + " =",
+                value,
+                lambda value, key=key, object=self.object:
+                    setattr(object, key, value))
+            sublist.append(item)
+        return sublist
+
+class InstanceTreeItem(ObjectTreeItem):
+    def IsExpandable(self):
+        return 1
+    def GetSubList(self):
+        sublist = ObjectTreeItem.GetSubList(self)
+        sublist.insert(0,
+            make_objecttreeitem("__class__ =", self.object.__class__))
+        return sublist
+
+class ClassTreeItem(ObjectTreeItem):
+    def IsExpandable(self):
+        return 1
+    def GetSubList(self):
+        sublist = ObjectTreeItem.GetSubList(self)
+        if len(self.object.__bases__) == 1:
+            item = make_objecttreeitem("__bases__[0] =",
+                self.object.__bases__[0])
+        else:
+            item = make_objecttreeitem("__bases__ =", self.object.__bases__)
+        sublist.insert(0, item)
+        return sublist
+
+class AtomicObjectTreeItem(ObjectTreeItem):
+    def IsExpandable(self):
+        return 0
+
+class SequenceTreeItem(ObjectTreeItem):
+    def IsExpandable(self):
+        return len(self.object) > 0
+    def keys(self):
+        return range(len(self.object))
+    def GetSubList(self):
+        sublist = []
+        for key in self.keys():
+            try:
+                value = self.object[key]
+            except KeyError:
+                continue
+            def setfunction(value, key=key, object=self.object):
+                object[key] = value
+            item = make_objecttreeitem(`key` + ":", value, setfunction)
+            sublist.append(item)
+        return sublist
+
+class DictTreeItem(SequenceTreeItem):
+    def keys(self):
+        keys = self.object.keys()
+        try:
+            keys.sort()
+        except:
+            pass
+        return keys
+
+from types import *
+
+dispatch = {
+    IntType: AtomicObjectTreeItem,
+    LongType: AtomicObjectTreeItem,
+    FloatType: AtomicObjectTreeItem,
+    StringType: AtomicObjectTreeItem,
+    TupleType: SequenceTreeItem,
+    ListType: SequenceTreeItem,
+    DictType: DictTreeItem,
+    InstanceType: InstanceTreeItem,
+    ClassType: ClassTreeItem,
+}
+
+def make_objecttreeitem(labeltext, object, setfunction=None):
+    t = type(object)
+    if dispatch.has_key(t):
+        c = dispatch[t]
+    else:
+        c = ObjectTreeItem
+    return c(labeltext, object, setfunction)
+
+# Test script
+
+def test():
+    import sys
+    from Tkinter import Toplevel
+    import PyShell
+    root = Toplevel(PyShell.root)
+    root.configure(bd=0, bg="yellow")
+    root.focus_set()
+    sc = ScrolledCanvas(root, bg="white", highlightthickness=0, takefocus=1)
+    sc.frame.pack(expand=1, fill="both")
+    item = make_objecttreeitem("sys", sys)
+    node = TreeNode(sc.canvas, None, item)
+    node.expand()
+
+if __name__ == '__main__':
+    test()
diff --git a/Lib/idlelib/OldStackViewer.py b/Lib/idlelib/OldStackViewer.py
new file mode 100644
index 0000000..2fa4127
--- /dev/null
+++ b/Lib/idlelib/OldStackViewer.py
@@ -0,0 +1,276 @@
+import string
+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 = string.strip(sourceline)
+            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/Lib/idlelib/OutputWindow.py b/Lib/idlelib/OutputWindow.py
new file mode 100644
index 0000000..12280ad
--- /dev/null
+++ b/Lib/idlelib/OutputWindow.py
@@ -0,0 +1,279 @@
+# changes by dscherer@cmu.edu
+#   - OutputWindow and OnDemandOutputWindow have been hastily
+#     extended to provide readline() support, an "iomark" separate
+#     from the "insert" cursor, and scrolling to clear the window.
+#     These changes are used by the ExecBinding module to provide
+#     standard input and output for user programs.  Many of the new
+#     features are very similar to features of PyShell, which is a
+#     subclass of OutputWindow.  Someone should make some sense of
+#     this.
+
+from Tkinter import *
+from EditorWindow import EditorWindow
+import re
+import tkMessageBox
+
+from UndoDelegator import UndoDelegator
+
+class OutputUndoDelegator(UndoDelegator):
+    reading = 0
+    # Forbid insert/delete before the I/O mark, in the blank lines after
+    #   the output, or *anywhere* if we are not presently doing user input
+    def insert(self, index, chars, tags=None):
+        try:
+            if (self.delegate.compare(index, "<", "iomark") or
+                self.delegate.compare(index, ">", "endmark") or
+                (index!="iomark" and not self.reading)):
+                self.delegate.bell()
+                return
+        except TclError:
+            pass
+        UndoDelegator.insert(self, index, chars, tags)
+    def delete(self, index1, index2=None):
+        try:
+            if (self.delegate.compare(index1, "<", "iomark") or
+                self.delegate.compare(index1, ">", "endmark") or
+                (index2 and self.delegate.compare(index2, ">=", "endmark")) or
+                not self.reading):
+                self.delegate.bell()
+                return
+        except TclError:
+            pass
+        UndoDelegator.delete(self, index1, index2)
+
+class OutputWindow(EditorWindow):
+    """An editor window that can serve as an input and output file.
+       The input support has been rather hastily hacked in, and should
+       not be trusted.
+    """
+
+    UndoDelegator = OutputUndoDelegator
+    source_window = None
+
+    def __init__(self, *args, **keywords):
+        if keywords.has_key('source_window'):
+            self.source_window = keywords['source_window']
+        apply(EditorWindow.__init__, (self,) + args)
+        self.text.bind("<<goto-file-line>>", self.goto_file_line)
+        self.text.bind("<<newline-and-indent>>", self.enter_callback)
+        self.text.mark_set("iomark","1.0")
+        self.text.mark_gravity("iomark", LEFT)
+        self.text.mark_set("endmark","1.0")
+
+    # Customize EditorWindow
+
+    def ispythonsource(self, filename):
+        # No colorization needed
+        return 0
+
+    def short_title(self):
+        return "Output"
+
+    def long_title(self):
+        return ""
+
+    def maybesave(self):
+        # Override base class method -- don't ask any questions
+        if self.get_saved():
+            return "yes"
+        else:
+            return "no"
+
+    # Act as input file - incomplete
+
+    def set_line_and_column(self, event=None):
+        index = self.text.index(INSERT)
+        if (self.text.compare(index, ">", "endmark")):
+          self.text.mark_set("insert", "endmark")
+        self.text.see("insert")
+        EditorWindow.set_line_and_column(self)
+
+    reading = 0
+    canceled = 0
+    endoffile = 0
+
+    def readline(self):
+        save = self.reading
+        try:
+            self.reading = self.undo.reading = 1
+            self.text.mark_set("insert", "iomark")
+            self.text.see("insert")
+            self.top.mainloop()
+        finally:
+            self.reading = self.undo.reading = save
+        line = self.text.get("input", "iomark")
+        if self.canceled:
+            self.canceled = 0
+            raise KeyboardInterrupt
+        if self.endoffile:
+            self.endoffile = 0
+            return ""
+        return line or '\n'
+
+    def close(self):
+        self.interrupt()
+        return EditorWindow.close(self)
+
+    def interrupt(self):
+        if self.reading:
+            self.endoffile = 1
+            self.top.quit()
+
+    def enter_callback(self, event):
+        if self.reading and self.text.compare("insert", ">=", "iomark"):
+            self.text.mark_set("input", "iomark")
+            self.text.mark_set("iomark", "insert")
+            self.write('\n',"iomark")
+            self.text.tag_add("stdin", "input", "iomark")
+            self.text.update_idletasks()
+            self.top.quit() # Break out of recursive mainloop() in raw_input()
+
+        return "break"
+
+    # Act as output file
+
+    def write(self, s, tags=(), mark="iomark"):
+        self.text.mark_gravity(mark, RIGHT)
+        self.text.insert(mark, str(s), tags)
+        self.text.mark_gravity(mark, LEFT)
+        self.text.see(mark)
+        self.text.update()
+
+    def writelines(self, l):
+        map(self.write, l)
+
+    def flush(self):
+        pass
+
+    # Our own right-button menu
+
+    rmenu_specs = [
+        ("Go to file/line", "<<goto-file-line>>"),
+    ]
+
+    file_line_pats = [
+        r'file "([^"]*)", line (\d+)',
+        r'([^\s]+)\((\d+)\)',
+        r'([^\s]+):\s*(\d+):',
+    ]
+
+    file_line_progs = None
+
+    def goto_file_line(self, event=None):
+        if self.file_line_progs is None:
+            l = []
+            for pat in self.file_line_pats:
+                l.append(re.compile(pat, re.IGNORECASE))
+            self.file_line_progs = l
+        # x, y = self.event.x, self.event.y
+        # self.text.mark_set("insert", "@%d,%d" % (x, y))
+        line = self.text.get("insert linestart", "insert lineend")
+        result = self._file_line_helper(line)
+        if not result:
+            # Try the previous line.  This is handy e.g. in tracebacks,
+            # where you tend to right-click on the displayed source line
+            line = self.text.get("insert -1line linestart",
+                                 "insert -1line lineend")
+            result = self._file_line_helper(line)
+            if not result:
+                tkMessageBox.showerror(
+                    "No special line",
+                    "The line you point at doesn't look like "
+                    "a valid file name followed by a line number.",
+                    master=self.text)
+                return
+        filename, lineno = result
+        edit = self.untitled(filename) or self.flist.open(filename)
+        edit.gotoline(lineno)
+        edit.wakeup()
+
+    def untitled(self, filename):
+        if filename!='Untitled' or not self.source_window or self.source_window.io.filename:
+            return None
+        return self.source_window
+
+    def _file_line_helper(self, line):
+        for prog in self.file_line_progs:
+            m = prog.search(line)
+            if m:
+                break
+        else:
+            return None
+        filename, lineno = m.group(1, 2)
+        if not self.untitled(filename):
+            try:
+                f = open(filename, "r")
+                f.close()
+            except IOError:
+                return None
+        try:
+            return filename, int(lineno)
+        except TypeError:
+            return None
+
+# This classes now used by ExecBinding.py:
+
+class OnDemandOutputWindow:
+    source_window = None
+
+    tagdefs = {
+        # XXX Should use IdlePrefs.ColorPrefs
+        "stdin":   {"foreground": "black"},
+        "stdout":  {"foreground": "blue"},
+        "stderr":  {"foreground": "red"},
+    }   
+    
+    def __init__(self, flist):
+        self.flist = flist
+        self.owin = None
+        self.title = "Output"
+        self.close_hook = None
+        self.old_close = None
+
+    def owclose(self):
+        if self.close_hook:
+            self.close_hook()
+        if self.old_close:
+            self.old_close()
+
+    def set_title(self, title):
+        self.title = title
+        if self.owin and self.owin.text:
+          self.owin.saved_change_hook()
+
+    def write(self, s, tags=(), mark="iomark"):
+        if not self.owin or not self.owin.text:
+            self.setup()
+        self.owin.write(s, tags, mark)
+
+    def readline(self):
+        if not self.owin or not self.owin.text:
+            self.setup()
+        return self.owin.readline()
+
+    def scroll_clear(self):
+        if self.owin and self.owin.text:
+           lineno = self.owin.getlineno("endmark")
+           self.owin.text.mark_set("insert","endmark")
+           self.owin.text.yview(float(lineno))
+           self.owin.wakeup()
+    
+    def setup(self):
+        self.owin = owin = OutputWindow(self.flist, source_window = self.source_window)
+        owin.short_title = lambda self=self: self.title
+        text = owin.text
+
+        self.old_close = owin.close_hook
+        owin.close_hook = self.owclose
+
+        # xxx Bad hack: 50 blank lines at the bottom so that
+        #     we can scroll the top of the window to the output
+        #     cursor in scroll_clear().  There must be a better way...
+        owin.text.mark_gravity('endmark', LEFT)
+        owin.text.insert('iomark', '\n'*50)
+        owin.text.mark_gravity('endmark', RIGHT)
+        
+        for tag, cnf in self.tagdefs.items():
+            if cnf:
+                apply(text.tag_configure, (tag,), cnf)
+        text.tag_raise('sel')
diff --git a/Lib/idlelib/ParenMatch.py b/Lib/idlelib/ParenMatch.py
new file mode 100644
index 0000000..a607e49
--- /dev/null
+++ b/Lib/idlelib/ParenMatch.py
@@ -0,0 +1,192 @@
+"""ParenMatch -- An IDLE extension for parenthesis matching.
+
+When you hit a right paren, the cursor should move briefly to the left
+paren.  Paren here is used generically; the matching applies to
+parentheses, square brackets, and curly braces.
+
+WARNING: This extension will fight with the CallTips extension,
+because they both are interested in the KeyRelease-parenright event.
+We'll have to fix IDLE to do something reasonable when two or more
+extensions what to capture the same event.
+"""
+
+import string
+
+import PyParse
+from AutoIndent import AutoIndent, index2line
+from IdleConf import idleconf
+
+class ParenMatch:
+    """Highlight matching parentheses
+
+    There are three supported style of paren matching, based loosely
+    on the Emacs options.  The style is select based on the 
+    HILITE_STYLE attribute; it can be changed used the set_style
+    method.
+
+    The supported styles are:
+
+    default -- When a right paren is typed, highlight the matching
+        left paren for 1/2 sec.
+
+    expression -- When a right paren is typed, highlight the entire
+        expression from the left paren to the right paren.
+
+    TODO:
+        - fix interaction with CallTips
+        - extend IDLE with configuration dialog to change options
+        - implement rest of Emacs highlight styles (see below)
+        - print mismatch warning in IDLE status window
+
+    Note: In Emacs, there are several styles of highlight where the
+    matching paren is highlighted whenever the cursor is immediately
+    to the right of a right paren.  I don't know how to do that in Tk,
+    so I haven't bothered.
+    """
+    
+    menudefs = []
+    
+    keydefs = {
+        '<<flash-open-paren>>' : ('<KeyRelease-parenright>',
+                                  '<KeyRelease-bracketright>',
+                                  '<KeyRelease-braceright>'),
+        '<<check-restore>>' : ('<KeyPress>',),
+    }
+
+    windows_keydefs = {}
+    unix_keydefs = {}
+
+    iconf = idleconf.getsection('ParenMatch')
+    STYLE = iconf.getdef('style', 'default')
+    FLASH_DELAY = iconf.getint('flash-delay')
+    HILITE_CONFIG = iconf.getcolor('hilite')
+    BELL = iconf.getboolean('bell')
+    del iconf
+
+    def __init__(self, editwin):
+        self.editwin = editwin
+        self.text = editwin.text
+        self.finder = LastOpenBracketFinder(editwin)
+        self.counter = 0
+        self._restore = None
+        self.set_style(self.STYLE)
+
+    def set_style(self, style):
+        self.STYLE = style
+        if style == "default":
+            self.create_tag = self.create_tag_default
+            self.set_timeout = self.set_timeout_last
+        elif style == "expression":
+            self.create_tag = self.create_tag_expression
+            self.set_timeout = self.set_timeout_none
+
+    def flash_open_paren_event(self, event):
+        index = self.finder.find(keysym_type(event.keysym))
+        if index is None:
+            self.warn_mismatched()
+            return
+        self._restore = 1
+        self.create_tag(index)
+        self.set_timeout()
+
+    def check_restore_event(self, event=None):
+        if self._restore:
+            self.text.tag_delete("paren")
+            self._restore = None
+
+    def handle_restore_timer(self, timer_count):
+        if timer_count + 1 == self.counter:
+            self.check_restore_event()
+
+    def warn_mismatched(self):
+        if self.BELL:
+            self.text.bell()
+
+    # any one of the create_tag_XXX methods can be used depending on
+    # the style
+
+    def create_tag_default(self, index):
+        """Highlight the single paren that matches"""
+        self.text.tag_add("paren", index)
+        self.text.tag_config("paren", self.HILITE_CONFIG)
+
+    def create_tag_expression(self, index):
+        """Highlight the entire expression"""
+        self.text.tag_add("paren", index, "insert")
+        self.text.tag_config("paren", self.HILITE_CONFIG)
+
+    # any one of the set_timeout_XXX methods can be used depending on
+    # the style
+
+    def set_timeout_none(self):
+        """Highlight will remain until user input turns it off"""
+        pass
+
+    def set_timeout_last(self):
+        """The last highlight created will be removed after .5 sec"""
+        # associate a counter with an event; only disable the "paren"
+        # tag if the event is for the most recent timer.
+        self.editwin.text_frame.after(self.FLASH_DELAY,
+                                      lambda self=self, c=self.counter: \
+                                      self.handle_restore_timer(c))
+        self.counter = self.counter + 1
+
+def keysym_type(ks):
+    # Not all possible chars or keysyms are checked because of the
+    # limited context in which the function is used.
+    if ks == "parenright" or ks == "(":
+        return "paren"
+    if ks == "bracketright" or ks == "[":
+        return "bracket"
+    if ks == "braceright" or ks == "{":
+        return "brace"
+
+class LastOpenBracketFinder:
+    num_context_lines = AutoIndent.num_context_lines
+    indentwidth = AutoIndent.indentwidth
+    tabwidth = AutoIndent.tabwidth
+    context_use_ps1 = AutoIndent.context_use_ps1
+    
+    def __init__(self, editwin):
+        self.editwin = editwin
+        self.text = editwin.text
+
+    def _find_offset_in_buf(self, lno):
+        y = PyParse.Parser(self.indentwidth, self.tabwidth)
+        for context in self.num_context_lines:
+            startat = max(lno - context, 1)
+            startatindex = `startat` + ".0"
+            # rawtext needs to contain everything up to the last
+            # character, which was the close paren.  the parser also
+	    # requires that the last line ends with "\n"
+            rawtext = self.text.get(startatindex, "insert")[:-1] + "\n"
+            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)
+        i = y.get_last_open_bracket_pos()
+        return i, y.str
+
+    def find(self, right_keysym_type):
+        """Return the location of the last open paren"""
+        lno = index2line(self.text.index("insert"))
+        i, buf = self._find_offset_in_buf(lno)
+        if i is None \
+	   or keysym_type(buf[i]) != right_keysym_type:
+            return None
+        lines_back = string.count(buf[i:], "\n") - 1
+        # subtract one for the "\n" added to please the parser
+        upto_open = buf[:i]
+        j = string.rfind(upto_open, "\n") + 1 # offset of column 0 of line
+        offset = i - j
+        return "%d.%d" % (lno - lines_back, 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
+
diff --git a/Lib/idlelib/PathBrowser.py b/Lib/idlelib/PathBrowser.py
new file mode 100644
index 0000000..7ea2410
--- /dev/null
+++ b/Lib/idlelib/PathBrowser.py
@@ -0,0 +1,95 @@
+import os
+import sys
+import imp
+
+from TreeWidget import TreeItem
+from ClassBrowser import ClassBrowser, ModuleBrowserTreeItem
+
+class PathBrowser(ClassBrowser):
+    
+    def __init__(self, flist):
+        self.init(flist)
+
+    def settitle(self):
+        self.top.wm_title("Path Browser")
+        self.top.wm_iconname("Path Browser")
+
+    def rootnode(self):
+        return PathBrowserTreeItem()
+
+class PathBrowserTreeItem(TreeItem):
+
+    def GetText(self):
+        return "sys.path"
+
+    def GetSubList(self):
+        sublist = []
+        for dir in sys.path:
+            item = DirBrowserTreeItem(dir)
+            sublist.append(item)
+        return sublist
+
+class DirBrowserTreeItem(TreeItem):
+
+    def __init__(self, dir, packages=[]):
+        self.dir = dir
+        self.packages = packages
+
+    def GetText(self):
+        if not self.packages:
+            return self.dir
+        else:
+            return self.packages[-1] + ": package"
+
+    def GetSubList(self):
+        try:
+            names = os.listdir(self.dir or os.curdir)
+        except os.error:
+            return []
+        packages = []
+        for name in names:
+            file = os.path.join(self.dir, name)
+            if self.ispackagedir(file):
+                nn = os.path.normcase(name)
+                packages.append((nn, name, file))
+        packages.sort()
+        sublist = []
+        for nn, name, file in packages:
+            item = DirBrowserTreeItem(file, self.packages + [name])
+            sublist.append(item)
+        for nn, name in self.listmodules(names):
+            item = ModuleBrowserTreeItem(os.path.join(self.dir, name))
+            sublist.append(item)
+        return sublist
+
+    def ispackagedir(self, file):
+        if not os.path.isdir(file):
+            return 0
+        init = os.path.join(file, "__init__.py")
+        return os.path.exists(init)
+
+    def listmodules(self, allnames):
+        modules = {}
+        suffixes = imp.get_suffixes()
+        sorted = []
+        for suff, mode, flag in suffixes:
+            i = -len(suff)
+            for name in allnames[:]:
+                normed_name = os.path.normcase(name)
+                if normed_name[i:] == suff:
+                    mod_name = name[:i]
+                    if not modules.has_key(mod_name):
+                        modules[mod_name] = None
+                        sorted.append((normed_name, name))
+                        allnames.remove(name)
+        sorted.sort()
+        return sorted
+
+def main():
+    import PyShell
+    PathBrowser(PyShell.flist)
+    if sys.stdin is sys.__stdin__:
+        mainloop()
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/idlelib/Percolator.py b/Lib/idlelib/Percolator.py
new file mode 100644
index 0000000..9def5f4
--- /dev/null
+++ b/Lib/idlelib/Percolator.py
@@ -0,0 +1,85 @@
+from WidgetRedirector import WidgetRedirector
+from Delegator import Delegator
+
+class Percolator:
+
+    def __init__(self, text):
+        # XXX would be nice to inherit from Delegator
+        self.text = text
+        self.redir = WidgetRedirector(text)
+        self.top = self.bottom = Delegator(text)
+        self.bottom.insert = self.redir.register("insert", self.insert)
+        self.bottom.delete = self.redir.register("delete", self.delete)
+        self.filters = []
+
+    def close(self):
+        while self.top is not self.bottom:
+            self.removefilter(self.top)
+        self.top = None
+        self.bottom.setdelegate(None); self.bottom = None
+        self.redir.close(); self.redir = None
+        self.text = None
+
+    def insert(self, index, chars, tags=None):
+        # Could go away if inheriting from Delegator
+        self.top.insert(index, chars, tags)
+
+    def delete(self, index1, index2=None):
+        # Could go away if inheriting from Delegator
+        self.top.delete(index1, index2)
+
+    def insertfilter(self, filter):
+        # Perhaps rename to pushfilter()?
+        assert isinstance(filter, Delegator)
+        assert filter.delegate is None
+        filter.setdelegate(self.top)
+        self.top = filter
+
+    def removefilter(self, filter):
+        # XXX Perhaps should only support popfilter()?
+        assert isinstance(filter, Delegator)
+        assert filter.delegate is not None
+        f = self.top
+        if f is filter:
+            self.top = filter.delegate
+            filter.setdelegate(None)
+        else:
+            while f.delegate is not filter:
+                assert f is not self.bottom
+                f.resetcache()
+                f = f.delegate
+            f.setdelegate(filter.delegate)
+            filter.setdelegate(None)
+
+
+def main():
+    class Tracer(Delegator):
+        def __init__(self, name):
+            self.name = name
+            Delegator.__init__(self, None)
+        def insert(self, *args):
+            print self.name, ": insert", args
+            apply(self.delegate.insert, args)
+        def delete(self, *args):
+            print self.name, ": delete", args
+            apply(self.delegate.delete, args)
+    from Tkinter import *
+    root = Tk()
+    root.wm_protocol("WM_DELETE_WINDOW", root.quit)
+    text = Text()
+    text.pack()
+    text.focus_set()
+    p = Percolator(text)
+    t1 = Tracer("t1")
+    t2 = Tracer("t2")
+    p.insertfilter(t1)
+    p.insertfilter(t2)
+    root.mainloop()
+    p.removefilter(t2)
+    root.mainloop()
+    p.insertfilter(t2)
+    p.removefilter(t1)
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/idlelib/PyParse.py b/Lib/idlelib/PyParse.py
new file mode 100644
index 0000000..23b995c
--- /dev/null
+++ b/Lib/idlelib/PyParse.py
@@ -0,0 +1,569 @@
+import string
+import re
+import sys
+
+# Reason last stmt is continued (or C_NONE if it's not).
+C_NONE, C_BACKSLASH, C_STRING, C_BRACKET = range(4)
+
+if 0:   # for throwaway debugging output
+    def dump(*stuff):
+        sys.__stdout__.write(string.join(map(str, stuff), " ") + "\n")
+
+# Find what looks like the start of a popular stmt.
+
+_synchre = re.compile(r"""
+    ^
+    [ \t]*
+    (?: if
+    |   for
+    |   while
+    |   else
+    |   def
+    |   return
+    |   assert
+    |   break
+    |   class
+    |   continue
+    |   elif
+    |   try
+    |   except
+    |   raise
+    |   import
+    )
+    \b
+""", re.VERBOSE | re.MULTILINE).search
+
+# Match blank line or non-indenting comment line.
+
+_junkre = re.compile(r"""
+    [ \t]*
+    (?: \# \S .* )?
+    \n
+""", re.VERBOSE).match
+
+# Match any flavor of string; the terminating quote is optional
+# so that we're robust in the face of incomplete program text.
+
+_match_stringre = re.compile(r"""
+    \""" [^"\\]* (?:
+                     (?: \\. | "(?!"") )
+                     [^"\\]*
+                 )*
+    (?: \""" )?
+
+|   " [^"\\\n]* (?: \\. [^"\\\n]* )* "?
+
+|   ''' [^'\\]* (?:
+                   (?: \\. | '(?!'') )
+                   [^'\\]*
+                )*
+    (?: ''' )?
+
+|   ' [^'\\\n]* (?: \\. [^'\\\n]* )* '?
+""", re.VERBOSE | re.DOTALL).match
+
+# Match a line that starts with something interesting;
+# used to find the first item of a bracket structure.
+
+_itemre = re.compile(r"""
+    [ \t]*
+    [^\s#\\]    # if we match, m.end()-1 is the interesting char
+""", re.VERBOSE).match
+
+# Match start of stmts that should be followed by a dedent.
+
+_closere = re.compile(r"""
+    \s*
+    (?: return
+    |   break
+    |   continue
+    |   raise
+    |   pass
+    )
+    \b
+""", re.VERBOSE).match
+
+# Chew up non-special chars as quickly as possible.  If match is
+# successful, m.end() less 1 is the index of the last boring char
+# matched.  If match is unsuccessful, the string starts with an
+# interesting char.
+
+_chew_ordinaryre = re.compile(r"""
+    [^[\](){}#'"\\]+
+""", re.VERBOSE).match
+
+# Build translation table to map uninteresting chars to "x", open
+# brackets to "(", and close brackets to ")".
+
+_tran = ['x'] * 256
+for ch in "({[":
+    _tran[ord(ch)] = '('
+for ch in ")}]":
+    _tran[ord(ch)] = ')'
+for ch in "\"'\\\n#":
+    _tran[ord(ch)] = ch
+_tran = string.join(_tran, '')
+del ch
+
+class Parser:
+
+    def __init__(self, indentwidth, tabwidth):
+        self.indentwidth = indentwidth
+        self.tabwidth = tabwidth
+
+    def set_str(self, str):
+        assert len(str) == 0 or str[-1] == '\n'
+        self.str = str
+        self.study_level = 0
+
+    # Return index of a good place to begin parsing, as close to the
+    # end of the string as possible.  This will be the start of some
+    # popular stmt like "if" or "def".  Return None if none found:
+    # the caller should pass more prior context then, if possible, or
+    # if not (the entire program text up until the point of interest
+    # has already been tried) pass 0 to set_lo.
+    #
+    # This will be reliable iff given a reliable is_char_in_string
+    # function, meaning that when it says "no", it's absolutely
+    # guaranteed that the char is not in a string.
+    #
+    # Ack, hack: in the shell window this kills us, because there's
+    # no way to tell the differences between output, >>> etc and
+    # user input.  Indeed, IDLE's first output line makes the rest
+    # look like it's in an unclosed paren!:
+    # Python 1.5.2 (#0, Apr 13 1999, ...
+
+    def find_good_parse_start(self, use_ps1, is_char_in_string=None,
+                              _rfind=string.rfind,
+                              _synchre=_synchre):
+        str, pos = self.str, None
+        if use_ps1:
+            # shell window
+            ps1 = '\n' + sys.ps1
+            i = _rfind(str, ps1)
+            if i >= 0:
+                pos = i + len(ps1)
+                # make it look like there's a newline instead
+                # of ps1 at the start -- hacking here once avoids
+                # repeated hackery later
+                self.str = str[:pos-1] + '\n' + str[pos:]
+            return pos
+
+        # File window -- real work.
+        if not is_char_in_string:
+            # no clue -- make the caller pass everything
+            return None
+
+        # Peek back from the end for a good place to start,
+        # but don't try too often; pos will be left None, or
+        # bumped to a legitimate synch point.
+        limit = len(str)
+        for tries in range(5):
+            i = _rfind(str, ":\n", 0, limit)
+            if i < 0:
+                break
+            i = _rfind(str, '\n', 0, i) + 1  # start of colon line
+            m = _synchre(str, i, limit)
+            if m and not is_char_in_string(m.start()):
+                pos = m.start()
+                break
+            limit = i
+        if pos is None:
+            # Nothing looks like a block-opener, or stuff does
+            # but is_char_in_string keeps returning true; most likely
+            # we're in or near a giant string, the colorizer hasn't
+            # caught up enough to be helpful, or there simply *aren't*
+            # any interesting stmts.  In any of these cases we're
+            # going to have to parse the whole thing to be sure, so
+            # give it one last try from the start, but stop wasting
+            # time here regardless of the outcome.
+            m = _synchre(str)
+            if m and not is_char_in_string(m.start()):
+                pos = m.start()
+            return pos
+
+        # Peeking back worked; look forward until _synchre no longer
+        # matches.
+        i = pos + 1
+        while 1:
+            m = _synchre(str, i)
+            if m:
+                s, i = m.span()
+                if not is_char_in_string(s):
+                    pos = s
+            else:
+                break
+        return pos
+
+    # Throw away the start of the string.  Intended to be called with
+    # find_good_parse_start's result.
+
+    def set_lo(self, lo):
+        assert lo == 0 or self.str[lo-1] == '\n'
+        if lo > 0:
+            self.str = self.str[lo:]
+
+    # As quickly as humanly possible <wink>, find the line numbers (0-
+    # based) of the non-continuation lines.
+    # Creates self.{goodlines, continuation}.
+
+    def _study1(self, _replace=string.replace, _find=string.find):
+        if self.study_level >= 1:
+            return
+        self.study_level = 1
+
+        # Map all uninteresting characters to "x", all open brackets
+        # to "(", all close brackets to ")", then collapse runs of
+        # uninteresting characters.  This can cut the number of chars
+        # by a factor of 10-40, and so greatly speed the following loop.
+        str = self.str
+        str = string.translate(str, _tran)
+        str = _replace(str, 'xxxxxxxx', 'x')
+        str = _replace(str, 'xxxx', 'x')
+        str = _replace(str, 'xx', 'x')
+        str = _replace(str, 'xx', 'x')
+        str = _replace(str, '\nx', '\n')
+        # note that replacing x\n with \n would be incorrect, because
+        # x may be preceded by a backslash
+
+        # March over the squashed version of the program, accumulating
+        # the line numbers of non-continued stmts, and determining
+        # whether & why the last stmt is a continuation.
+        continuation = C_NONE
+        level = lno = 0     # level is nesting level; lno is line number
+        self.goodlines = goodlines = [0]
+        push_good = goodlines.append
+        i, n = 0, len(str)
+        while i < n:
+            ch = str[i]
+            i = i+1
+
+            # cases are checked in decreasing order of frequency
+            if ch == 'x':
+                continue
+
+            if ch == '\n':
+                lno = lno + 1
+                if level == 0:
+                    push_good(lno)
+                    # else we're in an unclosed bracket structure
+                continue
+
+            if ch == '(':
+                level = level + 1
+                continue
+
+            if ch == ')':
+                if level:
+                    level = level - 1
+                    # else the program is invalid, but we can't complain
+                continue
+
+            if ch == '"' or ch == "'":
+                # consume the string
+                quote = ch
+                if str[i-1:i+2] == quote * 3:
+                    quote = quote * 3
+                w = len(quote) - 1
+                i = i+w
+                while i < n:
+                    ch = str[i]
+                    i = i+1
+
+                    if ch == 'x':
+                        continue
+
+                    if str[i-1:i+w] == quote:
+                        i = i+w
+                        break
+
+                    if ch == '\n':
+                        lno = lno + 1
+                        if w == 0:
+                            # unterminated single-quoted string
+                            if level == 0:
+                                push_good(lno)
+                            break
+                        continue
+
+                    if ch == '\\':
+                        assert i < n
+                        if str[i] == '\n':
+                            lno = lno + 1
+                        i = i+1
+                        continue
+
+                    # else comment char or paren inside string
+
+                else:
+                    # didn't break out of the loop, so we're still
+                    # inside a string
+                    continuation = C_STRING
+                continue    # with outer loop
+
+            if ch == '#':
+                # consume the comment
+                i = _find(str, '\n', i)
+                assert i >= 0
+                continue
+
+            assert ch == '\\'
+            assert i < n
+            if str[i] == '\n':
+                lno = lno + 1
+                if i+1 == n:
+                    continuation = C_BACKSLASH
+            i = i+1
+
+        # The last stmt may be continued for all 3 reasons.
+        # String continuation takes precedence over bracket
+        # continuation, which beats backslash continuation.
+        if continuation != C_STRING and level > 0:
+            continuation = C_BRACKET
+        self.continuation = continuation
+
+        # Push the final line number as a sentinel value, regardless of
+        # whether it's continued.
+        assert (continuation == C_NONE) == (goodlines[-1] == lno)
+        if goodlines[-1] != lno:
+            push_good(lno)
+
+    def get_continuation_type(self):
+        self._study1()
+        return self.continuation
+
+    # study1 was sufficient to determine the continuation status,
+    # but doing more requires looking at every character.  study2
+    # does this for the last interesting statement in the block.
+    # Creates:
+    #     self.stmt_start, stmt_end
+    #         slice indices of last interesting stmt
+    #     self.lastch
+    #         last non-whitespace character before optional trailing
+    #         comment
+    #     self.lastopenbracketpos
+    #         if continuation is C_BRACKET, index of last open bracket
+
+    def _study2(self, _rfind=string.rfind, _find=string.find,
+                      _ws=string.whitespace):
+        if self.study_level >= 2:
+            return
+        self._study1()
+        self.study_level = 2
+
+        # Set p and q to slice indices of last interesting stmt.
+        str, goodlines = self.str, self.goodlines
+        i = len(goodlines) - 1
+        p = len(str)    # index of newest line
+        while i:
+            assert p
+            # p is the index of the stmt at line number goodlines[i].
+            # Move p back to the stmt at line number goodlines[i-1].
+            q = p
+            for nothing in range(goodlines[i-1], goodlines[i]):
+                # tricky: sets p to 0 if no preceding newline
+                p = _rfind(str, '\n', 0, p-1) + 1
+            # The stmt str[p:q] isn't a continuation, but may be blank
+            # or a non-indenting comment line.
+            if  _junkre(str, p):
+                i = i-1
+            else:
+                break
+        if i == 0:
+            # nothing but junk!
+            assert p == 0
+            q = p
+        self.stmt_start, self.stmt_end = p, q
+
+        # Analyze this stmt, to find the last open bracket (if any)
+        # and last interesting character (if any).
+        lastch = ""
+        stack = []  # stack of open bracket indices
+        push_stack = stack.append
+        while p < q:
+            # suck up all except ()[]{}'"#\\
+            m = _chew_ordinaryre(str, p, q)
+            if m:
+                # we skipped at least one boring char
+                p = m.end()
+                # back up over totally boring whitespace
+                i = p-1    # index of last boring char
+                while i >= 0 and str[i] in " \t\n":
+                    i = i-1
+                if i >= 0:
+                    lastch = str[i]
+                if p >= q:
+                    break
+
+            ch = str[p]
+
+            if ch in "([{":
+                push_stack(p)
+                lastch = ch
+                p = p+1
+                continue
+
+            if ch in ")]}":
+                if stack:
+                    del stack[-1]
+                lastch = ch
+                p = p+1
+                continue
+
+            if ch == '"' or ch == "'":
+                # consume string
+                # Note that study1 did this with a Python loop, but
+                # we use a regexp here; the reason is speed in both
+                # cases; the string may be huge, but study1 pre-squashed
+                # strings to a couple of characters per line.  study1
+                # also needed to keep track of newlines, and we don't
+                # have to.
+                lastch = ch
+                p = _match_stringre(str, p, q).end()
+                continue
+
+            if ch == '#':
+                # consume comment and trailing newline
+                p = _find(str, '\n', p, q) + 1
+                assert p > 0
+                continue
+
+            assert ch == '\\'
+            p = p+1     # beyond backslash
+            assert p < q
+            if str[p] != '\n':
+                # the program is invalid, but can't complain
+                lastch = ch + str[p]
+            p = p+1     # beyond escaped char
+
+        # end while p < q:
+
+        self.lastch = lastch
+        if stack:
+            self.lastopenbracketpos = stack[-1]
+
+    # Assuming continuation is C_BRACKET, return the number
+    # of spaces the next line should be indented.
+
+    def compute_bracket_indent(self, _find=string.find):
+        self._study2()
+        assert self.continuation == C_BRACKET
+        j = self.lastopenbracketpos
+        str = self.str
+        n = len(str)
+        origi = i = string.rfind(str, '\n', 0, j) + 1
+        j = j+1     # one beyond open bracket
+        # find first list item; set i to start of its line
+        while j < n:
+            m = _itemre(str, j)
+            if m:
+                j = m.end() - 1     # index of first interesting char
+                extra = 0
+                break
+            else:
+                # this line is junk; advance to next line
+                i = j = _find(str, '\n', j) + 1
+        else:
+            # nothing interesting follows the bracket;
+            # reproduce the bracket line's indentation + a level
+            j = i = origi
+            while str[j] in " \t":
+                j = j+1
+            extra = self.indentwidth
+        return len(string.expandtabs(str[i:j],
+                                     self.tabwidth)) + extra
+
+    # Return number of physical lines in last stmt (whether or not
+    # it's an interesting stmt!  this is intended to be called when
+    # continuation is C_BACKSLASH).
+
+    def get_num_lines_in_stmt(self):
+        self._study1()
+        goodlines = self.goodlines
+        return goodlines[-1] - goodlines[-2]
+
+    # Assuming continuation is C_BACKSLASH, return the number of spaces
+    # the next line should be indented.  Also assuming the new line is
+    # the first one following the initial line of the stmt.
+
+    def compute_backslash_indent(self):
+        self._study2()
+        assert self.continuation == C_BACKSLASH
+        str = self.str
+        i = self.stmt_start
+        while str[i] in " \t":
+            i = i+1
+        startpos = i
+
+        # See whether the initial line starts an assignment stmt; i.e.,
+        # look for an = operator
+        endpos = string.find(str, '\n', startpos) + 1
+        found = level = 0
+        while i < endpos:
+            ch = str[i]
+            if ch in "([{":
+                level = level + 1
+                i = i+1
+            elif ch in ")]}":
+                if level:
+                    level = level - 1
+                i = i+1
+            elif ch == '"' or ch == "'":
+                i = _match_stringre(str, i, endpos).end()
+            elif ch == '#':
+                break
+            elif level == 0 and ch == '=' and \
+                   (i == 0 or str[i-1] not in "=<>!") and \
+                   str[i+1] != '=':
+                found = 1
+                break
+            else:
+                i = i+1
+
+        if found:
+            # found a legit =, but it may be the last interesting
+            # thing on the line
+            i = i+1     # move beyond the =
+            found = re.match(r"\s*\\", str[i:endpos]) is None
+
+        if not found:
+            # oh well ... settle for moving beyond the first chunk
+            # of non-whitespace chars
+            i = startpos
+            while str[i] not in " \t\n":
+                i = i+1
+
+        return len(string.expandtabs(str[self.stmt_start :
+                                         i],
+                                     self.tabwidth)) + 1
+
+    # Return the leading whitespace on the initial line of the last
+    # interesting stmt.
+
+    def get_base_indent_string(self):
+        self._study2()
+        i, n = self.stmt_start, self.stmt_end
+        j = i
+        str = self.str
+        while j < n and str[j] in " \t":
+            j = j + 1
+        return str[i:j]
+
+    # Did the last interesting stmt open a block?
+
+    def is_block_opener(self):
+        self._study2()
+        return self.lastch == ':'
+
+    # Did the last interesting stmt close a block?
+
+    def is_block_closer(self):
+        self._study2()
+        return _closere(self.str, self.stmt_start) is not None
+
+    # index of last open bracket ({[, or None if none
+    lastopenbracketpos = None
+
+    def get_last_open_bracket_pos(self):
+        self._study2()
+        return self.lastopenbracketpos
diff --git a/Lib/idlelib/PyShell.py b/Lib/idlelib/PyShell.py
new file mode 100644
index 0000000..7ae7130
--- /dev/null
+++ b/Lib/idlelib/PyShell.py
@@ -0,0 +1,860 @@
+#! /usr/bin/env python
+
+# changes by dscherer@cmu.edu
+
+#   the main() function has been replaced by a whole class, in order to
+#     address the constraint that only one process can sit on the port
+#     hard-coded into the loader.
+
+#     It attempts to load the RPC protocol server and publish itself.  If
+#     that fails, it assumes that some other copy of IDLE is already running
+#     on the port and attempts to contact it.  It then uses the RPC mechanism
+#     to ask that copy to do whatever it was instructed (via the command
+#     line) to do.  (Think netscape -remote).  The handling of command line
+#     arguments for remotes is still very incomplete.
+
+#   default behavior (no command line options) is to NOT start the Python
+#     Shell.  If files are specified, they are opened, otherwise a single
+#     blank editor window opens.
+
+#   If any command line -options are specified, a shell does appear.  This
+#     is necessary to make the current semantics of the options make sense.
+
+import os
+import spawn
+import sys
+import string
+import getopt
+import re
+import protocol
+
+import linecache
+from code import InteractiveInterpreter
+
+from Tkinter import *
+import tkMessageBox
+
+from EditorWindow import EditorWindow, fixwordbreaks
+from FileList import FileList
+from ColorDelegator import ColorDelegator
+from UndoDelegator import UndoDelegator
+from OutputWindow import OutputWindow, OnDemandOutputWindow
+from IdleConf import idleconf
+import idlever
+
+# We need to patch linecache.checkcache, because we don't want it
+# to throw away our <pyshell#...> entries.
+# Rather than repeating its code here, we save those entries,
+# then call the original function, and then restore the saved entries.
+def linecache_checkcache(orig_checkcache=linecache.checkcache):
+    cache = linecache.cache
+    save = {}
+    for filename in cache.keys():
+        if filename[:1] + filename[-1:] == '<>':
+            save[filename] = cache[filename]
+    orig_checkcache()
+    cache.update(save)
+linecache.checkcache = linecache_checkcache
+
+
+# Note: <<newline-and-indent>> event is defined in AutoIndent.py
+
+#$ event <<plain-newline-and-indent>>
+#$ win <Control-j>
+#$ unix <Control-j>
+
+#$ event <<beginning-of-line>>
+#$ win <Control-a>
+#$ win <Home>
+#$ unix <Control-a>
+#$ unix <Home>
+
+#$ event <<history-next>>
+#$ win <Alt-n>
+#$ unix <Alt-n>
+
+#$ event <<history-previous>>
+#$ win <Alt-p>
+#$ unix <Alt-p>
+
+#$ event <<interrupt-execution>>
+#$ win <Control-c>
+#$ unix <Control-c>
+
+#$ event <<end-of-file>>
+#$ win <Control-d>
+#$ unix <Control-d>
+
+#$ event <<open-stack-viewer>>
+
+#$ event <<toggle-debugger>>
+
+
+class PyShellEditorWindow(EditorWindow):
+
+    # Regular text edit window when a shell is present
+    # XXX ought to merge with regular editor window
+
+    def __init__(self, *args):
+        apply(EditorWindow.__init__, (self,) + args)
+        self.text.bind("<<set-breakpoint-here>>", self.set_breakpoint_here)
+        self.text.bind("<<open-python-shell>>", self.flist.open_shell)
+
+    rmenu_specs = [
+        ("Set breakpoint here", "<<set-breakpoint-here>>"),
+    ]
+
+    def set_breakpoint_here(self, event=None):
+        if not self.flist.pyshell or not self.flist.pyshell.interp.debugger:
+            self.text.bell()
+            return
+        self.flist.pyshell.interp.debugger.set_breakpoint_here(self)
+
+
+class PyShellFileList(FileList):
+
+    # File list when a shell is present
+
+    EditorWindow = PyShellEditorWindow
+
+    pyshell = None
+
+    def open_shell(self, event=None):
+        if self.pyshell:
+            self.pyshell.wakeup()
+        else:
+            self.pyshell = PyShell(self)
+            self.pyshell.begin()
+        return self.pyshell
+
+
+class ModifiedColorDelegator(ColorDelegator):
+
+    # Colorizer for the shell window itself
+
+    def recolorize_main(self):
+        self.tag_remove("TODO", "1.0", "iomark")
+        self.tag_add("SYNC", "1.0", "iomark")
+        ColorDelegator.recolorize_main(self)
+
+    tagdefs = ColorDelegator.tagdefs.copy()
+    cconf = idleconf.getsection('Colors')
+
+    tagdefs.update({
+        "stdin": cconf.getcolor("stdin"),
+        "stdout": cconf.getcolor("stdout"),
+        "stderr": cconf.getcolor("stderr"),
+        "console": cconf.getcolor("console"),
+        "ERROR": cconf.getcolor("ERROR"),
+	None: cconf.getcolor("normal"),
+    })
+
+
+class ModifiedUndoDelegator(UndoDelegator):
+
+    # Forbid insert/delete before the I/O mark
+
+    def insert(self, index, chars, tags=None):
+        try:
+            if self.delegate.compare(index, "<", "iomark"):
+                self.delegate.bell()
+                return
+        except TclError:
+            pass
+        UndoDelegator.insert(self, index, chars, tags)
+
+    def delete(self, index1, index2=None):
+        try:
+            if self.delegate.compare(index1, "<", "iomark"):
+                self.delegate.bell()
+                return
+        except TclError:
+            pass
+        UndoDelegator.delete(self, index1, index2)
+
+class ModifiedInterpreter(InteractiveInterpreter):
+
+    def __init__(self, tkconsole):
+        self.tkconsole = tkconsole
+        locals = sys.modules['__main__'].__dict__
+        InteractiveInterpreter.__init__(self, locals=locals)
+
+    gid = 0
+
+    def execsource(self, source):
+        # Like runsource() but assumes complete exec source
+        filename = self.stuffsource(source)
+        self.execfile(filename, source)
+
+    def execfile(self, filename, source=None):
+        # Execute an existing file
+        if source is None:
+            source = open(filename, "r").read()
+        try:
+            code = compile(source, filename, "exec")
+        except (OverflowError, SyntaxError):
+            self.tkconsole.resetoutput()
+            InteractiveInterpreter.showsyntaxerror(self, filename)
+        else:
+            self.runcode(code)
+
+    def runsource(self, source):
+        # Extend base class to stuff the source in the line cache first
+        filename = self.stuffsource(source)
+        self.more = 0
+        return InteractiveInterpreter.runsource(self, source, filename)
+
+    def stuffsource(self, source):
+        # Stuff source in the filename cache
+        filename = "<pyshell#%d>" % self.gid
+        self.gid = self.gid + 1
+        lines = string.split(source, "\n")
+        linecache.cache[filename] = len(source)+1, 0, lines, filename
+        return filename
+
+    def showsyntaxerror(self, filename=None):
+        # Extend base class to color the offending position
+        # (instead of printing it and pointing at it with a caret)
+        text = self.tkconsole.text
+        stuff = self.unpackerror()
+        if not stuff:
+            self.tkconsole.resetoutput()
+            InteractiveInterpreter.showsyntaxerror(self, filename)
+            return
+        msg, lineno, offset, line = stuff
+        if lineno == 1:
+            pos = "iomark + %d chars" % (offset-1)
+        else:
+            pos = "iomark linestart + %d lines + %d chars" % (lineno-1,
+                                                              offset-1)
+        text.tag_add("ERROR", pos)
+        text.see(pos)
+        char = text.get(pos)
+        if char and char in string.letters + string.digits + "_":
+            text.tag_add("ERROR", pos + " wordstart", pos)
+        self.tkconsole.resetoutput()
+        self.write("SyntaxError: %s\n" % str(msg))
+
+    def unpackerror(self):
+        type, value, tb = sys.exc_info()
+        ok = type is SyntaxError
+        if ok:
+            try:
+                msg, (dummy_filename, lineno, offset, line) = value
+            except:
+                ok = 0
+        if ok:
+            return msg, lineno, offset, line
+        else:
+            return None
+
+    def showtraceback(self):
+        # Extend base class method to reset output properly
+        text = self.tkconsole.text
+        self.tkconsole.resetoutput()
+        self.checklinecache()
+        InteractiveInterpreter.showtraceback(self)
+
+    def checklinecache(self):
+        c = linecache.cache
+        for key in c.keys():
+            if key[:1] + key[-1:] != "<>":
+                del c[key]
+
+    debugger = None
+
+    def setdebugger(self, debugger):
+        self.debugger = debugger
+
+    def getdebugger(self):
+        return self.debugger
+
+    def runcode(self, code):
+        # Override base class method
+        debugger = self.debugger
+        try:
+            self.tkconsole.beginexecuting()
+            try:
+                if debugger:
+                    debugger.run(code, self.locals)
+                else:
+                    exec code in self.locals
+            except SystemExit:
+                if tkMessageBox.askyesno(
+                    "Exit?",
+                    "Do you want to exit altogether?",
+                    default="yes",
+                    master=self.tkconsole.text):
+                    raise
+                else:
+                    self.showtraceback()
+                    if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):
+                        self.tkconsole.open_stack_viewer()
+            except:
+                self.showtraceback()
+                if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):
+                    self.tkconsole.open_stack_viewer()
+
+        finally:
+            self.tkconsole.endexecuting()
+
+    def write(self, s):
+        # Override base class write
+        self.tkconsole.console.write(s)
+
+
+class PyShell(OutputWindow):
+
+    shell_title = "Python Shell"
+
+    # Override classes
+    ColorDelegator = ModifiedColorDelegator
+    UndoDelegator = ModifiedUndoDelegator
+
+    # Override menu bar specs
+    menu_specs = PyShellEditorWindow.menu_specs[:]
+    menu_specs.insert(len(menu_specs)-2, ("debug", "_Debug"))
+
+    # New classes
+    from IdleHistory import History
+
+    def __init__(self, flist=None):
+        self.interp = ModifiedInterpreter(self)
+        if flist is None:
+            root = Tk()
+            fixwordbreaks(root)
+            root.withdraw()
+            flist = PyShellFileList(root)
+
+        OutputWindow.__init__(self, flist, None, None)
+
+        import __builtin__
+        __builtin__.quit = __builtin__.exit = "To exit, type Ctrl-D."
+
+        self.auto = self.extensions["AutoIndent"] # Required extension
+        self.auto.config(usetabs=1, indentwidth=8, context_use_ps1=1)
+
+        text = self.text
+        text.configure(wrap="char")
+        text.bind("<<newline-and-indent>>", self.enter_callback)
+        text.bind("<<plain-newline-and-indent>>", self.linefeed_callback)
+        text.bind("<<interrupt-execution>>", self.cancel_callback)
+        text.bind("<<beginning-of-line>>", self.home_callback)
+        text.bind("<<end-of-file>>", self.eof_callback)
+        text.bind("<<open-stack-viewer>>", self.open_stack_viewer)
+        text.bind("<<toggle-debugger>>", self.toggle_debugger)
+        text.bind("<<open-python-shell>>", self.flist.open_shell)
+        text.bind("<<toggle-jit-stack-viewer>>", self.toggle_jit_stack_viewer)
+
+        self.save_stdout = sys.stdout
+        self.save_stderr = sys.stderr
+        self.save_stdin = sys.stdin
+        sys.stdout = PseudoFile(self, "stdout")
+        sys.stderr = PseudoFile(self, "stderr")
+        sys.stdin = self
+        self.console = PseudoFile(self, "console")
+
+        self.history = self.History(self.text)
+
+    reading = 0
+    executing = 0
+    canceled = 0
+    endoffile = 0
+
+    def toggle_debugger(self, event=None):
+        if self.executing:
+            tkMessageBox.showerror("Don't debug now",
+                "You can only toggle the debugger when idle",
+                master=self.text)
+            self.set_debugger_indicator()
+            return "break"
+        else:
+            db = self.interp.getdebugger()
+            if db:
+                self.close_debugger()
+            else:
+                self.open_debugger()
+
+    def set_debugger_indicator(self):
+        db = self.interp.getdebugger()
+        self.setvar("<<toggle-debugger>>", not not db)
+
+    def toggle_jit_stack_viewer( self, event=None):
+        pass # All we need is the variable
+
+    def close_debugger(self):
+        db = self.interp.getdebugger()
+        if db:
+            self.interp.setdebugger(None)
+            db.close()
+            self.resetoutput()
+            self.console.write("[DEBUG OFF]\n")
+            sys.ps1 = ">>> "
+            self.showprompt()
+        self.set_debugger_indicator()
+
+    def open_debugger(self):
+        import Debugger
+        self.interp.setdebugger(Debugger.Debugger(self))
+        sys.ps1 = "[DEBUG ON]\n>>> "
+        self.showprompt()
+        self.set_debugger_indicator()
+
+    def beginexecuting(self):
+        # Helper for ModifiedInterpreter
+        self.resetoutput()
+        self.executing = 1
+        ##self._cancel_check = self.cancel_check
+        ##sys.settrace(self._cancel_check)
+
+    def endexecuting(self):
+        # Helper for ModifiedInterpreter
+        ##sys.settrace(None)
+        ##self._cancel_check = None
+        self.executing = 0
+        self.canceled = 0
+
+    def close(self):
+        # Extend base class method
+        if self.executing:
+            # XXX Need to ask a question here
+            if not tkMessageBox.askokcancel(
+                "Kill?",
+                "The program is still running; do you want to kill it?",
+                default="ok",
+                master=self.text):
+                return "cancel"
+            self.canceled = 1
+            if self.reading:
+                self.top.quit()
+            return "cancel"
+        return PyShellEditorWindow.close(self)
+
+    def _close(self):
+        self.close_debugger()
+        # Restore std streams
+        sys.stdout = self.save_stdout
+        sys.stderr = self.save_stderr
+        sys.stdin = self.save_stdin
+        # Break cycles
+        self.interp = None
+        self.console = None
+        self.auto = None
+        self.flist.pyshell = None
+        self.history = None
+        OutputWindow._close(self) # Really EditorWindow._close
+
+    def ispythonsource(self, filename):
+        # Override this so EditorWindow never removes the colorizer
+        return 1
+
+    def short_title(self):
+        return self.shell_title
+
+    def begin(self):
+        self.resetoutput()
+        self.write("Python %s on %s\n%s\nIDLE %s -- press F1 for help\n" %
+                   (sys.version, sys.platform, sys.copyright,
+                    idlever.IDLE_VERSION))
+        try:
+            sys.ps1
+        except AttributeError:
+            sys.ps1 = ">>> "
+        self.showprompt()
+        import Tkinter
+        Tkinter._default_root = None
+
+    def interact(self):
+        self.begin()
+        self.top.mainloop()
+
+    def readline(self):
+        save = self.reading
+        try:
+            self.reading = 1
+            self.top.mainloop()
+        finally:
+            self.reading = save
+        line = self.text.get("iomark", "end-1c")
+        self.resetoutput()
+        if self.canceled:
+            self.canceled = 0
+            raise KeyboardInterrupt
+        if self.endoffile:
+            self.endoffile = 0
+            return ""
+        return line
+
+    def isatty(self):
+        return 1
+
+    def cancel_callback(self, event):
+        try:
+            if self.text.compare("sel.first", "!=", "sel.last"):
+                return # Active selection -- always use default binding
+        except:
+            pass
+        if not (self.executing or self.reading):
+            self.resetoutput()
+            self.write("KeyboardInterrupt\n")
+            self.showprompt()
+            return "break"
+        self.endoffile = 0
+        self.canceled = 1
+        if self.reading:
+            self.top.quit()
+        return "break"
+
+    def eof_callback(self, event):
+        if self.executing and not self.reading:
+            return # Let the default binding (delete next char) take over
+        if not (self.text.compare("iomark", "==", "insert") and
+                self.text.compare("insert", "==", "end-1c")):
+            return # Let the default binding (delete next char) take over
+        if not self.executing:
+##             if not tkMessageBox.askokcancel(
+##                 "Exit?",
+##                 "Are you sure you want to exit?",
+##                 default="ok", master=self.text):
+##                 return "break"
+            self.resetoutput()
+            self.close()
+        else:
+            self.canceled = 0
+            self.endoffile = 1
+            self.top.quit()
+        return "break"
+
+    def home_callback(self, event):
+        if event.state != 0 and event.keysym == "Home":
+            return # <Modifier-Home>; fall back to class binding
+        if self.text.compare("iomark", "<=", "insert") and \
+           self.text.compare("insert linestart", "<=", "iomark"):
+            self.text.mark_set("insert", "iomark")
+            self.text.tag_remove("sel", "1.0", "end")
+            self.text.see("insert")
+            return "break"
+
+    def linefeed_callback(self, event):
+        # Insert a linefeed without entering anything (still autoindented)
+        if self.reading:
+            self.text.insert("insert", "\n")
+            self.text.see("insert")
+        else:
+            self.auto.auto_indent(event)
+        return "break"
+
+    def enter_callback(self, event):
+        if self.executing and not self.reading:
+            return # Let the default binding (insert '\n') take over
+        # If some text is selected, recall the selection
+        # (but only if this before the I/O mark)
+        try:
+            sel = self.text.get("sel.first", "sel.last")
+            if sel:
+                if self.text.compare("sel.last", "<=", "iomark"):
+                    self.recall(sel)
+                    return "break"
+        except:
+            pass
+        # If we're strictly before the line containing iomark, recall
+        # the current line, less a leading prompt, less leading or
+        # trailing whitespace
+        if self.text.compare("insert", "<", "iomark linestart"):
+            # Check if there's a relevant stdin range -- if so, use it
+            prev = self.text.tag_prevrange("stdin", "insert")
+            if prev and self.text.compare("insert", "<", prev[1]):
+                self.recall(self.text.get(prev[0], prev[1]))
+                return "break"
+            next = self.text.tag_nextrange("stdin", "insert")
+            if next and self.text.compare("insert lineend", ">=", next[0]):
+                self.recall(self.text.get(next[0], next[1]))
+                return "break"
+            # No stdin mark -- just get the current line
+            self.recall(self.text.get("insert linestart", "insert lineend"))
+            return "break"
+        # If we're in the current input and there's only whitespace
+        # beyond the cursor, erase that whitespace first
+        s = self.text.get("insert", "end-1c")
+        if s and not string.strip(s):
+            self.text.delete("insert", "end-1c")
+        # If we're in the current input before its last line,
+        # insert a newline right at the insert point
+        if self.text.compare("insert", "<", "end-1c linestart"):
+            self.auto.auto_indent(event)
+            return "break"
+        # We're in the last line; append a newline and submit it
+        self.text.mark_set("insert", "end-1c")
+        if self.reading:
+            self.text.insert("insert", "\n")
+            self.text.see("insert")
+        else:
+            self.auto.auto_indent(event)
+        self.text.tag_add("stdin", "iomark", "end-1c")
+        self.text.update_idletasks()
+        if self.reading:
+            self.top.quit() # Break out of recursive mainloop() in raw_input()
+        else:
+            self.runit()
+        return "break"
+
+    def recall(self, s):
+        if self.history:
+            self.history.recall(s)
+
+    def runit(self):
+        line = self.text.get("iomark", "end-1c")
+        # Strip off last newline and surrounding whitespace.
+        # (To allow you to hit return twice to end a statement.)
+        i = len(line)
+        while i > 0 and line[i-1] in " \t":
+            i = i-1
+        if i > 0 and line[i-1] == "\n":
+            i = i-1
+        while i > 0 and line[i-1] in " \t":
+            i = i-1
+        line = line[:i]
+        more = self.interp.runsource(line)
+        if not more:
+            self.showprompt()
+
+    def cancel_check(self, frame, what, args,
+                     dooneevent=tkinter.dooneevent,
+                     dontwait=tkinter.DONT_WAIT):
+        # Hack -- use the debugger hooks to be able to handle events
+        # and interrupt execution at any time.
+        # This slows execution down quite a bit, so you may want to
+        # disable this (by not calling settrace() in runcode() above)
+        # for full-bore (uninterruptable) speed.
+        # XXX This should become a user option.
+        if self.canceled:
+            return
+        dooneevent(dontwait)
+        if self.canceled:
+            self.canceled = 0
+            raise KeyboardInterrupt
+        return self._cancel_check
+
+    def open_stack_viewer(self, event=None):
+        try:
+            sys.last_traceback
+        except:
+            tkMessageBox.showerror("No stack trace",
+                "There is no stack trace yet.\n"
+                "(sys.last_traceback is not defined)",
+                master=self.text)
+            return
+        from StackViewer import StackBrowser
+        sv = StackBrowser(self.root, self.flist)
+
+    def showprompt(self):
+        self.resetoutput()
+        try:
+            s = str(sys.ps1)
+        except:
+            s = ""
+        self.console.write(s)
+        self.text.mark_set("insert", "end-1c")
+
+    def resetoutput(self):
+        source = self.text.get("iomark", "end-1c")
+        if self.history:
+            self.history.history_store(source)
+        if self.text.get("end-2c") != "\n":
+            self.text.insert("end-1c", "\n")
+        self.text.mark_set("iomark", "end-1c")
+        sys.stdout.softspace = 0
+
+    def write(self, s, tags=()):
+        self.text.mark_gravity("iomark", "right")
+        OutputWindow.write(self, s, tags, "iomark")
+        self.text.mark_gravity("iomark", "left")
+        if self.canceled:
+            self.canceled = 0
+            raise KeyboardInterrupt
+
+class PseudoFile:
+
+    def __init__(self, shell, tags):
+        self.shell = shell
+        self.tags = tags
+
+    def write(self, s):
+        self.shell.write(s, self.tags)
+
+    def writelines(self, l):
+        map(self.write, l)
+
+    def flush(self):
+        pass
+
+    def isatty(self):
+        return 1
+
+usage_msg = """\
+usage: idle.py [-c command] [-d] [-e] [-s] [-t title] [arg] ...
+
+-c command  run this command
+-d          enable debugger
+-e          edit mode; arguments are files to be edited
+-s          run $IDLESTARTUP or $PYTHONSTARTUP before anything else
+-t title    set title of shell window
+
+When neither -c nor -e is used, and there are arguments, and the first
+argument is not '-', the first argument is run as a script.  Remaining
+arguments are arguments to the script or to the command run by -c.
+"""
+
+class usageError:
+    def __init__(self, string): self.string = string
+    def __repr__(self): return self.string
+
+class main:
+    def __init__(self):
+        try:
+            self.server = protocol.Server(connection_hook = self.address_ok)
+            protocol.publish( 'IDLE', self.connect )
+            self.main( sys.argv[1:] )
+            return
+        except protocol.connectionLost:
+            try:
+                client = protocol.Client()
+                IDLE = client.getobject('IDLE')
+                if IDLE:
+                    try:
+                        IDLE.remote( sys.argv[1:] )
+                    except usageError, msg:
+                        sys.stderr.write("Error: %s\n" % str(msg))
+                        sys.stderr.write(usage_msg)
+                    return
+            except protocol.connectionLost:
+                pass
+
+        # xxx Should scream via Tk()
+        print "Something already has our socket, but it won't open a window for me!"
+        print "Unable to proceed."
+
+    def idle(self):
+        spawn.kill_zombies()
+        self.server.rpc_loop()
+        root.after(25, self.idle)
+
+    # We permit connections from localhost only
+    def address_ok(self, addr):
+        return addr[0] == '127.0.0.1'
+
+    def connect(self, client, addr):
+        return self
+
+    def remote( self, argv ):
+        # xxx Should make this behavior match the behavior in main, or redo
+        #     command line options entirely.
+
+        try:
+            opts, args = getopt.getopt(argv, "c:deist:")
+        except getopt.error, msg:
+            raise usageError(msg)
+
+        for filename in args:
+            flist.open(filename)
+        if not args:
+            flist.new()
+
+    def main( self, argv ):
+        cmd = None
+        edit = 0
+        noshell = 1
+    
+        debug = 0
+        startup = 0
+    
+        try:
+            opts, args = getopt.getopt(argv, "c:deist:")
+        except getopt.error, msg:
+            sys.stderr.write("Error: %s\n" % str(msg))
+            sys.stderr.write(usage_msg)
+            sys.exit(2)
+    
+        for o, a in opts:
+            noshell = 0
+            if o == '-c':
+                cmd = a
+            if o == '-d':
+                debug = 1
+            if o == '-e':
+                edit = 1
+            if o == '-s':
+                startup = 1
+            if o == '-t':
+                PyShell.shell_title = a
+    
+        if noshell: edit=1
+    
+        if not edit:
+            if cmd:
+                sys.argv = ["-c"] + args
+            else:
+                sys.argv = args or [""]
+    
+        for i in range(len(sys.path)):
+            sys.path[i] = os.path.abspath(sys.path[i])
+    
+        pathx = []
+        if edit:
+            for filename in args:
+                pathx.append(os.path.dirname(filename))
+        elif args and args[0] != "-":
+            pathx.append(os.path.dirname(args[0]))
+        else:
+            pathx.append(os.curdir)
+        for dir in pathx:
+            dir = os.path.abspath(dir)
+            if not dir in sys.path:
+                sys.path.insert(0, dir)
+
+        global flist, root
+        root = Tk()
+        fixwordbreaks(root)
+        root.withdraw()
+        flist = PyShellFileList(root)
+    
+        if edit:
+            for filename in args:
+                flist.open(filename)
+            if not args:
+                flist.new()
+    
+        #dbg=OnDemandOutputWindow(flist)
+        #dbg.set_title('Internal IDLE Problem')
+        #sys.stdout = PseudoFile(dbg,['stdout'])
+        #sys.stderr = PseudoFile(dbg,['stderr'])
+    
+        if noshell:
+          flist.pyshell = None
+        else:
+          shell = PyShell(flist)
+          interp = shell.interp
+          flist.pyshell = shell
+      
+          if startup:
+              filename = os.environ.get("IDLESTARTUP") or \
+                         os.environ.get("PYTHONSTARTUP")
+              if filename and os.path.isfile(filename):
+                  interp.execfile(filename)
+      
+          if debug:
+              shell.open_debugger()
+          if cmd:
+              interp.execsource(cmd)
+          elif not edit and args and args[0] != "-":
+              interp.execfile(args[0])
+      
+          shell.begin()
+
+        self.idle()
+        root.mainloop()
+        root.destroy()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/idlelib/README.txt b/Lib/idlelib/README.txt
new file mode 100644
index 0000000..1b065ae
--- /dev/null
+++ b/Lib/idlelib/README.txt
@@ -0,0 +1,121 @@
+EXPERIMENTAL LOADER IDLE 2000-05-29
+-----------------------------------
+
+   David Scherer  <dscherer@cmu.edu>
+
+This is a modification of the CVS version of IDLE 0.5, updated as of
+2000-03-09.  It is alpha software and might be unstable.  If it breaks,
+you get to keep both pieces.
+
+If you have problems or suggestions, you should either contact me or
+post to the list at http://www.python.org/mailman/listinfo/idle-dev
+(making it clear that you are using this modified version of IDLE).
+
+Changes:
+
+  The ExecBinding module, a replacement for ScriptBinding, executes
+  programs in a separate process, piping standard I/O through an RPC
+  mechanism to an OnDemandOutputWindow in IDLE.  It supports executing
+  unnamed programs (through a temporary file).  It does not yet support
+  debugging.
+
+  When running programs with ExecBinding, tracebacks will be clipped
+  to exclude system modules.  If, however, a system module calls back
+  into the user program, that part of the traceback will be shown.
+
+  The OnDemandOutputWindow class has been improved.  In particular,
+  it now supports a readline() function used to implement user input,
+  and a scroll_clear() operation which is used to hide the output of
+  a previous run by scrolling it out of the window.
+
+  Startup behavior has been changed.  By default IDLE starts up with
+  just a blank editor window, rather than an interactive window.  Opening
+  a file in such a blank window replaces the (nonexistent) contents of
+  that window instead of creating another window.  Because of the need to
+  have a well-known port for the ExecBinding protocol, only one copy of
+  IDLE can be running.  Additional invocations use the RPC mechanism to
+  report their command line arguments to the copy already running.
+
+  The menus have been reorganized.  In particular, the excessively large
+  'edit' menu has been split up into 'edit', 'format', and 'run'.
+
+  'Python Documentation' now works on Windows, if the win32api module is
+  present.
+
+  A few key bindings have been changed: F1 now loads Python Documentation
+  instead of the IDLE help; shift-TAB is now a synonym for unindent.
+
+New modules:
+  ExecBinding.py         Executes program through loader
+  loader.py              Bootstraps user program
+  protocol.py            RPC protocol
+  Remote.py              User-process interpreter
+  spawn.py               OS-specific code to start programs
+
+Files modified:
+  autoindent.py          ( bindings tweaked )
+  bindings.py            ( menus reorganized )
+  config.txt             ( execbinding enabled )
+  editorwindow.py        ( new menus, fixed 'Python Documentation' )
+  filelist.py            ( hook for "open in same window" )
+  formatparagraph.py     ( bindings tweaked )
+  idle.bat               ( removed absolute pathname )
+  idle.pyw               ( weird bug due to import with same name? )
+  iobinding.py           ( open in same window, EOL convention )
+  keydefs.py             ( bindings tweaked )
+  outputwindow.py        ( readline, scroll_clear, etc )
+  pyshell.py             ( changed startup behavior )
+  readme.txt             ( <Recursion on file with id=1234567> )
+
+IDLE 0.5 - February 2000
+------------------------
+
+This is an early release of IDLE, my own attempt at a Tkinter-based
+IDE for Python.
+
+For news about this release, see the file NEWS.txt.  (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).
+
+FEEDBACK
+
+(removed, since Guido probably doesn't want complaints about my
+changes)
+
+--Guido van Rossum (home page: http://www.python.org/~guido/)
diff --git a/Lib/idlelib/Remote.py b/Lib/idlelib/Remote.py
new file mode 100644
index 0000000..facba78
--- /dev/null
+++ b/Lib/idlelib/Remote.py
@@ -0,0 +1,101 @@
+"""Remote
+     This module is imported by the loader and serves to control
+     the execution of the user program.  It presently executes files
+     and reports exceptions to IDLE.  It could be extended to provide
+     other services, such as interactive mode and debugging.  To that
+     end, it could be a subclass of e.g. InteractiveInterpreter.
+
+     Two other classes, pseudoIn and pseudoOut, are file emulators also
+     used by loader.
+"""
+import sys, os
+import traceback
+
+class Remote:    
+    def __init__(self, main, master):
+        self.main = main
+        self.master = master
+        self.this_file = self.canonic( self.__init__.im_func.func_code.co_filename )
+
+    def canonic(self, path):
+        return os.path.normcase(os.path.abspath(path))
+
+    def mainloop(self):
+        while 1:
+            args = self.master.get_command()
+
+            try:
+                f = getattr(self,args[0])
+                apply(f,args[1:])
+            except:
+                if not self.report_exception(): raise
+
+    def finish(self):
+        sys.exit()
+
+    def run(self, *argv):
+        sys.argv = argv
+
+        path = self.canonic( argv[0] )
+        dir = self.dir = os.path.dirname(path)
+        os.chdir(dir)
+
+        sys.path[0] = dir
+
+        usercode = open(path)
+        exec usercode in self.main
+
+    def report_exception(self):
+        try:
+            type, value, tb = sys.exc_info()
+            sys.last_type = type
+            sys.last_value = value
+            sys.last_traceback = tb
+
+            tblist = traceback.extract_tb(tb)
+
+            # Look through the traceback, canonicalizing filenames and
+            #   eliminating leading and trailing system modules.
+            first = last = 1
+            for i in range(len(tblist)):
+                filename, lineno, name, line = tblist[i]
+                filename = self.canonic(filename)
+                tblist[i] = filename, lineno, name, line
+
+                dir = os.path.dirname(filename)
+                if filename == self.this_file:
+                    first = i+1
+                elif dir==self.dir:
+                    last = i+1
+
+            # Canonicalize the filename in a syntax error, too:
+            if type is SyntaxError:
+                try:
+                    msg, (filename, lineno, offset, line) = value
+                    filename = self.canonic(filename)
+                    value = msg, (filename, lineno, offset, line)
+                except:
+                    pass
+
+            return self.master.program_exception( type, value, tblist, first, last )
+        finally:
+            # avoid any circular reference through the traceback
+            del tb
+
+class pseudoIn:
+    def __init__(self, readline):
+        self.readline = readline
+    def isatty():
+        return 1
+
+class pseudoOut:
+    def __init__(self, func, **kw):
+        self.func = func
+        self.kw = kw
+    def write(self, *args):
+        return apply( self.func, args, self.kw )
+    def writelines(self, l):
+        map(self.write, l)
+    def flush(self):
+        pass
+
diff --git a/Lib/idlelib/ReplaceDialog.py b/Lib/idlelib/ReplaceDialog.py
new file mode 100644
index 0000000..e29d4d6
--- /dev/null
+++ b/Lib/idlelib/ReplaceDialog.py
@@ -0,0 +1,172 @@
+import string
+import os
+import re
+import fnmatch
+from Tkinter import *
+import tkMessageBox
+import SearchEngine
+from SearchDialogBase import SearchDialogBase
+
+def replace(text):
+    root = text._root()
+    engine = SearchEngine.get(root)
+    if not hasattr(engine, "_replacedialog"):
+        engine._replacedialog = ReplaceDialog(root, engine)
+    dialog = engine._replacedialog
+    dialog.open(text)
+
+class ReplaceDialog(SearchDialogBase):
+
+    title = "Replace Dialog"
+    icon = "Replace"
+
+    def __init__(self, root, engine):
+        SearchDialogBase.__init__(self, root, engine)
+        self.replvar = StringVar(root)
+
+    def open(self, text):
+        SearchDialogBase.open(self, text)
+        try:
+            first = text.index("sel.first")
+        except TclError:
+            first = None
+        try:
+            last = text.index("sel.last")
+        except TclError:
+            last = None
+        first = first or text.index("insert")
+        last = last or first
+        self.show_hit(first, last)
+        self.ok = 1
+
+    def create_entries(self):
+        SearchDialogBase.create_entries(self)
+        self.replent = self.make_entry("Replace with:", self.replvar)
+
+    def create_command_buttons(self):
+        SearchDialogBase.create_command_buttons(self)
+        self.make_button("Find", self.find_it)
+        self.make_button("Replace", self.replace_it)
+        self.make_button("Replace+Find", self.default_command, 1)
+        self.make_button("Replace All", self.replace_all)
+
+    def find_it(self, event=None):
+        self.do_find(0)
+
+    def replace_it(self, event=None):
+        if self.do_find(self.ok):
+            self.do_replace()
+
+    def default_command(self, event=None):
+        if self.do_find(self.ok):
+            self.do_replace()
+            self.do_find(0)
+
+    def replace_all(self, event=None):
+        prog = self.engine.getprog()
+        if not prog:
+            return
+        repl = self.replvar.get()
+        text = self.text
+        res = self.engine.search_text(text, prog)
+        if not res:
+            text.bell()
+            return
+        text.tag_remove("sel", "1.0", "end")
+        text.tag_remove("hit", "1.0", "end")
+        line = res[0]
+        col = res[1].start()
+        if self.engine.iswrap():
+            line = 1
+            col = 0
+        ok = 1
+        first = last = None
+        # XXX ought to replace circular instead of top-to-bottom when wrapping
+        text.undo_block_start()
+        while 1:
+            res = self.engine.search_forward(text, prog, line, col, 0, ok)
+            if not res:
+                break
+            line, m = res
+            chars = text.get("%d.0" % line, "%d.0" % (line+1))
+            orig = m.group()
+            new = re.pcre_expand(m, repl)
+            i, j = m.span()
+            first = "%d.%d" % (line, i)
+            last = "%d.%d" % (line, j)
+            if new == orig:
+                text.mark_set("insert", last)
+            else:
+                text.mark_set("insert", first)
+                if first != last:
+                    text.delete(first, last)
+                if new:
+                    text.insert(first, new)
+            col = i + len(new)
+            ok = 0
+        text.undo_block_stop()
+        if first and last:
+            self.show_hit(first, last)
+        self.close()
+
+    def do_find(self, ok=0):
+        if not self.engine.getprog():
+            return 0
+        text = self.text
+        res = self.engine.search_text(text, None, ok)
+        if not res:
+            text.bell()
+            return 0
+        line, m = res
+        i, j = m.span()
+        first = "%d.%d" % (line, i)
+        last = "%d.%d" % (line, j)
+        self.show_hit(first, last)
+        self.ok = 1
+        return 1
+
+    def do_replace(self):
+        prog = self.engine.getprog()
+        if not prog:
+            return 0
+        text = self.text
+        try:
+            first = pos = text.index("sel.first")
+            last = text.index("sel.last")
+        except TclError:
+            pos = None
+        if not pos:
+            first = last = pos = text.index("insert")
+        line, col = SearchEngine.get_line_col(pos)
+        chars = text.get("%d.0" % line, "%d.0" % (line+1))
+        m = prog.match(chars, col)
+        if not prog:
+            return 0
+        new = re.pcre_expand(m, self.replvar.get())
+        text.mark_set("insert", first)
+        text.undo_block_start()
+        if m.group():
+            text.delete(first, last)
+        if new:
+            text.insert(first, new)
+        text.undo_block_stop()
+        self.show_hit(first, text.index("insert"))
+        self.ok = 0
+        return 1
+
+    def show_hit(self, first, last):
+        text = self.text
+        text.mark_set("insert", first)
+        text.tag_remove("sel", "1.0", "end")
+        text.tag_add("sel", first, last)
+        text.tag_remove("hit", "1.0", "end")
+        if first == last:
+            text.tag_add("hit", first)
+        else:
+            text.tag_add("hit", first, last)
+        text.see("insert")
+        text.update_idletasks()
+
+    def close(self, event=None):
+        SearchDialogBase.close(self, event)
+        self.text.tag_remove("hit", "1.0", "end")
diff --git a/Lib/idlelib/ScriptBinding.py b/Lib/idlelib/ScriptBinding.py
new file mode 100644
index 0000000..aa46c68
--- /dev/null
+++ b/Lib/idlelib/ScriptBinding.py
@@ -0,0 +1,169 @@
+"""Extension to execute code outside the Python shell window.
+
+This adds the following commands (to the Edit menu, until there's a
+separate Python menu):
+
+- Check module (Alt-F5) does a full syntax check of the current module.
+It also runs the tabnanny to catch any inconsistent tabs.
+
+- Import module (F5) is equivalent to either import or reload of the
+current module.  The window must have been saved previously. The
+module is added to sys.modules, and is also added to the __main__
+namespace.  Output goes to the shell window.
+
+- Run module (Control-F5) does the same but executes the module's
+code in the __main__ namespace.
+
+"""
+
+import sys
+import os
+import imp
+import tkMessageBox
+
+indent_message = """Error: Inconsistent indentation detected!
+
+This means that either:
+
+(1) your indentation is outright incorrect (easy to fix), or
+
+(2) your indentation mixes tabs and spaces in a way that depends on \
+how many spaces a tab is worth.
+
+To fix case 2, change all tabs to spaces by using Select All followed \
+by Untabify Region (both in the Edit menu)."""
+
+class ScriptBinding:
+    
+    keydefs = {
+        '<<check-module>>': ['<Alt-F5>', '<Meta-F5>'],
+        '<<import-module>>': ['<F5>'],
+        '<<run-script>>': ['<Control-F5>'],
+    }
+    
+    menudefs = [
+        ('edit', [None,
+                  ('Check module', '<<check-module>>'),
+                  ('Import module', '<<import-module>>'),
+                  ('Run script', '<<run-script>>'),
+                 ]
+        ),
+    ]
+
+    def __init__(self, editwin):
+        self.editwin = editwin
+        # Provide instance variables referenced by Debugger
+        # XXX This should be done differently
+        self.flist = self.editwin.flist
+        self.root = self.flist.root
+
+    def check_module_event(self, event):
+        filename = self.getfilename()
+        if not filename:
+            return
+        if not self.tabnanny(filename):
+            return
+        if not self.checksyntax(filename):
+            return
+
+    def tabnanny(self, filename):
+        import tabnanny
+        import tokenize
+        tabnanny.reset_globals()
+        f = open(filename, 'r')
+        try:
+            tokenize.tokenize(f.readline, tabnanny.tokeneater)
+        except tokenize.TokenError, msg:
+            self.errorbox("Token error",
+                          "Token error:\n%s" % str(msg))
+            return 0
+        except tabnanny.NannyNag, nag:
+            # The error messages from tabnanny are too confusing...
+            self.editwin.gotoline(nag.get_lineno())
+            self.errorbox("Tab/space error", indent_message)
+            return 0
+        return 1
+
+    def checksyntax(self, filename):
+        f = open(filename, 'r')
+        source = f.read()
+        f.close()
+        if '\r' in source:
+            import re
+            source = re.sub(r"\r\n", "\n", source)
+        if source and source[-1] != '\n':
+            source = source + '\n'
+        try:
+            compile(source, filename, "exec")
+        except (SyntaxError, OverflowError), err:
+            try:
+                msg, (errorfilename, lineno, offset, line) = err
+                if not errorfilename:
+                    err.args = msg, (filename, lineno, offset, line)
+                    err.filename = filename
+            except:
+                lineno = None
+                msg = "*** " + str(err)
+            if lineno:
+                self.editwin.gotoline(lineno)
+            self.errorbox("Syntax error",
+                          "There's an error in your program:\n" + msg)
+        return 1
+
+    def import_module_event(self, event):
+        filename = self.getfilename()
+        if not filename:
+            return
+
+        modname, ext = os.path.splitext(os.path.basename(filename))
+        if sys.modules.has_key(modname):
+            mod = sys.modules[modname]
+        else:
+            mod = imp.new_module(modname)
+            sys.modules[modname] = mod
+        mod.__file__ = filename
+        setattr(sys.modules['__main__'], modname, mod)
+
+        dir = os.path.dirname(filename)
+        dir = os.path.normpath(os.path.abspath(dir))
+        if dir not in sys.path:
+            sys.path.insert(0, dir)
+
+        flist = self.editwin.flist
+        shell = flist.open_shell()
+        interp = shell.interp
+        interp.runcode("reload(%s)" % modname)
+
+    def run_script_event(self, event):
+        filename = self.getfilename()
+        if not filename:
+            return
+
+        flist = self.editwin.flist
+        shell = flist.open_shell()
+        interp = shell.interp
+        if (not sys.argv or
+            os.path.basename(sys.argv[0]) != os.path.basename(filename)):
+            # XXX Too often this discards arguments the user just set...
+            sys.argv = [filename]
+        interp.execfile(filename)
+
+    def getfilename(self):
+        # Logic to make sure we have a saved filename
+        # XXX Better logic would offer to save!
+        if not self.editwin.get_saved():
+            self.errorbox("Not saved",
+                          "Please save first!")
+            self.editwin.text.focus_set()
+            return
+        filename = self.editwin.io.filename
+        if not filename:
+            self.errorbox("No file name",
+                          "This window has no file name")
+            return
+        return filename
+
+    def errorbox(self, title, message):
+        # XXX This should really be a function of EditorWindow...
+        tkMessageBox.showerror(title, message, master=self.editwin.text)
+        self.editwin.text.focus_set()
diff --git a/Lib/idlelib/ScrolledList.py b/Lib/idlelib/ScrolledList.py
new file mode 100644
index 0000000..7fb1c20
--- /dev/null
+++ b/Lib/idlelib/ScrolledList.py
@@ -0,0 +1,139 @@
+from Tkinter import *
+
+class ScrolledList:
+    
+    default = "(None)"
+
+    def __init__(self, master, **options):
+        # Create top frame, with scrollbar and listbox
+        self.master = master
+        self.frame = frame = Frame(master)
+        self.frame.pack(fill="both", expand=1)
+        self.vbar = vbar = Scrollbar(frame, name="vbar")
+        self.vbar.pack(side="right", fill="y")
+        self.listbox = listbox = Listbox(frame, exportselection=0,
+            background="white")
+        if options:
+            listbox.configure(options)
+        listbox.pack(expand=1, fill="both")
+        # Tie listbox and scrollbar together
+        vbar["command"] = listbox.yview
+        listbox["yscrollcommand"] = vbar.set
+        # Bind events to the list box
+        listbox.bind("<ButtonRelease-1>", self.click_event)
+        listbox.bind("<Double-ButtonRelease-1>", self.double_click_event)
+        listbox.bind("<ButtonPress-3>", self.popup_event)
+        listbox.bind("<Key-Up>", self.up_event)
+        listbox.bind("<Key-Down>", self.down_event)
+        # Mark as empty
+        self.clear()
+
+    def close(self):
+        self.frame.destroy()
+
+    def clear(self):
+        self.listbox.delete(0, "end")
+        self.empty = 1
+        self.listbox.insert("end", self.default)
+
+    def append(self, item):
+        if self.empty:
+            self.listbox.delete(0, "end")
+            self.empty = 0
+        self.listbox.insert("end", str(item))
+
+    def get(self, index):
+        return self.listbox.get(index)
+
+    def click_event(self, event):
+        self.listbox.activate("@%d,%d" % (event.x, event.y))
+        index = self.listbox.index("active")
+        self.select(index)
+        self.on_select(index)
+        return "break"
+
+    def double_click_event(self, event):
+        index = self.listbox.index("active")
+        self.select(index)
+        self.on_double(index)
+        return "break"
+
+    menu = None
+
+    def popup_event(self, event):
+        if not self.menu:
+            self.make_menu()
+        menu = self.menu
+        self.listbox.activate("@%d,%d" % (event.x, event.y))
+        index = self.listbox.index("active")
+        self.select(index)
+        menu.tk_popup(event.x_root, event.y_root)
+
+    def make_menu(self):
+        menu = Menu(self.listbox, tearoff=0)
+        self.menu = menu
+        self.fill_menu()
+
+    def up_event(self, event):
+        index = self.listbox.index("active")
+        if self.listbox.selection_includes(index):
+            index = index - 1
+        else:
+            index = self.listbox.size() - 1
+        if index < 0:
+            self.listbox.bell()
+        else:
+            self.select(index)
+            self.on_select(index)
+        return "break"
+
+    def down_event(self, event):
+        index = self.listbox.index("active")
+        if self.listbox.selection_includes(index):
+            index = index + 1
+        else:
+            index = 0
+        if index >= self.listbox.size():
+            self.listbox.bell()
+        else:
+            self.select(index)
+            self.on_select(index)
+        return "break"
+
+    def select(self, index):
+        self.listbox.focus_set()
+        self.listbox.activate(index)
+        self.listbox.selection_clear(0, "end")
+        self.listbox.selection_set(index)
+        self.listbox.see(index)
+
+    # Methods to override for specific actions
+
+    def fill_menu(self):
+        pass
+
+    def on_select(self, index):
+        pass
+
+    def on_double(self, index):
+        pass
+
+
+def test():
+    root = Tk()
+    root.protocol("WM_DELETE_WINDOW", root.destroy)
+    class MyScrolledList(ScrolledList):
+        def fill_menu(self): self.menu.add_command(label="pass")
+        def on_select(self, index): print "select", self.get(index)
+        def on_double(self, index): print "double", self.get(index)
+    s = MyScrolledList(root)
+    for i in range(30):
+        s.append("item %02d" % i)
+    return root
+
+def main():
+    root = test()
+    root.mainloop()
+
+if __name__ == '__main__':
+    main()
diff --git a/Lib/idlelib/SearchBinding.py b/Lib/idlelib/SearchBinding.py
new file mode 100644
index 0000000..5943e3b
--- /dev/null
+++ b/Lib/idlelib/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/Lib/idlelib/SearchDialog.py b/Lib/idlelib/SearchDialog.py
new file mode 100644
index 0000000..0f0cb18
--- /dev/null
+++ b/Lib/idlelib/SearchDialog.py
@@ -0,0 +1,67 @@
+from Tkinter import *
+import SearchEngine
+from SearchDialogBase import SearchDialogBase
+
+
+def _setup(text):
+    root = text._root()
+    engine = SearchEngine.get(root)
+    if not hasattr(engine, "_searchdialog"):
+        engine._searchdialog = SearchDialog(root, engine)
+    return engine._searchdialog
+
+def find(text):
+    return _setup(text).open(text)
+
+def find_again(text):
+    return _setup(text).find_again(text)
+
+def find_selection(text):
+    return _setup(text).find_selection(text)
+
+class SearchDialog(SearchDialogBase):
+
+    def create_widgets(self):
+        f = SearchDialogBase.create_widgets(self)
+        self.make_button("Find", self.default_command, 1)
+
+    def default_command(self, event=None):
+        if not self.engine.getprog():
+            return
+        if self.find_again(self.text):
+            self.close()
+
+    def find_again(self, text):
+        if not self.engine.getpat():
+            self.open(text)
+            return 0
+        if not self.engine.getprog():
+            return 0
+        res = self.engine.search_text(text)
+        if res:
+            line, m = res
+            i, j = m.span()
+            first = "%d.%d" % (line, i)
+            last = "%d.%d" % (line, j)
+            try:
+                selfirst = text.index("sel.first")
+                sellast = text.index("sel.last")
+                if selfirst == first and sellast == last:
+                    text.bell()
+                    return 0
+            except TclError:
+                pass
+            text.tag_remove("sel", "1.0", "end")
+            text.tag_add("sel", first, last)
+            text.mark_set("insert", self.engine.isback() and first or last)
+            text.see("insert")
+            return 1
+        else:
+            text.bell()
+            return 0
+
+    def find_selection(self, text):
+        pat = text.get("sel.first", "sel.last")
+        if pat:
+            self.engine.setcookedpat(pat)
+        return self.find_again(text)
diff --git a/Lib/idlelib/SearchDialogBase.py b/Lib/idlelib/SearchDialogBase.py
new file mode 100644
index 0000000..faf5269
--- /dev/null
+++ b/Lib/idlelib/SearchDialogBase.py
@@ -0,0 +1,129 @@
+import string
+from Tkinter import *
+
+class SearchDialogBase:
+
+    title = "Search Dialog"
+    icon = "Search"
+    needwrapbutton = 1
+
+    def __init__(self, root, engine):
+        self.root = root
+        self.engine = engine
+        self.top = None
+
+    def open(self, text):
+        self.text = text
+        if not self.top:
+            self.create_widgets()
+        else:
+            self.top.deiconify()
+            self.top.tkraise()
+        self.ent.focus_set()
+        self.ent.selection_range(0, "end")
+        self.ent.icursor(0)
+        self.top.grab_set()
+
+    def close(self, event=None):
+        if self.top:
+            self.top.grab_release()
+            self.top.withdraw()
+
+    def create_widgets(self):
+        top = Toplevel(self.root)
+        top.bind("<Return>", self.default_command)
+        top.bind("<Escape>", self.close)
+        top.protocol("WM_DELETE_WINDOW", self.close)
+        top.wm_title(self.title)
+        top.wm_iconname(self.icon)
+        self.top = top
+
+        self.row = 0
+        self.top.grid_columnconfigure(0, weight=0)
+        self.top.grid_columnconfigure(1, weight=100)
+
+        self.create_entries()
+        self.create_option_buttons()
+        self.create_other_buttons()
+        return self.create_command_buttons()
+
+    def make_entry(self, label, var):
+        l = Label(self.top, text=label)
+        l.grid(row=self.row, col=0, sticky="w")
+        e = Entry(self.top, textvariable=var, exportselection=0)
+        e.grid(row=self.row, col=1, sticky="we")
+        self.row = self.row + 1
+        return e
+
+    def make_frame(self):
+        f = Frame(self.top)
+        f.grid(row=self.row, col=0, columnspan=2, sticky="we")
+        self.row = self.row + 1
+        return f
+
+    def make_button(self, label, command, isdef=0, side="left"):
+        b = Button(self.buttonframe,
+                   text=label, command=command,
+                   default=isdef and "active" or "normal")
+        b.pack(side=side)
+        return b
+
+    def create_entries(self):
+        self.ent = self.make_entry("Find:", self.engine.patvar)
+
+    def create_option_buttons(self):
+        f = self.make_frame()
+
+        btn = Checkbutton(f, anchor="w",
+                variable=self.engine.revar,
+                text="Regular expression")
+        btn.pack(side="left", fill="both")
+        if self.engine.isre():
+            btn.select()
+
+        btn = Checkbutton(f, anchor="w",
+                variable=self.engine.casevar,
+                text="Match case")
+        btn.pack(side="left", fill="both")
+        if self.engine.iscase():
+            btn.select()
+
+        btn = Checkbutton(f, anchor="w",
+                variable=self.engine.wordvar,
+                text="Whole word")
+        btn.pack(side="left", fill="both")
+        if self.engine.isword():
+            btn.select()
+
+        if self.needwrapbutton:
+            btn = Checkbutton(f, anchor="w",
+                    variable=self.engine.wrapvar,
+                    text="Wrap around")
+            btn.pack(side="left", fill="both")
+            if self.engine.iswrap():
+                btn.select()
+
+    def create_other_buttons(self):
+        f = self.make_frame()
+
+        lbl = Label(f, text="Direction: ")
+        lbl.pack(side="left")
+
+        btn = Radiobutton(f, anchor="w",
+                variable=self.engine.backvar, value=1,
+                text="Up")
+        btn.pack(side="left", fill="both")
+        if self.engine.isback():
+            btn.select()
+
+        btn = Radiobutton(f, anchor="w",
+                variable=self.engine.backvar, value=0,
+                text="Down")
+        btn.pack(side="left", fill="both")
+        if not self.engine.isback():
+            btn.select()
+
+    def create_command_buttons(self):
+        f = self.buttonframe = self.make_frame()
+        b = self.make_button("close", self.close, side="right")
+        b.lower()
diff --git a/Lib/idlelib/SearchEngine.py b/Lib/idlelib/SearchEngine.py
new file mode 100644
index 0000000..e379751
--- /dev/null
+++ b/Lib/idlelib/SearchEngine.py
@@ -0,0 +1,221 @@
+import string
+import re
+from Tkinter import *
+import tkMessageBox
+
+def get(root):
+    if not hasattr(root, "_searchengine"):
+        root._searchengine = SearchEngine(root)
+        # XXX This will never garbage-collect -- who cares
+    return root._searchengine
+
+class SearchEngine:
+
+    def __init__(self, root):
+        self.root = root
+        # State shared by search, replace, and grep;
+        # the search dialogs bind these to UI elements.
+        self.patvar = StringVar(root)           # search pattern
+        self.revar = BooleanVar(root)           # regular expression?
+        self.casevar = BooleanVar(root)         # match case?
+        self.wordvar = BooleanVar(root)         # match whole word?
+        self.wrapvar = BooleanVar(root)         # wrap around buffer?
+        self.wrapvar.set(1)                     # (on by default)
+        self.backvar = BooleanVar(root)         # search backwards?
+
+    # Access methods
+
+    def getpat(self):
+        return self.patvar.get()
+
+    def setpat(self, pat):
+        self.patvar.set(pat)
+
+    def isre(self):
+        return self.revar.get()
+
+    def iscase(self):
+        return self.casevar.get()
+
+    def isword(self):
+        return self.wordvar.get()
+
+    def iswrap(self):
+        return self.wrapvar.get()
+
+    def isback(self):
+        return self.backvar.get()
+
+    # Higher level access methods
+
+    def getcookedpat(self):
+        pat = self.getpat()
+        if not self.isre():
+            pat = re.escape(pat)
+        if self.isword():
+            pat = r"\b%s\b" % pat
+        return pat
+
+    def getprog(self):
+        pat = self.getpat()
+        if not pat:
+            self.report_error(pat, "Empty regular expression")
+            return None
+        pat = self.getcookedpat()
+        flags = 0
+        if not self.iscase():
+            flags = flags | re.IGNORECASE
+        try:
+            prog = re.compile(pat, flags)
+        except re.error, what:
+            try:
+                msg, col = what
+            except:
+                msg = str(what)
+                col = -1
+            self.report_error(pat, msg, col)
+            return None
+        return prog
+
+    def report_error(self, pat, msg, col=-1):
+        # Derived class could overrid this with something fancier
+        msg = "Error: " + str(msg)
+        if pat:
+            msg = msg + "\np\Pattern: " + str(pat)
+        if col >= 0:
+            msg = msg + "\nOffset: " + str(col)
+        tkMessageBox.showerror("Regular expression error",
+                               msg, master=self.root)
+
+    def setcookedpat(self, pat):
+        if self.isre():
+            pat = re.escape(pat)
+        self.setpat(pat)
+
+    def search_text(self, text, prog=None, ok=0):
+        """Search a text widget for the pattern.
+
+        If prog is given, it should be the precompiled pattern.
+        Return a tuple (lineno, matchobj); None if not found.
+
+        This obeys the wrap and direction (back) settings.
+
+        The search starts at the selection (if there is one) or
+        at the insert mark (otherwise).  If the search is forward,
+        it starts at the right of the selection; for a backward
+        search, it starts at the left end.  An empty match exactly
+        at either end of the selection (or at the insert mark if
+        there is no selection) is ignored  unless the ok flag is true
+        -- this is done to guarantee progress.
+
+        If the search is allowed to wrap around, it will return the
+        original selection if (and only if) it is the only match.
+
+        """
+        if not prog:
+            prog = self.getprog()
+            if not prog:
+                return None # Compilation failed -- stop
+        wrap = self.wrapvar.get()
+        first, last = get_selection(text)
+        if self.isback():
+            if ok:
+                start = last
+            else:
+                start = first
+            line, col = get_line_col(start)
+            res = self.search_backward(text, prog, line, col, wrap, ok)
+        else:
+            if ok:
+                start = first
+            else:
+                start = last
+            line, col = get_line_col(start)
+            res = self.search_forward(text, prog, line, col, wrap, ok)
+        return res
+
+    def search_forward(self, text, prog, line, col, wrap, ok=0):
+        wrapped = 0
+        startline = line
+        chars = text.get("%d.0" % line, "%d.0" % (line+1))
+        while chars:
+            m = prog.search(chars[:-1], col)
+            if m:
+                if ok or m.end() > col:
+                    return line, m
+            line = line + 1
+            if wrapped and line > startline:
+                break
+            col = 0
+            ok = 1
+            chars = text.get("%d.0" % line, "%d.0" % (line+1))
+            if not chars and wrap:
+                wrapped = 1
+                wrap = 0
+                line = 1
+                chars = text.get("1.0", "2.0")
+        return None
+
+    def search_backward(self, text, prog, line, col, wrap, ok=0):
+        wrapped = 0
+        startline = line
+        chars = text.get("%d.0" % line, "%d.0" % (line+1))
+        while 1:
+            m = search_reverse(prog, chars[:-1], col)
+            if m:
+                if ok or m.start() < col:
+                    return line, m
+            line = line - 1
+            if wrapped and line < startline:
+                break
+            ok = 1
+            if line <= 0:
+                if not wrap:
+                    break
+                wrapped = 1
+                wrap = 0
+                pos = text.index("end-1c")
+                line, col = map(int, string.split(pos, "."))
+            chars = text.get("%d.0" % line, "%d.0" % (line+1))
+            col = len(chars) - 1
+        return None
+
+# Helper to search backwards in a string.
+# (Optimized for the case where the pattern isn't found.)
+
+def search_reverse(prog, chars, col):
+    m = prog.search(chars)
+    if not m:
+        return None
+    found = None
+    i, j = m.span()
+    while i < col and j <= col:
+        found = m
+        if i == j:
+            j = j+1
+        m = prog.search(chars, j)
+        if not m:
+            break
+        i, j = m.span()
+    return found
+
+# Helper to get selection end points, defaulting to insert mark.
+# Return a tuple of indices ("line.col" strings).
+
+def get_selection(text):
+    try:
+        first = text.index("sel.first")
+        last = text.index("sel.last")
+    except TclError:
+        first = last = None
+    if not first:
+        first = text.index("insert")
+    if not last:
+        last = first
+    return first, last
+
+# Helper to parse a text index into a (line, col) tuple.
+
+def get_line_col(index):
+    line, col = map(int, string.split(index, ".")) # Fails on invalid index
+    return line, col
diff --git a/Lib/idlelib/Separator.py b/Lib/idlelib/Separator.py
new file mode 100644
index 0000000..2645e57
--- /dev/null
+++ b/Lib/idlelib/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/Lib/idlelib/StackViewer.py b/Lib/idlelib/StackViewer.py
new file mode 100644
index 0000000..5b3c87a
--- /dev/null
+++ b/Lib/idlelib/StackViewer.py
@@ -0,0 +1,135 @@
+import string
+from Tkinter import *
+import linecache
+
+from TreeWidget import TreeNode, TreeItem, ScrolledCanvas
+from ObjectBrowser import ObjectTreeItem, make_objecttreeitem
+from OldStackViewer import StackViewer, NamespaceViewer
+
+def StackBrowser(root, flist=None, stack=None):
+    top = Toplevel(root)
+    sc = ScrolledCanvas(top, bg="white", highlightthickness=0)
+    sc.frame.pack(expand=1, fill="both")
+    item = StackTreeItem(flist)
+    node = TreeNode(sc.canvas, None, item)
+    node.expand()
+
+class StackTreeItem(TreeItem):
+
+    def __init__(self, flist=None):
+        self.flist = flist
+        self.stack = get_stack()
+        self.text = get_exception()
+
+    def GetText(self):
+        return self.text
+
+    def GetSubList(self):
+        sublist = []
+        for info in self.stack:
+            item = FrameTreeItem(info, self.flist)
+            sublist.append(item)
+        return sublist
+
+class FrameTreeItem(TreeItem):
+
+    def __init__(self, info, flist):
+        self.info = info
+        self.flist = flist
+
+    def GetText(self):
+        frame, lineno = self.info
+        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 = string.strip(sourceline)
+        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
+        return item
+
+    def GetSubList(self):
+        frame, lineno = self.info
+        sublist = []
+        if frame.f_globals is not frame.f_locals:
+            item = VariablesTreeItem("<locals>", frame.f_locals, self.flist)
+            sublist.append(item)
+        item = VariablesTreeItem("<globals>", frame.f_globals, self.flist)
+        sublist.append(item)
+        return sublist
+
+    def OnDoubleClick(self):
+        if self.flist:
+            frame, lineno = self.info
+            filename = frame.f_code.co_filename
+            edit = self.flist.open(filename)
+            edit.gotoline(lineno)
+
+class VariablesTreeItem(ObjectTreeItem):
+
+    def GetText(self):
+        return self.labeltext
+
+    def GetLabelText(self):
+        return None
+
+    def IsExpandable(self):
+        return len(self.object) > 0
+
+    def keys(self):
+        return self.object.keys()
+
+    def GetSubList(self):
+        sublist = []
+        for key in self.keys():
+            try:
+                value = self.object[key]
+            except KeyError:
+                continue
+            def setfunction(value, key=key, object=self.object):
+                object[key] = value
+            item = make_objecttreeitem(key + " =", value, setfunction)
+            sublist.append(item)
+        return sublist
+        
+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 get_exception(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
+
+if __name__ == "__main__":
+    root = Tk()
+    root.withdraw()
+    StackBrowser(root)
diff --git a/Lib/idlelib/TODO.txt b/Lib/idlelib/TODO.txt
new file mode 100644
index 0000000..9701a87
--- /dev/null
+++ b/Lib/idlelib/TODO.txt
@@ -0,0 +1,205 @@
+
+TO DO:
+
+- improve debugger:
+    - manage breakpoints globally, allow bp deletion, tbreak, cbreak etc.
+    - real object browser
+    - help on how to use it (a simple help button will do wonders)
+    - performance?  (updates of large sets of locals are slow)
+    - better integration of "debug module"
+    - debugger should be global resource (attached to flist, not to shell)
+    - fix the stupid bug where you need to step twice
+    - display class name in stack viewer entries for methods
+    - suppress tracing through IDLE internals (e.g. print)
+    - add a button to suppress through a specific module or class or method
+- insert the initial current directory into sys.path
+- default directory attribute for each window instead of only for windows
+  that have an associated filename
+- command expansion from keywords, module contents, other buffers, etc.
+- "Recent documents" menu item
+- Filter region command
+- Optional horizontal scroll bar
+- more Emacsisms:
+    - ^K should cut to buffer
+    - M-[, M-] to move by paragraphs
+    - incremental search?
+- search should indicate wrap-around in some way
+- restructure state sensitive code to avoid testing flags all the time
+- persistent user state (e.g. window and cursor positions, bindings)
+- make backups when saving
+- check file mtimes at various points
+- Pluggable interface with RCS/CVS/Perforce/Clearcase
+- better help?
+- don't open second class browser on same module (nor second path browser)
+- unify class and path browsers
+- Need to define a standard way whereby one can determine one is running
+  inside IDLE (needed for Tk mainloop, also handy for $PYTHONSTARTUP)
+- Add more utility methods for use by extensions (a la get_selection)
+- Way to run command in totally separate interpreter (fork+os.system?)
+- Way to find definition of fully-qualified name:
+  In other words, select "UserDict.UserDict", hit some magic key and
+  it loads up UserDict.py and finds the first def or class for UserDict.
+- need a way to force colorization on/off
+- need a way to force auto-indent on/off
+
+Details:
+
+- when there's a selection, left/right arrow should go to either
+  end of the selection
+- ^O (on Unix -- open-line) should honor autoindent
+- after paste, show end of pasted text
+- on Windows, should turn short filename to long filename (not only in argv!)
+  (shouldn't this be done -- or undone -- by ntpath.normpath?)
+- new autoindent after colon even indents when the colon is in a comment!
+- sometimes forward slashes in pathname remain
+- sometimes star in window name remains in Windows menu
+- With unix bindings, ESC by itself is ignored
+- Sometimes for no apparent reason a selection from the cursor to the
+  end of the command buffer appears, which is hard to get rid of
+  because it stays when you are typing!
+- The Line/Col in the status bar can be wrong initially in PyShell
+
+Structural problems:
+
+- too much knowledge in FileList about EditorWindow (for example)
+- should add some primitives for accessing the selection etc.
+  to repeat cumbersome code over and over
+
+======================================================================
+
+Jeff Bauer suggests:
+
+- Open Module doesn't appear to handle hierarchical packages.
+- Class browser should also allow hierarchical packages.
+- Open and Open Module could benefit from a history,
+  either command line style, or Microsoft recent-file
+  style.
+- Add a Smalltalk-style inspector  (i.e. Tkinspect)
+
+The last suggestion is already a reality, but not yet
+integrated into IDLE.  I use a module called inspector.py,
+that used to be available from python.org(?)  It no longer
+appears to be in the contributed section, and the source
+has no author attribution.
+
+In any case, the code is useful for visually navigating
+an object's attributes, including its container hierarchy.
+
+    >>> from inspector import Tkinspect
+    >>> Tkinspect(None, myObject)
+
+Tkinspect could probably be extended and refined to
+integrate better into IDLE.
+
+======================================================================
+
+Comparison to PTUI
+------------------
+
++ PTUI's help is better (HTML!)
+
++ PTUI can attach a shell to any module
+
++ PTUI has some more I/O commands:
+  open multiple
+  append
+  examine (what's that?)
+
+======================================================================
+
+Notes after trying to run Grail
+-------------------------------
+
+- Grail does stuff to sys.path based on sys.argv[0]; you must set
+sys.argv[0] to something decent first (it is normally set to the path of
+the idle script).
+
+- Grail must be exec'ed in __main__ because that's imported by some
+other parts of Grail.
+
+- Grail uses a module called History and so does idle :-(
+
+======================================================================
+
+Robin Friedrich's items:
+
+Things I'd like to see:
+    - I'd like support for shift-click extending the selection. There's a
+      bug now that it doesn't work the first time you try it.
+    - Printing is needed. How hard can that be on Windows?
+    - The python-mode trick of autoindenting a line with <tab> is neat and
+      very handy.
+    - (someday) a spellchecker for docstrings and comments.
+    - a pagedown/up command key which moves to next class/def statement (top
+      level)
+    - split window capability
+    - DnD text relocation/copying
+
+Things I don't want to see.
+    - line numbers...  will probably slow things down way too much.
+    - Please use another icon for the tree browser leaf. The small snake
+      isn't cutting it.
+
+----------------------------------------------------------------------
+
+- Customizable views (multi-window or multi-pane).  (Markus Gritsch)
+
+- Being able to double click (maybe double right click) on a callable
+object in the editor which shows the source of the object, if
+possible.  (Gerrit Holl)
+
+- Hooks into the guts, like in Emacs.  (Mike Romberg)
+
+- Sharing the editor with a remote tutor.  (Martijn Faassen)
+
+- Multiple views on the same file.  (Tony J Ibbs)
+
+- Store breakpoints in a global (per-project) database (GvR); Dirk
+Heise adds: save some space-trimmed context and search around when
+reopening a file that might have been edited by someone else.
+
+- Capture menu events in extensions without changing the IDLE source.
+(Matthias Barmeier)
+
+- Use overlapping panels (a "notebook" in MFC terms I think) for info
+that doesn't need to be accessible simultaneously (e.g. HTML source
+and output).  Use multi-pane windows for info that does need to be
+shown together (e.g. class browser and source).  (Albert Brandl)
+
+- A project should invisibly track all symbols, for instant search,
+replace and cross-ref.  Projects should be allowed to span multiple
+directories, hosts, etc.  Project management files are placed in a
+directory you specify.  A global mapping between project names and
+project directories should exist [not so sure --GvR].  (Tim Peters)
+
+- Merge attr-tips and auto-expand.  (Mark Hammond, Tim Peters)
+
+- Python Shell should behave more like a "shell window" as users know
+it -- i.e. you can only edit the current command, and the cursor can't
+escape from the command area.  (Albert Brandl)
+
+- Set X11 class to "idle/Idle", set icon and title to something
+beginning with "idle" -- for window manangers.  (Randall Hopper)
+
+- Config files editable through a preferences dialog.  (me)
+
+- Config files still editable outside the preferences dialog.
+(Randall Hopper)
+
+- When you're editing a command in PyShell, and there are only blank
+lines below the cursor, hitting Return should ignore or delete those
+blank lines rather than deciding you're not on the last line.  (me)
+
+- Run command (F5 c.s.) should be more like Pythonwin's Run -- a
+dialog with options to give command line arguments, run the debugger,
+etc.  (me)
+
+- Shouldn't be able to delete part of the prompt (or any text before
+it) in the PyShell.  (Martijn Faassen)
+
+- Emacs style auto-fill (also smart about comments and strings).
+(Jeremy Hylton)
+
+- Output of Run Script should go to a separate output window, not to
+the shell window.  Output of separate runs should all go to the same
+window but clearly delimited.  (David Scherer)
diff --git a/Lib/idlelib/ToolTip.py b/Lib/idlelib/ToolTip.py
new file mode 100644
index 0000000..691f510
--- /dev/null
+++ b/Lib/idlelib/ToolTip.py
@@ -0,0 +1,87 @@
+# Ideas gleaned from PySol
+
+import os
+from Tkinter import *
+
+class ToolTipBase:
+
+    def __init__(self, button):
+        self.button = button
+        self.tipwindow = None
+        self.id = None
+        self.x = self.y = 0
+        self._id1 = self.button.bind("<Enter>", self.enter)
+        self._id2 = self.button.bind("<Leave>", self.leave)
+        self._id3 = self.button.bind("<ButtonPress>", self.leave)
+
+    def enter(self, event=None):
+        self.schedule()
+
+    def leave(self, event=None):
+        self.unschedule()
+        self.hidetip()
+
+    def schedule(self):
+        self.unschedule()
+        self.id = self.button.after(1500, self.showtip)
+
+    def unschedule(self):
+        id = self.id
+        self.id = None
+        if id:
+            self.button.after_cancel(id)
+
+    def showtip(self):
+        if self.tipwindow:
+            return
+        # The tip window must be completely outside the button;
+        # otherwise when the mouse enters the tip window we get
+        # a leave event and it disappears, and then we get an enter
+        # event and it reappears, and so on forever :-(
+        x = self.button.winfo_rootx() + 20
+        y = self.button.winfo_rooty() + self.button.winfo_height() + 1
+        self.tipwindow = tw = Toplevel(self.button)
+        tw.wm_overrideredirect(1)
+        tw.wm_geometry("+%d+%d" % (x, y))
+        self.showcontents()
+
+    def showcontents(self, text="Your text here"):
+        # Override this in derived class
+        label = Label(self.tipwindow, text=text, justify=LEFT,
+                      background="#ffffe0", relief=SOLID, borderwidth=1)
+        label.pack()
+
+    def hidetip(self):
+        tw = self.tipwindow
+        self.tipwindow = None
+        if tw:
+            tw.destroy()
+
+class ToolTip(ToolTipBase):
+    def __init__(self, button, text):
+        ToolTipBase.__init__(self, button)
+        self.text = text
+    def showcontents(self):
+        ToolTipBase.showcontents(self, self.text)
+
+class ListboxToolTip(ToolTipBase):
+    def __init__(self, button, items):
+        ToolTipBase.__init__(self, button)
+        self.items = items
+    def showcontents(self):
+        listbox = Listbox(self.tipwindow, background="#ffffe0")
+        listbox.pack()
+        for item in self.items:
+            listbox.insert(END, item)
+
+def main():
+    # Test code
+    root = Tk()
+    b = Button(root, text="Hello", command=root.destroy)
+    b.pack()
+    root.update()
+    tip = ListboxToolTip(b, ["Hello", "world"])
+    
+    # root.mainloop() # not in idle
+
+main()
diff --git a/Lib/idlelib/TreeWidget.py b/Lib/idlelib/TreeWidget.py
new file mode 100644
index 0000000..60eefdc
--- /dev/null
+++ b/Lib/idlelib/TreeWidget.py
@@ -0,0 +1,471 @@
+# XXX TO DO:
+# - popup menu
+# - support partial or total redisplay
+# - key bindings (instead of quick-n-dirty bindings on Canvas):
+#   - up/down arrow keys to move focus around
+#   - ditto for page up/down, home/end
+#   - left/right arrows to expand/collapse & move out/in
+# - more doc strings
+# - add icons for "file", "module", "class", "method"; better "python" icon
+# - callback for selection???
+# - multiple-item selection
+# - tooltips
+# - redo geometry without magic numbers
+# - keep track of object ids to allow more careful cleaning
+# - optimize tree redraw after expand of subnode
+
+import os
+import sys
+import string
+from Tkinter import *
+import imp
+
+import ZoomHeight
+
+ICONDIR = "Icons"
+
+# Look for Icons subdirectory in the same directory as this module
+try:
+    _icondir = os.path.join(os.path.dirname(__file__), ICONDIR)
+except NameError:
+    _icondir = ICONDIR
+if os.path.isdir(_icondir):
+    ICONDIR = _icondir
+elif not os.path.isdir(ICONDIR):
+    raise RuntimeError, "can't find icon directory (%s)" % `ICONDIR`
+
+def listicons(icondir=ICONDIR):
+    """Utility to display the available icons."""
+    root = Tk()
+    import glob
+    list = glob.glob(os.path.join(icondir, "*.gif"))
+    list.sort()
+    images = []
+    row = column = 0
+    for file in list:
+        name = os.path.splitext(os.path.basename(file))[0]
+        image = PhotoImage(file=file, master=root)
+        images.append(image)
+        label = Label(root, image=image, bd=1, relief="raised")
+        label.grid(row=row, column=column)
+        label = Label(root, text=name)
+        label.grid(row=row+1, column=column)
+        column = column + 1
+        if column >= 10:
+            row = row+2
+            column = 0
+    root.images = images
+
+
+class TreeNode:
+
+    def __init__(self, canvas, parent, item):
+        self.canvas = canvas
+        self.parent = parent
+        self.item = item
+        self.state = 'collapsed'
+        self.selected = 0
+        self.children = []
+        self.x = self.y = None
+        self.iconimages = {} # cache of PhotoImage instances for icons
+
+    def destroy(self):
+        for c in self.children[:]:
+            self.children.remove(c)
+            c.destroy()
+        self.parent = None
+
+    def geticonimage(self, name):
+        try:
+            return self.iconimages[name]
+        except KeyError:
+            pass
+        file, ext = os.path.splitext(name)
+        ext = ext or ".gif"
+        fullname = os.path.join(ICONDIR, file + ext)
+        image = PhotoImage(master=self.canvas, file=fullname)
+        self.iconimages[name] = image
+        return image
+
+    def select(self, event=None):
+        if self.selected:
+            return
+        self.deselectall()
+        self.selected = 1
+        self.canvas.delete(self.image_id)
+        self.drawicon()
+        self.drawtext()
+
+    def deselect(self, event=None):
+        if not self.selected:
+            return
+        self.selected = 0
+        self.canvas.delete(self.image_id)
+        self.drawicon()
+        self.drawtext()
+
+    def deselectall(self):
+        if self.parent:
+            self.parent.deselectall()
+        else:
+            self.deselecttree()
+
+    def deselecttree(self):
+        if self.selected:
+            self.deselect()
+        for child in self.children:
+            child.deselecttree()
+
+    def flip(self, event=None):
+        if self.state == 'expanded':
+            self.collapse()
+        else:
+            self.expand()
+        self.item.OnDoubleClick()
+        return "break"
+
+    def expand(self, event=None):
+        if not self.item._IsExpandable():
+            return
+        if self.state != 'expanded':
+            self.state = 'expanded'
+            self.update()
+            self.view()
+
+    def collapse(self, event=None):
+        if self.state != 'collapsed':
+            self.state = 'collapsed'
+            self.update()
+
+    def view(self):
+        top = self.y - 2
+        bottom = self.lastvisiblechild().y + 17
+        height = bottom - top
+        visible_top = self.canvas.canvasy(0)
+        visible_height = self.canvas.winfo_height()
+        visible_bottom = self.canvas.canvasy(visible_height)
+        if visible_top <= top and bottom <= visible_bottom:
+            return
+        x0, y0, x1, y1 = self.canvas._getints(self.canvas['scrollregion'])
+        if top >= visible_top and height <= visible_height:
+            fraction = top + height - visible_height
+        else:
+            fraction = top
+        fraction = float(fraction) / y1
+        self.canvas.yview_moveto(fraction)
+
+    def lastvisiblechild(self):
+        if self.children and self.state == 'expanded':
+            return self.children[-1].lastvisiblechild()
+        else:
+            return self
+
+    def update(self):
+        if self.parent:
+            self.parent.update()
+        else:
+            oldcursor = self.canvas['cursor']
+            self.canvas['cursor'] = "watch"
+            self.canvas.update()
+            self.canvas.delete(ALL)     # XXX could be more subtle
+            self.draw(7, 2)
+            x0, y0, x1, y1 = self.canvas.bbox(ALL)
+            self.canvas.configure(scrollregion=(0, 0, x1, y1))
+            self.canvas['cursor'] = oldcursor
+
+    def draw(self, x, y):
+        # XXX This hard-codes too many geometry constants!
+        self.x, self.y = x, y
+        self.drawicon()
+        self.drawtext()
+        if self.state != 'expanded':
+            return y+17
+        # draw children
+        if not self.children:
+            sublist = self.item._GetSubList()
+            if not sublist:
+                # _IsExpandable() was mistaken; that's allowed
+                return y+17
+            for item in sublist:
+                child = TreeNode(self.canvas, self, item)
+                self.children.append(child)
+        cx = x+20
+        cy = y+17
+        cylast = 0
+        for child in self.children:
+            cylast = cy
+            self.canvas.create_line(x+9, cy+7, cx, cy+7, fill="gray50")
+            cy = child.draw(cx, cy)
+            if child.item._IsExpandable():
+                if child.state == 'expanded':
+                    iconname = "minusnode"
+                    callback = child.collapse
+                else:
+                    iconname = "plusnode"
+                    callback = child.expand
+                image = self.geticonimage(iconname)
+                id = self.canvas.create_image(x+9, cylast+7, image=image)
+                # XXX This leaks bindings until canvas is deleted:
+                self.canvas.tag_bind(id, "<1>", callback)
+                self.canvas.tag_bind(id, "<Double-1>", lambda x: None)
+        id = self.canvas.create_line(x+9, y+10, x+9, cylast+7,
+            ##stipple="gray50",     # XXX Seems broken in Tk 8.0.x
+            fill="gray50")
+        self.canvas.tag_lower(id) # XXX .lower(id) before Python 1.5.2
+        return cy
+
+    def drawicon(self):
+        if self.selected:
+            imagename = (self.item.GetSelectedIconName() or
+                         self.item.GetIconName() or
+                         "openfolder")
+        else:
+            imagename = self.item.GetIconName() or "folder"
+        image = self.geticonimage(imagename)
+        id = self.canvas.create_image(self.x, self.y, anchor="nw", image=image)
+        self.image_id = id
+        self.canvas.tag_bind(id, "<1>", self.select)
+        self.canvas.tag_bind(id, "<Double-1>", self.flip)
+
+    def drawtext(self):
+        textx = self.x+20-1
+        texty = self.y-1
+        labeltext = self.item.GetLabelText()
+        if labeltext:
+            id = self.canvas.create_text(textx, texty, anchor="nw",
+                                         text=labeltext)
+            self.canvas.tag_bind(id, "<1>", self.select)
+            self.canvas.tag_bind(id, "<Double-1>", self.flip)
+            x0, y0, x1, y1 = self.canvas.bbox(id)
+            textx = max(x1, 200) + 10
+        text = self.item.GetText() or "<no text>"
+        try:
+            self.entry
+        except AttributeError:
+            pass
+        else:
+            self.edit_finish()
+        try:
+            label = self.label
+        except AttributeError:
+            # padding carefully selected (on Windows) to match Entry widget:
+            self.label = Label(self.canvas, text=text, bd=0, padx=2, pady=2)
+        if self.selected:
+            self.label.configure(fg="white", bg="darkblue")
+        else:
+            self.label.configure(fg="black", bg="white")
+        id = self.canvas.create_window(textx, texty,
+                                       anchor="nw", window=self.label)
+        self.label.bind("<1>", self.select_or_edit)
+        self.label.bind("<Double-1>", self.flip)
+        self.text_id = id
+
+    def select_or_edit(self, event=None):
+        if self.selected and self.item.IsEditable():
+            self.edit(event)
+        else:
+            self.select(event)
+
+    def edit(self, event=None):
+        self.entry = Entry(self.label, bd=0, highlightthickness=1, width=0)
+        self.entry.insert(0, self.label['text'])
+        self.entry.selection_range(0, END)
+        self.entry.pack(ipadx=5)
+        self.entry.focus_set()
+        self.entry.bind("<Return>", self.edit_finish)
+        self.entry.bind("<Escape>", self.edit_cancel)
+
+    def edit_finish(self, event=None):
+        try:
+            entry = self.entry
+            del self.entry
+        except AttributeError:
+            return
+        text = entry.get()
+        entry.destroy()
+        if text and text != self.item.GetText():
+            self.item.SetText(text)
+        text = self.item.GetText()
+        self.label['text'] = text
+        self.drawtext()
+        self.canvas.focus_set()
+
+    def edit_cancel(self, event=None):
+        self.drawtext()
+        self.canvas.focus_set()
+
+
+class TreeItem:
+
+    """Abstract class representing tree items.
+
+    Methods should typically be overridden, otherwise a default action
+    is used.
+
+    """
+
+    def __init__(self):
+        """Constructor.  Do whatever you need to do."""
+
+    def GetText(self):
+        """Return text string to display."""
+
+    def GetLabelText(self):
+        """Return label text string to display in front of text (if any)."""
+
+    expandable = None
+
+    def _IsExpandable(self):
+        """Do not override!  Called by TreeNode."""
+        if self.expandable is None:
+            self.expandable = self.IsExpandable()
+        return self.expandable
+
+    def IsExpandable(self):
+        """Return whether there are subitems."""
+        return 1
+
+    def _GetSubList(self):
+        """Do not override!  Called by TreeNode."""
+        if not self.IsExpandable():
+            return []
+        sublist = self.GetSubList()
+        if not sublist:
+            self.expandable = 0
+        return sublist
+
+    def IsEditable(self):
+        """Return whether the item's text may be edited."""
+
+    def SetText(self, text):
+        """Change the item's text (if it is editable)."""
+
+    def GetIconName(self):
+        """Return name of icon to be displayed normally."""
+
+    def GetSelectedIconName(self):
+        """Return name of icon to be displayed when selected."""
+
+    def GetSubList(self):
+        """Return list of items forming sublist."""
+
+    def OnDoubleClick(self):
+        """Called on a double-click on the item."""
+
+
+# Example application
+
+class FileTreeItem(TreeItem):
+
+    """Example TreeItem subclass -- browse the file system."""
+
+    def __init__(self, path):
+        self.path = path
+
+    def GetText(self):
+        return os.path.basename(self.path) or self.path
+
+    def IsEditable(self):
+        return os.path.basename(self.path) != ""
+
+    def SetText(self, text):
+        newpath = os.path.dirname(self.path)
+        newpath = os.path.join(newpath, text)
+        if os.path.dirname(newpath) != os.path.dirname(self.path):
+            return
+        try:
+            os.rename(self.path, newpath)
+            self.path = newpath
+        except os.error:
+            pass
+
+    def GetIconName(self):
+        if not self.IsExpandable():
+            return "python" # XXX wish there was a "file" icon
+
+    def IsExpandable(self):
+        return os.path.isdir(self.path)
+
+    def GetSubList(self):
+        try:
+            names = os.listdir(self.path)
+        except os.error:
+            return []
+        names.sort(lambda a, b: cmp(os.path.normcase(a), os.path.normcase(b)))
+        sublist = []
+        for name in names:
+            item = FileTreeItem(os.path.join(self.path, name))
+            sublist.append(item)
+        return sublist
+
+
+# A canvas widget with scroll bars and some useful bindings
+
+class ScrolledCanvas:
+    def __init__(self, master, **opts):
+        if not opts.has_key('yscrollincrement'):
+            opts['yscrollincrement'] = 17
+        self.master = master
+        self.frame = Frame(master)
+        self.frame.rowconfigure(0, weight=1)
+        self.frame.columnconfigure(0, weight=1)
+        self.canvas = apply(Canvas, (self.frame,), opts)
+        self.canvas.grid(row=0, column=0, sticky="nsew")
+        self.vbar = Scrollbar(self.frame, name="vbar")
+        self.vbar.grid(row=0, column=1, sticky="nse")
+        self.hbar = Scrollbar(self.frame, name="hbar", orient="horizontal")
+        self.hbar.grid(row=1, column=0, sticky="ews")
+        self.canvas['yscrollcommand'] = self.vbar.set
+        self.vbar['command'] = self.canvas.yview
+        self.canvas['xscrollcommand'] = self.hbar.set
+        self.hbar['command'] = self.canvas.xview
+        self.canvas.bind("<Key-Prior>", self.page_up)
+        self.canvas.bind("<Key-Next>", self.page_down)
+        self.canvas.bind("<Key-Up>", self.unit_up)
+        self.canvas.bind("<Key-Down>", self.unit_down)
+        if isinstance(master, Toplevel) or isinstance(master, Tk):
+            self.canvas.bind("<Alt-F2>", self.zoom_height)
+        self.canvas.focus_set()
+    def page_up(self, event):
+        self.canvas.yview_scroll(-1, "page")
+        return "break"
+    def page_down(self, event):
+        self.canvas.yview_scroll(1, "page")
+        return "break"
+    def unit_up(self, event):
+        self.canvas.yview_scroll(-1, "unit")
+        return "break"
+    def unit_down(self, event):
+        self.canvas.yview_scroll(1, "unit")
+        return "break"
+    def zoom_height(self, event):
+        ZoomHeight.zoom_height(self.master)
+        return "break"
+
+
+# Testing functions
+
+def test():
+    import PyShell
+    root = Toplevel(PyShell.root)
+    root.configure(bd=0, bg="yellow")
+    root.focus_set()
+    sc = ScrolledCanvas(root, bg="white", highlightthickness=0, takefocus=1)
+    sc.frame.pack(expand=1, fill="both")
+    item = FileTreeItem("C:/windows/desktop")
+    node = TreeNode(sc.canvas, None, item)
+    node.expand()
+
+def test2():
+    # test w/o scrolling canvas
+    root = Tk()
+    root.configure(bd=0)
+    canvas = Canvas(root, bg="white", highlightthickness=0)
+    canvas.pack(expand=1, fill="both")
+    item = FileTreeItem(os.curdir)
+    node = TreeNode(canvas, None, item)
+    node.update()
+    canvas.focus_set()
+
+if __name__ == '__main__':
+    test()
diff --git a/Lib/idlelib/UndoDelegator.py b/Lib/idlelib/UndoDelegator.py
new file mode 100644
index 0000000..ec7af81
--- /dev/null
+++ b/Lib/idlelib/UndoDelegator.py
@@ -0,0 +1,352 @@
+import sys
+import string
+from Tkinter import *
+from Delegator import Delegator
+
+#$ event <<redo>>
+#$ win <Control-y>
+#$ unix <Alt-z>
+
+#$ event <<undo>>
+#$ win <Control-z>
+#$ unix <Control-z>
+
+#$ event <<dump-undo-state>>
+#$ win <Control-backslash>
+#$ unix <Control-backslash>
+
+
+class UndoDelegator(Delegator):
+
+    max_undo = 1000
+
+    def __init__(self):
+        Delegator.__init__(self)
+        self.reset_undo()
+
+    def setdelegate(self, delegate):
+        if self.delegate is not None:
+            self.unbind("<<undo>>")
+            self.unbind("<<redo>>")
+            self.unbind("<<dump-undo-state>>")
+        Delegator.setdelegate(self, delegate)
+        if delegate is not None:
+            self.bind("<<undo>>", self.undo_event)
+            self.bind("<<redo>>", self.redo_event)
+            self.bind("<<dump-undo-state>>", self.dump_event)
+
+    def dump_event(self, event):
+        from pprint import pprint
+        pprint(self.undolist[:self.pointer])
+        print "pointer:", self.pointer,
+        print "saved:", self.saved,
+        print "can_merge:", self.can_merge,
+        print "get_saved():", self.get_saved()
+        pprint(self.undolist[self.pointer:])
+        return "break"
+
+    def reset_undo(self):
+        self.was_saved = -1
+        self.pointer = 0
+        self.undolist = []
+        self.undoblock = 0  # or a CommandSequence instance
+        self.set_saved(1)
+
+    def set_saved(self, flag):
+        if flag:
+            self.saved = self.pointer
+        else:
+            self.saved = -1
+        self.can_merge = 0
+        self.check_saved()
+
+    def get_saved(self):
+        return self.saved == self.pointer
+
+    saved_change_hook = None
+
+    def set_saved_change_hook(self, hook):
+        self.saved_change_hook = hook
+
+    was_saved = -1
+
+    def check_saved(self):
+        is_saved = self.get_saved()
+        if is_saved != self.was_saved:
+            self.was_saved = is_saved
+            if self.saved_change_hook:
+                self.saved_change_hook()
+
+    def insert(self, index, chars, tags=None):
+        self.addcmd(InsertCommand(index, chars, tags))
+
+    def delete(self, index1, index2=None):
+        self.addcmd(DeleteCommand(index1, index2))
+
+    # Clients should call undo_block_start() and undo_block_stop()
+    # around a sequence of editing cmds to be treated as a unit by
+    # undo & redo.  Nested matching calls are OK, and the inner calls
+    # then act like nops.  OK too if no editing cmds, or only one
+    # editing cmd, is issued in between:  if no cmds, the whole
+    # sequence has no effect; and if only one cmd, that cmd is entered
+    # directly into the undo list, as if undo_block_xxx hadn't been
+    # called.  The intent of all that is to make this scheme easy
+    # to use:  all the client has to worry about is making sure each
+    # _start() call is matched by a _stop() call.
+
+    def undo_block_start(self):
+        if self.undoblock == 0:
+            self.undoblock = CommandSequence()
+        self.undoblock.bump_depth()
+
+    def undo_block_stop(self):
+        if self.undoblock.bump_depth(-1) == 0:
+            cmd = self.undoblock
+            self.undoblock = 0
+            if len(cmd) > 0:
+                if len(cmd) == 1:
+                    # no need to wrap a single cmd
+                    cmd = cmd.getcmd(0)
+                # this blk of cmds, or single cmd, has already
+                # been done, so don't execute it again
+                self.addcmd(cmd, 0)
+
+    def addcmd(self, cmd, execute=1):
+        if execute:
+            cmd.do(self.delegate)
+        if self.undoblock != 0:
+            self.undoblock.append(cmd)
+            return
+        if self.can_merge and self.pointer > 0:
+            lastcmd = self.undolist[self.pointer-1]
+            if lastcmd.merge(cmd):
+                return
+        self.undolist[self.pointer:] = [cmd]
+        if self.saved > self.pointer:
+            self.saved = -1
+        self.pointer = self.pointer + 1
+        if len(self.undolist) > self.max_undo:
+            ##print "truncating undo list"
+            del self.undolist[0]
+            self.pointer = self.pointer - 1
+            if self.saved >= 0:
+                self.saved = self.saved - 1
+        self.can_merge = 1
+        self.check_saved()
+
+    def undo_event(self, event):
+        if self.pointer == 0:
+            self.bell()
+            return "break"
+        cmd = self.undolist[self.pointer - 1]
+        cmd.undo(self.delegate)
+        self.pointer = self.pointer - 1
+        self.can_merge = 0
+        self.check_saved()
+        return "break"
+
+    def redo_event(self, event):
+        if self.pointer >= len(self.undolist):
+            self.bell()
+            return "break"
+        cmd = self.undolist[self.pointer]
+        cmd.redo(self.delegate)
+        self.pointer = self.pointer + 1
+        self.can_merge = 0
+        self.check_saved()
+        return "break"
+
+
+class Command:
+
+    # Base class for Undoable commands
+
+    tags = None
+
+    def __init__(self, index1, index2, chars, tags=None):
+        self.marks_before = {}
+        self.marks_after = {}
+        self.index1 = index1
+        self.index2 = index2
+        self.chars = chars
+        if tags:
+            self.tags = tags
+
+    def __repr__(self):
+        s = self.__class__.__name__
+        t = (self.index1, self.index2, self.chars, self.tags)
+        if self.tags is None:
+            t = t[:-1]
+        return s + `t`
+
+    def do(self, text):
+        pass
+
+    def redo(self, text):
+        pass
+
+    def undo(self, text):
+        pass
+
+    def merge(self, cmd):
+        return 0
+
+    def save_marks(self, text):
+        marks = {}
+        for name in text.mark_names():
+            if name != "insert" and name != "current":
+                marks[name] = text.index(name)
+        return marks
+
+    def set_marks(self, text, marks):
+        for name, index in marks.items():
+            text.mark_set(name, index)
+
+
+class InsertCommand(Command):
+
+    # Undoable insert command
+
+    def __init__(self, index1, chars, tags=None):
+        Command.__init__(self, index1, None, chars, tags)
+
+    def do(self, text):
+        self.marks_before = self.save_marks(text)
+        self.index1 = text.index(self.index1)
+        if text.compare(self.index1, ">", "end-1c"):
+            # Insert before the final newline
+            self.index1 = text.index("end-1c")
+        text.insert(self.index1, self.chars, self.tags)
+        self.index2 = text.index("%s+%dc" % (self.index1, len(self.chars)))
+        self.marks_after = self.save_marks(text)
+        ##sys.__stderr__.write("do: %s\n" % self)
+
+    def redo(self, text):
+        text.mark_set('insert', self.index1)
+        text.insert(self.index1, self.chars, self.tags)
+        self.set_marks(text, self.marks_after)
+        text.see('insert')
+        ##sys.__stderr__.write("redo: %s\n" % self)
+
+    def undo(self, text):
+        text.mark_set('insert', self.index1)
+        text.delete(self.index1, self.index2)
+        self.set_marks(text, self.marks_before)
+        text.see('insert')
+        ##sys.__stderr__.write("undo: %s\n" % self)
+
+    def merge(self, cmd):
+        if self.__class__ is not cmd.__class__:
+            return 0
+        if self.index2 != cmd.index1:
+            return 0
+        if self.tags != cmd.tags:
+            return 0
+        if len(cmd.chars) != 1:
+            return 0
+        if self.chars and \
+           self.classify(self.chars[-1]) != self.classify(cmd.chars):
+            return 0
+        self.index2 = cmd.index2
+        self.chars = self.chars + cmd.chars
+        return 1
+
+    alphanumeric = string.letters + string.digits + "_"
+
+    def classify(self, c):
+        if c in self.alphanumeric:
+            return "alphanumeric"
+        if c == "\n":
+            return "newline"
+        return "punctuation"
+
+
+class DeleteCommand(Command):
+
+    # Undoable delete command
+
+    def __init__(self, index1, index2=None):
+        Command.__init__(self, index1, index2, None, None)
+
+    def do(self, text):
+        self.marks_before = self.save_marks(text)
+        self.index1 = text.index(self.index1)
+        if self.index2:
+            self.index2 = text.index(self.index2)
+        else:
+            self.index2 = text.index(self.index1 + " +1c")
+        if text.compare(self.index2, ">", "end-1c"):
+            # Don't delete the final newline
+            self.index2 = text.index("end-1c")
+        self.chars = text.get(self.index1, self.index2)
+        text.delete(self.index1, self.index2)
+        self.marks_after = self.save_marks(text)
+        ##sys.__stderr__.write("do: %s\n" % self)
+
+    def redo(self, text):
+        text.mark_set('insert', self.index1)
+        text.delete(self.index1, self.index2)
+        self.set_marks(text, self.marks_after)
+        text.see('insert')
+        ##sys.__stderr__.write("redo: %s\n" % self)
+
+    def undo(self, text):
+        text.mark_set('insert', self.index1)
+        text.insert(self.index1, self.chars)
+        self.set_marks(text, self.marks_before)
+        text.see('insert')
+        ##sys.__stderr__.write("undo: %s\n" % self)
+
+class CommandSequence(Command):
+
+    # Wrapper for a sequence of undoable cmds to be undone/redone
+    # as a unit
+
+    def __init__(self):
+        self.cmds = []
+        self.depth = 0
+
+    def __repr__(self):
+        s = self.__class__.__name__
+        strs = []
+        for cmd in self.cmds:
+            strs.append("    " + `cmd`)
+        return s + "(\n" + string.join(strs, ",\n") + "\n)"
+
+    def __len__(self):
+        return len(self.cmds)
+
+    def append(self, cmd):
+        self.cmds.append(cmd)
+
+    def getcmd(self, i):
+        return self.cmds[i]
+
+    def redo(self, text):
+        for cmd in self.cmds:
+            cmd.redo(text)
+
+    def undo(self, text):
+        cmds = self.cmds[:]
+        cmds.reverse()
+        for cmd in cmds:
+            cmd.undo(text)
+
+    def bump_depth(self, incr=1):
+        self.depth = self.depth + incr
+        return self.depth
+
+def main():
+    from Percolator import Percolator
+    root = Tk()
+    root.wm_protocol("WM_DELETE_WINDOW", root.quit)
+    text = Text()
+    text.pack()
+    text.focus_set()
+    p = Percolator(text)
+    d = UndoDelegator()
+    p.insertfilter(d)
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/idlelib/WidgetRedirector.py b/Lib/idlelib/WidgetRedirector.py
new file mode 100644
index 0000000..b49ccf1
--- /dev/null
+++ b/Lib/idlelib/WidgetRedirector.py
@@ -0,0 +1,92 @@
+from Tkinter import *
+
+
+class WidgetRedirector:
+
+    """Support for redirecting arbitrary widget subcommands."""
+
+    def __init__(self, widget):
+        self.dict = {}
+        self.widget = widget
+        self.tk = tk = widget.tk
+        w = widget._w
+        self.orig = w + "_orig"
+        tk.call("rename", w, self.orig)
+        tk.createcommand(w, self.dispatch)
+
+    def __repr__(self):
+        return "WidgetRedirector(%s<%s>)" % (self.widget.__class__.__name__,
+                                             self.widget._w)
+
+    def close(self):
+        for name in self.dict.keys():
+            self.unregister(name)
+        widget = self.widget; del self.widget
+        orig = self.orig; del self.orig
+        tk = widget.tk
+        w = widget._w
+        tk.deletecommand(w)
+        tk.call("rename", orig, w)
+
+    def register(self, name, function):
+        if self.dict.has_key(name):
+            previous = dict[name]
+        else:
+            previous = OriginalCommand(self, name)
+        self.dict[name] = function
+        setattr(self.widget, name, function)
+        return previous
+
+    def unregister(self, name):
+        if self.dict.has_key(name):
+            function = self.dict[name]
+            del self.dict[name]
+            if hasattr(self.widget, name):
+                delattr(self.widget, name)
+            return function
+        else:
+            return None
+
+    def dispatch(self, cmd, *args):
+        m = self.dict.get(cmd)
+        try:
+            if m:
+                return apply(m, args)
+            else:
+                return self.tk.call((self.orig, cmd) + args)
+        except TclError:
+            return ""
+
+
+class OriginalCommand:
+
+    def __init__(self, redir, name):
+        self.redir = redir
+        self.name = name
+        self.tk = redir.tk
+        self.orig = redir.orig
+        self.tk_call = self.tk.call
+        self.orig_and_name = (self.orig, self.name)
+
+    def __repr__(self):
+        return "OriginalCommand(%s, %s)" % (`self.redir`, `self.name`)
+
+    def __call__(self, *args):
+        return self.tk_call(self.orig_and_name + args)
+
+
+def main():
+    root = Tk()
+    text = Text()
+    text.pack()
+    text.focus_set()
+    redir = WidgetRedirector(text)
+    global orig_insert
+    def my_insert(*args):
+        print "insert", args
+        apply(orig_insert, args)
+    orig_insert = redir.register("insert", my_insert)
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/idlelib/WindowList.py b/Lib/idlelib/WindowList.py
new file mode 100644
index 0000000..6de3e58
--- /dev/null
+++ b/Lib/idlelib/WindowList.py
@@ -0,0 +1,85 @@
+from Tkinter import *
+
+class WindowList:
+
+    def __init__(self):
+        self.dict = {}
+        self.callbacks = []
+
+    def add(self, window):
+        window.after_idle(self.call_callbacks)
+        self.dict[str(window)] = window
+
+    def delete(self, window):
+        try:
+            del self.dict[str(window)]
+        except KeyError:
+            # Sometimes, destroy() is called twice
+            pass
+        self.call_callbacks()
+
+    def add_windows_to_menu(self,  menu):
+        list = []
+        for key in self.dict.keys():
+            window = self.dict[key]
+            try:
+                title = window.get_title()
+            except TclError:
+                continue
+            list.append((title, window))
+        list.sort()
+        for title, window in list:
+            if title == "Python Shell":
+                # Hack -- until we have a better way to this
+                continue
+            menu.add_command(label=title, command=window.wakeup)
+
+    def register_callback(self, callback):
+        self.callbacks.append(callback)
+
+    def unregister_callback(self, callback):
+        try:
+           self.callbacks.remove(callback)
+        except ValueError:
+            pass
+
+    def call_callbacks(self):
+        for callback in self.callbacks:
+            try:
+                callback()
+            except:
+                print "warning: callback failed in WindowList", \
+                      sys.exc_type, ":", sys.exc_value
+
+registry = WindowList()
+
+add_windows_to_menu = registry.add_windows_to_menu
+register_callback = registry.register_callback
+unregister_callback = registry.unregister_callback
+
+
+class ListedToplevel(Toplevel):
+
+    def __init__(self, master, **kw):
+        Toplevel.__init__(self, master, kw)
+        registry.add(self)
+
+    def destroy(self):
+        registry.delete(self)
+        Toplevel.destroy(self)
+
+    def get_title(self):
+        # Subclass can override
+        return self.wm_title()
+
+    def wakeup(self):
+        try:
+            if self.wm_state() == "iconic":
+                self.wm_deiconify()
+            else:
+                self.tkraise()
+            self.focus_set()
+        except TclError:
+            # This can happen when the window menu was torn off.
+            # Simply ignore it.
+            pass
diff --git a/Lib/idlelib/ZoomHeight.py b/Lib/idlelib/ZoomHeight.py
new file mode 100644
index 0000000..ecc306a
--- /dev/null
+++ b/Lib/idlelib/ZoomHeight.py
@@ -0,0 +1,46 @@
+# Sample extension: zoom a window to maximum height
+
+import re
+import sys
+
+class ZoomHeight:
+
+    menudefs = [
+        ('windows', [
+            ('_Zoom Height', '<<zoom-height>>'),
+         ])
+    ]
+
+    windows_keydefs = {
+        '<<zoom-height>>': ['<Alt-F2>'],
+    }
+    unix_keydefs = {
+        '<<zoom-height>>': ['<Control-x><Control-z>'],
+    }
+
+    def __init__(self, editwin):
+        self.editwin = editwin
+
+    def zoom_height_event(self, event):
+        top = self.editwin.top
+        zoom_height(top)
+
+def zoom_height(top):
+    geom = top.wm_geometry()
+    m = re.match(r"(\d+)x(\d+)\+(-?\d+)\+(-?\d+)", geom)
+    if not m:
+        top.bell()
+        return
+    width, height, x, y = map(int, m.groups())
+    newheight = top.winfo_screenheight()
+    if sys.platform == 'win32':
+        newy = 0
+        newheight = newheight - 72
+    else:
+        newy = 24
+        newheight = newheight - 96
+    if height >= newheight:
+        newgeom = ""
+    else:
+        newgeom = "%dx%d+%d+%d" % (width, newheight, x, newy)
+    top.wm_geometry(newgeom)
diff --git a/Lib/idlelib/__init__.py b/Lib/idlelib/__init__.py
new file mode 100644
index 0000000..4c5b567
--- /dev/null
+++ b/Lib/idlelib/__init__.py
@@ -0,0 +1 @@
+# Dummy file to make this a potential package.
diff --git a/Lib/idlelib/config-unix.txt b/Lib/idlelib/config-unix.txt
new file mode 100644
index 0000000..be9fa81
--- /dev/null
+++ b/Lib/idlelib/config-unix.txt
@@ -0,0 +1,3 @@
+[EditorWindow]
+font-name= courier
+font-size= 10
diff --git a/Lib/idlelib/config-win.txt b/Lib/idlelib/config-win.txt
new file mode 100644
index 0000000..9faa635
--- /dev/null
+++ b/Lib/idlelib/config-win.txt
@@ -0,0 +1,3 @@
+[EditorWindow]
+font-name: courier new
+font-size: 10
diff --git a/Lib/idlelib/config.txt b/Lib/idlelib/config.txt
new file mode 100644
index 0000000..586a8d8
--- /dev/null
+++ b/Lib/idlelib/config.txt
@@ -0,0 +1,66 @@
+# 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 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]    # disabled in favor of ExecBinding
+
+[ExecBinding]
+
+[CallTips]
+
+[ParenMatch]
+enable= 0
+style= expression
+flash-delay= 500
+bell= 1
+hilite-foreground= black
+hilite-background= #43cd80
diff --git a/Lib/idlelib/eventparse.py b/Lib/idlelib/eventparse.py
new file mode 100644
index 0000000..cb2028d
--- /dev/null
+++ b/Lib/idlelib/eventparse.py
@@ -0,0 +1,93 @@
+#! /usr/bin/env python
+
+"""Parse event definitions out of comments in source files."""
+
+import re
+import sys
+import os
+import string
+import getopt
+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(string.strip(line[2:-1]))
+        else:
+            if sublist:
+                hits.append(sublist)
+                sublist = []
+    if sublist:
+        hits.append(sublist)
+        sublist = []
+    dd = {}
+    for sublist in hits:
+        d = {}
+        for line in sublist:
+            words = string.split(line, 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/Lib/idlelib/extend.txt b/Lib/idlelib/extend.txt
new file mode 100644
index 0000000..bcc2da9
--- /dev/null
+++ b/Lib/idlelib/extend.txt
@@ -0,0 +1,106 @@
+Writing an IDLE extension
+
+An IDLE extension can define new key bindings and menu entries for IDLE
+edit windows.  There is a simple mechanism to load extensions when IDLE
+starts up and to attach them to each edit window. (It is also possible
+to make other changes to IDLE, but this must be done by editing the IDLE
+source code.)
+
+The list of extensions loaded at startup time is configured by editing
+the file extend.py; see below for details.
+
+An IDLE extension is defined by a class.  Methods of the class define
+actions that are invoked by those bindings or menu entries. Class (or
+instance) variables define the bindings and menu additions; these are
+automatically applied by IDLE when the extension is linked to an edit
+window.
+
+An IDLE extension class is instantiated with a single argument,
+`editwin', an EditorWindow instance. The extension cannot assume much
+about this argument, but it is guarateed to have the following instance
+variables:
+
+    text	a Text instance (a widget)
+    io		an IOBinding instance (more about this later)
+    flist	the FileList instance (shared by all edit windows)
+
+(There are a few more, but they are rarely useful.)
+
+The extension class must not bind key events.  Rather, it must define
+one or more virtual events, e.g. <<zoom-height>>, and corresponding
+methods, e.g. zoom_height_event(), and have one or more class (or instance)
+variables that define mappings between virtual events and key sequences,
+e.g. <Alt-F2>.  When the extension is loaded, these key sequences will
+be bound to the corresponding virtual events, and the virtual events
+will be bound to the corresponding methods.  (This indirection is done
+so that the key bindings can easily be changed, and so that other
+sources of virtual events can exist, such as menu entries.)
+
+The following class or instance variables are used to define key
+bindings for virtual events:
+
+    keydefs		for all platforms
+    mac_keydefs		for Macintosh
+    windows_keydefs	for Windows
+    unix_keydefs	for Unix (and other platforms)
+
+Each of these variables, if it exists, must be a dictionary whose
+keys are virtual events, and whose values are lists of key sequences.
+
+An extension can define menu entries in a similar fashion.  This is done
+with a class or instance variable named menudefs; it should be a list of
+pair, where each pair is a menu name (lowercase) and a list of menu
+entries. Each menu entry is either None (to insert a separator entry) or
+a pair of strings (menu_label, virtual_event).  Here, menu_label is the
+label of the menu entry, and virtual_event is the virtual event to be
+generated when the entry is selected.  An underscore in the menu label
+is removed; the character following the underscore is displayed
+underlined, to indicate the shortcut character (for Windows).
+
+At the moment, extensions cannot define whole new menus; they must
+define entries in existing menus.  Some menus are not present on some
+windows; such entry definitions are then ignored, but the key bindings
+are still applied.  (This should probably be refined in the future.)
+
+Here is a complete example example:
+
+class ZoomHeight:
+
+    menudefs = [
+        ('edit', [
+            None, # Separator
+            ('_Zoom Height', '<<zoom-height>>'),
+         ])
+    ]
+
+    windows_keydefs = {
+        '<<zoom-height>>': ['<Alt-F2>'],
+    }
+    unix_keydefs = {
+        '<<zoom-height>>': ['<Control-z><Control-z>'],
+    }
+
+    def __init__(self, editwin):
+        self.editwin = editwin
+
+    def zoom_height_event(self, event):
+        "...Do what you want here..."
+
+The final piece of the puzzle is the file "extend.py", which contains a
+simple table used to configure the loading of extensions.  This file
+currently contains a single list variable named "standard", which is a
+list of extension names that are to be loaded.  (In the future, other
+configuration variables may be added to this module.)
+
+Extensions can define key bindings and menu entries that reference
+events they don't implement (including standard events); however this is
+not recommended (and may be forbidden in the future).
+
+Extensions are not required to define menu entries for all events they
+implement.
+
+Note: in order to change key bindings, you must currently edit the file
+keydefs.  It contains two dictionaries named and formatted like the
+keydefs dictionaries described above, one for the Unix bindings and one
+for the Windows bindings.  In the future, a better mechanism will be
+provided.
diff --git a/Lib/idlelib/help.txt b/Lib/idlelib/help.txt
new file mode 100644
index 0000000..001da01
--- /dev/null
+++ b/Lib/idlelib/help.txt
@@ -0,0 +1,155 @@
+[See end for tips.]
+
+Click on the dotted line at the top of a menu to "tear it off": a
+separate window containing the menu is created.
+
+File menu:
+
+	New window -- create a new editing window
+	Open... -- open an existing file
+	Open module... -- open an existing module (searches sys.path)
+	Class browser -- show classes and methods in current file
+	Path browser -- show sys.path directories, modules, classes
+		and methods
+	---
+	Save -- save current window to the associated file (unsaved
+		windows have a * before and after the window title)
+
+	Save As... -- save current window to new file, which becomes
+		the associated file
+	Save Copy As... -- save current window to different file
+		without changing the associated file
+	---
+	Close -- close current window (asks to save if unsaved)
+	Exit -- close all windows and quit IDLE (asks to save if unsaved)
+
+Edit menu:
+
+	Undo -- Undo last change to current window (max 1000 changes)
+	Redo -- Redo last undone change to current window
+	---
+	Cut -- Copy selection into system-wide clipboard; then delete selection
+	Copy -- Copy selection into system-wide clipboard
+	Paste -- Insert system-wide clipboard into window
+	Select All -- Select the entire contents of the edit buffer
+	---
+	Find... -- Open a search dialog box with many options
+	Find again -- Repeat last search
+	Find selection -- Search for the string in the selection
+	Find in Files... -- Open a search dialog box for searching files
+	Replace... -- Open a search-and-replace dialog box
+	Go to line -- Ask for a line number and show that line
+	---
+	Indent region -- Shift selected lines right 4 spaces
+	Dedent region -- Shift selected lines left 4 spaces
+	Comment out region -- Insert ## in front of selected lines
+	Uncomment region -- Remove leading # or ## from selected lines
+	Tabify region -- Turns *leading* stretches of spaces into tabs
+	Untabify region -- Turn *all* tabs into the right number of spaces
+	Expand word -- Expand the word you have typed to match another
+		word in the same buffer; repeat to get a different expansion
+	Format Paragraph -- Reformat the current blank-line-separated paragraph
+	---
+	Import module -- Import or reload the current module
+	Run script -- Execute the current file in the __main__ namespace
+
+Windows menu:
+
+	Zoom Height -- toggles the window between normal size (24x80)
+	and maximum height.
+	---
+	The rest of this menu lists the names of all open windows;
+	select one to bring it to the foreground (deiconifying it if
+	necessary).
+
+Debug menu (in the Python Shell window only):
+
+	Go to file/line -- look around the insert point for a filename
+		and linenumber, open the file, and show the line
+	Open stack viewer -- show the stack traceback of the last exception
+	Debugger toggle -- Run commands in the shell under the debugger
+	JIT Stack viewer toggle -- Open stack viewer on traceback
+
+Basic editing and navigation:
+
+	Backspace deletes to the left; DEL deletes to the right
+	Arrow keys and Page Up/Down to move around
+	Home/End go to begin/end of line
+	Control-Home/End go to begin/end of file
+	Some Emacs bindings may also work, e.g. ^B/^P/^A/^E/^D/^L
+
+Automatic indentation:
+
+	After a block-opening statement, the next line is indented by
+	4 spaces (in the Python Shell window by one tab).  After
+	certain keywords (break, return etc.) the next line is
+	dedented.  In leading indentation, Backspace deletes up to 4
+	spaces if they are there.  Tab inserts 1-4 spaces (in the
+	Python Shell window one tab).  See also the indent/dedent
+	region commands in the edit menu.
+
+Python Shell window:
+
+	^C interrupts executing command
+	^D sends end-of-file; closes window if typed at >>> prompt
+
+    Command history:
+
+	Alt-p retrieves previous command matching what you have typed
+	Alt-n retrieves next
+	Return while on any previous command retrieves that command
+	Alt-/ (Expand word) is also useful here
+
+Syntax colors:
+
+	The coloring is applied in a background "thread", so you may
+	occasionally see uncolorized text.  To change the color
+	scheme, edit the ColorPrefs class in IdlePrefs.py.
+
+    Python syntax colors:
+
+	Keywords	orange
+	Strings		green
+	Comments	red
+	Definitions	blue
+
+    Shell colors:
+
+	Console output	brown
+	stdout		blue
+	stderr		dark green
+	stdin		black
+
+Other preferences:
+
+	To change the font on Windows, open EditorWindow.py and change
+	    text['font'] = ("lucida console", 8)
+	to, e.g.,
+	    text['font'] = ("courier new", 10)
+
+	To change keyboard bindings, edit Bindings.py
+
+Command line usage:
+
+	idle.py [-c command] [-d] [-e] [-s] [-t title] [arg] ...
+
+	-c command  run this command
+	-d          enable debugger
+	-e          edit mode; arguments are files to be edited
+	-s          run $IDLESTARTUP or $PYTHONSTARTUP first
+	-t title    set title of shell window
+
+	If there are arguments:
+
+	    If -e is used, arguments are files opened for editing and
+	    sys.argv reflects the arguments passed to IDLE itself.
+
+	    Otherwise, if -c is used, all arguments are placed in
+	    sys.argv[1:...], with sys.argv[0] set to '-c'.
+
+	    Otherwise, if neither -e nor -c is used, the first
+	    argument is a script which is executed with the remaining
+	    arguments in sys.argv[1:...]  and sys.argv[0] set to the
+	    script name.  If the script name is '-', no script is
+	    executed but an interactive Python session is started; the
+	    arguments are still available in sys.argv.
diff --git a/Lib/idlelib/idle.bat b/Lib/idlelib/idle.bat
new file mode 100755
index 0000000..c1b5fd2
--- /dev/null
+++ b/Lib/idlelib/idle.bat
@@ -0,0 +1,3 @@
+@echo off
+rem Working IDLE bat for Windows - uses start instead of absolute pathname
+start idle.pyw %1 %2 %3 %4 %5 %6 %7 %8 %9
diff --git a/Lib/idlelib/idle.py b/Lib/idlelib/idle.py
new file mode 100644
index 0000000..71fdce5
--- /dev/null
+++ b/Lib/idlelib/idle.py
@@ -0,0 +1,12 @@
+#! /usr/bin/env python
+
+import os
+import sys
+import IdleConf
+
+idle_dir = os.path.split(sys.argv[0])[0]
+IdleConf.load(idle_dir)
+
+# defer importing Pyshell until IdleConf is loaded
+import PyShell
+PyShell.main()
diff --git a/Lib/idlelib/idle.pyw b/Lib/idlelib/idle.pyw
new file mode 100644
index 0000000..71fdce5
--- /dev/null
+++ b/Lib/idlelib/idle.pyw
@@ -0,0 +1,12 @@
+#! /usr/bin/env python
+
+import os
+import sys
+import IdleConf
+
+idle_dir = os.path.split(sys.argv[0])[0]
+IdleConf.load(idle_dir)
+
+# defer importing Pyshell until IdleConf is loaded
+import PyShell
+PyShell.main()
diff --git a/Lib/idlelib/idlever.py b/Lib/idlelib/idlever.py
new file mode 100644
index 0000000..e51797e
--- /dev/null
+++ b/Lib/idlelib/idlever.py
@@ -0,0 +1 @@
+IDLE_VERSION = "0.5"
diff --git a/Lib/idlelib/keydefs.py b/Lib/idlelib/keydefs.py
new file mode 100644
index 0000000..3d34893
--- /dev/null
+++ b/Lib/idlelib/keydefs.py
@@ -0,0 +1,55 @@
+windows_keydefs = \
+{'<<Copy>>': ['<Control-c>'],
+ '<<Cut>>': ['<Control-x>'],
+ '<<Paste>>': ['<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>'],
+ '<<python-docs>>': ['<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>'],
+ '<<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>']}
+
+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>'],
+ '<<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/Lib/idlelib/loader.py b/Lib/idlelib/loader.py
new file mode 100644
index 0000000..6a438c3
--- /dev/null
+++ b/Lib/idlelib/loader.py
@@ -0,0 +1,64 @@
+# Everything is done inside the loader function so that no other names
+# are placed in the global namespace.  Before user code is executed,
+# even this name is unbound.
+def loader():
+    import sys, os, protocol, threading, time
+    import Remote
+
+##  Use to debug the loading process itself:
+##    sys.stdout = open('c:\\windows\\desktop\\stdout.txt','a')
+##    sys.stderr = open('c:\\windows\\desktop\\stderr.txt','a')
+
+    # Ensure that there is absolutely no pollution of the global
+    # namespace by deleting the global name of this function.
+    global loader
+    del loader
+
+    # Connect to IDLE
+    try:
+        client = protocol.Client()
+    except protocol.connectionLost, cL:
+        print 'loader: Unable to connect to IDLE', cL
+        return
+
+    # Connect to an ExecBinding object that needs our help.  If
+    # the user is starting multiple programs right now, we might get a
+    # different one than the one that started us.  Proving that's okay is
+    # left as an exercise to the reader.  (HINT:  Twelve, by the pigeonhole
+    # principle)
+    ExecBinding = client.getobject('ExecBinding')
+    if not ExecBinding:
+        print "loader: IDLE does not need me."
+        return
+
+    # All of our input and output goes through ExecBinding.
+    sys.stdin  = Remote.pseudoIn( ExecBinding.readline )
+    sys.stdout = Remote.pseudoOut( ExecBinding.write.void, tag="stdout" )
+    sys.stderr = Remote.pseudoOut( ExecBinding.write.void, tag="stderr" )
+
+    # Create a Remote object and start it running.
+    remote = Remote.Remote(globals(), ExecBinding)
+    rthread = threading.Thread(target=remote.mainloop)
+    rthread.setDaemon(1)
+    rthread.start()
+
+    # Block until either the client or the user program stops
+    user = rthread.isAlive
+    while user and client.isAlive():
+        time.sleep(0.025)
+
+        if not user():
+          user = hasattr(sys, "ready_to_exit") and sys.ready_to_exit
+          for t in threading.enumerate():
+            if not t.isDaemon() and t.isAlive() and t!=threading.currentThread():
+              user = t.isAlive
+              break
+
+    # We need to make sure we actually exit, so that the user doesn't get
+    #   stuck with an invisible process.  We want to finalize C modules, so
+    #   we don't use os._exit(), but we don't call sys.exitfunc, which might
+    #   block forever.
+    del sys.exitfunc
+    sys.exit()
+
+loader()
diff --git a/Lib/idlelib/protocol.py b/Lib/idlelib/protocol.py
new file mode 100644
index 0000000..10295bf
--- /dev/null
+++ b/Lib/idlelib/protocol.py
@@ -0,0 +1,369 @@
+"""protocol        (David Scherer <dscherer@cmu.edu>)
+
+     This module implements a simple RPC or "distributed object" protocol.
+     I am probably the 100,000th person to write this in Python, but, hey,
+     it was fun.
+
+     Contents:
+
+       connectionLost is an exception that will be thrown by functions in
+           the protocol module or calls to remote methods that fail because
+           the remote program has closed the socket or because no connection
+           could be established in the first place.
+
+       Server( port=None, connection_hook=None ) creates a server on a
+           well-known port, to which clients can connect.  When a client
+           connects, a Connection is created for it.  If connection_hook
+           is defined, then connection_hook( socket.getpeername() ) is called
+           before a Connection is created, and if it returns false then the
+           connection is refused.  connection_hook must be prepared to be
+           called from any thread.
+  
+       Client( ip='127.0.0.1', port=None ) returns a Connection to a Server
+           object at a well-known address and port.
+  
+       Connection( socket ) creates an RPC connection on an arbitrary socket,
+           which must already be connected to another program.  You do not
+           need to use this directly if you are using Client() or Server().
+  
+       publish( name, connect_function ) provides an object with the
+           specified name to some or all Connections.  When another program
+           calls Connection.getobject() with the specified name, the
+           specified connect_function is called with the arguments
+
+              connect_function( conn, addr )
+
+           where conn is the Connection object to the requesting client and
+           addr is the address returned by socket.getpeername().  If that
+           function returns an object, that object becomes accessible to
+           the caller.  If it returns None, the caller's request fails.
+
+     Connection objects:
+
+       .close() refuses additional RPC messages from the peer, and notifies
+           the peer that the connection has been closed.  All pending remote
+           method calls in either program will fail with a connectionLost
+           exception.  Further remote method calls on this connection will
+           also result in errors.
+
+       .getobject(name) returns a proxy for the remote object with the
+           specified name, if it exists and the peer permits us access.
+           Otherwise, it returns None.  It may throw a connectionLost
+           exception.  The returned proxy supports basic attribute access
+           and method calls, and its methods have an extra attribute,
+           .void, which is a function that has the same effect but always
+           returns None.  This last capability is provided as a performance
+           hack: object.method.void(params) can return without waiting for
+           the remote process to respond, but object.method(params) needs
+           to wait for a return value or exception.
+
+       .rpc_loop(block=0) processes *incoming* messages for this connection.
+           If block=1, it continues processing until an exception or return
+           value is received, which is normally forever.  Otherwise it
+           returns when all currently pending messages have been delivered.
+           It may throw a connectionLost exception.
+
+       .set_close_hook(f) specifies a function to be called when the remote
+           object closes the connection during a call to rpc_loop().  This
+           is a good way for servers to be notified when clients disconnect.
+
+       .set_shutdown_hook(f) specifies a function called *immediately* when
+           the receive loop detects that the connection has been lost.  The
+           provided function must be prepared to run in any thread.
+
+     Server objects:
+
+       .rpc_loop() processes incoming messages on all connections, and
+           returns when all pending messages have been processed.  It will
+           *not* throw connectionLost exceptions; the
+           Connection.set_close_hook() mechanism is much better for servers.
+"""
+
+import sys, os, string, types
+import socket
+from threading import Thread
+from Queue import Queue, Empty
+from cPickle import Pickler, Unpickler, PicklingError
+
+class connectionLost:
+    def __init__(self, what=""): self.what = what
+    def __repr__(self): return self.what
+    def __str__(self): return self.what
+
+def getmethods(cls):
+    "Returns a list of the names of the methods of a class."
+    methods = []
+    for b in cls.__bases__:
+        methods = methods + getmethods(b)
+    d = cls.__dict__
+    for k in d.keys():
+        if type(d[k])==types.FunctionType:
+            methods.append(k)
+    return methods
+
+class methodproxy:
+    "Proxy for a method of a remote object."
+    def __init__(self, classp, name):
+        self.classp=classp
+        self.name=name
+        self.client = classp.client
+    def __call__(self, *args, **keywords):
+        return self.client.call( 'm', self.classp.name, self.name, args, keywords )
+
+    def void(self, *args, **keywords):
+        self.client.call_void( 'm', self.classp.name,self.name,args,keywords)
+
+class classproxy:
+    "Proxy for a remote object."
+    def __init__(self, client, name, methods):
+        self.__dict__['client'] = client
+        self.__dict__['name'] = name
+        
+        for m in methods:
+            prox = methodproxy( self, m )
+            self.__dict__[m] = prox
+
+    def __getattr__(self, attr):
+        return self.client.call( 'g', self.name, attr )
+
+    def __setattr__(self, attr, value):
+        self.client.call_void( 's', self.name, attr, value )
+
+local_connect  = {}
+def publish(name, connect_function):
+    local_connect[name]=connect_function
+
+class socketFile:
+    "File emulator based on a socket.  Provides only blocking semantics for now."
+
+    def __init__(self, socket):
+        self.socket = socket
+        self.buffer = ''
+
+    def _recv(self,bytes):
+        try:
+            r=self.socket.recv(bytes)
+        except:
+            raise connectionLost()
+        if not r:
+            raise connectionLost()
+        return r
+
+    def write(self, string):
+        try:
+            self.socket.send( string )
+        except:
+            raise connectionLost()
+
+    def read(self,bytes):
+        x = bytes-len(self.buffer)
+        while x>0:
+            self.buffer=self.buffer+self._recv(x)
+            x = bytes-len(self.buffer)
+        s = self.buffer[:bytes]
+        self.buffer=self.buffer[bytes:]
+        return s
+
+    def readline(self):
+        while 1:
+            f = string.find(self.buffer,'\n')
+            if f>=0:
+                s = self.buffer[:f+1]
+                self.buffer=self.buffer[f+1:]
+                return s
+            self.buffer = self.buffer + self._recv(1024)
+
+
+class Connection (Thread):
+    debug = 0
+    def __init__(self, socket):
+        self.local_objects = {}
+        self.socket = socket
+        self.name = socket.getpeername()
+        self.socketfile = socketFile(socket)
+        self.queue = Queue(-1)
+        self.refuse_messages = 0
+        self.cmds = { 'm': self.r_meth,
+                      'g': self.r_get,
+                      's': self.r_set,
+                      'o': self.r_geto,
+                      'e': self.r_exc,
+                     #'r' handled by rpc_loop
+                    }
+
+        Thread.__init__(self)
+        self.setDaemon(1)
+        self.start()
+
+    def getobject(self, name):
+        methods = self.call( 'o', name )
+        if methods is None: return None
+        return classproxy(self, name, methods)
+
+    # close_hook is called from rpc_loop(), like a normal remote method
+    #   invocation
+    def set_close_hook(self,hook): self.close_hook = hook
+
+    # shutdown_hook is called directly from the run() thread, and needs
+    #   to be "thread safe"
+    def set_shutdown_hook(self,hook): self.shutdown_hook = hook
+
+    close_hook = None
+    shutdown_hook = None
+
+    def close(self):
+        self._shutdown()
+        self.refuse_messages = 1
+
+    def call(self, c, *args):
+        self.send( (c, args, 1 ) )
+        return self.rpc_loop( block = 1 )
+
+    def call_void(self, c, *args):
+        try:
+            self.send( (c, args, 0 ) )
+        except:
+            pass
+   
+    # the following methods handle individual RPC calls:
+
+    def r_geto(self, obj):
+        c = local_connect.get(obj)
+        if not c: return None
+        o = c(self, self.name)
+        if not o: return None
+        self.local_objects[obj] = o
+        return getmethods(o.__class__)
+
+    def r_meth(self, obj, name, args, keywords):
+        return apply( getattr(self.local_objects[obj],name), args, keywords)
+
+    def r_get(self, obj, name):       
+        return getattr(self.local_objects[obj],name)
+
+    def r_set(self, obj, name, value):
+        setattr(self.local_objects[obj],name,value)
+
+    def r_exc(self, e, v):
+        raise e, v
+
+    def rpc_exec(self, cmd, arg, ret):
+        if self.refuse_messages: return
+        if self.debug: print cmd,arg,ret
+        if ret:
+            try:
+                r=apply(self.cmds.get(cmd), arg)
+                self.send( ('r', r, 0) )
+            except:
+                try:
+                    self.send( ('e', sys.exc_info()[:2], 0) )
+                except PicklingError:
+                    self.send( ('e', (TypeError, 'Unpicklable exception.'), 0 ) )
+        else:
+            # we cannot report exceptions to the caller, so
+            #   we report them in this process.
+            r=apply(self.cmds.get(cmd), arg)
+
+    # the following methods implement the RPC and message loops:
+
+    def rpc_loop(self, block=0):
+        if self.refuse_messages: raise connectionLost('(already closed)')
+        try:
+            while 1:
+                try:
+                    cmd, arg, ret = self.queue.get( block )
+                except Empty:
+                    return None
+                if cmd=='r': return arg
+                self.rpc_exec(cmd,arg,ret)
+        except connectionLost:
+            if self.close_hook:
+                self.close_hook()
+                self.close_hook = None
+            raise
+
+    def run(self):
+        try:
+            while 1:
+                data = self.recv()
+                self.queue.put( data )
+        except:
+            self.queue.put( ('e', sys.exc_info()[:2], 0) )
+
+    # The following send raw pickled data to the peer
+
+    def send(self, data):
+        try:
+            Pickler(self.socketfile,1).dump( data )
+        except connectionLost:
+            self._shutdown()
+            if self.shutdown_hook: self.shutdown_hook()
+            raise
+
+    def recv(self):
+        try:
+            return Unpickler(self.socketfile).load()
+        except connectionLost:
+            self._shutdown()
+            if self.shutdown_hook: self.shutdown_hook()
+            raise
+        except:
+            raise
+
+    def _shutdown(self):
+        try:
+            self.socket.shutdown(1)
+            self.socket.close()
+        except:
+            pass
+
+
+class Server (Thread):
+    default_port = 0x1D1E   # "IDlE"
+
+    def __init__(self, port=None, connection_hook=None):
+        self.connections = []
+        self.port = port or self.default_port
+        self.connection_hook = connection_hook
+
+        try:
+            self.wellknown = s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.bind('', self.port)
+            s.listen(3)
+        except:
+            raise connectionLost
+
+        Thread.__init__(self)
+        self.setDaemon(1)
+        self.start()
+
+    def run(self):
+        s = self.wellknown
+        while 1:
+            conn, addr = s.accept()
+            if self.connection_hook and not self.connection_hook(addr):
+                try:
+                    conn.shutdown(1)
+                except:
+                    pass
+                continue
+            self.connections.append( Connection(conn) )
+
+    def rpc_loop(self):
+        cns = self.connections[:]
+        for c in cns:
+            try:
+                c.rpc_loop(block = 0)
+            except connectionLost:
+                if c in self.connections:
+                    self.connections.remove(c)
+
+def Client(ip='127.0.0.1', port=None):
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.connect(ip,port or Server.default_port)
+    except socket.error, what:
+        raise connectionLost(str(what))
+    except:
+        raise connectionLost()
+    return Connection(s)
diff --git a/Lib/idlelib/pyclbr.py b/Lib/idlelib/pyclbr.py
new file mode 100644
index 0000000..74b7ff7
--- /dev/null
+++ b/Lib/idlelib/pyclbr.py
@@ -0,0 +1,336 @@
+"""Parse a Python file and retrieve classes and methods.
+
+Parse enough of a Python file to recognize class and method
+definitions and to find out the superclasses of a class.
+
+The interface consists of a single function:
+	readmodule(module, path)
+module is the name of a Python module, path is an optional list of
+directories where the module is to be searched.  If present, path is
+prepended to the system search path sys.path.
+The return value is a dictionary.  The keys of the dictionary are
+the names of the classes defined in the module (including classes
+that are defined via the from XXX import YYY construct).  The values
+are class instances of the class Class defined here.
+
+A class is described by the class Class in this module.  Instances
+of this class have the following instance variables:
+	name -- the name of the class
+	super -- a list of super classes (Class instances)
+	methods -- a dictionary of methods
+	file -- the file in which the class was defined
+	lineno -- the line in the file on which the class statement occurred
+The dictionary of methods uses the method names as keys and the line
+numbers on which the method was defined as values.
+If the name of a super class is not recognized, the corresponding
+entry in the list of super classes is not a class instance but a
+string giving the name of the super class.  Since import statements
+are recognized and imported modules are scanned as well, this
+shouldn't happen often.
+
+BUGS
+- Continuation lines are not dealt with at all.
+- While triple-quoted strings won't confuse it, lines that look like
+  def, class, import or "from ... import" stmts inside backslash-continued
+  single-quoted strings are treated like code.  The expense of stopping
+  that isn't worth it.
+- Code that doesn't pass tabnanny or python -t will confuse it, unless
+  you set the module TABWIDTH vrbl (default 8) to the correct tab width
+  for the file.
+
+PACKAGE RELATED BUGS
+- If you have a package and a module inside that or another package
+  with the same name, module caching doesn't work properly since the
+  key is the base name of the module/package.
+- The only entry that is returned when you readmodule a package is a
+  __path__ whose value is a list which confuses certain class browsers.
+- When code does:
+  from package import subpackage
+  class MyClass(subpackage.SuperClass):
+    ...
+  It can't locate the parent.  It probably needs to have the same
+  hairy logic that the import locator already does.  (This logic
+  exists coded in Python in the freeze package.)
+"""
+
+import os
+import sys
+import imp
+import re
+import string
+
+TABWIDTH = 8
+
+_getnext = re.compile(r"""
+    (?P<String>
+       \""" [^"\\]* (?:
+			(?: \\. | "(?!"") )
+			[^"\\]*
+		    )*
+       \"""
+
+    |   ''' [^'\\]* (?:
+			(?: \\. | '(?!'') )
+			[^'\\]*
+		    )*
+	'''
+    )
+
+|   (?P<Method>
+	^
+	(?P<MethodIndent> [ \t]* )
+	def [ \t]+
+	(?P<MethodName> [a-zA-Z_] \w* )
+	[ \t]* \(
+    )
+
+|   (?P<Class>
+	^
+	(?P<ClassIndent> [ \t]* )
+	class [ \t]+
+	(?P<ClassName> [a-zA-Z_] \w* )
+	[ \t]*
+	(?P<ClassSupers> \( [^)\n]* \) )?
+	[ \t]* :
+    )
+
+|   (?P<Import>
+	^ import [ \t]+
+	(?P<ImportList> [^#;\n]+ )
+    )
+
+|   (?P<ImportFrom>
+	^ from [ \t]+
+	(?P<ImportFromPath>
+	    [a-zA-Z_] \w*
+	    (?:
+		[ \t]* \. [ \t]* [a-zA-Z_] \w*
+	    )*
+	)
+	[ \t]+
+	import [ \t]+
+	(?P<ImportFromList> [^#;\n]+ )
+    )
+""", re.VERBOSE | re.DOTALL | re.MULTILINE).search
+
+_modules = {}                           # cache of modules we've seen
+
+# each Python class is represented by an instance of this class
+class Class:
+	'''Class to represent a Python class.'''
+	def __init__(self, module, name, super, file, lineno):
+		self.module = module
+		self.name = name
+		if super is None:
+			super = []
+		self.super = super
+		self.methods = {}
+		self.file = file
+		self.lineno = lineno
+
+	def _addmethod(self, name, lineno):
+		self.methods[name] = lineno
+
+class Function(Class):
+	'''Class to represent a top-level Python function'''
+	def __init__(self, module, name, file, lineno):
+		Class.__init__(self, module, name, None, file, lineno)
+	def _addmethod(self, name, lineno):
+		assert 0, "Function._addmethod() shouldn't be called"
+
+def readmodule(module, path=[], inpackage=0):
+	'''Backwards compatible interface.
+
+	Like readmodule_ex() but strips Function objects from the
+	resulting dictionary.'''
+
+	dict = readmodule_ex(module, path, inpackage)
+	res = {}
+	for key, value in dict.items():
+		if not isinstance(value, Function):
+			res[key] = value
+	return res
+
+def readmodule_ex(module, path=[], inpackage=0):
+	'''Read a module file and return a dictionary of classes.
+
+	Search for MODULE in PATH and sys.path, read and parse the
+	module and return a dictionary with one entry for each class
+	found in the module.'''
+
+	dict = {}
+
+	i = string.rfind(module, '.')
+	if i >= 0:
+		# Dotted module name
+		package = string.strip(module[:i])
+		submodule = string.strip(module[i+1:])
+		parent = readmodule(package, path, inpackage)
+		child = readmodule(submodule, parent['__path__'], 1)
+		return child
+
+	if _modules.has_key(module):
+		# we've seen this module before...
+		return _modules[module]
+	if module in sys.builtin_module_names:
+		# this is a built-in module
+		_modules[module] = dict
+		return dict
+
+	# search the path for the module
+	f = None
+	if inpackage:
+		try:
+			f, file, (suff, mode, type) = \
+				imp.find_module(module, path)
+		except ImportError:
+			f = None
+	if f is None:
+		fullpath = list(path) + sys.path
+		f, file, (suff, mode, type) = imp.find_module(module, fullpath)
+	if type == imp.PKG_DIRECTORY:
+		dict['__path__'] = [file]
+		_modules[module] = dict
+		path = [file] + path
+		f, file, (suff, mode, type) = \
+				imp.find_module('__init__', [file])
+	if type != imp.PY_SOURCE:
+		# not Python source, can't do anything with this module
+		f.close()
+		_modules[module] = dict
+		return dict
+
+	_modules[module] = dict
+	imports = []
+	classstack = []	# stack of (class, indent) pairs
+	src = f.read()
+	f.close()
+
+	# To avoid having to stop the regexp at each newline, instead
+	# when we need a line number we simply string.count the number of
+	# newlines in the string since the last time we did this; i.e.,
+	#    lineno = lineno + \
+	#             string.count(src, '\n', last_lineno_pos, here)
+	#    last_lineno_pos = here
+	countnl = string.count
+	lineno, last_lineno_pos = 1, 0
+	i = 0
+	while 1:
+		m = _getnext(src, i)
+		if not m:
+			break
+		start, i = m.span()
+
+		if m.start("Method") >= 0:
+			# found a method definition or function
+			thisindent = _indent(m.group("MethodIndent"))
+			meth_name = m.group("MethodName")
+			lineno = lineno + \
+				 countnl(src, '\n',
+					 last_lineno_pos, start)
+			last_lineno_pos = start
+			# close all classes indented at least as much
+			while classstack and \
+			      classstack[-1][1] >= thisindent:
+				del classstack[-1]
+			if classstack:
+				# it's a class method
+				cur_class = classstack[-1][0]
+				cur_class._addmethod(meth_name, lineno)
+			else:
+				# it's a function
+				f = Function(module, meth_name,
+					     file, lineno)
+				dict[meth_name] = f
+
+		elif m.start("String") >= 0:
+			pass
+
+		elif m.start("Class") >= 0:
+			# we found a class definition
+			thisindent = _indent(m.group("ClassIndent"))
+			# close all classes indented at least as much
+			while classstack and \
+			      classstack[-1][1] >= thisindent:
+				del classstack[-1]
+			lineno = lineno + \
+				 countnl(src, '\n', last_lineno_pos, start)
+			last_lineno_pos = start
+			class_name = m.group("ClassName")
+			inherit = m.group("ClassSupers")
+			if inherit:
+				# the class inherits from other classes
+				inherit = string.strip(inherit[1:-1])
+				names = []
+				for n in string.splitfields(inherit, ','):
+					n = string.strip(n)
+					if dict.has_key(n):
+						# we know this super class
+						n = dict[n]
+					else:
+						c = string.splitfields(n, '.')
+						if len(c) > 1:
+							# super class
+							# is of the
+							# form module.class:
+							# look in
+							# module for class
+							m = c[-2]
+							c = c[-1]
+							if _modules.has_key(m):
+								d = _modules[m]
+								if d.has_key(c):
+									n = d[c]
+					names.append(n)
+				inherit = names
+			# remember this class
+			cur_class = Class(module, class_name, inherit,
+					  file, lineno)
+			dict[class_name] = cur_class
+			classstack.append((cur_class, thisindent))
+
+		elif m.start("Import") >= 0:
+			# import module
+			for n in string.split(m.group("ImportList"), ','):
+				n = string.strip(n)
+				try:
+					# recursively read the imported module
+					d = readmodule(n, path, inpackage)
+				except:
+					##print 'module', n, 'not found'
+					pass
+
+		elif m.start("ImportFrom") >= 0:
+			# from module import stuff
+			mod = m.group("ImportFromPath")
+			names = string.split(m.group("ImportFromList"), ',')
+			try:
+				# recursively read the imported module
+				d = readmodule(mod, path, inpackage)
+			except:
+				##print 'module', mod, 'not found'
+				continue
+			# add any classes that were defined in the
+			# imported module to our name space if they
+			# were mentioned in the list
+			for n in names:
+				n = string.strip(n)
+				if d.has_key(n):
+					dict[n] = d[n]
+				elif n == '*':
+					# only add a name if not
+					# already there (to mimic what
+					# Python does internally)
+					# also don't add names that
+					# start with _
+					for n in d.keys():
+						if n[0] != '_' and \
+						   not dict.has_key(n):
+							dict[n] = d[n]
+		else:
+			assert 0, "regexp _getnext found something unexpected"
+
+	return dict
+
+def _indent(ws, _expandtabs=string.expandtabs):
+	return len(_expandtabs(ws, TABWIDTH))
diff --git a/Lib/idlelib/spawn.py b/Lib/idlelib/spawn.py
new file mode 100644
index 0000000..ce6b41c
--- /dev/null
+++ b/Lib/idlelib/spawn.py
@@ -0,0 +1,59 @@
+# spawn - This is ugly, OS-specific code to spawn a separate process.  It
+#         also defines a function for getting the version of a path most
+#         likely to work with cranky API functions.
+
+import os
+
+def hardpath(path):
+    path = os.path.normcase(os.path.abspath(path))
+    try:
+        import win32api
+        path = win32api.GetShortPathName( path )
+    except:
+        pass
+    return path
+
+if hasattr(os, 'spawnv'):
+
+  # Windows-ish OS: we use spawnv(), and stick quotes around arguments
+  #   in case they contains spaces, since Windows will jam all the
+  #   arguments to spawn() or exec() together into one string.  The
+  #   kill_zombies function is a noop.
+
+  def spawn(bin, *args):
+    nargs = [bin]
+    for arg in args:
+      nargs.append( '"'+arg+'"' )
+    os.spawnv( os.P_NOWAIT, bin, nargs )
+
+  def kill_zombies(): pass
+
+elif hasattr(os, 'fork'):
+
+  # UNIX-ish operating system: we fork() and exec(), and we have to track
+  #   the pids of our children and call waitpid() on them to avoid leaving
+  #   zombies in the process table.  kill_zombies() does the dirty work, and
+  #   should be called periodically.
+
+  zombies = []
+
+  def spawn(bin, *args):
+    pid = os.fork()
+    if pid:
+      zombies.append(pid)
+    else:
+      os.execv( bin, (bin, ) + args )
+
+  def kill_zombies():
+      for z in zombies[:]:
+          stat = os.waitpid(z, os.WNOHANG)
+          if stat[0]==z:
+              zombies.remove(z)
+
+else:
+  # If you get here, you may be able to write an alternative implementation
+  # of these functions for your OS.
+
+  def kill_zombies(): pass
+
+  raise OSError, 'This OS does not support fork() or spawnv().'
diff --git a/Lib/idlelib/tabnanny.py b/Lib/idlelib/tabnanny.py
new file mode 100644
index 0000000..8d3eab5
--- /dev/null
+++ b/Lib/idlelib/tabnanny.py
@@ -0,0 +1,372 @@
+#! /usr/bin/env python
+
+"""The Tab Nanny despises ambiguous indentation.  She knows no mercy."""
+
+# Released to the public domain, by Tim Peters, 15 April 1998.
+
+# XXX Note: this is now a standard library module.
+# XXX The API needs to undergo changes however; the current code is too
+# XXX script-like.  This will be addressed later.
+
+__version__ = "6"
+
+import os
+import sys
+import string
+import getopt
+import tokenize
+
+verbose = 0
+filename_only = 0
+
+def errprint(*args):
+    sep = ""
+    for arg in args:
+        sys.stderr.write(sep + str(arg))
+        sep = " "
+    sys.stderr.write("\n")
+
+def main():
+    global verbose, filename_only
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], "qv")
+    except getopt.error, msg:
+        errprint(msg)
+        return
+    for o, a in opts:
+        if o == '-q':
+            filename_only = filename_only + 1
+        if o == '-v':
+            verbose = verbose + 1
+    if not args:
+        errprint("Usage:", sys.argv[0], "[-v] file_or_directory ...")
+        return
+    for arg in args:
+        check(arg)
+
+class NannyNag:
+    def __init__(self, lineno, msg, line):
+        self.lineno, self.msg, self.line = lineno, msg, line
+    def get_lineno(self):
+        return self.lineno
+    def get_msg(self):
+        return self.msg
+    def get_line(self):
+        return self.line
+
+def check(file):
+    if os.path.isdir(file) and not os.path.islink(file):
+        if verbose:
+            print "%s: listing directory" % `file`
+        names = os.listdir(file)
+        for name in names:
+            fullname = os.path.join(file, name)
+            if (os.path.isdir(fullname) and
+                not os.path.islink(fullname) or
+                os.path.normcase(name[-3:]) == ".py"):
+                check(fullname)
+        return
+
+    try:
+        f = open(file)
+    except IOError, msg:
+        errprint("%s: I/O Error: %s" % (`file`, str(msg)))
+        return
+
+    if verbose > 1:
+        print "checking", `file`, "..."
+
+    reset_globals()
+    try:
+        tokenize.tokenize(f.readline, tokeneater)
+
+    except tokenize.TokenError, msg:
+        errprint("%s: Token Error: %s" % (`file`, str(msg)))
+        return
+
+    except NannyNag, nag:
+        badline = nag.get_lineno()
+        line = nag.get_line()
+        if verbose:
+            print "%s: *** Line %d: trouble in tab city! ***" % (
+                `file`, badline)
+            print "offending line:", `line`
+            print nag.get_msg()
+        else:
+            if ' ' in file: file = '"' + file + '"'
+            if filename_only: print file
+            else: print file, badline, `line`
+        return
+
+    if verbose:
+        print "%s: Clean bill of health." % `file`
+
+class Whitespace:
+    # the characters used for space and tab
+    S, T = ' \t'
+
+    # members:
+    #   raw
+    #       the original string
+    #   n
+    #       the number of leading whitespace characters in raw
+    #   nt
+    #       the number of tabs in raw[:n]
+    #   norm
+    #       the normal form as a pair (count, trailing), where:
+    #       count
+    #           a tuple such that raw[:n] contains count[i]
+    #           instances of S * i + T
+    #       trailing
+    #           the number of trailing spaces in raw[:n]
+    #       It's A Theorem that m.indent_level(t) ==
+    #       n.indent_level(t) for all t >= 1 iff m.norm == n.norm.
+    #   is_simple
+    #       true iff raw[:n] is of the form (T*)(S*)
+
+    def __init__(self, ws):
+        self.raw  = ws
+        S, T = Whitespace.S, Whitespace.T
+        count = []
+        b = n = nt = 0
+        for ch in self.raw:
+            if ch == S:
+                n = n + 1
+                b = b + 1
+            elif ch == T:
+                n = n + 1
+                nt = nt + 1
+                if b >= len(count):
+                    count = count + [0] * (b - len(count) + 1)
+                count[b] = count[b] + 1
+                b = 0
+            else:
+                break
+        self.n    = n
+        self.nt   = nt
+        self.norm = tuple(count), b
+        self.is_simple = len(count) <= 1
+
+    # return length of longest contiguous run of spaces (whether or not
+    # preceding a tab)
+    def longest_run_of_spaces(self):
+        count, trailing = self.norm
+        return max(len(count)-1, trailing)
+
+    def indent_level(self, tabsize):
+        # count, il = self.norm
+        # for i in range(len(count)):
+        #    if count[i]:
+        #        il = il + (i/tabsize + 1)*tabsize * count[i]
+        # return il
+
+        # quicker:
+        # il = trailing + sum (i/ts + 1)*ts*count[i] =
+        # trailing + ts * sum (i/ts + 1)*count[i] =
+        # trailing + ts * sum i/ts*count[i] + count[i] =
+        # trailing + ts * [(sum i/ts*count[i]) + (sum count[i])] =
+        # trailing + ts * [(sum i/ts*count[i]) + num_tabs]
+        # and note that i/ts*count[i] is 0 when i < ts
+
+        count, trailing = self.norm
+        il = 0
+        for i in range(tabsize, len(count)):
+            il = il + i/tabsize * count[i]
+        return trailing + tabsize * (il + self.nt)
+
+    # return true iff self.indent_level(t) == other.indent_level(t)
+    # for all t >= 1
+    def equal(self, other):
+        return self.norm == other.norm
+
+    # return a list of tuples (ts, i1, i2) such that
+    # i1 == self.indent_level(ts) != other.indent_level(ts) == i2.
+    # Intended to be used after not self.equal(other) is known, in which
+    # case it will return at least one witnessing tab size.
+    def not_equal_witness(self, other):
+        n = max(self.longest_run_of_spaces(),
+                other.longest_run_of_spaces()) + 1
+        a = []
+        for ts in range(1, n+1):
+            if self.indent_level(ts) != other.indent_level(ts):
+                a.append( (ts,
+                           self.indent_level(ts),
+                           other.indent_level(ts)) )
+        return a
+
+    # Return true iff self.indent_level(t) < other.indent_level(t)
+    # for all t >= 1.
+    # The algorithm is due to Vincent Broman.
+    # Easy to prove it's correct.
+    # XXXpost that.
+    # Trivial to prove n is sharp (consider T vs ST).
+    # Unknown whether there's a faster general way.  I suspected so at
+    # first, but no longer.
+    # For the special (but common!) case where M and N are both of the
+    # form (T*)(S*), M.less(N) iff M.len() < N.len() and
+    # M.num_tabs() <= N.num_tabs(). Proof is easy but kinda long-winded.
+    # XXXwrite that up.
+    # Note that M is of the form (T*)(S*) iff len(M.norm[0]) <= 1.
+    def less(self, other):
+        if self.n >= other.n:
+            return 0
+        if self.is_simple and other.is_simple:
+            return self.nt <= other.nt
+        n = max(self.longest_run_of_spaces(),
+                other.longest_run_of_spaces()) + 1
+        # the self.n >= other.n test already did it for ts=1
+        for ts in range(2, n+1):
+            if self.indent_level(ts) >= other.indent_level(ts):
+                return 0
+        return 1
+
+    # return a list of tuples (ts, i1, i2) such that
+    # i1 == self.indent_level(ts) >= other.indent_level(ts) == i2.
+    # Intended to be used after not self.less(other) is known, in which
+    # case it will return at least one witnessing tab size.
+    def not_less_witness(self, other):
+        n = max(self.longest_run_of_spaces(),
+                other.longest_run_of_spaces()) + 1
+        a = []
+        for ts in range(1, n+1):
+            if self.indent_level(ts) >= other.indent_level(ts):
+                a.append( (ts,
+                           self.indent_level(ts),
+                           other.indent_level(ts)) )
+        return a
+
+def format_witnesses(w):
+    import string
+    firsts = map(lambda tup: str(tup[0]), w)
+    prefix = "at tab size"
+    if len(w) > 1:
+        prefix = prefix + "s"
+    return prefix + " " + string.join(firsts, ', ')
+
+# The collection of globals, the reset_globals() function, and the
+# tokeneater() function, depend on which version of tokenize is
+# in use.
+
+if hasattr(tokenize, 'NL'):
+ # take advantage of Guido's patch!
+
+ indents = []
+ check_equal = 0
+
+ def reset_globals():
+     global indents, check_equal
+     check_equal = 0
+     indents = [Whitespace("")]
+
+ def tokeneater(type, token, start, end, line,
+                INDENT=tokenize.INDENT,
+                DEDENT=tokenize.DEDENT,
+                NEWLINE=tokenize.NEWLINE,
+                JUNK=(tokenize.COMMENT, tokenize.NL) ):
+     global indents, check_equal
+
+     if type == NEWLINE:
+         # a program statement, or ENDMARKER, will eventually follow,
+         # after some (possibly empty) run of tokens of the form
+         #     (NL | COMMENT)* (INDENT | DEDENT+)?
+         # If an INDENT appears, setting check_equal is wrong, and will
+         # be undone when we see the INDENT.
+         check_equal = 1
+
+     elif type == INDENT:
+         check_equal = 0
+         thisguy = Whitespace(token)
+         if not indents[-1].less(thisguy):
+             witness = indents[-1].not_less_witness(thisguy)
+             msg = "indent not greater e.g. " + format_witnesses(witness)
+             raise NannyNag(start[0], msg, line)
+         indents.append(thisguy)
+
+     elif type == DEDENT:
+         # there's nothing we need to check here!  what's important is
+         # that when the run of DEDENTs ends, the indentation of the
+         # program statement (or ENDMARKER) that triggered the run is
+         # equal to what's left at the top of the indents stack
+
+         # Ouch!  This assert triggers if the last line of the source
+         # is indented *and* lacks a newline -- then DEDENTs pop out
+         # of thin air.
+         # assert check_equal  # else no earlier NEWLINE, or an earlier INDENT
+         check_equal = 1
+
+         del indents[-1]
+
+     elif check_equal and type not in JUNK:
+         # this is the first "real token" following a NEWLINE, so it
+         # must be the first token of the next program statement, or an
+         # ENDMARKER; the "line" argument exposes the leading whitespace
+         # for this statement; in the case of ENDMARKER, line is an empty
+         # string, so will properly match the empty string with which the
+         # "indents" stack was seeded
+         check_equal = 0
+         thisguy = Whitespace(line)
+         if not indents[-1].equal(thisguy):
+             witness = indents[-1].not_equal_witness(thisguy)
+             msg = "indent not equal e.g. " + format_witnesses(witness)
+             raise NannyNag(start[0], msg, line)
+
+else:
+ # unpatched version of tokenize
+
+ nesting_level = 0
+ indents = []
+ check_equal = 0
+
+ def reset_globals():
+     global nesting_level, indents, check_equal
+     nesting_level = check_equal = 0
+     indents = [Whitespace("")]
+
+ def tokeneater(type, token, start, end, line,
+                INDENT=tokenize.INDENT,
+                DEDENT=tokenize.DEDENT,
+                NEWLINE=tokenize.NEWLINE,
+                COMMENT=tokenize.COMMENT,
+                OP=tokenize.OP):
+     global nesting_level, indents, check_equal
+
+     if type == INDENT:
+         check_equal = 0
+         thisguy = Whitespace(token)
+         if not indents[-1].less(thisguy):
+             witness = indents[-1].not_less_witness(thisguy)
+             msg = "indent not greater e.g. " + format_witnesses(witness)
+             raise NannyNag(start[0], msg, line)
+         indents.append(thisguy)
+
+     elif type == DEDENT:
+         del indents[-1]
+
+     elif type == NEWLINE:
+         if nesting_level == 0:
+             check_equal = 1
+
+     elif type == COMMENT:
+         pass
+
+     elif check_equal:
+         check_equal = 0
+         thisguy = Whitespace(line)
+         if not indents[-1].equal(thisguy):
+             witness = indents[-1].not_equal_witness(thisguy)
+             msg = "indent not equal e.g. " + format_witnesses(witness)
+             raise NannyNag(start[0], msg, line)
+
+     if type == OP and token in ('{', '[', '('):
+         nesting_level = nesting_level + 1
+
+     elif type == OP and token in ('}', ']', ')'):
+         if nesting_level == 0:
+             raise NannyNag(start[0],
+                            "unbalanced bracket '" + token + "'",
+                            line)
+         nesting_level = nesting_level - 1
+
+if __name__ == '__main__':
+    main()
+
diff --git a/Lib/idlelib/testcode.py b/Lib/idlelib/testcode.py
new file mode 100644
index 0000000..05eaa56
--- /dev/null
+++ b/Lib/idlelib/testcode.py
@@ -0,0 +1,31 @@
+import string
+
+def f():
+    a = 0
+    b = 1
+    c = 2
+    d = 3
+    e = 4
+    g()
+
+def g():
+    h()
+
+def h():
+    i()
+
+def i():
+    j()
+
+def j():
+    k()
+
+def k():
+    l()
+
+l = lambda: test()
+
+def test():
+    string.capwords(1)
+
+f()