mirror of
https://github.com/python/cpython.git
synced 2026-07-24 19:02:12 -04:00
Miss Islington (bot)
bbc7e9b323
Textbox mangled non-ASCII characters of an 8-bit locale encoding: it masked
reads with curses.ascii.ascii(), which clears the 8th bit, and tested input
with curses.ascii.isprint(), which rejects bytes above 127.
Decode cells and input bytes with the window's encoding instead. Cells are
read with instr() and the lower-right cell is written as text, since inch() and
insch() with an int byte mishandle a non-ASCII character on a wide build. This
uses only the byte-oriented curses API, so it works without wide-character
support.
(cherry picked from commit c253f0c14b)
Co-authored-by: Serhiy Storchaka <storchaka@gmail.com>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
237 lines
9.1 KiB
Python
237 lines
9.1 KiB
Python
"""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 move to start
|
|
of next line.
|
|
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._update_max_yx()
|
|
self.stripspaces = 1
|
|
self.lastcmd = None
|
|
win.keypad(1)
|
|
|
|
def _update_max_yx(self):
|
|
maxy, maxx = self.win.getmaxyx()
|
|
self.maxy = maxy - 1
|
|
self.maxx = maxx - 1
|
|
|
|
def _decode(self, ch):
|
|
# The text of a chtype cell or input byte, decoded with the window's
|
|
# encoding. A_CHARTEXT keeps the character byte, dropping the attributes.
|
|
return bytes([ch & curses.A_CHARTEXT]).decode(self.win.encoding, 'replace')
|
|
|
|
def _char_at(self, *yx):
|
|
# The text of the cell at the given position (default: the cursor).
|
|
# instr() re-encodes it to the window's encoding; inch() cannot
|
|
# represent a non-ASCII 8-bit-locale character on a wide build.
|
|
return self.win.instr(*yx, 1).decode(self.win.encoding, 'replace')
|
|
|
|
def _cell_at(self, *yx):
|
|
# The cell at the given position (default: the cursor) as a chtype
|
|
# addch() can write back with its rendition. inch() mangles a non-ASCII
|
|
# character on a wide build, so take the byte from instr() and the
|
|
# attributes from inch().
|
|
return self.win.instr(*yx, 1)[0] | self.win.inch(*yx) & curses.A_ATTRIBUTES
|
|
|
|
def _isprint(self, cell):
|
|
# Whether a chtype cell holds a printable character; _decode() drops the
|
|
# attribute bits.
|
|
return self._decode(cell).isprintable()
|
|
|
|
def _printable_key(self, ch):
|
|
# Whether the integer keystroke is a printable character, not a key
|
|
# code. 0..255 are character bytes (decoded with the window's encoding);
|
|
# larger values are function and navigation keys.
|
|
return ch <= 0xff and self._decode(ch).isprintable()
|
|
|
|
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."""
|
|
self._update_max_yx()
|
|
last = self.maxx
|
|
while True:
|
|
if self._char_at(y, last) != ' ':
|
|
last = min(self.maxx, last+1)
|
|
break
|
|
elif last == 0:
|
|
break
|
|
last = last - 1
|
|
return last
|
|
|
|
def _insert_printable_char(self, ch):
|
|
self._update_max_yx()
|
|
(y, x) = self.win.getyx()
|
|
backyx = None
|
|
while True:
|
|
if self.insert_mode:
|
|
oldch = self._cell_at()
|
|
if y >= self.maxy and x >= self.maxx:
|
|
# Use insch() in the lower-right cell: addch() there would move
|
|
# the cursor out of the window, raising an error and scrolling
|
|
# a scrollable window. Pass it as text: insch() does not decode
|
|
# an int byte through the locale on a wide build.
|
|
self.win.insch(self._decode(ch), ch & curses.A_ATTRIBUTES)
|
|
break
|
|
self.win.addch(ch)
|
|
if not self.insert_mode or not self._isprint(oldch):
|
|
break
|
|
ch = oldch
|
|
(y, x) = self.win.getyx()
|
|
# Remember where to put the cursor back since we are in insert_mode
|
|
if backyx is None:
|
|
backyx = y, x
|
|
|
|
if backyx is not None:
|
|
self.win.move(*backyx)
|
|
|
|
def do_command(self, ch):
|
|
"Process a single editing command."
|
|
self._update_max_yx()
|
|
(y, x) = self.win.getyx()
|
|
self.lastcmd = ch
|
|
if self._printable_key(ch):
|
|
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,
|
|
curses.ascii.DEL):
|
|
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, curses.ascii.DEL):
|
|
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 = ""
|
|
self._update_max_yx()
|
|
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 + self._char_at(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 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))
|