if not hasattr(root
, "_searchengine"):
root
._searchengine
= SearchEngine(root
)
# XXX This will never garbage-collect -- who cares
return root
._searchengine
def __init__(self
, root
):
# State shared by search, replace, and grep;
# the search dialogs bind these to UI elements.
self
.patvar
= StringVar(root
) # search pattern
self
.revar
= BooleanVar(root
) # regular expression?
self
.casevar
= BooleanVar(root
) # match case?
self
.wordvar
= BooleanVar(root
) # match whole word?
self
.wrapvar
= BooleanVar(root
) # wrap around buffer?
self
.wrapvar
.set(1) # (on by default)
self
.backvar
= BooleanVar(root
) # search backwards?
return self
.casevar
.get()
return self
.wordvar
.get()
return self
.wrapvar
.get()
return self
.backvar
.get()
# Higher level access methods
self
.report_error(pat
, "Empty regular expression")
pat
= self
.getcookedpat()
flags
= flags | re
.IGNORECASE
prog
= re
.compile(pat
, flags
)
self
.report_error(pat
, msg
, col
)
def report_error(self
, pat
, msg
, col
=-1):
# Derived class could overrid this with something fancier
msg
= "Error: " + str(msg
)
msg
= msg
+ "\np\Pattern: " + str(pat
)
msg
= msg
+ "\nOffset: " + str(col
)
tkMessageBox
.showerror("Regular expression error",
def setcookedpat(self
, pat
):
def search_text(self
, text
, prog
=None, ok
=0):
"""Search a text widget for the pattern.
If prog is given, it should be the precompiled pattern.
Return a tuple (lineno, matchobj); None if not found.
This obeys the wrap and direction (back) settings.
The search starts at the selection (if there is one) or
at the insert mark (otherwise). If the search is forward,
it starts at the right of the selection; for a backward
search, it starts at the left end. An empty match exactly
at either end of the selection (or at the insert mark if
there is no selection) is ignored unless the ok flag is true
-- this is done to guarantee progress.
If the search is allowed to wrap around, it will return the
original selection if (and only if) it is the only match.
return None # Compilation failed -- stop
wrap
= self
.wrapvar
.get()
first
, last
= get_selection(text
)
line
, col
= get_line_col(start
)
res
= self
.search_backward(text
, prog
, line
, col
, wrap
, ok
)
line
, col
= get_line_col(start
)
res
= self
.search_forward(text
, prog
, line
, col
, wrap
, ok
)
def search_forward(self
, text
, prog
, line
, col
, wrap
, ok
=0):
chars
= text
.get("%d.0" % line
, "%d.0" % (line
+1))
m
= prog
.search(chars
[:-1], col
)
if wrapped
and line
> startline
:
chars
= text
.get("%d.0" % line
, "%d.0" % (line
+1))
chars
= text
.get("1.0", "2.0")
def search_backward(self
, text
, prog
, line
, col
, wrap
, ok
=0):
chars
= text
.get("%d.0" % line
, "%d.0" % (line
+1))
m
= search_reverse(prog
, chars
[:-1], col
)
if ok
or m
.start() < col
:
if wrapped
and line
< startline
:
pos
= text
.index("end-1c")
line
, col
= map(int, pos
.split("."))
chars
= text
.get("%d.0" % line
, "%d.0" % (line
+1))
# Helper to search backwards in a string.
# (Optimized for the case where the pattern isn't found.)
def search_reverse(prog
, chars
, col
):
while i
< col
and j
<= col
:
m
= prog
.search(chars
, j
)
# Helper to get selection end points, defaulting to insert mark.
# Return a tuple of indices ("line.col" strings).
first
= text
.index("sel.first")
last
= text
.index("sel.last")
first
= text
.index("insert")
# Helper to parse a text index into a (line, col) tuple.
line
, col
= map(int, index
.split(".")) # Fails on invalid index