| from __future__ import annotations |
|
|
|
|
| from typing import ClassVar, Generic, Iterator, NewType, TypeVar |
|
|
| import rich.repr |
| from rich.console import RenderableType |
| from rich.style import Style, NULL_STYLE |
| from rich.text import Text, TextType |
| from rich.tree import Tree |
|
|
| from ..geometry import Region, Size |
| from .. import events |
| from ..reactive import Reactive |
| from .._types import MessageTarget |
| from ..widgets import Static |
| from ..message import Message |
| from .. import messages |
|
|
|
|
| NodeID = NewType("NodeID", int) |
|
|
|
|
| NodeDataType = TypeVar("NodeDataType") |
| EventNodeDataType = TypeVar("EventNodeDataType") |
|
|
|
|
| @rich.repr.auto |
| class TreeNode(Generic[NodeDataType]): |
| def __init__( |
| self, |
| parent: TreeNode[NodeDataType] | None, |
| node_id: NodeID, |
| control: TreeControl, |
| tree: Tree, |
| label: TextType, |
| data: NodeDataType, |
| ) -> None: |
| self.parent = parent |
| self.id = node_id |
| self._control = control |
| self._tree = tree |
| self.label = label |
| self.data = data |
| self.loaded = False |
| self._expanded = False |
| self._empty = False |
| self._tree.expanded = False |
| self.children: list[TreeNode] = [] |
|
|
| def __rich_repr__(self) -> rich.repr.Result: |
| yield "id", self.id |
| yield "label", self.label |
| yield "data", self.data |
|
|
| @property |
| def control(self) -> TreeControl: |
| return self._control |
|
|
| @property |
| def empty(self) -> bool: |
| return self._empty |
|
|
| @property |
| def expanded(self) -> bool: |
| return self._expanded |
|
|
| @property |
| def is_cursor(self) -> bool: |
| return self.control.cursor == self.id and self.control.show_cursor |
|
|
| @property |
| def tree(self) -> Tree: |
| return self._tree |
|
|
| @property |
| def next_node(self) -> TreeNode[NodeDataType] | None: |
| """The next node in the tree, or None if at the end.""" |
|
|
| if self.expanded and self.children: |
| return self.children[0] |
| else: |
|
|
| sibling = self.next_sibling |
| if sibling is not None: |
| return sibling |
|
|
| node = self |
| while True: |
| if node.parent is None: |
| return None |
| sibling = node.parent.next_sibling |
| if sibling is not None: |
| return sibling |
| else: |
| node = node.parent |
|
|
| @property |
| def previous_node(self) -> TreeNode[NodeDataType] | None: |
| """The previous node in the tree, or None if at the end.""" |
|
|
| sibling = self.previous_sibling |
| if sibling is not None: |
|
|
| def last_sibling(node) -> TreeNode[NodeDataType]: |
| if node.expanded and node.children: |
| return last_sibling(node.children[-1]) |
| else: |
| return ( |
| node.children[-1] if (node.children and node.expanded) else node |
| ) |
|
|
| return last_sibling(sibling) |
|
|
| if self.parent is None: |
| return None |
| return self.parent |
|
|
| @property |
| def next_sibling(self) -> TreeNode[NodeDataType] | None: |
| """The next sibling, or None if last sibling.""" |
| if self.parent is None: |
| return None |
| iter_siblings = iter(self.parent.children) |
| try: |
| for node in iter_siblings: |
| if node is self: |
| return next(iter_siblings) |
| except StopIteration: |
| pass |
| return None |
|
|
| @property |
| def previous_sibling(self) -> TreeNode[NodeDataType] | None: |
| """Previous sibling or None if first sibling.""" |
| if self.parent is None: |
| return None |
| iter_siblings = iter(self.parent.children) |
| sibling: TreeNode[NodeDataType] | None = None |
|
|
| for node in iter_siblings: |
| if node is self: |
| return sibling |
| sibling = node |
| return None |
|
|
| def expand(self, expanded: bool = True) -> None: |
| self._expanded = expanded |
| self._tree.expanded = expanded |
| self._control.refresh(layout=True) |
|
|
| def toggle(self) -> None: |
| self.expand(not self._expanded) |
|
|
| def add(self, label: TextType, data: NodeDataType) -> None: |
| self._control.add(self.id, label, data=data) |
| self._control.refresh(layout=True) |
| self._empty = False |
|
|
| def __rich__(self) -> RenderableType: |
| return self._control.render_node(self) |
|
|
|
|
| class TreeControl(Generic[NodeDataType], Static, can_focus=True): |
| DEFAULT_CSS = """ |
| TreeControl { |
| color: $text; |
| height: auto; |
| width: 100%; |
| link-style: not underline; |
| } |
| |
| TreeControl > .tree--guides { |
| color: $success; |
| } |
| |
| TreeControl > .tree--guides-highlight { |
| color: $success; |
| text-style: uu; |
| } |
| |
| TreeControl > .tree--guides-cursor { |
| color: $secondary; |
| text-style: bold; |
| } |
| |
| TreeControl > .tree--labels { |
| color: $text; |
| } |
| |
| TreeControl > .tree--cursor { |
| background: $secondary; |
| color: $text; |
| } |
| |
| """ |
|
|
| COMPONENT_CLASSES: ClassVar[set[str]] = { |
| "tree--guides", |
| "tree--guides-highlight", |
| "tree--guides-cursor", |
| "tree--labels", |
| "tree--cursor", |
| } |
|
|
| class NodeSelected(Generic[EventNodeDataType], Message, bubble=False): |
| def __init__( |
| self, sender: MessageTarget, node: TreeNode[EventNodeDataType] |
| ) -> None: |
| self.node = node |
| super().__init__(sender) |
|
|
| def __init__( |
| self, |
| label: TextType, |
| data: NodeDataType, |
| *, |
| name: str | None = None, |
| id: str | None = None, |
| classes: str | None = None, |
| ) -> None: |
| super().__init__(name=name, id=id, classes=classes) |
| self.data = data |
|
|
| self.node_id = NodeID(0) |
| self.nodes: dict[NodeID, TreeNode[NodeDataType]] = {} |
| self._tree = Tree(label) |
|
|
| self.root: TreeNode[NodeDataType] = TreeNode( |
| None, self.node_id, self, self._tree, label, data |
| ) |
|
|
| self._tree.label = self.root |
| self.nodes[NodeID(self.node_id)] = self.root |
|
|
| self.auto_links = False |
|
|
| hover_node: Reactive[NodeID | None] = Reactive(None) |
| cursor: Reactive[NodeID] = Reactive(NodeID(0)) |
| cursor_line: Reactive[int] = Reactive(0) |
| show_cursor: Reactive[bool] = Reactive(False) |
|
|
| def watch_cursor_line(self, value: int) -> None: |
| line_region = Region(0, value, self.size.width, 1) |
| self.emit_no_wait(messages.ScrollToRegion(self, line_region)) |
|
|
| def get_content_height(self, container: Size, viewport: Size, width: int) -> int: |
| def get_size(tree: Tree) -> int: |
| return 1 + sum( |
| get_size(child) if child.expanded else 1 for child in tree.children |
| ) |
|
|
| size = get_size(self._tree) |
| return size |
|
|
| def add( |
| self, |
| node_id: NodeID, |
| label: TextType, |
| data: NodeDataType, |
| ) -> None: |
|
|
| parent = self.nodes[node_id] |
| self.node_id = NodeID(self.node_id + 1) |
| child_tree = parent._tree.add(label) |
| child_tree.guide_style = self._guide_style |
| child_node: TreeNode[NodeDataType] = TreeNode( |
| parent, self.node_id, self, child_tree, label, data |
| ) |
| parent.children.append(child_node) |
| child_tree.label = child_node |
| self.nodes[self.node_id] = child_node |
|
|
| self.refresh(layout=True) |
|
|
| def find_cursor(self) -> int | None: |
| """Find the line location for the cursor node.""" |
|
|
| node_id = self.cursor |
| line = 0 |
|
|
| stack: list[Iterator[TreeNode[NodeDataType]]] |
| stack = [iter([self.root])] |
|
|
| pop = stack.pop |
| push = stack.append |
| while stack: |
| iter_children = pop() |
| try: |
| node = next(iter_children) |
| except StopIteration: |
| continue |
| else: |
| if node.id == node_id: |
| return line |
| line += 1 |
| push(iter_children) |
| if node.children and node.expanded: |
| push(iter(node.children)) |
| return None |
|
|
| def render(self) -> RenderableType: |
| guide_style = self._guide_style |
|
|
| def update_guide_style(tree: Tree) -> None: |
| tree.guide_style = guide_style |
| for child in tree.children: |
| if child.expanded: |
| update_guide_style(child) |
|
|
| update_guide_style(self._tree) |
| if self.hover_node is not None: |
| hover = self.nodes.get(self.hover_node) |
| if hover is not None: |
| hover._tree.guide_style = self._highlight_guide_style |
| if self.cursor is not None and self.show_cursor: |
| cursor = self.nodes.get(self.cursor) |
| if cursor is not None: |
| cursor._tree.guide_style = self._cursor_guide_style |
| return self._tree |
|
|
| def render_node(self, node: TreeNode[NodeDataType]) -> RenderableType: |
| label_style = self.get_component_styles("tree--labels").rich_style |
| label = ( |
| Text(node.label, no_wrap=True, style=label_style, overflow="ellipsis") |
| if isinstance(node.label, str) |
| else node.label |
| ) |
| if node.id == self.hover_node: |
| label.stylize("underline") |
| label.apply_meta({"@click": f"click_label({node.id})", "tree_node": node.id}) |
| return label |
|
|
| def action_click_label(self, node_id: NodeID) -> None: |
| node = self.nodes[node_id] |
| self.cursor = node.id |
| self.cursor_line = self.find_cursor() or 0 |
| self.show_cursor = True |
| self.post_message_no_wait(self.NodeSelected(self, node)) |
|
|
| def on_mount(self) -> None: |
| self._tree.guide_style = self._guide_style |
|
|
| @property |
| def _guide_style(self) -> Style: |
| return self.get_component_rich_style("tree--guides") |
|
|
| @property |
| def _highlight_guide_style(self) -> Style: |
| return self.get_component_rich_style("tree--guides-highlight") |
|
|
| @property |
| def _cursor_guide_style(self) -> Style: |
| return self.get_component_rich_style("tree--guides-cursor") |
|
|
| def on_mouse_move(self, event: events.MouseMove) -> None: |
| self.hover_node = event.style.meta.get("tree_node") |
|
|
| def key_down(self, event: events.Key) -> None: |
| event.stop() |
| self.cursor_down() |
|
|
| def key_up(self, event: events.Key) -> None: |
| event.stop() |
| self.cursor_up() |
|
|
| def key_pagedown(self) -> None: |
| assert self.parent is not None |
| height = self.container_viewport.height |
|
|
| cursor = self.cursor |
| cursor_line = self.cursor_line |
| for _ in range(height): |
| cursor_node = self.nodes[cursor] |
| next_node = cursor_node.next_node |
| if next_node is not None: |
| cursor_line += 1 |
| cursor = next_node.id |
| self.cursor = cursor |
| self.cursor_line = cursor_line |
|
|
| def key_pageup(self) -> None: |
| assert self.parent is not None |
| height = self.container_viewport.height |
| cursor = self.cursor |
| cursor_line = self.cursor_line |
| for _ in range(height): |
| cursor_node = self.nodes[cursor] |
| previous_node = cursor_node.previous_node |
| if previous_node is not None: |
| cursor_line -= 1 |
| cursor = previous_node.id |
| self.cursor = cursor |
| self.cursor_line = cursor_line |
|
|
| def key_home(self) -> None: |
| self.cursor_line = 0 |
| self.cursor = NodeID(0) |
|
|
| def key_end(self) -> None: |
| self.cursor = self.nodes[NodeID(0)].children[-1].id |
| self.cursor_line = self.find_cursor() or 0 |
|
|
| def key_enter(self, event: events.Key) -> None: |
| cursor_node = self.nodes[self.cursor] |
| event.stop() |
| self.post_message_no_wait(self.NodeSelected(self, cursor_node)) |
|
|
| def cursor_down(self) -> None: |
| if not self.show_cursor: |
| self.show_cursor = True |
| return |
| cursor_node = self.nodes[self.cursor] |
| next_node = cursor_node.next_node |
| if next_node is not None: |
| self.cursor_line += 1 |
| self.cursor = next_node.id |
|
|
| def cursor_up(self) -> None: |
| if not self.show_cursor: |
| self.show_cursor = True |
| return |
| cursor_node = self.nodes[self.cursor] |
| previous_node = cursor_node.previous_node |
| if previous_node is not None: |
| self.cursor_line -= 1 |
| self.cursor = previous_node.id |
|
|
