Changeset 391 for python/trunk/Lib/idlelib

python/trunk

Property svn:mergeinfo set to
/python/vendor/Python-2.7.6 merged eligible
/python/vendor/current merged eligible

python/trunk/Lib/idlelib/AutoComplete.py

-              r2
+              r391
 import string
+from configHandler import idleConf
+import AutoCompleteWindow
+from HyperParser import HyperParser
+import __main__
+from idlelib.configHandler import idleConf
 # This string includes all chars that may be in a file name (without a path
 …
 # These constants represent the two different types of completions
 COMPLETE_ATTRIBUTES, COMPLETE_FILES = range(1, 2+1)
+from idlelib import AutoCompleteWindow
+from idlelib.HyperParser import HyperParser
+import __main__
 SEPS = os.sep
 …
             return
         self.autocompletewindow = self._make_autocomplete_window()
+        self.autocompletewindow.show_window(comp_lists,
+                                            "insert-%dc" % len(comp_start),
+                                            complete,
+                                            mode,
+                                            userWantsWin)
+        return True
+        return not self.autocompletewindow.show_window(
+                comp_lists, "insert-%dc" % len(comp_start),
+                complete, mode, userWantsWin)
     def fetch_completions(self, what, mode):
 …
                     bigl.sort()
                     if "__all__" in bigl:
+                        smalll = eval("__all__", namespace)
+                        smalll.sort()
+                        smalll = sorted(eval("__all__", namespace))
                     else:
                         smalll = filter(lambda s: s[:1] != '_', bigl)
+                        smalll = [s for s in bigl if s[:1] != '_']
                 else:
                     try:
 …
                         bigl.sort()
                         if "__all__" in bigl:
+                            smalll = entity.__all__
+                            smalll.sort()
+                            smalll = sorted(entity.__all__)
                         else:
                             smalll = filter(lambda s: s[:1] != '_', bigl)
+                            smalll = [s for s in bigl if s[:1] != '_']
                     except:
                         return [], []
 …
                     bigl = os.listdir(expandedpath)
                     bigl.sort()
                     smalll = filter(lambda s: s[:1] != '.', bigl)
+                    smalll = [s for s in bigl if s[:1] != '.']
                 except OSError:
                     return [], []

python/trunk/Lib/idlelib/AutoCompleteWindow.py

-              r2
+              r391
 """
 from Tkinter import *
 from MultiCall import MC_SHIFT
+import AutoComplete
+from idlelib.MultiCall import MC_SHIFT
+from idlelib.AutoComplete import COMPLETE_FILES, COMPLETE_ATTRIBUTES
 HIDE_VIRTUAL_EVENT_NAME = "<<autocompletewindow-hide>>"
 …
         if complete:
             completed = self._complete_string(self.start)
+            start = self.start
             self._change_start(completed)
             i = self._binary_search(completed)
 …
                 self.completions[i+1][:len(completed)] != completed):
                 # There is exactly one matching completion
                 return
+                return completed == start
         self.userwantswindow = userWantsWin
         self.lasttypedstart = self.start
 …
             self.lastkey_was_tab = False
         if (len(keysym) == 1 or keysym in ("underscore", "BackSpace")
             or (self.mode==AutoComplete.COMPLETE_FILES and keysym in
+            or (self.mode == COMPLETE_FILES and keysym in
                 ("period", "minus"))) \
            and not (state & ~MC_SHIFT):
 …
             return
         elif (self.mode == AutoComplete.COMPLETE_ATTRIBUTES and keysym in
+        elif (self.mode == COMPLETE_ATTRIBUTES and keysym in
               ("period", "space", "parenleft", "parenright", "bracketleft",
                "bracketright")) or \
              (self.mode == AutoComplete.COMPLETE_FILES and keysym in
+             (self.mode == COMPLETE_FILES and keysym in
               ("slash", "backslash", "quotedbl", "apostrophe")) \
              and not (state & ~MC_SHIFT):
 …
             cursel = int(self.listbox.curselection()[0])
             if self.completions[cursel][:len(self.start)] == self.start \
                and (self.mode==AutoComplete.COMPLETE_ATTRIBUTES or self.start):
+               and (self.mode == COMPLETE_ATTRIBUTES or self.start):
                 self._change_start(self.completions[cursel])
             self.hide_window()
 …
                 return
+        elif reduce(lambda x, y: x or y,
+                    [keysym.find(s) != -1 for s in ("Shift", "Control", "Alt",
+                                                    "Meta", "Command", "Option")
+                     ]):
+        elif any(s in keysym for s in ("Shift", "Control", "Alt",
+                                       "Meta", "Command", "Option")):
             # A modifier key, so ignore
             return

python/trunk/Lib/idlelib/Bindings.py

-              r2
+              r391
 """
 import sys
 from configHandler import idleConf
 import macosxSupport
+from idlelib.configHandler import idleConf
+from idlelib import macosxSupport
 menudefs = [
  # underscore prefixes character to underscore
  ('file', [
    ('_New Window', '<<open-new-window>>'),
+   ('_New File', '<<open-new-window>>'),
    ('_Open...', '<<open-window-from-file>>'),
    ('Open _Module...', '<<open-module>>'),
 …
     del menudefs[-1][1][0:2]
+    menudefs.insert(0,
+            ('application', [
+                ('About IDLE', '<<about-idle>>'),
+                None,
+                ('_Preferences....', '<<open-config-dialog>>'),
+            ]))
+    # Remove the 'Configure' entry from the options menu, it is in the
+    # application menu as 'Preferences'
+    del menudefs[-2][1][0:2]
 default_keydefs = idleConf.GetCurrentKeySet()

python/trunk/Lib/idlelib/CREDITS.txt

-              r2
+              r391
 Scott David Daniels, Tal Einat, Hernan Foffani, Christos Georgiou,
 Jim Jewett, Martin v. Löwis, Jason Orendorff, Guilherme Polo, Josh Robb,
 Nigel Rowe, Bruce Sherwood, and Jeff Shute have submitted useful patches.
 Thanks, guys!
+Nigel Rowe, Bruce Sherwood, Jeff Shute, and Weeble have submitted useful
+patches.  Thanks, guys!
 For additional details refer to NEWS.txt and Changelog.

python/trunk/Lib/idlelib/CallTipWindow.py

-              r2
+              r391
         self.lastline = None
         self.hideid = self.checkhideid = None
+        self.checkhide_after_id = None
     def position_window(self):
 …
         else:
             self.position_window()
+            self.widget.after(CHECKHIDE_TIME, self.checkhide_event)
+            if self.checkhide_after_id is not None:
+                self.widget.after_cancel(self.checkhide_after_id)
+            self.checkhide_after_id = \
+                self.widget.after(CHECKHIDE_TIME, self.checkhide_event)
     def hide_event(self, event):

python/trunk/Lib/idlelib/CallTips.py

-              r2
+              r391
 import types
 import CallTipWindow
 from HyperParser import HyperParser
+from idlelib import CallTipWindow
+from idlelib.HyperParser import HyperParser
 import __main__
 …
             return
         hp.set_index(sur_paren[0])
         name = hp.get_expression()
         if not name or (not evalfuncs and name.find('(') != -1):
             return
         arg_text = self.fetch_tip(name)
+        expression = hp.get_expression()
+        if not expression or (not evalfuncs and expression.find('(') != -1):
+            return
+        arg_text = self.fetch_tip(expression)
         if not arg_text:
             return
 …
         self.calltip.showtip(arg_text, sur_paren[0], sur_paren[1])
     def fetch_tip(self, name):
+    def fetch_tip(self, expression):
         """Return the argument list and docstring of a function or class
 …
         try:
             rpcclt = self.editwin.flist.pyshell.interp.rpcclt
         except:
+        except AttributeError:
             rpcclt = None
         if rpcclt:
             return rpcclt.remotecall("exec", "get_the_calltip",
                                      (name,), {})
+                                     (expression,), {})
         else:
             entity = self.get_entity(name)
+            entity = self.get_entity(expression)
             return get_arg_text(entity)
+    def get_entity(self, name):
+        "Lookup name in a namespace spanning sys.modules and __main.dict__"
+        if name:
+    def get_entity(self, expression):
+        """Return the object corresponding to expression evaluated
+        in a namespace spanning sys.modules and __main.dict__.
+        """
+        if expression:
             namespace = sys.modules.copy()
             namespace.update(__main__.__dict__)
             try:
+                return eval(name, namespace)
+            except (NameError, AttributeError):
+                return eval(expression, namespace)
+            except BaseException:
+                # An uncaught exception closes idle, and eval can raise any
+                # exception, especially if user classes are involved.
                 return None
 …
 def get_arg_text(ob):
+    """Get a string describing the arguments for the given object"""
+    """Get a string describing the arguments for the given object,
+       only if it is callable."""
     arg_text = ""
     if ob is not None:
+    if ob is not None and hasattr(ob, '__call__'):
         arg_offset = 0
         if type(ob) in (types.ClassType, types.TypeType):
 …
                 items.append("***")
             arg_text = ", ".join(items)
             arg_text = "(%s)" % re.sub("\.\d+", "<tuple>", arg_text)
+            arg_text = "(%s)" % re.sub("(?<!\d)\.\d+", "<tuple>", arg_text)
         # See if we can use the docstring
         doc = getattr(ob, "__doc__", "")
 …
              TC, tc.t1, tc.t2, tc.t3, tc.t4, tc.t5, tc.t6, tc.t7)
+    test(tests)
+    # test(tests)
+    from unittest import main
+    main('idlelib.idle_test.test_calltips', verbosity=2, exit=False)

python/trunk/Lib/idlelib/ClassBrowser.py

-              r2
+              r391
 import pyclbr
 import PyShell
 from WindowList import ListedToplevel
 from TreeWidget import TreeNode, TreeItem, ScrolledCanvas
 from configHandler import idleConf
+from idlelib import PyShell
+from idlelib.WindowList import ListedToplevel
+from idlelib.TreeWidget import TreeNode, TreeItem, ScrolledCanvas
+from idlelib.configHandler import idleConf
 class ClassBrowser:

python/trunk/Lib/idlelib/CodeContext.py

-              r2
+              r391
 import Tkinter
 from Tkconstants import TOP, LEFT, X, W, SUNKEN
-from configHandler import idleConf
 import re
 from sys import maxint as INFINITY
+from idlelib.configHandler import idleConf
 BLOCKOPENERS = set(["class", "def", "elif", "else", "except", "finally", "for",

python/trunk/Lib/idlelib/ColorDelegator.py

-              r2
+              r391
 import __builtin__
 from Tkinter import *
 from Delegator import Delegator
 from configHandler import idleConf
+from idlelib.Delegator import Delegator
+from idlelib.configHandler import idleConf
 DEBUG = False
 …
     builtin = r"([^.'\"\\#]\b|^)" + any("BUILTIN", builtinlist) + r"\b"
     comment = any("COMMENT", [r"#[^\n]*"])
+    sqstring = r"(\b[rRuU])?'[^'\\\n]*(\\.[^'\\\n]*)*'?"
+    dqstring = r'(\b[rRuU])?"[^"\\\n]*(\\.[^"\\\n]*)*"?'
+    sq3string = r"(\b[rRuU])?'''[^'\\]*((\\.|'(?!''))[^'\\]*)*(''')?"
+    dq3string = r'(\b[rRuU])?"""[^"\\]*((\\.|"(?!""))[^"\\]*)*(""")?'
+    stringprefix = r"(\br|u|ur|R|U|UR|Ur|uR|b|B|br|Br|bR|BR)?"
+    sqstring = stringprefix + r"'[^'\\\n]*(\\.[^'\\\n]*)*'?"
+    dqstring = stringprefix + r'"[^"\\\n]*(\\.[^"\\\n]*)*"?'
+    sq3string = stringprefix + r"'''[^'\\]*((\\.|'(?!''))[^'\\]*)*(''')?"
+    dq3string = stringprefix + r'"""[^"\\]*((\\.|"(?!""))[^"\\]*)*(""")?'
     string = any("STRING", [sq3string, dq3string, sqstring, dqstring])
     return kw + "|" + builtin + "|" + comment + "|" + string +\
 …
             self.bind("<<toggle-auto-coloring>>", self.toggle_colorize_event)
             self.notify_range("1.0", "end")
+        else:
+            # No delegate - stop any colorizing
+            self.stop_colorizing = True
+            self.allow_colorizing = False
     def config_colors(self):
 …
 def main():
     from Percolator import Percolator
+    from idlelib.Percolator import Percolator
     root = Tk()
     root.wm_protocol("WM_DELETE_WINDOW", root.quit)

python/trunk/Lib/idlelib/Debugger.py

-              r2
+              r391
 import types
 from Tkinter import *
 from WindowList import ListedToplevel
 from ScrolledList import ScrolledList
 import macosxSupport
+from idlelib.WindowList import ListedToplevel
+from idlelib.ScrolledList import ScrolledList
+from idlelib import macosxSupport

python/trunk/Lib/idlelib/Delegator.py

-              r2
+              r391
     def __init__(self, delegate=None):
         self.delegate = delegate
         self.__cache = {}
+        self.__cache = set()
     def __getattr__(self, name):
         attr = getattr(self.delegate, name) # May raise AttributeError
         setattr(self, name, attr)
         self.__cache[name] = attr
+        self.__cache.add(name)
         return attr
     def resetcache(self):
         for key in self.__cache.keys():
+        for key in self.__cache:
             try:
                 delattr(self, key)
 …
         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

python/trunk/Lib/idlelib/EditorWindow.py

-              r2
+              r391
 import re
 import imp
-from itertools import count
 from Tkinter import *
 import tkSimpleDialog
 import tkMessageBox
-from MultiCall import MultiCallCreator
 import webbrowser
+import idlever
+import WindowList
+import SearchDialog
+import GrepDialog
+import ReplaceDialog
+import PyParse
+from configHandler import idleConf
+import aboutDialog, textView, configDialog
+import macosxSupport
+from idlelib.MultiCall import MultiCallCreator
+from idlelib import idlever
+from idlelib import WindowList
+from idlelib import SearchDialog
+from idlelib import GrepDialog
+from idlelib import ReplaceDialog
+from idlelib import PyParse
+from idlelib.configHandler import idleConf
+from idlelib import aboutDialog, textView, configDialog
+from idlelib import macosxSupport
 # The default tab setting for a Text widget, in average-width characters.
 …
     release = '%s%s' % (major, minor)
     if micro:
+        release += '%s' % micro
+    if level != 'final':
+        release += '%s' % (micro,)
+    if level == 'candidate':
+        release += 'rc%s' % (serial,)
+    elif level != 'final':
         release += '%s%s' % (level[0], serial)
     return release
 …
         except AttributeError:
             raise ImportError, 'No source for module ' + module.__name__
+    if descr[2] != imp.PY_SOURCE:
+        # If all of the above fails and didn't raise an exception,fallback
+        # to a straight import which can find __init__.py in a package.
+        m = __import__(fullname)
+        try:
+            filename = m.__file__
+        except AttributeError:
+            pass
+        else:
+            file = None
+            base, ext = os.path.splitext(filename)
+            if ext == '.pyc':
+                ext = '.py'
+            filename = base + ext
+            descr = filename, None, imp.PY_SOURCE
     return file, filename, descr
+class HelpDialog(object):
+    def __init__(self):
+        self.parent = None      # parent of help window
+        self.dlg = None         # the help window iteself
+    def display(self, parent, near=None):
+        """ Display the help dialog.
+            parent - parent widget for the help window
+            near - a Toplevel widget (e.g. EditorWindow or PyShell)
+                   to use as a reference for placing the help window
+        """
+        if self.dlg is None:
+            self.show_dialog(parent)
+        if near:
+            self.nearwindow(near)
+    def show_dialog(self, parent):
+        self.parent = parent
+        fn=os.path.join(os.path.abspath(os.path.dirname(__file__)),'help.txt')
+        self.dlg = dlg = textView.view_file(parent,'Help',fn, modal=False)
+        dlg.bind('<Destroy>', self.destroy, '+')
+    def nearwindow(self, near):
+        # Place the help dialog near the window specified by parent.
+        # Note - this may not reposition the window in Metacity
+        #  if "/apps/metacity/general/disable_workarounds" is enabled
+        dlg = self.dlg
+        geom = (near.winfo_rootx() + 10, near.winfo_rooty() + 10)
+        dlg.withdraw()
+        dlg.geometry("=+%d+%d" % geom)
+        dlg.deiconify()
+        dlg.lift()
+    def destroy(self, ev=None):
+        self.dlg = None
+        self.parent = None
+helpDialog = HelpDialog()  # singleton instance
 class EditorWindow(object):
     from Percolator import Percolator
     from ColorDelegator import ColorDelegator
     from UndoDelegator import UndoDelegator
     from IOBinding import IOBinding, filesystemencoding, encoding
     import Bindings
+    from idlelib.Percolator import Percolator
+    from idlelib.ColorDelegator import ColorDelegator
+    from idlelib.UndoDelegator import UndoDelegator
+    from idlelib.IOBinding import IOBinding, filesystemencoding, encoding
+    from idlelib import Bindings
     from Tkinter import Toplevel
     from MultiStatusBar import MultiStatusBar
+    from idlelib.MultiStatusBar import MultiStatusBar
     help_url = None
 …
         if flist:
             self.tkinter_vars = flist.vars
             #self.top.instance_dict makes flist.inversedict avalable to
             #configDialog.py so it can access all EditorWindow instaces
+            #self.top.instance_dict makes flist.inversedict available to
+            #configDialog.py so it can access all EditorWindow instances
             self.top.instance_dict = flist.inversedict
         else:
 …
         self.text_frame = text_frame = Frame(top)
         self.vbar = vbar = Scrollbar(text_frame, name='vbar')
         self.width = idleConf.GetOption('main','EditorWindow','width')
+        self.width = idleConf.GetOption('main','EditorWindow','width', type='int')
         text_options = {
                 'name': 'text',
 …
                 'wrap': 'none',
                 'width': self.width,
                 'height': idleConf.GetOption('main', 'EditorWindow', 'height')}
+                'height': idleConf.GetOption('main', 'EditorWindow', 'height', type='int')}
         if TkVersion >= 8.5:
             # Starting with tk 8.5 we have to set the new tabstyle option
 …
             # Command-W on editorwindows doesn't work without this.
             text.bind('<<close-window>>', self.close_event)
+            # Some OS X systems have only one mouse button,
+            # so use control-click for pulldown menus there.
+            #  (Note, AquaTk defines <2> as the right button if
+            #   present and the Tk Text widget already binds <2>.)
+            text.bind("<Control-Button-1>",self.right_menu_event)
+        else:
+            # Elsewhere, use right-click for pulldown menus.
+            text.bind("<3>",self.right_menu_event)
         text.bind("<<cut>>", self.cut)
         text.bind("<<copy>>", self.copy)
 …
         text.bind("<<replace>>", self.replace_event)
         text.bind("<<goto-line>>", self.goto_line_event)
-        text.bind("<3>", self.right_menu_event)
         text.bind("<<smart-backspace>>",self.smart_backspace_event)
         text.bind("<<newline-and-indent>>",self.newline_and_indent_event)
 …
             fontWeight='bold'
         text.config(font=(idleConf.GetOption('main', 'EditorWindow', 'font'),
+                          idleConf.GetOption('main', 'EditorWindow', 'font-size'),
+                          idleConf.GetOption('main', 'EditorWindow',
+                                             'font-size', type='int'),
                           fontWeight))
         text_frame.pack(side=LEFT, fill=BOTH, expand=1)
 …
         self.showerror = tkMessageBox.showerror
+        self._highlight_workaround()  # Fix selection tags on Windows
+    def _highlight_workaround(self):
+        # On Windows, Tk removes painting of the selection
+        # tags which is different behavior than on Linux and Mac.
+        # See issue14146 for more information.
+        if not sys.platform.startswith('win'):
+            return
+        text = self.text
+        text.event_add("<<Highlight-FocusOut>>", "<FocusOut>")
+        text.event_add("<<Highlight-FocusIn>>", "<FocusIn>")
+        def highlight_fix(focus):
+            sel_range = text.tag_ranges("sel")
+            if sel_range:
+                if focus == 'out':
+                    HILITE_CONFIG = idleConf.GetHighlight(
+                            idleConf.CurrentTheme(), 'hilite')
+                    text.tag_config("sel_fix", HILITE_CONFIG)
+                    text.tag_raise("sel_fix")
+                    text.tag_add("sel_fix", *sel_range)
+                elif focus == 'in':
+                    text.tag_remove("sel_fix", "1.0", "end")
+        text.bind("<<Highlight-FocusOut>>",
+                lambda ev: highlight_fix("out"))
+        text.bind("<<Highlight-FocusIn>>",
+                lambda ev: highlight_fix("in"))
     def _filename_to_unicode(self, filename):
         """convert filename to unicode in order to display it in Tk"""
 …
     def home_callback(self, event):
+        if (event.state & 12) != 0 and event.keysym == "Home":
+            # state&1==shift, state&4==control, state&8==alt
+            return # <Modifier-Home>; fall back to class binding
+        if (event.state & 4) != 0 and event.keysym == "Home":
+            # state&4==Control. If <Control-Home>, use the Tk binding.
+            return
         if self.text.index("iomark") and \
            self.text.compare("iomark", "<=", "insert lineend") and \
            self.text.compare("insert linestart", "<=", "iomark"):
+            # In Shell on input line, go to just after prompt
             insertpt = int(self.text.index("iomark").split(".")[1])
         else:
 …
             else:
                 insertpt=len(line)
         lineat = int(self.text.index("insert").split('.')[1])
         if insertpt == lineat:
             insertpt = 0
         dest = "insert linestart+"+str(insertpt)+"c"
         if (event.state&1) == 0:
             # shift not pressed
+            # shift was not pressed
             self.text.tag_remove("sel", "1.0", "end")
         else:
             if not self.text.index("sel.first"):
+                self.text.mark_set("anchor","insert")
+                self.text.mark_set("my_anchor", "insert")  # there was no previous selection
+            else:
+                if self.text.compare(self.text.index("sel.first"), "<", self.text.index("insert")):
+                    self.text.mark_set("my_anchor", "sel.first") # extend back
+                else:
+                    self.text.mark_set("my_anchor", "sel.last") # extend forward
             first = self.text.index(dest)
+            last = self.text.index("anchor")
+            last = self.text.index("my_anchor")
             if self.text.compare(first,">",last):
                 first,last = last,first
             self.text.tag_remove("sel", "1.0", "end")
             self.text.tag_add("sel", first, last)
         self.text.mark_set("insert", dest)
         self.text.see("insert")
 …
     if macosxSupport.runningAsOSXApp():
-        del menu_specs[-3]
         menu_specs[-2] = ("windows", "_Window")
 …
             mbar.add_cascade(label=label, menu=menu, underline=underline)
         if macosxSupport.runningAsOSXApp():
+        if macosxSupport.isCarbonAquaTk(self.root):
             # Insert the application menu
             menudict['application'] = menu = Menu(mbar, name='apple')
 …
     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:
 …
         if iswin:
             self.text.config(cursor="arrow")
+        for item in self.rmenu_specs:
+            try:
+                label, eventname, verify_state = item
+            except ValueError: # see issue1207589
+                continue
+            if verify_state is None:
+                continue
+            state = getattr(self, verify_state)()
+            rmenu.entryconfigure(label, state=state)
         rmenu.tk_popup(event.x_root, event.y_root)
         if iswin:
 …
     rmenu_specs = [
         # ("Label", "<<virtual-event>>"), ...
         ("Close", "<<close-window>>"), # Example
+        # ("Label", "<<virtual-event>>", "statefuncname"), ...
+        ("Close", "<<close-window>>", None), # 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)
+        for item in self.rmenu_specs:
+            label, eventname = item[0], item[1]
+            if label is not None:
+                def command(text=self.text, eventname=eventname):
+                    text.event_generate(eventname)
+                rmenu.add_command(label=label, command=command)
+            else:
+                rmenu.add_separator()
         self.rmenu = rmenu
+    def rmenu_check_cut(self):
+        return self.rmenu_check_copy()
+    def rmenu_check_copy(self):
+        try:
+            indx = self.text.index('sel.first')
+        except TclError:
+            return 'disabled'
+        else:
+            return 'normal' if indx else 'disabled'
+    def rmenu_check_paste(self):
+        try:
+            self.text.tk.call('tk::GetSelection', self.text, 'CLIPBOARD')
+        except TclError:
+            return 'disabled'
+        else:
+            return 'normal'
     def about_dialog(self, event=None):
 …
     def help_dialog(self, event=None):
+        fn=os.path.join(os.path.abspath(os.path.dirname(__file__)),'help.txt')
+        textView.view_file(self.top,'Help',fn)
+        if self.root:
+            parent = self.root
+        else:
+            parent = self.top
+        helpDialog.display(parent, near=self.top)
     def python_docs(self, event=None):
         if sys.platform[:3] == 'win':
+            os.startfile(self.help_url)
+            try:
+                os.startfile(self.help_url)
+            except WindowsError as why:
+                tkMessageBox.showerror(title='Document Start Failure',
+                    message=str(why), parent=self.text)
         else:
             webbrowser.open(self.help_url)
 …
         try:
             (f, file, (suffix, mode, type)) = _find_module(name)
         except (NameError, ImportError), msg:
+        except (NameError, ImportError) as msg:
             tkMessageBox.showerror("Import error", str(msg), parent=self.text)
             return
 …
         head, tail = os.path.split(filename)
         base, ext = os.path.splitext(tail)
         import ClassBrowser
+        from idlelib import ClassBrowser
         ClassBrowser.ClassBrowser(self.flist, base, [head])
     def open_path_browser(self, event=None):
         import PathBrowser
+        from idlelib import PathBrowser
         PathBrowser.PathBrowser(self.flist)
 …
             fontWeight='bold'
         self.text.config(font=(idleConf.GetOption('main','EditorWindow','font'),
+                idleConf.GetOption('main','EditorWindow','font-size'),
+                idleConf.GetOption('main','EditorWindow','font-size',
+                                   type='int'),
                 fontWeight))
 …
         for menubarItem in self.menudict.keys():
             menu = self.menudict[menubarItem]
+            end = menu.index(END) + 1
+            end = menu.index(END)
+            if end is None:
+                # Skip empty menus
+                continue
+            end += 1
             for index in range(0, end):
                 if menu.type(index) == 'command':
 …
                         itemName = menu.entrycget(index, 'label')
                         event = ''
                         if menuEventDict.has_key(menubarItem):
                             if menuEventDict[menubarItem].has_key(itemName):
+                        if menubarItem in menuEventDict:
+                            if itemName in menuEventDict[menubarItem]:
                                 event = menuEventDict[menubarItem][itemName]
                         if event:
 …
         def display_extra_help(helpfile=helpfile):
             if not helpfile.startswith(('www', 'http')):
                 url = os.path.normpath(helpfile)
+                helpfile = os.path.normpath(helpfile)
             if sys.platform[:3] == 'win':
+                os.startfile(helpfile)
+                try:
+                    os.startfile(helpfile)
+                except WindowsError as why:
+                    tkMessageBox.showerror(title='Document Start Failure',
+                        message=str(why), parent=self.text)
             else:
                 webbrowser.open(helpfile)
 …
         rf_list = []
         if os.path.exists(self.recent_files_path):
+            rf_list_file = open(self.recent_files_path,'r')
+            try:
+            with  open(self.recent_files_path, 'r') as rf_list_file:
                 rf_list = rf_list_file.readlines()
-            finally:
-                rf_list_file.close()
         if new_file:
             new_file = os.path.abspath(new_file) + '\n'
 …
         ulchars = "1234567890ABCDEFGHIJK"
         rf_list = rf_list[0:len(ulchars)]
-        rf_file = open(self.recent_files_path, 'w')
         try:
+            rf_file.writelines(rf_list)
+        finally:
+            rf_file.close()
+            with open(self.recent_files_path, 'w') as rf_file:
+                rf_file.writelines(rf_list)
+        except IOError as err:
+            if not getattr(self.root, "recentfilelist_error_displayed", False):
+                self.root.recentfilelist_error_displayed = True
+                tkMessageBox.showerror(title='IDLE Error',
+                    message='Unable to update Recent Files list:\n%s'
+                        % str(err),
+                    parent=self.text)
         # for each edit window instance, construct the recent files menu
         for instance in self.top.instance_dict.keys():
             menu = instance.recent_files_menu
             menu.delete(1, END)  # clear, and rebuild:
             for i, file in zip(count(), rf_list):
                 file_name = file[0:-1]  # zap \n
+            menu.delete(0, END)  # clear, and rebuild:
+            for i, file_name in enumerate(rf_list):
+                file_name = file_name.rstrip()  # zap \n
                 # make unicode string to display non-ASCII chars correctly
                 ufile_name = self._filename_to_unicode(file_name)
 …
         want = ((have - 1) // self.indentwidth) * self.indentwidth
         # Debug prompt is multilined....
+        last_line_of_prompt = sys.ps1.split('\n')[-1]
+        if self.context_use_ps1:
+            last_line_of_prompt = sys.ps1.split('\n')[-1]
+        else:
+            last_line_of_prompt = ''
         ncharsdeleted = 0
         while 1:
 …
                 for context in self.num_context_lines:
                     startat = max(lno - context, 1)
                     startatindex = `startat` + ".0"
+                    startatindex = repr(startat) + ".0"
                     rawtext = text.get(startatindex, "insert")
                     y.set_str(rawtext)
 …
         head, tail, chars, lines = self.get_region()
         tabwidth = self._asktabwidth()
+        if tabwidth is None: return
         for pos in range(len(lines)):
             line = lines[pos]
 …
         head, tail, chars, lines = self.get_region()
         tabwidth = self._asktabwidth()
+        if tabwidth is None: return
         for pos in range(len(lines)):
             lines[pos] = lines[pos].expandtabs(tabwidth)
 …
             initialvalue=self.indentwidth,
             minvalue=2,
             maxvalue=16) or self.tabwidth
+            maxvalue=16)
     # Guess indentwidth from text content.
 …
             try:
                 _tokenize.tokenize(self.readline, self.tokeneater)
             except _tokenize.TokenError:
+            except (_tokenize.TokenError, SyntaxError):
                 # since we cut off the tokenizer early, we can trigger
                 # spurious errors
 …
 def get_accelerator(keydefs, eventname):
     keylist = keydefs.get(eventname)
+    if not keylist:
+    # issue10940: temporary workaround to prevent hang with OS X Cocoa Tk 8.5
+    # if not keylist:
+    if (not keylist) or (macosxSupport.runningAsOSXApp() and eventname in {
+                            "<<open-module>>",
+                            "<<goto-line>>",
+                            "<<change-indentwidth>>"}):
         return ""
     s = keylist[0]

python/trunk/Lib/idlelib/FileList.py

-              r2
+              r391
 class FileList:
     from EditorWindow import EditorWindow  # class variable, may be overridden
                                            # e.g. by PyShellFileList
+    # N.B. this import overridden in PyShellFileList.
+    from idlelib.EditorWindow import EditorWindow
     def __init__(self, root):
 …
             return None
         key = os.path.normcase(filename)
         if self.dict.has_key(key):
+        if key in self.dict:
             edit = self.dict[key]
             edit.top.wakeup()
 …
         return self.EditorWindow(self, filename)
     def close_all_callback(self, event):
+    def close_all_callback(self, *args, **kwds):
         for edit in self.inversedict.keys():
             reply = edit.close()
 …
         if newkey == key:
             return
         if self.dict.has_key(newkey):
+        if newkey in self.dict:
             conflict = self.dict[newkey]
             self.inversedict[conflict] = None
 …
 def _test():
     from EditorWindow import fixwordbreaks
+    from idlelib.EditorWindow import fixwordbreaks
     import sys
     root = Tk()

python/trunk/Lib/idlelib/FormatParagraph.py

-              r2
+              r391
+# Extension to format a paragraph
+"""Extension to format a paragraph or selection to a max width.
 # 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.
+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 :-)
+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, aren't handled :-)
+"""
 import re
 from configHandler import idleConf
+from idlelib.configHandler import idleConf
 class FormatParagraph:
 …
     def format_paragraph_event(self, event):
+        maxformatwidth = int(idleConf.GetOption('main','FormatParagraph','paragraph'))
+        """Formats paragraph to a max width specified in idleConf.
+        If text is selected, format_paragraph_event will start breaking lines
+        at the max width, starting from the beginning selection.
+        If no text is selected, format_paragraph_event uses the current
+        cursor location to determine the paragraph (lines of text surrounded
+        by blank lines) and formats it.
+        """
+        maxformatwidth = idleConf.GetOption(
+                'main', 'FormatParagraph', 'paragraph', type='int')
         text = self.editwin.text
         first, last = self.editwin.get_selection_indices()
         if first and last:
             data = text.get(first, last)
             comment_header = ''
+            comment_header = get_comment_header(data)
         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 = data.split("\n")
+            lines = map(lambda st, l=len(comment_header): st[l:], lines)
+            data = "\n".join(lines)
+            # Reformat to maxformatwidth chars or a 20 char width, whichever is greater.
+            format_width = max(maxformatwidth - len(comment_header), 20)
+            newdata = reformat_paragraph(data, format_width)
+            # re-split and re-insert the comment header.
+            newdata = newdata.split("\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 = '\n'.join(map(builder, newdata)) + block_suffix
+            newdata = reformat_comment(data, maxformatwidth, comment_header)
         else:
-            # Just a normal text format
             newdata = reformat_paragraph(data, maxformatwidth)
         text.tag_remove("sel", "1.0", "end")
         if newdata != data:
             text.mark_set("insert", first)
 …
 def find_paragraph(text, mark):
+    """Returns the start/stop indices enclosing the paragraph that mark is in.
+    Also returns the comment format string, if any, and paragraph of text
+    between the start/stop indices.
+    """
     lineno, col = map(int, mark.split("."))
+    line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
+    line = text.get("%d.0" % lineno, "%d.end" % lineno)
+    # Look for start of next paragraph if the index passed in is a blank line
     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)
+        line = text.get("%d.0" % lineno, "%d.end" % lineno)
     first_lineno = lineno
     comment_header = get_comment_header(line)
     comment_header_len = len(comment_header)
+    # Once start line found, search for end of paragraph (a blank line)
     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)
+        line = text.get("%d.0" % lineno, "%d.end" % lineno)
     last = "%d.0" % lineno
+    # Search back to beginning of paragraph
+    # Search back to beginning of paragraph (first blank line before)
     lineno = first_lineno - 1
     line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
+    line = text.get("%d.0" % lineno, "%d.end" % 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)
+        line = text.get("%d.0" % lineno, "%d.end" % lineno)
     first = "%d.0" % (lineno+1)
     return first, last, comment_header, text.get(first, last)
+# This should perhaps be replaced with textwrap.wrap
 def reformat_paragraph(data, limit):
+    """Return data reformatted to specified width (limit)."""
     lines = data.split("\n")
     i = 0
 …
                 continue # Can happen when line ends in whitespace
             if len((partial + word).expandtabs()) > limit and \
                partial != indent1:
+                   partial != indent1:
                 new.append(partial.rstrip())
                 partial = indent2
 …
     return "\n".join(new)
+def reformat_comment(data, limit, comment_header):
+    """Return data reformatted to specified width with comment header."""
+    # Remove header from the comment lines
+    lc = len(comment_header)
+    data = "\n".join(line[lc:] for line in data.split("\n"))
+    # Reformat to maxformatwidth chars or a 20 char width,
+    # whichever is greater.
+    format_width = max(limit - len(comment_header), 20)
+    newdata = reformat_paragraph(data, format_width)
+    # re-split and re-insert the comment header.
+    newdata = newdata.split("\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 is not made of complete lines, but whatever!)
+    # Can't think of a clean solution, so we hack away
+    block_suffix = ""
+    if not newdata[-1]:
+        block_suffix = "\n"
+        newdata = newdata[:-1]
+    return '\n'.join(comment_header+line for line in newdata) + block_suffix
 def is_all_white(line):
+    """Return True if line is empty or all whitespace."""
     return re.match(r"^\s*$", line) is not None
 def get_indent(line):
+    return re.match(r"^(\s*)", line).group()
+    """Return the initial space or tab indent of line."""
+    return re.match(r"^([ \t]*)", line).group()
 def get_comment_header(line):
+    m = re.match(r"^(\s*#*)", line)
+    """Return string with leading whitespace and '#' from line or ''.
+    A null return indicates that the line is not a comment line. A non-
+    null return, such as '    #', will be used to find the other lines of
+    a comment block with the same  indent.
+    """
+    m = re.match(r"^([ \t]*#*)", line)
     if m is None: return ""
     return m.group(1)
+if __name__ == "__main__":
+    from test import support; support.use_resources = ['gui']
+    import unittest
+    unittest.main('idlelib.idle_test.test_formatparagraph',
+            verbosity=2, exit=False)

python/trunk/Lib/idlelib/GrepDialog.py

-              r2
+              r391
 import sys
 from Tkinter import *
 import SearchEngine
 from SearchDialogBase import SearchDialogBase
+from idlelib import SearchEngine
+from idlelib.SearchDialogBase import SearchDialogBase
 def grep(text, io=None, flist=None):
 …
             self.top.bell()
             return
         from OutputWindow import OutputWindow
+        from idlelib.OutputWindow import OutputWindow
         save = sys.stdout
         try:
 …
         for fn in list:
             try:
+                f = open(fn)
+            except IOError, msg:
+                with open(fn) as f:
+                    for lineno, line in enumerate(f, 1):
+                        if line[-1:] == '\n':
+                            line = line[:-1]
+                        if prog.search(line):
+                            sys.stdout.write("%s: %s: %s\n" %
+                                             (fn, lineno, line))
+                            hits += 1
+            except IOError as 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."
+        print(("Hits found: %s\n"
+              "(Hint: right-click to open locations.)"
+              % hits) if hits else "No hits.")
     def findfiles(self, dir, base, rec):
         try:
             names = os.listdir(dir or os.curdir)
         except os.error, msg:
+        except os.error as msg:
             print msg
             return []
 …
             self.top.grab_release()
             self.top.withdraw()
+if __name__ == "__main__":
+    # A human test is a bit tricky since EditorWindow() imports this module.
+    # Hence Idle must be restarted after editing this file for a live test.
+    import unittest
+    unittest.main('idlelib.idle_test.test_grep', verbosity=2, exit=False)

python/trunk/Lib/idlelib/HISTORY.txt

r2	r391
14	14	project.
15	15
16		- This release requires python 2.1 or better. Compatability with earlier
	16	- This release requires python 2.1 or better. Compatibility with earlier
17	17	versions of python (especially ancient ones like 1.5x) is no longer a
18	18	priority in IDLEfork development.

python/trunk/Lib/idlelib/HyperParser.py

-              r2
+              r391
 import string
 import keyword
 import PyParse
+from idlelib import PyParse
 class HyperParser:
 …
             for context in editwin.num_context_lines:
                 startat = max(lno - context, 1)
                 startatindex = `startat` + ".0"
+                startatindex = repr(startat) + ".0"
                 stopatindex = "%d.end" % lno
                 # We add the newline because PyParse requires a newline at end.
 …
                 else:
                     # We can't continue after other types of brackets
+                    if rawtext[pos] in "'\"":
+                        # Scan a string prefix
+                        while pos > 0 and rawtext[pos - 1] in "rRbBuU":
+                            pos -= 1
+                        last_identifier_pos = pos
                     break

python/trunk/Lib/idlelib/IOBinding.py

-              r2
+              r391
 import os
 import types
+import pipes
 import sys
 import codecs
 …
 from SimpleDialog import SimpleDialog
 from configHandler import idleConf
+from idlelib.configHandler import idleConf
 try:
 …
 encoding = encoding.lower()
 coding_re = re.compile("coding[:=]\s*([-\w_.]+)")
+coding_re = re.compile(r'^[ \t\f]*#.*coding[:=][ \t]*([-\w.]+)')
 class EncodingMessage(SimpleDialog):
 …
     """
     # Only consider the first two lines
+    str = str.split("\n")[:2]
+    str = "\n".join(str)
+    match = coding_re.search(str)
+    if not match:
+    lst = str.split("\n", 2)[:2]
+    for line in lst:
+        match = coding_re.match(line)
+        if match is not None:
+            break
+    else:
         return None
     name = match.group(1)
 …
     def open(self, event=None, editFile=None):
+        if self.editwin.flist:
+        flist = self.editwin.flist
+        # Save in case parent window is closed (ie, during askopenfile()).
+        if flist:
             if not editFile:
                 filename = self.askopenfile()
 …
                 filename=editFile
             if filename:
+                # If the current window has no filename and hasn't been
+                # modified, we replace its contents (no loss).  Otherwise
+                # we open a new window.  But we won't replace the
+                # shell window (which has an interp(reter) attribute), which
+                # gets set to "not modified" at every new prompt.
+                try:
+                    interp = self.editwin.interp
+                except AttributeError:
+                    interp = None
+                if not self.filename and self.get_saved() and not interp:
+                    self.editwin.flist.open(filename, self.loadfile)
+                # If editFile is valid and already open, flist.open will
+                # shift focus to its existing window.
+                # If the current window exists and is a fresh unnamed,
+                # unmodified editor window (not an interpreter shell),
+                # pass self.loadfile to flist.open so it will load the file
+                # in the current window (if the file is not already open)
+                # instead of a new window.
+                if (self.editwin and
+                        not getattr(self.editwin, 'interp', None) and
+                        not self.filename and
+                        self.get_saved()):
+                    flist.open(filename, self.loadfile)
                 else:
                     self.editwin.flist.open(filename)
+                    flist.open(filename)
             else:
+                self.text.focus_set()
+                if self.text:
+                    self.text.focus_set()
             return "break"
+        #
         # Code for use outside IDLE:
         if self.get_saved():
 …
             # 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:
+            with open(filename, 'rb') as f:
+                chars = f.read()
+        except IOError as msg:
             tkMessageBox.showerror("I/O Error", str(msg), master=self.text)
             return False
 …
         self.set_filename(filename)
         self.text.mark_set("insert", "1.0")
         self.text.see("insert")
+        self.text.yview("insert")
         self.updaterecentfileslist(filename)
         return True
 …
         try:
             enc = coding_spec(chars)
         except LookupError, name:
+        except LookupError as name:
             tkMessageBox.showerror(
                 title="Error loading the file",
 …
         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":
+        confirm = tkMessageBox.askyesnocancel(
+                  title="Save On Close",
+                  message=message,
+                  default=tkMessageBox.YES,
+                  master=self.text)
+        if confirm:
+            reply = "yes"
             self.save(None)
             if not self.get_saved():
                 reply = "cancel"
+        elif confirm is None:
+            reply = "cancel"
+        else:
+            reply = "no"
         self.text.focus_set()
         return reply
 …
         else:
             if self.writefile(self.filename):
                 self.set_saved(1)
+                self.set_saved(True)
                 try:
                     self.editwin.store_file_breaks()
 …
             chars = chars.replace("\n", self.eol_convention)
         try:
+            f = open(filename, "wb")
+            f.write(chars)
+            f.flush()
+            f.close()
+            with open(filename, "wb") as f:
+                f.write(chars)
             return True
         except IOError, msg:
+        except IOError as msg:
             tkMessageBox.showerror("I/O Error", str(msg),
                                    master=self.text)
 …
             enc = coding_spec(chars)
             failed = None
         except LookupError, msg:
+        except LookupError as msg:
             failed = msg
             enc = None
 …
     def print_window(self, event):
+        m = tkMessageBox.Message(
+            title="Print",
+            message="Print to Default Printer",
+            icon=tkMessageBox.QUESTION,
+            type=tkMessageBox.OKCANCEL,
+            default=tkMessageBox.OK,
+            master=self.text)
+        reply = m.show()
+        if reply != tkMessageBox.OK:
+        confirm = tkMessageBox.askokcancel(
+                  title="Print",
+                  message="Print to Default Printer",
+                  default=tkMessageBox.OK,
+                  master=self.text)
+        if not confirm:
             self.text.focus_set()
             return "break"
 …
                 os.unlink(tempfilename)
                 return "break"
         platform=os.name
         printPlatform=1
+        platform = os.name
+        printPlatform = True
         if platform == 'posix': #posix platform
             command = idleConf.GetOption('main','General',
 …
             command = idleConf.GetOption('main','General','print-command-win')
         else: #no printing for this platform
             printPlatform=0
+            printPlatform = False
         if printPlatform:  #we can try to print for this platform
             command = command % filename
+            command = command % pipes.quote(filename)
             pipe = os.popen(command, "r")
             # things can get ugly on NT if there is no printer available.
 …
                 tkMessageBox.showerror("Print status", output, master=self.text)
         else:  #no printing for this platform
             message="Printing is not enabled for this platform: %s" % platform
+            message = "Printing is not enabled for this platform: %s" % platform
             tkMessageBox.showinfo("Print status", message, master=self.text)
         if tempfilename:
 …
     filetypes = [
         ("Python and text files", "*.py *.pyw *.txt", "TEXT"),
         ("All text files", "*", "TEXT"),
+        ("Python files", "*.py *.pyw", "TEXT"),
+        ("Text files", "*.txt", "TEXT"),
         ("All files", "*"),
+        ]

python/trunk/Lib/idlelib/IdleHistory.py

-              r2
+              r391
+from configHandler import idleConf
+"Implement Idle Shell history mechanism with History class"
+from idlelib.configHandler import idleConf
 class History:
+    ''' Implement Idle Shell history mechanism.
+    def __init__(self, text, output_sep = "\n"):
+    store - Store source statement (called from PyShell.resetoutput).
+    fetch - Fetch stored statement matching prefix already entered.
+    history_next - Bound to <<history-next>> event (default Alt-N).
+    history_prev - Bound to <<history-prev>> event (default Alt-P).
+    '''
+    def __init__(self, text):
+        '''Initialize data attributes and bind event methods.
+        .text - Idle wrapper of tk Text widget, with .bell().
+        .history - source statements, possibly with multiple lines.
+        .prefix - source already entered at prompt; filters history list.
+        .pointer - index into history.
+        .cyclic - wrap around history list (or not).
+        '''
         self.text = text
         self.history = []
+        self.history_prefix = None
+        self.history_pointer = None
+        self.output_sep = output_sep
+        self.prefix = None
+        self.pointer = None
         self.cyclic = idleConf.GetOption("main", "History", "cyclic", 1, "bool")
         text.bind("<<history-previous>>", self.history_prev)
 …
     def history_next(self, event):
+        self.history_do(0)
+        "Fetch later statement; start with ealiest if cyclic."
+        self.fetch(reverse=False)
         return "break"
     def history_prev(self, event):
+        self.history_do(1)
+        "Fetch earlier statement; start with most recent."
+        self.fetch(reverse=True)
         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 = self.text.get(start, end).split(self.output_sep)
+        return "\n".join(lines)
+    def fetch(self, reverse):
+        '''Fetch statememt and replace current line in text widget.
     def _put_source(self, where, source):
         output = self.output_sep.join(source.split("\n"))
         self.text.insert(where, output)
     def history_do(self, reverse):
+        Set prefix and pointer as needed for successive fetches.
+        Reset them to None, None when returning to the start line.
+        Sound bell when return to start line or cannot leave a line
+        because cyclic is False.
+        '''
         nhist = len(self.history)
         pointer = self.history_pointer
         prefix = self.history_prefix
+        pointer = self.pointer
+        prefix = self.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]:
+                    self.text.get("iomark", "end-1c") != self.history[pointer]:
                 pointer = prefix = None
+                self.text.mark_set("insert", "end-1c")  # != after cursor move
         if pointer is None or prefix is None:
             prefix = self._get_source("iomark", "end-1c")
+            prefix = self.text.get("iomark", "end-1c")
             if reverse:
                 pointer = nhist
+                pointer = nhist  # will be decremented
             else:
                 if self.cyclic:
                     pointer = -1
                 else:
+                    pointer = -1  # will be incremented
+                else:  # abort history_next
                     self.text.bell()
                     return
         nprefix = len(prefix)
         while 1:
+            if reverse:
+                pointer = pointer - 1
+            else:
+                pointer = pointer + 1
+            pointer += -1 if reverse else 1
             if pointer < 0 or pointer >= nhist:
                 self.text.bell()
                 if not self.cyclic and pointer < 0:
+                if not self.cyclic and pointer < 0:  # abort history_prev
                     return
                 else:
                     if self._get_source("iomark", "end-1c") != prefix:
+                    if self.text.get("iomark", "end-1c") != prefix:
                         self.text.delete("iomark", "end-1c")
                         self._put_source("iomark", prefix)
+                        self.text.insert("iomark", prefix)
                     pointer = prefix = None
                 break
 …
             if item[:nprefix] == prefix and len(item) > nprefix:
                 self.text.delete("iomark", "end-1c")
                 self._put_source("iomark", item)
+                self.text.insert("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
+        self.pointer = pointer
+        self.prefix = prefix
+    def history_store(self, source):
+    def store(self, source):
+        "Store Shell input statement into history list."
         source = source.strip()
         if len(source) > 2:
 …
                 pass
             self.history.append(source)
+        self.history_pointer = None
+        self.history_prefix = None
+        self.pointer = None
+        self.prefix = None
+if __name__ == "__main__":
+    from test import test_support as support
+    support.use_resources = ['gui']
+    from unittest import main
+    main('idlelib.idle_test.test_idlehistory', verbosity=2, exit=False)

python/trunk/Lib/idlelib/MultiCall.py

-              r2
+              r391
 import re
 import Tkinter
 import macosxSupport
+from idlelib import macosxSupport
 # the event type constants, which define the meaning of mc_type
 …
 # number of modifiers is the state - the most specific state comes first.
 _states = range(1 << len(_modifiers))
+_state_names = [reduce(lambda x, y: x + y,
+                       [_modifiers[i][0]+'-' for i in range(len(_modifiers))
+                        if (1 << i) & s],
+                       "")
+_state_names = [''.join(m[0]+'-'
+                        for i, m in enumerate(_modifiers)
+                        if (1 << i) & s)
                 for s in _states]
+_state_subsets = map(lambda i: filter(lambda j: not (j & (~i)), _states),
+                      _states)
+for l in _state_subsets:
+    l.sort(lambda a, b, nummod = lambda x: len(filter(lambda i: (1<<i) & x,
+                                                      range(len(_modifiers)))):
+           nummod(b) - nummod(a))
+def expand_substates(states):
+    '''For each item of states return a list containing all combinations of
+    that item with individual bits reset, sorted by the number of set bits.
+    '''
+    def nbits(n):
+        "number of bits set in n base 2"
+        nb = 0
+        while n:
+            n, rem = divmod(n, 2)
+            nb += rem
+        return nb
+    statelist = []
+    for state in states:
+        substates = list(set(state & x for x in states))
+        substates.sort(key=nbits, reverse=True)
+        statelist.append(substates)
+    return statelist
+_state_subsets = expand_substates(_states)
 # _state_codes gives for each state, the portable code to be passed as mc_state
+_state_codes = [reduce(lambda x, y: x | y,
+                       [_modifier_masks[i] for i in range(len(_modifiers))
+                        if (1 << i) & s],
+)
+                for s in _states]
+_state_codes = []
+for s in _states:
+    r = 0
+    for i in range(len(_modifiers)):
+        if (1 << i) & s:
+            r |= _modifier_masks[i]
+    _state_codes.append(r)
 class _ComplexBinder:
 …
             ishandlerrunning[:] = []
             # Call all functions in doafterhandler and remove them from list
+            while doafterhandler:
+                doafterhandler.pop()()
+            for f in doafterhandler:
+                f()
+            doafterhandler[:] = []
             if r:
                 return r
 …
     def bind(self, triplet, func):
         if not self.bindedfuncs.has_key(triplet[2]):
+        if triplet[2] not in self.bindedfuncs:
             self.bindedfuncs[triplet[2]] = [[] for s in _states]
             for s in _states:
 …
         def __init__(self, *args, **kwargs):
             apply(widget.__init__, (self,)+args, kwargs)
+            widget.__init__(self, *args, **kwargs)
             # a dictionary which maps a virtual event to a tuple with:
             #  0. the function binded

python/trunk/Lib/idlelib/MultiStatusBar.py

r2	r391
10	10
11	11	def set_label(self, name, text='', side=LEFT):
12		if n~~ot self.labels.has_key(name)~~:
	12	if name not in self.labels:
13	13	label = Label(self, bd=1, relief=SUNKEN, anchor=W)
14	14	label.pack(side=side)

python/trunk/Lib/idlelib/NEWS.txt

-              r2
+              r391
+What's New in Python 2.6.4rc1
+=============================
+*Release date: 07-Oct-2009*
+What's New in IDLE 2.7.5?
+=========================
+- Issue #17390: Display Python version on Idle title bar.
+  Initial patch by Edmond Burnett.
+What's New in IDLE 2.7.4?
+=========================
+- Issue #15318: Prevent writing to sys.stdin.
+- Issue #13532, #15319: Check that arguments to sys.stdout.write are strings.
+- Issue # 12510: Attempt to get certain tool tips no longer crashes IDLE.
+- Issue10365: File open dialog now works instead of crashing even when
+  parent window is closed while dialog is open.
+- Issue 14876: use user-selected font for highlight configuration.
+- Issue #14018: Update checks for unstable system Tcl/Tk versions on OS X
+  to include versions shipped with OS X 10.7 and 10.8 in addition to 10.6.
+- Issue #15853: Prevent IDLE crash on OS X when opening Preferences menu
+  with certain versions of Tk 8.5.  Initial patch by Kevin Walzer.
+What's New in IDLE 2.7.3?
+=========================
+- Issue #14409: IDLE now properly executes commands in the Shell window
+  when it cannot read the normal config files on startup and
+  has to use the built-in default key bindings.
+  There was previously a bug in one of the defaults.
+- Issue #3573: IDLE hangs when passing invalid command line args
+  (directory(ies) instead of file(s)).
+What's New in IDLE 2.7.2?
+=========================
+*Release date: 29-May-2011*
+- Issue #6378: Further adjust idle.bat to start associated Python
+- Issue #11896: Save on Close failed despite selecting "Yes" in dialog.
+- <Home> toggle failing on Tk 8.5, causing IDLE exits and strange selection
+  behavior. Issue 4676.  Improve selection extension behaviour.
+- <Home> toggle non-functional when NumLock set on Windows.  Issue 3851.
+What's New in IDLE 2.7?
+=======================
+*Release date: 07-03-2010*
+- idle.py modified and simplified to better support developing experimental
+  versions of IDLE which are not installed in the standard location.
 - OutputWindow/PyShell right click menu "Go to file/line" wasn't working with
   file paths containing spaces.  Bug 5559.
-What's New in Python 2.6.3
-==========================
-*Release date: 02-Oct-2009*
-What's New in IDLE 2.6.3rc1?
-============================
-*Release date: 28-Sep-2009*
-- On OS X IDLE 2.6 shows two Preference menu items.  Issue6951.
 - Windows: Version string for the .chm help file changed, file not being
   accessed  Patch 5783 Guilherme Polo
+- Allow multiple IDLE GUI/subprocess pairs to exist simultaneously. Thanks to
+  David Scherer for suggesting the use of an ephemeral port for the GUI.
+  Patch 1529142 Weeble.
+- Remove port spec from run.py and fix bug where subprocess fails to
+  extract port from command line when warnings are present.
 - Tk 8.5 Text widget requires 'wordprocessor' tabstyle attr to handle
   mixed space/tab properly. Issue 5129, patch by Guilherme Polo.
-What's New in IDLE 2.6.2rc1?
-============================
-*Release date: 06-Apr-2009*
 - Issue #3549: On MacOS the preferences menu was not present
 What's New in IDLE 2.6?
 …
   were Python source; improve use of ColorDelagator.  Patch 1334. Tal Einat.
 - ScriptBinding event handlers weren't returning 'break'. Patch 2050, Tal Einat
+- ScriptBinding event handlers weren't returning 'break'. Patch 2050, Tal Einat.
 - There was an error on exit if no sys.exitfunc was defined. Issue 1647.

python/trunk/Lib/idlelib/ObjectBrowser.py

-              r2
+              r391
 # - for classes/modules, add "open source" to object browser
 from TreeWidget import TreeItem, TreeNode, ScrolledCanvas
+from idlelib.TreeWidget import TreeItem, TreeNode, ScrolledCanvas
 from repr import Repr
 …
 def make_objecttreeitem(labeltext, object, setfunction=None):
     t = type(object)
     if dispatch.has_key(t):
+    if t in dispatch:
         c = dispatch[t]
     else:

python/trunk/Lib/idlelib/OutputWindow.py

-              r2
+              r391
 from Tkinter import *
 from EditorWindow import EditorWindow
+from idlelib.EditorWindow import EditorWindow
 import re
 import tkMessageBox
 import IOBinding
+from idlelib import IOBinding
 class OutputWindow(EditorWindow):
 …
         self.text.update()
+    def writelines(self, l):
+        map(self.write, l)
+    def writelines(self, lines):
+        for line in lines:
+            self.write(line)
     def flush(self):
 …
     rmenu_specs = [
+        ("Go to file/line", "<<goto-file-line>>"),
+        ("Cut", "<<cut>>", "rmenu_check_cut"),
+        ("Copy", "<<copy>>", "rmenu_check_copy"),
+        ("Paste", "<<paste>>", "rmenu_check_paste"),
+        (None, None, None),
+        ("Go to file/line", "<<goto-file-line>>", None),
+    ]

python/trunk/Lib/idlelib/ParenMatch.py

-              r2
+              r391
 """
 from HyperParser import HyperParser
 from configHandler import idleConf
+from idlelib.HyperParser import HyperParser
+from idlelib.configHandler import idleConf
 _openers = {')':'(',']':'[','}':'{'}

python/trunk/Lib/idlelib/PathBrowser.py

-              r2
+              r391
 import imp
 from TreeWidget import TreeItem
 from ClassBrowser import ClassBrowser, ModuleBrowserTreeItem
+from idlelib.TreeWidget import TreeItem
+from idlelib.ClassBrowser import ClassBrowser, ModuleBrowserTreeItem
 class PathBrowser(ClassBrowser):
 …
                 if normed_name[i:] == suff:
                     mod_name = name[:i]
                     if not modules.has_key(mod_name):
+                    if mod_name not in modules:
                         modules[mod_name] = None
                         sorted.append((normed_name, name))
 …
 def main():
     import PyShell
+    from idlelib import PyShell
     PathBrowser(PyShell.flist)
     if sys.stdin is sys.__stdin__:
 …
 if __name__ == "__main__":
+    main()
+    from unittest import main
+    main('idlelib.idle_test.test_pathbrowser', verbosity=2, exit=False)

python/trunk/Lib/idlelib/Percolator.py

r2	r391
1		from WidgetRedirector import WidgetRedirector
2		from Delegator import Delegator
	1	from idlelib.WidgetRedirector import WidgetRedirector
	2	from idlelib.Delegator import Delegator
3	3
4	4	class Percolator:

python/trunk/Lib/idlelib/PyShell.py

-              r2
+              r391
 import traceback
 import types
 import macosxSupport
+import io
 import linecache
 from code import InteractiveInterpreter
+from platform import python_version
 try:
 …
 import tkMessageBox
 from EditorWindow import EditorWindow, fixwordbreaks
 from FileList import FileList
 from ColorDelegator import ColorDelegator
 from UndoDelegator import UndoDelegator
 from OutputWindow import OutputWindow
 from configHandler import idleConf
 import idlever
+import rpc
 import Debugger
+import RemoteDebugger
+from idlelib.EditorWindow import EditorWindow, fixwordbreaks
+from idlelib.FileList import FileList
+from idlelib.ColorDelegator import ColorDelegator
+from idlelib.UndoDelegator import UndoDelegator
+from idlelib.OutputWindow import OutputWindow
+from idlelib.configHandler import idleConf
+from idlelib import idlever
+from idlelib import rpc
+from idlelib import Debugger
+from idlelib import RemoteDebugger
+from idlelib import macosxSupport
 IDENTCHARS = string.ascii_letters + string.digits + "_"
+LOCALHOST = '127.0.0.1'
+HOST = '127.0.0.1' # python execution server on localhost loopback
+PORT = 0  # someday pass in host, port for remote debug capability
 try:
 …
 # temporarily redirect the stream to the shell window to display warnings when
 # checking user's code.
+global warning_stream
+warning_stream = sys.__stderr__
+try:
+    import warnings
+except ImportError:
+    pass
+else:
+    def idle_showwarning(message, category, filename, lineno,
+                         file=None, line=None):
+warning_stream = sys.__stderr__  # None, at least on Windows, if no console.
+import warnings
+def idle_formatwarning(message, category, filename, lineno, line=None):
+    """Format warnings the IDLE way."""
+    s = "\nWarning (from warnings module):\n"
+    s += '  File \"%s\", line %s\n' % (filename, lineno)
+    if line is None:
+        line = linecache.getline(filename, lineno)
+    line = line.strip()
+    if line:
+        s += "    %s\n" % line
+    s += "%s: %s\n" % (category.__name__, message)
+    return s
+def idle_showwarning(
+        message, category, filename, lineno, file=None, line=None):
+    """Show Idle-format warning (after replacing warnings.showwarning).
+    The differences are the formatter called, the file=None replacement,
+    which can be None, the capture of the consequence AttributeError,
+    and the output of a hard-coded prompt.
+    """
+    if file is None:
         file = warning_stream
+        try:
+            file.write(warnings.formatwarning(message, category, filename,\
+                                              lineno, file=file, line=line))
+        except IOError:
+            pass  ## file (probably __stderr__) is invalid, warning dropped.
+    warnings.showwarning = idle_showwarning
+    def idle_formatwarning(message, category, filename, lineno,
+                           file=None, line=None):
+        """Format warnings the IDLE way"""
+        s = "\nWarning (from warnings module):\n"
+        s += '  File \"%s\", line %s\n' % (filename, lineno)
+        line = linecache.getline(filename, lineno).strip() \
+            if line is None else line
+        if line:
+            s += "    %s\n" % line
+        s += "%s: %s\n>>> " % (category.__name__, message)
+        return s
+    warnings.formatwarning = idle_formatwarning
+    try:
+        file.write(idle_formatwarning(
+                message, category, filename, lineno, line=line))
+        file.write(">>> ")
+    except (AttributeError, IOError):
+        pass  # if file (probably __stderr__) is invalid, skip warning.
+_warnings_showwarning = None
+def capture_warnings(capture):
+    "Replace warning.showwarning with idle_showwarning, or reverse."
+    global _warnings_showwarning
+    if capture:
+        if _warnings_showwarning is None:
+            _warnings_showwarning = warnings.showwarning
+            warnings.showwarning = idle_showwarning
+    else:
+        if _warnings_showwarning is not None:
+            warnings.showwarning = _warnings_showwarning
+            _warnings_showwarning = None
+capture_warnings(True)
 def extended_linecache_checkcache(filename=None,
 …
     Rather than repeating the linecache code, patch it to save the
     <pyshell#...> entries, call the original linecache.checkcache()
     (which destroys them), and then restore the saved entries.
+    (skipping them), and then restore the saved entries.
     orig_checkcache is bound at definition time to the original
     method, allowing it to be patched.
     """
     cache = linecache.cache
     save = {}
     for filename in cache.keys():
         if filename[:1] + filename[-1:] == '<>':
             save[filename] = cache[filename]
     orig_checkcache()
+    for key in list(cache):
+        if key[:1] + key[-1:] == '<>':
+            save[key] = cache.pop(key)
+    orig_checkcache(filename)
     cache.update(save)
 …
                                            'breakpoints.lst')
         # whenever a file is changed, restore breakpoints
-        if self.io.filename: self.restore_file_breaks()
         def filename_changed_hook(old_hook=self.io.filename_change_hook,
                                   self=self):
 …
             old_hook()
         self.io.set_filename_change_hook(filename_changed_hook)
+    rmenu_specs = [("Set Breakpoint", "<<set-breakpoint-here>>"),
+                   ("Clear Breakpoint", "<<clear-breakpoint-here>>")]
+        if self.io.filename:
+            self.restore_file_breaks()
+    rmenu_specs = [
+        ("Cut", "<<cut>>", "rmenu_check_cut"),
+        ("Copy", "<<copy>>", "rmenu_check_copy"),
+        ("Paste", "<<paste>>", "rmenu_check_paste"),
+        ("Set Breakpoint", "<<set-breakpoint-here>>", None),
+        ("Clear Breakpoint", "<<clear-breakpoint-here>>", None)
+    ]
     def set_breakpoint(self, lineno):
 …
         filename = self.io.filename
         try:
+            lines = open(self.breakpointPath,"r").readlines()
+            with open(self.breakpointPath,"r") as old_file:
+                lines = old_file.readlines()
         except IOError:
             lines = []
+        new_file = open(self.breakpointPath,"w")
+        for line in lines:
+            if not line.startswith(filename + '='):
+                new_file.write(line)
+        self.update_breakpoints()
+        breaks = self.breakpoints
+        if breaks:
+            new_file.write(filename + '=' + str(breaks) + '\n')
+        new_file.close()
+        try:
+            with open(self.breakpointPath,"w") as new_file:
+                for line in lines:
+                    if not line.startswith(filename + '='):
+                        new_file.write(line)
+                self.update_breakpoints()
+                breaks = self.breakpoints
+                if breaks:
+                    new_file.write(filename + '=' + str(breaks) + '\n')
+        except IOError as err:
+            if not getattr(self.root, "breakpoint_error_displayed", False):
+                self.root.breakpoint_error_displayed = True
+                tkMessageBox.showerror(title='IDLE Error',
+                    message='Unable to update breakpoint list:\n%s'
+                        % str(err),
+                    parent=self.text)
     def restore_file_breaks(self):
         self.text.update()   # this enables setting "BREAK" tags to be visible
+        if self.io is None:
+            # can happen if IDLE closes due to the .update() call
+            return
         filename = self.io.filename
         if filename is None:
 …
         lines = []
         for index in range(0, len(ranges), 2):
             lineno = int(float(ranges[index]))
             end = int(float(ranges[index+1]))
+            lineno = int(float(ranges[index].string))
+            end = int(float(ranges[index+1].string))
             while lineno < end:
                 lines.append(lineno)
 …
         })
+    def removecolors(self):
+        # Don't remove shell color tags before "iomark"
+        for tag in self.tagdefs:
+            self.tag_remove(tag, "iomark", "end")
 class ModifiedUndoDelegator(UndoDelegator):
     "Extend base class: forbid insert/delete before the I/O mark"
 …
         self.save_warnings_filters = None
         self.restarting = False
+        self.subprocess_arglist = self.build_subprocess_arglist()
+    port = 8833
+        self.subprocess_arglist = None
+        self.port = PORT
+        self.original_compiler_flags = self.compile.compiler.flags
+    _afterid = None
     rpcclt = None
     rpcpid = None
     def spawn_subprocess(self):
+        if self.subprocess_arglist is None:
+            self.subprocess_arglist = self.build_subprocess_arglist()
         args = self.subprocess_arglist
         self.rpcpid = os.spawnv(os.P_NOWAIT, sys.executable, args)
     def build_subprocess_arglist(self):
+        assert (self.port!=0), (
+            "Socket should have been assigned a port number.")
         w = ['-W' + s for s in sys.warnoptions]
         if 1/2 > 0: # account for new division
 …
     def start_subprocess(self):
+        # spawning first avoids passing a listening socket to the subprocess
+        self.spawn_subprocess()
+        #time.sleep(20) # test to simulate GUI not accepting connection
+        addr = (LOCALHOST, self.port)
+        # Idle starts listening for connection on localhost
+        addr = (HOST, self.port)
+        # GUI makes several attempts to acquire socket, listens for connection
         for i in range(3):
             time.sleep(i)
 …
                 self.rpcclt = MyRPCClient(addr)
                 break
             except socket.error, err:
+            except socket.error as err:
                 pass
         else:
             self.display_port_binding_error()
             return None
+        # if PORT was 0, system will assign an 'ephemeral' port. Find it out:
+        self.port = self.rpcclt.listening_sock.getsockname()[1]
+        # if PORT was not 0, probably working with a remote execution server
+        if PORT != 0:
+            # To allow reconnection within the 2MSL wait (cf. Stevens TCP
+            # V1, 18.6),  set SO_REUSEADDR.  Note that this can be problematic
+            # on Windows since the implementation allows two active sockets on
+            # the same address!
+            self.rpcclt.listening_sock.setsockopt(socket.SOL_SOCKET,
+                                           socket.SO_REUSEADDR, 1)
+        self.spawn_subprocess()
+        #time.sleep(20) # test to simulate GUI not accepting connection
         # Accept the connection from the Python execution server
         self.rpcclt.listening_sock.settimeout(10)
         try:
             self.rpcclt.accept()
         except socket.timeout, err:
+        except socket.timeout as err:
             self.display_no_subprocess_error()
             return None
+        self.rpcclt.register("stdin", self.tkconsole)
+        self.rpcclt.register("console", self.tkconsole)
+        self.rpcclt.register("stdin", self.tkconsole.stdin)
         self.rpcclt.register("stdout", self.tkconsole.stdout)
         self.rpcclt.register("stderr", self.tkconsole.stderr)
 …
         self.rpcclt.register("linecache", linecache)
         self.rpcclt.register("interp", self)
         self.transfer_path()
+        self.transfer_path(with_cwd=True)
         self.poll_subprocess()
         return self.rpcclt
     def restart_subprocess(self):
+    def restart_subprocess(self, with_cwd=False):
         if self.restarting:
             return self.rpcclt
 …
         try:
             self.rpcclt.accept()
         except socket.timeout, err:
+        except socket.timeout as err:
             self.display_no_subprocess_error()
             return None
+        self.transfer_path()
+        self.transfer_path(with_cwd=with_cwd)
+        console.stop_readline()
         # annotate restart in shell window and mark it
         console.text.delete("iomark", "end-1c")
 …
             # reload remote debugger breakpoints for all PyShellEditWindows
             debug.load_breakpoints()
+        self.compile.compiler.flags = self.original_compiler_flags
         self.restarting = False
         return self.rpcclt
 …
     def kill_subprocess(self):
+        if self._afterid is not None:
+            self.tkconsole.text.after_cancel(self._afterid)
         try:
             self.rpcclt.close()
 …
                     return
+    def transfer_path(self):
+    def transfer_path(self, with_cwd=False):
+        if with_cwd:        # Issue 13506
+            path = ['']     # include Current Working Directory
+            path.extend(sys.path)
+        else:
+            path = sys.path
         self.runcommand("""if 1:
         import sys as _sys
         _sys.path = %r
         del _sys
         \n""" % (sys.path,))
+        \n""" % (path,))
     active_seq = None
 …
         # Reschedule myself
         if not self.tkconsole.closing:
             self.tkconsole.text.after(self.tkconsole.pollinterval,
                                       self.poll_subprocess)
+            self._afterid = self.tkconsole.text.after(
+                self.tkconsole.pollinterval, self.poll_subprocess)
     debugger = None
 …
         method we allow the subprocess to unblock.  After a bit the shell
         requests the subprocess to open the remote stack viewer which returns a
         static object looking at the last exceptiopn.  It is queried through
+        static object looking at the last exception.  It is queried through
         the RPC mechanism.
 …
     def remote_stack_viewer(self):
         import RemoteObjectBrowser
+        from idlelib import RemoteObjectBrowser
         oid = self.rpcclt.remotequeue("exec", "stackviewer", ("flist",), {})
         if oid is None:
 …
             return
         item = RemoteObjectBrowser.StubObjectTreeItem(self.rpcclt, oid)
         from TreeWidget import ScrolledCanvas, TreeNode
+        from idlelib.TreeWidget import ScrolledCanvas, TreeNode
         top = Toplevel(self.tkconsole.root)
         theme = idleConf.GetOption('main','Theme','name')
 …
         warnings.filterwarnings(action="error", category=SyntaxWarning)
         if isinstance(source, types.UnicodeType):
             import IOBinding
+            from idlelib import IOBinding
             try:
                 source = source.encode(IOBinding.encoding)
 …
         tkMessageBox.showerror(
             "Port Binding Error",
+            "IDLE can't bind TCP/IP port 8833, which is necessary to "
+            "communicate with its Python execution server.  Either "
+            "no networking is installed on this computer or another "
+            "process (another IDLE?) is using the port.  Run IDLE with the -n "
+            "command line switch to start without a subprocess and refer to "
+            "Help/IDLE Help 'Running without a subprocess' for further "
+            "details.",
+            "IDLE can't bind to a TCP/IP port, which is necessary to "
+            "communicate with its Python execution server.  This might be "
+            "because no networking is installed on this computer.  "
+            "Run IDLE with the -n command line switch to start without a "
+            "subprocess and refer to Help/IDLE Help 'Running without a "
+            "subprocess' for further details.",
             master=self.tkconsole.text)
 …
 class PyShell(OutputWindow):
     shell_title = "Python Shell"
+    shell_title = "Python " + python_version() + " Shell"
     # Override classes
 …
     if macosxSupport.runningAsOSXApp():
-        del menu_specs[-3]
         menu_specs[-2] = ("windows", "_Window")
     # New classes
     from IdleHistory import History
+    from idlelib.IdleHistory import History
     def __init__(self, flist=None):
 …
         self.save_stderr = sys.stderr
         self.save_stdin = sys.stdin
+        import IOBinding
+        self.stdout = PseudoFile(self, "stdout", IOBinding.encoding)
+        self.stderr = PseudoFile(self, "stderr", IOBinding.encoding)
+        self.console = PseudoFile(self, "console", IOBinding.encoding)
+        from idlelib import IOBinding
+        self.stdin = PseudoInputFile(self, "stdin", IOBinding.encoding)
+        self.stdout = PseudoOutputFile(self, "stdout", IOBinding.encoding)
+        self.stderr = PseudoOutputFile(self, "stderr", IOBinding.encoding)
+        self.console = PseudoOutputFile(self, "console", IOBinding.encoding)
         if not use_subprocess:
             sys.stdout = self.stdout
             sys.stderr = self.stderr
             sys.stdin = self
+            sys.stdin = self.stdin
+        #
         self.history = self.History(self.text)
 …
     endoffile = False
     closing = False
+    _stop_readline_flag = False
     def set_warning_stream(self, stream):
 …
             if response is False:
                 return "cancel"
+        if self.reading:
+            self.top.quit()
+        self.stop_readline()
         self.canceled = True
         self.closing = True
-        # Wait for poll_subprocess() rescheduling to stop
-        self.text.after(2 * self.pollinterval, self.close2)
-    def close2(self):
         return EditorWindow.close(self)
 …
           'Type "copyright", "credits" or "license()" for more information.'
-    firewallmessage = """
-    ****************************************************************
-    Personal firewall software may warn about the connection IDLE
-    makes to its subprocess using this computer's internal loopback
-    interface.  This connection is not visible on any external
-    interface and no data is sent to or received from the Internet.
-    ****************************************************************
-    """
     def begin(self):
         self.resetoutput()
 …
         else:
             nosub = "==== No Subprocess ===="
+        self.write("Python %s on %s\n%s\n%s\nIDLE %s      %s\n" %
+                   (sys.version, sys.platform, self.COPYRIGHT,
+                    self.firewallmessage, idlever.IDLE_VERSION, nosub))
+        self.write("Python %s on %s\n%s\n%s" %
+                   (sys.version, sys.platform, self.COPYRIGHT, nosub))
         self.showprompt()
         import Tkinter
 …
         return True
+    def stop_readline(self):
+        if not self.reading:  # no nested mainloop to exit.
+            return
+        self._stop_readline_flag = True
+        self.top.quit()
     def readline(self):
         save = self.reading
 …
         finally:
             self.reading = save
+        if self._stop_readline_flag:
+            self._stop_readline_flag = False
+            return ""
         line = self.text.get("iomark", "end-1c")
         if len(line) == 0:  # may be EOF if we quit our mainloop with Ctrl-C
             line = "\n"
         if isinstance(line, unicode):
             import IOBinding
+            from idlelib import IOBinding
             try:
                 line = line.encode(IOBinding.encoding)
 …
                 master=self.text)
             return
         from StackViewer import StackBrowser
+        from idlelib.StackViewer import StackBrowser
         sv = StackBrowser(self.root, self.flist)
 …
     def restart_shell(self, event=None):
+        self.interp.restart_subprocess()
+        "Callback for Run/Restart Shell Cntl-F6"
+        self.interp.restart_subprocess(with_cwd=True)
     def showprompt(self):
 …
         source = self.text.get("iomark", "end-1c")
         if self.history:
             self.history.history_store(source)
+            self.history.store(source)
         if self.text.get("end-2c") != "\n":
             self.text.insert("end-1c", "\n")
 …
                 raise KeyboardInterrupt
+class PseudoFile(object):
+    def rmenu_check_cut(self):
+        try:
+            if self.text.compare('sel.first', '<', 'iomark'):
+                return 'disabled'
+        except TclError: # no selection, so the index 'sel.first' doesn't exist
+            return 'disabled'
+        return super(PyShell, self).rmenu_check_cut()
+    def rmenu_check_paste(self):
+        if self.text.compare('insert', '<', 'iomark'):
+            return 'disabled'
+        return super(PyShell, self).rmenu_check_paste()
+class PseudoFile(io.TextIOBase):
     def __init__(self, shell, tags, encoding=None):
 …
         self.tags = tags
         self.softspace = 0
+        self.encoding = encoding
+    def write(self, s):
+        self.shell.write(s, self.tags)
+    def writelines(self, l):
+        map(self.write, l)
+    def flush(self):
+        pass
+        self._encoding = encoding
+    @property
+    def encoding(self):
+        return self._encoding
+    @property
+    def name(self):
+        return '<%s>' % self.tags
     def isatty(self):
         return True
+class PseudoOutputFile(PseudoFile):
+    def writable(self):
+        return True
+    def write(self, s):
+        if self.closed:
+            raise ValueError("write to closed file")
+        if not isinstance(s, (basestring, bytearray)):
+            raise TypeError('must be string, not ' + type(s).__name__)
+        return self.shell.write(s, self.tags)
+class PseudoInputFile(PseudoFile):
+    def __init__(self, shell, tags, encoding=None):
+        PseudoFile.__init__(self, shell, tags, encoding)
+        self._line_buffer = ''
+    def readable(self):
+        return True
+    def read(self, size=-1):
+        if self.closed:
+            raise ValueError("read from closed file")
+        if size is None:
+            size = -1
+        elif not isinstance(size, int):
+            raise TypeError('must be int, not ' + type(size).__name__)
+        result = self._line_buffer
+        self._line_buffer = ''
+        if size < 0:
+            while True:
+                line = self.shell.readline()
+                if not line: break
+                result += line
+        else:
+            while len(result) < size:
+                line = self.shell.readline()
+                if not line: break
+                result += line
+            self._line_buffer = result[size:]
+            result = result[:size]
+        return result
+    def readline(self, size=-1):
+        if self.closed:
+            raise ValueError("read from closed file")
+        if size is None:
+            size = -1
+        elif not isinstance(size, int):
+            raise TypeError('must be int, not ' + type(size).__name__)
+        line = self._line_buffer or self.shell.readline()
+        if size < 0:
+            size = len(line)
+        self._line_buffer = line[size:]
+        return line[:size]
+    def close(self):
+        self.shell.close()
 …
     global flist, root, use_subprocess
+    capture_warnings(True)
     use_subprocess = True
     enable_shell = False
 …
     try:
         opts, args = getopt.getopt(sys.argv[1:], "c:deihnr:st:")
     except getopt.error, msg:
+    except getopt.error as msg:
         sys.stderr.write("Error: %s\n" % str(msg))
         sys.stderr.write(usage_msg)
 …
         for dir in pathx:
             dir = os.path.abspath(dir)
             if not dir in sys.path:
+            if dir not in sys.path:
                 sys.path.insert(0, dir)
     else:
 …
                                     'editor-on-startup', type='bool')
     enable_edit = enable_edit or edit_start
     enable_shell = enable_shell or not edit_start
+    enable_shell = enable_shell or not enable_edit
     # start editor and/or shell windows:
     root = Tk(className="Idle")
 …
     if enable_edit:
         if not (cmd or script):
+            for filename in args:
+                flist.open(filename)
+            for filename in args[:]:
+                if flist.open(filename) is None:
+                    # filename is a directory actually, disconsider it
+                    args.remove(filename)
             if not args:
                 flist.new()
 …
             shell.interp.execfile(script)
+    root.mainloop()
+    # Check for problematic OS X Tk versions and print a warning message
+    # in the IDLE shell window; this is less intrusive than always opening
+    # a separate window.
+    tkversionwarning = macosxSupport.tkVersionWarning(root)
+    if tkversionwarning:
+        shell.interp.runcommand(''.join(("print('", tkversionwarning, "')")))
+    while flist.inversedict:  # keep IDLE running while files are open.
+        root.mainloop()
     root.destroy()
+    capture_warnings(False)
 if __name__ == "__main__":
     sys.modules['PyShell'] = sys.modules['__main__']
     main()
+capture_warnings(False)  # Make sure turned off; see issue 18081

python/trunk/Lib/idlelib/RemoteDebugger.py

-              r2
+              r391
 import types
 import rpc
 import Debugger
+from idlelib import rpc
+from idlelib import Debugger
 debugging = 0
 …
     def _get_dict_proxy(self, did):
         if self._dictcache.has_key(did):
+        if did in self._dictcache:
             return self._dictcache[did]
         dp = DictProxy(self._conn, self._oid, did)

python/trunk/Lib/idlelib/RemoteObjectBrowser.py

r2	r391
1		import rpc
	1	from idlelib import rpc
2	2
3	3	def remote_object_tree_item(item):

python/trunk/Lib/idlelib/ReplaceDialog.py

-              r2
+              r391
 from Tkinter import *
+import SearchEngine
+from SearchDialogBase import SearchDialogBase
+from idlelib import SearchEngine
+from idlelib.SearchDialogBase import SearchDialogBase
+import re
 def replace(text):
 …
     dialog = engine._replacedialog
     dialog.open(text)
 class ReplaceDialog(SearchDialogBase):
 …
     def default_command(self, event=None):
         if self.do_find(self.ok):
+            self.do_replace()
+            self.do_find(0)
+            if self.do_replace():   # Only find next match if replace succeeded.
+                                    # A bad re can cause a it to fail.
+                self.do_find(0)
+    def _replace_expand(self, m, repl):
+        """ Helper function for expanding a regular expression
+            in the replace field, if needed. """
+        if self.engine.isre():
+            try:
+                new = m.expand(repl)
+            except re.error:
+                self.engine.report_error(repl, 'Invalid Replace Expression')
+                new = None
+        else:
+            new = repl
+        return new
     def replace_all(self, event=None):
 …
             chars = text.get("%d.0" % line, "%d.0" % (line+1))
             orig = m.group()
+            new = m.expand(repl)
+            new = self._replace_expand(m, repl)
+            if new is None:
+                break
             i, j = m.span()
             first = "%d.%d" % (line, i)
 …
         if not prog:
             return False
+        new = m.expand(self.replvar.get())
+        new = self._replace_expand(m, self.replvar.get())
+        if new is None:
+            return False
         text.mark_set("insert", first)
         text.undo_block_start()

python/trunk/Lib/idlelib/ScriptBinding.py

-              r2
+              r391
 import tokenize
 import tkMessageBox
+import PyShell
+from configHandler import idleConf
+from idlelib import PyShell
+from idlelib.configHandler import idleConf
+from idlelib import macosxSupport
 IDENTCHARS = string.ascii_letters + string.digits + "_"
 …
         self.root = self.editwin.root
+        if macosxSupport.runningAsOSXApp():
+            self.editwin.text_frame.bind('<<run-module-event-2>>', self._run_module_event)
     def check_module_event(self, event):
         filename = self.getfilename()
 …
         try:
             tabnanny.process_tokens(tokenize.generate_tokens(f.readline))
         except tokenize.TokenError, msg:
+        except tokenize.TokenError as msg:
             msgtxt, (lineno, start) = msg
             self.editwin.gotoline(lineno)
 …
                           "Token Error: %s" % msgtxt)
             return False
         except tabnanny.NannyNag, nag:
+        except tabnanny.NannyNag as nag:
             # The error messages from tabnanny are too confusing...
             self.editwin.gotoline(nag.get_lineno())
 …
         saved_stream = shell.get_warning_stream()
         shell.set_warning_stream(shell.stderr)
+        f = open(filename, 'r')
+        source = f.read()
+        f.close()
+        with open(filename, 'r') as f:
+            source = f.read()
         if '\r' in source:
             source = re.sub(r"\r\n", "\n", source)
 …
                 # If successful, return the compiled code
                 return compile(source, filename, "exec")
             except (SyntaxError, OverflowError), err:
+            except (SyntaxError, OverflowError, ValueError) as err:
                 try:
                     msg, (errorfilename, lineno, offset, line) = err
 …
         if not self.tabnanny(filename):
             return 'break'
+        shell = self.shell
+        interp = shell.interp
+        interp = self.shell.interp
         if PyShell.use_subprocess:
             shell.restart_shell()
+            interp.restart_subprocess(with_cwd=False)
         dirname = os.path.dirname(filename)
         # XXX Too often this discards arguments the user just set...
         interp.runcommand("""if 1:
             _filename = %r
+            __file__ = {filename!r}
             import sys as _sys
             from os.path import basename as _basename
             if (not _sys.argv or
                 _basename(_sys.argv[0]) != _basename(_filename)):
                 _sys.argv = [_filename]
+                _basename(_sys.argv[0]) != _basename(__file__)):
+                _sys.argv = [__file__]
             import os as _os
             _os.chdir(%r)
             del _filename, _sys, _basename, _os
             \n""" % (filename, dirname))
+            _os.chdir({dirname!r})
+            del _sys, _basename, _os
+            \n""".format(filename=filename, dirname=dirname))
         interp.prepend_syspath(filename)
         # XXX KBK 03Jul04 When run w/o subprocess, runtime warnings still
 …
         interp.runcode(code)
         return 'break'
+    if macosxSupport.runningAsOSXApp():
+        # Tk-Cocoa in MacOSX is broken until at least
+        # Tk 8.5.9, and without this rather
+        # crude workaround IDLE would hang when a user
+        # tries to run a module using the keyboard shortcut
+        # (the menu item works fine).
+        _run_module_event = run_module_event
+        def run_module_event(self, event):
+            self.editwin.text_frame.after(200,
+                lambda: self.editwin.text_frame.event_generate('<<run-module-event-2>>'))
+            return 'break'
     def getfilename(self):
 …
                 self.editwin.io.save(None)
             else:
                 reply = self.ask_save_dialog()
+                confirm = self.ask_save_dialog()
                 self.editwin.text.focus_set()
                 if reply == "ok":
+                if confirm:
                     self.editwin.io.save(None)
                     filename = self.editwin.io.filename
 …
     def ask_save_dialog(self):
         msg = "Source Must Be Saved\n" + 5*' ' + "OK to Save?"
+        mb = tkMessageBox.Message(title="Save Before Run or Check",
+                                  message=msg,
+                                  icon=tkMessageBox.QUESTION,
+                                  type=tkMessageBox.OKCANCEL,
+                                  default=tkMessageBox.OK,
+                                  master=self.editwin.text)
+        return mb.show()
+        confirm = tkMessageBox.askokcancel(title="Save Before Run or Check",
+                                           message=msg,
+                                           default=tkMessageBox.OK,
+                                           master=self.editwin.text)
+        return confirm
     def errorbox(self, title, message):

python/trunk/Lib/idlelib/SearchDialog.py

-              r2
+              r391
 from Tkinter import *
-import SearchEngine
-from SearchDialogBase import SearchDialogBase
+from idlelib import SearchEngine
+from idlelib.SearchDialogBase import SearchDialogBase
 def _setup(text):
 …
     def create_widgets(self):
         f = SearchDialogBase.create_widgets(self)
         self.make_button("Find", self.default_command, 1)
+        self.make_button("Find Next", self.default_command, 1)
     def default_command(self, event=None):
         if not self.engine.getprog():
             return
+        if self.find_again(self.text):
+            self.close()
+        self.find_again(self.text)
     def find_again(self, text):

python/trunk/Lib/idlelib/SearchDialogBase.py

-              r2
+              r391
+'''Define SearchDialogBase used by Search, Replace, and Grep dialogs.'''
 from Tkinter import *
 class SearchDialogBase:
+    '''Create most of a modal search dialog (make_frame, create_widgets).
+    The wide left column contains:
+or 2 text entry lines (create_entries, make_entry);
+    a row of standard radiobuttons (create_option_buttons);
+    a row of dialog specific radiobuttons (create_other_buttons).
+    The narrow right column contains command buttons
+    (create_command_buttons, make_button).
+    These are bound to functions that execute the command.
+    Except for command buttons, this base class is not limited to
+    items common to all three subclasses.  Rather, it is the Find dialog
+    minus the "Find Next" command and its execution function.
+    The other dialogs override methods to replace and add widgets.
+    '''
     title = "Search Dialog"

python/trunk/Lib/idlelib/SearchEngine.py

-              r2
+              r391
+'''Define SearchEngine for search dialogs.'''
 import re
 from Tkinter import *
+from Tkinter import StringVar, BooleanVar, TclError
 import tkMessageBox
 def get(root):
+    '''Return the singleton SearchEngine instance for the process.
+    The single SearchEngine saves settings between dialog instances.
+    If there is not a SearchEngine already, make one.
+    '''
     if not hasattr(root, "_searchengine"):
         root._searchengine = SearchEngine(root)
         # XXX This will never garbage-collect -- who cares
+        # This creates a cycle that persists until root is deleted.
     return root._searchengine
 class SearchEngine:
+    """Handles searching a text widget for Find, Replace, and Grep."""
     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?
+        '''Initialize Variables that save search state.
+        The dialogs bind these to the UI elements present in the dialogs.
+        '''
+        self.root = root  # need for report_error()
+        self.patvar = StringVar(root, '')   # search pattern
+        self.revar = BooleanVar(root, False)   # regular expression?
+        self.casevar = BooleanVar(root, False)   # match case?
+        self.wordvar = BooleanVar(root, False)   # match whole word?
+        self.wrapvar = BooleanVar(root, True)   # wrap around buffer?
+        self.backvar = BooleanVar(root, False)   # search backwards?
     # Access methods
 …
     # Higher level access methods
+    def setcookedpat(self, pat):
+        "Set pattern after escaping if re."
+        # called only in SearchDialog.py: 66
+        if self.isre():
+            pat = re.escape(pat)
+        self.setpat(pat)
     def getcookedpat(self):
         pat = self.getpat()
         if not self.isre():
+        if not self.isre():  # if True, see setcookedpat
             pat = re.escape(pat)
         if self.isword():
 …
     def getprog(self):
+        "Return compiled cooked search pattern."
         pat = self.getpat()
         if not pat:
 …
         try:
             prog = re.compile(pat, flags)
         except re.error, what:
+        except re.error as what:
             try:
                 msg, col = what
 …
     def report_error(self, pat, msg, col=-1):
         # Derived class could overrid this with something fancier
+        # Derived class could override this with something fancier
         msg = "Error: " + str(msg)
         if pat:
             msg = msg + "\np\Pattern: " + str(pat)
+            msg = msg + "\nPattern: " + str(pat)
         if col >= 0:
             msg = msg + "\nOffset: " + str(col)
 …
                                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.
+        """
+        '''Return (lineno, matchobj) or None for forward/backward search.
+        This function calls the right function with the right arguments.
+        It directly return the result of that call.
+        Text is a text widget. Prog is a precompiled pattern.
+        The ok parameteris a bit complicated as it has two effects.
+        If there is a selection, the search begin at either end,
+        depending on the direction setting and ok, with ok meaning that
+        the search starts with the selection. Otherwise, search begins
+        at the insert mark.
+        To aid progress, the search functions do not return an empty
+        match at the starting position unless ok is True.
+        '''
         if not prog:
             prog = self.getprog()
 …
         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):
+    '''Search backwards and return an re match object or None.
+    This is done by searching forwards until there is no match.
+    Prog: compiled re object with a search method returning a match.
+    Chars: line of text, without \n.
+    Col: stop index for the search; the limit for match.end().
+    '''
     m = prog.search(chars)
     if not m:
         return None
     found = None
     i, j = m.span()
+    i, j = m.span()  # m.start(), m.end() == match slice indexes
     while i < col and j <= col:
         found = m
 …
     return found
-# Helper to get selection end points, defaulting to insert mark.
-# Return a tuple of indices ("line.col" strings).
 def get_selection(text):
+    '''Return tuple of 'line.col' indexes from selection or insert mark.
+    '''
     try:
         first = text.index("sel.first")
 …
     return first, last
-# Helper to parse a text index into a (line, col) tuple.
 def get_line_col(index):
+    '''Return (line, col) tuple of ints from 'line.col' string.'''
     line, col = map(int, index.split(".")) # Fails on invalid index
     return line, col
+if __name__ == "__main__":
+    from test import support; support.use_resources = ['gui']
+    import unittest
+    unittest.main('idlelib.idle_test.test_searchengine', verbosity=2, exit=False)

python/trunk/Lib/idlelib/StackViewer.py

-              r2
+              r391
 import linecache
 from TreeWidget import TreeNode, TreeItem, ScrolledCanvas
 from ObjectBrowser import ObjectTreeItem, make_objecttreeitem
+from idlelib.TreeWidget import TreeNode, TreeItem, ScrolledCanvas
+from idlelib.ObjectBrowser import ObjectTreeItem, make_objecttreeitem
 def StackBrowser(root, flist=None, tb=None, top=None):

python/trunk/Lib/idlelib/TreeWidget.py

-              r2
+              r391
 import imp
 import ZoomHeight
 from configHandler import idleConf
+from idlelib import ZoomHeight
+from idlelib.configHandler import idleConf
 ICONDIR = "Icons"
 …
         except os.error:
             return []
         names.sort(lambda a, b: cmp(os.path.normcase(a), os.path.normcase(b)))
+        names.sort(key = os.path.normcase)
         sublist = []
         for name in names:
 …
 class ScrolledCanvas:
     def __init__(self, master, **opts):
         if not opts.has_key('yscrollincrement'):
+        if 'yscrollincrement' not in opts:
             opts['yscrollincrement'] = 17
         self.master = master
 …
 def test():
     import PyShell
+    from idlelib import PyShell
     root = Toplevel(PyShell.root)
     root.configure(bd=0, bg="yellow")

python/trunk/Lib/idlelib/UndoDelegator.py

-              r2
+              r391
 import string
 from Tkinter import *
+from Delegator import Delegator
+from idlelib.Delegator import Delegator
 #$ event <<redo>>
 …
 def main():
     from Percolator import Percolator
+    from idlelib.Percolator import Percolator
     root = Tk()
     root.wm_protocol("WM_DELETE_WINDOW", root.quit)

python/trunk/Lib/idlelib/ZoomHeight.py

-              r2
+              r391
 import re
 import sys
+import macosxSupport
+from idlelib import macosxSupport
 class ZoomHeight:

python/trunk/Lib/idlelib/aboutDialog.py

-              r2
+              r391
 from Tkinter import *
 import os
+import os.path
 import textView
 import idlever
+from idlelib import textView
+from idlelib import idlever
 class AboutDialog(Toplevel):
 …
                                sys.version.split()[0], fg=self.fg, bg=self.bg)
         labelPythonVer.grid(row=9, column=0, sticky=W, padx=10, pady=0)
+        # handle weird tk version num in windoze python >= 1.6 (?!?)
+        tkVer = repr(TkVersion).split('.')
+        tkVer[len(tkVer)-1] = str('%.3g' % (float('.'+tkVer[len(tkVer)-1])))[2:]
+        if tkVer[len(tkVer)-1] == '':
+            tkVer[len(tkVer)-1] = '0'
+        tkVer = '.'.join(tkVer)
+        tkVer = self.tk.call('info', 'patchlevel')
         labelTkVer = Label(frameBg, text='Tk version:  '+
                            tkVer, fg=self.fg, bg=self.bg)
 …
     root = Tk()
     def run():
         import aboutDialog
+        from idlelib import aboutDialog
         aboutDialog.AboutDialog(root, 'About')
     Button(root, text='Dialog', command=run).pack()

python/trunk/Lib/idlelib/config-extensions.def

-              r2
+              r391
 [ScriptBinding]
 enable=1
+enable_shell=0
+enable_editor=1
 [ScriptBinding_cfgBindings]
 run-module=<Key-F5>
 …
 [CodeContext_bindings]
 toggle-code-context=
+[RstripExtension]
+enable=1
+enable_shell=0
+enable_editor=1

python/trunk/Lib/idlelib/config-keys.def

-              r2
+              r391
 close-window = <Command-Key-w>
 restart-shell = <Control-Key-F6>
 save-window-as-file = <Command-Key-S>
+save-window-as-file = <Shift-Command-Key-S>
 close-all-windows = <Command-Key-q>
 view-restart = <Key-F6>
 …
 find-selection = <Shift-Command-Key-F3>
 python-context-help = <Shift-Key-F1>
 save-copy-of-window-as-file = <Shift-Command-Key-s>
+save-copy-of-window-as-file = <Option-Command-Key-s>
 open-window-from-file = <Command-Key-o>
 python-docs = <Key-F1>

python/trunk/Lib/idlelib/configDialog.py

-              r2
+              r391
 import string
 from configHandler import idleConf
 from dynOptionMenuWidget import DynOptionMenu
 from tabbedpages import TabbedPageSet
 from keybindingDialog import GetKeysDialog
 from configSectionNameDialog import GetCfgSectionNameDialog
 from configHelpSourceEdit import GetHelpSourceDialog
 import macosxSupport
+from idlelib.configHandler import idleConf
+from idlelib.dynOptionMenuWidget import DynOptionMenu
+from idlelib.tabbedpages import TabbedPageSet
+from idlelib.keybindingDialog import GetKeysDialog
+from idlelib.configSectionNameDialog import GetCfgSectionNameDialog
+from idlelib.configHelpSourceEdit import GetHelpSourceDialog
+from idlelib import macosxSupport
 class ConfigDialog(Toplevel):
 …
         self.configure(borderwidth=5)
+        self.title('IDLE Preferences')
         self.geometry("+%d+%d" % (parent.winfo_rootx()+20,
                 parent.winfo_rooty()+30))
 …
         #frameCustom
         self.textHighlightSample=Text(frameCustom,relief=SOLID,borderwidth=1,
             font=('courier',12,''),cursor='hand2',width=21,height=10,
+            font=('courier',12,''),cursor='hand2',width=21,height=11,
             takefocus=FALSE,highlightthickness=0,wrap=NONE)
         text=self.textHighlightSample
 …
     def AddChangedItem(self,type,section,item,value):
         value=str(value) #make sure we use a string
         if not self.changedItems[type].has_key(section):
+        if section not in self.changedItems[type]:
             self.changedItems[type][section]={}
         self.changedItems[type][section][item]=value
 …
         #remove key set from config
         idleConf.userCfg['keys'].remove_section(keySetName)
         if self.changedItems['keys'].has_key(keySetName):
+        if keySetName in self.changedItems['keys']:
             del(self.changedItems['keys'][keySetName])
         #write changes
 …
         #remove theme from config
         idleConf.userCfg['highlight'].remove_section(themeName)
         if self.changedItems['highlight'].has_key(themeName):
+        if themeName in self.changedItems['highlight']:
             del(self.changedItems['highlight'][themeName])
         #write changes
 …
         else:
             fontWeight=tkFont.NORMAL
+        self.editFont.config(size=self.fontSize.get(),
+                weight=fontWeight,family=fontName)
+        newFont = (fontName, self.fontSize.get(), fontWeight)
+        self.labelFontSample.config(font=newFont)
+        self.textHighlightSample.configure(font=newFont)
     def SetHighlightTarget(self):
 …
             if theme in self.changedItems['highlight'].keys():
                 themeDict=self.changedItems['highlight'][theme]
                 if themeDict.has_key(element+'-foreground'):
+                if element+'-foreground' in themeDict:
                     colours['foreground']=themeDict[element+'-foreground']
                 if themeDict.has_key(element+'-background'):
+                if element+'-background' in themeDict:
                     colours['background']=themeDict[element+'-background']
             self.textHighlightSample.tag_config(element, **colours)
 …
         ##font size dropdown
         fontSize=idleConf.GetOption('main','EditorWindow','font-size',
                 default='10')
+                type='int', default='10')
         self.optMenuFontSize.SetMenu(('7','8','9','10','11','12','13','14',
                 '16','18','20','22'),fontSize )
 …
         ##load theme element option menu
         themeNames=self.themeElements.keys()
         themeNames.sort(self.__ThemeNameIndexCompare)
+        themeNames.sort(key=lambda x: self.themeElements[x][1])
         self.optMenuHighlightTarget.SetMenu(themeNames,themeNames[0])
         self.PaintThemeSample()
         self.SetHighlightTarget()
-    def __ThemeNameIndexCompare(self,a,b):
-        if self.themeElements[a][1]<self.themeElements[b][1]: return -1
-        elif self.themeElements[a][1]==self.themeElements[b][1]: return 0
-        else: return 1
     def LoadKeyCfg(self):
 …
                                              default=0, type='bool'))
         #initial window size
+        self.winWidth.set(idleConf.GetOption('main','EditorWindow','width'))
+        self.winHeight.set(idleConf.GetOption('main','EditorWindow','height'))
+        self.winWidth.set(idleConf.GetOption('main','EditorWindow','width',
+                                             type='int'))
+        self.winHeight.set(idleConf.GetOption('main','EditorWindow','height',
+                                              type='int'))
         #initial paragraph reformat size
+        self.paraWidth.set(idleConf.GetOption('main','FormatParagraph','paragraph'))
+        self.paraWidth.set(idleConf.GetOption('main','FormatParagraph','paragraph',
+                                              type='int'))
         # default source encoding
         self.encoding.set(idleConf.GetOption('main', 'EditorWindow',

python/trunk/Lib/idlelib/configHandler.py

-              r2
+              r391
 import sys
 import string
 import macosxSupport
+from idlelib import macosxSupport
 from ConfigParser import ConfigParser, NoOptionError, NoSectionError
 …
         """
+        if self.userCfg[configType].has_option(section,option):
+            return self.userCfg[configType].Get(section, option,
+                                                type=type, raw=raw)
+        elif self.defaultCfg[configType].has_option(section,option):
+            return self.defaultCfg[configType].Get(section, option,
+                                                   type=type, raw=raw)
+        else: #returning default, print warning
+            if warn_on_default:
+                warning = ('\n Warning: configHandler.py - IdleConf.GetOption -\n'
+                           ' problem retrieving configration option %r\n'
+                           ' from section %r.\n'
+                           ' returning default value: %r\n' %
+                           (option, section, default))
+                try:
+                    sys.stderr.write(warning)
+                except IOError:
+                    pass
+            return default
+        try:
+            if self.userCfg[configType].has_option(section,option):
+                return self.userCfg[configType].Get(section, option,
+                                                    type=type, raw=raw)
+        except ValueError:
+            warning = ('\n Warning: configHandler.py - IdleConf.GetOption -\n'
+                       ' invalid %r value for configuration option %r\n'
+                       ' from section %r: %r\n' %
+                       (type, option, section,
+                        self.userCfg[configType].Get(section, option,
+                                                     raw=raw)))
+            try:
+                sys.stderr.write(warning)
+            except IOError:
+                pass
+        try:
+            if self.defaultCfg[configType].has_option(section,option):
+                return self.defaultCfg[configType].Get(section, option,
+                                                       type=type, raw=raw)
+        except ValueError:
+            pass
+        #returning default, print warning
+        if warn_on_default:
+            warning = ('\n Warning: configHandler.py - IdleConf.GetOption -\n'
+                       ' problem retrieving configuration option %r\n'
+                       ' from section %r.\n'
+                       ' returning default value: %r\n' %
+                       (option, section, default))
+            try:
+                sys.stderr.write(warning)
+            except IOError:
+                pass
+        return default
     def SetOption(self, configType, section, option, value):
 …
             '<<goto-line>>': ['<Alt-g>'],
             '<<smart-backspace>>': ['<Key-BackSpace>'],
             '<<newline-and-indent>>': ['<Key-Return> <Key-KP_Enter>'],
+            '<<newline-and-indent>>': ['<Key-Return>', '<Key-KP_Enter>'],
             '<<smart-indent>>': ['<Key-Tab>'],
             '<<indent-region>>': ['<Control-Key-bracketright>'],
 …
             if menuItem and helpPath: #neither are empty strings
                 helpSources.append( (menuItem,helpPath,option) )
         helpSources.sort(self.__helpsort)
+        helpSources.sort(key=lambda x: int(x[2]))
         return helpSources
-    def __helpsort(self, h1, h2):
-        if int(h1[2]) < int(h2[2]):
-            return -1
-        elif int(h1[2]) > int(h2[2]):
-            return 1
-        else:
-            return 0
     def GetAllExtraHelpSourcesList(self):

python/trunk/Lib/idlelib/configSectionNameDialog.py

-              r2
+              r391
 Dialog that allows user to specify a new config file section name.
 Used to get new highlight theme and keybinding set names.
+The 'return value' for the dialog, used two placed in configDialog.py,
+is the .result attribute set in the Ok and Cancel methods.
 """
 from Tkinter import *
 import tkMessageBox
 class GetCfgSectionNameDialog(Toplevel):
     def __init__(self,parent,title,message,usedNames):
+    def __init__(self, parent, title, message, used_names):
         """
         message - string, informational message to display
         usedNames - list, list of names already in use for validity check
+        used_names - string collection, names already in use for validity check
         """
         Toplevel.__init__(self, parent)
         self.configure(borderwidth=5)
         self.resizable(height=FALSE,width=FALSE)
+        self.resizable(height=FALSE, width=FALSE)
         self.title(title)
         self.transient(parent)
 …
         self.protocol("WM_DELETE_WINDOW", self.Cancel)
         self.parent = parent
+        self.message=message
+        self.usedNames=usedNames
+        self.result=''
+        self.CreateWidgets()
+        self.withdraw() #hide while setting geometry
+        self.message = message
+        self.used_names = used_names
+        self.create_widgets()
+        self.withdraw()  #hide while setting geometry
         self.update_idletasks()
         #needs to be done here so that the winfo_reqwidth is valid
         self.messageInfo.config(width=self.frameMain.winfo_reqwidth())
+        self.geometry("+%d+%d" %
+            ((parent.winfo_rootx()+((parent.winfo_width()/2)
+                -(self.winfo_reqwidth()/2)),
+              parent.winfo_rooty()+((parent.winfo_height()/2)
+                -(self.winfo_reqheight()/2)) )) ) #centre dialog over parent
+        self.deiconify() #geometry set, unhide
+        self.geometry(
+                "+%d+%d" % (
+                parent.winfo_rootx() +
+                (parent.winfo_width()/2 - self.winfo_reqwidth()/2),
+                parent.winfo_rooty() +
+                (parent.winfo_height()/2 - self.winfo_reqheight()/2)
+                ) )  #centre dialog over parent
+        self.deiconify()  #geometry set, unhide
         self.wait_window()
+    def create_widgets(self):
+        self.name = StringVar(self.parent)
+        self.fontSize = StringVar(self.parent)
+        self.frameMain = Frame(self, borderwidth=2, relief=SUNKEN)
+        self.frameMain.pack(side=TOP, expand=TRUE, fill=BOTH)
+        self.messageInfo = Message(self.frameMain, anchor=W, justify=LEFT,
+                    padx=5, pady=5, text=self.message) #,aspect=200)
+        entryName = Entry(self.frameMain, textvariable=self.name, width=30)
+        entryName.focus_set()
+        self.messageInfo.pack(padx=5, pady=5) #, expand=TRUE, fill=BOTH)
+        entryName.pack(padx=5, pady=5)
+        frameButtons = Frame(self, pady=2)
+        frameButtons.pack(side=BOTTOM)
+        self.buttonOk = Button(frameButtons, text='Ok',
+                width=8, command=self.Ok)
+        self.buttonOk.pack(side=LEFT, padx=5)
+        self.buttonCancel = Button(frameButtons, text='Cancel',
+                width=8, command=self.Cancel)
+        self.buttonCancel.pack(side=RIGHT, padx=5)
+    def CreateWidgets(self):
+        self.name=StringVar(self)
+        self.fontSize=StringVar(self)
+        self.frameMain = Frame(self,borderwidth=2,relief=SUNKEN)
+        self.frameMain.pack(side=TOP,expand=TRUE,fill=BOTH)
+        self.messageInfo=Message(self.frameMain,anchor=W,justify=LEFT,padx=5,pady=5,
+                text=self.message)#,aspect=200)
+        entryName=Entry(self.frameMain,textvariable=self.name,width=30)
+        entryName.focus_set()
+        self.messageInfo.pack(padx=5,pady=5)#,expand=TRUE,fill=BOTH)
+        entryName.pack(padx=5,pady=5)
+        frameButtons=Frame(self)
+        frameButtons.pack(side=BOTTOM,fill=X)
+        self.buttonOk = Button(frameButtons,text='Ok',
+                width=8,command=self.Ok)
+        self.buttonOk.grid(row=0,column=0,padx=5,pady=5)
+        self.buttonCancel = Button(frameButtons,text='Cancel',
+                width=8,command=self.Cancel)
+        self.buttonCancel.grid(row=0,column=1,padx=5,pady=5)
+    def NameOk(self):
+        #simple validity check for a sensible
+        #ConfigParser file section name
+        nameOk=1
+        name=self.name.get()
+        name.strip()
+    def name_ok(self):
+        ''' After stripping entered name, check that it is a  sensible
+        ConfigParser file section name. Return it if it is, '' if not.
+        '''
+        name = self.name.get().strip()
         if not name: #no name specified
             tkMessageBox.showerror(title='Name Error',
                     message='No name specified.', parent=self)
-            nameOk=0
         elif len(name)>30: #name too long
             tkMessageBox.showerror(title='Name Error',
                     message='Name too long. It should be no more than '+
                     '30 characters.', parent=self)
             nameOk=0
         elif name in self.usedNames:
+            name = ''
+        elif name in self.used_names:
             tkMessageBox.showerror(title='Name Error',
                     message='This name is already in use.', parent=self)
+            nameOk=0
+        return nameOk
+            name = ''
+        return name
+    def Ok(self, event=None):
+        name = self.name_ok()
+        if name:
+            self.result = name
+            self.destroy()
+    def Cancel(self, event=None):
+        self.result = ''
+        self.destroy()
+if __name__ == '__main__':
+    import unittest
+    unittest.main('idlelib.idle_test.test_config_name', verbosity=2, exit=False)
+    def Ok(self, event=None):
+        if self.NameOk():
+            self.result=self.name.get().strip()
+            self.destroy()
+    def Cancel(self, event=None):
+        self.result=''
+        self.destroy()
+if __name__ == '__main__':
+    #test the dialog
+    root=Tk()
+    # also human test the dialog
+    root = Tk()
     def run():
-        keySeq=''
         dlg=GetCfgSectionNameDialog(root,'Get Name',
+                'The information here should need to be word wrapped. Test.')
+                "After the text entered with [Ok] is stripped, <nothing>, "
+                "'abc', or more that 30 chars are errors. "
+                "Close with a valid entry (printed), [Cancel], or [X]",
+                {'abc'})
         print dlg.result
+    Button(root,text='Dialog',command=run).pack()
+    Message(root, text='').pack()  # will be needed for oher dialog tests
+    Button(root, text='Click to begin dialog test', command=run).pack()
     root.mainloop()

python/trunk/Lib/idlelib/extend.txt

-              r2
+              r391
 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
+about this argument, but it is guaranteed to have the following instance
 variables:
 …
 case there must be empty bindings in cofig-extensions.def)
 Here is a complete example example:
+Here is a complete example:
 class ZoomHeight:
 …
 The final piece of the puzzle is the file "config-extensions.def", which is
 used to to configure the loading of extensions and to establish key (or, more
+used to configure the loading of extensions and to establish key (or, more
 generally, event) bindings to the virtual events defined in the extensions.

python/trunk/Lib/idlelib/help.txt

-              r2
+              r391
 File Menu:
         New Window       -- Create a new editing window
+        New File         -- Create a new editing window
         Open...          -- Open an existing file
         Recent Files...  -- Open a list of recent files
 …
         Go to File/Line   -- look around the insert point for a filename
                              and linenumber, open the file, and show the line
+                             and line number, open the file, and show the line
         Debugger (toggle) -- Run commands in the shell under the debugger
         Stack Viewer      -- Show the stack traceback of the last exception
 …
                           Sources can be specified.
                           On MacOS X this menu is not present, use
+                          On OS X this menu is not present, use
                           menu 'IDLE -> Preferences...' instead.
         ---
 …
         ---
         (Additional Help Sources may be added here)
+Edit context menu (Right-click / Control-click on OS X in Edit window):
+        Cut              -- Copy a selection into system-wide clipboard,
+                            then delete the selection
+        Copy             -- Copy selection into system-wide clipboard
+        Paste            -- Insert system-wide clipboard into window
+        Set Breakpoint   -- Sets a breakpoint (when debugger open)
+        Clear Breakpoint -- Clears the breakpoint on that line
+Shell context menu (Right-click / Control-click on OS X in Shell window):
+        Cut              -- Copy a selection into system-wide clipboard,
+                            then delete the selection
+        Copy             -- Copy selection into system-wide clipboard
+        Paste            -- Insert system-wide clipboard into window
+        ---
+        Go to file/line  -- Same as in Debug menu
 …
         Control-c interrupts executing command.
+        Control-d sends end-of-file; closes window if typed at >>> prompt
+                (this is Control-z on Windows).
+        Control-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.
               (These are Control-p, Control-n on the Mac)
+              (These are Control-p, Control-n on OS X)
         Return while cursor is on a previous command retrieves that command.
         Expand word is also useful to reduce typing.

python/trunk/Lib/idlelib/idle.bat

r2	r391
1	1	@echo off
2		rem Working IDLE bat for Windows - uses start instead of absolute pathname
3		start idle.pyw %1 %2 %3 %4 %5 %6 %7 %8 %9
	2	rem Start IDLE using the appropriate Python interpreter
	3	set CURRDIR=%~dp0
	4	start "IDLE" "%CURRDIR%..\..\pythonw.exe" "%CURRDIR%idle.pyw" %1 %2 %3 %4 %5 %6 %7 %8 %9

python/trunk/Lib/idlelib/idle.py

-              r2
+              r391
+try:
+    import idlelib.PyShell
+except ImportError:
+    # IDLE is not installed, but maybe PyShell is on sys.path:
+    try:
+        import PyShell
+    except ImportError:
+        raise
+    else:
+        import os
+        idledir = os.path.dirname(os.path.abspath(PyShell.__file__))
+        if idledir != os.getcwd():
+            # We're not in the IDLE directory, help the subprocess find run.py
+            pypath = os.environ.get('PYTHONPATH', '')
+            if pypath:
+                os.environ['PYTHONPATH'] = pypath + ':' + idledir
+            else:
+                os.environ['PYTHONPATH'] = idledir
+        PyShell.main()
+else:
+    idlelib.PyShell.main()
+import os.path
+import sys
+# If we are working on a development version of IDLE, we need to prepend the
+# parent of this idlelib dir to sys.path.  Otherwise, importing idlelib gets
+# the version installed with the Python used to call this module:
+idlelib_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, idlelib_dir)
+import idlelib.PyShell
+idlelib.PyShell.main()

python/trunk/Lib/idlelib/idlever.py

r2	r391
1		IDLE_VERSION = "2.~~6.5~~"
	1	IDLE_VERSION = "2.7.6"

python/trunk/Lib/idlelib/keybindingDialog.py

-              r2
+              r391
         config-keys.def must use the same ordering.
         """
         import macosxSupport
+        from idlelib import macosxSupport
         if macosxSupport.runningAsOSXApp():
             self.modifiers = ['Shift', 'Control', 'Option', 'Command']
 …
     def GetModifiers(self):
         modList = [variable.get() for variable in self.modifier_vars]
         return filter(None, modList)
+        return [mod for mod in modList if mod]
     def ClearKeySeq(self):

python/trunk/Lib/idlelib/macosxSupport.py

-              r2
+              r391
 import sys
 import Tkinter
+from os import path
+_appbundle = None
 def runningAsOSXApp():
 …
     Returns True if Python is running from within an app on OSX.
     If so, assume that Python was built with Aqua Tcl/Tk rather than
     X11 Tck/Tk.
+    X11 Tcl/Tk.
     """
+    return (sys.platform == 'darwin' and '.app' in sys.executable)
+    global _appbundle
+    if _appbundle is None:
+        _appbundle = (sys.platform == 'darwin' and '.app' in sys.executable)
+    return _appbundle
+_carbonaquatk = None
+def isCarbonAquaTk(root):
+    """
+    Returns True if IDLE is using a Carbon Aqua Tk (instead of the
+    newer Cocoa Aqua Tk).
+    """
+    global _carbonaquatk
+    if _carbonaquatk is None:
+        _carbonaquatk = (runningAsOSXApp() and
+                         'aqua' in root.tk.call('tk', 'windowingsystem') and
+                         'AppKit' not in root.tk.call('winfo', 'server', '.'))
+    return _carbonaquatk
+def tkVersionWarning(root):
+    """
+    Returns a string warning message if the Tk version in use appears to
+    be one known to cause problems with IDLE.
+. Apple Cocoa-based Tk 8.5.7 shipped with Mac OS X 10.6 is unusable.
+. Apple Cocoa-based Tk 8.5.9 in OS X 10.7 and 10.8 is better but
+        can still crash unexpectedly.
+    """
+    if (runningAsOSXApp() and
+            ('AppKit' in root.tk.call('winfo', 'server', '.')) ):
+        patchlevel = root.tk.call('info', 'patchlevel')
+        if patchlevel not in ('8.5.7', '8.5.9'):
+            return False
+        return (r"WARNING: The version of Tcl/Tk ({0}) in use may"
+                r" be unstable.\n"
+                r"Visit http://www.python.org/download/mac/tcltk/"
+                r" for current information.".format(patchlevel))
+    else:
+        return False
 def addOpenEventSupport(root, flist):
     """
     This ensures that the application will respont to open AppleEvents, which
     makes is feaseable to use IDLE as the default application for python files.
+    This ensures that the application will respond to open AppleEvents, which
+    makes is feasible to use IDLE as the default application for python files.
     """
     def doOpenFile(*args):
 …
     # menu.
     from Tkinter import Menu, Text, Text
     from EditorWindow import prepstr, get_accelerator
     import Bindings
     import WindowList
     from MultiCall import MultiCallCreator
+    from idlelib.EditorWindow import prepstr, get_accelerator
+    from idlelib import Bindings
+    from idlelib import WindowList
+    from idlelib.MultiCall import MultiCallCreator
     menubar = Menu(root)
 …
     WindowList.register_callback(postwindowsmenu)
-    menudict['application'] = menu = Menu(menubar, name='apple')
-    menubar.add_cascade(label='IDLE', menu=menu)
     def about_dialog(event=None):
         import aboutDialog
+        from idlelib import aboutDialog
         aboutDialog.AboutDialog(root, 'About IDLE')
     def config_dialog(event=None):
         import configDialog
+        from idlelib import configDialog
         root.instance_dict = flist.inversedict
         configDialog.ConfigDialog(root, 'Settings')
+    def help_dialog(event=None):
+        from idlelib import textView
+        fn = path.join(path.abspath(path.dirname(__file__)), 'help.txt')
+        textView.view_file(root, 'Help', fn)
     root.bind('<<about-idle>>', about_dialog)
     root.bind('<<open-config-dialog>>', config_dialog)
+    root.createcommand('::tk::mac::ShowPreferences', config_dialog)
     if flist:
         root.bind('<<close-all-windows>>', flist.close_all_callback)
+        # The binding above doesn't reliably work on all versions of Tk
+        # on MacOSX. Adding command definition below does seem to do the
+        # right thing for now.
+        root.createcommand('exit', flist.close_all_callback)
     ###check if Tk version >= 8.4.14; if so, use hard-coded showprefs binding
     tkversion = root.tk.eval('info patchlevel')
     # Note: we cannot check if the string tkversion >= '8.4.14', because
     # the string '8.4.7' is greater than the string '8.4.14'.
     if tuple(map(int, tkversion.split('.'))) >= (8, 4, 14):
         Bindings.menudefs[0] =  ('application', [
+    if isCarbonAquaTk(root):
+        # for Carbon AquaTk, replace the default Tk apple menu
+        menudict['application'] = menu = Menu(menubar, name='apple')
+        menubar.add_cascade(label='IDLE', menu=menu)
+        Bindings.menudefs.insert(0,
+            ('application', [
                 ('About IDLE', '<<about-idle>>'),
+                None,
+            ])
+        root.createcommand('::tk::mac::ShowPreferences', config_dialog)
+                    None,
+                ]))
+        tkversion = root.tk.eval('info patchlevel')
+        if tuple(map(int, tkversion.split('.'))) < (8, 4, 14):
+            # for earlier AquaTk versions, supply a Preferences menu item
+            Bindings.menudefs[0][1].append(
+                    ('_Preferences....', '<<open-config-dialog>>'),
+                )
     else:
+        for mname, entrylist in Bindings.menudefs:
+            menu = menudict.get(mname)
+            if not menu:
+                continue
+            else:
+                for entry in entrylist:
+                    if not entry:
+                        menu.add_separator()
+                    else:
+                        label, eventname = entry
+                        underline, label = prepstr(label)
+                        accelerator = get_accelerator(Bindings.default_keydefs,
+                        eventname)
+                        def command(text=root, eventname=eventname):
+                            text.event_generate(eventname)
+                        menu.add_command(label=label, underline=underline,
+                        command=command, accelerator=accelerator)
+        # assume Cocoa AquaTk
+        # replace default About dialog with About IDLE one
+        root.createcommand('tkAboutDialog', about_dialog)
+        # replace default "Help" item in Help menu
+        root.createcommand('::tk::mac::ShowHelp', help_dialog)
+        # remove redundant "IDLE Help" from menu
+        del Bindings.menudefs[-1][1][0]
 def setupApp(root, flist):

python/trunk/Lib/idlelib/rpc.py

-              r2
+              r391
 For security reasons, GvR requested that Idle's Python execution server process
 connect to the Idle process, which listens for the connection.  Since Idle has
 has only one client per server, this was not a limitation.
+only one client per server, this was not a limitation.
    +---------------------------------+ +-------------+
 …
     def exithook(self):
         "override for specific exit action"
         os._exit()
+        os._exit(0)
     def debug(self, *args):
 …
         except TypeError:
             return ("ERROR", "Bad request format")
         if not self.objtable.has_key(oid):
+        if oid not in self.objtable:
             return ("ERROR", "Unknown object id: %r" % (oid,))
         obj = self.objtable[oid]
 …
             cvar = self.cvars[myseq]
             cvar.acquire()
             while not self.responses.has_key(myseq):
+            while myseq not in self.responses:
                 cvar.wait()
             response = self.responses[myseq]
 …
     def __init__(self, address, family=socket.AF_INET, type=socket.SOCK_STREAM):
         self.listening_sock = socket.socket(family, type)
-        self.listening_sock.setsockopt(socket.SOL_SOCKET,
-                                       socket.SO_REUSEADDR, 1)
         self.listening_sock.bind(address)
         self.listening_sock.listen(1)
 …
         if self.__attributes is None:
             self.__getattributes()
         if self.__attributes.has_key(name):
+        if name in self.__attributes:
             value = self.sockio.remotecall(self.oid, '__getattribute__',
                                            (name,), {})
 …
     for name in dir(obj):
         attr = getattr(obj, name)
         if callable(attr):
+        if hasattr(attr, '__call__'):
             methods[name] = 1
     if type(obj) == types.InstanceType:
 …
     for name in dir(obj):
         attr = getattr(obj, name)
         if not callable(attr):
+        if not hasattr(attr, '__call__'):
             attributes[name] = 1
 …
 # XXX KBK 09Sep03  We need a proper unit test for this module.  Previously
 #                  existing test code was removed at Rev 1.27.
+#                  existing test code was removed at Rev 1.27 (r34098).

python/trunk/Lib/idlelib/run.py

-              r2
+              r391
 import sys
+import io
 import linecache
 import time
 …
 import Queue
+import CallTips
+import AutoComplete
+import RemoteDebugger
+import RemoteObjectBrowser
+import StackViewer
+import rpc
+from idlelib import CallTips
+from idlelib import AutoComplete
+from idlelib import RemoteDebugger
+from idlelib import RemoteObjectBrowser
+from idlelib import StackViewer
+from idlelib import rpc
+from idlelib import PyShell
+from idlelib import IOBinding
 import __main__
 …
 LOCALHOST = '127.0.0.1'
+try:
+    import warnings
+except ImportError:
+    pass
+else:
+    def idle_formatwarning_subproc(message, category, filename, lineno,
+                                   file=None, line=None):
+        """Format warnings the IDLE way"""
+        s = "\nWarning (from warnings module):\n"
+        s += '  File \"%s\", line %s\n' % (filename, lineno)
+        line = linecache.getline(filename, lineno).strip() \
+            if line is None else line
+        if line:
+            s += "    %s\n" % line
+        s += "%s: %s\n" % (category.__name__, message)
+        return s
+    warnings.formatwarning = idle_formatwarning_subproc
+import warnings
+def idle_showwarning_subproc(
+        message, category, filename, lineno, file=None, line=None):
+    """Show Idle-format warning after replacing warnings.showwarning.
+    The only difference is the formatter called.
+    """
+    if file is None:
+        file = sys.stderr
+    try:
+        file.write(PyShell.idle_formatwarning(
+                message, category, filename, lineno, line))
+    except IOError:
+        pass # the file (probably stderr) is invalid - this warning gets lost.
+_warnings_showwarning = None
+def capture_warnings(capture):
+    "Replace warning.showwarning with idle_showwarning_subproc, or reverse."
+    global _warnings_showwarning
+    if capture:
+        if _warnings_showwarning is None:
+            _warnings_showwarning = warnings.showwarning
+            warnings.showwarning = idle_showwarning_subproc
+    else:
+        if _warnings_showwarning is not None:
+            warnings.showwarning = _warnings_showwarning
+            _warnings_showwarning = None
+capture_warnings(True)
 # Thread shared globals: Establish a queue between a subthread (which handles
 …
     global no_exitfunc
     no_exitfunc = del_exitfunc
-    port = 8833
     #time.sleep(15) # test subprocess not responding
+    if sys.argv[1:]:
+        port = int(sys.argv[1])
+    try:
+        assert(len(sys.argv) > 1)
+        port = int(sys.argv[-1])
+    except:
+        print>>sys.stderr, "IDLE Subprocess: no IP port passed in sys.argv."
+        return
+    capture_warnings(True)
     sys.argv[:] = [""]
     sockthread = threading.Thread(target=manage_socket,
 …
             continue
         except SystemExit:
+            capture_warnings(False)
             raise
         except:
 …
             server = MyRPCServer(address, MyHandler)
             break
         except socket.error, err:
+        except socket.error as err:
             print>>sys.__stderr__,"IDLE Subprocess: socket error: "\
                                         + err[1] + ", retrying...."
+                                        + err.args[1] + ", retrying...."
     else:
         print>>sys.__stderr__, "IDLE Subprocess: Connection to "\
 …
     root = Tkinter.Tk()
     root.withdraw()
     if err[0] == 61: # connection refused
+    if err.args[0] == 61: # connection refused
         msg = "IDLE's subprocess can't connect to %s:%d.  This may be due "\
               "to your personal firewall configuration.  It is safe to "\
 …
         tkMessageBox.showerror("IDLE Subprocess Error", msg, parent=root)
     else:
+        tkMessageBox.showerror("IDLE Subprocess Error", "Socket Error: %s" % err[1])
+        tkMessageBox.showerror("IDLE Subprocess Error",
+                               "Socket Error: %s" % err.args[1])
     root.destroy()
 …
         except AttributeError:
             pass
+    capture_warnings(False)
     sys.exit(0)
 …
             thread.interrupt_main()
 class MyHandler(rpc.RPCHandler):
 …
         executive = Executive(self)
         self.register("exec", executive)
+        sys.stdin = self.console = self.get_remote_proxy("stdin")
+        sys.stdout = self.get_remote_proxy("stdout")
+        sys.stderr = self.get_remote_proxy("stderr")
+        import IOBinding
+        sys.stdin.encoding = sys.stdout.encoding = \
+                             sys.stderr.encoding = IOBinding.encoding
+        self.console = self.get_remote_proxy("console")
+        sys.stdin = PyShell.PseudoInputFile(self.console, "stdin",
+                IOBinding.encoding)
+        sys.stdout = PyShell.PseudoOutputFile(self.console, "stdout",
+                IOBinding.encoding)
+        sys.stderr = PyShell.PseudoOutputFile(self.console, "stderr",
+                IOBinding.encoding)
+        # Keep a reference to stdin so that it won't try to exit IDLE if
+        # sys.stdin gets changed from within IDLE's shell. See issue17838.
+        self._keep_stdin = sys.stdin
         self.interp = self.get_remote_proxy("interp")
         rpc.RPCHandler.getresponse(self, myseq=None, wait=0.05)
 …
             finally:
                 interruptable = False
+        except SystemExit:
+            # Scripts that raise SystemExit should just
+            # return to the interactive prompt
+            pass
         except:
             self.usr_exc_info = sys.exc_info()
             if quitting:
                 exit()
-            # even print a user code SystemExit exception, continue
             print_exception()
             jit = self.rpchandler.console.getvar("<<toggle-jit-stack-viewer>>")
 …
         item = StackViewer.StackTreeItem(flist, tb)
         return RemoteObjectBrowser.remote_object_tree_item(item)
+capture_warnings(False)  # Make sure turned off; see issue 18081

python/trunk/Lib/idlelib/textView.py

-              r2
+              r391
     """
     def __init__(self, parent, title, text):
+    def __init__(self, parent, title, text, modal=True):
         """Show the given text in a scrollable window with a 'close' button
 …
         self.CreateWidgets()
         self.title(title)
-        self.transient(parent)
-        self.grab_set()
         self.protocol("WM_DELETE_WINDOW", self.Ok)
         self.parent = parent
 …
         self.textView.insert(0.0, text)
         self.textView.config(state=DISABLED)
+        self.wait_window()
+        if modal:
+            self.transient(parent)
+            self.grab_set()
+            self.wait_window()
     def CreateWidgets(self):
 …
 def view_text(parent, title, text):
     TextViewer(parent, title, text)
+def view_text(parent, title, text, modal=True):
+    return TextViewer(parent, title, text, modal)
 def view_file(parent, title, filename, encoding=None):
+def view_file(parent, title, filename, encoding=None, modal=True):
     try:
         if encoding:
 …
                                parent=parent)
     else:
         return view_text(parent, title, textFile.read())
+        return view_text(parent, title, textFile.read(), modal)
 …
     text = file(filename, 'r').read()
     btn1 = Button(root, text='view_text',
                  command=lambda:view_text(root, 'view_text', text))
+                  command=lambda:view_text(root, 'view_text', text))
     btn1.pack(side=LEFT)
     btn2 = Button(root, text='view_file',
                   command=lambda:view_file(root, 'view_file', filename))
     btn2.pack(side=LEFT)
+    btn3 = Button(root, text='nonmodal view_text',
+                  command=lambda:view_text(root, 'nonmodal view_text', text,
+                                           modal=False))
+    btn3.pack(side=LEFT)
     close = Button(root, text='Close', command=root.destroy)
     close.pack(side=RIGHT)

/python/vendor/Python-2.7.6	merged	eligible
/python/vendor/current	merged	eligible

Context Navigation

Legend:

Download in other formats: