EditorWindow.py 58.8 KB
Newer Older
David Scherer's avatar
David Scherer committed
1 2 3 4
import sys
import os
import re
import imp
5 6 7
from Tkinter import *
import tkSimpleDialog
import tkMessageBox
8
import webbrowser
9 10 11 12 13 14 15 16 17 18 19

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
David Scherer's avatar
David Scherer committed
20 21 22 23

# The default tab setting for a Text widget, in average-width characters.
TK_TABWIDTH_DEFAULT = 8

24 25 26 27 28
def _sphinx_version():
    "Format sys.version_info to produce the Sphinx version string used to install the chm docs"
    major, minor, micro, level, serial = sys.version_info
    release = '%s%s' % (major, minor)
    if micro:
29 30 31 32
        release += '%s' % (micro,)
    if level == 'candidate':
        release += 'rc%s' % (serial,)
    elif level != 'final':
33 34 35
        release += '%s%s' % (level[0], serial)
    return release

Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
36 37 38 39 40 41 42 43 44 45 46
def _find_module(fullname, path=None):
    """Version of imp.find_module() that handles hierarchical module names"""

    file = None
    for tgt in fullname.split('.'):
        if file is not None:
            file.close()            # close intermediate files
        (file, filename, descr) = imp.find_module(tgt, path)
        if descr[2] == imp.PY_SOURCE:
            break                   # find but not load the source file
        module = imp.load_module(tgt, file, filename, descr)
47 48 49 50
        try:
            path = module.__path__
        except AttributeError:
            raise ImportError, 'No source for module ' + module.__name__
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
51 52
    return file, filename, descr

53
class EditorWindow(object):
54 55 56 57 58
    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
59
    from Tkinter import Toplevel
60
    from idlelib.MultiStatusBar import MultiStatusBar
David Scherer's avatar
David Scherer committed
61

62
    help_url = None
David Scherer's avatar
David Scherer committed
63 64

    def __init__(self, flist=None, filename=None, key=None, root=None):
65
        if EditorWindow.help_url is None:
66
            dochome =  os.path.join(sys.prefix, 'Doc', 'index.html')
67 68 69 70 71 72 73 74 75
            if sys.platform.count('linux'):
                # look for html docs in a couple of standard places
                pyver = 'python-docs-' + '%s.%s.%s' % sys.version_info[:3]
                if os.path.isdir('/var/www/html/python/'):  # "python2" rpm
                    dochome = '/var/www/html/python/index.html'
                else:
                    basepath = '/usr/share/doc/'  # standard location
                    dochome = os.path.join(basepath, pyver,
                                           'Doc', 'index.html')
76
            elif sys.platform[:3] == 'win':
77
                chmfile = os.path.join(sys.prefix, 'Doc',
78
                                       'Python%s.chm' % _sphinx_version())
79 80
                if os.path.isfile(chmfile):
                    dochome = chmfile
81 82 83 84
            elif macosxSupport.runningAsOSXApp():
                # documentation is stored inside the python framework
                dochome = os.path.join(sys.prefix,
                        'Resources/English.lproj/Documentation/index.html')
85 86 87
            dochome = os.path.normpath(dochome)
            if os.path.isfile(dochome):
                EditorWindow.help_url = dochome
88 89 90
                if sys.platform == 'darwin':
                    # Safari requires real file:-URLs
                    EditorWindow.help_url = 'file://' + EditorWindow.help_url
91
            else:
92
                EditorWindow.help_url = "http://docs.python.org/%d.%d" % sys.version_info[:2]
93
        currentTheme=idleConf.CurrentTheme()
David Scherer's avatar
David Scherer committed
94 95 96
        self.flist = flist
        root = root or flist.root
        self.root = root
97 98 99 100
        try:
            sys.ps1
        except AttributeError:
            sys.ps1 = '>>> '
David Scherer's avatar
David Scherer committed
101
        self.menubar = Menu(root)
102
        self.top = top = WindowList.ListedToplevel(root, menu=self.menubar)
103
        if flist:
104
            self.tkinter_vars = flist.vars
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
105
            #self.top.instance_dict makes flist.inversedict avalable to
106
            #configDialog.py so it can access all EditorWindow instaces
107
            self.top.instance_dict = flist.inversedict
108 109 110
        else:
            self.tkinter_vars = {}  # keys: Tkinter event names
                                    # values: Tkinter variable instances
111 112
            self.top.instance_dict = {}
        self.recent_files_path = os.path.join(idleConf.GetUserCfgDir(),
113
                'recent-files.lst')
David Scherer's avatar
David Scherer committed
114
        self.text_frame = text_frame = Frame(top)
115
        self.vbar = vbar = Scrollbar(text_frame, name='vbar')
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
116
        self.width = idleConf.GetOption('main','EditorWindow','width')
117 118 119 120 121 122 123 124 125 126 127 128
        text_options = {
                'name': 'text',
                'padx': 5,
                'wrap': 'none',
                'width': self.width,
                'height': idleConf.GetOption('main', 'EditorWindow', 'height')}
        if TkVersion >= 8.5:
            # Starting with tk 8.5 we have to set the new tabstyle option
            # to 'wordprocessor' to achieve the same display of tabs as in
            # older tk versions.
            text_options['tabstyle'] = 'wordprocessor'
        self.text = text = MultiCallCreator(Text)(text_frame, **text_options)
129
        self.top.focused_widget = self.text
David Scherer's avatar
David Scherer committed
130 131 132 133 134 135

        self.createmenubar()
        self.apply_bindings()

        self.top.protocol("WM_DELETE_WINDOW", self.close)
        self.top.bind("<<close-window>>", self.close_event)
136 137
        if macosxSupport.runningAsOSXApp():
            # Command-W on editorwindows doesn't work without this.
138
            text.bind('<<close-window>>', self.close_event)
139 140 141 142 143 144 145 146
            # 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)
147 148 149
        text.bind("<<cut>>", self.cut)
        text.bind("<<copy>>", self.copy)
        text.bind("<<paste>>", self.paste)
David Scherer's avatar
David Scherer committed
150 151 152 153
        text.bind("<<center-insert>>", self.center_insert_event)
        text.bind("<<help>>", self.help_dialog)
        text.bind("<<python-docs>>", self.python_docs)
        text.bind("<<about-idle>>", self.about_dialog)
154
        text.bind("<<open-config-dialog>>", self.config_dialog)
David Scherer's avatar
David Scherer committed
155 156 157 158
        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)
159 160 161 162 163 164
        text.bind("<<find>>", self.find_event)
        text.bind("<<find-again>>", self.find_again_event)
        text.bind("<<find-in-files>>", self.find_in_files_event)
        text.bind("<<find-selection>>", self.find_selection_event)
        text.bind("<<replace>>", self.replace_event)
        text.bind("<<goto-line>>", self.goto_line_event)
165 166 167 168 169 170 171 172 173 174 175
        text.bind("<<smart-backspace>>",self.smart_backspace_event)
        text.bind("<<newline-and-indent>>",self.newline_and_indent_event)
        text.bind("<<smart-indent>>",self.smart_indent_event)
        text.bind("<<indent-region>>",self.indent_region_event)
        text.bind("<<dedent-region>>",self.dedent_region_event)
        text.bind("<<comment-region>>",self.comment_region_event)
        text.bind("<<uncomment-region>>",self.uncomment_region_event)
        text.bind("<<tabify-region>>",self.tabify_region_event)
        text.bind("<<untabify-region>>",self.untabify_region_event)
        text.bind("<<toggle-tabs>>",self.toggle_tabs_event)
        text.bind("<<change-indentwidth>>",self.change_indentwidth_event)
176 177
        text.bind("<Left>", self.move_at_edge_if_selection(0))
        text.bind("<Right>", self.move_at_edge_if_selection(1))
178 179
        text.bind("<<del-word-left>>", self.del_word_left)
        text.bind("<<del-word-right>>", self.del_word_right)
180
        text.bind("<<beginning-of-line>>", self.home_callback)
181

David Scherer's avatar
David Scherer committed
182 183 184 185
        if flist:
            flist.inversedict[self] = key
            if key:
                flist.dict[key] = self
186
            text.bind("<<open-new-window>>", self.new_callback)
David Scherer's avatar
David Scherer committed
187 188 189 190
            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)

191
        self.set_status_bar()
David Scherer's avatar
David Scherer committed
192 193 194
        vbar['command'] = text.yview
        vbar.pack(side=RIGHT, fill=Y)
        text['yscrollcommand'] = vbar.set
195 196
        fontWeight = 'normal'
        if idleConf.GetOption('main', 'EditorWindow', 'font-bold', type='bool'):
197
            fontWeight='bold'
198 199 200
        text.config(font=(idleConf.GetOption('main', 'EditorWindow', 'font'),
                          idleConf.GetOption('main', 'EditorWindow', 'font-size'),
                          fontWeight))
David Scherer's avatar
David Scherer committed
201 202 203 204
        text_frame.pack(side=LEFT, fill=BOTH, expand=1)
        text.pack(side=TOP, fill=BOTH, expand=1)
        text.focus_set()

Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
205 206 207 208 209 210
        # usetabs true  -> literal tab characters are used by indent and
        #                  dedent cmds, possibly mixed with spaces if
        #                  indentwidth is not a multiple of tabwidth,
        #                  which will cause Tabnanny to nag!
        #         false -> tab characters are converted to spaces by indent
        #                  and dedent cmds, and ditto TAB keystrokes
211 212 213 214 215
        # Although use-spaces=0 can be configured manually in config-main.def,
        # configuration of tabs v. spaces is not supported in the configuration
        # dialog.  IDLE promotes the preferred Python indentation: use spaces!
        usespaces = idleConf.GetOption('main', 'Indent', 'use-spaces', type='bool')
        self.usetabs = not usespaces
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
216 217 218 219 220 221

        # tabwidth is the display width of a literal tab character.
        # CAUTION:  telling Tk to use anything other than its default
        # tab setting causes it to use an entirely different tabbing algorithm,
        # treating tab stops as fixed distances from the left margin.
        # Nobody expects this, so for now tabwidth should never be changed.
222 223 224 225 226 227
        self.tabwidth = 8    # must remain 8 until Tk is fixed.

        # indentwidth is the number of screen characters per indent level.
        # The recommended Python indentation is four spaces.
        self.indentwidth = self.tabwidth
        self.set_notabs_indentwidth()
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
228 229 230 231 232 233 234 235 236 237 238 239 240

        # If context_use_ps1 is true, parsing searches back for a ps1 line;
        # else searches for a popular (if, def, ...) Python stmt.
        self.context_use_ps1 = False

        # When searching backwards for a reliable place to begin parsing,
        # first start num_context_lines[0] lines back, then
        # num_context_lines[1] lines back if that didn't work, and so on.
        # The last value should be huge (larger than the # of lines in a
        # conceivable file).
        # Making the initial values larger slows things down more often.
        self.num_context_lines = 50, 500, 5000000

David Scherer's avatar
David Scherer committed
241
        self.per = per = self.Percolator(text)
242 243 244 245 246 247 248 249

        self.undo = undo = self.UndoDelegator()
        per.insertfilter(undo)
        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)

        # IOBinding implements file I/O and printing functionality
David Scherer's avatar
David Scherer committed
250
        self.io = io = self.IOBinding(self)
251 252
        io.set_filename_change_hook(self.filename_change_hook)

Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
253 254 255 256 257 258
        # Create the recent files submenu
        self.recent_files_menu = Menu(self.menubar)
        self.menudict['file'].insert_cascade(3, label='Recent Files',
                                             underline=0,
                                             menu=self.recent_files_menu)
        self.update_recent_files_list()
David Scherer's avatar
David Scherer committed
259

260
        self.color = None # initialized below in self.ResetColorizer
David Scherer's avatar
David Scherer committed
261
        if filename:
262
            if os.path.exists(filename) and not os.path.isdir(filename):
David Scherer's avatar
David Scherer committed
263 264 265
                io.loadfile(filename)
            else:
                io.set_filename(filename)
266
        self.ResetColorizer()
David Scherer's avatar
David Scherer committed
267 268
        self.saved_change_hook()

Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
269 270
        self.set_indentation_params(self.ispythonsource(filename))

David Scherer's avatar
David Scherer committed
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
        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

289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
    def _filename_to_unicode(self, filename):
        """convert filename to unicode in order to display it in Tk"""
        if isinstance(filename, unicode) or not filename:
            return filename
        else:
            try:
                return filename.decode(self.filesystemencoding)
            except UnicodeDecodeError:
                # XXX
                try:
                    return filename.decode(self.encoding)
                except UnicodeDecodeError:
                    # byte-to-byte conversion
                    return filename.decode('iso8859-1')

304 305 306 307 308
    def new_callback(self, event):
        dirname, basename = self.io.defaultfilename()
        self.flist.new(dirname)
        return "break"

309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
    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 self.text.index("iomark") and \
           self.text.compare("iomark", "<=", "insert lineend") and \
           self.text.compare("insert linestart", "<=", "iomark"):
            insertpt = int(self.text.index("iomark").split(".")[1])
        else:
            line = self.text.get("insert linestart", "insert lineend")
            for insertpt in xrange(len(line)):
                if line[insertpt] not in (' ','\t'):
                    break
            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
            self.text.tag_remove("sel", "1.0", "end")
        else:
            if not self.text.index("sel.first"):
                self.text.mark_set("anchor","insert")

            first = self.text.index(dest)
            last = self.text.index("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")
        return "break"

David Scherer's avatar
David Scherer committed
353
    def set_status_bar(self):
354
        self.status_bar = self.MultiStatusBar(self.top)
355 356 357 358
        if macosxSupport.runningAsOSXApp():
            # Insert some padding to avoid obscuring some of the statusbar
            # by the resize widget.
            self.status_bar.set_label('_padding1', '    ', side=RIGHT)
David Scherer's avatar
David Scherer committed
359 360 361
        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)
362 363 364
        self.text.bind("<<set-line-and-column>>", self.set_line_and_column)
        self.text.event_add("<<set-line-and-column>>",
                            "<KeyRelease>", "<ButtonRelease>")
David Scherer's avatar
David Scherer committed
365 366 367
        self.text.after_idle(self.set_line_and_column)

    def set_line_and_column(self, event=None):
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
368
        line, column = self.text.index(INSERT).split('.')
David Scherer's avatar
David Scherer committed
369 370 371 372 373 374 375 376
        self.status_bar.set_label('column', 'Col: %s' % column)
        self.status_bar.set_label('line', 'Ln: %s' % line)

    menu_specs = [
        ("file", "_File"),
        ("edit", "_Edit"),
        ("format", "F_ormat"),
        ("run", "_Run"),
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
377
        ("options", "_Options"),
David Scherer's avatar
David Scherer committed
378 379 380 381
        ("windows", "_Windows"),
        ("help", "_Help"),
    ]

382 383 384 385 386
    if macosxSupport.runningAsOSXApp():
        del menu_specs[-3]
        menu_specs[-2] = ("windows", "_Window")


David Scherer's avatar
David Scherer committed
387 388 389 390 391 392 393
    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)
394

395
        if macosxSupport.runningAsOSXApp():
396 397 398 399
            # Insert the application menu
            menudict['application'] = menu = Menu(mbar, name='apple')
            mbar.add_cascade(label='IDLE', menu=menu)

David Scherer's avatar
David Scherer committed
400
        self.fill_menus()
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
401 402
        self.base_helpmenu_length = self.menudict['help'].index(END)
        self.reset_help_menu_entries()
David Scherer's avatar
David Scherer committed
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443

    def postwindowsmenu(self):
        # Only called when Windows menu exists
        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):
444
        aboutDialog.AboutDialog(self.top,'About IDLE')
445

446 447
    def config_dialog(self, event=None):
        configDialog.ConfigDialog(self.top,'Settings')
448

David Scherer's avatar
David Scherer committed
449
    def help_dialog(self, event=None):
450
        fn=os.path.join(os.path.abspath(os.path.dirname(__file__)),'help.txt')
451
        textView.view_file(self.top,'Help',fn)
452

453
    def python_docs(self, event=None):
454
        if sys.platform[:3] == 'win':
455
            os.startfile(self.help_url)
456 457
        else:
            webbrowser.open(self.help_url)
458
        return "break"
David Scherer's avatar
David Scherer committed
459

460 461 462 463 464
    def cut(self,event):
        self.text.event_generate("<<Cut>>")
        return "break"

    def copy(self,event):
465 466 467
        if not self.text.tag_ranges("sel"):
            # There is no selection, so do nothing and maybe interrupt.
            return
468 469 470 471 472
        self.text.event_generate("<<Copy>>")
        return "break"

    def paste(self,event):
        self.text.event_generate("<<Paste>>")
473
        self.text.see("insert")
474 475
        return "break"

David Scherer's avatar
David Scherer committed
476 477 478 479 480 481 482 483 484 485
    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")

486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
    def move_at_edge_if_selection(self, edge_index):
        """Cursor move begins at start or end of selection

        When a left/right cursor key is pressed create and return to Tkinter a
        function which causes a cursor move from the associated edge of the
        selection.

        """
        self_text_index = self.text.index
        self_text_mark_set = self.text.mark_set
        edges_table = ("sel.first+1c", "sel.last-1c")
        def move_at_edge(event):
            if (event.state & 5) == 0: # no shift(==1) or control(==4) pressed
                try:
                    self_text_index("sel.first")
                    self_text_mark_set("insert", edges_table[edge_index])
                except TclError:
                    pass
        return move_at_edge

506 507 508 509 510 511 512 513
    def del_word_left(self, event):
        self.text.event_generate('<Meta-Delete>')
        return "break"

    def del_word_right(self, event):
        self.text.event_generate('<Meta-d>')
        return "break"

514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
    def find_event(self, event):
        SearchDialog.find(self.text)
        return "break"

    def find_again_event(self, event):
        SearchDialog.find_again(self.text)
        return "break"

    def find_selection_event(self, event):
        SearchDialog.find_selection(self.text)
        return "break"

    def find_in_files_event(self, event):
        GrepDialog.grep(self.text, self.io, self.flist)
        return "break"

    def replace_event(self, event):
        ReplaceDialog.replace(self.text)
        return "break"

    def goto_line_event(self, event):
        text = self.text
        lineno = tkSimpleDialog.askinteger("Goto",
                "Go to line number:",parent=text)
        if lineno is None:
            return "break"
        if lineno <= 0:
            text.bell()
            return "break"
        text.mark_set("insert", "%d.0" % lineno)
        text.see("insert")

David Scherer's avatar
David Scherer committed
546 547 548 549 550 551 552
    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:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
553
            name = name.strip()
554 555 556 557 558 559
        name = tkSimpleDialog.askstring("Module",
                 "Enter the name of a Python module\n"
                 "to search on sys.path and open:",
                 parent=self.text, initialvalue=name)
        if name:
            name = name.strip()
David Scherer's avatar
David Scherer committed
560
        if not name:
561
            return
David Scherer's avatar
David Scherer committed
562 563
        # XXX Ought to insert current file's directory in front of path
        try:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
564
            (f, file, (suffix, mode, type)) = _find_module(name)
David Scherer's avatar
David Scherer committed
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
        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)
590
        from idlelib import ClassBrowser
David Scherer's avatar
David Scherer committed
591 592 593
        ClassBrowser.ClassBrowser(self.flist, base, [head])

    def open_path_browser(self, event=None):
594
        from idlelib import PathBrowser
David Scherer's avatar
David Scherer committed
595 596 597 598 599 600 601 602 603 604
        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):
605
        if not filename or os.path.isdir(filename):
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
606
            return True
David Scherer's avatar
David Scherer committed
607 608
        base, ext = os.path.splitext(os.path.basename(filename))
        if os.path.normcase(ext) in (".py", ".pyw"):
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
609
            return True
David Scherer's avatar
David Scherer committed
610 611 612 613 614
        try:
            f = open(filename)
            line = f.readline()
            f.close()
        except IOError:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
615
            return False
616
        return line.startswith('#!') and line.find('python') >= 0
David Scherer's avatar
David Scherer committed
617 618 619

    def close_hook(self):
        if self.flist:
620 621
            self.flist.unregister_maybe_terminate(self)
            self.flist = None
David Scherer's avatar
David Scherer committed
622 623 624 625 626 627 628 629

    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()
630
        self.top.update_windowlist_registry(self)
631
        self.ResetColorizer()
David Scherer's avatar
David Scherer committed
632

633
    def _addcolorizer(self):
David Scherer's avatar
David Scherer committed
634 635
        if self.color:
            return
636 637 638 639 640 641 642
        if self.ispythonsource(self.io.filename):
            self.color = self.ColorDelegator()
        # can add more colorizers here...
        if self.color:
            self.per.removefilter(self.undo)
            self.per.insertfilter(self.color)
            self.per.insertfilter(self.undo)
David Scherer's avatar
David Scherer committed
643

644
    def _rmcolorizer(self):
David Scherer's avatar
David Scherer committed
645 646
        if not self.color:
            return
647
        self.color.removecolors()
David Scherer's avatar
David Scherer committed
648 649
        self.per.removefilter(self.color)
        self.color = None
650

651
    def ResetColorizer(self):
652 653 654 655
        "Update the colour theme"
        # Called from self.filename_change_hook and from configDialog.py
        self._rmcolorizer()
        self._addcolorizer()
656
        theme = idleConf.GetOption('main','Theme','name')
657 658 659 660 661 662 663 664 665 666
        normal_colors = idleConf.GetHighlight(theme, 'normal')
        cursor_color = idleConf.GetHighlight(theme, 'cursor', fgBg='fg')
        select_colors = idleConf.GetHighlight(theme, 'hilite')
        self.text.config(
            foreground=normal_colors['foreground'],
            background=normal_colors['background'],
            insertbackground=cursor_color,
            selectforeground=select_colors['foreground'],
            selectbackground=select_colors['background'],
            )
David Scherer's avatar
David Scherer committed
667

668
    def ResetFont(self):
669
        "Update the text widgets' font if it is changed"
670
        # Called from configDialog.py
671 672 673 674 675 676 677
        fontWeight='normal'
        if idleConf.GetOption('main','EditorWindow','font-bold',type='bool'):
            fontWeight='bold'
        self.text.config(font=(idleConf.GetOption('main','EditorWindow','font'),
                idleConf.GetOption('main','EditorWindow','font-size'),
                fontWeight))

678 679
    def RemoveKeybindings(self):
        "Remove the keybindings before they are changed."
680
        # Called from configDialog.py
681
        self.Bindings.default_keydefs = keydefs = idleConf.GetCurrentKeySet()
682
        for event, keylist in keydefs.items():
683 684
            self.text.event_delete(event, *keylist)
        for extensionName in self.get_standard_extension_names():
685 686 687
            xkeydefs = idleConf.GetExtensionBindings(extensionName)
            if xkeydefs:
                for event, keylist in xkeydefs.items():
688 689 690 691 692
                    self.text.event_delete(event, *keylist)

    def ApplyKeybindings(self):
        "Update the keybindings after they are changed"
        # Called from configDialog.py
693
        self.Bindings.default_keydefs = keydefs = idleConf.GetCurrentKeySet()
694
        self.apply_bindings()
695
        for extensionName in self.get_standard_extension_names():
696 697 698
            xkeydefs = idleConf.GetExtensionBindings(extensionName)
            if xkeydefs:
                self.apply_bindings(xkeydefs)
699
        #update menu accelerators
700
        menuEventDict = {}
701
        for menu in self.Bindings.menudefs:
702
            menuEventDict[menu[0]] = {}
703 704
            for item in menu[1]:
                if item:
705
                    menuEventDict[menu[0]][prepstr(item[0])[1]] = item[1]
706
        for menubarItem in self.menudict.keys():
707 708 709 710 711
            menu = self.menudict[menubarItem]
            end = menu.index(END) + 1
            for index in range(0, end):
                if menu.type(index) == 'command':
                    accel = menu.entrycget(index, 'accelerator')
712
                    if accel:
713 714
                        itemName = menu.entrycget(index, 'label')
                        event = ''
715 716
                        if menubarItem in menuEventDict:
                            if itemName in menuEventDict[menubarItem]:
717
                                event = menuEventDict[menubarItem][itemName]
718
                        if event:
719 720
                            accel = get_accelerator(keydefs, event)
                            menu.entryconfig(index, accelerator=accel)
721

722 723 724 725 726 727 728
    def set_notabs_indentwidth(self):
        "Update the indentwidth if changed and not using tabs in this window"
        # Called from configDialog.py
        if not self.usetabs:
            self.indentwidth = idleConf.GetOption('main', 'Indent','num-spaces',
                                                  type='int')

Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
    def reset_help_menu_entries(self):
        "Update the additional help entries on the Help menu"
        help_list = idleConf.GetAllExtraHelpSourcesList()
        helpmenu = self.menudict['help']
        # first delete the extra help entries, if any
        helpmenu_length = helpmenu.index(END)
        if helpmenu_length > self.base_helpmenu_length:
            helpmenu.delete((self.base_helpmenu_length + 1), helpmenu_length)
        # then rebuild them
        if help_list:
            helpmenu.add_separator()
            for entry in help_list:
                cmd = self.__extra_help_callback(entry[1])
                helpmenu.add_command(label=entry[0], command=cmd)
        # and update the menu dictionary
        self.menudict['help'] = helpmenu

    def __extra_help_callback(self, helpfile):
        "Create a callback with the helpfile value frozen at definition time"
        def display_extra_help(helpfile=helpfile):
749
            if not helpfile.startswith(('www', 'http')):
750 751 752 753 754
                url = os.path.normpath(helpfile)
            if sys.platform[:3] == 'win':
                os.startfile(helpfile)
            else:
                webbrowser.open(helpfile)
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
755
        return display_extra_help
756

Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
757 758 759 760 761
    def update_recent_files_list(self, new_file=None):
        "Load and update the recent files list and menus"
        rf_list = []
        if os.path.exists(self.recent_files_path):
            rf_list_file = open(self.recent_files_path,'r')
762
            try:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
763
                rf_list = rf_list_file.readlines()
764
            finally:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
                rf_list_file.close()
        if new_file:
            new_file = os.path.abspath(new_file) + '\n'
            if new_file in rf_list:
                rf_list.remove(new_file)  # move to top
            rf_list.insert(0, new_file)
        # clean and save the recent files list
        bad_paths = []
        for path in rf_list:
            if '\0' in path or not os.path.exists(path[0:-1]):
                bad_paths.append(path)
        rf_list = [path for path in rf_list if path not in bad_paths]
        ulchars = "1234567890ABCDEFGHIJK"
        rf_list = rf_list[0:len(ulchars)]
        rf_file = open(self.recent_files_path, 'w')
780
        try:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
781
            rf_file.writelines(rf_list)
782
        finally:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
783 784 785 786 787
            rf_file.close()
        # 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:
788 789
            for i, file_name in enumerate(rf_list):
                file_name = file_name.rstrip()  # zap \n
790 791
                # make unicode string to display non-ASCII chars correctly
                ufile_name = self._filename_to_unicode(file_name)
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
792
                callback = instance.__recent_file_callback(file_name)
793
                menu.add_command(label=ulchars[i] + " " + ufile_name,
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
794 795 796 797 798 799 800
                                 command=callback,
                                 underline=0)

    def __recent_file_callback(self, file_name):
        def open_recent_file(fn_closure=file_name):
            self.io.open(editFile=fn_closure)
        return open_recent_file
801

David Scherer's avatar
David Scherer committed
802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
    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)
833 834
        # return unicode string to display non-ASCII chars correctly
        return self._filename_to_unicode(filename)
David Scherer's avatar
David Scherer committed
835 836

    def long_title(self):
837 838
        # return unicode string to display non-ASCII chars correctly
        return self._filename_to_unicode(self.io.filename or "")
David Scherer's avatar
David Scherer committed
839 840 841 842 843 844 845 846 847

    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
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
848
        newtop = max(1, lineno - height//2)
David Scherer's avatar
David Scherer committed
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864
        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)))

Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
865 866 867 868 869 870 871
    def get_geometry(self):
        "Return (width, height, x, y)"
        geom = self.top.wm_geometry()
        m = re.match(r"(\d+)x(\d+)\+(-?\d+)\+(-?\d+)", geom)
        tuple = (map(int, m.groups()))
        return tuple

David Scherer's avatar
David Scherer committed
872 873 874 875 876
    def close_event(self, event):
        self.close()

    def maybesave(self):
        if self.io:
877
            if not self.get_saved():
878
                if self.top.state()!='normal':
879 880 881
                    self.top.deiconify()
                self.top.lower()
                self.top.lift()
David Scherer's avatar
David Scherer committed
882 883 884 885
            return self.io.maybesave()

    def close(self):
        reply = self.maybesave()
886
        if str(reply) != "cancel":
David Scherer's avatar
David Scherer committed
887 888 889 890
            self._close()
        return reply

    def _close(self):
891
        if self.io.filename:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
892
            self.update_recent_files_list(new_file=self.io.filename)
David Scherer's avatar
David Scherer committed
893 894
        WindowList.unregister_callback(self.postwindowsmenu)
        self.unload_extensions()
895 896 897
        self.io.close()
        self.io = None
        self.undo = None
David Scherer's avatar
David Scherer committed
898
        if self.color:
899 900
            self.color.close(False)
            self.color = None
David Scherer's avatar
David Scherer committed
901
        self.text = None
902
        self.tkinter_vars = None
903 904 905 906 907 908
        self.per.close()
        self.per = None
        self.top.destroy()
        if self.close_hook:
            # unless override: unregister from flist, terminate if last window
            self.close_hook()
David Scherer's avatar
David Scherer committed
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924

    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:
925
                print "Failed to load extension", repr(name)
David Scherer's avatar
David Scherer committed
926 927 928 929
                import traceback
                traceback.print_exc()

    def get_standard_extension_names(self):
930
        return idleConf.GetExtensions(editor_only=True)
David Scherer's avatar
David Scherer committed
931 932

    def load_extension(self, name):
933 934 935 936 937
        try:
            mod = __import__(name, globals(), locals(), [])
        except ImportError:
            print "\nFailed to import extension: ", name
            return
David Scherer's avatar
David Scherer committed
938
        cls = getattr(mod, name)
939 940 941
        keydefs = idleConf.GetExtensionBindings(name)
        if hasattr(cls, "menudefs"):
            self.fill_menus(cls.menudefs, keydefs)
David Scherer's avatar
David Scherer committed
942 943 944 945 946
        ins = cls(self)
        self.extensions[name] = ins
        if keydefs:
            self.apply_bindings(keydefs)
            for vevent in keydefs.keys():
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
947
                methodname = vevent.replace("-", "_")
David Scherer's avatar
David Scherer committed
948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
                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))

    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:
963
                text.event_add(event, *keylist)
David Scherer's avatar
David Scherer committed
964

965
    def fill_menus(self, menudefs=None, keydefs=None):
966 967 968 969
        """Add appropriate entries to the menus and submenus

        Menus that are absent or None in self.menudict are ignored.
        """
970 971
        if menudefs is None:
            menudefs = self.Bindings.menudefs
David Scherer's avatar
David Scherer committed
972 973 974 975
        if keydefs is None:
            keydefs = self.Bindings.default_keydefs
        menudict = self.menudict
        text = self.text
976
        for mname, entrylist in menudefs:
David Scherer's avatar
David Scherer committed
977 978 979
            menu = menudict.get(mname)
            if not menu:
                continue
980 981
            for entry in entrylist:
                if not entry:
David Scherer's avatar
David Scherer committed
982 983
                    menu.add_separator()
                else:
984
                    label, eventname = entry
David Scherer's avatar
David Scherer committed
985 986 987 988
                    checkbutton = (label[:1] == '!')
                    if checkbutton:
                        label = label[1:]
                    underline, label = prepstr(label)
989 990 991
                    accelerator = get_accelerator(keydefs, eventname)
                    def command(text=text, eventname=eventname):
                        text.event_generate(eventname)
David Scherer's avatar
David Scherer committed
992
                    if checkbutton:
993
                        var = self.get_var_obj(eventname, BooleanVar)
David Scherer's avatar
David Scherer committed
994 995 996 997 998
                        menu.add_checkbutton(label=label, underline=underline,
                            command=command, accelerator=accelerator,
                            variable=var)
                    else:
                        menu.add_command(label=label, underline=underline,
999 1000
                                         command=command,
                                         accelerator=accelerator)
David Scherer's avatar
David Scherer committed
1001 1002

    def getvar(self, name):
1003
        var = self.get_var_obj(name)
David Scherer's avatar
David Scherer committed
1004
        if var:
1005 1006 1007 1008
            value = var.get()
            return value
        else:
            raise NameError, name
David Scherer's avatar
David Scherer committed
1009 1010

    def setvar(self, name, value, vartype=None):
1011
        var = self.get_var_obj(name, vartype)
David Scherer's avatar
David Scherer committed
1012 1013
        if var:
            var.set(value)
1014 1015
        else:
            raise NameError, name
David Scherer's avatar
David Scherer committed
1016

1017 1018
    def get_var_obj(self, name, vartype=None):
        var = self.tkinter_vars.get(name)
David Scherer's avatar
David Scherer committed
1019
        if not var and vartype:
1020 1021
            # create a Tkinter variable object with self.text as master:
            self.tkinter_vars[name] = var = vartype(self.text)
David Scherer's avatar
David Scherer committed
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
        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,
1067
                                  "n" * newtabwidth)
David Scherer's avatar
David Scherer committed
1068 1069
            text.configure(tabs=pixels)

1070 1071 1072 1073 1074 1075
    # If ispythonsource and guess are true, guess a good value for
    # indentwidth based on file content (if possible), and if
    # indentwidth != tabwidth set usetabs false.
    # In any case, adjust the Text widget's view of what a tab
    # character means.

Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1076
    def set_indentation_params(self, ispythonsource, guess=True):
1077 1078 1079 1080 1081
        if guess and ispythonsource:
            i = self.guess_indent()
            if 2 <= i <= 8:
                self.indentwidth = i
            if self.indentwidth != self.tabwidth:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1082
                self.usetabs = False
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
        self.set_tabwidth(self.tabwidth)

    def smart_backspace_event(self, event):
        text = self.text
        first, last = self.get_selection_indices()
        if first and last:
            text.delete(first, last)
            text.mark_set("insert", first)
            return "break"
        # Delete whitespace left, until hitting a real char or closest
        # preceding virtual tab stop.
        chars = text.get("insert linestart", "insert")
        if chars == '':
            if text.compare("insert", ">", "1.0"):
                # easy: delete preceding newline
                text.delete("insert-1c")
            else:
                text.bell()     # at start of buffer
            return "break"
        if  chars[-1] not in " \t":
            # easy: delete preceding real char
            text.delete("insert-1c")
            return "break"
        # Ick.  It may require *inserting* spaces if we back up over a
        # tab character!  This is written to be clear, not fast.
1108 1109
        tabwidth = self.tabwidth
        have = len(chars.expandtabs(tabwidth))
1110 1111
        assert have > 0
        want = ((have - 1) // self.indentwidth) * self.indentwidth
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1112 1113
        # Debug prompt is multilined....
        last_line_of_prompt = sys.ps1.split('\n')[-1]
1114 1115
        ncharsdeleted = 0
        while 1:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1116
            if chars == last_line_of_prompt:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1117
                break
1118 1119
            chars = chars[:-1]
            ncharsdeleted = ncharsdeleted + 1
1120
            have = len(chars.expandtabs(tabwidth))
1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
            if have <= want or chars[-1] not in " \t":
                break
        text.undo_block_start()
        text.delete("insert-%dc" % ncharsdeleted, "insert")
        if have < want:
            text.insert("insert", ' ' * (want - have))
        text.undo_block_stop()
        return "break"

    def smart_indent_event(self, event):
        # if intraline selection:
        #     delete it
        # elif multiline selection:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1134 1135 1136
        #     do indent-region
        # else:
        #     indent one level
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
        text = self.text
        first, last = self.get_selection_indices()
        text.undo_block_start()
        try:
            if first and last:
                if index2line(first) != index2line(last):
                    return self.indent_region_event(event)
                text.delete(first, last)
                text.mark_set("insert", first)
            prefix = text.get("insert linestart", "insert")
            raw, effective = classifyws(prefix, self.tabwidth)
            if raw == len(prefix):
                # only whitespace to the left
                self.reindent_to(effective + self.indentwidth)
            else:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1152
                # tab to the next 'stop' within or to right of line's text:
1153 1154 1155
                if self.usetabs:
                    pad = '\t'
                else:
1156
                    effective = len(prefix.expandtabs(self.tabwidth))
1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177
                    n = self.indentwidth
                    pad = ' ' * (n - effective % n)
                text.insert("insert", pad)
            text.see("insert")
            return "break"
        finally:
            text.undo_block_stop()

    def newline_and_indent_event(self, event):
        text = self.text
        first, last = self.get_selection_indices()
        text.undo_block_start()
        try:
            if first and last:
                text.delete(first, last)
                text.mark_set("insert", first)
            line = text.get("insert linestart", "insert")
            i, n = 0, len(line)
            while i < n and line[i] in " \t":
                i = i+1
            if i == n:
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1178 1179
                # the cursor is in or at leading indentation in a continuation
                # line; just inject an empty line at the start
1180 1181 1182
                text.insert("insert linestart", '\n')
                return "break"
            indent = line[:i]
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1183
            # strip whitespace before insert point unless it's in the prompt
1184
            i = 0
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1185 1186
            last_line_of_prompt = sys.ps1.split('\n')[-1]
            while line and line[-1] in " \t" and line != last_line_of_prompt:
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
                line = line[:-1]
                i = i+1
            if i:
                text.delete("insert - %d chars" % i, "insert")
            # strip whitespace after insert point
            while text.get("insert") in " \t":
                text.delete("insert")
            # start new line
            text.insert("insert", '\n')

            # adjust indentation for continuations and block
            # open/close first need to find the last stmt
            lno = index2line(text.index('insert'))
            y = PyParse.Parser(self.indentwidth, self.tabwidth)
1201 1202 1203
            if not self.context_use_ps1:
                for context in self.num_context_lines:
                    startat = max(lno - context, 1)
1204
                    startatindex = repr(startat) + ".0"
1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
                    rawtext = text.get(startatindex, "insert")
                    y.set_str(rawtext)
                    bod = y.find_good_parse_start(
                              self.context_use_ps1,
                              self._build_char_in_string_func(startatindex))
                    if bod is not None or startat == 1:
                        break
                y.set_lo(bod or 0)
            else:
                r = text.tag_prevrange("console", "insert")
                if r:
                    startatindex = r[1]
                else:
                    startatindex = "1.0"
1219 1220
                rawtext = text.get(startatindex, "insert")
                y.set_str(rawtext)
1221 1222
                y.set_lo(0)

1223 1224 1225
            c = y.get_continuation_type()
            if c != PyParse.C_NONE:
                # The current stmt hasn't ended yet.
1226 1227 1228 1229 1230 1231
                if c == PyParse.C_STRING_FIRST_LINE:
                    # after the first line of a string; do not indent at all
                    pass
                elif c == PyParse.C_STRING_NEXT_LINES:
                    # inside a string which started before this line;
                    # just mimic the current indent
1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
                    text.insert("insert", indent)
                elif c == PyParse.C_BRACKET:
                    # line up with the first (if any) element of the
                    # last open bracket structure; else indent one
                    # level beyond the indent of the line with the
                    # last open bracket
                    self.reindent_to(y.compute_bracket_indent())
                elif c == PyParse.C_BACKSLASH:
                    # if more than one line in this stmt already, just
                    # mimic the current indent; else if initial line
                    # has a start on an assignment stmt, indent to
                    # beyond leftmost =; else to beyond first chunk of
                    # non-whitespace on initial line
                    if y.get_num_lines_in_stmt() > 1:
                        text.insert("insert", indent)
                    else:
                        self.reindent_to(y.compute_backslash_indent())
                else:
1250
                    assert 0, "bogus continuation type %r" % (c,)
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
                return "break"

            # This line starts a brand new stmt; indent relative to
            # indentation of initial line of closest preceding
            # interesting stmt.
            indent = y.get_base_indent_string()
            text.insert("insert", indent)
            if y.is_block_opener():
                self.smart_indent_event(event)
            elif indent and y.is_block_closer():
                self.smart_backspace_event(event)
            return "break"
        finally:
            text.see("insert")
            text.undo_block_stop()

    # Our editwin provides a is_char_in_string function that works
    # with a Tk text index, but PyParse only knows about offsets into
    # a string. This builds a function for PyParse that accepts an
    # offset.

    def _build_char_in_string_func(self, startindex):
        def inner(offset, _startindex=startindex,
                  _icis=self.is_char_in_string):
            return _icis(_startindex + "+%dc" % offset)
        return inner

    def indent_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        for pos in range(len(lines)):
            line = lines[pos]
            if line:
                raw, effective = classifyws(line, self.tabwidth)
                effective = effective + self.indentwidth
                lines[pos] = self._make_blanks(effective) + line[raw:]
        self.set_region(head, tail, chars, lines)
        return "break"

    def dedent_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        for pos in range(len(lines)):
            line = lines[pos]
            if line:
                raw, effective = classifyws(line, self.tabwidth)
                effective = max(effective - self.indentwidth, 0)
                lines[pos] = self._make_blanks(effective) + line[raw:]
        self.set_region(head, tail, chars, lines)
        return "break"

    def comment_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        for pos in range(len(lines) - 1):
            line = lines[pos]
            lines[pos] = '##' + line
        self.set_region(head, tail, chars, lines)

    def uncomment_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        for pos in range(len(lines)):
            line = lines[pos]
            if not line:
                continue
            if line[:2] == '##':
                line = line[2:]
            elif line[:1] == '#':
                line = line[1:]
            lines[pos] = line
        self.set_region(head, tail, chars, lines)

    def tabify_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        tabwidth = self._asktabwidth()
        for pos in range(len(lines)):
            line = lines[pos]
            if line:
                raw, effective = classifyws(line, tabwidth)
                ntabs, nspaces = divmod(effective, tabwidth)
                lines[pos] = '\t' * ntabs + ' ' * nspaces + line[raw:]
        self.set_region(head, tail, chars, lines)

    def untabify_region_event(self, event):
        head, tail, chars, lines = self.get_region()
        tabwidth = self._asktabwidth()
        for pos in range(len(lines)):
1335
            lines[pos] = lines[pos].expandtabs(tabwidth)
1336 1337 1338 1339 1340
        self.set_region(head, tail, chars, lines)

    def toggle_tabs_event(self, event):
        if self.askyesno(
              "Toggle tabs",
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1341 1342
              "Turn tabs " + ("on", "off")[self.usetabs] +
              "?\nIndent width " +
1343 1344
              ("will be", "remains at")[self.usetabs] + " 8." +
              "\n Note: a tab is always 8 columns",
1345 1346
              parent=self.text):
            self.usetabs = not self.usetabs
1347 1348 1349
            # Try to prevent inconsistent indentation.
            # User must change indent width manually after using tabs.
            self.indentwidth = 8
1350 1351
        return "break"

Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1352 1353 1354 1355 1356 1357 1358
    # XXX this isn't bound to anything -- see tabwidth comments
##     def change_tabwidth_event(self, event):
##         new = self._asktabwidth()
##         if new != self.tabwidth:
##             self.tabwidth = new
##             self.set_indentation_params(0, guess=0)
##         return "break"
1359 1360 1361 1362

    def change_indentwidth_event(self, event):
        new = self.askinteger(
                  "Indent width",
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1363
                  "New indent width (2-16)\n(Always use 8 when using tabs)",
1364 1365 1366 1367
                  parent=self.text,
                  initialvalue=self.indentwidth,
                  minvalue=2,
                  maxvalue=16)
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1368
        if new and new != self.indentwidth and not self.usetabs:
1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
            self.indentwidth = new
        return "break"

    def get_region(self):
        text = self.text
        first, last = self.get_selection_indices()
        if first and last:
            head = text.index(first + " linestart")
            tail = text.index(last + "-1c lineend +1c")
        else:
            head = text.index("insert linestart")
            tail = text.index("insert lineend +1c")
        chars = text.get(head, tail)
1382
        lines = chars.split("\n")
1383 1384 1385 1386
        return head, tail, chars, lines

    def set_region(self, head, tail, chars, lines):
        text = self.text
1387
        newchars = "\n".join(lines)
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422
        if newchars == chars:
            text.bell()
            return
        text.tag_remove("sel", "1.0", "end")
        text.mark_set("insert", head)
        text.undo_block_start()
        text.delete(head, tail)
        text.insert(head, newchars)
        text.undo_block_stop()
        text.tag_add("sel", head, "insert")

    # Make string that displays as n leading blanks.

    def _make_blanks(self, n):
        if self.usetabs:
            ntabs, nspaces = divmod(n, self.tabwidth)
            return '\t' * ntabs + ' ' * nspaces
        else:
            return ' ' * n

    # Delete from beginning of line to insert point, then reinsert
    # column logical (meaning use tabs if appropriate) spaces.

    def reindent_to(self, column):
        text = self.text
        text.undo_block_start()
        if text.compare("insert linestart", "!=", "insert"):
            text.delete("insert linestart", "insert")
        if column:
            text.insert("insert", self._make_blanks(column))
        text.undo_block_stop()

    def _asktabwidth(self):
        return self.askinteger(
            "Tab width",
1423
            "Columns per tab? (2-16)",
1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
            parent=self.text,
            initialvalue=self.indentwidth,
            minvalue=2,
            maxvalue=16) or self.tabwidth

    # Guess indentwidth from text content.
    # Return guessed indentwidth.  This should not be believed unless
    # it's in a reasonable range (e.g., it will be 0 if no indented
    # blocks are found).

    def guess_indent(self):
        opener, indented = IndentSearcher(self.text, self.tabwidth).run()
        if opener and indented:
            raw, indentsmall = classifyws(opener, self.tabwidth)
            raw, indentlarge = classifyws(indented, self.tabwidth)
        else:
            indentsmall = indentlarge = 0
        return indentlarge - indentsmall

# "line.col" -> line, as an int
def index2line(index):
    return int(float(index))

# Look at the leading whitespace in s.
# Return pair (# of leading ws characters,
#              effective # of leading blanks after expanding
#              tabs to width tabwidth)

def classifyws(s, tabwidth):
    raw = effective = 0
    for ch in s:
        if ch == ' ':
            raw = raw + 1
            effective = effective + 1
        elif ch == '\t':
            raw = raw + 1
            effective = (effective // tabwidth + 1) * tabwidth
        else:
            break
    return raw, effective

import tokenize
_tokenize = tokenize
del tokenize

1469
class IndentSearcher(object):
1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485

    # .run() chews over the Text widget, looking for a block opener
    # and the stmt following it.  Returns a pair,
    #     (line containing block opener, line containing stmt)
    # Either or both may be None.

    def __init__(self, text, tabwidth):
        self.text = text
        self.tabwidth = tabwidth
        self.i = self.finished = 0
        self.blkopenline = self.indentedline = None

    def readline(self):
        if self.finished:
            return ""
        i = self.i = self.i + 1
1486
        mark = repr(i) + ".0"
1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
        if self.text.compare(mark, ">=", "end"):
            return ""
        return self.text.get(mark, mark + " lineend+1c")

    def tokeneater(self, type, token, start, end, line,
                   INDENT=_tokenize.INDENT,
                   NAME=_tokenize.NAME,
                   OPENERS=('class', 'def', 'for', 'if', 'try', 'while')):
        if self.finished:
            pass
        elif type == NAME and token in OPENERS:
            self.blkopenline = line
        elif type == INDENT and self.blkopenline:
            self.indentedline = line
            self.finished = 1

    def run(self):
        save_tabsize = _tokenize.tabsize
        _tokenize.tabsize = self.tabwidth
        try:
            try:
                _tokenize.tokenize(self.readline, self.tokeneater)
            except _tokenize.TokenError:
                # since we cut off the tokenizer early, we can trigger
                # spurious errors
                pass
        finally:
            _tokenize.tabsize = save_tabsize
        return self.blkopenline, self.indentedline

### end autoindent code ###

David Scherer's avatar
David Scherer committed
1519 1520 1521
def prepstr(s):
    # Helper to extract the underscore from a string, e.g.
    # prepstr("Co_py") returns (2, "Copy").
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1522
    i = s.find('_')
David Scherer's avatar
David Scherer committed
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
    if i >= 0:
        s = s[:i] + s[i+1:]
    return i, s


keynames = {
 'bracketleft': '[',
 'bracketright': ']',
 'slash': '/',
}

1534 1535
def get_accelerator(keydefs, eventname):
    keylist = keydefs.get(eventname)
David Scherer's avatar
David Scherer committed
1536 1537 1538
    if not keylist:
        return ""
    s = keylist[0]
Kurt B. Kaiser's avatar
Kurt B. Kaiser committed
1539
    s = re.sub(r"-[a-z]\b", lambda m: m.group().upper(), s)
David Scherer's avatar
David Scherer committed
1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
    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)
1570
    edit.text.bind("<<close-all-windows>>", edit.close_event)
David Scherer's avatar
David Scherer committed
1571 1572 1573 1574 1575
    root.mainloop()
    root.destroy()

if __name__ == '__main__':
    test()