use kevinbotlib theme

Author: meowmeowahr

pyproject.toml

@@ -25,7 +25,9 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
+  "kevinbotlib==1.0.0a3",
   "pyside6~=6.8.2.1",
+  "qtawesome>=1.3.1",
 ]
 
 [project.urls]
@@ -68,3 +70,6 @@ exclude_lines = [
   "if __name__ == .__main__.:",
   "if TYPE_CHECKING:",
 ]
+
+[tool.ruff.lint]
+ignore = ["G004", "TRY400"]

src/kevinbotlib_dashboard/__main__.py

@@ -5,6 +5,7 @@
 import sys
 
 from kevinbotlib.logger import Level, Logger, LoggerConfiguration
+from kevinbotlib.ui.theme import ThemeStyle, Theme
 from PySide6.QtCore import QCommandLineOption, QCommandLineParser, QCoreApplication
 from PySide6.QtWidgets import QApplication
 
@@ -17,6 +18,8 @@ def run():
     app.setApplicationName("KevinbotLib Dashboard")
     app.setApplicationVersion(__about__.__version__)
 
+    Theme(ThemeStyle.System).apply(app)
+    
     parser = QCommandLineParser()
     parser.addHelpOption()
     parser.addVersionOption()

src/kevinbotlib_dashboard/app.py

@@ -2,8 +2,24 @@
 from collections.abc import Callable
 from typing import override
 
-
-from PySide6.QtCore import QObject, QPointF, QRect, QRectF, QRegularExpression, QSettings, QSize, Qt, QTimer, Signal, Slot, QModelIndex
+from kevinbotlib.comm import KevinbotCommClient
+from kevinbotlib.logger import Logger
+from kevinbotlib.ui.theme import Theme, ThemeStyle
+
+from PySide6.QtCore import (
+    QModelIndex,
+    QObject,
+    QPointF,
+    QRect,
+    QRectF,
+    QRegularExpression,
+    QSettings,
+    QSize,
+    Qt,
+    QTimer,
+    Signal,
+    Slot,
+)
 from PySide6.QtGui import QAction, QBrush, QCloseEvent, QColor, QPainter, QPen, QRegularExpressionValidator
 from PySide6.QtWidgets import (
     QDialog,
@@ -20,15 +36,13 @@
     QPushButton,
     QSpinBox,
     QStyleOptionGraphicsItem,
+    QTreeView,
     QVBoxLayout,
     QWidget,
-    QTreeView,
 )
 
-from kevinbotlib.comm import KevinbotCommClient
-from kevinbotlib.logger import Logger
-
 from kevinbotlib_dashboard.grid_theme import Themes
+from kevinbotlib_dashboard.toast import Notifier, Severity
 from kevinbotlib_dashboard.tree import DictTreeModel
 from kevinbotlib_dashboard.widgets import Divider
 
@@ -478,12 +492,20 @@ def __init__(self):
         )
         self.client.connect()
 
+        self.notifier = Notifier(self)
+
         self.menu = self.menuBar()
         self.menu.setNativeMenuBar(False)
 
+        self.file_menu = self.menu.addMenu("&File")
+
+        self.save_action = self.file_menu.addAction("Save Layout", self.save_slot)
+        self.save_action.setShortcut("Ctrl+S")
+
         self.edit_menu = self.menu.addMenu("&Edit")
 
         self.settings_action = self.edit_menu.addAction("Settings", self.open_settings)
+        self.settings_action.setShortcut("Ctrl+,")
 
         self.status = self.statusBar()
 
@@ -534,13 +556,16 @@ def update_latency(self):
             self.latency_status.setText(f"Latency: {self.client.websocket.latency:.2f}ms")
 
     @Slot()
-    def update_tree(self, *args):
+    def update_tree(self):
         # 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 not value:
+                continue
+
             if "struct" in value and "dashboard" in value["struct"]:
                 structured = {}
                 for viewable in value["struct"]["dashboard"]:
@@ -565,13 +590,12 @@ def update_tree(self, *args):
                 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('/')
+                parts = key.split("/")
                 d = hierarchical_dict
                 for part in parts[:-1]:
                     d = d.setdefault(part, {})
@@ -581,21 +605,19 @@ def to_hierarchical_dict(flat_dict: dict):
         # Convert flat dictionary to hierarchical
 
         expanded_indexes = []
-        def store_expansion(parent=QModelIndex()):
+
+        def store_expansion(parent):
             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
-                    ))
+                    expanded_indexes.append((self.get_index_path(index), True))
                 store_expansion(index)
-        store_expansion()
-        
+
+        store_expansion(QModelIndex())
+
         # Store selection
         selected_paths = self.get_selection_paths()
 
-
         # Update data...
         h = to_hierarchical_dict(data)
         self.model.update_data(h)
@@ -606,17 +628,16 @@ def restore_expansion():
                 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
+        return [
+            self.get_index_path(index) for index in self.tree.selectionModel().selectedIndexes() if index.column() == 0
+        ]
 
     def restore_selection(self, paths):
         selection_model = self.tree.selectionModel()
@@ -638,7 +659,7 @@ def get_index_from_path(self, path):
         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()
@@ -698,6 +719,7 @@ def closeEvent(self, event: QCloseEvent):
 
     def save_slot(self):
         self.settings.setValue("layout", self.controller.get_widgets())
+        self.notifier.toast("Layout Saved", "Layout saved successfully", severity=Severity.Success)
 
     def open_settings(self):
         self.settings_window.show()

src/kevinbotlib_dashboard/toast.py

@@ -0,0 +1,150 @@
+from dataclasses import dataclass
+from enum import Enum
+
+import qtawesome as qta
+from PySide6.QtCore import QObject, QTimer, Signal
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import QGraphicsOpacityEffect, QHBoxLayout, QLabel, QMainWindow, QVBoxLayout, QWidget
+
+
+@dataclass
+class CustomSeverity:
+    icon: str
+    color: QColor
+
+
+class Severity(Enum):
+    Success = CustomSeverity("mdi6.check-bold", QColor("#31C376"))
+    Info = CustomSeverity("mdi6.information-outline", QColor("#005C9F"))
+    Warning = CustomSeverity("mdi6.alert", QColor("#FF9800"))
+    Error = CustomSeverity("mdi6.alert-circle", QColor("#F44336"))
+    Critical = CustomSeverity("mdi6.alert-octagon", QColor("#9C27B0"))
+
+
+class NotificationWidget(QWidget):
+    closed = Signal()
+
+    def __init__(self, title: str, text: str, severity: CustomSeverity, duration: int, parent=None):
+        super().__init__(parent)
+        self.duration = duration
+        self.setup_ui(title, text, severity)
+        self.setup_animations()
+        self.setAutoFillBackground(True)
+
+    def setup_ui(self, title: str, text: str, severity: CustomSeverity):
+        # Main layout
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        # Create content widget with background
+        self.content = QWidget()
+        self.content.setObjectName("notification")
+        content_layout = QHBoxLayout(self.content)
+
+        # Icon
+        icon_label = qta.IconWidget()
+        icon_label.setIconSize(38)
+        icon_label.setIcon(qta.icon(severity.icon, color=severity.color.name()))
+        content_layout.addWidget(icon_label)
+
+        # Text content
+        text_layout = QVBoxLayout()
+        title_label = QLabel(title)
+        title_label.setStyleSheet(f"font-weight: bold; color: {severity.color.name()}")
+        text_layout.addWidget(title_label)
+
+        message_label = QLabel(text)
+        message_label.setWordWrap(True)
+        text_layout.addWidget(message_label)
+
+        content_layout.addLayout(text_layout, 3)
+        layout.addWidget(self.content)
+
+        # Style
+        self.content.setStyleSheet(f"""
+            QWidget#notification {{
+                border: 2px solid {severity.color.name()};
+                border-radius: 4px;
+                padding: 8px;
+            }}
+        """)
+
+        # Set fixed width but dynamic height
+        self.setFixedWidth(300)
+        self.adjustSize()
+
+    def setup_animations(self):
+        # Opacity effect for fade animations
+        self.opacity_effect = QGraphicsOpacityEffect(self)
+        self.opacity_effect.setOpacity(0)
+        self.setGraphicsEffect(self.opacity_effect)
+
+        # Fade in
+        self.fade_in_timer = QTimer(self)
+        self.fade_in_timer.timeout.connect(self._fade_in)
+        self.fade_in_timer.start(10)
+
+        # Display duration
+        QTimer.singleShot(self.duration, self.start_fade_out)
+
+        self.current_opacity = 0
+
+    def _fade_in(self):
+        self.current_opacity += 0.1
+        if self.current_opacity >= 1:
+            self.fade_in_timer.stop()
+            self.current_opacity = 1
+        self.opacity_effect.setOpacity(self.current_opacity)
+
+    def start_fade_out(self):
+        self.fade_out_timer = QTimer(self)
+        self.fade_out_timer.timeout.connect(self._fade_out)
+        self.fade_out_timer.start(10)
+
+    def _fade_out(self):
+        self.current_opacity -= 0.1
+        if self.current_opacity <= 0:
+            self.fade_out_timer.stop()
+            self.close()
+            self.closed.emit()
+        self.opacity_effect.setOpacity(self.current_opacity)
+
+
+class Notifier(QObject):
+    def __init__(self, parent: QMainWindow):
+        super().__init__(parent)
+        self.notifications = []
+        self.margin = 10
+        self.parent_window = parent
+
+    def toast(self, title: str, text: str, duration: int = 2500, severity: Severity | CustomSeverity = Severity.Info):
+        if isinstance(severity, Severity):
+            severity = severity.value
+
+        notification = NotificationWidget(title, text, severity, duration, self.parent())
+        notification.closed.connect(lambda: self._remove_notification(notification))
+
+        # Calculate position
+        self._update_positions(notification)
+        notification.show()
+        self.notifications.append(notification)
+
+    def _update_positions(self, new_notification=None):
+        screen_geometry = self.parent_window.geometry()
+        base_x = screen_geometry.width() - 300 - self.margin  # 300 is notification width
+        current_y = screen_geometry.height() - self.margin - self.parent_window.statusBar().height()
+
+        # Position existing notifications
+        for notification in reversed(self.notifications):
+            current_y -= notification.height() + self.margin
+            notification.move(base_x, current_y)
+
+        # Position new notification if provided
+        if new_notification:
+            current_y -= new_notification.height() + self.margin
+            new_notification.move(base_x, current_y)
+
+    def _remove_notification(self, notification):
+        if notification in self.notifications:
+            self.notifications.remove(notification)
+            self._update_positions()  # Reposition remaining notifications