forked from OSchip/llvm-project
321 lines
8.7 KiB
Python
Executable File
321 lines
8.7 KiB
Python
Executable File
##===-- cui.py -----------------------------------------------*- Python -*-===##
|
|
##
|
|
## The LLVM Compiler Infrastructure
|
|
##
|
|
## This file is distributed under the University of Illinois Open Source
|
|
## License. See LICENSE.TXT for details.
|
|
##
|
|
##===----------------------------------------------------------------------===##
|
|
|
|
import curses
|
|
import curses.ascii
|
|
import threading
|
|
|
|
class CursesWin(object):
|
|
def __init__(self, x, y, w, h):
|
|
self.win = curses.newwin(h, w, y, x)
|
|
self.focus = False
|
|
|
|
def setFocus(self, focus):
|
|
self.focus = focus
|
|
def getFocus(self):
|
|
return self.focus
|
|
def canFocus(self):
|
|
return True
|
|
|
|
def handleEvent(self, event):
|
|
return
|
|
def draw(self):
|
|
return
|
|
|
|
class TextWin(CursesWin):
|
|
def __init__(self, x, y, w):
|
|
super(TextWin, self).__init__(x, y, w, 1)
|
|
self.win.bkgd(curses.color_pair(1))
|
|
self.text = ''
|
|
self.reverse = False
|
|
|
|
def canFocus(self):
|
|
return False
|
|
|
|
def draw(self):
|
|
w = self.win.getmaxyx()[1]
|
|
text = self.text
|
|
if len(text) > w:
|
|
#trunc_length = len(text) - w
|
|
text = text[-w+1:]
|
|
if self.reverse:
|
|
self.win.addstr(0, 0, text, curses.A_REVERSE)
|
|
else:
|
|
self.win.addstr(0, 0, text)
|
|
self.win.noutrefresh()
|
|
|
|
def setReverse(self, reverse):
|
|
self.reverse = reverse
|
|
|
|
def setText(self, text):
|
|
self.text = text
|
|
|
|
class TitledWin(CursesWin):
|
|
def __init__(self, x, y, w, h, title):
|
|
super(TitledWin, self).__init__(x, y+1, w, h-1)
|
|
self.title = title
|
|
self.title_win = TextWin(x, y, w)
|
|
self.title_win.setText(title)
|
|
self.draw()
|
|
|
|
def setTitle(self, title):
|
|
self.title_win.setText(title)
|
|
|
|
def draw(self):
|
|
self.title_win.setReverse(self.getFocus())
|
|
self.title_win.draw()
|
|
self.win.noutrefresh()
|
|
|
|
class ListWin(CursesWin):
|
|
def __init__(self, x, y, w, h):
|
|
super(ListWin, self).__init__(x, y, w, h)
|
|
self.items = []
|
|
self.selected = 0
|
|
self.first_drawn = 0
|
|
self.win.leaveok(True)
|
|
|
|
def draw(self):
|
|
if len(self.items) == 0:
|
|
self.win.erase()
|
|
return
|
|
|
|
h, w = self.win.getmaxyx()
|
|
|
|
allLines = []
|
|
firstSelected = -1
|
|
lastSelected = -1
|
|
for i, item in enumerate(self.items):
|
|
lines = self.items[i].split('\n')
|
|
lines = lines if lines[len(lines)-1] != '' else lines[:-1]
|
|
if len(lines) == 0:
|
|
lines = ['']
|
|
|
|
if i == self.getSelected():
|
|
firstSelected = len(allLines)
|
|
allLines.extend(lines)
|
|
if i == self.selected:
|
|
lastSelected = len(allLines) - 1
|
|
|
|
if firstSelected < self.first_drawn:
|
|
self.first_drawn = firstSelected
|
|
elif lastSelected >= self.first_drawn + h:
|
|
self.first_drawn = lastSelected - h + 1
|
|
|
|
self.win.erase()
|
|
|
|
begin = self.first_drawn
|
|
end = begin + h
|
|
|
|
y = 0
|
|
for i, line in list(enumerate(allLines))[begin:end]:
|
|
attr = curses.A_NORMAL
|
|
if i >= firstSelected and i <= lastSelected:
|
|
attr = curses.A_REVERSE
|
|
line = '{0:{width}}'.format(line, width=w-1)
|
|
|
|
# Ignore the error we get from drawing over the bottom-right char.
|
|
try:
|
|
self.win.addstr(y, 0, line[:w], attr)
|
|
except curses.error:
|
|
pass
|
|
y += 1
|
|
self.win.noutrefresh()
|
|
|
|
def getSelected(self):
|
|
if self.items:
|
|
return self.selected
|
|
return -1
|
|
|
|
def setSelected(self, selected):
|
|
self.selected = selected
|
|
if self.selected < 0:
|
|
self.selected = 0
|
|
elif self.selected >= len(self.items):
|
|
self.selected = len(self.items) - 1
|
|
|
|
def handleEvent(self, event):
|
|
if isinstance(event, int):
|
|
if len(self.items) > 0:
|
|
if event == curses.KEY_UP:
|
|
self.setSelected(self.selected - 1)
|
|
if event == curses.KEY_DOWN:
|
|
self.setSelected(self.selected + 1)
|
|
if event == curses.ascii.NL:
|
|
self.handleSelect(self.selected)
|
|
|
|
def addItem(self, item):
|
|
self.items.append(item)
|
|
|
|
def clearItems(self):
|
|
self.items = []
|
|
|
|
def handleSelect(self, index):
|
|
return
|
|
|
|
class InputHandler(threading.Thread):
|
|
def __init__(self, screen, queue):
|
|
super(InputHandler, self).__init__()
|
|
self.screen = screen
|
|
self.queue = queue
|
|
|
|
def run(self):
|
|
while True:
|
|
c = self.screen.getch()
|
|
self.queue.put(c)
|
|
|
|
|
|
class CursesUI(object):
|
|
""" Responsible for updating the console UI with curses. """
|
|
def __init__(self, screen, event_queue):
|
|
self.screen = screen
|
|
self.event_queue = event_queue
|
|
|
|
curses.start_color()
|
|
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)
|
|
curses.init_pair(2, curses.COLOR_YELLOW, curses.COLOR_BLACK)
|
|
curses.init_pair(3, curses.COLOR_RED, curses.COLOR_BLACK)
|
|
self.screen.bkgd(curses.color_pair(1))
|
|
self.screen.clear()
|
|
|
|
self.input_handler = InputHandler(self.screen, self.event_queue)
|
|
self.input_handler.daemon = True
|
|
|
|
self.focus = 0
|
|
|
|
self.screen.refresh()
|
|
|
|
def focusNext(self):
|
|
self.wins[self.focus].setFocus(False)
|
|
old = self.focus
|
|
while True:
|
|
self.focus += 1
|
|
if self.focus >= len(self.wins):
|
|
self.focus = 0
|
|
if self.wins[self.focus].canFocus():
|
|
break
|
|
self.wins[self.focus].setFocus(True)
|
|
|
|
def handleEvent(self, event):
|
|
if isinstance(event, int):
|
|
if event == curses.KEY_F3:
|
|
self.focusNext()
|
|
|
|
def eventLoop(self):
|
|
|
|
self.input_handler.start()
|
|
self.wins[self.focus].setFocus(True)
|
|
|
|
while True:
|
|
self.screen.noutrefresh()
|
|
|
|
for i, win in enumerate(self.wins):
|
|
if i != self.focus:
|
|
win.draw()
|
|
# Draw the focused window last so that the cursor shows up.
|
|
if self.wins:
|
|
self.wins[self.focus].draw()
|
|
curses.doupdate() # redraw the physical screen
|
|
|
|
event = self.event_queue.get()
|
|
|
|
for win in self.wins:
|
|
if isinstance(event, int):
|
|
if win.getFocus() or not win.canFocus():
|
|
win.handleEvent(event)
|
|
else:
|
|
win.handleEvent(event)
|
|
self.handleEvent(event)
|
|
|
|
class CursesEditLine(object):
|
|
""" Embed an 'editline'-compatible prompt inside a CursesWin. """
|
|
def __init__(self, win, history, enterCallback, tabCompleteCallback):
|
|
self.win = win
|
|
self.history = history
|
|
self.enterCallback = enterCallback
|
|
self.tabCompleteCallback = tabCompleteCallback
|
|
|
|
self.prompt = ''
|
|
self.content = ''
|
|
self.index = 0
|
|
self.startx = -1
|
|
self.starty = -1
|
|
|
|
def draw(self, prompt=None):
|
|
if not prompt:
|
|
prompt = self.prompt
|
|
(h, w) = self.win.getmaxyx()
|
|
if (len(prompt) + len(self.content)) / w + self.starty >= h-1:
|
|
self.win.scroll(1)
|
|
self.starty -= 1
|
|
if self.starty < 0:
|
|
raise RuntimeError('Input too long; aborting')
|
|
(y, x) = (self.starty, self.startx)
|
|
|
|
self.win.move(y, x)
|
|
self.win.clrtobot()
|
|
self.win.addstr(y, x, prompt)
|
|
remain = self.content
|
|
self.win.addstr(remain[:w-len(prompt)])
|
|
remain = remain[w-len(prompt):]
|
|
while remain != '':
|
|
y += 1
|
|
self.win.addstr(y, 0, remain[:w])
|
|
remain = remain[w:]
|
|
|
|
length = self.index + len(prompt)
|
|
self.win.move(self.starty + length / w, length % w)
|
|
|
|
def showPrompt(self, y, x, prompt=None):
|
|
self.content = ''
|
|
self.index = 0
|
|
self.startx = x
|
|
self.starty = y
|
|
self.draw(prompt)
|
|
|
|
def handleEvent(self, event):
|
|
if not isinstance(event, int):
|
|
return # not handled
|
|
key = event
|
|
|
|
if self.startx == -1:
|
|
raise RuntimeError('Trying to handle input without prompt')
|
|
|
|
if key == curses.ascii.NL:
|
|
self.enterCallback(self.content)
|
|
elif key == curses.ascii.TAB:
|
|
self.tabCompleteCallback(self.content)
|
|
elif curses.ascii.isprint(key):
|
|
self.content = self.content[:self.index] + chr(key) + self.content[self.index:]
|
|
self.index += 1
|
|
elif key == curses.KEY_BACKSPACE or key == curses.ascii.BS:
|
|
if self.index > 0:
|
|
self.index -= 1
|
|
self.content = self.content[:self.index] + self.content[self.index+1:]
|
|
elif key == curses.KEY_DC or key == curses.ascii.DEL or key == curses.ascii.EOT:
|
|
self.content = self.content[:self.index] + self.content[self.index+1:]
|
|
elif key == curses.ascii.VT: # CTRL-K
|
|
self.content = self.content[:self.index]
|
|
elif key == curses.KEY_LEFT or key == curses.ascii.STX: # left or CTRL-B
|
|
if self.index > 0:
|
|
self.index -= 1
|
|
elif key == curses.KEY_RIGHT or key == curses.ascii.ACK: # right or CTRL-F
|
|
if self.index < len(self.content):
|
|
self.index += 1
|
|
elif key == curses.ascii.SOH: # CTRL-A
|
|
self.index = 0
|
|
elif key == curses.ascii.ENQ: # CTRL-E
|
|
self.index = len(self.content)
|
|
elif key == curses.KEY_UP or key == curses.ascii.DLE: # up or CTRL-P
|
|
self.content = self.history.previous(self.content)
|
|
self.index = len(self.content)
|
|
elif key == curses.KEY_DOWN or key == curses.ascii.SO: # down or CTRL-N
|
|
self.content = self.history.next()
|
|
self.index = len(self.content)
|
|
self.draw()
|