Added two modules for ASCII characters and a simple editing form (ESR)

2 files changed, 261 insertions, 0 deletions

diff --git a/Lib/curses/ascii.py b/Lib/curses/ascii.py
new file mode 100644
index 0000000..b53c91c
--- /dev/null
+++ b/Lib/curses/ascii.py
@@ -0,0 +1,102 @@
+#
+# ascii.py -- constants and memembership tests for ASCII characters
+#
+
+NUL	= 0x00	# ^@
+SOH	= 0x01	# ^A
+STX	= 0x02	# ^B
+ETX	= 0x03	# ^C
+EOT	= 0x04	# ^D
+ENQ	= 0x05	# ^E
+ACK	= 0x06	# ^F
+BEL	= 0x07	# ^G
+BS	= 0x08	# ^H
+TAB	= 0x09	# ^I
+HT	= 0x09	# ^I
+LF	= 0x0a	# ^J
+NL	= 0x0a	# ^J
+VT	= 0x0b	# ^K
+FF	= 0x0c	# ^L
+CR	= 0x0d	# ^M
+SO	= 0x0e	# ^N
+SI	= 0x0f	# ^O
+DLE	= 0x10	# ^P
+DC1	= 0x11	# ^Q
+DC2	= 0x12	# ^R
+DC3	= 0x13	# ^S
+DC4	= 0x14	# ^T
+NAK	= 0x15	# ^U
+SYN	= 0x16	# ^V
+ETB	= 0x17	# ^W
+CAN	= 0x18	# ^X
+EM	= 0x19	# ^Y
+SUB	= 0x1a	# ^Z
+ESC	= 0x1b	# ^[
+FS	= 0x1c	# ^\
+GS	= 0x1d	# ^]
+RS	= 0x1e	# ^^
+US	= 0x1f	# ^_
+SP	= 0x20	# space
+DEL	= 0x7f	# delete
+
+controlnames = [
+"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
+"BS",  "HT",  "LF",  "VT",  "FF",  "CR",  "SO",  "SI",
+"DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
+"CAN", "EM",  "SUB", "ESC", "FS",  "GS",  "RS",  "US",
+"SP"
+]
+
+def _ctoi(c):
+    if type(c) == type(""):
+        return ord(c)
+    else:
+        return c
+
+def isalnum(c): return isalpha(c) or isdigit(c)
+def isalpha(c): return isupper(c) or islower(c)
+def isascii(c): return _ctoi(c) <= 127		# ?
+def isblank(c): return _ctoi(c) in (8,32)
+def iscntrl(c): return _ctoi(c) <= 31
+def isdigit(c): return _ctoi(c) >= 48 and _ctoi(c) <= 57
+def isgraph(c): return _ctoi(c) >= 33 and _ctoi(c) <= 126
+def islower(c): return _ctoi(c) >= 97 and _ctoi(c) <= 122
+def isprint(c): return _ctoi(c) >= 32 and _ctoi(c) <= 126
+def ispunct(c): return _ctoi(c) != 32 and not isalnum(c)
+def isspace(c): return _ctoi(c) in (12, 10, 13, 9, 11)
+def isupper(c): return _ctoi(c) >= 65 and _ctoi(c) <= 90
+def isxdigit(c): return isdigit(c) or \
+    (_ctoi(c) >= 65 and _ctoi(c) <= 70) or (_ctoi(c) >= 97 and _ctoi(c) <= 102)
+def isctrl(c): return _ctoi(c) < 32
+def ismeta(c): return _ctoi(c) > 127
+
+def ascii(c):
+    if type(c) == type(""):
+        return chr(_ctoi(c) & 0x7f)
+    else:
+        return _ctoi(c) & 0x7f
+
+def ctrl(c):
+    if type(c) == type(""):
+        return chr(_ctoi(c) & 0x1f)
+    else:
+        return _ctoi(c) & 0x1f
+
+def alt(c):
+    if type(c) == type(""):
+        return chr(_ctoi(c) | 0x80)
+    else:
+        return _ctoi(c) | 0x80
+
+def unctrl(c):
+    bits = _ctoi(c)
+    if bits == 0x7f:
+        rep = "^?"
+    elif bits & 0x20:
+        rep = chr((bits & 0x7f) | 0x20)
+    else:
+        rep = "^" + chr(((bits & 0x7f) | 0x20) + 0x20)
+    if bits & 0x80:
+        return "!" + rep
+    return rep
+
diff --git a/Lib/curses/textpad.py b/Lib/curses/textpad.py
new file mode 100644
index 0000000..cd68174
--- /dev/null
+++ b/Lib/curses/textpad.py
@@ -0,0 +1,159 @@
+"""curses.textpad
+
+"""
+
+import sys, curses, ascii
+
+def rectangle(win, uly, ulx, lry, lrx):
+    "Draw a rectangle."
+    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 (nospaces off) or end of line (nospaces on).
+    Ctrl-F      Cursor right, wrapping to next line when appropriate.
+    Ctrl-G      Terminate, returning the window contents.
+    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
+    """
+    def __init__(self, win):
+        self.win = win
+        (self.maxy, self.maxx) = win.getmaxyx()
+        self.maxy = self.maxy - 1
+        self.maxx = self.maxx - 1
+        self.stripspaces = 1
+        win.keypad(1)
+
+    def firstblank(self, y):
+        "Go to the location of the first blank on the given line."
+        (oldy, oldx) = self.win.getyx()
+        self.win.move(y, self.maxx-1)
+        last = self.maxx-1
+        while 1:
+            if last == 0:
+                break
+            if ascii.ascii(self.win.inch(y, last)) != ascii.SP:
+                last = last + 1
+                break
+            last = last - 1
+        self.win.move(oldy, oldx)
+        return last
+
+    def do_command(self, ch):
+        "Process a single editing command."
+        (y, x) = self.win.getyx()
+        if ascii.isprint(ch):
+            if y < self.maxy or x < self.maxx:
+                # The try-catch ignores the error we trigger from some curses
+                # versions by trying to write into the lowest-rightmost spot
+                # in the self.window.
+                try:
+                    self.win.addch(ch)
+                except ERR:
+                    pass
+        elif ch == ascii.SOH:				# Ctrl-a
+            self.win.move(y, 0)
+        elif ch in (ascii.STX, curses.KEY_LEFT):	# Ctrl-b
+            if x > 0:
+                self.win.move(y, x-1)
+            elif y == 0:
+                pass
+            elif self.stripspaces:
+                self.win.move(y-1, self.firstblank(y-1))
+            else:
+                self.win.move(y-1, self.maxx)
+        elif ch == ascii.EOT:				# Ctrl-d
+            self.win.delch()
+        elif ch == ascii.ENQ:				# Ctrl-e
+            if self.stripspaces:
+                self.win.move(y, self.firstblank(y, maxx))
+            else:
+                self.win.move(y, self.maxx)
+        elif ch in (ascii.ACK, curses.KEY_RIGHT):	# Ctrl-f
+            if x < self.maxx:
+                self.win.move(y, x+1)
+            elif y == self.maxx:
+                pass
+            else:
+                self.win.move(y+1, 0)
+        elif ch == ascii.BEL:				# Ctrl-g
+            return 0
+        elif ch == ascii.NL:				# Ctrl-j
+            if self.maxy == 0:
+                return 0
+            elif y < self.maxy:
+                self.win.move(y+1, 0)
+        elif ch == ascii.VT:				# Ctrl-k
+            if x == 0 and self.firstblank(y) == 0:
+                self.win.deleteln()
+            else:
+                self.win.clrtoeol()
+        elif ch == ascii.FF:				# Ctrl-l
+            self.win.refresh()
+        elif ch in (ascii.SO, curses.KEY_DOWN):		# Ctrl-n
+            if y < self.maxy:
+                self.win.move(y+1, x)
+        elif ch == ascii.SI:				# Ctrl-o
+            self.win.insertln()
+        elif ch in (ascii.DLE, curses.KEY_UP):		# Ctrl-p
+            if y > 0:
+                self.win.move(y-1, x)
+        self.win.refresh()
+        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.firstblank(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(ascii.ascii(self.win.inch(y, x)))
+            if self.maxy > 0:
+                result = result + "\n"
+        return result
+
+    def edit(self, validate=None):
+        "Edit in the widget window and collect the results."
+        while 1:
+            ch = self.win.getch()
+            if validate:
+                ch = validate(ch)
+            if not self.do_command(ch):
+                break
+        return self.gather()
+
+if __name__ == '__main__':
+    def test_editbox(stdscr):
+        win = curses.newwin(4, 9, 15, 20)
+        rectangle(stdscr, 14, 19, 19, 29)
+        stdscr.refresh()
+        return textbox(win).edit()
+
+    str = curses.wrapper(test_editbox)
+    print str