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

fastuiwidgets/components/widgets/slider.py

@@ -0,0 +1,307 @@
+# coding:utf-8
+from PySide6.QtCore import QSize, Qt, Signal, QPoint, QRectF, QPropertyAnimation, Property, QEasingCurve
+from PySide6.QtGui import QColor, QMouseEvent, QPainter, QPainterPath
+from PySide6.QtWidgets import QProxyStyle, QSlider, QStyle, QStyleOptionSlider, QWidget
+
+from ...common.style_sheet import FluentStyleSheet, themeColor, isDarkTheme
+from ...common.color import autoFallbackThemeColor
+from ...common.overload import singledispatchmethod
+
+
+
+class SliderHandle(QWidget):
+    """ Slider handle """
+
+    pressed = Signal()
+    released = Signal()
+
+    def __init__(self, parent: QSlider):
+        super().__init__(parent=parent)
+        self.setFixedSize(22, 22)
+        self._radius = 5
+        self.lightHandleColor = QColor()
+        self.darkHandleColor = QColor()
+        self.radiusAni = QPropertyAnimation(self, b'radius', self)
+        self.radiusAni.setDuration(100)
+
+    @Property(int)
+    def radius(self):
+        return self._radius
+
+    @radius.setter
+    def radius(self, r):
+        self._radius = r
+        self.update()
+
+    def setHandleColor(self, light, dark):
+        self.lightHandleColor = QColor(light)
+        self.darkHandleColor = QColor(dark)
+        self.update()
+
+    def enterEvent(self, e):
+        self._startAni(6)
+
+    def leaveEvent(self, e):
+        self._startAni(5)
+
+    def mousePressEvent(self, e):
+        self._startAni(4)
+        self.pressed.emit()
+
+    def mouseReleaseEvent(self, e):
+        self._startAni(6)
+        self.released.emit()
+
+    def _startAni(self, radius):
+        self.radiusAni.stop()
+        self.radiusAni.setStartValue(self.radius)
+        self.radiusAni.setEndValue(radius)
+        self.radiusAni.start()
+
+    def paintEvent(self, e):
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.RenderHint.Antialiasing)
+        painter.setPen(Qt.PenStyle.NoPen)
+
+        # draw outer circle
+        isDark = isDarkTheme()
+        painter.setPen(QColor(0, 0, 0, 90 if isDark else 25))
+        painter.setBrush(QColor(69, 69, 69) if isDark else Qt.GlobalColor.white)
+        painter.drawEllipse(self.rect().adjusted(1, 1, -1, -1))
+
+        # draw innert circle
+        painter.setBrush(autoFallbackThemeColor(self.lightHandleColor, self.darkHandleColor))
+        painter.drawEllipse(QPoint(11, 11), self.radius, self.radius)
+
+
+
+class Slider(QSlider):
+    """ A slider can be clicked
+
+    Constructors
+    ------------
+    * Slider(`parent`: QWidget = None)
+    * Slider(`orient`: Qt.Orientation, `parent`: QWidget = None)
+    """
+
+    clicked = Signal(int)
+
+    @singledispatchmethod
+    def __init__(self, parent: QWidget = None):
+        super().__init__(parent)
+        self._postInit()
+
+    @__init__.register
+    def _(self, orientation: Qt.Orientation, parent: QWidget = None):
+        super().__init__(orientation, parent=parent)
+        self._postInit()
+
+    def _postInit(self):
+        self.handle = SliderHandle(self)
+        self._pressedPos = QPoint()
+        self.lightGrooveColor = QColor()
+        self.darkGrooveColor = QColor()
+        self.setOrientation(self.orientation())
+
+        self.handle.pressed.connect(self.sliderPressed)
+        self.handle.released.connect(self.sliderReleased)
+        self.valueChanged.connect(self._adjustHandlePos)
+
+    def setThemeColor(self, light, dark):
+        self.lightGrooveColor = QColor(light)
+        self.darkGrooveColor = QColor(dark)
+        self.handle.setHandleColor(light, dark)
+        self.update()
+
+    def setOrientation(self, orientation: Qt.Orientation) -> None:
+        super().setOrientation(orientation)
+        if orientation == Qt.Orientation.Horizontal:
+            self.setMinimumHeight(22)
+        else:
+            self.setMinimumWidth(22)
+
+    def mousePressEvent(self, e: QMouseEvent):
+        self._pressedPos = e.pos()
+        self.setValue(self._posToValue(e.pos()))
+        self.clicked.emit(self.value())
+
+    def mouseMoveEvent(self, e: QMouseEvent):
+        self.setValue(self._posToValue(e.pos()))
+        self._pressedPos = e.pos()
+        self.sliderMoved.emit(self.value())
+
+    @property
+    def grooveLength(self):
+        l = self.width() if self.orientation() == Qt.Orientation.Horizontal else self.height()
+        return l - self.handle.width()
+
+    def _adjustHandlePos(self):
+        total = max(self.maximum() - self.minimum(), 1)
+        delta = int((self.value() - self.minimum()) / total * self.grooveLength)
+
+        if self.orientation() == Qt.Orientation.Vertical:
+            self.handle.move(0, delta)
+        else:
+            self.handle.move(delta, 0)
+
+    def _posToValue(self, pos: QPoint):
+        pd = self.handle.width() / 2
+        gs = max(self.grooveLength, 1)
+        v = pos.x() if self.orientation() == Qt.Orientation.Horizontal else pos.y()
+        return int((v - pd) / gs * (self.maximum() - self.minimum()) + self.minimum())
+
+    def paintEvent(self, e):
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.RenderHint.Antialiasing)
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(QColor(255, 255, 255, 115) if isDarkTheme() else QColor(0, 0, 0, 100))
+
+        if self.orientation() == Qt.Orientation.Horizontal:
+            self._drawHorizonGroove(painter)
+        else:
+            self._drawVerticalGroove(painter)
+
+    def _drawHorizonGroove(self, painter: QPainter):
+        w, r = self.width(), self.handle.width() / 2
+        painter.drawRoundedRect(QRectF(r, r-2, w-r*2, 4), 2, 2)
+
+        if self.maximum() - self.minimum() == 0:
+            return
+
+        painter.setBrush(autoFallbackThemeColor(self.lightGrooveColor, self.darkGrooveColor))
+        aw = (self.value() - self.minimum()) / (self.maximum() - self.minimum()) * (w - r*2)
+        painter.drawRoundedRect(QRectF(r, r-2, aw, 4), 2, 2)
+
+    def _drawVerticalGroove(self, painter: QPainter):
+        h, r = self.height(), self.handle.width() / 2
+        painter.drawRoundedRect(QRectF(r-2, r, 4, h-2*r), 2, 2)
+
+        if self.maximum() - self.minimum() == 0:
+            return
+
+        painter.setBrush(autoFallbackThemeColor(self.lightGrooveColor, self.darkGrooveColor))
+        ah = (self.value() - self.minimum()) / (self.maximum() - self.minimum()) * (h - r*2)
+        painter.drawRoundedRect(QRectF(r-2, r, 4, ah), 2, 2)
+
+    def resizeEvent(self, e):
+        self._adjustHandlePos()
+
+
+class ClickableSlider(QSlider):
+    """ A slider can be clicked """
+
+    clicked = Signal(int)
+
+    def mousePressEvent(self, e: QMouseEvent):
+        super().mousePressEvent(e)
+
+        if self.orientation() == Qt.Horizontal:
+            value = int(e.pos().x() / self.width() * self.maximum())
+        else:
+            value = int((self.height()-e.pos().y()) /
+                        self.height() * self.maximum())
+
+        self.setValue(value)
+        self.clicked.emit(self.value())
+
+
+
+class HollowHandleStyle(QProxyStyle):
+    """ Hollow handle style """
+
+    def __init__(self, config: dict = None):
+        """
+        Parameters
+        ----------
+        config: dict
+            style config
+        """
+        super().__init__()
+        self.config = {
+            "groove.height": 3,
+            "sub-page.color": QColor(255, 255, 255),
+            "add-page.color": QColor(255, 255, 255, 64),
+            "handle.color": QColor(255, 255, 255),
+            "handle.ring-width": 4,
+            "handle.hollow-radius": 6,
+            "handle.margin": 4
+        }
+        config = config if config else {}
+        self.config.update(config)
+
+        # get handle size
+        w = self.config["handle.margin"]+self.config["handle.ring-width"] + \
+            self.config["handle.hollow-radius"]
+        self.config["handle.size"] = QSize(2*w, 2*w)
+
+    def subControlRect(self, cc: QStyle.ComplexControl, opt: QStyleOptionSlider, sc: QStyle.SubControl, widget: QSlider):
+        """ get the rectangular area occupied by the sub control """
+        if cc != self.ComplexControl.CC_Slider or widget.orientation() != Qt.Horizontal \
+                or sc == self.SubControl.SC_SliderTickmarks:
+            return super().subControlRect(cc, opt, sc, widget)
+
+        rect = widget.rect()
+
+        if sc == self.SubControl.SC_SliderGroove:
+            h = self.config["groove.height"]
+            grooveRect = QRectF(0, (rect.height()-h)//2, rect.width(), h)
+            return grooveRect.toRect()
+
+        elif sc == self.SubControl.SC_SliderHandle:
+            size = self.config["handle.size"]
+            x = self.sliderPositionFromValue(
+                widget.minimum(), widget.maximum(), widget.value(), rect.width())
+
+            # solve the situation that the handle runs out of slider
+            x *= (rect.width()-size.width())/rect.width()
+            sliderRect = QRectF(x, 0, size.width(), size.height())
+            return sliderRect.toRect()
+
+    def drawComplexControl(self, cc: QStyle.ComplexControl, opt: QStyleOptionSlider, painter: QPainter, widget: QSlider):
+        """ draw sub control """
+        if cc != self.ComplexControl.CC_Slider or widget.orientation() != Qt.Horizontal:
+            return super().drawComplexControl(cc, opt, painter, widget)
+
+        grooveRect = self.subControlRect(cc, opt, self.SubControl.SC_SliderGroove, widget)
+        handleRect = self.subControlRect(cc, opt, self.SubControl.SC_SliderHandle, widget)
+        painter.setRenderHints(QPainter.Antialiasing)
+        painter.setPen(Qt.NoPen)
+
+        # paint groove
+        painter.save()
+        painter.translate(grooveRect.topLeft())
+
+        # paint the crossed part
+        w = handleRect.x()-grooveRect.x()
+        h = self.config['groove.height']
+        painter.setBrush(self.config["sub-page.color"])
+        painter.drawRect(0, 0, w, h)
+
+        # paint the uncrossed part
+        x = w+self.config['handle.size'].width()
+        painter.setBrush(self.config["add-page.color"])
+        painter.drawRect(x, 0, grooveRect.width()-w, h)
+        painter.restore()
+
+        # paint handle
+        ringWidth = self.config["handle.ring-width"]
+        hollowRadius = self.config["handle.hollow-radius"]
+        radius = ringWidth + hollowRadius
+
+        path = QPainterPath()
+        path.moveTo(0, 0)
+        center = handleRect.center() + QPoint(1, 1)
+        path.addEllipse(center, radius, radius)
+        path.addEllipse(center, hollowRadius, hollowRadius)
+
+        handleColor = self.config["handle.color"]  # type:QColor
+        handleColor.setAlpha(255 if opt.activeSubControls !=
+                             self.SubControl.SC_SliderHandle else 153)
+        painter.setBrush(handleColor)
+        painter.drawPath(path)
+
+        # press handle
+        if widget.isSliderDown():
+            handleColor.setAlpha(255)
+            painter.setBrush(handleColor)
+            painter.drawEllipse(handleRect)

fastuiwidgets/components/widgets/spin_box.py

@@ -0,0 +1,306 @@
+# coding:utf-8
+from enum import Enum
+
+from PySide6.QtCore import Qt, QSize, QRectF, QPoint
+from PySide6.QtGui import QPainter, QPainterPath, QColor
+from PySide6.QtWidgets import (QSpinBox, QDoubleSpinBox, QToolButton, QHBoxLayout,
+                               QDateEdit, QDateTimeEdit, QTimeEdit, QVBoxLayout, QApplication)
+
+from ...common.style_sheet import FluentStyleSheet, themeColor, isDarkTheme
+from ...common.icon import FluentIconBase, Theme, getIconColor
+from ...common.font import setFont
+from ...common.color import FluentSystemColor, autoFallbackThemeColor
+from .button import TransparentToolButton
+from .line_edit import LineEditMenu
+from .flyout import Flyout, FlyoutViewBase, FlyoutAnimationType
+
+
+class SpinIcon(FluentIconBase, Enum):
+    """ Spin icon """
+
+    UP = "Up"
+    DOWN = "Down"
+
+    def path(self, theme=Theme.AUTO):
+        return f':/fastuiwidgets/images/spin_box/{self.value}_{getIconColor(theme)}.svg'
+
+
+
+class SpinButton(QToolButton):
+
+    def __init__(self, icon: SpinIcon, parent=None):
+        super().__init__(parent=parent)
+        self.isPressed = False
+        self._icon = icon
+        self.setFixedSize(31, 23)
+        self.setIconSize(QSize(10, 10))
+        FluentStyleSheet.SPIN_BOX.apply(self)
+
+    def mousePressEvent(self, e):
+        self.isPressed = True
+        super().mousePressEvent(e)
+
+    def mouseReleaseEvent(self, e):
+        self.isPressed = False
+        super().mouseReleaseEvent(e)
+
+    def paintEvent(self, e):
+        super().paintEvent(e)
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.Antialiasing |
+                               QPainter.SmoothPixmapTransform)
+
+        if not self.isEnabled():
+            painter.setOpacity(0.36)
+        elif self.isPressed:
+            painter.setOpacity(0.7)
+
+        self._icon.render(painter, QRectF(10, 6.5, 11, 11))
+
+
+class CompactSpinButton(QToolButton):
+    """ Compact spin button """
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self.setFixedSize(26, 33)
+        self.setCursor(Qt.IBeamCursor)
+
+    def paintEvent(self, e):
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.Antialiasing)
+
+        x = (self.width() - 10) / 2
+        s = 9
+
+        SpinIcon.UP.render(painter, QRectF(x, self.height() / 2 - s + 1, s, s))
+        SpinIcon.DOWN.render(painter, QRectF(x, self.height() / 2 , s, s))
+
+
+class SpinFlyoutView(FlyoutViewBase):
+    """ Spin flyout view """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.upButton = TransparentToolButton(SpinIcon.UP, self)
+        self.downButton = TransparentToolButton(SpinIcon.DOWN, self)
+        self.vBoxLayout = QVBoxLayout(self)
+
+        self.upButton.setFixedSize(36, 36)
+        self.downButton.setFixedSize(36, 36)
+        self.upButton.setIconSize(QSize(13, 13))
+        self.downButton.setIconSize(QSize(13, 13))
+
+        self.vBoxLayout.setContentsMargins(6, 6, 6, 6)
+        self.vBoxLayout.setSpacing(0)
+        self.vBoxLayout.addWidget(self.upButton)
+        self.vBoxLayout.addWidget(self.downButton)
+
+    def paintEvent(self, e):
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.Antialiasing)
+
+        painter.setBrush(
+            QColor(46, 46, 46) if isDarkTheme() else QColor(249, 249, 249))
+        painter.setPen(
+            QColor(0, 0, 0, 51) if isDarkTheme() else QColor(0, 0, 0, 15))
+
+        rect = self.rect().adjusted(1, 1, -1, -1)
+        painter.drawRoundedRect(rect, 8, 8)
+
+
+class SpinBoxBase:
+    """ Spin box ui """
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self._isError = False
+        self.lightFocusedBorderColor = QColor()
+        self.darkFocusedBorderColor = QColor()
+
+        self.hBoxLayout = QHBoxLayout(self)
+
+        self.setProperty('transparent', True)
+        FluentStyleSheet.SPIN_BOX.apply(self)
+        self.setButtonSymbols(QSpinBox.NoButtons)
+        self.setFixedHeight(33)
+        setFont(self)
+
+        self.setAttribute(Qt.WA_MacShowFocusRect, False)
+        self.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.customContextMenuRequested.connect(self._showContextMenu)
+
+    def isError(self):
+        return self._isError
+
+    def setError(self, isError: bool):
+        """ set the error status """
+        if isError == self.isError():
+            return
+
+        self._isError = isError
+        self.update()
+
+    def setReadOnly(self, isReadOnly: bool):
+        super().setReadOnly(isReadOnly)
+        self.setSymbolVisible(not isReadOnly)
+
+    def setSymbolVisible(self, isVisible: bool):
+        """ set whether the spin symbol is visible """
+        self.setProperty("symbolVisible", isVisible)
+        self.setStyle(QApplication.style())
+
+    def setCustomFocusedBorderColor(self, light, dark):
+        """ set the border color in focused status
+
+        Parameters
+        ----------
+        light, dark: str | QColor | Qt.GlobalColor
+            border color in light/dark theme mode
+        """
+        self.lightFocusedBorderColor = QColor(light)
+        self.darkFocusedBorderColor = QColor(dark)
+        self.update()
+
+    def focusedBorderColor(self):
+        if self.isError():
+            return FluentSystemColor.CRITICAL_FOREGROUND.color()
+
+        return autoFallbackThemeColor(self.lightFocusedBorderColor, self.darkFocusedBorderColor)
+
+    def _showContextMenu(self, pos):
+        menu = LineEditMenu(self.lineEdit())
+        menu.exec_(self.mapToGlobal(pos))
+
+    def _drawBorderBottom(self):
+        if not self.hasFocus():
+            return
+
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.Antialiasing)
+        painter.setPen(Qt.NoPen)
+
+        path = QPainterPath()
+        w, h = self.width(), self.height()
+        path.addRoundedRect(QRectF(0, h-10, w, 10), 5, 5)
+
+        rectPath = QPainterPath()
+        rectPath.addRect(0, h-10, w, 8)
+        path = path.subtracted(rectPath)
+
+        painter.fillPath(path, self.focusedBorderColor())
+
+    def paintEvent(self, e):
+        super().paintEvent(e)
+        self._drawBorderBottom()
+
+
+class InlineSpinBoxBase(SpinBoxBase):
+    """ Inline spin box base """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.upButton = SpinButton(SpinIcon.UP, self)
+        self.downButton = SpinButton(SpinIcon.DOWN, self)
+
+        self.hBoxLayout.setContentsMargins(0, 4, 4, 4)
+        self.hBoxLayout.setSpacing(5)
+        self.hBoxLayout.addWidget(self.upButton, 0, Qt.AlignRight)
+        self.hBoxLayout.addWidget(self.downButton, 0, Qt.AlignRight)
+        self.hBoxLayout.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+
+        self.upButton.clicked.connect(self.stepUp)
+        self.downButton.clicked.connect(self.stepDown)
+
+    def setSymbolVisible(self, isVisible: bool):
+        super().setSymbolVisible(isVisible)
+        self.upButton.setVisible(isVisible)
+        self.downButton.setVisible(isVisible)
+
+    def setAccelerated(self, on: bool):
+        super().setAccelerated(on)
+        self.upButton.setAutoRepeat(on)
+        self.downButton.setAutoRepeat(on)
+
+
+class CompactSpinBoxBase(SpinBoxBase):
+    """ Compact spin box base """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.compactSpinButton = CompactSpinButton(self)
+        self.spinFlyoutView = SpinFlyoutView(self)
+        self.spinFlyout = Flyout(self.spinFlyoutView, self, False)
+
+        self.hBoxLayout.setContentsMargins(0, 0, 0, 0)
+        self.hBoxLayout.addWidget(self.compactSpinButton, 0, Qt.AlignRight)
+        self.hBoxLayout.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+
+        self.compactSpinButton.clicked.connect(self._showFlyout)
+        self.spinFlyoutView.upButton.clicked.connect(self.stepUp)
+        self.spinFlyoutView.downButton.clicked.connect(self.stepDown)
+
+        self.spinFlyout.hide()
+
+    def setAccelerated(self, on: bool):
+        super().setAccelerated(on)
+        self.spinFlyoutView.upButton.setAutoRepeat(on)
+        self.spinFlyoutView.downButton.setAutoRepeat(on)
+
+    def focusInEvent(self, e):
+        super().focusInEvent(e)
+        self._showFlyout()
+
+    def setSymbolVisible(self, isVisible: bool):
+        super().setSymbolVisible(isVisible)
+        self.compactSpinButton.setVisible(isVisible)
+
+    def _showFlyout(self):
+        if self.spinFlyout.isVisible() or self.isReadOnly():
+            return
+
+        y = int(self.compactSpinButton.height() / 2 - 46)
+        pos = self.compactSpinButton.mapToGlobal(QPoint(-12, y))
+
+        self.spinFlyout.exec(pos, FlyoutAnimationType.FADE_IN)
+
+
+class SpinBox(InlineSpinBoxBase, QSpinBox):
+    """ Spin box """
+
+
+class CompactSpinBox(CompactSpinBoxBase, QSpinBox):
+    """ Compact spin box """
+
+
+class DoubleSpinBox(InlineSpinBoxBase, QDoubleSpinBox):
+    """ Double spin box """
+
+
+class CompactDoubleSpinBox(CompactSpinBoxBase, QDoubleSpinBox):
+    """ Compact double spin box """
+
+
+class TimeEdit(InlineSpinBoxBase, QTimeEdit):
+    """ Time edit """
+
+
+class CompactTimeEdit(CompactSpinBoxBase, QTimeEdit):
+    """ Compact time edit """
+
+
+class DateTimeEdit(InlineSpinBoxBase, QDateTimeEdit):
+    """ Date time edit """
+
+
+class CompactDateTimeEdit(CompactSpinBoxBase, QDateTimeEdit):
+    """ Compact date time edit """
+
+
+class DateEdit(InlineSpinBoxBase, QDateEdit):
+    """ Date edit """
+
+
+class CompactDateEdit(CompactSpinBoxBase, QDateEdit):
+    """ Compact date edit """
+