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

fastuiwidgets/components/navigation/pivot.py

@@ -0,0 +1,272 @@
+# coding:utf-8
+from typing import Dict
+
+from PySide6.QtCore import Qt, Signal, QRectF
+from PySide6.QtGui import QPainter, QFont, QColor
+from PySide6.QtWidgets import QApplication, QPushButton, QWidget, QHBoxLayout, QSizePolicy
+
+from ...common.font import setFont
+from ...common.router import qrouter
+from ...common.style_sheet import themeColor, FluentStyleSheet
+from ...common.color import autoFallbackThemeColor
+from ...common.animation import FluentAnimation, FluentAnimationType, FluentAnimationProperty
+from ..widgets.button import PushButton
+from .navigation_panel import RouteKeyError
+
+
+class PivotItem(PushButton):
+    """ Pivot item """
+
+    itemClicked = Signal(bool)
+
+    def _postInit(self):
+        self.isSelected = False
+        self.setProperty('isSelected', False)
+        self.clicked.connect(lambda: self.itemClicked.emit(True))
+        self.setAttribute(Qt.WA_LayoutUsesWidgetRect)
+
+        FluentStyleSheet.PIVOT.apply(self)
+        setFont(self, 18)
+
+    def setSelected(self, isSelected: bool):
+        if self.isSelected == isSelected:
+            return
+
+        self.isSelected = isSelected
+        self.setProperty('isSelected', isSelected)
+        self.setStyle(QApplication.style())
+        self.update()
+
+
+class Pivot(QWidget):
+    """ Pivot """
+
+    currentItemChanged = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.items = {}  # type: Dict[str, PivotItem]
+        self._currentRouteKey = None
+
+        self.lightIndicatorColor = QColor()
+        self.darkIndicatorColor = QColor()
+
+        self.hBoxLayout = QHBoxLayout(self)
+        self.slideAni = FluentAnimation.create(
+            FluentAnimationType.POINT_TO_POINT, FluentAnimationProperty.SCALE, value=0, parent=self)
+
+        FluentStyleSheet.PIVOT.apply(self)
+
+        self.hBoxLayout.setSpacing(0)
+        self.hBoxLayout.setAlignment(Qt.AlignLeft)
+        self.hBoxLayout.setContentsMargins(0, 0, 0, 0)
+        self.hBoxLayout.setSizeConstraint(QHBoxLayout.SetMinimumSize)
+
+        self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
+
+    def addItem(self, routeKey: str, text: str, onClick=None, icon=None):
+        """ add item
+
+        Parameters
+        ----------
+        routeKey: str
+            the unique name of item
+
+        text: str
+            the text of navigation item
+
+        onClick: callable
+            the slot connected to item clicked signal
+
+        icon: str
+            the icon of navigation item
+        """
+        return self.insertItem(-1, routeKey, text, onClick, icon)
+
+    def addWidget(self, routeKey: str, widget: PivotItem, onClick=None):
+        """ add widget
+
+        Parameters
+        ----------
+        routeKey: str
+            the unique name of item
+
+        widget: PivotItem
+            navigation widget
+
+        onClick: callable
+            the slot connected to item clicked signal
+        """
+        self.insertWidget(-1, routeKey, widget, onClick)
+
+    def insertItem(self, index: int, routeKey: str, text: str, onClick=None, icon=None):
+        """ insert item
+
+        Parameters
+        ----------
+        index: int
+            insert position
+
+        routeKey: str
+            the unique name of item
+
+        text: str
+            the text of navigation item
+
+        onClick: callable
+            the slot connected to item clicked signal
+
+        icon: str
+            the icon of navigation item
+        """
+        if routeKey in self.items:
+            return
+
+        item = PivotItem(text, self)
+        if icon:
+            item.setIcon(icon)
+
+        self.insertWidget(index, routeKey, item, onClick)
+        return item
+
+    def insertWidget(self, index: int, routeKey: str, widget: PivotItem, onClick=None):
+        """ insert item
+
+        Parameters
+        ----------
+        index: int
+            insert position
+
+        routeKey: str
+            the unique name of item
+
+        widget: PivotItem
+            navigation widget
+
+        onClick: callable
+            the slot connected to item clicked signal
+        """
+        if routeKey in self.items:
+            return
+
+        widget.setProperty('routeKey', routeKey)
+        widget.itemClicked.connect(self._onItemClicked)
+        if onClick:
+            widget.itemClicked.connect(onClick)
+
+        self.items[routeKey] = widget
+        self.hBoxLayout.insertWidget(index, widget, 1)
+
+    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)
+        self.hBoxLayout.removeWidget(item)
+        qrouter.remove(routeKey)
+        item.deleteLater()
+
+        if not self.items:
+            self._currentRouteKey = None
+
+    def clear(self):
+        """ clear all navigation items """
+        for k, w in self.items.items():
+            self.hBoxLayout.removeWidget(w)
+            qrouter.remove(k)
+            w.deleteLater()
+
+        self.items.clear()
+        self._currentRouteKey = None
+
+    def currentItem(self):
+        """ Returns the current selected item """
+        if self._currentRouteKey is None:
+            return None
+
+        return self.widget(self._currentRouteKey)
+
+    def currentRouteKey(self):
+        return self._currentRouteKey
+
+    def setCurrentItem(self, routeKey: str):
+        """ set current selected item
+
+        Parameters
+        ----------
+        routeKey: str
+            the unique name of item
+        """
+        if routeKey not in self.items or routeKey == self.currentRouteKey():
+            return
+
+        self._currentRouteKey = routeKey
+        self.slideAni.startAnimation(self.widget(routeKey).x())
+
+        for k, item in self.items.items():
+            item.setSelected(k == routeKey)
+
+        self.currentItemChanged.emit(routeKey)
+
+    def showEvent(self, e):
+        super().showEvent(e)
+        self._adjustIndicatorPos()
+
+    def setItemFontSize(self, size: int):
+        """ set the pixel font size of items """
+        for item in self.items.values():
+            font = item.font()
+            font.setPixelSize(size)
+            item.setFont(font)
+            item.adjustSize()
+
+    def setItemText(self, routeKey: str, text: str):
+        """ set the text of item """
+        item = self.widget(routeKey)
+        item.setText(text)
+
+    def setIndicatorColor(self, light, dark):
+        self.lightIndicatorColor = QColor(light)
+        self.darkIndicatorColor = QColor(dark)
+        self.update()
+
+    def _onItemClicked(self):
+        item = self.sender()  # type: PivotItem
+        self.setCurrentItem(item.property('routeKey'))
+
+    def widget(self, routeKey: str):
+        if routeKey not in self.items:
+            raise RouteKeyError(f"`{routeKey}` is illegal.")
+
+        return self.items[routeKey]
+
+    def resizeEvent(self, e) -> None:
+        super().resizeEvent(e)
+        self._adjustIndicatorPos()
+
+    def _adjustIndicatorPos(self):
+        item = self.currentItem()
+        if item:
+            self.slideAni.stop()
+            self.slideAni.setValue(item.x())
+
+    def paintEvent(self, e):
+        super().paintEvent(e)
+
+        if not self.currentItem():
+            return
+
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.Antialiasing)
+        painter.setPen(Qt.NoPen)
+        painter.setBrush(autoFallbackThemeColor(self.lightIndicatorColor, self.darkIndicatorColor))
+
+        x = int(self.currentItem().width() / 2 - 8 + self.slideAni.value())
+        painter.drawRoundedRect(x, self.height() - 3, 16, 3, 1.5, 1.5)

fastuiwidgets/components/navigation/segmented_widget.py

@@ -0,0 +1,174 @@
+# coding:utf-8
+from typing import Union
+from PySide6.QtCore import Qt, Signal, QRectF
+from PySide6.QtGui import QPainter, QIcon, QColor
+from PySide6.QtWidgets import QApplication, QWidget
+
+from ...common.font import setFont
+from ...common.icon import FluentIconBase, drawIcon, Theme
+from ...common.color import autoFallbackThemeColor
+from ...common.style_sheet import themeColor, FluentStyleSheet, isDarkTheme
+from ..widgets.button import PushButton, ToolButton, TransparentToolButton
+from .pivot import Pivot, PivotItem
+
+
+class SegmentedItem(PivotItem):
+    """ Segmented item """
+
+    def _postInit(self):
+        super()._postInit()
+        setFont(self, 14)
+
+
+class SegmentedToolItem(ToolButton):
+    """ Pivot item """
+
+    itemClicked = Signal(bool)
+
+    def _postInit(self):
+        self.isSelected = False
+        self.setProperty('isSelected', False)
+        self.clicked.connect(lambda: self.itemClicked.emit(True))
+
+        self.setFixedSize(38, 33)
+        FluentStyleSheet.PIVOT.apply(self)
+
+    def setSelected(self, isSelected: bool):
+        if self.isSelected == isSelected:
+            return
+
+        self.isSelected = isSelected
+        self.setProperty('isSelected', isSelected)
+        self.setStyle(QApplication.style())
+        self.update()
+
+
+class SegmentedToggleToolItem(TransparentToolButton):
+
+    itemClicked = Signal(bool)
+
+    def _postInit(self):
+        super()._postInit()
+        self.isSelected = False
+
+        self.setFixedSize(50, 32)
+        self.clicked.connect(lambda: self.itemClicked.emit(True))
+
+    def setSelected(self, isSelected: bool):
+        if self.isSelected == isSelected:
+            return
+
+        self.isSelected = isSelected
+        self.setChecked(isSelected)
+
+    def _drawIcon(self, icon, painter: QPainter, rect: QRectF, state=QIcon.State.Off):
+        if self.isSelected and isinstance(icon, FluentIconBase):
+            theme = Theme.DARK if not isDarkTheme() else Theme.LIGHT
+            icon = icon.icon(theme)
+
+        return drawIcon(icon, painter, rect, state)
+
+
+class SegmentedWidget(Pivot):
+    """ Segmented widget """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setAttribute(Qt.WA_StyledBackground)
+
+    def insertItem(self, index: int, routeKey: str, text: str, onClick=None, icon=None):
+        if routeKey in self.items:
+            return
+
+        item = SegmentedItem(text, self)
+        if icon:
+            item.setIcon(icon)
+
+        self.insertWidget(index, routeKey, item, onClick)
+        return item
+
+    def paintEvent(self, e):
+        QWidget.paintEvent(self, e)
+
+        if not self.currentItem():
+            return
+
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.Antialiasing)
+
+        # draw background
+        if isDarkTheme():
+            painter.setPen(QColor(255, 255, 255, 14))
+            painter.setBrush(QColor(255, 255, 255, 15))
+        else:
+            painter.setPen(QColor(0, 0, 0, 19))
+            painter.setBrush(QColor(255, 255, 255, 179))
+
+        item = self.currentItem()
+        rect = item.rect().adjusted(1, 1, -1, -1).translated(int(self.slideAni.value()), 0)
+        painter.drawRoundedRect(rect, 5, 5)
+
+        # draw indicator
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(autoFallbackThemeColor(self.lightIndicatorColor, self.darkIndicatorColor))
+
+        x = int(self.currentItem().width() / 2 - 8 + self.slideAni.value())
+        painter.drawRoundedRect(QRectF(x, self.height() - 3.5, 16, 3), 1.5, 1.5)
+
+
+class SegmentedToolWidget(SegmentedWidget):
+    """ Segmented tool widget """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setAttribute(Qt.WA_StyledBackground)
+
+    def addItem(self, routeKey: str, icon: Union[str, QIcon, FluentIconBase], onClick=None):
+        """ add item
+
+        Parameters
+        ----------
+        routeKey: str
+            the unique name of item
+
+        icon: str | QIcon | FluentIconBase
+            the icon of navigation item
+
+        onClick: callable
+            the slot connected to item clicked signal
+        """
+        return self.insertItem(-1, routeKey, icon, onClick)
+
+    def insertItem(self, index: int, routeKey: str, icon: Union[str, QIcon, FluentIconBase], onClick=None):
+        if routeKey in self.items:
+            return
+
+        item = self._createItem(icon)
+        self.insertWidget(index, routeKey, item, onClick)
+        return item
+
+    def _createItem(self, icon):
+        return SegmentedToolItem(icon)
+
+
+class SegmentedToggleToolWidget(SegmentedToolWidget):
+    """ Segmented toggle tool widget """
+
+    def _createItem(self, icon):
+        return SegmentedToggleToolItem(icon)
+
+    def paintEvent(self, e):
+        QWidget.paintEvent(self, e)
+
+        if not self.currentItem():
+            return
+
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.RenderHint.Antialiasing)
+
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(autoFallbackThemeColor(self.lightIndicatorColor, self.darkIndicatorColor))
+
+        item = self.currentItem()
+        painter.drawRoundedRect(
+            QRectF(self.slideAni.value(), 0, item.width(), item.height()), 4, 4)

fastuiwidgets/components/settings/__init__.py

@@ -0,0 +1,8 @@
+from .setting_card import (SettingCard, SwitchSettingCard, RangeSettingCard,
+                           PushSettingCard, ColorSettingCard, HyperlinkCard,
+                           PrimaryPushSettingCard, ColorPickerButton, ComboBoxSettingCard)
+from .expand_setting_card import ExpandSettingCard, ExpandGroupSettingCard, SimpleExpandGroupSettingCard
+from .folder_list_setting_card import FolderListSettingCard
+from .options_setting_card import OptionsSettingCard
+from .custom_color_setting_card import CustomColorSettingCard
+from .setting_card_group import SettingCardGroup

fastuiwidgets/components/settings/custom_color_setting_card.py

@@ -0,0 +1,139 @@
+# coding:utf-8
+from typing import Union
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QIcon, QColor
+from PySide6.QtWidgets import QWidget, QLabel, QButtonGroup, QVBoxLayout, QPushButton, QHBoxLayout
+
+from ..dialog_box import ColorDialog
+from .expand_setting_card import ExpandGroupSettingCard
+from ..widgets.button import RadioButton
+from ...common.config import qconfig, ColorConfigItem
+from ...common.icon import FluentIconBase
+
+
+class CustomColorSettingCard(ExpandGroupSettingCard):
+    """ Custom color setting card """
+
+    colorChanged = Signal(QColor)
+
+    def __init__(self, configItem: ColorConfigItem, icon: Union[str, QIcon, FluentIconBase], title: str,
+                 content=None, parent=None, enableAlpha=False):
+        """
+        Parameters
+        ----------
+        configItem: ColorConfigItem
+            options config item
+
+        icon: str | QIcon | FluentIconBase
+            the icon to be drawn
+
+        title: str
+            the title of setting card
+
+        content: str
+            the content of setting card
+
+        parent: QWidget
+            parent window
+
+        enableAlpha: bool
+            whether to enable the alpha channel
+        """
+        super().__init__(icon, title, content, parent=parent)
+        self.enableAlpha = enableAlpha
+        self.configItem = configItem
+        self.defaultColor = QColor(configItem.defaultValue)
+        self.customColor = QColor(qconfig.get(configItem))
+
+        self.choiceLabel = QLabel(self)
+
+        self.radioWidget = QWidget(self.view)
+        self.radioLayout = QVBoxLayout(self.radioWidget)
+        self.defaultRadioButton = RadioButton(
+            self.tr('Default color'), self.radioWidget)
+        self.customRadioButton = RadioButton(
+            self.tr('Custom color'), self.radioWidget)
+        self.buttonGroup = QButtonGroup(self)
+
+        self.customColorWidget = QWidget(self.view)
+        self.customColorLayout = QHBoxLayout(self.customColorWidget)
+        self.customLabel = QLabel(
+            self.tr('Custom color'), self.customColorWidget)
+        self.chooseColorButton = QPushButton(
+            self.tr('Choose color'), self.customColorWidget)
+
+        self.__initWidget()
+
+    def __initWidget(self):
+        self.__initLayout()
+
+        if self.defaultColor != self.customColor:
+            self.customRadioButton.setChecked(True)
+            self.chooseColorButton.setEnabled(True)
+        else:
+            self.defaultRadioButton.setChecked(True)
+            self.chooseColorButton.setEnabled(False)
+
+        self.choiceLabel.setText(self.buttonGroup.checkedButton().text())
+        self.choiceLabel.adjustSize()
+
+        self.choiceLabel.setObjectName("titleLabel")
+        self.customLabel.setObjectName("titleLabel")
+        self.chooseColorButton.setObjectName('chooseColorButton')
+
+        self.buttonGroup.buttonClicked.connect(self.__onRadioButtonClicked)
+        self.chooseColorButton.clicked.connect(self.__showColorDialog)
+
+    def __initLayout(self):
+        self.addWidget(self.choiceLabel)
+
+        self.radioLayout.setSpacing(19)
+        self.radioLayout.setAlignment(Qt.AlignTop)
+        self.radioLayout.setContentsMargins(48, 18, 0, 18)
+        self.buttonGroup.addButton(self.customRadioButton)
+        self.buttonGroup.addButton(self.defaultRadioButton)
+        self.radioLayout.addWidget(self.customRadioButton)
+        self.radioLayout.addWidget(self.defaultRadioButton)
+        self.radioLayout.setSizeConstraint(QVBoxLayout.SetMinimumSize)
+
+        self.customColorLayout.setContentsMargins(48, 18, 44, 18)
+        self.customColorLayout.addWidget(self.customLabel, 0, Qt.AlignLeft)
+        self.customColorLayout.addWidget(self.chooseColorButton, 0, Qt.AlignRight)
+        self.customColorLayout.setSizeConstraint(QHBoxLayout.SetMinimumSize)
+
+        self.viewLayout.setSpacing(0)
+        self.viewLayout.setContentsMargins(0, 0, 0, 0)
+        self.addGroupWidget(self.radioWidget)
+        self.addGroupWidget(self.customColorWidget)
+
+    def __onRadioButtonClicked(self, button: RadioButton):
+        """ radio button clicked slot """
+        if button.text() == self.choiceLabel.text():
+            return
+
+        self.choiceLabel.setText(button.text())
+        self.choiceLabel.adjustSize()
+
+        if button is self.defaultRadioButton:
+            self.chooseColorButton.setDisabled(True)
+            qconfig.set(self.configItem, self.defaultColor)
+            if self.defaultColor != self.customColor:
+                self.colorChanged.emit(self.defaultColor)
+        else:
+            self.chooseColorButton.setDisabled(False)
+            qconfig.set(self.configItem, self.customColor)
+            if self.defaultColor != self.customColor:
+                self.colorChanged.emit(self.customColor)
+
+    def __showColorDialog(self):
+        """ show color dialog """
+        w = ColorDialog(
+            qconfig.get(self.configItem), self.tr('Choose color'), self.window(), self.enableAlpha)
+        w.colorChanged.connect(self.__onCustomColorChanged)
+        w.exec()
+
+    def __onCustomColorChanged(self, color):
+        """ custom color changed slot """
+        qconfig.set(self.configItem, color)
+        self.customColor = QColor(color)
+        self.colorChanged.emit(color)