Initial revision

Lib/idlelib/EditorWindow.py

@@ -0,0 +1,749 @@
+# changes by dscherer@cmu.edu
+#   - created format and run menus
+#   - added silly advice dialog (apologies to Douglas Adams)
+#   - made Python Documentation work on Windows (requires win32api to
+#     do a ShellExecute(); other ways of starting a web browser are awkward)
+
+import sys
+import os
+import string
+import re
+import imp
+from Tkinter import *
+import tkSimpleDialog
+import tkMessageBox
+import idlever
+import WindowList
+from IdleConf import idleconf
+
+# The default tab setting for a Text widget, in average-width characters.
+TK_TABWIDTH_DEFAULT = 8
+
+# File menu
+
+#$ event <<open-module>>
+#$ win <Alt-m>
+#$ unix <Control-x><Control-m>
+
+#$ event <<open-class-browser>>
+#$ win <Alt-c>
+#$ unix <Control-x><Control-b>
+
+#$ event <<open-path-browser>>
+
+#$ event <<close-window>>
+#$ unix <Control-x><Control-0>
+#$ unix <Control-x><Key-0>
+#$ win <Alt-F4>
+
+# Edit menu
+
+#$ event <<Copy>>
+#$ win <Control-c>
+#$ unix <Alt-w>
+
+#$ event <<Cut>>
+#$ win <Control-x>
+#$ unix <Control-w>
+
+#$ event <<Paste>>
+#$ win <Control-v>
+#$ unix <Control-y>
+
+#$ event <<select-all>>
+#$ win <Alt-a>
+#$ unix <Alt-a>
+
+# Help menu
+
+#$ event <<help>>
+#$ win <F1>
+#$ unix <F1>
+
+#$ event <<about-idle>>
+
+# Events without menu entries
+
+#$ event <<remove-selection>>
+#$ win <Escape>
+
+#$ event <<center-insert>>
+#$ win <Control-l>
+#$ unix <Control-l>
+
+#$ event <<do-nothing>>
+#$ unix <Control-x>
+
+
+about_title = "About IDLE"
+about_text = """\
+IDLE %s
+
+An Integrated DeveLopment Environment for Python
+
+by Guido van Rossum
+
+This version of IDLE has been modified by David Scherer
+  (dscherer@cmu.edu).  See readme.txt for details.
+""" % idlever.IDLE_VERSION
+
+class EditorWindow:
+
+    from Percolator import Percolator
+    from ColorDelegator import ColorDelegator
+    from UndoDelegator import UndoDelegator
+    from IOBinding import IOBinding
+    import Bindings
+    from Tkinter import Toplevel
+    from MultiStatusBar import MultiStatusBar
+
+    about_title = about_title
+    about_text = about_text
+
+    vars = {}
+
+    def __init__(self, flist=None, filename=None, key=None, root=None):
+        edconf = idleconf.getsection('EditorWindow')
+        coconf = idleconf.getsection('Colors')
+        self.flist = flist
+        root = root or flist.root
+        self.root = root
+        if flist:
+            self.vars = flist.vars
+        self.menubar = Menu(root)
+        self.top = top = self.Toplevel(root, menu=self.menubar)
+        self.vbar = vbar = Scrollbar(top, name='vbar')
+        self.text_frame = text_frame = Frame(top)
+        self.text = text = Text(text_frame, name='text', padx=5,
+                      foreground=coconf.getdef('normal-foreground'),
+                      background=coconf.getdef('normal-background'),
+                      highlightcolor=coconf.getdef('hilite-foreground'),
+                      highlightbackground=coconf.getdef('hilite-background'),
+                      insertbackground=coconf.getdef('cursor-background'),
+                      width=edconf.getint('width'),
+                      height=edconf.getint('height'),
+                      wrap="none")
+
+        self.createmenubar()
+        self.apply_bindings()
+
+        self.top.protocol("WM_DELETE_WINDOW", self.close)
+        self.top.bind("<<close-window>>", self.close_event)
+        text.bind("<<center-insert>>", self.center_insert_event)
+        text.bind("<<help>>", self.help_dialog)
+        text.bind("<<good-advice>>", self.good_advice)
+        text.bind("<<python-docs>>", self.python_docs)
+        text.bind("<<about-idle>>", self.about_dialog)
+        text.bind("<<open-module>>", self.open_module)
+        text.bind("<<do-nothing>>", lambda event: "break")
+        text.bind("<<select-all>>", self.select_all)
+        text.bind("<<remove-selection>>", self.remove_selection)
+        text.bind("<3>", self.right_menu_event)
+        if flist:
+            flist.inversedict[self] = key
+            if key:
+                flist.dict[key] = self
+            text.bind("<<open-new-window>>", self.flist.new_callback)
+            text.bind("<<close-all-windows>>", self.flist.close_all_callback)
+            text.bind("<<open-class-browser>>", self.open_class_browser)
+            text.bind("<<open-path-browser>>", self.open_path_browser)
+
+        vbar['command'] = text.yview
+        vbar.pack(side=RIGHT, fill=Y)
+
+        text['yscrollcommand'] = vbar.set
+        text['font'] = edconf.get('font-name'), edconf.get('font-size')
+        text_frame.pack(side=LEFT, fill=BOTH, expand=1)
+        text.pack(side=TOP, fill=BOTH, expand=1)
+        text.focus_set()
+
+        self.per = per = self.Percolator(text)
+        if self.ispythonsource(filename):
+            self.color = color = self.ColorDelegator(); per.insertfilter(color)
+            ##print "Initial colorizer"
+        else:
+            ##print "No initial colorizer"
+            self.color = None
+        self.undo = undo = self.UndoDelegator(); per.insertfilter(undo)
+        self.io = io = self.IOBinding(self)
+
+        text.undo_block_start = undo.undo_block_start
+        text.undo_block_stop = undo.undo_block_stop
+        undo.set_saved_change_hook(self.saved_change_hook)
+        io.set_filename_change_hook(self.filename_change_hook)
+
+        if filename:
+            if os.path.exists(filename):
+                io.loadfile(filename)
+            else:
+                io.set_filename(filename)
+
+        self.saved_change_hook()
+
+        self.load_extensions()
+
+        menu = self.menudict.get('windows')
+        if menu:
+            end = menu.index("end")
+            if end is None:
+                end = -1
+            if end >= 0:
+                menu.add_separator()
+                end = end + 1
+            self.wmenu_end = end
+            WindowList.register_callback(self.postwindowsmenu)
+
+        # Some abstractions so IDLE extensions are cross-IDE
+        self.askyesno = tkMessageBox.askyesno
+        self.askinteger = tkSimpleDialog.askinteger
+        self.showerror = tkMessageBox.showerror
+
+        if self.extensions.has_key('AutoIndent'):
+            self.extensions['AutoIndent'].set_indentation_params(
+                self.ispythonsource(filename))
+        self.set_status_bar()
+
+    def set_status_bar(self):
+        self.status_bar = self.MultiStatusBar(self.text_frame)
+        self.status_bar.set_label('column', 'Col: ?', side=RIGHT)
+        self.status_bar.set_label('line', 'Ln: ?', side=RIGHT)
+        self.status_bar.pack(side=BOTTOM, fill=X)
+        self.text.bind('<KeyRelease>', self.set_line_and_column)
+        self.text.bind('<ButtonRelease>', self.set_line_and_column)
+        self.text.after_idle(self.set_line_and_column)
+
+    def set_line_and_column(self, event=None):
+        line, column = string.split(self.text.index(INSERT), '.')
+        self.status_bar.set_label('column', 'Col: %s' % column)
+        self.status_bar.set_label('line', 'Ln: %s' % line)
+
+    def wakeup(self):
+        if self.top.wm_state() == "iconic":
+            self.top.wm_deiconify()
+        else:
+            self.top.tkraise()
+        self.text.focus_set()
+
+    menu_specs = [
+        ("file", "_File"),
+        ("edit", "_Edit"),
+        ("format", "F_ormat"),
+        ("run", "_Run"),
+        ("windows", "_Windows"),
+        ("help", "_Help"),
+    ]
+
+    def createmenubar(self):
+        mbar = self.menubar
+        self.menudict = menudict = {}
+        for name, label in self.menu_specs:
+            underline, label = prepstr(label)
+            menudict[name] = menu = Menu(mbar, name=name)
+            mbar.add_cascade(label=label, menu=menu, underline=underline)
+        self.fill_menus()
+
+    def postwindowsmenu(self):
+        # Only called when Windows menu exists
+        # XXX Actually, this Just-In-Time updating interferes badly
+        # XXX with the tear-off feature.  It would be better to update
+        # XXX all Windows menus whenever the list of windows changes.
+        menu = self.menudict['windows']
+        end = menu.index("end")
+        if end is None:
+            end = -1
+        if end > self.wmenu_end:
+            menu.delete(self.wmenu_end+1, end)
+        WindowList.add_windows_to_menu(menu)
+
+    rmenu = None
+
+    def right_menu_event(self, event):
+        self.text.tag_remove("sel", "1.0", "end")
+        self.text.mark_set("insert", "@%d,%d" % (event.x, event.y))
+        if not self.rmenu:
+            self.make_rmenu()
+        rmenu = self.rmenu
+        self.event = event
+        iswin = sys.platform[:3] == 'win'
+        if iswin:
+            self.text.config(cursor="arrow")
+        rmenu.tk_popup(event.x_root, event.y_root)
+        if iswin:
+            self.text.config(cursor="ibeam")
+
+    rmenu_specs = [
+        # ("Label", "<<virtual-event>>"), ...
+        ("Close", "<<close-window>>"), # Example
+    ]
+
+    def make_rmenu(self):
+        rmenu = Menu(self.text, tearoff=0)
+        for label, eventname in self.rmenu_specs:
+            def command(text=self.text, eventname=eventname):
+                text.event_generate(eventname)
+            rmenu.add_command(label=label, command=command)
+        self.rmenu = rmenu
+
+    def about_dialog(self, event=None):
+        tkMessageBox.showinfo(self.about_title, self.about_text,
+                              master=self.text)
+
+    helpfile = "help.txt"
+
+    def good_advice(self, event=None):
+        tkMessageBox.showinfo('Advice', "Don't Panic!", master=self.text)
+
+    def help_dialog(self, event=None):
+        try:
+            helpfile = os.path.join(os.path.dirname(__file__), self.helpfile)
+        except NameError:
+            helpfile = self.helpfile
+        if self.flist:
+            self.flist.open(helpfile)
+        else:
+            self.io.loadfile(helpfile)
+
+    help_viewer = "netscape -remote 'openurl(%(url)s)' 2>/dev/null || " \
+                  "netscape %(url)s &"
+    help_url = "http://www.python.org/doc/current/"
+
+    def python_docs(self, event=None):
+        if sys.platform=='win32':
+          try:
+            import win32api
+            import ExecBinding
+            doc = os.path.join( os.path.dirname( ExecBinding.pyth_exe ), "doc", "index.html" )
+            win32api.ShellExecute(0, None, doc, None, sys.path[0], 1)
+          except:
+            pass
+        else:
+          cmd = self.help_viewer % {"url": self.help_url}
+          os.system(cmd)
+
+    def select_all(self, event=None):
+        self.text.tag_add("sel", "1.0", "end-1c")
+        self.text.mark_set("insert", "1.0")
+        self.text.see("insert")
+        return "break"
+
+    def remove_selection(self, event=None):
+        self.text.tag_remove("sel", "1.0", "end")
+        self.text.see("insert")
+
+    def open_module(self, event=None):
+        # XXX Shouldn't this be in IOBinding or in FileList?
+        try:
+            name = self.text.get("sel.first", "sel.last")
+        except TclError:
+            name = ""
+        else:
+            name = string.strip(name)
+        if not name:
+            name = tkSimpleDialog.askstring("Module",
+                     "Enter the name of a Python module\n"
+                     "to search on sys.path and open:",
+                     parent=self.text)
+            if name:
+                name = string.strip(name)
+            if not name:
+                return
+        # XXX Ought to support package syntax
+        # XXX Ought to insert current file's directory in front of path
+        try:
+            (f, file, (suffix, mode, type)) = imp.find_module(name)
+        except (NameError, ImportError), msg:
+            tkMessageBox.showerror("Import error", str(msg), parent=self.text)
+            return
+        if type != imp.PY_SOURCE:
+            tkMessageBox.showerror("Unsupported type",
+                "%s is not a source module" % name, parent=self.text)
+            return
+        if f:
+            f.close()
+        if self.flist:
+            self.flist.open(file)
+        else:
+            self.io.loadfile(file)
+
+    def open_class_browser(self, event=None):
+        filename = self.io.filename
+        if not filename:
+            tkMessageBox.showerror(
+                "No filename",
+                "This buffer has no associated filename",
+                master=self.text)
+            self.text.focus_set()
+            return None
+        head, tail = os.path.split(filename)
+        base, ext = os.path.splitext(tail)
+        import ClassBrowser
+        ClassBrowser.ClassBrowser(self.flist, base, [head])
+
+    def open_path_browser(self, event=None):
+        import PathBrowser
+        PathBrowser.PathBrowser(self.flist)
+
+    def gotoline(self, lineno):
+        if lineno is not None and lineno > 0:
+            self.text.mark_set("insert", "%d.0" % lineno)
+            self.text.tag_remove("sel", "1.0", "end")
+            self.text.tag_add("sel", "insert", "insert +1l")
+            self.center()
+
+    def ispythonsource(self, filename):
+        if not filename:
+            return 1
+        base, ext = os.path.splitext(os.path.basename(filename))
+        if os.path.normcase(ext) in (".py", ".pyw"):
+            return 1
+        try:
+            f = open(filename)
+            line = f.readline()
+            f.close()
+        except IOError:
+            return 0
+        return line[:2] == '#!' and string.find(line, 'python') >= 0
+
+    def close_hook(self):
+        if self.flist:
+            self.flist.close_edit(self)
+
+    def set_close_hook(self, close_hook):
+        self.close_hook = close_hook
+
+    def filename_change_hook(self):
+        if self.flist:
+            self.flist.filename_changed_edit(self)
+        self.saved_change_hook()
+        if self.ispythonsource(self.io.filename):
+            self.addcolorizer()
+        else:
+            self.rmcolorizer()
+
+    def addcolorizer(self):
+        if self.color:
+            return
+        ##print "Add colorizer"
+        self.per.removefilter(self.undo)
+        self.color = self.ColorDelegator()
+        self.per.insertfilter(self.color)
+        self.per.insertfilter(self.undo)
+
+    def rmcolorizer(self):
+        if not self.color:
+            return
+        ##print "Remove colorizer"
+        self.per.removefilter(self.undo)
+        self.per.removefilter(self.color)
+        self.color = None
+        self.per.insertfilter(self.undo)
+
+    def saved_change_hook(self):
+        short = self.short_title()
+        long = self.long_title()
+        if short and long:
+            title = short + " - " + long
+        elif short:
+            title = short
+        elif long:
+            title = long
+        else:
+            title = "Untitled"
+        icon = short or long or title
+        if not self.get_saved():
+            title = "*%s*" % title
+            icon = "*%s" % icon
+        self.top.wm_title(title)
+        self.top.wm_iconname(icon)
+
+    def get_saved(self):
+        return self.undo.get_saved()
+
+    def set_saved(self, flag):
+        self.undo.set_saved(flag)
+
+    def reset_undo(self):
+        self.undo.reset_undo()
+
+    def short_title(self):
+        filename = self.io.filename
+        if filename:
+            filename = os.path.basename(filename)
+        return filename
+
+    def long_title(self):
+        return self.io.filename or ""
+
+    def center_insert_event(self, event):
+        self.center()
+
+    def center(self, mark="insert"):
+        text = self.text
+        top, bot = self.getwindowlines()
+        lineno = self.getlineno(mark)
+        height = bot - top
+        newtop = max(1, lineno - height/2)
+        text.yview(float(newtop))
+
+    def getwindowlines(self):
+        text = self.text
+        top = self.getlineno("@0,0")
+        bot = self.getlineno("@0,65535")
+        if top == bot and text.winfo_height() == 1:
+            # Geometry manager hasn't run yet
+            height = int(text['height'])
+            bot = top + height - 1
+        return top, bot
+
+    def getlineno(self, mark="insert"):
+        text = self.text
+        return int(float(text.index(mark)))
+
+    def close_event(self, event):
+        self.close()
+
+    def maybesave(self):
+        if self.io:
+            return self.io.maybesave()
+
+    def close(self):
+        self.top.wm_deiconify()
+        self.top.tkraise()
+        reply = self.maybesave()
+        if reply != "cancel":
+            self._close()
+        return reply
+
+    def _close(self):
+        WindowList.unregister_callback(self.postwindowsmenu)
+        if self.close_hook:
+            self.close_hook()
+        self.flist = None
+        colorizing = 0
+        self.unload_extensions()
+        self.io.close(); self.io = None
+        self.undo = None # XXX
+        if self.color:
+            colorizing = self.color.colorizing
+            doh = colorizing and self.top
+            self.color.close(doh) # Cancel colorization
+        self.text = None
+        self.vars = None
+        self.per.close(); self.per = None
+        if not colorizing:
+            self.top.destroy()
+
+    def load_extensions(self):
+        self.extensions = {}
+        self.load_standard_extensions()
+
+    def unload_extensions(self):
+        for ins in self.extensions.values():
+            if hasattr(ins, "close"):
+                ins.close()
+        self.extensions = {}
+
+    def load_standard_extensions(self):
+        for name in self.get_standard_extension_names():
+            try:
+                self.load_extension(name)
+            except:
+                print "Failed to load extension", `name`
+                import traceback
+                traceback.print_exc()
+
+    def get_standard_extension_names(self):
+        return idleconf.getextensions()
+
+    def load_extension(self, name):
+        mod = __import__(name, globals(), locals(), [])
+        cls = getattr(mod, name)
+        ins = cls(self)
+        self.extensions[name] = ins
+        kdnames = ["keydefs"]
+        if sys.platform == 'win32':
+            kdnames.append("windows_keydefs")
+        elif sys.platform == 'mac':
+            kdnames.append("mac_keydefs")
+        else:
+            kdnames.append("unix_keydefs")
+        keydefs = {}
+        for kdname in kdnames:
+            if hasattr(ins, kdname):
+                keydefs.update(getattr(ins, kdname))
+        if keydefs:
+            self.apply_bindings(keydefs)
+            for vevent in keydefs.keys():
+                methodname = string.replace(vevent, "-", "_")
+                while methodname[:1] == '<':
+                    methodname = methodname[1:]
+                while methodname[-1:] == '>':
+                    methodname = methodname[:-1]
+                methodname = methodname + "_event"
+                if hasattr(ins, methodname):
+                    self.text.bind(vevent, getattr(ins, methodname))
+        if hasattr(ins, "menudefs"):
+            self.fill_menus(ins.menudefs, keydefs)
+        return ins
+
+    def apply_bindings(self, keydefs=None):
+        if keydefs is None:
+            keydefs = self.Bindings.default_keydefs
+        text = self.text
+        text.keydefs = keydefs
+        for event, keylist in keydefs.items():
+            if keylist:
+                apply(text.event_add, (event,) + tuple(keylist))
+
+    def fill_menus(self, defs=None, keydefs=None):
+        # Fill the menus. Menus that are absent or None in
+        # self.menudict are ignored.
+        if defs is None:
+            defs = self.Bindings.menudefs
+        if keydefs is None:
+            keydefs = self.Bindings.default_keydefs
+        menudict = self.menudict
+        text = self.text
+        for mname, itemlist in defs:
+            menu = menudict.get(mname)
+            if not menu:
+                continue
+            for item in itemlist:
+                if not item:
+                    menu.add_separator()
+                else:
+                    label, event = item
+                    checkbutton = (label[:1] == '!')
+                    if checkbutton:
+                        label = label[1:]
+                    underline, label = prepstr(label)
+                    accelerator = get_accelerator(keydefs, event)
+                    def command(text=text, event=event):
+                        text.event_generate(event)
+                    if checkbutton:
+                        var = self.getrawvar(event, BooleanVar)
+                        menu.add_checkbutton(label=label, underline=underline,
+                            command=command, accelerator=accelerator,
+                            variable=var)
+                    else:
+                        menu.add_command(label=label, underline=underline,
+                            command=command, accelerator=accelerator)
+
+    def getvar(self, name):
+        var = self.getrawvar(name)
+        if var:
+            return var.get()
+
+    def setvar(self, name, value, vartype=None):
+        var = self.getrawvar(name, vartype)
+        if var:
+            var.set(value)
+
+    def getrawvar(self, name, vartype=None):
+        var = self.vars.get(name)
+        if not var and vartype:
+            self.vars[name] = var = vartype(self.text)
+        return var
+
+    # Tk implementations of "virtual text methods" -- each platform
+    # reusing IDLE's support code needs to define these for its GUI's
+    # flavor of widget.
+
+    # Is character at text_index in a Python string?  Return 0 for
+    # "guaranteed no", true for anything else.  This info is expensive
+    # to compute ab initio, but is probably already known by the
+    # platform's colorizer.
+
+    def is_char_in_string(self, text_index):
+        if self.color:
+            # Return true iff colorizer hasn't (re)gotten this far
+            # yet, or the character is tagged as being in a string
+            return self.text.tag_prevrange("TODO", text_index) or \
+                   "STRING" in self.text.tag_names(text_index)
+        else:
+            # The colorizer is missing: assume the worst
+            return 1
+
+    # If a selection is defined in the text widget, return (start,
+    # end) as Tkinter text indices, otherwise return (None, None)
+    def get_selection_indices(self):
+        try:
+            first = self.text.index("sel.first")
+            last = self.text.index("sel.last")
+            return first, last
+        except TclError:
+            return None, None
+
+    # Return the text widget's current view of what a tab stop means
+    # (equivalent width in spaces).
+
+    def get_tabwidth(self):
+        current = self.text['tabs'] or TK_TABWIDTH_DEFAULT
+        return int(current)
+
+    # Set the text widget's current view of what a tab stop means.
+
+    def set_tabwidth(self, newtabwidth):
+        text = self.text
+        if self.get_tabwidth() != newtabwidth:
+            pixels = text.tk.call("font", "measure", text["font"],
+                                  "-displayof", text.master,
+                                  "n" * newtabwith)
+            text.configure(tabs=pixels)
+
+def prepstr(s):
+    # Helper to extract the underscore from a string, e.g.
+    # prepstr("Co_py") returns (2, "Copy").
+    i = string.find(s, '_')
+    if i >= 0:
+        s = s[:i] + s[i+1:]
+    return i, s
+
+
+keynames = {
+ 'bracketleft': '[',
+ 'bracketright': ']',
+ 'slash': '/',
+}
+
+def get_accelerator(keydefs, event):
+    keylist = keydefs.get(event)
+    if not keylist:
+        return ""
+    s = keylist[0]
+    s = re.sub(r"-[a-z]\b", lambda m: string.upper(m.group()), s)
+    s = re.sub(r"\b\w+\b", lambda m: keynames.get(m.group(), m.group()), s)
+    s = re.sub("Key-", "", s)
+    s = re.sub("Cancel","Ctrl-Break",s)   # dscherer@cmu.edu
+    s = re.sub("Control-", "Ctrl-", s)
+    s = re.sub("-", "+", s)
+    s = re.sub("><", " ", s)
+    s = re.sub("<", "", s)
+    s = re.sub(">", "", s)
+    return s
+
+
+def fixwordbreaks(root):
+    # Make sure that Tk's double-click and next/previous word
+    # operations use our definition of a word (i.e. an identifier)
+    tk = root.tk
+    tk.call('tcl_wordBreakAfter', 'a b', 0) # make sure word.tcl is loaded
+    tk.call('set', 'tcl_wordchars', '[a-zA-Z0-9_]')
+    tk.call('set', 'tcl_nonwordchars', '[^a-zA-Z0-9_]')
+
+
+def test():
+    root = Tk()
+    fixwordbreaks(root)
+    root.withdraw()
+    if sys.argv[1:]:
+        filename = sys.argv[1]
+    else:
+        filename = None
+    edit = EditorWindow(root=root, filename=filename)
+    edit.set_close_hook(root.quit)
+    root.mainloop()
+    root.destroy()
+
+if __name__ == '__main__':
+    test()