| import re |
| from Tkinter import * |
| import tkMessageBox |
| |
| def get(root): |
| if not hasattr(root, "_searchengine"): |
| root._searchengine = SearchEngine(root) |
| # XXX This will never garbage-collect -- who cares |
| return root._searchengine |
| |
| class SearchEngine: |
| |
| def __init__(self, root): |
| self.root = 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? |
| |
| # Access methods |
| |
| def getpat(self): |
| return self.patvar.get() |
| |
| def setpat(self, pat): |
| self.patvar.set(pat) |
| |
| def isre(self): |
| return self.revar.get() |
| |
| def iscase(self): |
| return self.casevar.get() |
| |
| def isword(self): |
| return self.wordvar.get() |
| |
| def iswrap(self): |
| return self.wrapvar.get() |
| |
| def isback(self): |
| return self.backvar.get() |
| |
| # Higher level access methods |
| |
| def getcookedpat(self): |
| pat = self.getpat() |
| if not self.isre(): |
| pat = re.escape(pat) |
| if self.isword(): |
| pat = r"\b%s\b" % pat |
| return pat |
| |
| def getprog(self): |
| pat = self.getpat() |
| if not pat: |
| self.report_error(pat, "Empty regular expression") |
| return None |
| pat = self.getcookedpat() |
| flags = 0 |
| if not self.iscase(): |
| flags = flags | re.IGNORECASE |
| try: |
| prog = re.compile(pat, flags) |
| except re.error, what: |
| try: |
| msg, col = what |
| except: |
| msg = str(what) |
| col = -1 |
| self.report_error(pat, msg, col) |
| return None |
| return prog |
| |
| def report_error(self, pat, msg, col=-1): |
| # Derived class could overrid this with something fancier |
| msg = "Error: " + str(msg) |
| if pat: |
| msg = msg + "\np\Pattern: " + str(pat) |
| if col >= 0: |
| msg = msg + "\nOffset: " + str(col) |
| tkMessageBox.showerror("Regular expression error", |
| msg, master=self.root) |
| |
| def setcookedpat(self, pat): |
| if self.isre(): |
| pat = re.escape(pat) |
| self.setpat(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. |
| |
| """ |
| if not prog: |
| prog = self.getprog() |
| if not prog: |
| return None # Compilation failed -- stop |
| wrap = self.wrapvar.get() |
| first, last = get_selection(text) |
| if self.isback(): |
| if ok: |
| start = last |
| else: |
| start = first |
| line, col = get_line_col(start) |
| res = self.search_backward(text, prog, line, col, wrap, ok) |
| else: |
| if ok: |
| start = first |
| else: |
| start = last |
| line, col = get_line_col(start) |
| res = self.search_forward(text, prog, line, col, wrap, ok) |
| return res |
| |
| def search_forward(self, text, prog, line, col, wrap, ok=0): |
| wrapped = 0 |
| startline = line |
| chars = text.get("%d.0" % line, "%d.0" % (line+1)) |
| while chars: |
| m = prog.search(chars[:-1], col) |
| if m: |
| if ok or m.end() > col: |
| return line, m |
| line = line + 1 |
| if wrapped and line > startline: |
| break |
| col = 0 |
| ok = 1 |
| chars = text.get("%d.0" % line, "%d.0" % (line+1)) |
| if not chars and wrap: |
| wrapped = 1 |
| wrap = 0 |
| line = 1 |
| chars = text.get("1.0", "2.0") |
| return None |
| |
| def search_backward(self, text, prog, line, col, wrap, ok=0): |
| wrapped = 0 |
| startline = line |
| chars = text.get("%d.0" % line, "%d.0" % (line+1)) |
| while 1: |
| m = search_reverse(prog, chars[:-1], col) |
| if m: |
| if ok or m.start() < col: |
| return line, m |
| line = line - 1 |
| if wrapped and line < startline: |
| break |
| ok = 1 |
| if line <= 0: |
| if not wrap: |
| break |
| wrapped = 1 |
| wrap = 0 |
| pos = text.index("end-1c") |
| line, col = map(int, pos.split(".")) |
| chars = text.get("%d.0" % line, "%d.0" % (line+1)) |
| col = len(chars) - 1 |
| return None |
| |
| # Helper to search backwards in a string. |
| # (Optimized for the case where the pattern isn't found.) |
| |
| def search_reverse(prog, chars, col): |
| m = prog.search(chars) |
| if not m: |
| return None |
| found = None |
| i, j = m.span() |
| while i < col and j <= col: |
| found = m |
| if i == j: |
| j = j+1 |
| m = prog.search(chars, j) |
| if not m: |
| break |
| i, j = m.span() |
| return found |
| |
| # Helper to get selection end points, defaulting to insert mark. |
| # Return a tuple of indices ("line.col" strings). |
| |
| def get_selection(text): |
| try: |
| first = text.index("sel.first") |
| last = text.index("sel.last") |
| except TclError: |
| first = last = None |
| if not first: |
| first = text.index("insert") |
| if not last: |
| last = first |
| return first, last |
| |
| # Helper to parse a text index into a (line, col) tuple. |
| |
| def get_line_col(index): |
| line, col = map(int, index.split(".")) # Fails on invalid index |
| return line, col |
