Python-FastUI-Widgets 1.0.0__py3-none-any.whl

fastuiwidgets/components/navigation/navigation_panel.py

@@ -0,0 +1,657 @@
+# coding:utf-8
+from enum import Enum
+from typing import Dict, Union
+
+from PySide6.QtCore import Qt, QPropertyAnimation, QRect, QSize, QEvent, QEasingCurve, Signal, QPoint
+from PySide6.QtGui import QResizeEvent, QIcon, QColor, QPainterPath
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QFrame, QApplication, QHBoxLayout
+
+from .navigation_widget import (NavigationTreeWidgetBase, NavigationToolButton, NavigationWidget, NavigationSeparator,
+                                NavigationTreeWidget, NavigationFlyoutMenu)
+from ..widgets.acrylic_label import AcrylicBrush
+from ..widgets.scroll_area import ScrollArea
+from ..widgets.tool_tip import ToolTipFilter
+from ..widgets.flyout import Flyout, FlyoutAnimationType, FlyoutViewBase, SlideRightFlyoutAnimationManager
+from ..material.acrylic_flyout import AcrylicFlyout, AcrylicFlyoutViewBase
+from ...common.router import qrouter
+from ...common.style_sheet import FluentStyleSheet, isDarkTheme
+from ...common.icon import FluentIconBase
+from ...common.icon import FluentIcon as FIF
+
+
+class NavigationDisplayMode(Enum):
+    """ Navigation display mode """
+    MINIMAL = 0
+    COMPACT = 1
+    EXPAND = 2
+    MENU = 3
+
+
+class NavigationItemPosition(Enum):
+    """ Navigation item position """
+    TOP = 0
+    SCROLL = 1
+    BOTTOM = 2
+
+
+class NavigationToolTipFilter(ToolTipFilter):
+    """ Navigation tool tip filter """
+
+    def _canShowToolTip(self) -> bool:
+        isVisible = super()._canShowToolTip()
+        parent = self.parent()  # type: NavigationWidget
+        return isVisible and parent.isCompacted
+
+
+class RouteKeyError(Exception):
+    """ Route key error """
+
+
+class NavigationItem:
+    """ Navigation item """
+
+    def __init__(self, routeKey: str, parentRouteKey: str, widget: NavigationWidget):
+        self.routeKey = routeKey
+        self.parentRouteKey = parentRouteKey
+        self.widget = widget
+
+
+class NavigationPanel(QFrame):
+    """ Navigation panel """
+
+    displayModeChanged = Signal(NavigationDisplayMode)
+
+    def __init__(self, parent=None, isMinimalEnabled=False):
+        super().__init__(parent=parent)
+        self._parent = parent   # type: QWidget
+        self._isMenuButtonVisible = True
+        self._isReturnButtonVisible = False
+        self._isCollapsible = True
+        self._isAcrylicEnabled = False
+
+        self.acrylicBrush = AcrylicBrush(self, 30)
+
+        self.scrollArea = ScrollArea(self)
+        self.scrollWidget = QWidget()
+
+        self.menuButton = NavigationToolButton(FIF.MENU, self)
+        self.returnButton = NavigationToolButton(FIF.RETURN, self)
+
+        self.vBoxLayout = NavigationItemLayout(self)
+        self.topLayout = NavigationItemLayout()
+        self.bottomLayout = NavigationItemLayout()
+        self.scrollLayout = NavigationItemLayout(self.scrollWidget)
+
+        self.items = {}   # type: Dict[str, NavigationItem]
+        self.history = qrouter
+
+        self.expandAni = QPropertyAnimation(self, b'geometry', self)
+        self.expandWidth = 322
+        self.minimumExpandWidth = 1008
+
+        self.isMinimalEnabled = isMinimalEnabled
+        if isMinimalEnabled:
+            self.displayMode = NavigationDisplayMode.MINIMAL
+        else:
+            self.displayMode = NavigationDisplayMode.COMPACT
+
+        self.__initWidget()
+
+    def __initWidget(self):
+        self.resize(48, self.height())
+        self.setAttribute(Qt.WA_StyledBackground)
+        self.window().installEventFilter(self)
+
+        self.returnButton.hide()
+        self.returnButton.setDisabled(True)
+
+        self.scrollArea.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.scrollArea.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        self.scrollArea.horizontalScrollBar().setEnabled(False)
+        self.scrollArea.setWidget(self.scrollWidget)
+        self.scrollArea.setWidgetResizable(True)
+
+        self.expandAni.setEasingCurve(QEasingCurve.OutQuad)
+        self.expandAni.setDuration(150)
+
+        self.menuButton.clicked.connect(self.toggle)
+        self.expandAni.finished.connect(self._onExpandAniFinished)
+        self.history.emptyChanged.connect(self.returnButton.setDisabled)
+        self.returnButton.clicked.connect(self.history.pop)
+
+        # add tool tip
+        self.returnButton.installEventFilter(ToolTipFilter(self.returnButton, 1000))
+        self.returnButton.setToolTip(self.tr('Back'))
+
+        self.menuButton.installEventFilter(ToolTipFilter(self.menuButton, 1000))
+        self.menuButton.setToolTip(self.tr('Open Navigation'))
+
+        self.scrollWidget.setObjectName('scrollWidget')
+        self.setProperty('menu', False)
+        FluentStyleSheet.NAVIGATION_INTERFACE.apply(self)
+        FluentStyleSheet.NAVIGATION_INTERFACE.apply(self.scrollWidget)
+        self.__initLayout()
+
+    def __initLayout(self):
+        self.vBoxLayout.setContentsMargins(0, 5, 0, 5)
+        self.topLayout.setContentsMargins(4, 0, 4, 0)
+        self.bottomLayout.setContentsMargins(4, 0, 4, 0)
+        self.scrollLayout.setContentsMargins(4, 0, 4, 0)
+        self.vBoxLayout.setSpacing(4)
+        self.topLayout.setSpacing(4)
+        self.bottomLayout.setSpacing(4)
+        self.scrollLayout.setSpacing(4)
+
+        self.vBoxLayout.addLayout(self.topLayout, 0)
+        self.vBoxLayout.addWidget(self.scrollArea, 1)
+        self.vBoxLayout.addLayout(self.bottomLayout, 0)
+
+        self.vBoxLayout.setAlignment(Qt.AlignTop)
+        self.topLayout.setAlignment(Qt.AlignTop)
+        self.scrollLayout.setAlignment(Qt.AlignTop)
+        self.bottomLayout.setAlignment(Qt.AlignBottom)
+
+        self.topLayout.addWidget(self.returnButton, 0, Qt.AlignTop)
+        self.topLayout.addWidget(self.menuButton, 0, Qt.AlignTop)
+
+    def _updateAcrylicColor(self):
+        if isDarkTheme():
+            tintColor = QColor(32, 32, 32, 200)
+            luminosityColor = QColor(0, 0, 0, 0)
+        else:
+            tintColor = QColor(255, 255, 255, 180)
+            luminosityColor = QColor(255, 255, 255, 0)
+
+        self.acrylicBrush.tintColor = tintColor
+        self.acrylicBrush.luminosityColor = luminosityColor
+
+    def widget(self, routeKey: str):
+        if routeKey not in self.items:
+            raise RouteKeyError(f"`{routeKey}` is illegal.")
+
+        return self.items[routeKey].widget
+
+    def addItem(self, routeKey: str, icon: Union[str, QIcon, FluentIconBase], text: str, onClick=None, selectable=True,
+                position=NavigationItemPosition.TOP, tooltip: str = None, parentRouteKey: str = None):
+        """ add navigation item
+
+        Parameters
+        ----------
+        routeKey: str
+            the unique name of item
+
+        icon: str | QIcon | FluentIconBase
+            the icon of navigation item
+
+        text: str
+            the text of navigation item
+
+        onClick: callable
+            the slot connected to item clicked signal
+
+        position: NavigationItemPosition
+            where the button is added
+
+        selectable: bool
+            whether the item is selectable
+
+        tooltip: str
+            the tooltip of item
+
+        parentRouteKey: str
+            the route key of parent item, the parent widget should be `NavigationTreeWidget`
+        """
+        return self.insertItem(-1, routeKey, icon, text, onClick, selectable, position, tooltip, parentRouteKey)
+
+    def addWidget(self, routeKey: str, widget: NavigationWidget, onClick=None, position=NavigationItemPosition.TOP,
+                  tooltip: str = None, parentRouteKey: str = None):
+        """ add custom widget
+
+        Parameters
+        ----------
+        routeKey: str
+            the unique name of item
+
+        widget: NavigationWidget
+            the custom widget to be added
+
+        onClick: callable
+            the slot connected to item clicked signal
+
+        position: NavigationItemPosition
+            where the button is added
+
+        tooltip: str
+            the tooltip of widget
+
+        parentRouteKey: str
+            the route key of parent item, the parent item should be `NavigationTreeWidget`
+        """
+        self.insertWidget(-1, routeKey, widget, onClick, position, tooltip, parentRouteKey)
+
+    def insertItem(self, index: int, routeKey: str, icon: Union[str, QIcon, FluentIconBase], text: str, onClick=None,
+                   selectable=True, position=NavigationItemPosition.TOP, tooltip: str = None, parentRouteKey=None):
+        """ insert navigation tree item
+
+        Parameters
+        ----------
+        index: int
+            the insert position of parent widget
+
+        routeKey: str
+            the unique name of item
+
+        icon: str | QIcon | FluentIconBase
+            the icon of navigation item
+
+        text: str
+            the text of navigation item
+
+        onClick: callable
+            the slot connected to item clicked signal
+
+        position: NavigationItemPosition
+            where the button is added
+
+        selectable: bool
+            whether the item is selectable
+
+        tooltip: str
+            the tooltip of item
+
+        parentRouteKey: str
+            the route key of parent item, the parent item should be `NavigationTreeWidget`
+        """
+        if routeKey in self.items:
+            return
+
+        w = NavigationTreeWidget(icon, text, selectable, self)
+        self.insertWidget(index, routeKey, w, onClick, position, tooltip, parentRouteKey)
+        return w
+
+    def insertWidget(self, index: int, routeKey: str, widget: NavigationWidget, onClick=None,
+                     position=NavigationItemPosition.TOP, tooltip: str = None, parentRouteKey: str = None):
+        """ insert custom widget
+
+        Parameters
+        ----------
+        index: int
+            insert position
+
+        routeKey: str
+            the unique name of item
+
+        widget: NavigationWidget
+            the custom widget to be added
+
+        onClick: callable
+            the slot connected to item clicked signal
+
+        position: NavigationItemPosition
+            where the button is added
+
+        tooltip: str
+            the tooltip of widget
+
+        parentRouteKey: str
+            the route key of parent item, the parent item should be `NavigationTreeWidget`
+        """
+        if routeKey in self.items:
+            return
+
+        self._registerWidget(routeKey, parentRouteKey, widget, onClick, tooltip)
+        if parentRouteKey:
+            self.widget(parentRouteKey).insertChild(index, widget)
+        else:
+            self._insertWidgetToLayout(index, widget, position)
+
+    def addSeparator(self, position=NavigationItemPosition.TOP):
+        """ add separator
+
+        Parameters
+        ----------
+        position: NavigationPostion
+            where to add the separator
+        """
+        self.insertSeparator(-1, position)
+
+    def insertSeparator(self, index: int, position=NavigationItemPosition.TOP):
+        """ add separator
+
+        Parameters
+        ----------
+        index: int
+            insert position
+
+        position: NavigationPostion
+            where to add the separator
+        """
+        separator = NavigationSeparator(self)
+        self._insertWidgetToLayout(index, separator, position)
+
+    def _registerWidget(self, routeKey: str, parentRouteKey: str, widget: NavigationWidget, onClick, tooltip: str):
+        """ register widget """
+        widget.clicked.connect(self._onWidgetClicked)
+
+        if onClick is not None:
+            widget.clicked.connect(onClick)
+
+        widget.setProperty('routeKey', routeKey)
+        widget.setProperty('parentRouteKey', parentRouteKey)
+        self.items[routeKey] = NavigationItem(routeKey, parentRouteKey, widget)
+
+        if self.displayMode in [NavigationDisplayMode.EXPAND, NavigationDisplayMode.MENU]:
+            widget.setCompacted(False)
+
+        if tooltip:
+            widget.setToolTip(tooltip)
+            widget.installEventFilter(NavigationToolTipFilter(widget, 1000))
+
+    def _insertWidgetToLayout(self, index: int, widget: NavigationWidget, position: NavigationItemPosition):
+        """ insert widget to layout """
+        if position == NavigationItemPosition.TOP:
+            widget.setParent(self)
+            self.topLayout.insertWidget(index, widget, 0, Qt.AlignTop)
+        elif position == NavigationItemPosition.SCROLL:
+            widget.setParent(self.scrollWidget)
+            self.scrollLayout.insertWidget(index, widget, 0, Qt.AlignTop)
+        else:
+            widget.setParent(self)
+            self.bottomLayout.insertWidget(index, widget, 0, Qt.AlignBottom)
+
+        widget.show()
+
+    def removeWidget(self, routeKey: str):
+        """ remove widget
+
+        Parameters
+        ----------
+        routeKey: str
+            the unique name of item
+        """
+        if routeKey not in self.items:
+            return
+
+        item = self.items.pop(routeKey)
+
+        if item.parentRouteKey is not None:
+            self.widget(item.parentRouteKey).removeChild(item.widget)
+
+        if isinstance(item.widget, NavigationTreeWidgetBase):
+            for child in item.widget.findChildren(NavigationWidget, options=Qt.FindChildrenRecursively):
+                key = child.property('routeKey')
+                if key is None:
+                    continue
+
+                self.items.pop(key)
+                child.deleteLater()
+                self.history.remove(key)
+
+        item.widget.deleteLater()
+        self.history.remove(routeKey)
+
+    def setMenuButtonVisible(self, isVisible: bool):
+        """ set whether the menu button is visible """
+        self._isMenuButtonVisible = isVisible
+        self.menuButton.setVisible(isVisible)
+
+    def setReturnButtonVisible(self, isVisible: bool):
+        """ set whether the return button is visible """
+        self._isReturnButtonVisible = isVisible
+        self.returnButton.setVisible(isVisible)
+
+    def setCollapsible(self, on: bool):
+        self._isCollapsible = on
+        if not on and self.displayMode != NavigationDisplayMode.EXPAND:
+            self.expand(False)
+
+    def setExpandWidth(self, width: int):
+        """ set the maximum width """
+        if width <= 42:
+            return
+
+        self.expandWidth = width
+        NavigationWidget.EXPAND_WIDTH = width - 10
+
+    def setMinimumExpandWidth(self, width: int):
+        """ Set the minimum window width that allows panel to be expanded """
+        self.minimumExpandWidth = width
+
+    def setAcrylicEnabled(self, isEnabled: bool):
+        if isEnabled == self.isAcrylicEnabled():
+            return
+
+        self._isAcrylicEnabled = isEnabled
+        self.setProperty("transparent", self._canDrawAcrylic())
+        self.setStyle(QApplication.style())
+        self.update()
+
+    def isAcrylicEnabled(self):
+        """ whether the acrylic effect is enabled """
+        return self._isAcrylicEnabled
+
+    def expand(self, useAni=True):
+        """ expand navigation panel """
+        self._setWidgetCompacted(False)
+        self.expandAni.setProperty('expand', True)
+        self.menuButton.setToolTip(self.tr('Close Navigation'))
+
+        # determine the display mode according to the width of window
+        # https://learn.microsoft.com/en-us/windows/apps/design/controls/navigationview#default
+        expandWidth = self.minimumExpandWidth + self.expandWidth - 322
+        if (self.window().width() >= expandWidth and not self.isMinimalEnabled) or not self._isCollapsible:
+            self.displayMode = NavigationDisplayMode.EXPAND
+        else:
+            self.setProperty('menu', True)
+            self.setStyle(QApplication.style())
+            self.displayMode = NavigationDisplayMode.MENU
+
+            # grab acrylic image
+            if self._canDrawAcrylic():
+                self.acrylicBrush.grabImage(
+                    QRect(self.mapToGlobal(QPoint()), QSize(self.expandWidth, self.height())))
+
+            if not self._parent.isWindow():
+                pos = self.parent().pos()
+                self.setParent(self.window())
+                self.move(pos)
+
+            self.show()
+
+        if useAni:
+            self.displayModeChanged.emit(self.displayMode)
+            self.expandAni.setStartValue(
+                QRect(self.pos(), QSize(48, self.height())))
+            self.expandAni.setEndValue(
+                QRect(self.pos(), QSize(self.expandWidth, self.height())))
+            self.expandAni.start()
+        else:
+            self.resize(self.expandWidth, self.height())
+            self._onExpandAniFinished()
+
+    def collapse(self):
+        """ collapse navigation panel """
+        if self.expandAni.state() == QPropertyAnimation.Running:
+            return
+
+        for item in self.items.values():
+            w = item.widget
+            if isinstance(w, NavigationTreeWidgetBase) and w.isRoot():
+                w.setExpanded(False)
+
+        self.expandAni.setStartValue(
+            QRect(self.pos(), QSize(self.width(), self.height())))
+        self.expandAni.setEndValue(
+            QRect(self.pos(), QSize(48, self.height())))
+        self.expandAni.setProperty('expand', False)
+        self.expandAni.start()
+
+        self.menuButton.setToolTip(self.tr('Open Navigation'))
+
+    def toggle(self):
+        """ toggle navigation panel """
+        if self.displayMode in [NavigationDisplayMode.COMPACT, NavigationDisplayMode.MINIMAL]:
+            self.expand()
+        else:
+            self.collapse()
+
+    def setCurrentItem(self, routeKey: str):
+        """ set current selected item
+
+        Parameters
+        ----------
+        routeKey: str
+            the unique name of item
+        """
+        if routeKey not in self.items:
+            return
+
+        for k, item in self.items.items():
+            item.widget.setSelected(k == routeKey)
+
+    def _onWidgetClicked(self):
+        widget = self.sender()  # type: NavigationWidget
+        if not widget.isSelectable:
+            return self._showFlyoutNavigationMenu(widget)
+
+        self.setCurrentItem(widget.property('routeKey'))
+
+        isLeaf = not isinstance(widget, NavigationTreeWidgetBase) or widget.isLeaf()
+        if self.displayMode == NavigationDisplayMode.MENU and isLeaf:
+            self.collapse()
+        elif self.isCollapsed():
+            self._showFlyoutNavigationMenu(widget)
+
+    def _showFlyoutNavigationMenu(self, widget: NavigationTreeWidget):
+        """ show flyout navigation menu """
+        if not (self.isCollapsed() and isinstance(widget, NavigationTreeWidget)):
+            return
+
+        if not widget.isRoot() or widget.isLeaf():
+            return
+
+        layout = QHBoxLayout()
+
+        if self._canDrawAcrylic():
+            view = AcrylicFlyoutViewBase()
+            view.setLayout(layout)
+            flyout = AcrylicFlyout(view, self.window())
+        else:
+            view = FlyoutViewBase()
+            view.setLayout(layout)
+            flyout = Flyout(view, self.window())
+
+        # add navigation menu to flyout
+        menu = NavigationFlyoutMenu(widget, view)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(menu)
+
+        # execuse flyout animation
+        flyout.resize(flyout.sizeHint())
+        pos = SlideRightFlyoutAnimationManager(flyout).position(widget)
+        flyout.exec(pos, FlyoutAnimationType.SLIDE_RIGHT)
+
+        menu.expanded.connect(lambda: self._adjustFlyoutMenuSize(flyout, widget, menu))
+
+    def _adjustFlyoutMenuSize(self, flyout: Flyout, widget: NavigationTreeWidget, menu: NavigationFlyoutMenu):
+        flyout.view.setFixedSize(menu.size())
+        flyout.setFixedSize(flyout.layout().sizeHint())
+
+        manager = flyout.aniManager
+        pos = manager.position(widget)
+
+        rect = self.window().geometry()
+        w, h = flyout.sizeHint().width() + 5, flyout.sizeHint().height()
+        x = max(rect.left(), min(pos.x(), rect.right() - w))
+        y = max(rect.top() + 42, min(pos.y() - 4, rect.bottom() - h + 5))
+        flyout.move(x, y)
+
+    def isCollapsed(self):
+        return self.displayMode == NavigationDisplayMode.COMPACT
+
+    def eventFilter(self, obj, e: QEvent):
+        if obj is not self.window() or not self._isCollapsible:
+            return super().eventFilter(obj, e)
+
+        if e.type() == QEvent.MouseButtonRelease:
+            if not self.geometry().contains(e.pos()) and self.displayMode == NavigationDisplayMode.MENU:
+                self.collapse()
+        elif e.type() == QEvent.Resize:
+            w = QResizeEvent(e).size().width()
+            if w < self.minimumExpandWidth and self.displayMode == NavigationDisplayMode.EXPAND:
+                self.collapse()
+            elif w >= self.minimumExpandWidth and self.displayMode == NavigationDisplayMode.COMPACT and \
+                    not self._isMenuButtonVisible:
+                self.expand()
+
+        return super().eventFilter(obj, e)
+
+    def _onExpandAniFinished(self):
+        if not self.expandAni.property('expand'):
+            if self.isMinimalEnabled:
+                self.displayMode = NavigationDisplayMode.MINIMAL
+            else:
+                self.displayMode = NavigationDisplayMode.COMPACT
+
+            self.displayModeChanged.emit(self.displayMode)
+
+        if self.displayMode == NavigationDisplayMode.MINIMAL:
+            self.hide()
+            self.setProperty('menu', False)
+            self.setStyle(QApplication.style())
+        elif self.displayMode == NavigationDisplayMode.COMPACT:
+            self.setProperty('menu', False)
+            self.setStyle(QApplication.style())
+
+            for item in self.items.values():
+                item.widget.setCompacted(True)
+
+            if not self._parent.isWindow():
+                self.setParent(self._parent)
+                self.move(0, 0)
+                self.show()
+
+    def _setWidgetCompacted(self, isCompacted: bool):
+        """ set whether the navigation widget is compacted """
+        for item in self.findChildren(NavigationWidget):
+            item.setCompacted(isCompacted)
+
+    def layoutMinHeight(self):
+        th = self.topLayout.minimumSize().height()
+        bh = self.bottomLayout.minimumSize().height()
+        sh = sum(w.height() for w in self.findChildren(NavigationSeparator))
+        spacing = self.topLayout.count() * self.topLayout.spacing()
+        spacing += self.bottomLayout.count() * self.bottomLayout.spacing()
+        return 36 + th + bh + sh + spacing
+
+    def _canDrawAcrylic(self):
+        return self.acrylicBrush.isAvailable() and self.isAcrylicEnabled()
+
+    def paintEvent(self, e):
+        if not self._canDrawAcrylic() or self.displayMode != NavigationDisplayMode.MENU:
+            return super().paintEvent(e)
+
+        path = QPainterPath()
+        path.setFillRule(Qt.WindingFill)
+        path.addRoundedRect(0, 1, self.width() - 1, self.height() - 1, 7, 7)
+        path.addRect(0, 1, 8, self.height() - 1)
+        self.acrylicBrush.setClipPath(path)
+
+        self._updateAcrylicColor()
+        self.acrylicBrush.paint()
+
+        super().paintEvent(e)
+
+
+
+class NavigationItemLayout(QVBoxLayout):
+    """ Navigation layout """
+
+    def setGeometry(self, rect: QRect):
+        super().setGeometry(rect)
+        for i in range(self.count()):
+            item = self.itemAt(i)
+            if isinstance(item.widget(), NavigationSeparator):
+                geo = item.geometry()
+                item.widget().setGeometry(0, geo.y(), geo.width(), geo.height())
+