| 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 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.''' |
| 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 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() |
