from idlelib.percolator import Percolator

from idlelib.colorizer import ColorDelegator, color_config

from idlelib.undo import UndoDelegator

from idlelib.iomenu import IOBinding, encoding

from idlelib import mainmenu

from idlelib.statusbar import MultiStatusBar

from idlelib.autocomplete import AutoComplete

from idlelib.autoexpand import AutoExpand

from idlelib.calltip import Calltip

from idlelib.codecontext import CodeContext

from idlelib.sidebar import LineNumbers

from idlelib.format import FormatParagraph, FormatRegion, Indents, Rstrip

from idlelib.parenmatch import ParenMatch

from idlelib.zoomheight import ZoomHeight

filesystemencoding = sys.getfilesystemencoding() # for file names

help_url = None

allow_code_context = True

allow_line_numbers = True

user_input_insert_tags = None

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

# Delay import: runscript imports pyshell imports EditorWindow.

from idlelib.runscript import ScriptBinding

if EditorWindow.help_url is None:

EditorWindow.help_url = _get_dochome()

self.flist = flist

root = root or flist.root

self.root = root

self.menubar = Menu(root)

self.top = top = window.ListedToplevel(root, menu=self.menubar)

if flist:

self.tkinter_vars = flist.vars

#self.top.instance_dict makes flist.inversedict available to

#configdialog.py so it can access all EditorWindow instances

self.top.instance_dict = flist.inversedict

else:

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

# values: Tkinter variable instances

self.top.instance_dict = {}

self.recent_files_path = idleConf.userdir and os.path.join(

idleConf.userdir, 'recent-files.lst')

self.prompt_last_line = '' # Override in PyShell

self.text_frame = text_frame = Frame(top)

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

width = idleConf.GetOption('main', 'EditorWindow', 'width', type='int')

text_options = {

'name': 'text',

'padx': 5,

'wrap': 'none',

'highlightthickness': 0,

'width': width,

'tabstyle': 'wordprocessor', # new in 8.5

'height': idleConf.GetOption(

'main', 'EditorWindow', 'height', type='int'),

}

self.text = text = MultiCallCreator(Text)(text_frame, **text_options)

self.top.focused_widget = self.text

self.createmenubar()

self.apply_bindings()

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

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

if macosx.isAquaTk():

# Command-W on editor windows doesn't work without this.

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

# Some OS X systems have only one mouse button, so use

# control-click for popup context menus there. For two

# buttons, AquaTk defines <2> as the right button, not <3>.

text.bind("<Control-Button-1>",self.right_menu_event)

text.bind("<2>", self.right_menu_event)

else:

# Elsewhere, use right-click for popup menus.

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

bind_wheel(text, wheel_event)

text.bind('<Configure>', self.handle_winconfig)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

self.fregion = fregion = self.FormatRegion(self)

# self.fregion used in smart_indent_event to access indent_region.

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

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

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

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

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

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

indents = self.Indents(self)

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

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

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

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

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

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

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

if flist:

flist.inversedict[self] = key

if key:

flist.dict[key] = self

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

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

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

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

text.bind("<<open-turtle-demo>>", self.open_turtle_demo)

self.set_status_bar()

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

text_frame.rowconfigure(1, weight=1)

text_frame.columnconfigure(1, weight=1)

vbar['command'] = self.handle_yview

vbar.grid(row=1, column=2, sticky=NSEW)

text['yscrollcommand'] = vbar.set

text['font'] = idleConf.GetFont(self.root, 'main', 'EditorWindow')

text.grid(row=1, column=1, sticky=NSEW)

text.focus_set()

self.set_width()

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

# dedent cmds, possibly mixed with spaces if

# indentwidth is not a multiple of tabwidth,

# which will cause Tabnanny to nag!

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

# and dedent cmds, and ditto TAB keystrokes

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

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

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

usespaces = idleConf.GetOption('main', 'Indent',

'use-spaces', type='bool')

self.usetabs = not usespaces

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

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

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

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

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

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

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

# The recommended Python indentation is four spaces.

self.indentwidth = self.tabwidth

self.set_notabs_indentwidth()

# Store the current value of the insertofftime now so we can restore

# it if needed.

if not hasattr(idleConf, 'blink_off_time'):

idleConf.blink_off_time = self.text['insertofftime']

self.update_cursor_blink()

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

# first start num_context_lines[0] lines back, then

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

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

# conceivable file).

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

self.num_context_lines = 50, 500, 5000000

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

self.undo = undo = self.UndoDelegator()

per.insertfilter(undo)

text.undo_block_start = undo.undo_block_start

text.undo_block_stop = undo.undo_block_stop

undo.set_saved_change_hook(self.saved_change_hook)

# IOBinding implements file I/O and printing functionality

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

io.set_filename_change_hook(self.filename_change_hook)

self.good_load = False

self.set_indentation_params(False)

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

self.code_context = None # optionally initialized later below

self.line_numbers = None # optionally initialized later below

if filename:

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

if io.loadfile(filename):

self.good_load = True

is_py_src = self.ispythonsource(filename)

self.set_indentation_params(is_py_src)

else:

io.set_filename(filename)

self.good_load = True

self.ResetColorizer()

self.saved_change_hook()

self.update_recent_files_list()

self.load_extensions()

menu = self.menudict.get('window')

if menu:

end = menu.index("end")

if end is None:

end = -1

if end >= 0:

menu.add_separator()

end = end + 1

self.wmenu_end = end

window.register_callback(self.postwindowsmenu)

# Some abstractions so IDLE extensions are cross-IDE

self.askinteger = simpledialog.askinteger

self.askyesno = messagebox.askyesno

self.showerror = messagebox.showerror

# Add pseudoevents for former extension fixed keys.

# (This probably needs to be done once in the process.)

text.event_add('<<autocomplete>>', '<Key-Tab>')

text.event_add('<<try-open-completions>>', '<KeyRelease-period>',

'<KeyRelease-slash>', '<KeyRelease-backslash>')

text.event_add('<<try-open-calltip>>', '<KeyRelease-parenleft>')

text.event_add('<<refresh-calltip>>', '<KeyRelease-parenright>')

text.event_add('<<paren-closed>>', '<KeyRelease-parenright>',

'<KeyRelease-bracketright>', '<KeyRelease-braceright>')

# Former extension bindings depends on frame.text being packed

# (called from self.ResetColorizer()).

autocomplete = self.AutoComplete(self, self.user_input_insert_tags)

text.bind("<<autocomplete>>", autocomplete.autocomplete_event)

text.bind("<<try-open-completions>>",

autocomplete.try_open_completions_event)

text.bind("<<force-open-completions>>",

autocomplete.force_open_completions_event)

text.bind("<<expand-word>>", self.AutoExpand(self).expand_word_event)

text.bind("<<format-paragraph>>",

self.FormatParagraph(self).format_paragraph_event)

parenmatch = self.ParenMatch(self)

text.bind("<<flash-paren>>", parenmatch.flash_paren_event)

text.bind("<<paren-closed>>", parenmatch.paren_closed_event)

scriptbinding = ScriptBinding(self)

text.bind("<<check-module>>", scriptbinding.check_module_event)

text.bind("<<run-module>>", scriptbinding.run_module_event)

text.bind("<<run-custom>>", scriptbinding.run_custom_event)

text.bind("<<do-rstrip>>", self.Rstrip(self).do_rstrip)

self.ctip = ctip = self.Calltip(self)

text.bind("<<try-open-calltip>>", ctip.try_open_calltip_event)

#refresh-calltip must come after paren-closed to work right

text.bind("<<refresh-calltip>>", ctip.refresh_calltip_event)

text.bind("<<force-open-calltip>>", ctip.force_open_calltip_event)

text.bind("<<zoom-height>>", self.ZoomHeight(self).zoom_height_event)

if self.allow_code_context:

self.code_context = self.CodeContext(self)

text.bind("<<toggle-code-context>>",

self.code_context.toggle_code_context_event)

else:

self.update_menu_state('options', '*ode*ontext', 'disabled')

if self.allow_line_numbers:

self.line_numbers = self.LineNumbers(self)

if idleConf.GetOption('main', 'EditorWindow',

'line-numbers-default', type='bool'):

self.toggle_line_numbers_event()

text.bind("<<toggle-line-numbers>>", self.toggle_line_numbers_event)

else:

self.update_menu_state('options', '*ine*umbers', 'disabled')

self.mtime = self.last_mtime()

text_frame.bind('<FocusIn>', self.focus_in_event)

def handle_winconfig(self, event=None):

self.set_width()

def set_width(self):

text = self.text

inner_padding = sum(map(text.tk.getint, [text.cget('border'),

text.cget('padx')]))

pixel_width = text.winfo_width() - 2 * inner_padding

# Divide the width of the Text widget by the font width,

# which is taken to be the width of '0' (zero).

# http://www.tcl.tk/man/tcl8.6/TkCmd/text.htm#M21

zero_char_width = \

Font(text, font=text.cget('font')).measure('0')

# Some fonts report a zero width for '0' (gh-90304).

self.width = (pixel_width // zero_char_width if zero_char_width

else text.tk.getint(text.cget('width')))

def new_callback(self, event):

dirname, basename = self.io.defaultfilename()

self.flist.new(dirname)

return "break"

def home_callback(self, event):

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

# state&4==Control. If <Control-Home>, use the Tk binding.

return None

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

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

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

# In Shell on input line, go to just after prompt

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

else:

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

for insertpt in range(len(line)):

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

break

else:

insertpt=len(line)

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

if insertpt == lineat:

insertpt = 0

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

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

# shift was not pressed

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

else:

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

# there was no previous selection

self.text.mark_set("my_anchor", "insert")

else:

if self.text.compare(self.text.index("sel.first"), "<",

self.text.index("insert")):

self.text.mark_set("my_anchor", "sel.first") # extend back

else:

self.text.mark_set("my_anchor", "sel.last") # extend forward

first = self.text.index(dest)

last = self.text.index("my_anchor")

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

first,last = last,first

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

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

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

self.text.see("insert")

return "break"

def set_status_bar(self):

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

sep = Frame(self.top, height=1, borderwidth=1, background='grey75')

if sys.platform == "darwin":

# Insert some padding to avoid obscuring some of the statusbar

# by the resize widget.

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

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

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

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

sep.pack(side=BOTTOM, fill=X)

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

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

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

self.text.after_idle(self.set_line_and_column)

def set_line_and_column(self, event=None):

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

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

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

""" Menu definitions and functions.

menu_specs = [

("file", "_File"),

("edit", "_Edit"),

("format", "F_ormat"),

("run", "_Run"),

("options", "_Options"),

("window", "_Window"),

("help", "_Help"),

]

def createmenubar(self):

"""Populate the menu bar widget for the editor window.

mbar = self.menubar

self.menudict = menudict = {}

for name, label in self.menu_specs:

underline, label = prepstr(label)

postcommand = getattr(self, f'{name}_menu_postcommand', None)

menudict[name] = menu = Menu(mbar, name=name, tearoff=0,

postcommand=postcommand)

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

if macosx.isCarbonTk():

# Insert the application menu

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

tearoff=0)

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

self.fill_menus()

self.recent_files_menu = Menu(self.menubar, tearoff=0)

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

underline=0,

menu=self.recent_files_menu)

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

self.reset_help_menu_entries()

def postwindowsmenu(self):

"""Callback to register window.

menu = self.menudict['window']

end = menu.index("end")

if end is None:

end = -1

if end > self.wmenu_end:

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

window.add_windows_to_menu(menu)

def update_menu_label(self, menu, index, label):

"Update label for menu item at index."

menuitem = self.menudict[menu]

menuitem.entryconfig(index, label=label)

def update_menu_state(self, menu, index, state):

"Update state for menu item at index."

menuitem = self.menudict[menu]

menuitem.entryconfig(index, state=state)

def handle_yview(self, event, *args):

"Handle scrollbar."

if event == 'moveto':

fraction = float(args[0])

lines = (round(self.getlineno('end') * fraction) -

self.getlineno('@0,0'))

event = 'scroll'

args = (lines, 'units')

self.text.yview(event, *args)

return 'break'

rmenu = None

def right_menu_event(self, event):

text = self.text

newdex = text.index(f'@{event.x},{event.y}')

try:

in_selection = (text.compare('sel.first', '<=', newdex) and

text.compare(newdex, '<=', 'sel.last'))

except TclError:

in_selection = False

if not in_selection:

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

text.mark_set("insert", newdex)

if not self.rmenu:

self.make_rmenu()

rmenu = self.rmenu

self.event = event

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

if iswin:

text.config(cursor="arrow")

for item in self.rmenu_specs:

try:

label, eventname, verify_state = item

except ValueError: # see issue1207589

continue

if verify_state is None:

continue

state = getattr(self, verify_state)()

rmenu.entryconfigure(label, state=state)

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

if iswin:

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

return "break"

rmenu_specs = [

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

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

]

def make_rmenu(self):

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

for item in self.rmenu_specs:

label, eventname = item[0], item[1]

if label is not None:

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

text.event_generate(eventname)

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

else:

rmenu.add_separator()

self.rmenu = rmenu

def rmenu_check_cut(self):

return self.rmenu_check_copy()

def rmenu_check_copy(self):

try:

indx = self.text.index('sel.first')

except TclError:

return 'disabled'

else:

return 'normal' if indx else 'disabled'

def rmenu_check_paste(self):

try:

self.text.tk.call('tk::GetSelection', self.text, 'CLIPBOARD')

except TclError:

return 'disabled'

else:

return 'normal'

def about_dialog(self, event=None):

"Handle Help 'About IDLE' event."

# Synchronize with macosx.overrideRootMenu.about_dialog.

help_about.AboutDialog(self.top)

return "break"

def config_dialog(self, event=None):

"Handle Options 'Configure IDLE' event."

# Synchronize with macosx.overrideRootMenu.config_dialog.

configdialog.ConfigDialog(self.top,'Settings')

return "break"

def help_dialog(self, event=None):

"Handle Help 'IDLE Help' event."

# Synchronize with macosx.overrideRootMenu.help_dialog.

if self.root:

parent = self.root

else:

parent = self.top

help.show_idlehelp(parent)

return "break"

def python_docs(self, event=None):

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

try:

os.startfile(self.help_url)

except OSError as why:

messagebox.showerror(title='Document Start Failure',

message=str(why), parent=self.text)

else:

webbrowser.open(self.help_url)

return "break"

def cut(self,event):

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

return "break"

def copy(self,event):

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

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

return None

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

return "break"

def paste(self,event):

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

self.text.see("insert")

return "break"

def select_all(self, event=None):

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

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

self.text.see("insert")

return "break"

def remove_selection(self, event=None):

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

self.text.see("insert")

return "break"

def move_at_edge_if_selection(self, edge_index):

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

self_text_index = self.text.index

self_text_mark_set = self.text.mark_set

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

def move_at_edge(event):

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

try:

self_text_index("sel.first")

self_text_mark_set("insert", edges_table[edge_index])

except TclError:

pass

return move_at_edge

def del_word_left(self, event):

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

return "break"

def del_word_right(self, event):

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

return "break"

def find_event(self, event):

search.find(self.text)

return "break"

def find_again_event(self, event):

search.find_again(self.text)

return "break"

def find_selection_event(self, event):

search.find_selection(self.text)

return "break"

def find_in_files_event(self, event):

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

return "break"

def replace_event(self, event):

replace.replace(self.text)

return "break"

def goto_line_event(self, event):

text = self.text

lineno = query.Goto(

text, "Go To Line",

"Enter a positive integer\n"

"('big' = end of file):"

).result

if lineno is not None:

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

text.mark_set("insert", f'{lineno}.0')

text.see("insert")

self.set_line_and_column()

return "break"

def open_module(self):

"""Get module name from user and open it.

# XXX This, open_module_browser, and open_path_browser

# would fit better in iomenu.IOBinding.

try:

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

except TclError:

name = ''

file_path = query.ModuleName(

self.text, "Open Module",

"Enter the name of a Python module\n"

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

name).result

if file_path is not None:

if self.flist:

self.flist.open(file_path)

else:

self.io.loadfile(file_path)

return file_path

def open_module_event(self, event):

self.open_module()

return "break"

def open_module_browser(self, event=None):

filename = self.io.filename

if not (self.__class__.__name__ == 'PyShellEditorWindow'

and filename):

filename = self.open_module()

if filename is None:

return "break"

from idlelib import browser

browser.ModuleBrowser(self.root, filename)

return "break"

def open_path_browser(self, event=None):

from idlelib import pathbrowser

pathbrowser.PathBrowser(self.root)

return "break"

def open_turtle_demo(self, event = None):

import subprocess

cmd = [sys.executable,

'-c',

'from turtledemo.__main__ import main; main()']

subprocess.Popen(cmd, shell=False)

return "break"

def gotoline(self, lineno):

if lineno is not None and lineno > 0:

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

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

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

self.center()

def ispythonsource(self, filename):

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

return True

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

if os.path.normcase(ext) in py_extensions:

return True

line = self.text.get('1.0', '1.0 lineend')

return line.startswith('#!') and 'python' in line

def close_hook(self):

if self.flist:

self.flist.unregister_maybe_terminate(self)

self.flist = None

def set_close_hook(self, close_hook):

self.close_hook = close_hook

def filename_change_hook(self):

if self.flist:

self.flist.filename_changed_edit(self)

self.saved_change_hook()

self.top.update_windowlist_registry(self)

self.ResetColorizer()

def _addcolorizer(self):

if self.color:

return

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

self.color = self.ColorDelegator()

# can add more colorizers here...

if self.color:

self.per.insertfilterafter(filter=self.color, after=self.undo)

def _rmcolorizer(self):

if not self.color:

return

self.color.removecolors()

self.per.removefilter(self.color)

self.color = None

def ResetColorizer(self):

"Update the color theme"

# Called from self.filename_change_hook and from configdialog.py

self._rmcolorizer()

self._addcolorizer()

EditorWindow.color_config(self.text)

if self.code_context is not None:

self.code_context.update_highlight_colors()

if self.line_numbers is not None:

self.line_numbers.update_colors()

IDENTCHARS = string.ascii_letters + string.digits + "_"

def colorize_syntax_error(self, text, pos):

text.tag_add("ERROR", pos)

char = text.get(pos)

if char and char in self.IDENTCHARS:

text.tag_add("ERROR", pos + " wordstart", pos)

if '\n' == text.get(pos): # error at line end

text.mark_set("insert", pos)

else:

text.mark_set("insert", pos + "+1c")

text.see(pos)

def update_cursor_blink(self):

"Update the cursor blink configuration."

cursorblink = idleConf.GetOption(

'main', 'EditorWindow', 'cursor-blink', type='bool')

if not cursorblink:

self.text['insertofftime'] = 0

else:

# Restore the original value

self.text['insertofftime'] = idleConf.blink_off_time

def ResetFont(self):

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

# Called from configdialog.py

# Update the code context widget first, since its height affects

# the height of the text widget. This avoids double re-rendering.

if self.code_context is not None:

self.code_context.update_font()

# Next, update the line numbers widget, since its width affects

# the width of the text widget.

if self.line_numbers is not None:

self.line_numbers.update_font()

# Finally, update the main text widget.

new_font = idleConf.GetFont(self.root, 'main', 'EditorWindow')

self.text['font'] = new_font

self.set_width()

def RemoveKeybindings(self):

"""Remove the virtual, configurable keybindings.

# Called from configdialog.deactivate_current_config.

self.mainmenu.default_keydefs = keydefs = idleConf.GetCurrentKeySet()

for event, keylist in keydefs.items():

self.text.event_delete(event, *keylist)

for extensionName in self.get_standard_extension_names():

xkeydefs = idleConf.GetExtensionBindings(extensionName)

for event, keylist in xkeydefs.items():

self.text.event_delete(event, *keylist)

def ApplyKeybindings(self):

"""Apply the virtual, configurable keybindings.

# Called from configdialog.activate_config_changes.

self.mainmenu.default_keydefs = keydefs = idleConf.GetCurrentKeySet()

self.apply_bindings()

for extensionName in self.get_standard_extension_names():

xkeydefs = idleConf.GetExtensionBindings(extensionName)

if xkeydefs:

self.apply_bindings(xkeydefs)

# Update menu accelerators.

menuEventDict = {}

for menu in self.mainmenu.menudefs:

menuEventDict[menu[0]] = {}

for item in menu[1]:

if item:

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

for menubarItem in self.menudict:

menu = self.menudict[menubarItem]

end = menu.index(END)

if end is None:

# Skip empty menus

continue

end += 1

for index in range(0, end):

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

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

if accel:

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

event = ''

if menubarItem in menuEventDict:

if itemName in menuEventDict[menubarItem]:

event = menuEventDict[menubarItem][itemName]

if event:

accel = get_accelerator(keydefs, event)

menu.entryconfig(index, accelerator=accel)

def set_notabs_indentwidth(self):

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

# Called from configdialog.py

if not self.usetabs:

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

type='int')

def reset_help_menu_entries(self):

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

help_list = idleConf.GetAllExtraHelpSourcesList()

helpmenu = self.menudict['help']

# First delete the extra help entries, if any.

helpmenu_length = helpmenu.index(END)

if helpmenu_length > self.base_helpmenu_length:

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

# Then rebuild them.

if help_list:

helpmenu.add_separator()

for entry in help_list:

cmd = self._extra_help_callback(entry[1])

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

# And update the menu dictionary.

self.menudict['help'] = helpmenu

def _extra_help_callback(self, resource):

"""Return a callback that loads resource (file or web page)."""

def display_extra_help(helpfile=resource):

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

helpfile = os.path.normpath(helpfile)

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

try:

os.startfile(helpfile)

except OSError as why:

messagebox.showerror(title='Document Start Failure',

message=str(why), parent=self.text)

else:

webbrowser.open(helpfile)

return display_extra_help

def update_recent_files_list(self, new_file=None):

"Load and update the recent files list and menus"

# TODO: move to iomenu.

rf_list = []

file_path = self.recent_files_path

if file_path and os.path.exists(file_path):

with open(file_path,

encoding='utf_8', errors='replace') as rf_list_file:

rf_list = rf_list_file.readlines()

if new_file:

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

if new_file in rf_list:

rf_list.remove(new_file) # move to top

rf_list.insert(0, new_file)

# clean and save the recent files list

bad_paths = []

for path in rf_list:

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

bad_paths.append(path)

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

ulchars = "1234567890ABCDEFGHIJK"

rf_list = rf_list[0:len(ulchars)]

if file_path:

try:

with open(file_path, 'w',

encoding='utf_8', errors='replace') as rf_file:

rf_file.writelines(rf_list)

except OSError as err:

if not getattr(self.root, "recentfiles_message", False):

self.root.recentfiles_message = True

messagebox.showwarning(title='IDLE Warning',

message="Cannot save Recent Files list to disk.\n"

f" {err}\n"

"Select OK to continue.",

parent=self.text)

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

for instance in self.top.instance_dict:

menu = instance.recent_files_menu

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

for i, file_name in enumerate(rf_list):

file_name = file_name.rstrip() # zap \n

callback = instance.__recent_file_callback(file_name)

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

command=callback,

underline=0)

def __recent_file_callback(self, file_name):

def open_recent_file(fn_closure=file_name):

self.io.open(editFile=fn_closure)

return open_recent_file

def saved_change_hook(self):

short = self.short_title()

long = self.long_title()

_py_version = ' (%s)' % platform.python_version()

if short and long and not macosx.isCocoaTk():

# Don't use both values on macOS because

# that doesn't match platform conventions.