semi-working tree view

Author: meowmeowahr

pyproject.toml

@@ -26,7 +26,6 @@ classifiers = [
 ]
 dependencies = [
   "pyside6~=6.8.2.1",
-  "kevinbotlib==1.0.0a2"
 ]
 
 [project.urls]

src/kevinbotlib_dashboard/app.py

@@ -2,8 +2,8 @@
 from collections.abc import Callable
 from typing import override
 
-from kevinbotlib.comm import KevinbotCommClient
-from PySide6.QtCore import QObject, QPointF, QRect, QRectF, QRegularExpression, QSettings, QSize, Qt, QTimer, Signal
+
+from PySide6.QtCore import QObject, QPointF, QRect, QRectF, QRegularExpression, QSettings, QSize, Qt, QTimer, Signal, Slot, QModelIndex
 from PySide6.QtGui import QAction, QBrush, QCloseEvent, QColor, QPainter, QPen, QRegularExpressionValidator
 from PySide6.QtWidgets import (
     QDialog,
@@ -22,9 +22,14 @@
     QStyleOptionGraphicsItem,
     QVBoxLayout,
     QWidget,
+    QTreeView,
 )
 
+from kevinbotlib.comm import KevinbotCommClient
+from kevinbotlib.logger import Logger
+
 from kevinbotlib_dashboard.grid_theme import Themes
+from kevinbotlib_dashboard.tree import DictTreeModel
 from kevinbotlib_dashboard.widgets import Divider
 
 
@@ -389,18 +394,16 @@ def __init__(self, graphics_view, parent=None):
         super().__init__(parent)
         self.graphics_view = graphics_view
         self.controller = WidgetGridController(self.graphics_view)
-        self.setup_ui()
 
-    def setup_ui(self):
         layout = QVBoxLayout(self)
         layout.setSpacing(10)
 
-        widgets = ["A", "B", "C", "D", "E"]
-        for widget_name in widgets:
-            button = QPushButton(widget_name)
-            button.clicked.connect(lambda _, name=widget_name: self.add_widget(name))
-            layout.addWidget(button)
-        layout.addStretch()
+        self.tree = QTreeView()
+        self.tree.setHeaderHidden(True)
+        layout.addWidget(self.tree)
+
+        self.model = DictTreeModel({})
+        self.tree.setModel(self.model)
 
     def add_widget(self, widget_name):
         self.controller.add(WidgetItem(widget_name, self.graphics_view))
@@ -465,6 +468,8 @@ def __init__(self):
 
         self.settings = QSettings("kevinbotlib", "dashboard")
 
+        self.logger = Logger()
+
         self.client = KevinbotCommClient(
             host=self.settings.value("ip", "10.0.0.2", str),  # type: ignore
             port=self.settings.value("port", 8765, int),  # type: ignore
@@ -502,6 +507,8 @@ def __init__(self):
             cols=self.settings.value("cols", 10, int),  # type: ignore
         )
         palette = WidgetPalette(self.graphics_view)
+        self.model = palette.model
+        self.tree = palette.tree
 
         layout.addWidget(self.graphics_view)
         layout.addWidget(palette)
@@ -511,6 +518,11 @@ def __init__(self):
         self.latency_timer.timeout.connect(self.update_latency)
         self.latency_timer.start()
 
+        self.update_timer = QTimer()
+        self.update_timer.setInterval(100)
+        self.update_timer.timeout.connect(self.update_tree)
+        self.update_timer.start()
+
         self.controller = WidgetGridController(self.graphics_view)
         self.controller.load(self.item_loader, self.settings.value("layout", [], type=list))  # type: ignore
 
@@ -521,8 +533,115 @@ def update_latency(self):
         if self.client.websocket:
             self.latency_status.setText(f"Latency: {self.client.websocket.latency:.2f}ms")
 
+    @Slot()
+    def update_tree(self, *args):
+        # Get the latest data
+        data_store = self.client.get_keys()
+        data = {}
+
+        # here we process what data can be displayed
+        for key, value in [(key, self.client.get_raw(key)) for key in data_store]:
+            if "struct" in value and "dashboard" in value["struct"]:
+                structured = {}
+                for viewable in value["struct"]["dashboard"]:
+                    display = ""
+                    if "element" in viewable:
+                        raw = value[viewable["element"]]
+                        if "format" in viewable:
+                            fmt = viewable["format"]
+                            if fmt == "percent":
+                                display = f"{raw * 100:.2f}%"
+                            elif fmt == "degrees":
+                                display = f"{raw}°"
+                            elif fmt == "radians":
+                                display = f"{raw} rad"
+                            elif fmt.startswith("limit:"):
+                                limit = int(fmt.split(":")[1])
+                                display = raw[:limit]
+                            else:
+                                display = raw
+
+                    structured[viewable["element"]] = display
+                data[key] = structured
+            else:
+                self.logger.error(f"Could not display {key}, it dosen't contain a structure")
+            
+
+        def to_hierarchical_dict(flat_dict: dict):
+            """Convert a flat dictionary into a hierarchical one based on '/'."""
+            hierarchical_dict = {}
+            for key, value in flat_dict.items():
+                parts = key.split('/')
+                d = hierarchical_dict
+                for part in parts[:-1]:
+                    d = d.setdefault(part, {})
+                d[parts[-1]] = {"items": value, "key": key}
+            return hierarchical_dict
+
+        # Convert flat dictionary to hierarchical
+
+        expanded_indexes = []
+        def store_expansion(parent=QModelIndex()):
+            for row in range(self.model.rowCount(parent)):
+                index = self.model.index(row, 0, parent)
+                if self.tree.isExpanded(index):
+                    expanded_indexes.append((
+                    self.get_index_path(index),
+                    True
+                    ))
+                store_expansion(index)
+        store_expansion()
+        
+        # Store selection
+        selected_paths = self.get_selection_paths()
+
+
+        # Update data...
+        h = to_hierarchical_dict(data)
+        self.model.update_data(h)
+
+        # Restore states
+        def restore_expansion():
+            for path, was_expanded in expanded_indexes:
+                index = self.get_index_from_path(path)
+                if index.isValid() and was_expanded:
+                    self.tree.setExpanded(index, True)
+        restore_expansion()
+        
+        # Restore selection
+        self.restore_selection(selected_paths)
+
+    def get_selection_paths(self):
+        paths = []
+        for index in self.tree.selectionModel().selectedIndexes():
+            if index.column() == 0:  # Only store for first column
+                paths.append(self.get_index_path(index))
+        return paths
+
+    def restore_selection(self, paths):
+        selection_model = self.tree.selectionModel()
+        selection_model.clear()
+        for path in paths:
+            index = self.get_index_from_path(path)
+            if index.isValid():
+                selection_model.select(index, selection_model.SelectionFlag.Select | selection_model.SelectionFlag.Rows)
+
+    def get_index_path(self, index):
+        path = []
+        while index.isValid():
+            path.append(index.row())
+            index = self.model.parent(index)
+        return tuple(reversed(path))
+
+    def get_index_from_path(self, path):
+        index = QModelIndex()
+        for row in path:
+            index = self.model.index(row, 0, index)
+        return index
+        
     def on_connect(self):
         self.connection_status.setText("Robot Connected")
+        self.update_tree()
 
     def on_disconnect(self):
         self.connection_status.setText("Robot Disconnected")

src/kevinbotlib_dashboard/tree.py

@@ -0,0 +1,106 @@
+from PySide6.QtCore import Qt, QAbstractItemModel, QModelIndex, QPersistentModelIndex
+from typing import Any, Dict, List
+
+class TreeItem:
+    def __init__(self, data: Any, key: str = "", parent: 'TreeItem | None' = None):
+        self.data = data
+        self.key = key
+        self.parent_item = parent
+        
+        self.child_items: List[TreeItem] = []
+        if isinstance(data, dict):
+            for k, v in data.items():
+                self.child_items.append(TreeItem(v, k, self))
+        self.userdata = None
+        
+        if len(self.child_items) > 0:
+            for child in self.child_items:
+                if child.key == "key":
+                    self.userdata = child.data
+                    print(self.key, self.userdata)
+                    self.child_items.clear() # This is the sendable, dont show any more data
+        
+    def child(self, row: int) -> 'TreeItem':
+        if 0 <= row < len(self.child_items):
+            return self.child_items[row]
+        return None
+    
+    def childCount(self) -> int:
+        return len(self.child_items)
+    
+    def row(self) -> int:
+        if self.parent_item:
+            return self.parent_item.child_items.index(self)
+        return 0
+    
+    def parent(self) -> 'TreeItem':
+        return self.parent_item
+
+class DictTreeModel(QAbstractItemModel):
+    def __init__(self, data: Dict):
+        super().__init__()
+        self.root_item = TreeItem(data)
+    
+    def index(self, row: int, column: int, parent: QModelIndex = QModelIndex()) -> QModelIndex:
+        if not self.hasIndex(row, column, parent):
+            return QModelIndex()
+        
+        if not parent.isValid():
+            parent_item = self.root_item
+        else:
+            parent_item = parent.internalPointer()
+        
+        child_item = parent_item.child(row)
+        if child_item:
+            return self.createIndex(row, column, child_item)
+        return QModelIndex()
+    
+    def parent(self, index: QModelIndex) -> QModelIndex:
+        if not index.isValid():
+            return QModelIndex()
+        
+        child_item = index.internalPointer()
+        parent_item = child_item.parent()
+        
+        if parent_item == self.root_item:
+            return QModelIndex()
+        
+        return self.createIndex(parent_item.row(), 0, parent_item)
+    
+    def rowCount(self, parent: QModelIndex = QModelIndex()) -> int:
+        if parent.column() > 0:
+            return 0
+        
+        if not parent.isValid():
+            parent_item = self.root_item
+        else:
+            parent_item = parent.internalPointer()
+        
+        return parent_item.childCount()
+    
+    def columnCount(self, /, parent: QModelIndex | QPersistentModelIndex = QModelIndex()) -> int:
+        return 1
+    
+    def data(self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole) -> Any:
+        if not index.isValid():
+            return None
+        
+        item = index.internalPointer()
+        
+        if role == Qt.ItemDataRole.DisplayRole:
+            if isinstance(item.data, dict):
+                # Show userdata alongside the key if it exists
+                if item.userdata is not None:
+                    return f"{item.key} [{item.userdata}]"
+                return f"{item.key}"
+            else:
+                return f"{item.key}: {item.data}"
+        elif role == Qt.ItemDataRole.UserRole:
+            return item.userdata
+            
+        return None
+    
+    def update_data(self, new_data: Dict):
+        self.beginResetModel()
+        self.root_item = TreeItem(new_data)
+        self.endResetModel()