1 import sys

     2 import os

     3 import re

     4 import imp

     5 from itertools import count

     6 from Tkinter import *

     7 import tkSimpleDialog

     8 import tkMessageBox

     9 from MultiCall import MultiCallCreator

    10 

    11 import webbrowser

    12 import idlever

    13 import WindowList

    14 import SearchDialog

    15 import GrepDialog

    16 import ReplaceDialog

    17 import PyParse

    18 from configHandler import idleConf

    19 import aboutDialog, textView, configDialog

    20 import macosxSupport

    21 

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

    23 TK_TABWIDTH_DEFAULT = 8

    24 

    25 def _find_module(fullname, path=None):

    26     """Version of imp.find_module() that handles hierarchical module names"""

    27 

    28     file = None

    29     for tgt in fullname.split('.'):

    30         if file is not None:

    31             file.close()            # close intermediate files

    32         (file, filename, descr) = imp.find_module(tgt, path)

    33         if descr[2] == imp.PY_SOURCE:

    34             break                   # find but not load the source file

    35         module = imp.load_module(tgt, file, filename, descr)

    36         try:

    37             path = module.__path__

    38         except AttributeError:

    39             raise ImportError, 'No source for module ' + module.__name__

    40     return file, filename, descr

    41 

    42 class EditorWindow(object):

    43     from Percolator import Percolator

    44     from ColorDelegator import ColorDelegator

    45     from UndoDelegator import UndoDelegator

    46     from IOBinding import IOBinding, filesystemencoding, encoding

    47     import Bindings

    48     from Tkinter import Toplevel

    49     from MultiStatusBar import MultiStatusBar

    50 

    51     help_url = None

    52 

    53     def __init__(self, flist=None, filename=None, key=None, root=None):

    54         if EditorWindow.help_url is None:

    55             dochome =  os.path.join(sys.prefix, 'Doc', 'index.html')

    56             if sys.platform.count('linux'):

    57                 # look for html docs in a couple of standard places

    58                 pyver = 'python-docs-' + '%s.%s.%s' % sys.version_info[:3]

    59                 if os.path.isdir('/var/www/html/python/'):  # "python2" rpm

    60                     dochome = '/var/www/html/python/index.html'

    61                 else:

    62                     basepath = '/usr/share/doc/'  # standard location

    63                     dochome = os.path.join(basepath, pyver,

    64                                            'Doc', 'index.html')

    65             elif sys.platform[:3] == 'win':

    66                 chmfile = os.path.join(sys.prefix, 'Doc',

    67                                        'Python%d%d.chm' % sys.version_info[:2])

    68                 if os.path.isfile(chmfile):

    69                     dochome = chmfile

    70 

    71             elif macosxSupport.runningAsOSXApp():

    72                 # documentation is stored inside the python framework

    73                 dochome = os.path.join(sys.prefix,

    74                         'Resources/English.lproj/Documentation/index.html')

    75 

    76             dochome = os.path.normpath(dochome)

    77             if os.path.isfile(dochome):

    78                 EditorWindow.help_url = dochome

    79                 if sys.platform == 'darwin':

    80                     # Safari requires real file:-URLs

    81                     EditorWindow.help_url = 'file://' + EditorWindow.help_url

    82             else:

    83                 EditorWindow.help_url = "http://www.python.org/doc/current"

    84         currentTheme=idleConf.CurrentTheme()

    85         self.flist = flist

    86         root = root or flist.root

    87         self.root = root

    88         try:

    89             sys.ps1

    90         except AttributeError:

    91             sys.ps1 = '>>> '

    92         self.menubar = Menu(root)

    93         self.top = top = WindowList.ListedToplevel(root, menu=self.menubar)

    94         if flist:

    95             self.tkinter_vars = flist.vars

    96             #self.top.instance_dict makes flist.inversedict avalable to

    97             #configDialog.py so it can access all EditorWindow instaces

    98             self.top.instance_dict = flist.inversedict

    99         else:

   100             self.tkinter_vars = {}  # keys: Tkinter event names

   101                                     # values: Tkinter variable instances

   102             self.top.instance_dict = {}

   103         self.recent_files_path = os.path.join(idleConf.GetUserCfgDir(),

   104                 'recent-files.lst')

   105         self.text_frame = text_frame = Frame(top)

   106         self.vbar = vbar = Scrollbar(text_frame, name='vbar')

   107         self.width = idleConf.GetOption('main','EditorWindow','width')

   108         self.text = text = MultiCallCreator(Text)(

   109                 text_frame, name='text', padx=5, wrap='none',

   110                 width=self.width,

   111                 height=idleConf.GetOption('main','EditorWindow','height') )

   112         self.top.focused_widget = self.text

   113 

   114         self.createmenubar()

   115         self.apply_bindings()

   116 

   117         self.top.protocol("WM_DELETE_WINDOW", self.close)

   118         self.top.bind("<<close-window>>", self.close_event)

   119         if macosxSupport.runningAsOSXApp():

   120             # Command-W on editorwindows doesn't work without this.

   121             text.bind('<<close-window>>', self.close_event)

   122         text.bind("<<cut>>", self.cut)

   123         text.bind("<<copy>>", self.copy)

   124         text.bind("<<paste>>", self.paste)

   125         text.bind("<<center-insert>>", self.center_insert_event)

   126         text.bind("<<help>>", self.help_dialog)

   127         text.bind("<<python-docs>>", self.python_docs)

   128         text.bind("<<about-idle>>", self.about_dialog)

   129         text.bind("<<open-config-dialog>>", self.config_dialog)

   130         text.bind("<<open-module>>", self.open_module)

   131         text.bind("<<do-nothing>>", lambda event: "break")

   132         text.bind("<<select-all>>", self.select_all)

   133         text.bind("<<remove-selection>>", self.remove_selection)

   134         text.bind("<<find>>", self.find_event)

   135         text.bind("<<find-again>>", self.find_again_event)

   136         text.bind("<<find-in-files>>", self.find_in_files_event)

   137         text.bind("<<find-selection>>", self.find_selection_event)

   138         text.bind("<<replace>>", self.replace_event)

   139         text.bind("<<goto-line>>", self.goto_line_event)

   140         text.bind("<3>", self.right_menu_event)

   141         text.bind("<<smart-backspace>>",self.smart_backspace_event)

   142         text.bind("<<newline-and-indent>>",self.newline_and_indent_event)

   143         text.bind("<<smart-indent>>",self.smart_indent_event)

   144         text.bind("<<indent-region>>",self.indent_region_event)

   145         text.bind("<<dedent-region>>",self.dedent_region_event)

   146         text.bind("<<comment-region>>",self.comment_region_event)

   147         text.bind("<<uncomment-region>>",self.uncomment_region_event)

   148         text.bind("<<tabify-region>>",self.tabify_region_event)

   149         text.bind("<<untabify-region>>",self.untabify_region_event)

   150         text.bind("<<toggle-tabs>>",self.toggle_tabs_event)

   151         text.bind("<<change-indentwidth>>",self.change_indentwidth_event)

   152         text.bind("<Left>", self.move_at_edge_if_selection(0))

   153         text.bind("<Right>", self.move_at_edge_if_selection(1))

   154         text.bind("<<del-word-left>>", self.del_word_left)

   155         text.bind("<<del-word-right>>", self.del_word_right)

   156         text.bind("<<beginning-of-line>>", self.home_callback)

   157 

   158         if flist:

   159             flist.inversedict[self] = key

   160             if key:

   161                 flist.dict[key] = self

   162             text.bind("<<open-new-window>>", self.new_callback)

   163             text.bind("<<close-all-windows>>", self.flist.close_all_callback)

   164             text.bind("<<open-class-browser>>", self.open_class_browser)

   165             text.bind("<<open-path-browser>>", self.open_path_browser)

   166 

   167         self.set_status_bar()

   168         vbar['command'] = text.yview

   169         vbar.pack(side=RIGHT, fill=Y)

   170         text['yscrollcommand'] = vbar.set

   171         fontWeight = 'normal'

   172         if idleConf.GetOption('main', 'EditorWindow', 'font-bold', type='bool'):

   173             fontWeight='bold'

   174         text.config(font=(idleConf.GetOption('main', 'EditorWindow', 'font'),

   175                           idleConf.GetOption('main', 'EditorWindow', 'font-size'),

   176                           fontWeight))

   177         text_frame.pack(side=LEFT, fill=BOTH, expand=1)

   178         text.pack(side=TOP, fill=BOTH, expand=1)

   179         text.focus_set()

   180 

   181         # usetabs true  -> literal tab characters are used by indent and

   182         #                  dedent cmds, possibly mixed with spaces if

   183         #                  indentwidth is not a multiple of tabwidth,

   184         #                  which will cause Tabnanny to nag!

   185         #         false -> tab characters are converted to spaces by indent

   186         #                  and dedent cmds, and ditto TAB keystrokes

   187         # Although use-spaces=0 can be configured manually in config-main.def,

   188         # configuration of tabs v. spaces is not supported in the configuration

   189         # dialog.  IDLE promotes the preferred Python indentation: use spaces!

   190         usespaces = idleConf.GetOption('main', 'Indent', 'use-spaces', type='bool')

   191         self.usetabs = not usespaces

   192 

   193         # tabwidth is the display width of a literal tab character.

   194         # CAUTION:  telling Tk to use anything other than its default

   195         # tab setting causes it to use an entirely different tabbing algorithm,

   196         # treating tab stops as fixed distances from the left margin.

   197         # Nobody expects this, so for now tabwidth should never be changed.

   198         self.tabwidth = 8    # must remain 8 until Tk is fixed.

   199 

   200         # indentwidth is the number of screen characters per indent level.

   201         # The recommended Python indentation is four spaces.

   202         self.indentwidth = self.tabwidth

   203         self.set_notabs_indentwidth()

   204 

   205         # If context_use_ps1 is true, parsing searches back for a ps1 line;

   206         # else searches for a popular (if, def, ...) Python stmt.

   207         self.context_use_ps1 = False

   208 

   209         # When searching backwards for a reliable place to begin parsing,

   210         # first start num_context_lines[0] lines back, then

   211         # num_context_lines[1] lines back if that didn't work, and so on.

   212         # The last value should be huge (larger than the # of lines in a

   213         # conceivable file).

   214         # Making the initial values larger slows things down more often.

   215         self.num_context_lines = 50, 500, 5000000

   216 

   217         self.per = per = self.Percolator(text)

   218 

   219         self.undo = undo = self.UndoDelegator()

   220         per.insertfilter(undo)

   221         text.undo_block_start = undo.undo_block_start

   222         text.undo_block_stop = undo.undo_block_stop

   223         undo.set_saved_change_hook(self.saved_change_hook)

   224 

   225         # IOBinding implements file I/O and printing functionality

   226         self.io = io = self.IOBinding(self)

   227         io.set_filename_change_hook(self.filename_change_hook)

   228 

   229         # Create the recent files submenu

   230         self.recent_files_menu = Menu(self.menubar)

   231         self.menudict['file'].insert_cascade(3, label='Recent Files',

   232                                              underline=0,

   233                                              menu=self.recent_files_menu)

   234         self.update_recent_files_list()

   235 

   236         self.color = None # initialized below in self.ResetColorizer

   237         if filename:

   238             if os.path.exists(filename) and not os.path.isdir(filename):

   239                 io.loadfile(filename)

   240             else:

   241                 io.set_filename(filename)

   242         self.ResetColorizer()

   243         self.saved_change_hook()

   244 

   245         self.set_indentation_params(self.ispythonsource(filename))

   246 

   247         self.load_extensions()

   248 

   249         menu = self.menudict.get('windows')

   250         if menu:

   251             end = menu.index("end")

   252             if end is None:

   253                 end = -1

   254             if end >= 0:

   255                 menu.add_separator()

   256                 end = end + 1

   257             self.wmenu_end = end

   258             WindowList.register_callback(self.postwindowsmenu)

   259 

   260         # Some abstractions so IDLE extensions are cross-IDE

   261         self.askyesno = tkMessageBox.askyesno

   262         self.askinteger = tkSimpleDialog.askinteger

   263         self.showerror = tkMessageBox.showerror

   264 

   265     def _filename_to_unicode(self, filename):

   266         """convert filename to unicode in order to display it in Tk"""

   267         if isinstance(filename, unicode) or not filename:

   268             return filename

   269         else:

   270             try:

   271                 return filename.decode(self.filesystemencoding)

   272             except UnicodeDecodeError:

   273                 # XXX

   274                 try:

   275                     return filename.decode(self.encoding)

   276                 except UnicodeDecodeError:

   277                     # byte-to-byte conversion

   278                     return filename.decode('iso8859-1')

   279 

   280     def new_callback(self, event):

   281         dirname, basename = self.io.defaultfilename()

   282         self.flist.new(dirname)

   283         return "break"

   284 

   285     def home_callback(self, event):

   286         if (event.state & 12) != 0 and event.keysym == "Home":

   287             # state&1==shift, state&4==control, state&8==alt

   288             return # <Modifier-Home>; fall back to class binding

   289 

   290         if self.text.index("iomark") and \

   291            self.text.compare("iomark", "<=", "insert lineend") and \

   292            self.text.compare("insert linestart", "<=", "iomark"):

   293             insertpt = int(self.text.index("iomark").split(".")[1])

   294         else:

   295             line = self.text.get("insert linestart", "insert lineend")

   296             for insertpt in xrange(len(line)):

   297                 if line[insertpt] not in (' ','\t'):

   298                     break

   299             else:

   300                 insertpt=len(line)

   301 

   302         lineat = int(self.text.index("insert").split('.')[1])

   303 

   304         if insertpt == lineat:

   305             insertpt = 0

   306 

   307         dest = "insert linestart+"+str(insertpt)+"c"

   308 

   309         if (event.state&1) == 0:

   310             # shift not pressed

   311             self.text.tag_remove("sel", "1.0", "end")

   312         else:

   313             if not self.text.index("sel.first"):

   314                 self.text.mark_set("anchor","insert")

   315 

   316             first = self.text.index(dest)

   317             last = self.text.index("anchor")

   318 

   319             if self.text.compare(first,">",last):

   320                 first,last = last,first

   321 

   322             self.text.tag_remove("sel", "1.0", "end")

   323             self.text.tag_add("sel", first, last)

   324 

   325         self.text.mark_set("insert", dest)

   326         self.text.see("insert")

   327         return "break"

   328 

   329     def set_status_bar(self):

   330         self.status_bar = self.MultiStatusBar(self.top)

   331         if macosxSupport.runningAsOSXApp():

   332             # Insert some padding to avoid obscuring some of the statusbar

   333             # by the resize widget.

   334             self.status_bar.set_label('_padding1', '    ', side=RIGHT)

   335         self.status_bar.set_label('column', 'Col: ?', side=RIGHT)

   336         self.status_bar.set_label('line', 'Ln: ?', side=RIGHT)

   337         self.status_bar.pack(side=BOTTOM, fill=X)

   338         self.text.bind("<<set-line-and-column>>", self.set_line_and_column)

   339         self.text.event_add("<<set-line-and-column>>",

   340                             "<KeyRelease>", "<ButtonRelease>")

   341         self.text.after_idle(self.set_line_and_column)

   342 

   343     def set_line_and_column(self, event=None):

   344         line, column = self.text.index(INSERT).split('.')

   345         self.status_bar.set_label('column', 'Col: %s' % column)

   346         self.status_bar.set_label('line', 'Ln: %s' % line)

   347 

   348     menu_specs = [

   349         ("file", "_File"),

   350         ("edit", "_Edit"),

   351         ("format", "F_ormat"),

   352         ("run", "_Run"),

   353         ("options", "_Options"),

   354         ("windows", "_Windows"),

   355         ("help", "_Help"),

   356     ]

   357 

   358     if macosxSupport.runningAsOSXApp():

   359         del menu_specs[-3]

   360         menu_specs[-2] = ("windows", "_Window")

   361 

   362 

   363     def createmenubar(self):

   364         mbar = self.menubar

   365         self.menudict = menudict = {}

   366         for name, label in self.menu_specs:

   367             underline, label = prepstr(label)

   368             menudict[name] = menu = Menu(mbar, name=name)

   369             mbar.add_cascade(label=label, menu=menu, underline=underline)

   370 

   371         if sys.platform == 'darwin' and '.framework' in sys.executable:

   372             # Insert the application menu

   373             menudict['application'] = menu = Menu(mbar, name='apple')

   374             mbar.add_cascade(label='IDLE', menu=menu)

   375 

   376         self.fill_menus()

   377         self.base_helpmenu_length = self.menudict['help'].index(END)

   378         self.reset_help_menu_entries()

   379 

   380     def postwindowsmenu(self):

   381         # Only called when Windows menu exists

   382         menu = self.menudict['windows']

   383         end = menu.index("end")

   384         if end is None:

   385             end = -1

   386         if end > self.wmenu_end:

   387             menu.delete(self.wmenu_end+1, end)

   388         WindowList.add_windows_to_menu(menu)

   389 

   390     rmenu = None

   391 

   392     def right_menu_event(self, event):

   393         self.text.tag_remove("sel", "1.0", "end")

   394         self.text.mark_set("insert", "@%d,%d" % (event.x, event.y))

   395         if not self.rmenu:

   396             self.make_rmenu()

   397         rmenu = self.rmenu

   398         self.event = event

   399         iswin = sys.platform[:3] == 'win'

   400         if iswin:

   401             self.text.config(cursor="arrow")

   402         rmenu.tk_popup(event.x_root, event.y_root)

   403         if iswin:

   404             self.text.config(cursor="ibeam")

   405 

   406     rmenu_specs = [

   407         # ("Label", "<<virtual-event>>"), ...

   408         ("Close", "<<close-window>>"), # Example

   409     ]

   410 

   411     def make_rmenu(self):

   412         rmenu = Menu(self.text, tearoff=0)

   413         for label, eventname in self.rmenu_specs:

   414             def command(text=self.text, eventname=eventname):

   415                 text.event_generate(eventname)

   416             rmenu.add_command(label=label, command=command)

   417         self.rmenu = rmenu

   418 

   419     def about_dialog(self, event=None):

   420         aboutDialog.AboutDialog(self.top,'About IDLE')

   421 

   422     def config_dialog(self, event=None):

   423         configDialog.ConfigDialog(self.top,'Settings')

   424 

   425     def help_dialog(self, event=None):

   426         fn=os.path.join(os.path.abspath(os.path.dirname(__file__)),'help.txt')

   427         textView.view_file(self.top,'Help',fn)

   428 

   429     def python_docs(self, event=None):

   430         if sys.platform[:3] == 'win':

   431             os.startfile(self.help_url)

   432         else:

   433             webbrowser.open(self.help_url)

   434         return "break"

   435 

   436     def cut(self,event):

   437         self.text.event_generate("<<Cut>>")

   438         return "break"

   439 

   440     def copy(self,event):

   441         if not self.text.tag_ranges("sel"):

   442             # There is no selection, so do nothing and maybe interrupt.

   443             return

   444         self.text.event_generate("<<Copy>>")

   445         return "break"

   446 

   447     def paste(self,event):

   448         self.text.event_generate("<<Paste>>")

   449         self.text.see("insert")

   450         return "break"

   451 

   452     def select_all(self, event=None):

   453         self.text.tag_add("sel", "1.0", "end-1c")

   454         self.text.mark_set("insert", "1.0")

   455         self.text.see("insert")

   456         return "break"

   457 

   458     def remove_selection(self, event=None):

   459         self.text.tag_remove("sel", "1.0", "end")

   460         self.text.see("insert")

   461 

   462     def move_at_edge_if_selection(self, edge_index):

   463         """Cursor move begins at start or end of selection

   464 

   465         When a left/right cursor key is pressed create and return to Tkinter a

   466         function which causes a cursor move from the associated edge of the

   467         selection.

   468 

   469         """

   470         self_text_index = self.text.index

   471         self_text_mark_set = self.text.mark_set

   472         edges_table = ("sel.first+1c", "sel.last-1c")

   473         def move_at_edge(event):

   474             if (event.state & 5) == 0: # no shift(==1) or control(==4) pressed

   475                 try:

   476                     self_text_index("sel.first")

   477                     self_text_mark_set("insert", edges_table[edge_index])

   478                 except TclError:

   479                     pass

   480         return move_at_edge

   481 

   482     def del_word_left(self, event):

   483         self.text.event_generate('<Meta-Delete>')

   484         return "break"

   485 

   486     def del_word_right(self, event):

   487         self.text.event_generate('<Meta-d>')

   488         return "break"

   489 

   490     def find_event(self, event):

   491         SearchDialog.find(self.text)

   492         return "break"

   493 

   494     def find_again_event(self, event):

   495         SearchDialog.find_again(self.text)

   496         return "break"

   497 

   498     def find_selection_event(self, event):

   499         SearchDialog.find_selection(self.text)

   500         return "break"

   501 

   502     def find_in_files_event(self, event):

   503         GrepDialog.grep(self.text, self.io, self.flist)

   504         return "break"

   505 

   506     def replace_event(self, event):

   507         ReplaceDialog.replace(self.text)

   508         return "break"

   509 

   510     def goto_line_event(self, event):

   511         text = self.text

   512         lineno = tkSimpleDialog.askinteger("Goto",

   513                 "Go to line number:",parent=text)

   514         if lineno is None:

   515             return "break"

   516         if lineno <= 0:

   517             text.bell()

   518             return "break"

   519         text.mark_set("insert", "%d.0" % lineno)

   520         text.see("insert")

   521 

   522     def open_module(self, event=None):

   523         # XXX Shouldn't this be in IOBinding or in FileList?

   524         try:

   525             name = self.text.get("sel.first", "sel.last")

   526         except TclError:

   527             name = ""

   528         else:

   529             name = name.strip()

   530         name = tkSimpleDialog.askstring("Module",

   531                  "Enter the name of a Python module\n"

   532                  "to search on sys.path and open:",

   533                  parent=self.text, initialvalue=name)

   534         if name:

   535             name = name.strip()

   536         if not name:

   537             return

   538         # XXX Ought to insert current file's directory in front of path

   539         try:

   540             (f, file, (suffix, mode, type)) = _find_module(name)

   541         except (NameError, ImportError), msg:

   542             tkMessageBox.showerror("Import error", str(msg), parent=self.text)

   543             return

   544         if type != imp.PY_SOURCE:

   545             tkMessageBox.showerror("Unsupported type",

   546                 "%s is not a source module" % name, parent=self.text)

   547             return

   548         if f:

   549             f.close()

   550         if self.flist:

   551             self.flist.open(file)

   552         else:

   553             self.io.loadfile(file)

   554 

   555     def open_class_browser(self, event=None):

   556         filename = self.io.filename

   557         if not filename:

   558             tkMessageBox.showerror(

   559                 "No filename",

   560                 "This buffer has no associated filename",

   561                 master=self.text)

   562             self.text.focus_set()

   563             return None

   564         head, tail = os.path.split(filename)

   565         base, ext = os.path.splitext(tail)

   566         import ClassBrowser

   567         ClassBrowser.ClassBrowser(self.flist, base, [head])

   568 

   569     def open_path_browser(self, event=None):

   570         import PathBrowser

   571         PathBrowser.PathBrowser(self.flist)

   572 

   573     def gotoline(self, lineno):

   574         if lineno is not None and lineno > 0:

   575             self.text.mark_set("insert", "%d.0" % lineno)

   576             self.text.tag_remove("sel", "1.0", "end")

   577             self.text.tag_add("sel", "insert", "insert +1l")

   578             self.center()

   579 

   580     def ispythonsource(self, filename):

   581         if not filename or os.path.isdir(filename):

   582             return True

   583         base, ext = os.path.splitext(os.path.basename(filename))

   584         if os.path.normcase(ext) in (".py", ".pyw"):

   585             return True

   586         try:

   587             f = open(filename)

   588             line = f.readline()

   589             f.close()

   590         except IOError:

   591             return False

   592         return line.startswith('#!') and line.find('python') >= 0

   593 

   594     def close_hook(self):

   595         if self.flist:

   596             self.flist.unregister_maybe_terminate(self)

   597             self.flist = None

   598 

   599     def set_close_hook(self, close_hook):

   600         self.close_hook = close_hook

   601 

   602     def filename_change_hook(self):

   603         if self.flist:

   604             self.flist.filename_changed_edit(self)

   605         self.saved_change_hook()

   606         self.top.update_windowlist_registry(self)

   607         self.ResetColorizer()

   608 

   609     def _addcolorizer(self):

   610         if self.color:

   611             return

   612         if self.ispythonsource(self.io.filename):

   613             self.color = self.ColorDelegator()

   614         # can add more colorizers here...

   615         if self.color:

   616             self.per.removefilter(self.undo)

   617             self.per.insertfilter(self.color)

   618             self.per.insertfilter(self.undo)

   619 

   620     def _rmcolorizer(self):

   621         if not self.color:

   622             return

   623         self.color.removecolors()

   624         self.per.removefilter(self.color)

   625         self.color = None

   626 

   627     def ResetColorizer(self):

   628         "Update the colour theme"

   629         # Called from self.filename_change_hook and from configDialog.py

   630         self._rmcolorizer()

   631         self._addcolorizer()

   632         theme = idleConf.GetOption('main','Theme','name')

   633         normal_colors = idleConf.GetHighlight(theme, 'normal')

   634         cursor_color = idleConf.GetHighlight(theme, 'cursor', fgBg='fg')

   635         select_colors = idleConf.GetHighlight(theme, 'hilite')

   636         self.text.config(

   637             foreground=normal_colors['foreground'],

   638             background=normal_colors['background'],

   639             insertbackground=cursor_color,

   640             selectforeground=select_colors['foreground'],

   641             selectbackground=select_colors['background'],

   642             )

   643 

   644     def ResetFont(self):

   645         "Update the text widgets' font if it is changed"

   646         # Called from configDialog.py

   647         fontWeight='normal'

   648         if idleConf.GetOption('main','EditorWindow','font-bold',type='bool'):

   649             fontWeight='bold'

   650         self.text.config(font=(idleConf.GetOption('main','EditorWindow','font'),

   651                 idleConf.GetOption('main','EditorWindow','font-size'),

   652                 fontWeight))

   653 

   654     def RemoveKeybindings(self):

   655         "Remove the keybindings before they are changed."

   656         # Called from configDialog.py

   657         self.Bindings.default_keydefs = keydefs = idleConf.GetCurrentKeySet()

   658         for event, keylist in keydefs.items():

   659             self.text.event_delete(event, *keylist)

   660         for extensionName in self.get_standard_extension_names():

   661             xkeydefs = idleConf.GetExtensionBindings(extensionName)

   662             if xkeydefs:

   663                 for event, keylist in xkeydefs.items():

   664                     self.text.event_delete(event, *keylist)

   665 

   666     def ApplyKeybindings(self):

   667         "Update the keybindings after they are changed"

   668         # Called from configDialog.py

   669         self.Bindings.default_keydefs = keydefs = idleConf.GetCurrentKeySet()

   670         self.apply_bindings()

   671         for extensionName in self.get_standard_extension_names():

   672             xkeydefs = idleConf.GetExtensionBindings(extensionName)

   673             if xkeydefs:

   674                 self.apply_bindings(xkeydefs)

   675         #update menu accelerators

   676         menuEventDict = {}

   677         for menu in self.Bindings.menudefs:

   678             menuEventDict[menu[0]] = {}

   679             for item in menu[1]:

   680                 if item:

   681                     menuEventDict[menu[0]][prepstr(item[0])[1]] = item[1]

   682         for menubarItem in self.menudict.keys():

   683             menu = self.menudict[menubarItem]

   684             end = menu.index(END) + 1

   685             for index in range(0, end):

   686                 if menu.type(index) == 'command':

   687                     accel = menu.entrycget(index, 'accelerator')

   688                     if accel:

   689                         itemName = menu.entrycget(index, 'label')

   690                         event = ''

   691                         if menuEventDict.has_key(menubarItem):

   692                             if menuEventDict[menubarItem].has_key(itemName):

   693                                 event = menuEventDict[menubarItem][itemName]

   694                         if event:

   695                             accel = get_accelerator(keydefs, event)

   696                             menu.entryconfig(index, accelerator=accel)

   697 

   698     def set_notabs_indentwidth(self):

   699         "Update the indentwidth if changed and not using tabs in this window"

   700         # Called from configDialog.py

   701         if not self.usetabs:

   702             self.indentwidth = idleConf.GetOption('main', 'Indent','num-spaces',

   703                                                   type='int')

   704 

   705     def reset_help_menu_entries(self):

   706         "Update the additional help entries on the Help menu"

   707         help_list = idleConf.GetAllExtraHelpSourcesList()

   708         helpmenu = self.menudict['help']

   709         # first delete the extra help entries, if any

   710         helpmenu_length = helpmenu.index(END)

   711         if helpmenu_length > self.base_helpmenu_length:

   712             helpmenu.delete((self.base_helpmenu_length + 1), helpmenu_length)

   713         # then rebuild them

   714         if help_list:

   715             helpmenu.add_separator()

   716             for entry in help_list:

   717                 cmd = self.__extra_help_callback(entry[1])

   718                 helpmenu.add_command(label=entry[0], command=cmd)

   719         # and update the menu dictionary

   720         self.menudict['help'] = helpmenu

   721 

   722     def __extra_help_callback(self, helpfile):

   723         "Create a callback with the helpfile value frozen at definition time"

   724         def display_extra_help(helpfile=helpfile):

   725             if not helpfile.startswith(('www', 'http')):

   726                 url = os.path.normpath(helpfile)

   727             if sys.platform[:3] == 'win':

   728                 os.startfile(helpfile)

   729             else:

   730                 webbrowser.open(helpfile)

   731         return display_extra_help

   732 

   733     def update_recent_files_list(self, new_file=None):

   734         "Load and update the recent files list and menus"

   735         rf_list = []

   736         if os.path.exists(self.recent_files_path):

   737             rf_list_file = open(self.recent_files_path,'r')

   738             try:

   739                 rf_list = rf_list_file.readlines()

   740             finally:

   741                 rf_list_file.close()

   742         if new_file:

   743             new_file = os.path.abspath(new_file) + '\n'

   744             if new_file in rf_list:

   745                 rf_list.remove(new_file)  # move to top

   746             rf_list.insert(0, new_file)

   747         # clean and save the recent files list

   748         bad_paths = []

   749         for path in rf_list:

   750             if '\0' in path or not os.path.exists(path[0:-1]):

   751                 bad_paths.append(path)

   752         rf_list = [path for path in rf_list if path not in bad_paths]

   753         ulchars = "1234567890ABCDEFGHIJK"

   754         rf_list = rf_list[0:len(ulchars)]

   755         rf_file = open(self.recent_files_path, 'w')

   756         try:

   757             rf_file.writelines(rf_list)

   758         finally:

   759             rf_file.close()

   760         # for each edit window instance, construct the recent files menu

   761         for instance in self.top.instance_dict.keys():

   762             menu = instance.recent_files_menu

   763             menu.delete(1, END)  # clear, and rebuild:

   764             for i, file in zip(count(), rf_list):

   765                 file_name = file[0:-1]  # zap \n

   766                 # make unicode string to display non-ASCII chars correctly

   767                 ufile_name = self._filename_to_unicode(file_name)

   768                 callback = instance.__recent_file_callback(file_name)

   769                 menu.add_command(label=ulchars[i] + " " + ufile_name,

   770                                  command=callback,

   771                                  underline=0)

   772 

   773     def __recent_file_callback(self, file_name):

   774         def open_recent_file(fn_closure=file_name):

   775             self.io.open(editFile=fn_closure)

   776         return open_recent_file

   777 

   778     def saved_change_hook(self):

   779         short = self.short_title()

   780         long = self.long_title()

   781         if short and long:

   782             title = short + " - " + long

   783         elif short:

   784             title = short

   785         elif long:

   786             title = long

   787         else:

   788             title = "Untitled"

   789         icon = short or long or title

   790         if not self.get_saved():

   791             title = "*%s*" % title

   792             icon = "*%s" % icon

   793         self.top.wm_title(title)

   794         self.top.wm_iconname(icon)

   795 

   796     def get_saved(self):

   797         return self.undo.get_saved()

   798 

   799     def set_saved(self, flag):

   800         self.undo.set_saved(flag)

   801 

   802     def reset_undo(self):

   803         self.undo.reset_undo()

   804 

   805     def short_title(self):

   806         filename = self.io.filename

   807         if filename:

   808             filename = os.path.basename(filename)

   809         # return unicode string to display non-ASCII chars correctly

   810         return self._filename_to_unicode(filename)

   811 

   812     def long_title(self):

   813         # return unicode string to display non-ASCII chars correctly

   814         return self._filename_to_unicode(self.io.filename or "")

   815 

   816     def center_insert_event(self, event):

   817         self.center()

   818 

   819     def center(self, mark="insert"):

   820         text = self.text

   821         top, bot = self.getwindowlines()

   822         lineno = self.getlineno(mark)

   823         height = bot - top

   824         newtop = max(1, lineno - height//2)

   825         text.yview(float(newtop))

   826 

   827     def getwindowlines(self):

   828         text = self.text

   829         top = self.getlineno("@0,0")

   830         bot = self.getlineno("@0,65535")

   831         if top == bot and text.winfo_height() == 1:

   832             # Geometry manager hasn't run yet

   833             height = int(text['height'])

   834             bot = top + height - 1

   835         return top, bot

   836 

   837     def getlineno(self, mark="insert"):

   838         text = self.text

   839         return int(float(text.index(mark)))

   840 

   841     def get_geometry(self):

   842         "Return (width, height, x, y)"

   843         geom = self.top.wm_geometry()

   844         m = re.match(r"(\d+)x(\d+)\+(-?\d+)\+(-?\d+)", geom)

   845         tuple = (map(int, m.groups()))

   846         return tuple

   847 

   848     def close_event(self, event):

   849         self.close()

   850 

   851     def maybesave(self):

   852         if self.io:

   853             if not self.get_saved():

   854                 if self.top.state()!='normal':

   855                     self.top.deiconify()

   856                 self.top.lower()

   857                 self.top.lift()

   858             return self.io.maybesave()

   859 

   860     def close(self):

   861         reply = self.maybesave()

   862         if str(reply) != "cancel":

   863             self._close()

   864         return reply

   865 

   866     def _close(self):

   867         if self.io.filename:

   868             self.update_recent_files_list(new_file=self.io.filename)

   869         WindowList.unregister_callback(self.postwindowsmenu)

   870         self.unload_extensions()

   871         self.io.close()

   872         self.io = None

   873         self.undo = None

   874         if self.color:

   875             self.color.close(False)

   876             self.color = None

   877         self.text = None

   878         self.tkinter_vars = None

   879         self.per.close()

   880         self.per = None

   881         self.top.destroy()

   882         if self.close_hook:

   883             # unless override: unregister from flist, terminate if last window

   884             self.close_hook()

   885 

   886     def load_extensions(self):

   887         self.extensions = {}

   888         self.load_standard_extensions()

   889 

   890     def unload_extensions(self):

   891         for ins in self.extensions.values():

   892             if hasattr(ins, "close"):

   893                 ins.close()

   894         self.extensions = {}

   895 

   896     def load_standard_extensions(self):

   897         for name in self.get_standard_extension_names():

   898             try:

   899                 self.load_extension(name)

   900             except:

   901                 print "Failed to load extension", repr(name)

   902                 import traceback

   903                 traceback.print_exc()

   904 

   905     def get_standard_extension_names(self):

   906         return idleConf.GetExtensions(editor_only=True)

   907 

   908     def load_extension(self, name):

   909         try:

   910             mod = __import__(name, globals(), locals(), [])

   911         except ImportError:

   912             print "\nFailed to import extension: ", name

   913             return

   914         cls = getattr(mod, name)

   915         keydefs = idleConf.GetExtensionBindings(name)

   916         if hasattr(cls, "menudefs"):

   917             self.fill_menus(cls.menudefs, keydefs)

   918         ins = cls(self)

   919         self.extensions[name] = ins

   920         if keydefs:

   921             self.apply_bindings(keydefs)

   922             for vevent in keydefs.keys():

   923                 methodname = vevent.replace("-", "_")

   924                 while methodname[:1] == '<':

   925                     methodname = methodname[1:]

   926                 while methodname[-1:] == '>':

   927                     methodname = methodname[:-1]

   928                 methodname = methodname + "_event"

   929                 if hasattr(ins, methodname):

   930                     self.text.bind(vevent, getattr(ins, methodname))

   931 

   932     def apply_bindings(self, keydefs=None):

   933         if keydefs is None:

   934             keydefs = self.Bindings.default_keydefs

   935         text = self.text

   936         text.keydefs = keydefs

   937         for event, keylist in keydefs.items():

   938             if keylist:

   939                 text.event_add(event, *keylist)

   940 

   941     def fill_menus(self, menudefs=None, keydefs=None):

   942         """Add appropriate entries to the menus and submenus

   943 

   944         Menus that are absent or None in self.menudict are ignored.

   945         """

   946         if menudefs is None:

   947             menudefs = self.Bindings.menudefs

   948         if keydefs is None:

   949             keydefs = self.Bindings.default_keydefs

   950         menudict = self.menudict

   951         text = self.text

   952         for mname, entrylist in menudefs:

   953             menu = menudict.get(mname)

   954             if not menu:

   955                 continue

   956             for entry in entrylist:

   957                 if not entry:

   958                     menu.add_separator()

   959                 else:

   960                     label, eventname = entry

   961                     checkbutton = (label[:1] == '!')

   962                     if checkbutton:

   963                         label = label[1:]

   964                     underline, label = prepstr(label)

   965                     accelerator = get_accelerator(keydefs, eventname)

   966                     def command(text=text, eventname=eventname):

   967                         text.event_generate(eventname)

   968                     if checkbutton:

   969                         var = self.get_var_obj(eventname, BooleanVar)

   970                         menu.add_checkbutton(label=label, underline=underline,

   971                             command=command, accelerator=accelerator,

   972                             variable=var)

   973                     else:

   974                         menu.add_command(label=label, underline=underline,

   975                                          command=command,

   976                                          accelerator=accelerator)

   977 

   978     def getvar(self, name):

   979         var = self.get_var_obj(name)

   980         if var:

   981             value = var.get()

   982             return value

   983         else:

   984             raise NameError, name

   985 

   986     def setvar(self, name, value, vartype=None):

   987         var = self.get_var_obj(name, vartype)

   988         if var:

   989             var.set(value)

   990         else:

   991             raise NameError, name

   992 

   993     def get_var_obj(self, name, vartype=None):

   994         var = self.tkinter_vars.get(name)

   995         if not var and vartype:

   996             # create a Tkinter variable object with self.text as master:

   997             self.tkinter_vars[name] = var = vartype(self.text)

   998         return var

   999 

  1000     # Tk implementations of "virtual text methods" -- each platform

  1001     # reusing IDLE's support code needs to define these for its GUI's

  1002     # flavor of widget.

  1003 

  1004     # Is character at text_index in a Python string?  Return 0 for

  1005     # "guaranteed no", true for anything else.  This info is expensive

  1006     # to compute ab initio, but is probably already known by the

  1007     # platform's colorizer.

  1008 

  1009     def is_char_in_string(self, text_index):

  1010         if self.color:

  1011             # Return true iff colorizer hasn't (re)gotten this far

  1012             # yet, or the character is tagged as being in a string

  1013             return self.text.tag_prevrange("TODO", text_index) or \

  1014                    "STRING" in self.text.tag_names(text_index)

  1015         else:

  1016             # The colorizer is missing: assume the worst

  1017             return 1

  1018 

  1019     # If a selection is defined in the text widget, return (start,

  1020     # end) as Tkinter text indices, otherwise return (None, None)

  1021     def get_selection_indices(self):

  1022         try:

  1023             first = self.text.index("sel.first")

  1024             last = self.text.index("sel.last")

  1025             return first, last

  1026         except TclError:

  1027             return None, None

  1028 

  1029     # Return the text widget's current view of what a tab stop means

  1030     # (equivalent width in spaces).

  1031 

  1032     def get_tabwidth(self):

  1033         current = self.text['tabs'] or TK_TABWIDTH_DEFAULT

  1034         return int(current)

  1035 

  1036     # Set the text widget's current view of what a tab stop means.

  1037 

  1038     def set_tabwidth(self, newtabwidth):

  1039         text = self.text

  1040         if self.get_tabwidth() != newtabwidth:

  1041             pixels = text.tk.call("font", "measure", text["font"],

  1042                                   "-displayof", text.master,

  1043                                   "n" * newtabwidth)

  1044             text.configure(tabs=pixels)

  1045 

  1046     # If ispythonsource and guess are true, guess a good value for

  1047     # indentwidth based on file content (if possible), and if

  1048     # indentwidth != tabwidth set usetabs false.

  1049     # In any case, adjust the Text widget's view of what a tab

  1050     # character means.

  1051 

  1052     def set_indentation_params(self, ispythonsource, guess=True):

  1053         if guess and ispythonsource:

  1054             i = self.guess_indent()

  1055             if 2 <= i <= 8:

  1056                 self.indentwidth = i

  1057             if self.indentwidth != self.tabwidth:

  1058                 self.usetabs = False

  1059         self.set_tabwidth(self.tabwidth)

  1060 

  1061     def smart_backspace_event(self, event):

  1062         text = self.text

  1063         first, last = self.get_selection_indices()

  1064         if first and last:

  1065             text.delete(first, last)

  1066             text.mark_set("insert", first)

  1067             return "break"

  1068         # Delete whitespace left, until hitting a real char or closest

  1069         # preceding virtual tab stop.

  1070         chars = text.get("insert linestart", "insert")

  1071         if chars == '':

  1072             if text.compare("insert", ">", "1.0"):

  1073                 # easy: delete preceding newline

  1074                 text.delete("insert-1c")

  1075             else:

  1076                 text.bell()     # at start of buffer

  1077             return "break"

  1078         if  chars[-1] not in " \t":

  1079             # easy: delete preceding real char

  1080             text.delete("insert-1c")

  1081             return "break"

  1082         # Ick.  It may require *inserting* spaces if we back up over a

  1083         # tab character!  This is written to be clear, not fast.

  1084         tabwidth = self.tabwidth

  1085         have = len(chars.expandtabs(tabwidth))

  1086         assert have > 0

  1087         want = ((have - 1) // self.indentwidth) * self.indentwidth

  1088         # Debug prompt is multilined....

  1089         last_line_of_prompt = sys.ps1.split('\n')[-1]

  1090         ncharsdeleted = 0

  1091         while 1:

  1092             if chars == last_line_of_prompt:

  1093                 break

  1094             chars = chars[:-1]

  1095             ncharsdeleted = ncharsdeleted + 1

  1096             have = len(chars.expandtabs(tabwidth))

  1097             if have <= want or chars[-1] not in " \t":

  1098                 break

  1099         text.undo_block_start()

  1100         text.delete("insert-%dc" % ncharsdeleted, "insert")

  1101         if have < want:

  1102             text.insert("insert", ' ' * (want - have))

  1103         text.undo_block_stop()

  1104         return "break"

  1105 

  1106     def smart_indent_event(self, event):

  1107         # if intraline selection:

  1108         #     delete it

  1109         # elif multiline selection:

  1110         #     do indent-region

  1111         # else:

  1112         #     indent one level

  1113         text = self.text

  1114         first, last = self.get_selection_indices()

  1115         text.undo_block_start()

  1116         try:

  1117             if first and last:

  1118                 if index2line(first) != index2line(last):

  1119                     return self.indent_region_event(event)

  1120                 text.delete(first, last)

  1121                 text.mark_set("insert", first)

  1122             prefix = text.get("insert linestart", "insert")

  1123             raw, effective = classifyws(prefix, self.tabwidth)

  1124             if raw == len(prefix):

  1125                 # only whitespace to the left

  1126                 self.reindent_to(effective + self.indentwidth)

  1127             else:

  1128                 # tab to the next 'stop' within or to right of line's text:

  1129                 if self.usetabs:

  1130                     pad = '\t'

  1131                 else:

  1132                     effective = len(prefix.expandtabs(self.tabwidth))

  1133                     n = self.indentwidth

  1134                     pad = ' ' * (n - effective % n)

  1135                 text.insert("insert", pad)