Debian Codegraph @

Lib/idlelib/editor.py

raw
1 import importlib.abc
2 import importlib.util
3 import os
4 import platform
5 import re
6 import string
7 import sys
8 import tokenize
9 import traceback
10 import webbrowser
11
12 from tkinter import *
13 from tkinter.font import Font
14 from tkinter.ttk import Scrollbar
15 from tkinter import simpledialog
16 from tkinter import messagebox
17
18 from idlelib.config import idleConf
19 from idlelib import configdialog
20 from idlelib import grep
21 from idlelib import help
22 from idlelib import help_about
23 from idlelib import macosx
24 from idlelib.multicall import MultiCallCreator
25 from idlelib import pyparse
26 from idlelib import query
27 from idlelib import replace
28 from idlelib import search
29 from idlelib.tree import wheel_event
30 from idlelib.util import py_extensions
31 from idlelib import window
32 from idlelib.help import _get_dochome
33
34 # The default tab setting for a Text widget, in average-width characters.
35 TK_TABWIDTH_DEFAULT = 8
36 darwin = sys.platform == 'darwin'
37
38 class EditorWindow:
39 from idlelib.percolator import Percolator
40 from idlelib.colorizer import ColorDelegator, color_config
41 from idlelib.undo import UndoDelegator
42 from idlelib.iomenu import IOBinding, encoding
43 from idlelib import mainmenu
44 from idlelib.statusbar import MultiStatusBar
45 from idlelib.autocomplete import AutoComplete
46 from idlelib.autoexpand import AutoExpand
47 from idlelib.calltip import Calltip
48 from idlelib.codecontext import CodeContext
49 from idlelib.sidebar import LineNumbers
50 from idlelib.format import FormatParagraph, FormatRegion, Indents, Rstrip
51 from idlelib.parenmatch import ParenMatch
52 from idlelib.zoomheight import ZoomHeight
53
54 filesystemencoding = sys.getfilesystemencoding() # for file names
55 help_url = None
56
57 allow_code_context = True
58 allow_line_numbers = True
59 user_input_insert_tags = None
60
61 def __init__(self, flist=None, filename=None, key=None, root=None):
62 # Delay import: runscript imports pyshell imports EditorWindow.
63 from idlelib.runscript import ScriptBinding
64
65 if EditorWindow.help_url is None:
66 EditorWindow.help_url = _get_dochome()
67 self.flist = flist
68 root = root or flist.root
69 self.root = root
70 self.menubar = Menu(root)
71 self.top = top = window.ListedToplevel(root, menu=self.menubar)
72 if flist:
73 self.tkinter_vars = flist.vars
74 #self.top.instance_dict makes flist.inversedict available to
75 #configdialog.py so it can access all EditorWindow instances
76 self.top.instance_dict = flist.inversedict
77 else:
78 self.tkinter_vars = {} # keys: Tkinter event names
79 # values: Tkinter variable instances
80 self.top.instance_dict = {}
81 self.recent_files_path = idleConf.userdir and os.path.join(
82 idleConf.userdir, 'recent-files.lst')
83
84 self.prompt_last_line = '' # Override in PyShell
85 self.text_frame = text_frame = Frame(top)
86 self.vbar = vbar = Scrollbar(text_frame, name='vbar')
87 width = idleConf.GetOption('main', 'EditorWindow', 'width', type='int')
88 text_options = {
89 'name': 'text',
90 'padx': 5,
91 'wrap': 'none',
92 'highlightthickness': 0,
93 'width': width,
94 'tabstyle': 'wordprocessor', # new in 8.5
95 'height': idleConf.GetOption(
96 'main', 'EditorWindow', 'height', type='int'),
97 }
98 self.text = text = MultiCallCreator(Text)(text_frame, **text_options)
99 self.top.focused_widget = self.text
100
101 self.createmenubar()
102 self.apply_bindings()
103
104 self.top.protocol("WM_DELETE_WINDOW", self.close)
105 self.top.bind("<<close-window>>", self.close_event)
106 if macosx.isAquaTk():
107 # Command-W on editor windows doesn't work without this.
108 text.bind('<<close-window>>', self.close_event)
109 # Some OS X systems have only one mouse button, so use
110 # control-click for popup context menus there. For two
111 # buttons, AquaTk defines <2> as the right button, not <3>.
112 text.bind("<Control-Button-1>",self.right_menu_event)
113 text.bind("<2>", self.right_menu_event)
114 else:
115 # Elsewhere, use right-click for popup menus.
116 text.bind("<3>",self.right_menu_event)
117
118 text.bind('<MouseWheel>', wheel_event)
119 if text._windowingsystem == 'x11':
120 text.bind('<Button-4>', wheel_event)
121 text.bind('<Button-5>', wheel_event)
122 text.bind('<Configure>', self.handle_winconfig)
123 text.bind("<<cut>>", self.cut)
124 text.bind("<<copy>>", self.copy)
125 text.bind("<<paste>>", self.paste)
126 text.bind("<<center-insert>>", self.center_insert_event)
127 text.bind("<<help>>", self.help_dialog)
128 text.bind("<<python-docs>>", self.python_docs)
129 text.bind("<<about-idle>>", self.about_dialog)
130 text.bind("<<open-config-dialog>>", self.config_dialog)
131 text.bind("<<open-module>>", self.open_module_event)
132 text.bind("<<do-nothing>>", lambda event: "break")
133 text.bind("<<select-all>>", self.select_all)
134 text.bind("<<remove-selection>>", self.remove_selection)
135 text.bind("<<find>>", self.find_event)
136 text.bind("<<find-again>>", self.find_again_event)
137 text.bind("<<find-in-files>>", self.find_in_files_event)
138 text.bind("<<find-selection>>", self.find_selection_event)
139 text.bind("<<replace>>", self.replace_event)
140 text.bind("<<goto-line>>", self.goto_line_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 self.fregion = fregion = self.FormatRegion(self)
145 # self.fregion used in smart_indent_event to access indent_region.
146 text.bind("<<indent-region>>", fregion.indent_region_event)
147 text.bind("<<dedent-region>>", fregion.dedent_region_event)
148 text.bind("<<comment-region>>", fregion.comment_region_event)
149 text.bind("<<uncomment-region>>", fregion.uncomment_region_event)
150 text.bind("<<tabify-region>>", fregion.tabify_region_event)
151 text.bind("<<untabify-region>>", fregion.untabify_region_event)
152 indents = self.Indents(self)
153 text.bind("<<toggle-tabs>>", indents.toggle_tabs_event)
154 text.bind("<<change-indentwidth>>", indents.change_indentwidth_event)
155 text.bind("<Left>", self.move_at_edge_if_selection(0))
156 text.bind("<Right>", self.move_at_edge_if_selection(1))
157 text.bind("<<del-word-left>>", self.del_word_left)
158 text.bind("<<del-word-right>>", self.del_word_right)
159 text.bind("<<beginning-of-line>>", self.home_callback)
160
161 if flist:
162 flist.inversedict[self] = key
163 if key:
164 flist.dict[key] = self
165 text.bind("<<open-new-window>>", self.new_callback)
166 text.bind("<<close-all-windows>>", self.flist.close_all_callback)
167 text.bind("<<open-class-browser>>", self.open_module_browser)
168 text.bind("<<open-path-browser>>", self.open_path_browser)
169 text.bind("<<open-turtle-demo>>", self.open_turtle_demo)
170
171 self.set_status_bar()
172 text_frame.pack(side=LEFT, fill=BOTH, expand=1)
173 text_frame.rowconfigure(1, weight=1)
174 text_frame.columnconfigure(1, weight=1)
175 vbar['command'] = self.handle_yview
176 vbar.grid(row=1, column=2, sticky=NSEW)
177 text['yscrollcommand'] = vbar.set
178 text['font'] = idleConf.GetFont(self.root, 'main', 'EditorWindow')
179 text.grid(row=1, column=1, sticky=NSEW)
180 text.focus_set()
181 self.set_width()
182
183 # usetabs true -> literal tab characters are used by indent and
184 # dedent cmds, possibly mixed with spaces if
185 # indentwidth is not a multiple of tabwidth,
186 # which will cause Tabnanny to nag!
187 # false -> tab characters are converted to spaces by indent
188 # and dedent cmds, and ditto TAB keystrokes
189 # Although use-spaces=0 can be configured manually in config-main.def,
190 # configuration of tabs v. spaces is not supported in the configuration
191 # dialog. IDLE promotes the preferred Python indentation: use spaces!
192 usespaces = idleConf.GetOption('main', 'Indent',
193 'use-spaces', type='bool')
194 self.usetabs = not usespaces
195
196 # tabwidth is the display width of a literal tab character.
197 # CAUTION: telling Tk to use anything other than its default
198 # tab setting causes it to use an entirely different tabbing algorithm,
199 # treating tab stops as fixed distances from the left margin.
200 # Nobody expects this, so for now tabwidth should never be changed.
201 self.tabwidth = 8 # must remain 8 until Tk is fixed.
202
203 # indentwidth is the number of screen characters per indent level.
204 # The recommended Python indentation is four spaces.
205 self.indentwidth = self.tabwidth
206 self.set_notabs_indentwidth()
207
208 # Store the current value of the insertofftime now so we can restore
209 # it if needed.
210 if not hasattr(idleConf, 'blink_off_time'):
211 idleConf.blink_off_time = self.text['insertofftime']
212 self.update_cursor_blink()
213
214 # When searching backwards for a reliable place to begin parsing,
215 # first start num_context_lines[0] lines back, then
216 # num_context_lines[1] lines back if that didn't work, and so on.
217 # The last value should be huge (larger than the # of lines in a
218 # conceivable file).
219 # Making the initial values larger slows things down more often.
220 self.num_context_lines = 50, 500, 5000000
221 self.per = per = self.Percolator(text)
222 self.undo = undo = self.UndoDelegator()
223 per.insertfilter(undo)
224 text.undo_block_start = undo.undo_block_start
225 text.undo_block_stop = undo.undo_block_stop
226 undo.set_saved_change_hook(self.saved_change_hook)
227 # IOBinding implements file I/O and printing functionality
228 self.io = io = self.IOBinding(self)
229 io.set_filename_change_hook(self.filename_change_hook)
230 self.good_load = False
231 self.set_indentation_params(False)
232 self.color = None # initialized below in self.ResetColorizer
233 self.code_context = None # optionally initialized later below
234 self.line_numbers = None # optionally initialized later below
235 if filename:
236 if os.path.exists(filename) and not os.path.isdir(filename):
237 if io.loadfile(filename):
238 self.good_load = True
239 is_py_src = self.ispythonsource(filename)
240 self.set_indentation_params(is_py_src)
241 else:
242 io.set_filename(filename)
243 self.good_load = True
244
245 self.ResetColorizer()
246 self.saved_change_hook()
247 self.update_recent_files_list()
248 self.load_extensions()
249 menu = self.menudict.get('window')
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 window.register_callback(self.postwindowsmenu)
259
260 # Some abstractions so IDLE extensions are cross-IDE
261 self.askinteger = simpledialog.askinteger
262 self.askyesno = messagebox.askyesno
263 self.showerror = messagebox.showerror
264
265 # Add pseudoevents for former extension fixed keys.
266 # (This probably needs to be done once in the process.)
267 text.event_add('<<autocomplete>>', '<Key-Tab>')
268 text.event_add('<<try-open-completions>>', '<KeyRelease-period>',
269 '<KeyRelease-slash>', '<KeyRelease-backslash>')
270 text.event_add('<<try-open-calltip>>', '<KeyRelease-parenleft>')
271 text.event_add('<<refresh-calltip>>', '<KeyRelease-parenright>')
272 text.event_add('<<paren-closed>>', '<KeyRelease-parenright>',
273 '<KeyRelease-bracketright>', '<KeyRelease-braceright>')
274
275 # Former extension bindings depends on frame.text being packed
276 # (called from self.ResetColorizer()).
277 autocomplete = self.AutoComplete(self, self.user_input_insert_tags)
278 text.bind("<<autocomplete>>", autocomplete.autocomplete_event)
279 text.bind("<<try-open-completions>>",
280 autocomplete.try_open_completions_event)
281 text.bind("<<force-open-completions>>",
282 autocomplete.force_open_completions_event)
283 text.bind("<<expand-word>>", self.AutoExpand(self).expand_word_event)
284 text.bind("<<format-paragraph>>",
285 self.FormatParagraph(self).format_paragraph_event)
286 parenmatch = self.ParenMatch(self)
287 text.bind("<<flash-paren>>", parenmatch.flash_paren_event)
288 text.bind("<<paren-closed>>", parenmatch.paren_closed_event)
289 scriptbinding = ScriptBinding(self)
290 text.bind("<<check-module>>", scriptbinding.check_module_event)
291 text.bind("<<run-module>>", scriptbinding.run_module_event)
292 text.bind("<<run-custom>>", scriptbinding.run_custom_event)
293 text.bind("<<do-rstrip>>", self.Rstrip(self).do_rstrip)
294 self.ctip = ctip = self.Calltip(self)
295 text.bind("<<try-open-calltip>>", ctip.try_open_calltip_event)
296 #refresh-calltip must come after paren-closed to work right
297 text.bind("<<refresh-calltip>>", ctip.refresh_calltip_event)
298 text.bind("<<force-open-calltip>>", ctip.force_open_calltip_event)
299 text.bind("<<zoom-height>>", self.ZoomHeight(self).zoom_height_event)
300 if self.allow_code_context:
301 self.code_context = self.CodeContext(self)
302 text.bind("<<toggle-code-context>>",
303 self.code_context.toggle_code_context_event)
304 else:
305 self.update_menu_state('options', '*ode*ontext', 'disabled')
306 if self.allow_line_numbers:
307 self.line_numbers = self.LineNumbers(self)
308 if idleConf.GetOption('main', 'EditorWindow',
309 'line-numbers-default', type='bool'):
310 self.toggle_line_numbers_event()
311 text.bind("<<toggle-line-numbers>>", self.toggle_line_numbers_event)
312 else:
313 self.update_menu_state('options', '*ine*umbers', 'disabled')
314
315 def handle_winconfig(self, event=None):
316 self.set_width()
317
318 def set_width(self):
319 text = self.text
320 inner_padding = sum(map(text.tk.getint, [text.cget('border'),
321 text.cget('padx')]))
322 pixel_width = text.winfo_width() - 2 * inner_padding
323
324 # Divide the width of the Text widget by the font width,
325 # which is taken to be the width of '0' (zero).
326 # http://www.tcl.tk/man/tcl8.6/TkCmd/text.htm#M21
327 zero_char_width = \
328 Font(text, font=text.cget('font')).measure('0')
329 self.width = pixel_width // zero_char_width
330
331 def new_callback(self, event):
332 dirname, basename = self.io.defaultfilename()
333 self.flist.new(dirname)
334 return "break"
335
336 def home_callback(self, event):
337 if (event.state & 4) != 0 and event.keysym == "Home":
338 # state&4==Control. If <Control-Home>, use the Tk binding.
339 return None
340 if self.text.index("iomark") and \
341 self.text.compare("iomark", "<=", "insert lineend") and \
342 self.text.compare("insert linestart", "<=", "iomark"):
343 # In Shell on input line, go to just after prompt
344 insertpt = int(self.text.index("iomark").split(".")[1])
345 else:
346 line = self.text.get("insert linestart", "insert lineend")
347 for insertpt in range(len(line)):
348 if line[insertpt] not in (' ','\t'):
349 break
350 else:
351 insertpt=len(line)
352 lineat = int(self.text.index("insert").split('.')[1])
353 if insertpt == lineat:
354 insertpt = 0
355 dest = "insert linestart+"+str(insertpt)+"c"
356 if (event.state&1) == 0:
357 # shift was not pressed
358 self.text.tag_remove("sel", "1.0", "end")
359 else:
360 if not self.text.index("sel.first"):
361 # there was no previous selection
362 self.text.mark_set("my_anchor", "insert")
363 else:
364 if self.text.compare(self.text.index("sel.first"), "<",
365 self.text.index("insert")):
366 self.text.mark_set("my_anchor", "sel.first") # extend back
367 else:
368 self.text.mark_set("my_anchor", "sel.last") # extend forward
369 first = self.text.index(dest)
370 last = self.text.index("my_anchor")
371 if self.text.compare(first,">",last):
372 first,last = last,first
373 self.text.tag_remove("sel", "1.0", "end")
374 self.text.tag_add("sel", first, last)
375 self.text.mark_set("insert", dest)
376 self.text.see("insert")
377 return "break"
378
379 def set_status_bar(self):
380 self.status_bar = self.MultiStatusBar(self.top)
381 sep = Frame(self.top, height=1, borderwidth=1, background='grey75')
382 if sys.platform == "darwin":
383 # Insert some padding to avoid obscuring some of the statusbar
384 # by the resize widget.
385 self.status_bar.set_label('_padding1', ' ', side=RIGHT)
386 self.status_bar.set_label('column', 'Col: ?', side=RIGHT)
387 self.status_bar.set_label('line', 'Ln: ?', side=RIGHT)
388 self.status_bar.pack(side=BOTTOM, fill=X)
389 sep.pack(side=BOTTOM, fill=X)
390 self.text.bind("<<set-line-and-column>>", self.set_line_and_column)
391 self.text.event_add("<<set-line-and-column>>",
392 "<KeyRelease>", "<ButtonRelease>")
393 self.text.after_idle(self.set_line_and_column)
394
395 def set_line_and_column(self, event=None):
396 line, column = self.text.index(INSERT).split('.')
397 self.status_bar.set_label('column', 'Col: %s' % column)
398 self.status_bar.set_label('line', 'Ln: %s' % line)
399
400
401 """ Menu definitions and functions.
402 * self.menubar - the always visible horizontal menu bar.
403 * mainmenu.menudefs - a list of tuples, one for each menubar item.
404 Each tuple pairs a lower-case name and list of dropdown items.
405 Each item is a name, virtual event pair or None for separator.
406 * mainmenu.default_keydefs - maps events to keys.
407 * text.keydefs - same.
408 * cls.menu_specs - menubar name, titlecase display form pairs
409 with Alt-hotkey indicator. A subset of menudefs items.
410 * self.menudict - map menu name to dropdown menu.
411 * self.recent_files_menu - 2nd level cascade in the file cascade.
412 * self.wmenu_end - set in __init__ (purpose unclear).
413
414 createmenubar, postwindowsmenu, update_menu_label, update_menu_state,
415 ApplyKeybings (2nd part), reset_help_menu_entries,
416 _extra_help_callback, update_recent_files_list,
417 apply_bindings, fill_menus, (other functions?)
418 """
419
420 menu_specs = [
421 ("file", "_File"),
422 ("edit", "_Edit"),
423 ("format", "F_ormat"),
424 ("run", "_Run"),
425 ("options", "_Options"),
426 ("window", "_Window"),
427 ("help", "_Help"),
428 ]
429
430 def createmenubar(self):
431 """Populate the menu bar widget for the editor window.
432
433 Each option on the menubar is itself a cascade-type Menu widget
434 with the menubar as the parent. The names, labels, and menu
435 shortcuts for the menubar items are stored in menu_specs. Each
436 submenu is subsequently populated in fill_menus(), except for
437 'Recent Files' which is added to the File menu here.
438
439 Instance variables:
440 menubar: Menu widget containing first level menu items.
441 menudict: Dictionary of {menuname: Menu instance} items. The keys
442 represent the valid menu items for this window and may be a
443 subset of all the menudefs available.
444 recent_files_menu: Menu widget contained within the 'file' menudict.
445 """
446 mbar = self.menubar
447 self.menudict = menudict = {}
448 for name, label in self.menu_specs:
449 underline, label = prepstr(label)
450 postcommand = getattr(self, f'{name}_menu_postcommand', None)
451 menudict[name] = menu = Menu(mbar, name=name, tearoff=0,
452 postcommand=postcommand)
453 mbar.add_cascade(label=label, menu=menu, underline=underline)
454 if macosx.isCarbonTk():
455 # Insert the application menu
456 menudict['application'] = menu = Menu(mbar, name='apple',
457 tearoff=0)
458 mbar.add_cascade(label='IDLE', menu=menu)
459 self.fill_menus()
460 self.recent_files_menu = Menu(self.menubar, tearoff=0)
461 self.menudict['file'].insert_cascade(3, label='Recent Files',
462 underline=0,
463 menu=self.recent_files_menu)
464 self.base_helpmenu_length = self.menudict['help'].index(END)
465 self.reset_help_menu_entries()
466
467 def postwindowsmenu(self):
468 """Callback to register window.
469
470 Only called when Window menu exists.
471 """
472 menu = self.menudict['window']
473 end = menu.index("end")
474 if end is None:
475 end = -1
476 if end > self.wmenu_end:
477 menu.delete(self.wmenu_end+1, end)
478 window.add_windows_to_menu(menu)
479
480 def update_menu_label(self, menu, index, label):
481 "Update label for menu item at index."
482 menuitem = self.menudict[menu]
483 menuitem.entryconfig(index, label=label)
484
485 def update_menu_state(self, menu, index, state):
486 "Update state for menu item at index."
487 menuitem = self.menudict[menu]
488 menuitem.entryconfig(index, state=state)
489
490 def handle_yview(self, event, *args):
491 "Handle scrollbar."
492 if event == 'moveto':
493 fraction = float(args[0])
494 lines = (round(self.getlineno('end') * fraction) -
495 self.getlineno('@0,0'))
496 event = 'scroll'
497 args = (lines, 'units')
498 self.text.yview(event, *args)
499 return 'break'
500
501 rmenu = None
502
503 def right_menu_event(self, event):
504 text = self.text
505 newdex = text.index(f'@{event.x},{event.y}')
506 try:
507 in_selection = (text.compare('sel.first', '<=', newdex) and
508 text.compare(newdex, '<=', 'sel.last'))
509 except TclError:
510 in_selection = False
511 if not in_selection:
512 text.tag_remove("sel", "1.0", "end")
513 text.mark_set("insert", newdex)
514 if not self.rmenu:
515 self.make_rmenu()
516 rmenu = self.rmenu
517 self.event = event
518 iswin = sys.platform[:3] == 'win'
519 if iswin:
520 text.config(cursor="arrow")
521
522 for item in self.rmenu_specs:
523 try:
524 label, eventname, verify_state = item
525 except ValueError: # see issue1207589
526 continue
527
528 if verify_state is None:
529 continue
530 state = getattr(self, verify_state)()
531 rmenu.entryconfigure(label, state=state)
532
533 rmenu.tk_popup(event.x_root, event.y_root)
534 if iswin:
535 self.text.config(cursor="ibeam")
536 return "break"
537
538 rmenu_specs = [
539 # ("Label", "<<virtual-event>>", "statefuncname"), ...
540 ("Close", "<<close-window>>", None), # Example
541 ]
542
543 def make_rmenu(self):
544 rmenu = Menu(self.text, tearoff=0)
545 for item in self.rmenu_specs:
546 label, eventname = item[0], item[1]
547 if label is not None:
548 def command(text=self.text, eventname=eventname):
549 text.event_generate(eventname)
550 rmenu.add_command(label=label, command=command)
551 else:
552 rmenu.add_separator()
553 self.rmenu = rmenu
554
555 def rmenu_check_cut(self):
556 return self.rmenu_check_copy()
557
558 def rmenu_check_copy(self):
559 try:
560 indx = self.text.index('sel.first')
561 except TclError:
562 return 'disabled'
563 else:
564 return 'normal' if indx else 'disabled'
565
566 def rmenu_check_paste(self):
567 try:
568 self.text.tk.call('tk::GetSelection', self.text, 'CLIPBOARD')
569 except TclError:
570 return 'disabled'
571 else:
572 return 'normal'
573
574 def about_dialog(self, event=None):
575 "Handle Help 'About IDLE' event."
576 # Synchronize with macosx.overrideRootMenu.about_dialog.
577 help_about.AboutDialog(self.top)
578 return "break"
579
580 def config_dialog(self, event=None):
581 "Handle Options 'Configure IDLE' event."
582 # Synchronize with macosx.overrideRootMenu.config_dialog.
583 configdialog.ConfigDialog(self.top,'Settings')
584 return "break"
585
586 def help_dialog(self, event=None):
587 "Handle Help 'IDLE Help' event."
588 # Synchronize with macosx.overrideRootMenu.help_dialog.
589 if self.root:
590 parent = self.root
591 else:
592 parent = self.top
593 help.show_idlehelp(parent)
594 return "break"
595
596 def python_docs(self, event=None):
597 if sys.platform[:3] == 'win':
598 try:
599 os.startfile(self.help_url)
600 except OSError as why:
601 messagebox.showerror(title='Document Start Failure',
602 message=str(why), parent=self.text)
603 else:
604 webbrowser.open(self.help_url)
605 return "break"
606
607 def cut(self,event):
608 self.text.event_generate("<<Cut>>")
609 return "break"
610
611 def copy(self,event):
612 if not self.text.tag_ranges("sel"):
613 # There is no selection, so do nothing and maybe interrupt.
614 return None
615 self.text.event_generate("<<Copy>>")
616 return "break"
617
618 def paste(self,event):
619 self.text.event_generate("<<Paste>>")
620 self.text.see("insert")
621 return "break"
622
623 def select_all(self, event=None):
624 self.text.tag_add("sel", "1.0", "end-1c")
625 self.text.mark_set("insert", "1.0")
626 self.text.see("insert")
627 return "break"
628
629 def remove_selection(self, event=None):
630 self.text.tag_remove("sel", "1.0", "end")
631 self.text.see("insert")
632 return "break"
633
634 def move_at_edge_if_selection(self, edge_index):
635 """Cursor move begins at start or end of selection
636
637 When a left/right cursor key is pressed create and return to Tkinter a
638 function which causes a cursor move from the associated edge of the
639 selection.
640
641 """
642 self_text_index = self.text.index
643 self_text_mark_set = self.text.mark_set
644 edges_table = ("sel.first+1c", "sel.last-1c")
645 def move_at_edge(event):
646 if (event.state & 5) == 0: # no shift(==1) or control(==4) pressed
647 try:
648 self_text_index("sel.first")
649 self_text_mark_set("insert", edges_table[edge_index])
650 except TclError:
651 pass
652 return move_at_edge
653
654 def del_word_left(self, event):
655 self.text.event_generate('<Meta-Delete>')
656 return "break"
657
658 def del_word_right(self, event):
659 self.text.event_generate('<Meta-d>')
660 return "break"
661
662 def find_event(self, event):
663 search.find(self.text)
664 return "break"
665
666 def find_again_event(self, event):
667 search.find_again(self.text)
668 return "break"
669
670 def find_selection_event(self, event):
671 search.find_selection(self.text)
672 return "break"
673
674 def find_in_files_event(self, event):
675 grep.grep(self.text, self.io, self.flist)
676 return "break"
677
678 def replace_event(self, event):
679 replace.replace(self.text)
680 return "break"
681
682 def goto_line_event(self, event):
683 text = self.text
684 lineno = query.Goto(
685 text, "Go To Line",
686 "Enter a positive integer\n"
687 "('big' = end of file):"
688 ).result
689 if lineno is not None:
690 text.tag_remove("sel", "1.0", "end")
691 text.mark_set("insert", f'{lineno}.0')
692 text.see("insert")
693 self.set_line_and_column()
694 return "break"
695
696 def open_module(self):
697 """Get module name from user and open it.
698
699 Return module path or None for calls by open_module_browser
700 when latter is not invoked in named editor window.
701 """
702 # XXX This, open_module_browser, and open_path_browser
703 # would fit better in iomenu.IOBinding.
704 try:
705 name = self.text.get("sel.first", "sel.last").strip()
706 except TclError:
707 name = ''
708 file_path = query.ModuleName(
709 self.text, "Open Module",
710 "Enter the name of a Python module\n"
711 "to search on sys.path and open:",
712 name).result
713 if file_path is not None:
714 if self.flist:
715 self.flist.open(file_path)
716 else:
717 self.io.loadfile(file_path)
718 return file_path
719
720 def open_module_event(self, event):
721 self.open_module()
722 return "break"
723
724 def open_module_browser(self, event=None):
725 filename = self.io.filename
726 if not (self.__class__.__name__ == 'PyShellEditorWindow'
727 and filename):
728 filename = self.open_module()
729 if filename is None:
730 return "break"
731 from idlelib import browser
732 browser.ModuleBrowser(self.root, filename)
733 return "break"
734
735 def open_path_browser(self, event=None):
736 from idlelib import pathbrowser
737 pathbrowser.PathBrowser(self.root)
738 return "break"
739
740 def open_turtle_demo(self, event = None):
741 import subprocess
742
743 cmd = [sys.executable,
744 '-c',
745 'from turtledemo.__main__ import main; main()']
746 subprocess.Popen(cmd, shell=False)
747 return "break"
748
749 def gotoline(self, lineno):
750 if lineno is not None and lineno > 0:
751 self.text.mark_set("insert", "%d.0" % lineno)
752 self.text.tag_remove("sel", "1.0", "end")
753 self.text.tag_add("sel", "insert", "insert +1l")
754 self.center()
755
756 def ispythonsource(self, filename):
757 if not filename or os.path.isdir(filename):
758 return True
759 base, ext = os.path.splitext(os.path.basename(filename))
760 if os.path.normcase(ext) in py_extensions:
761 return True
762 line = self.text.get('1.0', '1.0 lineend')
763 return line.startswith('#!') and 'python' in line
764
765 def close_hook(self):
766 if self.flist:
767 self.flist.unregister_maybe_terminate(self)
768 self.flist = None
769
770 def set_close_hook(self, close_hook):
771 self.close_hook = close_hook
772
773 def filename_change_hook(self):
774 if self.flist:
775 self.flist.filename_changed_edit(self)
776 self.saved_change_hook()
777 self.top.update_windowlist_registry(self)
778 self.ResetColorizer()
779
780 def _addcolorizer(self):
781 if self.color:
782 return
783 if self.ispythonsource(self.io.filename):
784 self.color = self.ColorDelegator()
785 # can add more colorizers here...
786 if self.color:
787 self.per.insertfilterafter(filter=self.color, after=self.undo)
788
789 def _rmcolorizer(self):
790 if not self.color:
791 return
792 self.color.removecolors()
793 self.per.removefilter(self.color)
794 self.color = None
795
796 def ResetColorizer(self):
797 "Update the color theme"
798 # Called from self.filename_change_hook and from configdialog.py
799 self._rmcolorizer()
800 self._addcolorizer()
801 EditorWindow.color_config(self.text)
802
803 if self.code_context is not None:
804 self.code_context.update_highlight_colors()
805
806 if self.line_numbers is not None:
807 self.line_numbers.update_colors()
808
809 IDENTCHARS = string.ascii_letters + string.digits + "_"
810
811 def colorize_syntax_error(self, text, pos):
812 text.tag_add("ERROR", pos)
813 char = text.get(pos)
814 if char and char in self.IDENTCHARS:
815 text.tag_add("ERROR", pos + " wordstart", pos)
816 if '\n' == text.get(pos): # error at line end
817 text.mark_set("insert", pos)
818 else:
819 text.mark_set("insert", pos + "+1c")
820 text.see(pos)
821
822 def update_cursor_blink(self):
823 "Update the cursor blink configuration."
824 cursorblink = idleConf.GetOption(
825 'main', 'EditorWindow', 'cursor-blink', type='bool')
826 if not cursorblink:
827 self.text['insertofftime'] = 0
828 else:
829 # Restore the original value
830 self.text['insertofftime'] = idleConf.blink_off_time
831
832 def ResetFont(self):
833 "Update the text widgets' font if it is changed"
834 # Called from configdialog.py
835
836 # Update the code context widget first, since its height affects
837 # the height of the text widget. This avoids double re-rendering.
838 if self.code_context is not None:
839 self.code_context.update_font()
840 # Next, update the line numbers widget, since its width affects
841 # the width of the text widget.
842 if self.line_numbers is not None:
843 self.line_numbers.update_font()
844 # Finally, update the main text widget.
845 new_font = idleConf.GetFont(self.root, 'main', 'EditorWindow')
846 self.text['font'] = new_font
847 self.set_width()
848
849 def RemoveKeybindings(self):
850 """Remove the virtual, configurable keybindings.
851
852 Leaves the default Tk Text keybindings.
853 """
854 # Called from configdialog.deactivate_current_config.
855 self.mainmenu.default_keydefs = keydefs = idleConf.GetCurrentKeySet()
856 for event, keylist in keydefs.items():
857 self.text.event_delete(event, *keylist)
858 for extensionName in self.get_standard_extension_names():
859 xkeydefs = idleConf.GetExtensionBindings(extensionName)
860 if xkeydefs:
861 for event, keylist in xkeydefs.items():
862 self.text.event_delete(event, *keylist)
863
864 def ApplyKeybindings(self):
865 """Apply the virtual, configurable keybindings.
866
867 Also update hotkeys to current keyset.
868 """
869 # Called from configdialog.activate_config_changes.
870 self.mainmenu.default_keydefs = keydefs = idleConf.GetCurrentKeySet()
871 self.apply_bindings()
872 for extensionName in self.get_standard_extension_names():
873 xkeydefs = idleConf.GetExtensionBindings(extensionName)
874 if xkeydefs:
875 self.apply_bindings(xkeydefs)
876
877 # Update menu accelerators.
878 menuEventDict = {}
879 for menu in self.mainmenu.menudefs:
880 menuEventDict[menu[0]] = {}
881 for item in menu[1]:
882 if item:
883 menuEventDict[menu[0]][prepstr(item[0])[1]] = item[1]
884 for menubarItem in self.menudict:
885 menu = self.menudict[menubarItem]
886 end = menu.index(END)
887 if end is None:
888 # Skip empty menus
889 continue
890 end += 1
891 for index in range(0, end):
892 if menu.type(index) == 'command':
893 accel = menu.entrycget(index, 'accelerator')
894 if accel:
895 itemName = menu.entrycget(index, 'label')
896 event = ''
897 if menubarItem in menuEventDict:
898 if itemName in menuEventDict[menubarItem]:
899 event = menuEventDict[menubarItem][itemName]
900 if event:
901 accel = get_accelerator(keydefs, event)
902 menu.entryconfig(index, accelerator=accel)
903
904 def set_notabs_indentwidth(self):
905 "Update the indentwidth if changed and not using tabs in this window"
906 # Called from configdialog.py
907 if not self.usetabs:
908 self.indentwidth = idleConf.GetOption('main', 'Indent','num-spaces',
909 type='int')
910
911 def reset_help_menu_entries(self):
912 """Update the additional help entries on the Help menu."""
913 help_list = idleConf.GetAllExtraHelpSourcesList()
914 helpmenu = self.menudict['help']
915 # First delete the extra help entries, if any.
916 helpmenu_length = helpmenu.index(END)
917 if helpmenu_length > self.base_helpmenu_length:
918 helpmenu.delete((self.base_helpmenu_length + 1), helpmenu_length)
919 # Then rebuild them.
920 if help_list:
921 helpmenu.add_separator()
922 for entry in help_list:
923 cmd = self._extra_help_callback(entry[1])
924 helpmenu.add_command(label=entry[0], command=cmd)
925 # And update the menu dictionary.
926 self.menudict['help'] = helpmenu
927
928 def _extra_help_callback(self, resource):
929 """Return a callback that loads resource (file or web page)."""
930 def display_extra_help(helpfile=resource):
931 if not helpfile.startswith(('www', 'http')):
932 helpfile = os.path.normpath(helpfile)
933 if sys.platform[:3] == 'win':
934 try:
935 os.startfile(helpfile)
936 except OSError as why:
937 messagebox.showerror(title='Document Start Failure',
938 message=str(why), parent=self.text)
939 else:
940 webbrowser.open(helpfile)
941 return display_extra_help
942
943 def update_recent_files_list(self, new_file=None):
944 "Load and update the recent files list and menus"
945 # TODO: move to iomenu.
946 rf_list = []
947 file_path = self.recent_files_path
948 if file_path and os.path.exists(file_path):
949 with open(file_path,
950 encoding='utf_8', errors='replace') as rf_list_file:
951 rf_list = rf_list_file.readlines()
952 if new_file:
953 new_file = os.path.abspath(new_file) + '\n'
954 if new_file in rf_list:
955 rf_list.remove(new_file) # move to top
956 rf_list.insert(0, new_file)
957 # clean and save the recent files list
958 bad_paths = []
959 for path in rf_list:
960 if '\0' in path or not os.path.exists(path[0:-1]):
961 bad_paths.append(path)
962 rf_list = [path for path in rf_list if path not in bad_paths]
963 ulchars = "1234567890ABCDEFGHIJK"
964 rf_list = rf_list[0:len(ulchars)]
965 if file_path:
966 try:
967 with open(file_path, 'w',
968 encoding='utf_8', errors='replace') as rf_file:
969 rf_file.writelines(rf_list)
970 except OSError as err:
971 if not getattr(self.root, "recentfiles_message", False):
972 self.root.recentfiles_message = True
973 messagebox.showwarning(title='IDLE Warning',
974 message="Cannot save Recent Files list to disk.\n"
975 f" {err}\n"
976 "Select OK to continue.",
977 parent=self.text)
978 # for each edit window instance, construct the recent files menu
979 for instance in self.top.instance_dict:
980 menu = instance.recent_files_menu
981 menu.delete(0, END) # clear, and rebuild:
982 for i, file_name in enumerate(rf_list):
983 file_name = file_name.rstrip() # zap \n
984 callback = instance.__recent_file_callback(file_name)
985 menu.add_command(label=ulchars[i] + " " + file_name,
986 command=callback,
987 underline=0)
988
989 def __recent_file_callback(self, file_name):
990 def open_recent_file(fn_closure=file_name):
991 self.io.open(editFile=fn_closure)
992 return open_recent_file
993
994 def saved_change_hook(self):
995 short = self.short_title()
996 long = self.long_title()
997 _py_version = ' (%s)' % platform.python_version()
998 if short and long and not macosx.isCocoaTk():
999 # Don't use both values on macOS because
1000 # that doesn't match platform conventions.
1001 title = short + " - " + long + _py_version
1002 elif short:
1003 if short == "IDLE Shell":
1004 title = short + " " + platform.python_version()
1005 else:
1006 title = short + _py_version
1007 elif long:
1008 title = long
1009 else:
1010 title = "untitled"
1011 icon = short or long or title
1012 if not self.get_saved():
1013 title = "*%s*" % title
1014 icon = "*%s" % icon
1015 self.top.wm_title(title)
1016 self.top.wm_iconname(icon)
1017
1018 if macosx.isCocoaTk():
1019 # Add a proxy icon to the window title
1020 self.top.wm_attributes("-titlepath", long)
1021
1022 # Maintain the modification status for the window
1023 self.top.wm_attributes("-modified", not self.get_saved())
1024
1025 def get_saved(self):
1026 return self.undo.get_saved()
1027
1028 def set_saved(self, flag):
1029 self.undo.set_saved(flag)
1030
1031 def reset_undo(self):
1032 self.undo.reset_undo()
1033
1034 def short_title(self):
1035 filename = self.io.filename
1036 return os.path.basename(filename) if filename else "untitled"
1037
1038 def long_title(self):
1039 return self.io.filename or ""
1040
1041 def center_insert_event(self, event):
1042 self.center()
1043 return "break"
1044
1045 def center(self, mark="insert"):
1046 text = self.text
1047 top, bot = self.getwindowlines()
1048 lineno = self.getlineno(mark)
1049 height = bot - top
1050 newtop = max(1, lineno - height//2)
1051 text.yview(float(newtop))
1052
1053 def getwindowlines(self):
1054 text = self.text
1055 top = self.getlineno("@0,0")
1056 bot = self.getlineno("@0,65535")
1057 if top == bot and text.winfo_height() == 1:
1058 # Geometry manager hasn't run yet
1059 height = int(text['height'])
1060 bot = top + height - 1
1061 return top, bot
1062
1063 def getlineno(self, mark="insert"):
1064 text = self.text
1065 return int(float(text.index(mark)))
1066
1067 def get_geometry(self):
1068 "Return (width, height, x, y)"
1069 geom = self.top.wm_geometry()
1070 m = re.match(r"(\d+)x(\d+)\+(-?\d+)\+(-?\d+)", geom)
1071 return list(map(int, m.groups()))
1072
1073 def close_event(self, event):
1074 self.close()
1075 return "break"
1076
1077 def maybesave(self):
1078 if self.io:
1079 if not self.get_saved():
1080 if self.top.state()!='normal':
1081 self.top.deiconify()
1082 self.top.lower()
1083 self.top.lift()
1084 return self.io.maybesave()
1085
1086 def close(self):
1087 try:
1088 reply = self.maybesave()
1089 if str(reply) != "cancel":
1090 self._close()
1091 return reply
1092 except AttributeError: # bpo-35379: close called twice
1093 pass
1094
1095 def _close(self):
1096 if self.io.filename:
1097 self.update_recent_files_list(new_file=self.io.filename)
1098 window.unregister_callback(self.postwindowsmenu)
1099 self.unload_extensions()
1100 self.io.close()
1101 self.io = None
1102 self.undo = None
1103 if self.color:
1104 self.color.close()
1105 self.color = None
1106 self.text = None
1107 self.tkinter_vars = None
1108 self.per.close()
1109 self.per = None
1110 self.top.destroy()
1111 if self.close_hook:
1112 # unless override: unregister from flist, terminate if last window
1113 self.close_hook()
1114
1115 def load_extensions(self):
1116 self.extensions = {}
1117 self.load_standard_extensions()
1118
1119 def unload_extensions(self):
1120 for ins in list(self.extensions.values()):
1121 if hasattr(ins, "close"):
1122 ins.close()
1123 self.extensions = {}
1124
1125 def load_standard_extensions(self):
1126 for name in self.get_standard_extension_names():
1127 try:
1128 self.load_extension(name)
1129 except:
1130 print("Failed to load extension", repr(name))
1131 traceback.print_exc()
1132
1133 def get_standard_extension_names(self):
1134 return idleConf.GetExtensions(editor_only=True)
1135
1136 extfiles = { # Map built-in config-extension section names to file names.
1137 'ZzDummy': 'zzdummy',
1138 }
1139
1140 def load_extension(self, name):
1141 fname = self.extfiles.get(name, name)
1142 try:
1143 try:
1144 mod = importlib.import_module('.' + fname, package=__package__)
1145 except (ImportError, TypeError):
1146 mod = importlib.import_module(fname)
1147 except ImportError:
1148 print("\nFailed to import extension: ", name)
1149 raise
1150 cls = getattr(mod, name)
1151 keydefs = idleConf.GetExtensionBindings(name)
1152 if hasattr(cls, "menudefs"):
1153 self.fill_menus(cls.menudefs, keydefs)
1154 ins = cls(self)
1155 self.extensions[name] = ins
1156 if keydefs:
1157 self.apply_bindings(keydefs)
1158 for vevent in keydefs:
1159 methodname = vevent.replace("-", "_")
1160 while methodname[:1] == '<':
1161 methodname = methodname[1:]
1162 while methodname[-1:] == '>':
1163 methodname = methodname[:-1]
1164 methodname = methodname + "_event"
1165 if hasattr(ins, methodname):
1166 self.text.bind(vevent, getattr(ins, methodname))
1167
1168 def apply_bindings(self, keydefs=None):
1169 """Add events with keys to self.text."""
1170 if keydefs is None:
1171 keydefs = self.mainmenu.default_keydefs
1172 text = self.text
1173 text.keydefs = keydefs
1174 for event, keylist in keydefs.items():
1175 if keylist:
1176 text.event_add(event, *keylist)
1177
1178 def fill_menus(self, menudefs=None, keydefs=None):
1179 """Fill in dropdown menus used by this window.
1180
1181 Items whose name begins with '!' become checkbuttons.
1182 Other names indicate commands. None becomes a separator.
1183 """
1184 if menudefs is None:
1185 menudefs = self.mainmenu.menudefs
1186 if keydefs is None:
1187 keydefs = self.mainmenu.default_keydefs
1188 menudict = self.menudict
1189 text = self.text
1190 for mname, entrylist in menudefs:
1191 menu = menudict.get(mname)
1192 if not menu:
1193 continue
1194 for entry in entrylist:
1195 if entry is None:
1196 menu.add_separator()
1197 else:
1198 label, eventname = entry
1199 checkbutton = (label[:1] == '!')
1200 if checkbutton:
1201 label = label[1:]
1202 underline, label = prepstr(label)
1203 accelerator = get_accelerator(keydefs, eventname)
1204 def command(text=text, eventname=eventname):
1205 text.event_generate(eventname)
1206 if checkbutton:
1207 var = self.get_var_obj(eventname, BooleanVar)
1208 menu.add_checkbutton(label=label, underline=underline,
1209 command=command, accelerator=accelerator,
1210 variable=var)
1211 else:
1212 menu.add_command(label=label, underline=underline,
1213 command=command,
1214 accelerator=accelerator)
1215
1216 def getvar(self, name):
1217 var = self.get_var_obj(name)
1218 if var:
1219 value = var.get()
1220 return value
1221 else:
1222 raise NameError(name)
1223
1224 def setvar(self, name, value, vartype=None):
1225 var = self.get_var_obj(name, vartype)
1226 if var:
1227 var.set(value)
1228 else:
1229 raise NameError(name)
1230
1231 def get_var_obj(self, eventname, vartype=None):
1232 """Return a tkinter variable instance for the event.
1233 """
1234 var = self.tkinter_vars.get(eventname)
1235 if not var and vartype:
1236 # Create a Tkinter variable object.
1237 self.tkinter_vars[eventname] = var = vartype(self.text)
1238 return var
1239
1240 # Tk implementations of "virtual text methods" -- each platform
1241 # reusing IDLE's support code needs to define these for its GUI's
1242 # flavor of widget.
1243
1244 # Is character at text_index in a Python string? Return 0 for
1245 # "guaranteed no", true for anything else. This info is expensive
1246 # to compute ab initio, but is probably already known by the
1247 # platform's colorizer.
1248
1249 def is_char_in_string(self, text_index):
1250 if self.color:
1251 # Return true iff colorizer hasn't (re)gotten this far
1252 # yet, or the character is tagged as being in a string
1253 return self.text.tag_prevrange("TODO", text_index) or \
1254 "STRING" in self.text.tag_names(text_index)
1255 else:
1256 # The colorizer is missing: assume the worst
1257 return 1
1258
1259 # If a selection is defined in the text widget, return (start,
1260 # end) as Tkinter text indices, otherwise return (None, None)
1261 def get_selection_indices(self):
1262 try:
1263 first = self.text.index("sel.first")
1264 last = self.text.index("sel.last")
1265 return first, last
1266 except TclError:
1267 return None, None
1268
1269 # Return the text widget's current view of what a tab stop means
1270 # (equivalent width in spaces).
1271
1272 def get_tk_tabwidth(self):
1273 current = self.text['tabs'] or TK_TABWIDTH_DEFAULT
1274 return int(current)
1275
1276 # Set the text widget's current view of what a tab stop means.
1277
1278 def set_tk_tabwidth(self, newtabwidth):
1279 text = self.text
1280 if self.get_tk_tabwidth() != newtabwidth:
1281 # Set text widget tab width
1282 pixels = text.tk.call("font", "measure", text["font"],
1283 "-displayof", text.master,
1284 "n" * newtabwidth)
1285 text.configure(tabs=pixels)
1286
1287 ### begin autoindent code ### (configuration was moved to beginning of class)
1288
1289 def set_indentation_params(self, is_py_src, guess=True):
1290 if is_py_src and guess:
1291 i = self.guess_indent()
1292 if 2 <= i <= 8:
1293 self.indentwidth = i
1294 if self.indentwidth != self.tabwidth:
1295 self.usetabs = False
1296 self.set_tk_tabwidth(self.tabwidth)
1297
1298 def smart_backspace_event(self, event):
1299 text = self.text
1300 first, last = self.get_selection_indices()
1301 if first and last:
1302 text.delete(first, last)
1303 text.mark_set("insert", first)
1304 return "break"
1305 # Delete whitespace left, until hitting a real char or closest
1306 # preceding virtual tab stop.
1307 chars = text.get("insert linestart", "insert")
1308 if chars == '':
1309 if text.compare("insert", ">", "1.0"):
1310 # easy: delete preceding newline
1311 text.delete("insert-1c")
1312 else:
1313 text.bell() # at start of buffer
1314 return "break"
1315 if chars[-1] not in " \t":
1316 # easy: delete preceding real char
1317 text.delete("insert-1c")
1318 return "break"
1319 # Ick. It may require *inserting* spaces if we back up over a
1320 # tab character! This is written to be clear, not fast.
1321 tabwidth = self.tabwidth
1322 have = len(chars.expandtabs(tabwidth))
1323 assert have > 0
1324 want = ((have - 1) // self.indentwidth) * self.indentwidth
1325 # Debug prompt is multilined....
1326 ncharsdeleted = 0
1327 while True:
1328 chars = chars[:-1]
1329 ncharsdeleted = ncharsdeleted + 1
1330 have = len(chars.expandtabs(tabwidth))
1331 if have <= want or chars[-1] not in " \t":
1332 break
1333 text.undo_block_start()
1334 text.delete("insert-%dc" % ncharsdeleted, "insert")
1335 if have < want:
1336 text.insert("insert", ' ' * (want - have),
1337 self.user_input_insert_tags)
1338 text.undo_block_stop()
1339 return "break"
1340
1341 def smart_indent_event(self, event):
1342 # if intraline selection:
1343 # delete it
1344 # elif multiline selection:
1345 # do indent-region
1346 # else:
1347 # indent one level
1348 text = self.text
1349 first, last = self.get_selection_indices()
1350 text.undo_block_start()
1351 try:
1352 if first and last:
1353 if index2line(first) != index2line(last):
1354 return self.fregion.indent_region_event(event)
1355 text.delete(first, last)
1356 text.mark_set("insert", first)
1357 prefix = text.get("insert linestart", "insert")
1358 raw, effective = get_line_indent(prefix, self.tabwidth)
1359 if raw == len(prefix):
1360 # only whitespace to the left
1361 self.reindent_to(effective + self.indentwidth)
1362 else:
1363 # tab to the next 'stop' within or to right of line's text:
1364 if self.usetabs:
1365 pad = '\t'
1366 else:
1367 effective = len(prefix.expandtabs(self.tabwidth))
1368 n = self.indentwidth
1369 pad = ' ' * (n - effective % n)
1370 text.insert("insert", pad, self.user_input_insert_tags)
1371 text.see("insert")
1372 return "break"
1373 finally:
1374 text.undo_block_stop()
1375
1376 def newline_and_indent_event(self, event):
1377 """Insert a newline and indentation after Enter keypress event.
1378
1379 Properly position the cursor on the new line based on information
1380 from the current line. This takes into account if the current line
1381 is a shell prompt, is empty, has selected text, contains a block
1382 opener, contains a block closer, is a continuation line, or
1383 is inside a string.
1384 """
1385 text = self.text
1386 first, last = self.get_selection_indices()
1387 text.undo_block_start()
1388 try: # Close undo block and expose new line in finally clause.
1389 if first and last:
1390 text.delete(first, last)
1391 text.mark_set("insert", first)
1392 line = text.get("insert linestart", "insert")
1393
1394 # Count leading whitespace for indent size.
1395 i, n = 0, len(line)
1396 while i < n and line[i] in " \t":
1397 i += 1
1398 if i == n:
1399 # The cursor is in or at leading indentation in a continuation
1400 # line; just inject an empty line at the start.
1401 text.insert("insert linestart", '\n',
1402 self.user_input_insert_tags)
1403 return "break"
1404 indent = line[:i]
1405
1406 # Strip whitespace before insert point unless it's in the prompt.
1407 i = 0
1408 while line and line[-1] in " \t":
1409 line = line[:-1]
1410 i += 1
1411 if i:
1412 text.delete("insert - %d chars" % i, "insert")
1413
1414 # Strip whitespace after insert point.
1415 while text.get("insert") in " \t":
1416 text.delete("insert")
1417
1418 # Insert new line.
1419 text.insert("insert", '\n', self.user_input_insert_tags)
1420
1421 # Adjust indentation for continuations and block open/close.
1422 # First need to find the last statement.
1423 lno = index2line(text.index('insert'))
1424 y = pyparse.Parser(self.indentwidth, self.tabwidth)
1425 if not self.prompt_last_line:
1426 for context in self.num_context_lines:
1427 startat = max(lno - context, 1)
1428 startatindex = repr(startat) + ".0"
1429 rawtext = text.get(startatindex, "insert")
1430 y.set_code(rawtext)
1431 bod = y.find_good_parse_start(
1432 self._build_char_in_string_func(startatindex))
1433 if bod is not None or startat == 1:
1434 break
1435 y.set_lo(bod or 0)
1436 else:
1437 r = text.tag_prevrange("console", "insert")
1438 if r:
1439 startatindex = r[1]
1440 else:
1441 startatindex = "1.0"
1442 rawtext = text.get(startatindex, "insert")
1443 y.set_code(rawtext)
1444 y.set_lo(0)
1445
1446 c = y.get_continuation_type()
1447 if c != pyparse.C_NONE:
1448 # The current statement hasn't ended yet.
1449 if c == pyparse.C_STRING_FIRST_LINE:
1450 # After the first line of a string do not indent at all.
1451 pass
1452 elif c == pyparse.C_STRING_NEXT_LINES:
1453 # Inside a string which started before this line;
1454 # just mimic the current indent.
1455 text.insert("insert", indent, self.user_input_insert_tags)
1456 elif c == pyparse.C_BRACKET:
1457 # Line up with the first (if any) element of the
1458 # last open bracket structure; else indent one
1459 # level beyond the indent of the line with the
1460 # last open bracket.
1461 self.reindent_to(y.compute_bracket_indent())
1462 elif c == pyparse.C_BACKSLASH:
1463 # If more than one line in this statement already, just
1464 # mimic the current indent; else if initial line
1465 # has a start on an assignment stmt, indent to
1466 # beyond leftmost =; else to beyond first chunk of
1467 # non-whitespace on initial line.
1468 if y.get_num_lines_in_stmt() > 1:
1469 text.insert("insert", indent,
1470 self.user_input_insert_tags)
1471 else:
1472 self.reindent_to(y.compute_backslash_indent())
1473 else:
1474 assert 0, f"bogus continuation type {c!r}"
1475 return "break"
1476
1477 # This line starts a brand new statement; indent relative to
1478 # indentation of initial line of closest preceding
1479 # interesting statement.
1480 indent = y.get_base_indent_string()
1481 text.insert("insert", indent, self.user_input_insert_tags)
1482 if y.is_block_opener():
1483 self.smart_indent_event(event)
1484 elif indent and y.is_block_closer():
1485 self.smart_backspace_event(event)
1486 return "break"
1487 finally:
1488 text.see("insert")
1489 text.undo_block_stop()
1490
1491 # Our editwin provides an is_char_in_string function that works
1492 # with a Tk text index, but PyParse only knows about offsets into
1493 # a string. This builds a function for PyParse that accepts an
1494 # offset.
1495
1496 def _build_char_in_string_func(self, startindex):
1497 def inner(offset, _startindex=startindex,
1498 _icis=self.is_char_in_string):
1499 return _icis(_startindex + "+%dc" % offset)
1500 return inner
1501
1502 # XXX this isn't bound to anything -- see tabwidth comments
1503 ## def change_tabwidth_event(self, event):
1504 ## new = self._asktabwidth()
1505 ## if new != self.tabwidth:
1506 ## self.tabwidth = new
1507 ## self.set_indentation_params(0, guess=0)
1508 ## return "break"
1509
1510 # Make string that displays as n leading blanks.
1511
1512 def _make_blanks(self, n):
1513 if self.usetabs:
1514 ntabs, nspaces = divmod(n, self.tabwidth)
1515 return '\t' * ntabs + ' ' * nspaces
1516 else:
1517 return ' ' * n
1518
1519 # Delete from beginning of line to insert point, then reinsert
1520 # column logical (meaning use tabs if appropriate) spaces.
1521
1522 def reindent_to(self, column):
1523 text = self.text
1524 text.undo_block_start()
1525 if text.compare("insert linestart", "!=", "insert"):
1526 text.delete("insert linestart", "insert")
1527 if column:
1528 text.insert("insert", self._make_blanks(column),
1529 self.user_input_insert_tags)
1530 text.undo_block_stop()
1531
1532 # Guess indentwidth from text content.
1533 # Return guessed indentwidth. This should not be believed unless
1534 # it's in a reasonable range (e.g., it will be 0 if no indented
1535 # blocks are found).
1536
1537 def guess_indent(self):
1538 opener, indented = IndentSearcher(self.text).run()
1539 if opener and indented:
1540 raw, indentsmall = get_line_indent(opener, self.tabwidth)
1541 raw, indentlarge = get_line_indent(indented, self.tabwidth)
1542 else:
1543 indentsmall = indentlarge = 0
1544 return indentlarge - indentsmall
1545
1546 def toggle_line_numbers_event(self, event=None):
1547 if self.line_numbers is None:
1548 return
1549
1550 if self.line_numbers.is_shown:
1551 self.line_numbers.hide_sidebar()
1552 menu_label = "Show"
1553 else:
1554 self.line_numbers.show_sidebar()
1555 menu_label = "Hide"
1556 self.update_menu_label(menu='options', index='*ine*umbers',
1557 label=f'{menu_label} Line Numbers')
1558
1559 # "line.col" -> line, as an int
1560 def index2line(index):
1561 return int(float(index))
1562
1563
1564 _line_indent_re = re.compile(r'[ \t]*')
1565 def get_line_indent(line, tabwidth):
1566 """Return a line's indentation as (# chars, effective # of spaces).
1567
1568 The effective # of spaces is the length after properly "expanding"
1569 the tabs into spaces, as done by str.expandtabs(tabwidth).
1570 """
1571 m = _line_indent_re.match(line)
1572 return m.end(), len(m.group().expandtabs(tabwidth))
1573
1574
1575 class IndentSearcher:
1576 "Manage initial indent guess, returned by run method."
1577
1578 def __init__(self, text):
1579 self.text = text
1580 self.i = self.finished = 0
1581 self.blkopenline = self.indentedline = None
1582
1583 def readline(self):
1584 if self.finished:
1585 return ""
1586 i = self.i = self.i + 1
1587 mark = repr(i) + ".0"
1588 if self.text.compare(mark, ">=", "end"):
1589 return ""
1590 return self.text.get(mark, mark + " lineend+1c")
1591
1592 def tokeneater(self, type, token, start, end, line,
1593 INDENT=tokenize.INDENT,
1594 NAME=tokenize.NAME,
1595 OPENERS=('class', 'def', 'for', 'if', 'match', 'try',
1596 'while', 'with')):
1597 if self.finished:
1598 pass
1599 elif type == NAME and token in OPENERS:
1600 self.blkopenline = line
1601 elif type == INDENT and self.blkopenline:
1602 self.indentedline = line
1603 self.finished = 1
1604
1605 def run(self):
1606 """Return 2 lines containing block opener and indent.
1607
1608 Either the indent line or both may be None.
1609 """
1610 try:
1611 tokens = tokenize.generate_tokens(self.readline)
1612 for token in tokens:
1613 self.tokeneater(*token)
1614 except (tokenize.TokenError, SyntaxError):
1615 # Stopping the tokenizer early can trigger spurious errors.
1616 pass
1617 return self.blkopenline, self.indentedline
1618
1619 ### end autoindent code ###
1620
1621
1622 def prepstr(s):
1623 """Extract the underscore from a string.
1624
1625 For example, prepstr("Co_py") returns (2, "Copy").
1626
1627 Args:
1628 s: String with underscore.
1629
1630 Returns:
1631 Tuple of (position of underscore, string without underscore).
1632 """
1633 i = s.find('_')
1634 if i >= 0:
1635 s = s[:i] + s[i+1:]
1636 return i, s
1637
1638
1639 keynames = {
1640 'bracketleft': '[',
1641 'bracketright': ']',
1642 'slash': '/',
1643 }
1644
1645 def get_accelerator(keydefs, eventname):
1646 """Return a formatted string for the keybinding of an event.
1647
1648 Convert the first keybinding for a given event to a form that
1649 can be displayed as an accelerator on the menu.
1650
1651 Args:
1652 keydefs: Dictionary of valid events to keybindings.
1653 eventname: Event to retrieve keybinding for.
1654
1655 Returns:
1656 Formatted string of the keybinding.
1657 """
1658 keylist = keydefs.get(eventname)
1659 # issue10940: temporary workaround to prevent hang with OS X Cocoa Tk 8.5
1660 # if not keylist:
1661 if (not keylist) or (macosx.isCocoaTk() and eventname in {
1662 "<<open-module>>",
1663 "<<goto-line>>",
1664 "<<change-indentwidth>>"}):
1665 return ""
1666 s = keylist[0]
1667 # Convert strings of the form -singlelowercase to -singleuppercase.
1668 s = re.sub(r"-[a-z]\b", lambda m: m.group().upper(), s)
1669 # Convert certain keynames to their symbol.
1670 s = re.sub(r"\b\w+\b", lambda m: keynames.get(m.group(), m.group()), s)
1671 # Remove Key- from string.
1672 s = re.sub("Key-", "", s)
1673 # Convert Cancel to Ctrl-Break.
1674 s = re.sub("Cancel", "Ctrl-Break", s) # [email protected]
1675 # Convert Control to Ctrl-.
1676 s = re.sub("Control-", "Ctrl-", s)
1677 # Change - to +.
1678 s = re.sub("-", "+", s)
1679 # Change >< to space.
1680 s = re.sub("><", " ", s)
1681 # Remove <.
1682 s = re.sub("<", "", s)
1683 # Remove >.
1684 s = re.sub(">", "", s)
1685 return s
1686
1687
1688 def fixwordbreaks(root):
1689 # On Windows, tcl/tk breaks 'words' only on spaces, as in Command Prompt.
1690 # We want Motif style everywhere. See #21474, msg218992 and followup.
1691 tk = root.tk
1692 tk.call('tcl_wordBreakAfter', 'a b', 0) # make sure word.tcl is loaded
1693 tk.call('set', 'tcl_wordchars', r'\w')
1694 tk.call('set', 'tcl_nonwordchars', r'\W')
1695
1696
1697 def _editor_window(parent): # htest #
1698 # error if close master window first - timer event, after script
1699 root = parent
1700 fixwordbreaks(root)
1701 if sys.argv[1:]:
1702 filename = sys.argv[1]
1703 else:
1704 filename = None
1705 macosx.setupApp(root, None)
1706 edit = EditorWindow(root=root, filename=filename)
1707 text = edit.text
1708 text['height'] = 10
1709 for i in range(20):
1710 text.insert('insert', ' '*i + str(i) + '\n')
1711 # text.bind("<<close-all-windows>>", edit.close_event)
1712 # Does not stop error, neither does following
1713 # edit.text.bind("<<close-window>>", edit.close_event)
1714
1715
1716 if __name__ == '__main__':
1717 from unittest import main
1718 main('idlelib.idle_test.test_editor', verbosity=2, exit=False)
1719
1720 from idlelib.idle_test.htest import run
1721 run(_editor_window)