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

fastuiwidgets/components/widgets/stacked_widget.py

@@ -0,0 +1,211 @@
+# coding:utf-8
+from typing import List
+
+from PySide6.QtCore import (QAbstractAnimation, QEasingCurve, QPoint, QPropertyAnimation,
+                          Signal)
+from PySide6.QtWidgets import QGraphicsOpacityEffect, QStackedWidget, QWidget
+
+
+class OpacityAniStackedWidget(QStackedWidget):
+    """ Stacked widget with fade in and fade out animation """
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self.__nextIndex = 0
+        self.__effects = []  # type:List[QPropertyAnimation]
+        self.__anis = []     # type:List[QPropertyAnimation]
+
+    def addWidget(self, w: QWidget):
+        super().addWidget(w)
+
+        effect = QGraphicsOpacityEffect(self)
+        effect.setOpacity(1)
+        ani = QPropertyAnimation(effect, b'opacity', self)
+        ani.setDuration(220)
+        ani.finished.connect(self.__onAniFinished)
+        self.__anis.append(ani)
+        self.__effects.append(effect)
+        w.setGraphicsEffect(effect)
+
+    def setCurrentIndex(self, index: int):
+        index_ = self.currentIndex()
+        if index == index_:
+            return
+
+        if index > index_:
+            ani = self.__anis[index]
+            ani.setStartValue(0)
+            ani.setEndValue(1)
+            super().setCurrentIndex(index)
+        else:
+            ani = self.__anis[index_]
+            ani.setStartValue(1)
+            ani.setEndValue(0)
+
+        self.widget(index_).show()
+        self.__nextIndex = index
+        ani.start()
+
+    def setCurrentWidget(self, w: QWidget):
+        self.setCurrentIndex(self.indexOf(w))
+
+    def __onAniFinished(self):
+        super().setCurrentIndex(self.__nextIndex)
+
+
+class PopUpAniInfo:
+    """ Pop up ani info """
+
+    def __init__(self, widget: QWidget, deltaX: int, deltaY, ani: QPropertyAnimation):
+        self.widget = widget
+        self.deltaX = deltaX
+        self.deltaY = deltaY
+        self.ani = ani
+
+
+class PopUpAniStackedWidget(QStackedWidget):
+    """ Stacked widget with pop up animation """
+
+    aniFinished = Signal()
+    aniStart = Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.aniInfos = []  # type: List[PopUpAniInfo]
+        self.isAnimationEnabled = True
+        self._nextIndex = None
+        self._ani = None
+
+    def addWidget(self, widget, deltaX=0, deltaY=76):
+        """ add widget to window
+
+        Parameters
+        -----------
+        widget:
+            widget to be added
+
+        deltaX: int
+            the x-axis offset from the beginning to the end of animation
+
+        deltaY: int
+            the y-axis offset from the beginning to the end of animation
+        """
+        super().addWidget(widget)
+
+        self.aniInfos.append(PopUpAniInfo(
+            widget=widget,
+            deltaX=deltaX,
+            deltaY=deltaY,
+            ani=QPropertyAnimation(widget, b'pos'),
+        ))
+
+    def removeWidget(self, widget: QWidget):
+        index = self.indexOf(widget)
+        if index == -1:
+            return
+
+        self.aniInfos.pop(index)
+        super().removeWidget(widget)
+
+    def setAnimationEnabled(self, isEnabled: bool):
+        """set whether the pop animation is enabled"""
+        self.isAnimationEnabled = isEnabled
+
+    def setCurrentIndex(self, index: int, needPopOut: bool = False, showNextWidgetDirectly: bool = True,
+                        duration: int = 250, easingCurve=QEasingCurve.OutQuad):
+        """ set current window to display
+
+        Parameters
+        ----------
+        index: int
+            the index of widget to display
+
+        isNeedPopOut: bool
+            need pop up animation or not
+
+        showNextWidgetDirectly: bool
+            whether to show next widget directly when animation started
+
+        duration: int
+            animation duration
+
+        easingCurve: QEasingCurve
+            the interpolation mode of animation
+        """
+        if index < 0 or index >= self.count():
+            raise Exception(f'The index `{index}` is illegal')
+
+        if index == self.currentIndex():
+            return
+
+        if not self.isAnimationEnabled:
+            return super().setCurrentIndex(index)
+
+        if self._ani and self._ani.state() == QAbstractAnimation.Running:
+            self._ani.stop()
+            self.__onAniFinished()
+
+        # get the index of widget to be displayed
+        self._nextIndex = index
+
+        # get animation
+        nextAniInfo = self.aniInfos[index]
+        currentAniInfo = self.aniInfos[self.currentIndex()]
+
+        currentWidget = self.currentWidget()
+        nextWidget = nextAniInfo.widget
+        ani = currentAniInfo.ani if needPopOut else nextAniInfo.ani
+        self._ani = ani
+
+        if needPopOut:
+            deltaX, deltaY = currentAniInfo.deltaX, currentAniInfo.deltaY
+            pos = currentWidget.pos() + QPoint(deltaX, deltaY)
+            self.__setAnimation(ani, currentWidget.pos(), pos, duration, easingCurve)
+            nextWidget.setVisible(showNextWidgetDirectly)
+        else:
+            deltaX, deltaY = nextAniInfo.deltaX, nextAniInfo.deltaY
+            pos = nextWidget.pos() + QPoint(deltaX, deltaY)
+            self.__setAnimation(ani, pos, QPoint(nextWidget.x(), 0), duration, easingCurve)
+            super().setCurrentIndex(index)
+
+        # start animation
+        ani.finished.connect(self.__onAniFinished)
+        ani.start()
+        self.aniStart.emit()
+
+    def setCurrentWidget(self, widget, needPopOut: bool = False, showNextWidgetDirectly: bool = True,
+                         duration: int = 250, easingCurve=QEasingCurve.OutQuad):
+        """ set currect widget
+
+        Parameters
+        ----------
+        widget:
+            the widget to be displayed
+
+        isNeedPopOut: bool
+            need pop up animation or not
+
+        showNextWidgetDirectly: bool
+            whether to show next widget directly when animation started
+
+        duration: int
+            animation duration
+
+        easingCurve: QEasingCurve
+            the interpolation mode of animation
+        """
+        self.setCurrentIndex(
+            self.indexOf(widget), needPopOut, showNextWidgetDirectly, duration, easingCurve)
+
+    def __setAnimation(self, ani, startValue, endValue, duration, easingCurve=QEasingCurve.Linear):
+        """ set the config of animation """
+        ani.setEasingCurve(easingCurve)
+        ani.setStartValue(startValue)
+        ani.setEndValue(endValue)
+        ani.setDuration(duration)
+
+    def __onAniFinished(self):
+        """ animation finished slot """
+        self._ani.finished.disconnect()
+        super().setCurrentIndex(self._nextIndex)
+        self.aniFinished.emit()

fastuiwidgets/components/widgets/state_tool_tip.py

@@ -0,0 +1,188 @@
+# coding:utf-8
+from PySide6.QtCore import QEasingCurve, QPropertyAnimation, Qt, QTimer, Signal, QSize, QPoint, QRectF
+from PySide6.QtGui import QPainter
+from PySide6.QtWidgets import QLabel, QWidget, QToolButton, QGraphicsOpacityEffect
+from PySide6.QtSvgWidgets import QSvgWidget
+
+from ...common import FluentStyleSheet, isDarkTheme, Theme
+from ...common.icon import FluentIcon as FIF
+
+
+class StateCloseButton(QToolButton):
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setFixedSize(12, 12)
+        self.isPressed = False
+        self.isEnter = False
+
+    def enterEvent(self, e):
+        self.isEnter = True
+        self.update()
+
+    def leaveEvent(self, e):
+        self.isEnter = False
+        self.isPressed = False
+        self.update()
+
+    def mousePressEvent(self, e):
+        self.isPressed = True
+        self.update()
+        super().mousePressEvent(e)
+
+    def mouseReleaseEvent(self, e):
+        self.isPressed = False
+        self.update()
+        super().mouseReleaseEvent(e)
+
+    def paintEvent(self, e):
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.Antialiasing)
+        if self.isPressed:
+            painter.setOpacity(0.6)
+        elif self.isEnter:
+            painter.setOpacity(0.8)
+
+        theme = Theme.DARK if not isDarkTheme() else Theme.LIGHT
+        FIF.CLOSE.render(painter, self.rect(), theme)
+
+
+class StateToolTip(QWidget):
+    """ State tooltip """
+
+    closedSignal = Signal()
+
+    def __init__(self, title, content, parent=None):
+        """
+        Parameters
+        ----------
+        title: str
+            title of tooltip
+
+        content: str
+            content of tooltip
+
+        parant:
+            parent window
+        """
+        super().__init__(parent)
+        self.title = title
+        self.content = content
+
+        self.titleLabel = QLabel(self.title, self)
+        self.contentLabel = QLabel(self.content, self)
+        self.rotateTimer = QTimer(self)
+
+        self.opacityEffect = QGraphicsOpacityEffect(self)
+        self.animation = QPropertyAnimation(self.opacityEffect, b"opacity")
+        self.closeButton = StateCloseButton(self)
+
+        self.isDone = False
+        self.rotateAngle = 0
+        self.deltaAngle = 20
+
+        self.__initWidget()
+
+    def __initWidget(self):
+        """ initialize widgets """
+        self.setAttribute(Qt.WA_StyledBackground)
+        self.setGraphicsEffect(self.opacityEffect)
+        self.opacityEffect.setOpacity(1)
+        self.rotateTimer.setInterval(50)
+        self.contentLabel.setMinimumWidth(200)
+
+        # connect signal to slot
+        self.closeButton.clicked.connect(self.__onCloseButtonClicked)
+        self.rotateTimer.timeout.connect(self.__rotateTimerFlowSlot)
+
+        self.__setQss()
+        self.__initLayout()
+
+        self.rotateTimer.start()
+
+    def __initLayout(self):
+        """ initialize layout """
+        self.setFixedSize(max(self.titleLabel.width(),
+                          self.contentLabel.width()) + 56, 51)
+        self.titleLabel.move(32, 9)
+        self.contentLabel.move(12, 27)
+        self.closeButton.move(self.width() - 24, 19)
+
+    def __setQss(self):
+        """ set style sheet """
+        self.titleLabel.setObjectName("titleLabel")
+        self.contentLabel.setObjectName("contentLabel")
+
+        FluentStyleSheet.STATE_TOOL_TIP.apply(self)
+
+        self.titleLabel.adjustSize()
+        self.contentLabel.adjustSize()
+
+    def setTitle(self, title: str):
+        """ set the title of tooltip """
+        self.title = title
+        self.titleLabel.setText(title)
+        self.titleLabel.adjustSize()
+
+    def setContent(self, content: str):
+        """ set the content of tooltip """
+        self.content = content
+        self.contentLabel.setText(content)
+
+        # adjustSize() will mask spinner get stuck
+        self.contentLabel.adjustSize()
+
+    def setState(self, isDone=False):
+        """ set the state of tooltip """
+        self.isDone = isDone
+        self.update()
+        if isDone:
+            QTimer.singleShot(1000, self.__fadeOut)
+
+    def __onCloseButtonClicked(self):
+        """ close button clicked slot """
+        self.closedSignal.emit()
+        self.hide()
+
+    def __fadeOut(self):
+        """ fade out """
+        self.rotateTimer.stop()
+        self.animation.setDuration(200)
+        self.animation.setStartValue(1)
+        self.animation.setEndValue(0)
+        self.animation.finished.connect(self.deleteLater)
+        self.animation.start()
+
+    def __rotateTimerFlowSlot(self):
+        """ rotate timer time out slot """
+        self.rotateAngle = (self.rotateAngle + self.deltaAngle) % 360
+        self.update()
+
+    def getSuitablePos(self):
+        """ get suitable position in main window """
+        for i in range(10):
+            dy = i*(self.height() + 16)
+            pos = QPoint(self.parent().width() - self.width() - 24, 50+dy)
+            widget = self.parent().childAt(pos + QPoint(2, 2))
+            if isinstance(widget, StateToolTip):
+                pos += QPoint(0, self.height() + 16)
+            else:
+                break
+
+        return pos
+
+    def paintEvent(self, e):
+        """ paint state tooltip """
+        super().paintEvent(e)
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.Antialiasing)
+        painter.setPen(Qt.NoPen)
+        theme = Theme.DARK if not isDarkTheme() else Theme.LIGHT
+
+        if not self.isDone:
+            painter.translate(19, 18)
+            painter.rotate(self.rotateAngle)
+            FIF.SYNC.render(painter, QRectF(-8, -8, 16, 16), theme)
+        else:
+            FIF.COMPLETED.render(painter, QRectF(11, 10, 16, 16), theme)
+

fastuiwidgets/components/widgets/switch_button.py

@@ -0,0 +1,312 @@
+# coding: utf-8
+from enum import Enum
+
+from PySide6.QtCore import Qt, QTimer, Property, Signal, QEvent, QPoint, QPropertyAnimation, QEasingCurve
+from PySide6.QtGui import QColor, QPainter, QHoverEvent
+from PySide6.QtWidgets import QApplication, QHBoxLayout, QLabel, QToolButton, QWidget
+
+from ...common.style_sheet import FluentStyleSheet, themeColor, ThemeColor, isDarkTheme, setCustomStyleSheet
+from ...common.overload import singledispatchmethod
+from ...common.color import fallbackThemeColor, validColor
+from .button import ToolButton
+
+
+class Indicator(ToolButton):
+    """ Indicator of switch button """
+
+    checkedChanged = Signal(bool)
+
+    def __init__(self, parent):
+        super().__init__(parent=parent)
+        self.setCheckable(True)
+        self.setFixedSize(42, 22)
+        self.lightCheckedColor = QColor()
+        self.darkCheckedColor = QColor()
+
+        self._sliderX = 5
+        self.slideAni = QPropertyAnimation(self, b'sliderX', self)
+        self.slideAni.setDuration(120)
+
+        self.toggled.connect(self._toggleSlider)
+
+    def mouseReleaseEvent(self, e):
+        """ toggle checked state when mouse release"""
+        super().mouseReleaseEvent(e)
+        self.checkedChanged.emit(self.isChecked())
+
+    def _toggleSlider(self):
+        self.slideAni.setEndValue(25 if self.isChecked() else 5)
+        self.slideAni.start()
+
+    def toggle(self):
+        self.setChecked(not self.isChecked())
+
+    def setDown(self, isDown: bool):
+        self.isPressed = isDown
+        super().setDown(isDown)
+
+    def setHover(self, isHover: bool):
+        self.isHover = isHover
+        self.update()
+
+    def setCheckedColor(self, light, dark):
+        self.lightCheckedColor = QColor(light)
+        self.darkCheckedColor = QColor(dark)
+        self.update()
+
+    def paintEvent(self, e):
+        """ paint indicator """
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.Antialiasing)
+        self._drawBackground(painter)
+        self._drawCircle(painter)
+
+    def _drawBackground(self, painter: QPainter):
+        r = self.height() / 2
+        painter.setPen(self._borderColor())
+        painter.setBrush(self._backgroundColor())
+        painter.drawRoundedRect(self.rect().adjusted(1, 1, -1, -1), r, r)
+
+    def _drawCircle(self, painter: QPainter):
+        painter.setPen(Qt.NoPen)
+        painter.setBrush(self._sliderColor())
+        painter.drawEllipse(int(self.sliderX), 5, 12, 12)
+
+    def _backgroundColor(self):
+        isDark = isDarkTheme()
+
+        if self.isChecked():
+            color = self.darkCheckedColor if isDark else self.lightCheckedColor
+            if not self.isEnabled():
+                return QColor(255, 255, 255, 41) if isDark else QColor(0, 0, 0, 56)
+            if self.isPressed:
+                return validColor(color, ThemeColor.LIGHT_2.color())
+            elif self.isHover:
+                return validColor(color, ThemeColor.LIGHT_1.color())
+
+            return fallbackThemeColor(color)
+        else:
+            if not self.isEnabled():
+                return QColor(0, 0, 0, 0)
+            if self.isPressed:
+                return QColor(255, 255, 255, 18) if isDark else QColor(0, 0, 0, 23)
+            elif self.isHover:
+                return QColor(255, 255, 255, 10) if isDark else QColor(0, 0, 0, 15)
+
+            return QColor(0, 0, 0, 0)
+
+    def _borderColor(self):
+        isDark = isDarkTheme()
+
+        if self.isChecked():
+            return self._backgroundColor() if self.isEnabled() else QColor(0, 0, 0, 0)
+        else:
+            if self.isEnabled():
+                return QColor(255, 255, 255, 153) if isDark else QColor(0, 0, 0, 133)
+
+            return QColor(255, 255, 255, 41) if isDark else QColor(0, 0, 0, 56)
+
+    def _sliderColor(self):
+        isDark = isDarkTheme()
+
+        if self.isChecked():
+            if self.isEnabled():
+                return QColor(Qt.black if isDark else Qt.white)
+
+            return QColor(255, 255, 255, 77) if isDark else QColor(255, 255, 255)
+        else:
+            if self.isEnabled():
+                return QColor(255, 255, 255, 201) if isDark else QColor(0, 0, 0, 156)
+
+            return QColor(255, 255, 255, 96) if isDark else QColor(0, 0, 0, 91)
+
+    def getSliderX(self):
+        return self._sliderX
+
+    def setSliderX(self, x):
+        self._sliderX = max(x, 5)
+        self.update()
+
+    sliderX = Property(float, getSliderX, setSliderX)
+
+
+class IndicatorPosition(Enum):
+    """ Indicator position """
+    LEFT = 0
+    RIGHT = 1
+
+
+class SwitchButton(QWidget):
+    """ Switch button class
+
+    Constructors
+    ------------
+    * SwitchButton(`parent`: QWidget = None)
+    * SwitchButton(`text`: str = "Off", `parent`: QWidget = None, `indicatorPos`=IndicatorPosition.LEFT)
+    """
+
+    checkedChanged = Signal(bool)
+
+    @singledispatchmethod
+    def __init__(self, parent: QWidget = None, indicatorPos=IndicatorPosition.LEFT):
+        """
+        Parameters
+        ----------
+        parent: QWidget
+            parent widget
+
+        indicatorPosition: IndicatorPosition
+            the position of indicator
+        """
+        super().__init__(parent=parent)
+        self._text = self.tr('Off')
+        self._offText =  self.tr('Off')
+        self._onText =  self.tr('On')
+        self.__spacing = 12
+        self.lightTextColor = QColor(0, 0, 0)
+        self.darkTextColor = QColor(255, 255, 255)
+
+        self.indicatorPos = indicatorPos
+        self.hBox = QHBoxLayout(self)
+        self.indicator = Indicator(self)
+        self.label = QLabel(self._text, self)
+
+        self.__initWidget()
+
+    @__init__.register
+    def _(self, text: str = 'Off', parent: QWidget = None, indicatorPos=IndicatorPosition.LEFT):
+        """
+        Parameters
+        ----------
+        text: str
+            the text of switch button
+
+        parent: QWidget
+            parent widget
+
+        indicatorPosition: IndicatorPosition
+            the position of indicator
+        """
+        self.__init__(parent, indicatorPos)
+        self._offText = text
+        self.setText(text)
+
+    def __initWidget(self):
+        """ initialize widgets """
+        self.setAttribute(Qt.WA_StyledBackground)
+        self.installEventFilter(self)
+        self.setFixedHeight(22)
+
+        # set layout
+        self.hBox.setSpacing(self.__spacing)
+        self.hBox.setContentsMargins(2, 0, 0, 0)
+
+        if self.indicatorPos == IndicatorPosition.LEFT:
+            self.hBox.addWidget(self.indicator)
+            self.hBox.addWidget(self.label)
+            self.hBox.setAlignment(Qt.AlignLeft)
+        else:
+            self.hBox.addWidget(self.label, 0, Qt.AlignRight)
+            self.hBox.addWidget(self.indicator, 0, Qt.AlignRight)
+            self.hBox.setAlignment(Qt.AlignRight)
+
+        # set default style sheet
+        FluentStyleSheet.SWITCH_BUTTON.apply(self)
+        FluentStyleSheet.SWITCH_BUTTON.apply(self.label)
+
+        # connect signal to slot
+        self.indicator.toggled.connect(self._updateText)
+        self.indicator.toggled.connect(self.checkedChanged)
+
+    def eventFilter(self, obj, e: QEvent):
+        if obj is self and self.isEnabled():
+            if e.type() == QEvent.MouseButtonPress:
+                self.indicator.setDown(True)
+            elif e.type() == QEvent.MouseButtonRelease:
+                self.indicator.setDown(False)
+                self.indicator.toggle()
+            elif e.type() == QEvent.Enter:
+                self.indicator.setHover(True)
+            elif e.type() == QEvent.Leave:
+                self.indicator.setHover(False)
+
+        return super().eventFilter(obj, e)
+
+    def isChecked(self):
+        return self.indicator.isChecked()
+
+    def setChecked(self, isChecked):
+        """ set checked state """
+        self._updateText()
+        self.indicator.setChecked(isChecked)
+
+    def setTextColor(self, light, dark):
+        """ set the color of text
+
+        Parameters
+        ----------
+        light, dark: str | QColor | Qt.GlobalColor
+            text color in light/dark theme mode
+        """
+        self.lightTextColor = QColor(light)
+        self.darkTextColor = QColor(dark)
+
+        setCustomStyleSheet(
+            self.label,
+            f"SwitchButton>QLabel{{color:{self.lightTextColor.name(QColor.NameFormat.HexArgb)}}}",
+            f"SwitchButton>QLabel{{color:{self.darkTextColor.name(QColor.NameFormat.HexArgb)}}}"
+        )
+
+    def setCheckedIndicatorColor(self, light, dark):
+        """ set the color of indicator in checked status
+
+        Parameters
+        ----------
+        light, dark: str | QColor | Qt.GlobalColor
+            border color in light/dark theme mode
+        """
+        self.indicator.setCheckedColor(light, dark)
+
+    def toggleChecked(self):
+        """ toggle checked state """
+        self.indicator.setChecked(not self.indicator.isChecked())
+
+    def _updateText(self):
+        self.setText(self.onText if self.isChecked() else self.offText)
+        self.adjustSize()
+
+    def getText(self):
+        return self._text
+
+    def setText(self, text):
+        self._text = text
+        self.label.setText(text)
+        self.adjustSize()
+
+    def getSpacing(self):
+        return self.__spacing
+
+    def setSpacing(self, spacing):
+        self.__spacing = spacing
+        self.hBox.setSpacing(spacing)
+        self.update()
+
+    def getOnText(self):
+        return self._onText
+
+    def setOnText(self, text):
+        self._onText = text
+        self._updateText()
+
+    def getOffText(self):
+        return self._offText
+
+    def setOffText(self, text):
+        self._offText = text
+        self._updateText()
+
+    spacing = Property(int, getSpacing, setSpacing)
+    checked = Property(bool, isChecked, setChecked)
+    text = Property(str, getText, setText)
+    onText = Property(str, getOnText, setOnText)
+    offText = Property(str, getOffText, setOffText)