--- /dev/null
+#
+# 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
+
--- /dev/null
+"""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
projects / python / commitdiff