--HG--

branch : pmacs2

application.py

@@ -10,7 +10,7 @@ from point2 import Point
 #import mode, mode_c, mode_mini, mode_python, mode_nasm, mode_perl, mode_search
 #import mode_replace, mode_xml, mode_console, mode_sh, mode_text, mode_which
 #import mode_mutt, mode_sql, mode_javascript, mode_diff, mode_blame, mode_tt
-import mode2, mode_mini, mode_python, mode_perl
+import mode2, mode_mini, mode_python, mode_perl, mode_search, mode_replace
 
 def run(buffers, jump_to_line=None, init_mode=None):
     # save terminal state so we can restore it when the program exits
@@ -88,7 +88,7 @@ class Application(object):
             'perl':        mode_perl.Perl,
             'python':      mode_python.Python,
 #            'replace':     mode_replace.Replace,
-#            'search':      mode_search.Search,
+            'search':      mode_search.Search,
 #            'sh':          mode_sh.Sh,
 #            'text':        mode_text.Text,
 #            'which':       mode_which.Which,
@@ -450,11 +450,18 @@ class Application(object):
             self.draw_slot(i)
             self.draw_status_bar(i)
 
+    def highlight_char(self, sy, sx):
+        junk = self.win.inch(sy, sx)
+        c    = junk & 255
+        attr = (junk & (curses.A_COLOR|curses.A_ATTRIBUTES)) | curses.A_REVERSE
+        self.win.addch(sy, sx, c, attr)
+    def highlight_chars(self, sy, sx1, sx2):
+        for x in range(sx1, sx2):
+            self.highlight_char(sy, x)
+
     def draw_slot(self, i):
-        #assert len(self.bufferlist.slots) == 1, "only one"
         assert self.active_slot < len(self.bufferlist.slots), "only two"
         assert i < len(self.bufferlist.slots), "only three"
-        #assert i == 0, "only four"
 
         slot = self.bufferlist.slots[i]
         if slot.window is None:
@@ -467,18 +474,10 @@ class Application(object):
         lines = w.buffer.lines
         count = 0
         (x, y) = w.first.xy()
-        cursor = w.logical_cursor()
-        (cx, cy) = cursor.xy()
-        (px, py) = (None, None)
         while count < slot.height:
             if y >= len(lines):
                 self.win.addstr(slot.offset + count, 0, '~', redattr)
             else:
-                # let's find the cursor
-                if cy == y and cx >= x and cx < x + slot.width:
-                    px = cx - x
-                    py = count
-
                 line = lines[y]
                 if modename in w.buffer.highlights:
                     highlighter = w.buffer.highlights[modename]
@@ -517,40 +516,59 @@ class Application(object):
                     x += slot.width
             count += 1
 
+        # highlighted regions
+        for (high_w, p1, p2) in self.highlighted_ranges:
+            if w is not high_w:
+                # this region isn't in the current window so skip it
+                pass
+            elif p2 < w.first or p1 > w.last:
+                # this region is not visible, so skip it
+                pass
+            else:
+                # ok, so now we need to do some highlighting
+                count = 0
+                (x, y) = w.first.xy()
+                px = p1.x
+                while count < slot.height:
+                    if p1.y == y and px >= x and px < x + slot.width:
+                        if px + slot.width > p2.x:
+                            self.highlight_chars(slot.offset + count, px, p2.x)
+                            break
+                        else:
+                            self.highlight_chars(slot.offset + count, px, px + slot.width)
+                            px += slot.width
+                    if x + slot.width >= len(line):
+                        x = 0
+                        y += 1
+                    else:
+                        x += slot.width
+                    count += 1
+
         if self.margins_visible:
             for (limit, shade) in self.margins:
                 if self.x > limit:
                     for j in range(0, slot.height):
-                        # the actual character is the lower 8 bits, and the
-                        # attribute is the upper 8 bits; we will ignore the
-                        # attribute and just get the character
                         char = self.win.inch(j + slot.offset, limit) & 255
                         attr = color.build('default', shade, 'bold')
                         self.win.addch(j + slot.offset, limit, char, attr)
 
         if self.mini_active is False and self.active_slot == i:
-            if False and w.active_point is not None and w.point_is_visible(w.active_point):
+            if w.active_point is not None and w.point_is_visible(w.active_point):
-                pa = w.physical_point(w.active_point)
+                p = w.active_point
-                va = pa.offset(0, -w.visible_offset())
-                if len(lines[va.y]):
-                    a = lines[va.y][va.x]
             else:
-                    a = ' '
+                p = w.logical_cursor()
-                self.win.addch(va.y + slot.offset, va.x, a, curses.A_REVERSE)
+            count = 0
+            (x, y) = w.first.xy()
+            while count < slot.height:
+                if p.y == y and p.x >= x and p.x < x + slot.width:
+                    self.highlight_char(slot.offset + count, p.x - x)
+                    break
+                if x + slot.width >= len(line):
+                    x = 0
+                    y += 1
                 else:
-                assert px is not None and py is not None
+                    x += slot.width
-
+                count += 1
-                if cy >= len(lines):
-                    self.set_error('in main1: cursor error; %d >= %d' % (cy, len(lines)))
-                    return
-                elif cx == len(lines[cy]):
-                    c = ' '
-                elif px > len(lines[cy]):
-                    self.set_error('why? %r %r' % (cx, len(lines[cy])))
-                    return
-                else:
-                    c = lines[cy][cx]
-                self.win.addch(slot.offset + py , px, c, curses.A_REVERSE)
 
     def draw_status_bar(self, slotname):
         slot = self.bufferlist.slots[slotname]

method.py

@@ -147,14 +147,11 @@ class ForwardLines(Method):
 class Search(Method):
     '''Interactive search; finds next occurance of text in buffer'''
     def execute(self, w, **vargs):
-        self.old_cursor = w.logical_cursor().offset(0, 0)
+        self.old_cursor = w.logical_cursor()
         self.old_window = w
         self.direction = 'next'
-        w.application.open_mini_buffer('I-Search: ',
+        w.application.open_mini_buffer('I-Search: ', lambda x: None, self,
-                                       lambda x: None,
+                                       None, 'search')
-                                       self,
-                                       None,
-                                       'search')
 class ReverseSearch(Method):
     '''Interactive search; finds previous occurance of text in buffer'''
     def execute(self, w, **vargs):

mode_replace.py

@@ -1,12 +1,12 @@
 import sets, string
 
-import color, highlight, method, minibuffer, mode, point
+import color, method, minibuffer, mode2
-import random
+from point2 import Point
 
-class Replace(mode.Fundamental):
+class Replace(mode2.Fundamental):
     '''This is the default mode'''
     def __init__(self, w):
-        mode.Fundamental.__init__(self, w)
+        mode2.Fundamental.__init__(self, w)
 
         self.actions = {}
         self.bindings = {}
@@ -92,8 +92,8 @@ def _find_next(window, move=False):
             # success
             x = x + l.index(s)
             x2 = x + len(s)
-            m.p1 = point.Point(x, y)
+            m.p1 = Point(x, y)
-            m.p2 = point.Point(x2, y)
+            m.p2 = Point(x2, y)
             old_window.goto(m.p1)
             old_window.application.clear_highlighted_ranges()
             old_window.application.add_highlighted_range(old_window, m.p1, m.p2)

mode_search.py

@@ -1,11 +1,12 @@
 import sets, string
 
-import color, highlight, method, minibuffer, mode, point
+import color, method, minibuffer, mode2
+from point2 import Point
 
-class Search(mode.Fundamental):
+class Search(mode2.Fundamental):
     '''This is the default mode'''
     def __init__(self, w):
-        mode.Fundamental.__init__(self, w)
+        mode2.Fundamental.__init__(self, w)
 
         self.actions = {}
         self.bindings = {}
@@ -100,7 +101,7 @@ class InsertSearchString(method.Method):
         self.args = []
         self.help = None
     def execute(self, window, **vargs):
-        window.insert_string(self.string)
+        window.insert_string_at_cursor(self.string)
         s = window.buffer.make_string()
         if not s:
             return
@@ -133,14 +134,11 @@ def _find_previous(old_window, new_window, move=False):
         if s in l:
             # success
             x = l.index(s)
-            old_window.goto(point.Point(x, y))
+            old_window.goto(Point(x, y))
-            #new_window.application.highlighted_range = [old_window,
-            #                                            point.Point(x,y),
-            #                                            point.Point(x + len(s), y)]
             old_window.application.clear_highlighted_ranges()
             new_window.application.add_highlighted_range(old_window,
-                                                         point.Point(x,y),
+                                                         Point(x,y),
-                                                         point.Point(x + len(s), y))
+                                                         Point(x + len(s), y))
             break
         elif y >= len(old_buffer.lines) - 1:
             # failure
@@ -164,14 +162,11 @@ def _find_next(old_window, new_window, move=False):
         if s in l:
             # success
             x = l.index(s) + x
-            old_window.goto(point.Point(x, y))
+            old_window.goto(Point(x, y))
-            #new_window.application.highlighted_range = [old_window,
-            #                                            point.Point(x,y),
-            #                                            point.Point(x + len(s), y)]
             old_window.application.clear_highlighted_ranges()
             new_window.application.add_highlighted_range(old_window,
-                                                         point.Point(x,y),
+                                                         Point(x,y),
-                                                         point.Point(x + len(s), y))
+                                                         Point(x + len(s), y))
             break
         elif y >= len(old_buffer.lines) - 1:
             # failure

window2.py

@@ -328,8 +328,8 @@ class Window(object):
         self.assure_visible_cursor()
     def forward_lines(self, n):
         assert n > 0, "illegal number of lines: %d" % n
-        y = min(self.cursor[1] + n, len(self.buffer.lines) - 1)
+        y = min(self.logical_cursor().y + n, len(self.buffer.lines) - 1)
-        self.goto_line(y)
+        self.goto(Point(0, y))
     def forward_chars(self, n):
         (x, y) = self.logical_cursor().xy()
         for i in range(0, n):