changeset 50:df8d9afdaf2c

- fix crash caused when editing large commit-text lines (required modifying textpad)
author Mark Edgington <edgimar@gmail.com>
date Wed, 24 Jun 2009 19:49:25 +0200
parents a8f5ac16cf16
children c0e5e65165c1
files crecord/chunk_selector.py crecord/textpad.py
diffstat 2 files changed, 197 insertions(+), 6 deletions(-) [+]
line wrap: on
line diff
--- a/crecord/chunk_selector.py
+++ b/crecord/chunk_selector.py
@@ -26,7 +26,8 @@
     # I have no idea if wcurses works with crecord...
     import wcurses as curses
 
-import curses.textpad
+#from curses import textpad 
+import textpad # customized textpad
 
 try:
     curses
@@ -855,12 +856,9 @@
         self.printString(statusline, statusLineText, pairName="legend")
         statusline.refresh()
         helpwin = curses.newwin(self.yScreenSize-1,0,1,0)
-        reversedCommentText = self.commentText[::-1]
-        for char in reversedCommentText:
-            curses.ungetch(ord(char))
-        t = curses.textpad.Textbox(helpwin)
+        t = textpad.Textbox(helpwin)
         curses.raw()
-        self.commentText = t.edit(keyFilter).rstrip(" \n")
+        self.commentText = t.edit(keyFilter, self.commentText).rstrip(" \n")
         curses.cbreak()
 
     def confirmCommit(self):
new file mode 100644
--- /dev/null
+++ b/crecord/textpad.py
@@ -0,0 +1,193 @@
+"""Simple textbox editing widget with Emacs-like keybindings."""
+
+import curses
+import curses.ascii
+
+def rectangle(win, uly, ulx, lry, lrx):
+    """Draw a rectangle with corners at the provided upper-left
+    and lower-right coordinates.
+    """
+    win.vline(uly+1, ulx, curses.ACS_VLINE, lry - uly - 1)
+    win.hline(uly, ulx+1, curses.ACS_HLINE, lrx - ulx - 1)
+    win.hline(lry, ulx+1, curses.ACS_HLINE, lrx - ulx - 1)
+    win.vline(uly+1, lrx, curses.ACS_VLINE, lry - uly - 1)
+    win.addch(uly, ulx, curses.ACS_ULCORNER)
+    win.addch(uly, lrx, curses.ACS_URCORNER)
+    win.addch(lry, lrx, curses.ACS_LRCORNER)
+    win.addch(lry, ulx, curses.ACS_LLCORNER)
+
+class Textbox:
+    """Editing widget using the interior of a window object.
+     Supports the following Emacs-like key bindings:
+
+    Ctrl-A      Go to left edge of window.
+    Ctrl-B      Cursor left, wrapping to previous line if appropriate.
+    Ctrl-D      Delete character under cursor.
+    Ctrl-E      Go to right edge (stripspaces off) or end of line (stripspaces on).
+    Ctrl-F      Cursor right, wrapping to next line when appropriate.
+    Ctrl-G      Terminate, returning the window contents.
+    Ctrl-H      Delete character backward.
+    Ctrl-J      Terminate if the window is 1 line, otherwise insert newline.
+    Ctrl-K      If line is blank, delete it, otherwise clear to end of line.
+    Ctrl-L      Refresh screen.
+    Ctrl-N      Cursor down; move down one line.
+    Ctrl-O      Insert a blank line at cursor location.
+    Ctrl-P      Cursor up; move up one line.
+
+    Move operations do nothing if the cursor is at an edge where the movement
+    is not possible.  The following synonyms are supported where possible:
+
+    KEY_LEFT = Ctrl-B, KEY_RIGHT = Ctrl-F, KEY_UP = Ctrl-P, KEY_DOWN = Ctrl-N
+    KEY_BACKSPACE = Ctrl-h
+    """
+    def __init__(self, win, insert_mode=False):
+        self.win = win
+        self.insert_mode = insert_mode
+        (self.maxy, self.maxx) = win.getmaxyx()
+        self.maxy = self.maxy - 1
+        self.maxx = self.maxx - 1
+        self.stripspaces = 1
+        self.lastcmd = None
+        win.keypad(1)
+
+    def _end_of_line(self, y):
+        """Go to the location of the first blank on the given line,
+        returning the index of the last non-blank character."""
+        last = self.maxx
+        while True:
+            if curses.ascii.ascii(self.win.inch(y, last)) != curses.ascii.SP:
+                last = min(self.maxx, last+1)
+                break
+            elif last == 0:
+                break
+            last = last - 1
+        return last
+
+    def _insert_printable_char(self, ch):
+        (y, x) = self.win.getyx()
+        if y < self.maxy or x < self.maxx:
+            if self.insert_mode:
+                oldch = self.win.inch()
+            # The try-catch ignores the error we trigger from some curses
+            # versions by trying to write into the lowest-rightmost spot
+            # in the window.
+            try:
+                self.win.addch(ch)
+            except curses.error:
+                pass
+            if self.insert_mode:
+                (backy, backx) = self.win.getyx()
+                if curses.ascii.isprint(oldch):
+                    self._insert_printable_char(oldch)
+                    self.win.move(backy, backx)
+
+    def do_command(self, ch):
+        "Process a single editing command."
+        (y, x) = self.win.getyx()
+        self.lastcmd = ch
+        if curses.ascii.isprint(ch):
+            if y < self.maxy or x < self.maxx:
+                self._insert_printable_char(ch)
+        elif ch == curses.ascii.SOH:                           # ^a
+            self.win.move(y, 0)
+        elif ch in (curses.ascii.STX,curses.KEY_LEFT, curses.ascii.BS,curses.KEY_BACKSPACE):
+            if x > 0:
+                self.win.move(y, x-1)
+            elif y == 0:
+                pass
+            elif self.stripspaces:
+                self.win.move(y-1, self._end_of_line(y-1))
+            else:
+                self.win.move(y-1, self.maxx)
+            if ch in (curses.ascii.BS, curses.KEY_BACKSPACE):
+                self.win.delch()
+        elif ch == curses.ascii.EOT:                           # ^d
+            self.win.delch()
+        elif ch == curses.ascii.ENQ:                           # ^e
+            if self.stripspaces:
+                self.win.move(y, self._end_of_line(y))
+            else:
+                self.win.move(y, self.maxx)
+        elif ch in (curses.ascii.ACK, curses.KEY_RIGHT):       # ^f
+            if x < self.maxx:
+                self.win.move(y, x+1)
+            elif y == self.maxy:
+                pass
+            else:
+                self.win.move(y+1, 0)
+        elif ch == curses.ascii.BEL:                           # ^g
+            return 0
+        elif ch == curses.ascii.NL:                            # ^j
+            if self.maxy == 0:
+                return 0
+            elif y < self.maxy:
+                self.win.move(y+1, 0)
+        elif ch == curses.ascii.VT:                            # ^k
+            if x == 0 and self._end_of_line(y) == 0:
+                self.win.deleteln()
+            else:
+                # first undo the effect of self._end_of_line
+                self.win.move(y, x)
+                self.win.clrtoeol()
+        elif ch == curses.ascii.FF:                            # ^l
+            self.win.refresh()
+        elif ch in (curses.ascii.SO, curses.KEY_DOWN):         # ^n
+            if y < self.maxy:
+                self.win.move(y+1, x)
+                if x > self._end_of_line(y+1):
+                    self.win.move(y+1, self._end_of_line(y+1))
+        elif ch == curses.ascii.SI:                            # ^o
+            self.win.insertln()
+        elif ch in (curses.ascii.DLE, curses.KEY_UP):          # ^p
+            if y > 0:
+                self.win.move(y-1, x)
+                if x > self._end_of_line(y-1):
+                    self.win.move(y-1, self._end_of_line(y-1))
+        return 1
+
+    def gather(self):
+        "Collect and return the contents of the window."
+        result = ""
+        for y in range(self.maxy+1):
+            self.win.move(y, 0)
+            stop = self._end_of_line(y)
+            if stop == 0 and self.stripspaces:
+                continue
+            for x in range(self.maxx+1):
+                if self.stripspaces and x > stop:
+                    break
+                result = result + chr(curses.ascii.ascii(self.win.inch(y, x)))
+            if self.maxy > 0:
+                result = result + "\n"
+        return result
+
+    def edit(self, validate=None, initial_text=None):
+        "Edit in the widget window and collect the results."
+        if initial_text is None:
+            initial_text = ""
+        initial_text_list = list(initial_text)
+        while 1:
+            if initial_text_list:
+                curses.ungetch(ord(initial_text_list.pop(0)))
+            ch = self.win.getch()
+            if validate:
+                ch = validate(ch)
+            if not ch:
+                continue
+            if not self.do_command(ch):
+                break
+            self.win.refresh()
+        return self.gather()
+
+if __name__ == '__main__':
+    def test_editbox(stdscr):
+        ncols, nlines = 9, 4
+        uly, ulx = 15, 20
+        stdscr.addstr(uly-2, ulx, "Use Ctrl-G to end editing.")
+        win = curses.newwin(nlines, ncols, uly, ulx)
+        rectangle(stdscr, uly-1, ulx-1, uly + nlines, ulx + ncols)
+        stdscr.refresh()
+        return Textbox(win).edit()
+
+    str = curses.wrapper(test_editbox)
+    print 'Contents of text box:', repr(str)