diff options
Diffstat (limited to 'packages/Python/lldbsuite/test/lldbcurses.py')
| -rw-r--r-- | packages/Python/lldbsuite/test/lldbcurses.py | 1143 |
1 files changed, 1143 insertions, 0 deletions
diff --git a/packages/Python/lldbsuite/test/lldbcurses.py b/packages/Python/lldbsuite/test/lldbcurses.py new file mode 100644 index 000000000000..bc1fbf00d372 --- /dev/null +++ b/packages/Python/lldbsuite/test/lldbcurses.py @@ -0,0 +1,1143 @@ +from __future__ import absolute_import + +# System modules +import curses +import curses.panel +import sys +import time + +# 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 not window 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.''' + pass + + # 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 Point(x=-1, y=-1) # return an invalid coordinate if the line index isn't valid + + 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 == True + 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 == True: + 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() + |