mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-29 17:06:07 +00:00
b9c1b51e45
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
340 lines
10 KiB
Python
Executable File
340 lines
10 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()
|