[Lldb-commits] [lldb] r370804 - [lldb][NFC] Remove lldbcurses.py
Raphael Isemann via lldb-commits
lldb-commits at lists.llvm.org
Tue Sep 3 11:11:54 PDT 2019
Author: teemperor
Date: Tue Sep 3 11:11:54 2019
New Revision: 370804
URL: http://llvm.org/viewvc/llvm-project?rev=370804&view=rev
Log:
[lldb][NFC] Remove lldbcurses.py
Summary: This doesn't seem to be used anymore (at least I can't find any reference to this in the LLDB repo and it doesn't seem to be a standalone script). Git says this was once some new curses mode for viewing test results.
Reviewers: clayborg, JDevlieghere
Reviewed By: JDevlieghere
Subscribers: JDevlieghere, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D67064
Removed:
lldb/trunk/packages/Python/lldbsuite/test/lldbcurses.py
Removed: lldb/trunk/packages/Python/lldbsuite/test/lldbcurses.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/packages/Python/lldbsuite/test/lldbcurses.py?rev=370803&view=auto
==============================================================================
--- lldb/trunk/packages/Python/lldbsuite/test/lldbcurses.py (original)
+++ lldb/trunk/packages/Python/lldbsuite/test/lldbcurses.py (removed)
@@ -1,1306 +0,0 @@
-from __future__ import absolute_import
-
-# System modules
-import curses
-import curses.panel
-import sys
-
-# Third-party modules
-import six
-
-# LLDB modules
-
-
-class Point(object):
-
- def __init__(self, x, y):
- self.x = x
- self.y = y
-
- def __repr__(self):
- return str(self)
-
- def __str__(self):
- return "(x=%u, y=%u)" % (self.x, self.y)
-
- def __eq__(self, rhs):
- return self.x == rhs.x and self.y == rhs.y
-
- def __ne__(self, rhs):
- return self.x != rhs.x or self.y != rhs.y
-
- def is_valid_coordinate(self):
- return self.x >= 0 and self.y >= 0
-
-
-class Size(object):
-
- def __init__(self, w, h):
- self.w = w
- self.h = h
-
- def __repr__(self):
- return str(self)
-
- def __str__(self):
- return "(w=%u, h=%u)" % (self.w, self.h)
-
- def __eq__(self, rhs):
- return self.w == rhs.w and self.h == rhs.h
-
- def __ne__(self, rhs):
- return self.w != rhs.w or self.h != rhs.h
-
-
-class Rect(object):
-
- def __init__(self, x=0, y=0, w=0, h=0):
- self.origin = Point(x, y)
- self.size = Size(w, h)
-
- def __repr__(self):
- return str(self)
-
- def __str__(self):
- return "{ %s, %s }" % (str(self.origin), str(self.size))
-
- def get_min_x(self):
- return self.origin.x
-
- def get_max_x(self):
- return self.origin.x + self.size.w
-
- def get_min_y(self):
- return self.origin.y
-
- def get_max_y(self):
- return self.origin.y + self.size.h
-
- def contains_point(self, pt):
- if pt.x < self.get_max_x():
- if pt.y < self.get_max_y():
- if pt.x >= self.get_min_y():
- return pt.y >= self.get_min_y()
- return False
-
- def __eq__(self, rhs):
- return self.origin == rhs.origin and self.size == rhs.size
-
- def __ne__(self, rhs):
- return self.origin != rhs.origin or self.size != rhs.size
-
-
-class QuitException(Exception):
-
- def __init__(self):
- super(QuitException, self).__init__('QuitException')
-
-
-class Window(object):
-
- def __init__(self, window, delegate=None, can_become_first_responder=True):
- self.window = window
- self.parent = None
- self.delegate = delegate
- self.children = list()
- self.first_responders = list()
- self.can_become_first_responder = can_become_first_responder
- self.key_actions = dict()
-
- def add_child(self, window):
- self.children.append(window)
- window.parent = self
-
- def resize(self, size):
- self.window.resize(size.h, size.w)
-
- def resize_child(self, child, delta_size, adjust_neighbors):
- if child in self.children:
- frame = self.get_frame()
- orig_frame = child.get_frame()
- new_frame = Rect(
- x=orig_frame.origin.x,
- y=orig_frame.origin.y,
- w=orig_frame.size.w +
- delta_size.w,
- h=orig_frame.size.h +
- delta_size.h)
- old_child_max_x = orig_frame.get_max_x()
- new_child_max_x = new_frame.get_max_x()
- window_max_x = frame.get_max_x()
- if new_child_max_x < window_max_x:
- child.resize(new_frame.size)
- if old_child_max_x == window_max_x:
- new_frame.origin.x += window_max_x - new_child_max_x
- child.set_position(new_frame.origin)
- elif new_child_max_x > window_max_x:
- new_frame.origin.x -= new_child_max_x - window_max_x
- child.set_position(new_frame.origin)
- child.resize(new_frame.size)
-
- if adjust_neighbors:
- #print('orig_frame = %s\r\n' % (str(orig_frame)), end='')
- for curr_child in self.children:
- if curr_child is child:
- continue
- curr_child_frame = curr_child.get_frame()
- if delta_size.w != 0:
- #print('curr_child_frame = %s\r\n' % (str(curr_child_frame)), end='')
- if curr_child_frame.get_min_x() == orig_frame.get_max_x():
- curr_child_frame.origin.x += delta_size.w
- curr_child_frame.size.w -= delta_size.w
- #print('adjusted curr_child_frame = %s\r\n' % (str(curr_child_frame)), end='')
- curr_child.resize(curr_child_frame.size)
- curr_child.slide_position(
- Size(w=delta_size.w, h=0))
- elif curr_child_frame.get_max_x() == orig_frame.get_min_x():
- curr_child_frame.size.w -= delta_size.w
- #print('adjusted curr_child_frame = %s\r\n' % (str(curr_child_frame)), end='')
- curr_child.resize(curr_child_frame.size)
-
- def add_key_action(self, arg, callback, decription):
- if isinstance(arg, list):
- for key in arg:
- self.add_key_action(key, callback, description)
- else:
- if isinstance(arg, six.integer_types):
- key_action_dict = {'key': arg,
- 'callback': callback,
- 'description': decription}
- self.key_actions[arg] = key_action_dict
- elif isinstance(arg, basestring):
- key_integer = ord(arg)
- key_action_dict = {'key': key_integer,
- 'callback': callback,
- 'description': decription}
- self.key_actions[key_integer] = key_action_dict
- else:
- raise ValueError
-
- def draw_title_box(self, title):
- is_in_first_responder_chain = self.is_in_first_responder_chain()
- if is_in_first_responder_chain:
- self.attron(curses.A_REVERSE)
- self.box()
- if is_in_first_responder_chain:
- self.attroff(curses.A_REVERSE)
- if title:
- self.addstr(Point(x=2, y=0), ' ' + title + ' ')
-
- def remove_child(self, window):
- self.children.remove(window)
-
- def get_first_responder(self):
- if len(self.first_responders):
- return self.first_responders[-1]
- else:
- return None
-
- def set_first_responder(self, window):
- if window.can_become_first_responder:
- if six.callable(
- getattr(
- window,
- "hidden",
- None)) and window.hidden():
- return False
- if window not in self.children:
- self.add_child(window)
- # See if we have a current first responder, and if we do, let it know that
- # it will be resigning as first responder
- first_responder = self.get_first_responder()
- if first_responder:
- first_responder.relinquish_first_responder()
- # Now set the first responder to "window"
- if len(self.first_responders) == 0:
- self.first_responders.append(window)
- else:
- self.first_responders[-1] = window
- return True
- else:
- return False
-
- def push_first_responder(self, window):
- # Only push the window as the new first responder if the window isn't
- # already the first responder
- if window != self.get_first_responder():
- self.first_responders.append(window)
-
- def pop_first_responder(self, window):
- # Only pop the window from the first responder list if it is the first
- # responder
- if window == self.get_first_responder():
- old_first_responder = self.first_responders.pop()
- old_first_responder.relinquish_first_responder()
- return True
- else:
- return False
-
- def relinquish_first_responder(self):
- '''Override if there is something that you need to do when you lose first responder status.'''
-
- # def resign_first_responder(self, remove_from_parent, new_first_responder):
- # success = False
- # if self.parent:
- # if self.is_first_responder():
- # self.relinquish_first_responder()
- # if len(self.parent.first_responder):
- # self.parent.first_responder = None
- # success = True
- # if remove_from_parent:
- # self.parent.remove_child(self)
- # if new_first_responder:
- # self.parent.set_first_responder(new_first_responder)
- # else:
- # self.parent.select_next_first_responder()
- # return success
-
- def is_first_responder(self):
- if self.parent:
- return self.parent.get_first_responder() == self
- else:
- return False
-
- def is_in_first_responder_chain(self):
- if self.parent:
- return self in self.parent.first_responders
- else:
- return False
-
- def select_next_first_responder(self):
- if len(self.first_responders) > 1:
- self.pop_first_responder(self.first_responders[-1])
- else:
- num_children = len(self.children)
- if num_children == 1:
- return self.set_first_responder(self.children[0])
- for (i, window) in enumerate(self.children):
- if window.is_first_responder():
- break
- if i < num_children:
- for i in range(i + 1, num_children):
- if self.set_first_responder(self.children[i]):
- return True
- for i in range(0, i):
- if self.set_first_responder(self.children[i]):
- return True
-
- def point_in_window(self, pt):
- size = self.get_size()
- return pt.x >= 0 and pt.x < size.w and pt.y >= 0 and pt.y < size.h
-
- def addch(self, c):
- try:
- self.window.addch(c)
- except:
- pass
-
- def addch_at_point(self, pt, c):
- try:
- self.window.addch(pt.y, pt.x, c)
- except:
- pass
-
- def addstr(self, pt, str):
- try:
- self.window.addstr(pt.y, pt.x, str)
- except:
- pass
-
- def addnstr_at_point(self, pt, str, n):
- try:
- self.window.addnstr(pt.y, pt.x, str, n)
- except:
- pass
-
- def addnstr(self, str, n):
- try:
- self.window.addnstr(str, n)
- except:
- pass
-
- def attron(self, attr):
- return self.window.attron(attr)
-
- def attroff(self, attr):
- return self.window.attroff(attr)
-
- def box(self, vertch=0, horch=0):
- if vertch == 0:
- vertch = curses.ACS_VLINE
- if horch == 0:
- horch = curses.ACS_HLINE
- self.window.box(vertch, horch)
-
- def get_contained_rect(
- self,
- top_inset=0,
- bottom_inset=0,
- left_inset=0,
- right_inset=0,
- height=-1,
- width=-1):
- '''Get a rectangle based on the top "height" lines of this window'''
- rect = self.get_frame()
- x = rect.origin.x + left_inset
- y = rect.origin.y + top_inset
- if height == -1:
- h = rect.size.h - (top_inset + bottom_inset)
- else:
- h = height
- if width == -1:
- w = rect.size.w - (left_inset + right_inset)
- else:
- w = width
- return Rect(x=x, y=y, w=w, h=h)
-
- def erase(self):
- self.window.erase()
-
- def get_cursor(self):
- (y, x) = self.window.getyx()
- return Point(x=x, y=y)
-
- def get_frame(self):
- position = self.get_position()
- size = self.get_size()
- return Rect(x=position.x, y=position.y, w=size.w, h=size.h)
-
- def get_frame_in_parent(self):
- position = self.get_position_in_parent()
- size = self.get_size()
- return Rect(x=position.x, y=position.y, w=size.w, h=size.h)
-
- def get_position_in_parent(self):
- (y, x) = self.window.getparyx()
- return Point(x, y)
-
- def get_position(self):
- (y, x) = self.window.getbegyx()
- return Point(x, y)
-
- def get_size(self):
- (y, x) = self.window.getmaxyx()
- return Size(w=x, h=y)
-
- def move(self, pt):
- self.window.move(pt.y, pt.x)
-
- def refresh(self):
- self.update()
- curses.panel.update_panels()
- self.move(Point(x=0, y=0))
- return self.window.refresh()
-
- def resize(self, size):
- return self.window.resize(size.h, size.w)
-
- def timeout(self, timeout_msec):
- return self.window.timeout(timeout_msec)
-
- def handle_key(self, key, check_parent=True):
- '''Handle a key press in this window.'''
-
- # First try the first responder if this window has one, but don't allow
- # it to check with its parent (False second parameter) so we don't recurse
- # and get a stack overflow
- for first_responder in reversed(self.first_responders):
- if first_responder.handle_key(key, False):
- return True
-
- # Check our key map to see if we have any actions. Actions don't take
- # any arguments, they must be callable
- if key in self.key_actions:
- key_action = self.key_actions[key]
- key_action['callback']()
- return True
- # Check if there is a wildcard key for any key
- if -1 in self.key_actions:
- key_action = self.key_actions[-1]
- key_action['callback']()
- return True
- # Check if the window delegate wants to handle this key press
- if self.delegate:
- if six.callable(getattr(self.delegate, "handle_key", None)):
- if self.delegate.handle_key(self, key):
- return True
- if self.delegate(self, key):
- return True
- # Check if we have a parent window and if so, let the parent
- # window handle the key press
- if check_parent and self.parent:
- return self.parent.handle_key(key, True)
- else:
- return False # Key not handled
-
- def update(self):
- for child in self.children:
- child.update()
-
- def quit_action(self):
- raise QuitException
-
- def get_key(self, timeout_msec=-1):
- self.timeout(timeout_msec)
- done = False
- c = self.window.getch()
- if c == 27:
- self.timeout(0)
- escape_key = 0
- while True:
- escape_key = self.window.getch()
- if escape_key == -1:
- break
- else:
- c = c << 8 | escape_key
- self.timeout(timeout_msec)
- return c
-
- def key_event_loop(self, timeout_msec=-1, n=sys.maxsize):
- '''Run an event loop to receive key presses and pass them along to the
- responder chain.
-
- timeout_msec is the timeout it milliseconds. If the value is -1, an
- infinite wait will be used. It the value is zero, a non-blocking mode
- will be used, and if greater than zero it will wait for a key press
- for timeout_msec milliseconds.
-
- n is the number of times to go through the event loop before exiting'''
- done = False
- while not done and n > 0:
- c = self.get_key(timeout_msec)
- if c != -1:
- try:
- self.handle_key(c)
- except QuitException:
- done = True
- n -= 1
-
-
-class Panel(Window):
-
- def __init__(self, frame, delegate=None, can_become_first_responder=True):
- window = curses.newwin(
- frame.size.h,
- frame.size.w,
- frame.origin.y,
- frame.origin.x)
- super(
- Panel,
- self).__init__(
- window,
- delegate,
- can_become_first_responder)
- self.panel = curses.panel.new_panel(window)
-
- def hide(self):
- return self.panel.hide()
-
- def hidden(self):
- return self.panel.hidden()
-
- def show(self):
- return self.panel.show()
-
- def top(self):
- return self.panel.top()
-
- def set_position(self, pt):
- self.panel.move(pt.y, pt.x)
-
- def slide_position(self, size):
- new_position = self.get_position()
- new_position.x = new_position.x + size.w
- new_position.y = new_position.y + size.h
- self.set_position(new_position)
-
-
-class BoxedPanel(Panel):
-
- def __init__(self, frame, title, delegate=None,
- can_become_first_responder=True):
- super(
- BoxedPanel,
- self).__init__(
- frame,
- delegate,
- can_become_first_responder)
- self.title = title
- self.lines = list()
- self.first_visible_idx = 0
- self.selected_idx = -1
- self.add_key_action(
- curses.KEY_UP,
- self.select_prev,
- "Select the previous item")
- self.add_key_action(
- curses.KEY_DOWN,
- self.select_next,
- "Select the next item")
- self.add_key_action(
- curses.KEY_HOME,
- self.scroll_begin,
- "Go to the beginning of the list")
- self.add_key_action(
- curses.KEY_END,
- self.scroll_end,
- "Go to the end of the list")
- self.add_key_action(
- 0x1b4f48,
- self.scroll_begin,
- "Go to the beginning of the list")
- self.add_key_action(
- 0x1b4f46,
- self.scroll_end,
- "Go to the end of the list")
- self.add_key_action(
- curses.KEY_PPAGE,
- self.scroll_page_backward,
- "Scroll to previous page")
- self.add_key_action(
- curses.KEY_NPAGE,
- self.scroll_page_forward,
- "Scroll to next forward")
- self.update()
-
- def clear(self, update=True):
- self.lines = list()
- self.first_visible_idx = 0
- self.selected_idx = -1
- if update:
- self.update()
-
- def get_usable_width(self):
- '''Valid usable width is 0 to (width - 3) since the left and right lines display the box around
- this frame and we skip a leading space'''
- w = self.get_size().w
- if w > 3:
- return w - 3
- else:
- return 0
-
- def get_usable_height(self):
- '''Valid line indexes are 0 to (height - 2) since the top and bottom lines display the box around this frame.'''
- h = self.get_size().h
- if h > 2:
- return h - 2
- else:
- return 0
-
- def get_point_for_line(self, global_line_idx):
- '''Returns the point to use when displaying a line whose index is "line_idx"'''
- line_idx = global_line_idx - self.first_visible_idx
- num_lines = self.get_usable_height()
- if line_idx < num_lines:
- return Point(x=2, y=1 + line_idx)
- else:
- # return an invalid coordinate if the line index isn't valid
- return Point(x=-1, y=-1)
-
- def set_title(self, title, update=True):
- self.title = title
- if update:
- self.update()
-
- def scroll_to_line(self, idx):
- if idx < len(self.lines):
- self.selected_idx = idx
- max_visible_lines = self.get_usable_height()
- if idx < self.first_visible_idx or idx >= self.first_visible_idx + max_visible_lines:
- self.first_visible_idx = idx
- self.refresh()
-
- def scroll_begin(self):
- self.first_visible_idx = 0
- if len(self.lines) > 0:
- self.selected_idx = 0
- else:
- self.selected_idx = -1
- self.update()
-
- def scroll_end(self):
- max_visible_lines = self.get_usable_height()
- num_lines = len(self.lines)
- if num_lines > max_visible_lines:
- self.first_visible_idx = num_lines - max_visible_lines
- else:
- self.first_visible_idx = 0
- self.selected_idx = num_lines - 1
- self.update()
-
- def scroll_page_backward(self):
- num_lines = len(self.lines)
- max_visible_lines = self.get_usable_height()
- new_index = self.first_visible_idx - max_visible_lines
- if new_index < 0:
- self.first_visible_idx = 0
- else:
- self.first_visible_idx = new_index
- self.refresh()
-
- def scroll_page_forward(self):
- max_visible_lines = self.get_usable_height()
- self.first_visible_idx += max_visible_lines
- self._adjust_first_visible_line()
- self.refresh()
-
- def select_next(self):
- self.selected_idx += 1
- if self.selected_idx >= len(self.lines):
- self.selected_idx = len(self.lines) - 1
- self.refresh()
-
- def select_prev(self):
- self.selected_idx -= 1
- if self.selected_idx < 0:
- if len(self.lines) > 0:
- self.selected_idx = 0
- else:
- self.selected_idx = -1
- self.refresh()
-
- def get_selected_idx(self):
- return self.selected_idx
-
- def _adjust_first_visible_line(self):
- num_lines = len(self.lines)
- max_visible_lines = self.get_usable_height()
- if (self.first_visible_idx >= num_lines) or (
- num_lines - self.first_visible_idx) > max_visible_lines:
- self.first_visible_idx = num_lines - max_visible_lines
-
- def append_line(self, s, update=True):
- self.lines.append(s)
- self._adjust_first_visible_line()
- if update:
- self.update()
-
- def set_line(self, line_idx, s, update=True):
- '''Sets a line "line_idx" within the boxed panel to be "s"'''
- if line_idx < 0:
- return
- while line_idx >= len(self.lines):
- self.lines.append('')
- self.lines[line_idx] = s
- self._adjust_first_visible_line()
- if update:
- self.update()
-
- def update(self):
- self.erase()
- self.draw_title_box(self.title)
- max_width = self.get_usable_width()
- for line_idx in range(self.first_visible_idx, len(self.lines)):
- pt = self.get_point_for_line(line_idx)
- if pt.is_valid_coordinate():
- is_selected = line_idx == self.selected_idx
- if is_selected:
- self.attron(curses.A_REVERSE)
- self.move(pt)
- self.addnstr(self.lines[line_idx], max_width)
- if is_selected:
- self.attroff(curses.A_REVERSE)
- else:
- return
-
- def load_file(self, path):
- f = open(path)
- if f:
- self.lines = f.read().splitlines()
- for (idx, line) in enumerate(self.lines):
- # Remove any tabs from lines since they hose up the display
- if "\t" in line:
- self.lines[idx] = (8 * ' ').join(line.split('\t'))
- self.selected_idx = 0
- self.first_visible_idx = 0
- self.refresh()
-
-
-class Item(object):
-
- def __init__(self, title, action):
- self.title = title
- self.action = action
-
-
-class TreeItemDelegate(object):
-
- def might_have_children(self):
- return False
-
- def update_children(self, item):
- '''Return a list of child Item objects'''
- return None
-
- def draw_item_string(self, tree_window, item, s):
- pt = tree_window.get_cursor()
- width = tree_window.get_size().w - 1
- if width > pt.x:
- tree_window.addnstr(s, width - pt.x)
-
- def draw_item(self, tree_window, item):
- self.draw_item_string(tree_window, item, item.title)
-
- def do_action(self):
- pass
-
-
-class TreeItem(object):
-
- def __init__(
- self,
- delegate,
- parent=None,
- title=None,
- action=None,
- is_expanded=False):
- self.parent = parent
- self.title = title
- self.action = action
- self.delegate = delegate
- self.is_expanded = not parent or is_expanded
- self._might_have_children = None
- self.children = None
- self._children_might_have_children = False
-
- def get_children(self):
- if self.is_expanded and self.might_have_children():
- if self.children is None:
- self._children_might_have_children = False
- self.children = self.update_children()
- for child in self.children:
- if child.might_have_children():
- self._children_might_have_children = True
- break
- else:
- self._children_might_have_children = False
- self.children = None
- return self.children
-
- def append_visible_items(self, items):
- items.append(self)
- children = self.get_children()
- if children:
- for child in children:
- child.append_visible_items(items)
-
- def might_have_children(self):
- if self._might_have_children is None:
- if not self.parent:
- # Root item always might have children
- self._might_have_children = True
- else:
- # Check with the delegate to see if the item might have
- # children
- self._might_have_children = self.delegate.might_have_children()
- return self._might_have_children
-
- def children_might_have_children(self):
- return self._children_might_have_children
-
- def update_children(self):
- if self.is_expanded and self.might_have_children():
- self.children = self.delegate.update_children(self)
- for child in self.children:
- child.update_children()
- else:
- self.children = None
- return self.children
-
- def get_num_visible_rows(self):
- rows = 1
- if self.is_expanded:
- children = self.get_children()
- if children:
- for child in children:
- rows += child.get_num_visible_rows()
- return rows
-
- def draw(self, tree_window, row):
- display_row = tree_window.get_display_row(row)
- if display_row >= 0:
- tree_window.move(tree_window.get_item_draw_point(row))
- if self.parent:
- self.parent.draw_tree_for_child(tree_window, self, 0)
- if self.might_have_children():
- tree_window.addch(curses.ACS_DIAMOND)
- tree_window.addch(curses.ACS_HLINE)
- elif self.parent and self.parent.children_might_have_children():
- if self.parent.parent:
- tree_window.addch(curses.ACS_HLINE)
- tree_window.addch(curses.ACS_HLINE)
- else:
- tree_window.addch(' ')
- tree_window.addch(' ')
- is_selected = tree_window.is_selected(row)
- if is_selected:
- tree_window.attron(curses.A_REVERSE)
- self.delegate.draw_item(tree_window, self)
- if is_selected:
- tree_window.attroff(curses.A_REVERSE)
-
- def draw_tree_for_child(self, tree_window, child, reverse_depth):
- if self.parent:
- self.parent.draw_tree_for_child(
- tree_window, self, reverse_depth + 1)
- if self.children[-1] == child:
- # Last child
- if reverse_depth == 0:
- tree_window.addch(curses.ACS_LLCORNER)
- tree_window.addch(curses.ACS_HLINE)
- else:
- tree_window.addch(' ')
- tree_window.addch(' ')
- else:
- # Middle child
- if reverse_depth == 0:
- tree_window.addch(curses.ACS_LTEE)
- tree_window.addch(curses.ACS_HLINE)
- else:
- tree_window.addch(curses.ACS_VLINE)
- tree_window.addch(' ')
-
- def was_selected(self):
- self.delegate.do_action()
-
-
-class TreePanel(Panel):
-
- def __init__(self, frame, title, root_item):
- self.root_item = root_item
- self.title = title
- self.first_visible_idx = 0
- self.selected_idx = 0
- self.items = None
- super(TreePanel, self).__init__(frame)
- self.add_key_action(
- curses.KEY_UP,
- self.select_prev,
- "Select the previous item")
- self.add_key_action(
- curses.KEY_DOWN,
- self.select_next,
- "Select the next item")
- self.add_key_action(
- curses.KEY_RIGHT,
- self.right_arrow,
- "Expand an item")
- self.add_key_action(
- curses.KEY_LEFT,
- self.left_arrow,
- "Unexpand an item or navigate to parent")
- self.add_key_action(
- curses.KEY_HOME,
- self.scroll_begin,
- "Go to the beginning of the tree")
- self.add_key_action(
- curses.KEY_END,
- self.scroll_end,
- "Go to the end of the tree")
- self.add_key_action(
- 0x1b4f48,
- self.scroll_begin,
- "Go to the beginning of the tree")
- self.add_key_action(
- 0x1b4f46,
- self.scroll_end,
- "Go to the end of the tree")
- self.add_key_action(
- curses.KEY_PPAGE,
- self.scroll_page_backward,
- "Scroll to previous page")
- self.add_key_action(
- curses.KEY_NPAGE,
- self.scroll_page_forward,
- "Scroll to next forward")
-
- def get_selected_item(self):
- if self.selected_idx < len(self.items):
- return self.items[self.selected_idx]
- else:
- return None
-
- def select_item(self, item):
- if self.items and item in self.items:
- self.selected_idx = self.items.index(item)
- return True
- else:
- return False
-
- def get_visible_items(self):
- # Clear self.items when you want to update all chidren
- if self.items is None:
- self.items = list()
- children = self.root_item.get_children()
- if children:
- for child in children:
- child.append_visible_items(self.items)
- return self.items
-
- def update(self):
- self.erase()
- self.draw_title_box(self.title)
- visible_items = self.get_visible_items()
- for (row, child) in enumerate(visible_items):
- child.draw(self, row)
-
- def get_item_draw_point(self, row):
- display_row = self.get_display_row(row)
- if display_row >= 0:
- return Point(2, display_row + 1)
- else:
- return Point(-1, -1)
-
- def get_display_row(self, row):
- if row >= self.first_visible_idx:
- display_row = row - self.first_visible_idx
- if display_row < self.get_size().h - 2:
- return display_row
- return -1
-
- def is_selected(self, row):
- return row == self.selected_idx
-
- def get_num_lines(self):
- self.get_visible_items()
- return len(self.items)
-
- def get_num_visible_lines(self):
- return self.get_size().h - 2
-
- def select_next(self):
- self.selected_idx += 1
- num_lines = self.get_num_lines()
- if self.selected_idx >= num_lines:
- self.selected_idx = num_lines - 1
- self._selection_changed()
- self.refresh()
-
- def select_prev(self):
- self.selected_idx -= 1
- if self.selected_idx < 0:
- num_lines = self.get_num_lines()
- if num_lines > 0:
- self.selected_idx = 0
- else:
- self.selected_idx = -1
- self._selection_changed()
- self.refresh()
-
- def scroll_begin(self):
- self.first_visible_idx = 0
- num_lines = self.get_num_lines()
- if num_lines > 0:
- self.selected_idx = 0
- else:
- self.selected_idx = -1
- self.refresh()
-
- def redisplay_tree(self):
- self.items = None
- self.refresh()
-
- def right_arrow(self):
- selected_item = self.get_selected_item()
- if selected_item and selected_item.is_expanded == False:
- selected_item.is_expanded = True
- self.redisplay_tree()
-
- def left_arrow(self):
- selected_item = self.get_selected_item()
- if selected_item:
- if selected_item.is_expanded:
- selected_item.is_expanded = False
- self.redisplay_tree()
- elif selected_item.parent:
- if self.select_item(selected_item.parent):
- self.refresh()
-
- def scroll_end(self):
- num_visible_lines = self.get_num_visible_lines()
- num_lines = self.get_num_lines()
- if num_lines > num_visible_lines:
- self.first_visible_idx = num_lines - num_visible_lines
- else:
- self.first_visible_idx = 0
- self.selected_idx = num_lines - 1
- self.refresh()
-
- def scroll_page_backward(self):
- num_visible_lines = self.get_num_visible_lines()
- new_index = self.selected_idx - num_visible_lines
- if new_index < 0:
- self.selected_idx = 0
- else:
- self.selected_idx = new_index
- self._selection_changed()
- self.refresh()
-
- def scroll_page_forward(self):
- num_lines = self.get_num_lines()
- num_visible_lines = self.get_num_visible_lines()
- new_index = self.selected_idx + num_visible_lines
- if new_index >= num_lines:
- new_index = num_lines - 1
- self.selected_idx = new_index
- self._selection_changed()
- self.refresh()
-
- def _selection_changed(self):
- num_lines = self.get_num_lines()
- num_visible_lines = self.get_num_visible_lines()
- last_visible_index = self.first_visible_idx + num_visible_lines
- if self.selected_idx >= last_visible_index:
- self.first_visible_idx += (self.selected_idx -
- last_visible_index + 1)
- if self.selected_idx < self.first_visible_idx:
- self.first_visible_idx = self.selected_idx
- if self.selected_idx >= 0 and self.selected_idx < len(self.items):
- item = self.items[self.selected_idx]
- item.was_selected()
-
-
-class Menu(BoxedPanel):
-
- def __init__(self, title, items):
- max_title_width = 0
- for item in items:
- if max_title_width < len(item.title):
- max_title_width = len(item.title)
- frame = Rect(x=0, y=0, w=max_title_width + 4, h=len(items) + 2)
- super(
- Menu,
- self).__init__(
- frame,
- title=None,
- delegate=None,
- can_become_first_responder=True)
- self.selected_idx = 0
- self.title = title
- self.items = items
- for (item_idx, item) in enumerate(items):
- self.set_line(item_idx, item.title)
- self.hide()
-
- def update(self):
- super(Menu, self).update()
-
- def relinquish_first_responder(self):
- if not self.hidden():
- self.hide()
-
- def perform_action(self):
- selected_idx = self.get_selected_idx()
- if selected_idx < len(self.items):
- action = self.items[selected_idx].action
- if action:
- action()
-
-
-class MenuBar(Panel):
-
- def __init__(self, frame):
- super(MenuBar, self).__init__(frame, can_become_first_responder=True)
- self.menus = list()
- self.selected_menu_idx = -1
- self.add_key_action(
- curses.KEY_LEFT,
- self.select_prev,
- "Select the previous menu")
- self.add_key_action(
- curses.KEY_RIGHT,
- self.select_next,
- "Select the next menu")
- self.add_key_action(
- curses.KEY_DOWN,
- lambda: self.select(0),
- "Select the first menu")
- self.add_key_action(
- 27,
- self.relinquish_first_responder,
- "Hide current menu")
- self.add_key_action(
- curses.KEY_ENTER,
- self.perform_action,
- "Select the next menu item")
- self.add_key_action(
- 10,
- self.perform_action,
- "Select the next menu item")
-
- def insert_menu(self, menu, index=sys.maxsize):
- if index >= len(self.menus):
- self.menus.append(menu)
- else:
- self.menus.insert(index, menu)
- pt = self.get_position()
- for menu in self.menus:
- menu.set_position(pt)
- pt.x += len(menu.title) + 5
-
- def perform_action(self):
- '''If no menu is visible, show the first menu. If a menu is visible, perform the action
- associated with the selected menu item in the menu'''
- menu_visible = False
- for menu in self.menus:
- if not menu.hidden():
- menu_visible = True
- break
- if menu_visible:
- menu.perform_action()
- self.selected_menu_idx = -1
- self._selected_menu_changed()
- else:
- self.select(0)
-
- def relinquish_first_responder(self):
- if self.selected_menu_idx >= 0:
- self.selected_menu_idx = -1
- self._selected_menu_changed()
-
- def _selected_menu_changed(self):
- for (menu_idx, menu) in enumerate(self.menus):
- is_hidden = menu.hidden()
- if menu_idx != self.selected_menu_idx:
- if not is_hidden:
- if self.parent.pop_first_responder(menu) == False:
- menu.hide()
- for (menu_idx, menu) in enumerate(self.menus):
- is_hidden = menu.hidden()
- if menu_idx == self.selected_menu_idx:
- if is_hidden:
- menu.show()
- self.parent.push_first_responder(menu)
- menu.top()
- self.parent.refresh()
-
- def select(self, index):
- if index < len(self.menus):
- self.selected_menu_idx = index
- self._selected_menu_changed()
-
- def select_next(self):
- num_menus = len(self.menus)
- if self.selected_menu_idx == -1:
- if num_menus > 0:
- self.selected_menu_idx = 0
- self._selected_menu_changed()
- else:
- if self.selected_menu_idx + 1 < num_menus:
- self.selected_menu_idx += 1
- else:
- self.selected_menu_idx = -1
- self._selected_menu_changed()
-
- def select_prev(self):
- num_menus = len(self.menus)
- if self.selected_menu_idx == -1:
- if num_menus > 0:
- self.selected_menu_idx = num_menus - 1
- self._selected_menu_changed()
- else:
- if self.selected_menu_idx - 1 >= 0:
- self.selected_menu_idx -= 1
- else:
- self.selected_menu_idx = -1
- self._selected_menu_changed()
-
- def update(self):
- self.erase()
- is_in_first_responder_chain = self.is_in_first_responder_chain()
- if is_in_first_responder_chain:
- self.attron(curses.A_REVERSE)
- pt = Point(x=0, y=0)
- for menu in self.menus:
- self.addstr(pt, '| ' + menu.title + ' ')
- pt.x += len(menu.title) + 5
- self.addstr(pt, '|')
- width = self.get_size().w
- while pt.x < width:
- self.addch_at_point(pt, ' ')
- pt.x += 1
- if is_in_first_responder_chain:
- self.attroff(curses.A_REVERSE)
-
- for menu in self.menus:
- menu.update()
-
-
-class StatusPanel(Panel):
-
- def __init__(self, frame):
- super(
- StatusPanel,
- self).__init__(
- frame,
- delegate=None,
- can_become_first_responder=False)
- self.status_items = list()
- self.status_dicts = dict()
- self.next_status_x = 1
-
- def add_status_item(self, name, title, format, width, value, update=True):
- status_item_dict = {'name': name,
- 'title': title,
- 'width': width,
- 'format': format,
- 'value': value,
- 'x': self.next_status_x}
- index = len(self.status_items)
- self.status_items.append(status_item_dict)
- self.status_dicts[name] = index
- self.next_status_x += width + 2
- if update:
- self.update()
-
- def increment_status(self, name, update=True):
- if name in self.status_dicts:
- status_item_idx = self.status_dicts[name]
- status_item_dict = self.status_items[status_item_idx]
- status_item_dict['value'] = status_item_dict['value'] + 1
- if update:
- self.update()
-
- def update_status(self, name, value, update=True):
- if name in self.status_dicts:
- status_item_idx = self.status_dicts[name]
- status_item_dict = self.status_items[status_item_idx]
- status_item_dict['value'] = status_item_dict['format'] % (value)
- if update:
- self.update()
-
- def update(self):
- self.erase()
- for status_item_dict in self.status_items:
- self.addnstr_at_point(
- Point(
- x=status_item_dict['x'],
- y=0),
- '%s: %s' %
- (status_item_dict['title'],
- status_item_dict['value']),
- status_item_dict['width'])
-
-stdscr = None
-
-
-def intialize_curses():
- global stdscr
- stdscr = curses.initscr()
- curses.noecho()
- curses.cbreak()
- stdscr.keypad(1)
- try:
- curses.start_color()
- except:
- pass
- return Window(stdscr)
-
-
-def terminate_curses():
- global stdscr
- if stdscr:
- stdscr.keypad(0)
- curses.echo()
- curses.nocbreak()
- curses.endwin()
More information about the lldb-commits
mailing list