327 lines
6.2 KiB
Python
327 lines
6.2 KiB
Python
import os
|
|
import tty, termios
|
|
import select
|
|
|
|
COLOR_BLACK = 0
|
|
COLOR_RED = 1
|
|
COLOR_GREEN = 2
|
|
COLOR_YELLOW = 3
|
|
COLOR_BLUE = 4
|
|
COLOR_MAGENTA = 5
|
|
COLOR_CYAN = 6
|
|
COLOR_WHITE = 7
|
|
|
|
A_NORMAL = 0
|
|
A_BOLD = 1
|
|
A_UNDERLINE = 2
|
|
A_REVERSE = 4
|
|
A_STANDOUT = A_REVERSE
|
|
|
|
ATTRMAP = {
|
|
A_NORMAL: b"\x1b[0m",
|
|
A_BOLD: b"\x1b[1m", # Some terminal emulators don't render bold by default, then use 4m for underline
|
|
A_REVERSE: b"\x1b[7m",
|
|
}
|
|
|
|
# Use http://www.utf8-chartable.de/unicode-utf8-table.pl
|
|
# for utf-8 pseudographic reference
|
|
# "─"
|
|
ACS_HLINE = b"\xe2\x94\x80"
|
|
# "│"
|
|
ACS_VLINE = b"\xe2\x94\x82"
|
|
# "┌"
|
|
ACS_ULCORNER = b"\xe2\x94\x8c"
|
|
# "┐"
|
|
ACS_URCORNER = b"\xe2\x94\x90"
|
|
# "└"
|
|
ACS_LLCORNER = b"\xe2\x94\x94"
|
|
# "┘"
|
|
ACS_LRCORNER = b"\xe2\x94\x98"
|
|
|
|
KEY_F1 = 1031
|
|
KEY_RESIZE = 1100
|
|
KEY_MOUSE = 1101
|
|
KEY_BTAB = 1090
|
|
|
|
KEY_UP = 1001
|
|
KEY_DOWN = 1002
|
|
KEY_LEFT = 1003
|
|
KEY_RIGHT = 1004
|
|
KEY_HOME = 1005
|
|
KEY_END = 1006
|
|
KEY_PGUP = 1007
|
|
KEY_PGDN = 1008
|
|
KEY_QUIT = 1009
|
|
KEY_ENTER = 1010
|
|
KEY_BACKSPACE = 1011
|
|
KEY_DELETE = 1012
|
|
KEY_ESC = 0x1b
|
|
|
|
KEY_DC = KEY_DELETE
|
|
KEY_PPAGE = KEY_PGUP
|
|
KEY_NPAGE = KEY_PGDN
|
|
|
|
KEYMAP = {
|
|
b"\x1b[A": KEY_UP,
|
|
b"\x1b[B": KEY_DOWN,
|
|
b"\x1b[D": KEY_LEFT,
|
|
b"\x1b[C": KEY_RIGHT,
|
|
b"\x1bOH": KEY_HOME,
|
|
b"\x1bOF": KEY_END,
|
|
b"\x1b[1~": KEY_HOME,
|
|
b"\x1b[4~": KEY_END,
|
|
b"\x1b[5~": KEY_PGUP,
|
|
b"\x1b[6~": KEY_PGDN,
|
|
b"\x03": KEY_QUIT,
|
|
b"\r": KEY_ENTER,
|
|
b"\x7f": KEY_BACKSPACE,
|
|
b"\x1b[3~": KEY_DELETE,
|
|
|
|
b"\x1bOA": KEY_UP,
|
|
b"\x1bOB": KEY_DOWN,
|
|
b"\x1bOD": KEY_LEFT,
|
|
b"\x1bOC": KEY_RIGHT,
|
|
b"\x1bOP": KEY_F1,
|
|
b"\x1b": KEY_ESC,
|
|
|
|
b"\x1b[Z": KEY_BTAB,
|
|
}
|
|
|
|
ALL_MOUSE_EVENTS = 0xff
|
|
|
|
|
|
def _wr(s):
|
|
# TODO: When Python is 3.5, update this to use only bytes
|
|
if isinstance(s, str):
|
|
s = bytes(s, "utf-8")
|
|
os.write(1, s)
|
|
|
|
def _move(row, col):
|
|
# TODO: When Python is 3.5, update this to use bytes
|
|
_wr("\x1b[%d;%dH" % (row + 1, col + 1))
|
|
|
|
# Clear specified number of positions
|
|
def _clear_num_pos(num):
|
|
if num > 0:
|
|
_wr("\x1b[%dX" % num)
|
|
|
|
def _draw_box(left, top, width, height):
|
|
bottom = top + height - 1
|
|
_move(top, left)
|
|
_wr(ACS_ULCORNER)
|
|
hor = ACS_HLINE * (width - 2)
|
|
_wr(hor)
|
|
_wr(ACS_URCORNER)
|
|
|
|
_move(bottom, left)
|
|
_wr(ACS_LLCORNER)
|
|
_wr(hor)
|
|
_wr(ACS_LRCORNER)
|
|
|
|
top += 1
|
|
while top < bottom:
|
|
_move(top, left)
|
|
_wr(ACS_VLINE)
|
|
_move(top, left + width - 1)
|
|
_wr(ACS_VLINE)
|
|
top += 1
|
|
|
|
|
|
class error(Exception):
|
|
pass
|
|
|
|
|
|
class Window:
|
|
|
|
def __init__(self, lines, cols, y, x):
|
|
self.lines = lines
|
|
self.cols = cols
|
|
self.y = y
|
|
self.x = x
|
|
self.bkgattr = A_NORMAL
|
|
self.keybuf = None
|
|
self.keyi = 0
|
|
self.keydelay = -1
|
|
|
|
def _goto(self, row, col):
|
|
_move(self.y + row, self.x + col)
|
|
|
|
def move(self, y, x):
|
|
# Maybe need to cache coords?
|
|
self._goto(y, x)
|
|
|
|
def getmaxyx(self):
|
|
return (self.lines, self.cols)
|
|
|
|
def addstr(self, y, x, str, attr=A_NORMAL):
|
|
self._goto(y, x)
|
|
# TODO: Should be "ORed"
|
|
if attr == A_NORMAL:
|
|
attr = self.bkgattr
|
|
if attr != A_NORMAL:
|
|
_wr(ATTRMAP[attr])
|
|
_wr(str)
|
|
_wr(ATTRMAP[A_NORMAL])
|
|
else:
|
|
_wr(str)
|
|
|
|
def addnstr(self, y, x, str, n, attr=A_NORMAL):
|
|
self.addstr(y, x, str[:n], attr)
|
|
|
|
def addch(self, y, x, ch, attr=A_NORMAL):
|
|
if isinstance(ch, int):
|
|
ch = chr(ch)
|
|
self.addstr(y, x, ch, attr)
|
|
|
|
def attron(self, attr):
|
|
pass
|
|
|
|
def attroff(self, attr):
|
|
pass
|
|
|
|
def attrset(self, attr):
|
|
pass
|
|
|
|
def bkgdset(self, ch, attr=A_NORMAL):
|
|
self.bkgattr = attr
|
|
|
|
def erase(self):
|
|
for i in range(self.lines):
|
|
self._goto(i, 0)
|
|
_clear_num_pos(self.cols)
|
|
|
|
def border(self):
|
|
_draw_box(self.x, self.y, self.cols, self.lines)
|
|
|
|
def hline(self, y, x, ch, n):
|
|
self.move(y, x)
|
|
_wr(ch * n)
|
|
|
|
def vline(self, y, x, ch, n):
|
|
for i in range(n):
|
|
self.move(y + i, x)
|
|
_wr(ch)
|
|
|
|
def refresh(self):
|
|
pass
|
|
|
|
def redrawwin(self):
|
|
pass
|
|
|
|
def keypad(self, yes):
|
|
pass
|
|
|
|
def timeout(self, delay):
|
|
self.keydelay = delay
|
|
|
|
def nodelay(self, yes):
|
|
if yes:
|
|
self.keydelay = 0
|
|
else:
|
|
self.keydelay = -1
|
|
|
|
def getch(self):
|
|
if self.keybuf and self.keyi < len(self.keybuf):
|
|
c = self.keybuf[self.keyi]
|
|
self.keyi += 1
|
|
return c
|
|
|
|
if self.keydelay >= 0:
|
|
USE_EPOLL = 1
|
|
if USE_EPOLL:
|
|
poll = select.epoll()
|
|
poll.register(0, select.EPOLLIN)
|
|
res = poll.poll(self.keydelay / 1000)
|
|
poll.unregister(0)
|
|
poll.close()
|
|
else:
|
|
res = select.select([0], [], [], self.keydelay / 1000)[0]
|
|
if not res:
|
|
return -1
|
|
|
|
key = os.read(0, 32)
|
|
if key[0] != 0x1b:
|
|
self.keybuf = key
|
|
self.keyi = 1
|
|
key = key[0]
|
|
|
|
else:
|
|
if key in KEYMAP:
|
|
key = KEYMAP[key]
|
|
else:
|
|
assert False, repr(key)
|
|
return key
|
|
|
|
|
|
SCREEN = Window(24, 80, 0, 0)
|
|
org_termios = None
|
|
|
|
|
|
def wrapper(func):
|
|
global org_termios
|
|
org_termios = termios.tcgetattr(0)
|
|
res = func()
|
|
endwin()
|
|
return res
|
|
|
|
def initscr():
|
|
global org_termios
|
|
org_termios = termios.tcgetattr(0)
|
|
return SCREEN
|
|
|
|
def doupdate():
|
|
pass
|
|
|
|
def endwin():
|
|
global org_termios
|
|
_wr(b"\r")
|
|
termios.tcsetattr(0, termios.TCSANOW, org_termios)
|
|
|
|
def raw():
|
|
tty.setraw(0)
|
|
|
|
def cbreak():
|
|
#TODO
|
|
pass
|
|
|
|
def nocbreak():
|
|
#TODO
|
|
pass
|
|
|
|
def echo():
|
|
#TODO
|
|
pass
|
|
|
|
def noecho():
|
|
#TODO
|
|
pass
|
|
|
|
def meta(yes):
|
|
#TODO
|
|
pass
|
|
|
|
def mousemask(mask):
|
|
# Mouse reporting - X10 compatbility mode
|
|
_wr(b"\x1b[?9h")
|
|
|
|
def has_colors():
|
|
return False
|
|
|
|
def can_change_color():
|
|
return False
|
|
|
|
def curs_set(visibility):
|
|
if visibility > 0:
|
|
_wr(b"\x1b[?25h")
|
|
else:
|
|
_wr(b"\x1b[?25l")
|
|
|
|
def beep():
|
|
_wr(b"\x07")
|
|
|
|
def newwin(lines, cols, y=0, x=0):
|
|
#print("newwin(%d, %d, %d, %d)" % (lines, cols, y, x))
|
|
cols = cols or SCREEN.cols
|
|
lines = lines or SCREEN.lines
|
|
return Window(lines, cols, y, x)
|