Index: lldb/packages/Python/lldbsuite/test/lldbcurses.py =================================================================== --- lldb/packages/Python/lldbsuite/test/lldbcurses.py +++ /dev/null @@ -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()