You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
ORPA-pyOpenRPA/WPy32-3720/python-3.7.2/Lib/site-packages/idlexlib/extensions/SearchBar.py

953 lines
33 KiB

# IDLEX EXTENSION
## """SearchBar.py - An IDLE extension for searching for text in windows.
##
## Copyright (c) 2011 Tal Einat
## All rights reserved.
##
## Developed by: Tal Einat
##
## Permission is hereby granted, free of charge, to any person obtaining a
## copy of this software and associated documentation files (the "Software"),
## to deal with the Software without restriction, including without limitation
## the rights to use, copy, modify, merge, publish, distribute, sublicense,
## and/or sell copies of the Software, and to permit persons to whom the
## Software is furnished to do so, subject to the following conditions:
##
## Redistributions of source code must retain the above copyright notice,
## this list of conditions and the following disclaimers.
##
## Redistributions in binary form must reproduce the above copyright notice,
## this list of conditions and the following disclaimers in the documentation
## and/or other materials provided with the distribution.
##
## Neither the name of Tal Einat, nor the names of its contributors may be
## used to endorse or promote products derived from this Software without
## specific prior written permission.
##
## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
## EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
## MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
## IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR
## ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
## TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
## OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE.
##
##
##
## The interface is a small bar which appears on the bottom of the window,
## and dissapears when the user stops searching.
##
## This extension implements the usual search options, as well as regular
## expressions.
##
## Another nice feature is that while searching all matches are highlighted.
##
##
## Original Author: Tal Einat
##
## Modified by Roger D. Serwy to work with idlex and Python 3,
## as well as some bugfixes and improvements.
##
##
##
## """
config_extension_def = """
[SearchBar]
enable=1
is_incremental=1
reg_exp=0
match_case=0
whole_word=0
wrap_around=0
[Searchbar_cfgBindings]
toggle-search-bar=
"""
import time
import string
import re
import sys
if sys.version < '3':
import Tkinter
from Tkconstants import TOP, BOTTOM, LEFT, RIGHT, X, NONE
else:
import tkinter as Tkinter
from tkinter.constants import TOP, BOTTOM, LEFT, RIGHT, X, NONE
EXTNAME = 'SearchBar'
from idlelib.configHandler import idleConf
from idlelib.SearchEngine import SearchEngine
class SearchBarSearchEngine(SearchEngine):
""" Silence regex errors.
Incremental highlighting doesn't play well with mal-formed regex.
"""
def __init__(self, *args, **kw):
SearchEngine.__init__(self, *args, **kw)
self._error_callback_ptr = None
self._incrementalSearch = False
self.varlist = [self.revar, self.casevar, self.wordvar, self.wrapvar]
self.tracelist = []
def report_error(self, pat, msg, col=-1):
#print('report_error', pat, msg, col,self._incrementalSearch)
if self._incrementalSearch:
if self._error_callback_ptr:
return self._error_callback_ptr(pat, msg, col)
else:
return None
else:
return SearchEngine.report_error(self, pat, msg, col)
def error_callback(self, ptr):
# This is set by FindBar and ReplaceBar instances so that it
# calls the correct callback
self._error_callback_ptr = ptr
def load_cfg(self):
# Load settings from configuration handler - RDS 2012-02-03
self.revar.set(get_cfg('reg_exp', default=False))
self.casevar.set(get_cfg('match_case', default=False))
self.wordvar.set(get_cfg('whole_word', default=False))
self.wrapvar.set(get_cfg('wrap_around', default=False))
def save_cfg(self):
set_cfg('reg_exp', '%s' % self.revar.get())
set_cfg('match_case', '%s' % self.casevar.get())
set_cfg('whole_word', '%s' % self.wordvar.get())
set_cfg('wrap_around', '%s' % self.wrapvar.get())
def set_var_trace(self, ptr):
obs = []
for v in self.varlist:
obs.append(v.trace("w", ptr))
self.tracelist = zip(obs, self.varlist)
def remove_var_trace(self):
for obs, v in self.tracelist:
v.trace_vdelete('w', obs)
self.tracelist = []
def get_cfg(cfg, type="bool", default=True):
return idleConf.GetOption("extensions", EXTNAME,
cfg, type=type, default=default)
def set_cfg(cfg, b):
return idleConf.SetOption("extensions", EXTNAME,
cfg,'%s' % b)
class SearchBar:
menudefs = []
def __init__(self, editwin):
text = editwin.text
self.engine = engine = SearchBarSearchEngine(text)
self.fb = find_bar = FindBar(editwin, editwin.status_bar, engine)
self.rb = replace_bar = ReplaceBar(editwin, editwin.status_bar, engine)
def find_event(event):
replace_bar.hide_findbar_event(event, focus=False)
find_bar.show_findbar_event(event)
return "break"
text.bind("<<find>>", find_event)
def find_again_event(event):
find_bar.search_again_event(event)
return "break"
text.bind("<<find-again>>", find_again_event)
def find_selection_event(event):
find_bar.search_selection_event(event)
return "break"
text.bind("<<find-selection>>", find_selection_event)
def replace_event(event):
find_bar.hide_findbar_event(event, focus=False)
replace_bar.show_findbar_event(event)
return "break"
text.bind("<<replace>>", replace_event)
def close(self):
self.engine.save_cfg()
def FindBar(editwin, pack_after, engine):
return SearchBarWidget(editwin, pack_after, engine, is_replace=False)
def ReplaceBar(editwin, pack_after, engine):
return SearchBarWidget(editwin, pack_after, engine, is_replace=True)
class SearchBarWidget:
def __init__(self, editwin, pack_after, engine, is_replace=False):
self.text = editwin.text
self.root = self.text._root()
self.engine = engine
self.window_engine = get_window_engine(editwin)
self.is_replace = is_replace
self.top = editwin.top
self.pack_after = pack_after
self.widgets_built = False
self.shown = False
self.find_var = Tkinter.StringVar(self.root)
# The text widget's selection isn't shown when it doesn't have the
# focus. Let's replicate it so it will be seen while searching as well.
self.text.tag_configure("findsel",
background=self.text.tag_cget("sel","background"),
foreground=self.text.tag_cget("sel","foreground"))
self._is_incremental = None
self._expand_state = None
self.text.bind('<FocusIn>', self.text_focusin_event, '+')
def toggle_search_bar_event(self, event=None): # RDS - 2011-10-18
self.text.event_generate('<<find>>')
return "break"
def _show(self):
if not self.widgets_built:
self._build_widgets()
if not self.shown:
self.bar_frame.pack(side=BOTTOM, fill=X, expand=0, pady=1,
after=self.pack_after)
self.window_engine.show_find_marks()
self.shown = True # must be _before_ reset_selection()!
# Add the "findsel" tag, which looks like the selection
self._reset_selection()
self._is_incremental = self.is_incremental()
self._expand_state = None
self.engine.error_callback(self._error_callback)
self.engine.load_cfg()
self.engine.set_var_trace(self._incremental_callback)
def _hide(self, setcursor=False):
if self.widgets_built and self.shown:
v = self.text.yview()
self.bar_frame.pack_forget()
self.text.update_idletasks()
try:
self.text.yview_moveto(v[0]) # Tkinter work-around
except Exception as err: # This should never happen
print('SearchBar._hide', err)
self.window_engine.reset()
self.window_engine.hide_find_marks()
sel = self._get_selection()
self.shown = False # must be _after_ get_selection()!
if setcursor:
if sel:
self._set_selection(sel[0], sel[1])
self.text.mark_set("insert", sel[0])
else:
self._reset_selection()
self.text.see("insert")
self.text.tag_remove("findsel","1.0","end")
self._is_incremental = None
self._expand_state = None
self.engine.error_callback(None)
self.engine.save_cfg()
self.engine.remove_var_trace()
def _error_callback(self, pat, msg, col=-1):
# A callback for the SearchBarSearchEngine .report_error method
self.window_engine.reset()
pass
def is_incremental(self):
if self._is_incremental is None:
return get_cfg("is_incremental", default=False)
else:
return self._is_incremental
def _incremental_callback(self, *args):
self.engine._incrementalSearch = True
if self.shown and self.is_incremental():
if self.find_var.get():
self._safe_search(start=self.text.index("insert"))
else:
self.window_engine.reset()
self._clear_selection()
self.text.see("insert")
self.engine._incrementalSearch = False
def _build_widgets(self):
if not self.widgets_built:
def _make_entry(parent, label, var, width=7):
l = Tkinter.Label(parent, text=label, width=width, anchor="e")
l.pack(side=LEFT, fill=NONE, expand=0)
e = Tkinter.Entry(parent, textvariable=var, exportselection=0,
width=30, border=1)
e.pack(side=LEFT, fill=NONE, expand=0)
e.bind("<Escape>", self.hide_findbar_event)
return e
def _make_checkbutton(parent, label, var):
btn = Tkinter.Checkbutton(parent, anchor="w",
text=label, variable=var)
btn.pack(side=LEFT, fill=NONE, expand=0)
btn.bind("<Escape>", self.hide_findbar_event)
return btn
def _make_button(parent, label, command):
btn = Tkinter.Button(parent, text=label, command=command)
btn.pack(side=LEFT, fill=NONE, expand=0)
btn.bind("<Escape>", self.hide_findbar_event)
return btn
# Frame for the entire bar
self.bar_frame = Tkinter.Frame(self.top, border=1, relief="flat")
# Frame for the 'Find:' / 'Replace:' entry and direction
self.find_frame = Tkinter.Frame(self.bar_frame, border=0)
tabstop_top = Tkinter.Label(self.find_frame, takefocus=1, text='',
highlightthickness=0)
tabstop_top.pack(side=LEFT)
# 'Find:' / 'Replace:' entry
if not self.is_replace: tmp = "Find:"
else: tmp = "Replace:"
self.find_ent = _make_entry(self.find_frame,
tmp, self.find_var)
self.find_frame.pack(side=TOP, fill=X, expand=1)
if self.is_replace:
# Frame for the 'With:' entry + replace options
self.replace_frame = Tkinter.Frame(self.bar_frame, border=0)
tmp = Tkinter.Label(self.replace_frame, takefocus=0, text='',
highlightthickness=0)
tmp.pack(side=LEFT)
self.replace_with_var = Tkinter.StringVar(self.root)
self.replace_ent = _make_entry(self.replace_frame,"With:",
self.replace_with_var)
self.replace_frame.pack(side=TOP, fill=X, expand=0)
# Frame for the 'Find:' options
self.find_frame_options = Tkinter.Frame(self.bar_frame, border=0) # RDS - 2011-11-12
# Regular expression checkbutton
btn = _make_checkbutton(self.find_frame_options,
"Reg-Exp", self.engine.revar)
if self.engine.isre():
btn.select()
self.reg_btn = btn
# Match case checkbutton
btn = _make_checkbutton(self.find_frame_options,
"Match case", self.engine.casevar)
if self.engine.iscase():
btn.select()
self.case_btn = btn
# Whole word checkbutton
btn = _make_checkbutton(self.find_frame_options,
"Whole word", self.engine.wordvar)
if self.engine.isword():
btn.select()
self.word_btn = btn
# Wrap checkbutton
btn = _make_checkbutton(self.find_frame_options,
"Wrap around", self.engine.wrapvar)
if self.engine.iswrap():
btn.select()
self.wrap_btn = btn
self.find_frame_options.pack(side=TOP, fill=X, expand=1)
# Replace buttons (if needed)
if self.is_replace:
self.replace_frame_buttons = Tkinter.Frame(self.bar_frame, border=0)
self.find_btn = _make_button(self.replace_frame_buttons, "Find",
self._search)
self.replace_btn = _make_button(self.replace_frame_buttons, "Replace",
self._replace_event)
self.replace_find_btn = _make_button(self.replace_frame_buttons, "Replace+Find",
self._replace_find_event)
self.replace_all_btn = _make_button(self.replace_frame_buttons, "Replace All",
self._replace_all_event)
self.replace_frame_buttons.pack(side=TOP, fill=X, expand=0)
# Place the direction checkbutton in the correct frame
if self.is_replace:
target = self.replace_frame
else:
target = self.find_frame
# Direction checkbutton
Tkinter.Label(target, text="Direction:").pack(side=LEFT,
fill=NONE,
expand=0,padx=6)
self.direction_txt_var = Tkinter.StringVar(self.root)
btn = Tkinter.Checkbutton(target,
textvariable=self.direction_txt_var,
variable=self.engine.backvar,
command=self._update_direction_button,
indicatoron=0,
width=5,
)
btn.config(selectcolor=btn.cget("bg"))
btn.pack(side=LEFT, fill=NONE, expand=0)
if self.engine.isback():
btn.select()
self.direction_txt_var.set("Up")
else:
btn.deselect()
self.direction_txt_var.set("Down")
btn.bind("<Escape>",self.hide_findbar_event)
self.direction_btn = btn
self.widgets_built = True
# Key bindings for the 'Find:' / 'Replace:' Entry widget
self.find_ent.bind("<Control-Key-f>", self._safe_search)
self.find_ent.bind("<Control-Key-g>", self._safe_search)
self.find_ent.bind("<Control-Key-R>", self._toggle_reg_event)
self.find_ent.bind("<Control-Key-C>", self._toggle_case_event)
self.find_ent.bind("<Control-Key-W>", self._toggle_wrap_event)
self.find_ent.bind("<Control-Key-D>", self._toggle_direction_event)
self.find_ent_expander = EntryExpander(self.find_ent, self.text)
self.find_ent_expander.bind("<Alt-Key-slash>")
callback = self.find_ent._register(self._incremental_callback)
self.find_ent.tk.call("trace", "variable", self.find_var, "w",
callback)
keySetName = idleConf.CurrentKeys()
find_bindings = idleConf.GetKeyBinding(keySetName, '<<find-again>>')
for key_event in find_bindings:
self.find_ent.bind(key_event, self._search) # RDS - 2011-11-03
if not self.is_replace:
# Key bindings for the 'Find:' Entry widget
self.find_ent.bind("<Return>", self._safe_search)
def tab_fix1(ev):
if ev.state & 1 == 0: # Windows Fix
self.find_ent.focus()
return "break"
self.wrap_btn.bind('<Tab>', tab_fix1)
def tab_fix2(ev):
self.wrap_btn.focus()
return "break"
tabstop_top.bind('<FocusIn>', tab_fix2)
else:
# Key bindings for the 'Replace:' Entry widget
self.find_ent.bind("<Return>", self._replace_bar_find_entry_return_event)
# Key bindings for the 'With:' Entry widget
self.replace_ent.bind("<Return>", self._replace_event)
self.replace_ent.bind("<Shift-Return>", self._safe_search)
self.replace_ent.bind("<Control-Key-f>", self._safe_search)
self.replace_ent.bind("<Control-Key-g>", self._safe_search)
self.replace_ent.bind("<Control-Key-R>", self._toggle_reg_event)
self.replace_ent.bind("<Control-Key-C>", self._toggle_case_event)
self.replace_ent.bind("<Control-Key-W>", self._toggle_wrap_event)
self.replace_ent.bind("<Control-Key-D>", self._toggle_direction_event)
self.replace_ent_expander = EntryExpander(self.replace_ent,
self.text)
self.replace_ent_expander.bind("<Alt-Key-slash>")
for key_event in find_bindings:
self.replace_ent.bind(key_event, self._search) # RDS - 2011-11-19
def tab_fix1(ev):
if ev.state & 1 == 0: # Windows Fix
self.find_ent.focus()
return "break"
self.replace_all_btn.bind('<Tab>', tab_fix1)
def tab_fix2(x):
self.replace_all_btn.focus()
return "break"
tabstop_top.bind('<FocusIn>', tab_fix2)
def _destroy_widgets(self):
if self.widgets_built:
self.bar_frame.destroy()
def show_findbar_event(self, event):
self.text.tag_raise('findmark')
self.text.tag_raise('findsel')
self.text.tag_raise('sel')
# Get the current selection
sel = self._get_selection()
if sel:
# Put the current selection in the "Find:" entry
# FIXME: don't overwrite regexp if it matches the selection
self.find_var.set(self.text.get(sel[0],sel[1]))
self._clear_selection()
# Now show the FindBar in all it's glory!
self._show()
# Set the focus to the "Find:"/"Replace:" entry
self.find_ent.focus()
# Select all of the text in the "Find:"/"Replace:" entry
self.find_ent.selection_range(0,"end")
# Hide the findbar if the focus is lost
#self.bar_frame.bind("<FocusOut>", self.hide_findbar_event)
# RDS - 2012-02-02 - Don't hide on focus_out, since regex error messages
# trigger this.
# Focus traversal (Tab or Shift-Tab) shouldn't return focus to
# the text widget
self.prev_text_takefocus_value = self.text.cget("takefocus")
self.text.config(takefocus=0)
self._incremental_callback()
return "break"
def text_focusin_event(self, event=None): # RDS - 2012-02-02
if not self.shown:
return
else:
self.hide_findbar_event(setcursor=False)
def hide_findbar_event(self, event=None, setcursor=True, focus=True):
if not self.shown:
return "break"
self._hide(setcursor=setcursor)
if focus:
self.text.focus()
return "break"
def search_again_event(self, event):
if self.engine.getpat():
return self._search(event)
else:
return self.show_findbar_event(event)
def search_selection_event(self, event):
# Get the current selection
sel = self._get_selection()
if not sel:
# No selection - beep and leave
self.text.bell()
return "break"
# Set the window's search engine's pattern to the current selection
self.find_var.set(self.text.get(sel[0],sel[1]))
return self._search(event)
def _toggle_reg_event(self, event):
self.reg_btn.invoke()
return "break"
def _toggle_case_event(self, event):
self.case_btn.invoke()
return "break"
def _toggle_wrap_event(self, event):
self.wrap_btn.invoke()
return "break"
def _toggle_direction_event(self, event):
self.direction_btn.invoke()
return "break"
def _update_direction_button(self):
if self.engine.backvar.get():
self.direction_txt_var.set("Up")
else:
self.direction_txt_var.set("Down")
def _replace_bar_find_entry_return_event(self, event=None):
# Set the focus to the "With:" entry
self.replace_ent.focus()
# Select all of the text in the "With:" entry
self.replace_ent.selection_range(0,"end")
return "break"
def _search_text(self, start, is_safe):
self.engine.patvar.set(self.find_var.get())
regexp = self.engine.getprog()
if not regexp:
# an error occurred.
return None
direction = not self.engine.isback()
wrap = self.engine.iswrap()
sel = self._get_selection()
if start is None:
if sel:
start = sel[0]
else:
start = self.text.index("insert")
if ( direction and sel and start == sel[0] and
regexp.match(self.text.get(sel[0],sel[1])) ):
_start = start + "+1c"
else:
_start = start
res = self.window_engine.findnext(regexp,
_start, direction, wrap, is_safe)
# ring the bell if the selection was found again
if sel and start == sel[0] and res == sel:
self.text.bell()
return res
def _search(self, event=None, start=None, is_safe=False):
t = time.time()
res = self._search_text(start, is_safe)
if res:
first, last = res
self._clear_selection()
self._set_selection(first, last)
self.text.see(first)
if not self.shown:
self.text.mark_set("insert", first)
else:
self._clear_selection()
self.text.bell()
return "break"
def _safe_search(self, event=None, start=None):
return self._search(event=event, start=start, is_safe=True)
def _replace_event(self, event=None):
self.engine.patvar.set(self.find_var.get())
regexp = self.engine.getprog()
if not regexp:
return "break"
# Replace if appropriate
sel = self._get_selection()
if sel and regexp.match(self.text.get(sel[0], sel[1])):
replace_with = self.replace_with_var.get()
self.text.undo_block_start()
if sel[0] != sel[1]:
self.text.delete(sel[0], sel[1])
if replace_with:
self.text.insert(sel[0], replace_with)
self.text.undo_block_stop()
self._clear_selection()
self._set_selection(sel[0], sel[0] + '+%ic' % len(replace_with))
self.text.mark_set("insert", sel[0] + '+%ic' % len(replace_with))
return "break"
def _replace_find_event(self, event=None): # RDS - 2011-10-18
self._replace_event(event)
return self._search(event, is_safe=False)
def _replace_all_event(self, event=None):
self.engine.patvar.set(self.find_var.get())
regexp = self.engine.getprog()
if not regexp:
return "break"
direction = not self.engine.isback()
wrap = self.engine.iswrap()
self.window_engine.replace_all(regexp, self.replace_with_var.get())
return "break"
### Selection related methods
def _clear_selection(self):
tagname = self.shown and "findsel" or "sel"
self.text.tag_remove(tagname, "1.0", "end")
def _set_selection(self, start, end):
self._clear_selection()
tagname = self.shown and "findsel" or "sel"
self.text.tag_add(tagname, start, end)
def _get_selection(self):
tagname = self.shown and "findsel" or "sel"
return self.text.tag_nextrange(tagname, '1.0', 'end')
def _reset_selection(self):
if self.shown:
sel = self.text.tag_nextrange("sel", '1.0', 'end')
if sel:
self._set_selection(sel[0], sel[1])
else:
self._clear_selection()
class EntryExpander(object):
"""Expand words in an entry, taking possible words from a text widget."""
def __init__(self, entry, text):
self.text = text
self.entry = entry
self.reset()
self.entry.bind('<Map>', self.reset)
def reset(self, event=None):
self._state = None
def bind(self, event_string):
self.entry.bind(event_string, self._expand_word_event)
def _expand_word_event(self, event=None):
curinsert = self.entry.index("insert")
curline = self.entry.get()
if not self._state:
words = self._get_expand_words()
index = 0
else:
words, index, insert, line = self._state
if insert != curinsert or line != curline:
words = self._get_expand_words()
index = 0
if not words:
self.text.bell()
return "break"
curword = self._get_curr_word()
newword = words[index]
index = (index + 1) % len(words)
if index == 0:
self.text.bell() # Warn the user that we cycled around
idx = int(self.entry.index("insert"))
self.entry.delete(str(idx - len(curword)), str(idx))
self.entry.insert("insert", newword)
curinsert = self.entry.index("insert")
curline = self.entry.get()
self._state = words, index, curinsert, curline
return "break"
def _get_expand_words(self):
curword = self._get_curr_word()
if not curword:
return []
regexp = re.compile(r"\b" + curword + r"\w+\b")
# Start at 'insert wordend' so current word is first
beforewords = regexp.findall(self.text.get("1.0", "insert wordend"))
beforewords.reverse()
afterwords = regexp.findall(self.text.get("insert wordend", "end"))
# Interleave the lists of words
# (This is the next best thing to sorting by distance)
allwords = []
for a,b in zip(beforewords, afterwords):
allwords += [a,b]
minlen = len(allwords)/2
allwords += beforewords[minlen:] + afterwords[minlen:]
words_list = []
words_dict = {}
for w in allwords:
if w not in words_dict:
words_dict[w] = w
words_list.append(w)
words_list.append(curword)
return words_list
_wordchars = string.ascii_letters + string.digits + "_"
def _get_curr_word(self):
line = self.entry.get()
i = j = self.entry.index("insert")
while i > 0 and line[i-1] in self._wordchars:
i = i-1
return line[i:j]
def get_window_engine(editwin):
if not hasattr(editwin, "_window_search_engine"):
editwin._window_search_engine = WindowSearchEngine(editwin.text)
return editwin._window_search_engine
class WindowSearchEngine:
def __init__(self, text):
self.text = text
# Initialize 'findmark' tag
self.hide_find_marks()
self.reset()
def __del__(self):
try:
self.text.tag_delete("findmark")
except:
pass
def show_find_marks(self):
# Get the highlight colors for 'hit'
# Do this here (and not in __init__) for color config changes to take
# effect immediately
currentTheme = idleConf.CurrentTheme()
mark_fg = idleConf.GetHighlight(currentTheme, 'hit', fgBg='fg')
mark_bg = idleConf.GetHighlight(currentTheme, 'hit', fgBg='bg')
self.text.tag_configure("findmark",
foreground=mark_fg,
background=mark_bg)
def hide_find_marks(self):
self.text.tag_configure("findmark",
foreground='',
background='')
def reset(self):
self.text.tag_remove("findmark", "1.0", "end")
self.regexp = None
def _pos2idx(self, pos):
"Convert a position in the text string to a Text widget index"
return self.text.index("1.0+%dc"%pos)
def _set_regexp(self, regexp):
"Set the current regexp; search for and mark all matches in the text"
## When searching for an extension of the previous search,
## i.e. regexp.startswith(self.regexp), update hits instead of starting from
## scratch
self.reset()
self.regexp = regexp
txt = self.text.get("1.0", "end-1c")
prev = 0
line = 1
rfind = txt.rfind
tag_add = self.text.tag_add
for res in regexp.finditer(txt):
start, end = res.span()
line += txt[prev:start].count('\n')
prev = start
start_idx = "%d.%d" % (line,
start - (rfind('\n', 0, start) + 1))
end_idx = start_idx + '+%dc'%(end-start)
tag_add("findmark", start_idx, end_idx)
def findnext(self, regexp, start, direction=1, wrap=True, is_safe=False,
last=False):
"""Find the next text sequence which matches the given regexp.
The 'next' sequence is the one after the selection or the insert
cursor, or before if the direction is up instead of down.
The 'is_safe' argument tells whether it is safe to assume that the text
being searched has not been changed since the previous search; if the
text hasn't been changed then the search is almost trivial (due to
pre-processing).
"""
if regexp != self.regexp or not is_safe:
self._set_regexp(regexp)
# Search!
if direction:
next = self.text.tag_nextrange("findmark", start)
if not next:
if wrap:
# TODO: give message about wrap
next = self.text.tag_nextrange("findmark", '1.0', start)
else:
# TODO: no more matches message
pass
else:
next = self.text.tag_prevrange("findmark", start)
if not next:
if wrap:
# TODO: give message about wrap
next = self.text.tag_prevrange("findmark", 'end', start)
else:
# TODO: no more matches message
pass
if not last and not next:
if direction==1:
delta='-1c'
else:
delta='+1c'
q1 = self.text.index(start+delta)
next = self.findnext(regexp, q1, direction=direction,
wrap=wrap, is_safe=is_safe, last=True)
# the "last=True" flag is to prevent infinite recursion if something
# should go wrong with tag_nextrange or prevrange.
return next
def replace_all(self, regexp, replace_with):
oldhit = None
searchfrom = '1.0'
self.text.undo_block_start()
while True:
hit = self.findnext(regexp, searchfrom,
direction=1, wrap=False, is_safe=False)
if not hit or hit == oldhit:
break
oldhit = hit # avoid infinite loop due to ModifiedUndoDelegator in PyShell
first, last = hit
if first != last:
self.text.delete(first, last)
if replace_with:
self.text.insert(first, replace_with)
searchfrom = last
self.text.undo_block_stop()
def get_selection(text):
"Get the selection range in a text widget"
tmp = text.tag_nextrange("sel","1.0","end")
if tmp:
first, last = tmp
else:
first = last = text.index("insert")
return first, last
##def idx2ints(idx):
## "Convert a Text widget index to a (line, col) pair"
## line, col = map(int,idx.split(".")) # Fails on invalid index
## return line, col
##def ints2idx(ints):
## "Convert a (line, col) pair to Tk's Text widget's format."
## return "%d.%d" % ints # Fails on invalid index