| 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) |