logo

oasis-root

Compiled tree of Oasis Linux based on own branch at <https://hacktivis.me/git/oasis/> git clone https://anongit.hacktivis.me/git/oasis-root.git

editor.py (65876B)


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