home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / SearchEngine.py < prev    next >
Text File  |  2003-12-30  |  7KB  |  221 lines
  1. import re
  2. from Tkinter import *
  3. import tkMessageBox
  4.  
  5. def get(root):
  6.     if not hasattr(root, "_searchengine"):
  7.         root._searchengine = SearchEngine(root)
  8.         # XXX This will never garbage-collect -- who cares
  9.     return root._searchengine
  10.  
  11. class SearchEngine:
  12.  
  13.     def __init__(self, root):
  14.         self.root = root
  15.         # State shared by search, replace, and grep;
  16.         # the search dialogs bind these to UI elements.
  17.         self.patvar = StringVar(root)           # search pattern
  18.         self.revar = BooleanVar(root)           # regular expression?
  19.         self.casevar = BooleanVar(root)         # match case?
  20.         self.wordvar = BooleanVar(root)         # match whole word?
  21.         self.wrapvar = BooleanVar(root)         # wrap around buffer?
  22.         self.wrapvar.set(1)                     # (on by default)
  23.         self.backvar = BooleanVar(root)         # search backwards?
  24.  
  25.     # Access methods
  26.  
  27.     def getpat(self):
  28.         return self.patvar.get()
  29.  
  30.     def setpat(self, pat):
  31.         self.patvar.set(pat)
  32.  
  33.     def isre(self):
  34.         return self.revar.get()
  35.  
  36.     def iscase(self):
  37.         return self.casevar.get()
  38.  
  39.     def isword(self):
  40.         return self.wordvar.get()
  41.  
  42.     def iswrap(self):
  43.         return self.wrapvar.get()
  44.  
  45.     def isback(self):
  46.         return self.backvar.get()
  47.  
  48.     # Higher level access methods
  49.  
  50.     def getcookedpat(self):
  51.         pat = self.getpat()
  52.         if not self.isre():
  53.             pat = re.escape(pat)
  54.         if self.isword():
  55.             pat = r"\b%s\b" % pat
  56.         return pat
  57.  
  58.     def getprog(self):
  59.         pat = self.getpat()
  60.         if not pat:
  61.             self.report_error(pat, "Empty regular expression")
  62.             return None
  63.         pat = self.getcookedpat()
  64.         flags = 0
  65.         if not self.iscase():
  66.             flags = flags | re.IGNORECASE
  67.         try:
  68.             prog = re.compile(pat, flags)
  69.         except re.error, what:
  70.             try:
  71.                 msg, col = what
  72.             except:
  73.                 msg = str(what)
  74.                 col = -1
  75.             self.report_error(pat, msg, col)
  76.             return None
  77.         return prog
  78.  
  79.     def report_error(self, pat, msg, col=-1):
  80.         # Derived class could overrid this with something fancier
  81.         msg = "Error: " + str(msg)
  82.         if pat:
  83.             msg = msg + "\np\Pattern: " + str(pat)
  84.         if col >= 0:
  85.             msg = msg + "\nOffset: " + str(col)
  86.         tkMessageBox.showerror("Regular expression error",
  87.                                msg, master=self.root)
  88.  
  89.     def setcookedpat(self, pat):
  90.         if self.isre():
  91.             pat = re.escape(pat)
  92.         self.setpat(pat)
  93.  
  94.     def search_text(self, text, prog=None, ok=0):
  95.         """Search a text widget for the pattern.
  96.  
  97.         If prog is given, it should be the precompiled pattern.
  98.         Return a tuple (lineno, matchobj); None if not found.
  99.  
  100.         This obeys the wrap and direction (back) settings.
  101.  
  102.         The search starts at the selection (if there is one) or
  103.         at the insert mark (otherwise).  If the search is forward,
  104.         it starts at the right of the selection; for a backward
  105.         search, it starts at the left end.  An empty match exactly
  106.         at either end of the selection (or at the insert mark if
  107.         there is no selection) is ignored  unless the ok flag is true
  108.         -- this is done to guarantee progress.
  109.  
  110.         If the search is allowed to wrap around, it will return the
  111.         original selection if (and only if) it is the only match.
  112.  
  113.         """
  114.         if not prog:
  115.             prog = self.getprog()
  116.             if not prog:
  117.                 return None # Compilation failed -- stop
  118.         wrap = self.wrapvar.get()
  119.         first, last = get_selection(text)
  120.         if self.isback():
  121.             if ok:
  122.                 start = last
  123.             else:
  124.                 start = first
  125.             line, col = get_line_col(start)
  126.             res = self.search_backward(text, prog, line, col, wrap, ok)
  127.         else:
  128.             if ok:
  129.                 start = first
  130.             else:
  131.                 start = last
  132.             line, col = get_line_col(start)
  133.             res = self.search_forward(text, prog, line, col, wrap, ok)
  134.         return res
  135.  
  136.     def search_forward(self, text, prog, line, col, wrap, ok=0):
  137.         wrapped = 0
  138.         startline = line
  139.         chars = text.get("%d.0" % line, "%d.0" % (line+1))
  140.         while chars:
  141.             m = prog.search(chars[:-1], col)
  142.             if m:
  143.                 if ok or m.end() > col:
  144.                     return line, m
  145.             line = line + 1
  146.             if wrapped and line > startline:
  147.                 break
  148.             col = 0
  149.             ok = 1
  150.             chars = text.get("%d.0" % line, "%d.0" % (line+1))
  151.             if not chars and wrap:
  152.                 wrapped = 1
  153.                 wrap = 0
  154.                 line = 1
  155.                 chars = text.get("1.0", "2.0")
  156.         return None
  157.  
  158.     def search_backward(self, text, prog, line, col, wrap, ok=0):
  159.         wrapped = 0
  160.         startline = line
  161.         chars = text.get("%d.0" % line, "%d.0" % (line+1))
  162.         while 1:
  163.             m = search_reverse(prog, chars[:-1], col)
  164.             if m:
  165.                 if ok or m.start() < col:
  166.                     return line, m
  167.             line = line - 1
  168.             if wrapped and line < startline:
  169.                 break
  170.             ok = 1
  171.             if line <= 0:
  172.                 if not wrap:
  173.                     break
  174.                 wrapped = 1
  175.                 wrap = 0
  176.                 pos = text.index("end-1c")
  177.                 line, col = map(int, pos.split("."))
  178.             chars = text.get("%d.0" % line, "%d.0" % (line+1))
  179.             col = len(chars) - 1
  180.         return None
  181.  
  182. # Helper to search backwards in a string.
  183. # (Optimized for the case where the pattern isn't found.)
  184.  
  185. def search_reverse(prog, chars, col):
  186.     m = prog.search(chars)
  187.     if not m:
  188.         return None
  189.     found = None
  190.     i, j = m.span()
  191.     while i < col and j <= col:
  192.         found = m
  193.         if i == j:
  194.             j = j+1
  195.         m = prog.search(chars, j)
  196.         if not m:
  197.             break
  198.         i, j = m.span()
  199.     return found
  200.  
  201. # Helper to get selection end points, defaulting to insert mark.
  202. # Return a tuple of indices ("line.col" strings).
  203.  
  204. def get_selection(text):
  205.     try:
  206.         first = text.index("sel.first")
  207.         last = text.index("sel.last")
  208.     except TclError:
  209.         first = last = None
  210.     if not first:
  211.         first = text.index("insert")
  212.     if not last:
  213.         last = first
  214.     return first, last
  215.  
  216. # Helper to parse a text index into a (line, col) tuple.
  217.  
  218. def get_line_col(index):
  219.     line, col = map(int, index.split(".")) # Fails on invalid index
  220.     return line, col
  221.