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

fastuiwidgets/components/dialog_box/message_dialog.py

@@ -0,0 +1,65 @@
+# coding:utf-8
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import QLabel, QPushButton, QDialog
+
+from ...common.auto_wrap import TextWrap
+from ...common.style_sheet import FluentStyleSheet
+from .mask_dialog_base import MaskDialogBase
+
+
+class MessageDialog(MaskDialogBase):
+    """ Win10 style message dialog box with a mask """
+
+    yesSignal = Signal()
+    cancelSignal = Signal()
+
+    def __init__(self, title: str, content: str, parent):
+        super().__init__(parent=parent)
+        self.content = content
+        self.titleLabel = QLabel(title, self.widget)
+        self.contentLabel = QLabel(content, self.widget)
+        self.yesButton = QPushButton(self.tr('OK'), self.widget)
+        self.cancelButton = QPushButton(self.tr('Cancel'), self.widget)
+        self.__initWidget()
+
+    def __initWidget(self):
+        """ initialize widgets """
+        self.windowMask.resize(self.size())
+        self.widget.setMaximumWidth(540)
+        self.titleLabel.move(24, 24)
+        self.contentLabel.move(24, 56)
+        self.contentLabel.setText(TextWrap.wrap(self.content, 71)[0])
+
+        self.__setQss()
+        self.__initLayout()
+
+        # connect signal to slot
+        self.yesButton.clicked.connect(self.__onYesButtonClicked)
+        self.cancelButton.clicked.connect(self.__onCancelButtonClicked)
+
+    def __initLayout(self):
+        """ initialize layout """
+        self.contentLabel.adjustSize()
+        self.widget.setFixedSize(48+self.contentLabel.width(),
+                                 self.contentLabel.y() + self.contentLabel.height()+92)
+        self.yesButton.resize((self.widget.width() - 54) // 2, 32)
+        self.cancelButton.resize(self.yesButton.width(), 32)
+        self.yesButton.move(24, self.widget.height()-56)
+        self.cancelButton.move(
+            self.widget.width()-24-self.cancelButton.width(), self.widget.height()-56)
+
+    def __onCancelButtonClicked(self):
+        self.cancelSignal.emit()
+        self.reject()
+
+    def __onYesButtonClicked(self):
+        self.setEnabled(False)
+        self.yesSignal.emit()
+        self.accept()
+
+    def __setQss(self):
+        """ set style sheet """
+        self.windowMask.setObjectName('windowMask')
+        self.titleLabel.setObjectName('titleLabel')
+        self.contentLabel.setObjectName('contentLabel')
+        FluentStyleSheet.MESSAGE_DIALOG.apply(self)

fastuiwidgets/components/layout/__init__.py

@@ -0,0 +1,3 @@
+from .expand_layout import ExpandLayout
+from .flow_layout import FlowLayout
+from .v_box_layout import VBoxLayout

fastuiwidgets/components/layout/expand_layout.py

@@ -0,0 +1,96 @@
+# coding:utf-8
+from PySide6.QtCore import QSize, QPoint, Qt, QEvent, QRect
+from PySide6.QtGui import QResizeEvent
+from PySide6.QtWidgets import QLayout, QWidget
+
+
+class ExpandLayout(QLayout):
+    """ Expand layout """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.__items = []
+        self.__widgets = []
+
+    def addWidget(self, widget: QWidget):
+        if widget in self.__widgets:
+            return
+
+        self.__widgets.append(widget)
+        widget.installEventFilter(self)
+
+    def addItem(self, item):
+        self.__items.append(item)
+
+    def count(self):
+        return len(self.__items)
+
+    def itemAt(self, index):
+        if 0 <= index < len(self.__items):
+            return self.__items[index]
+
+        return None
+
+    def takeAt(self, index):
+        if 0 <= index < len(self.__items):
+            self.__widgets.pop(index)
+            return self.__items.pop(index)
+
+        return None
+
+    def expandingDirections(self):
+        return Qt.Vertical
+
+    def hasHeightForWidth(self):
+        return True
+
+    def heightForWidth(self, width):
+        """ get the minimal height according to width """
+        return self.__doLayout(QRect(0, 0, width, 0), False)
+
+    def setGeometry(self, rect):
+        super().setGeometry(rect)
+        self.__doLayout(rect, True)
+
+    def sizeHint(self):
+        return self.minimumSize()
+
+    def minimumSize(self):
+        size = QSize()
+
+        for w in self.__widgets:
+            size = size.expandedTo(w.minimumSize())
+
+        m = self.contentsMargins()
+        size += QSize(m.left()+m.right(), m.top()+m.bottom())
+
+        return size
+
+    def __doLayout(self, rect, move):
+        """ adjust widgets position according to the window size """
+        margin = self.contentsMargins()
+        x = rect.x() + margin.left()
+        y = rect.y() + margin.top()
+        width = rect.width() - margin.left() - margin.right()
+
+        for i, w in enumerate(self.__widgets):
+            if w.isHidden():
+                continue
+
+            y += (i>0)*self.spacing()
+            if move:
+                w.setGeometry(QRect(QPoint(x, y), QSize(width, w.height())))
+
+            y += w.height()
+
+        return y - rect.y()
+
+    def eventFilter(self, obj, e):
+        if obj in self.__widgets:
+            if e.type() == QEvent.Resize:
+                ds = e.size() - e.oldSize()  # type:QSize
+                if ds.height() != 0 and ds.width() == 0:
+                    w = self.parentWidget()
+                    w.resize(w.width(), w.height() + ds.height())
+
+        return super().eventFilter(obj, e)

fastuiwidgets/components/layout/flow_layout.py

@@ -0,0 +1,236 @@
+# coding:utf-8
+from typing import List
+
+from PySide6.QtCore import QSize, QPoint, Qt, QRect, QPropertyAnimation, QParallelAnimationGroup, QEasingCurve, QEvent, QTimer, QObject
+from PySide6.QtWidgets import QLayout, QWidgetItem, QLayoutItem
+
+
+class FlowLayout(QLayout):
+    """ Flow layout """
+
+    def __init__(self, parent=None, needAni=False, isTight=False):
+        """
+        Parameters
+        ----------
+        parent:
+            parent window or layout
+
+        needAni: bool
+            whether to add moving animation
+
+        isTight: bool
+            whether to use the tight layout when widgets are hidden
+        """
+        super().__init__(parent)
+        self._items = []    # type: List[QLayoutItem]
+        self._anis = []    # type: List[QPropertyAnimation]
+        self._aniGroup = QParallelAnimationGroup(self)
+        self._verticalSpacing = 10
+        self._horizontalSpacing = 10
+        self.duration = 300
+        self.ease = QEasingCurve.Linear
+        self.needAni = needAni
+        self.isTight = isTight
+        self._deBounceTimer = QTimer(self)
+        self._deBounceTimer.setSingleShot(True)
+        self._deBounceTimer.timeout.connect(lambda: self._doLayout(self.geometry(), True))
+        self._wParent = None
+        self._isInstalledEventFilter = False
+
+    def addItem(self, item):
+        self._items.append(item)
+
+    def insertItem(self, index, item):
+        self._items.insert(index, item)
+
+    def addWidget(self, w):
+        super().addWidget(w)
+        self._onWidgetAdded(w)
+
+    def insertWidget(self, index, w):
+        self.insertItem(index, QWidgetItem(w))
+        self.addChildWidget(w)
+        self._onWidgetAdded(w, index)
+
+    def _onWidgetAdded(self, w, index=-1):
+        if not self._isInstalledEventFilter:
+            if w.parent():
+                self._wParent = w.parent()
+                w.parent().installEventFilter(self)
+            else:
+                w.installEventFilter(self)
+
+        if not self.needAni:
+            return
+
+        ani = QPropertyAnimation(w, b'geometry')
+        ani.setEndValue(QRect(QPoint(0, 0), w.size()))
+        ani.setDuration(self.duration)
+        ani.setEasingCurve(self.ease)
+        w.setProperty('flowAni', ani)
+        self._aniGroup.addAnimation(ani)
+
+        if index == -1:
+            self._anis.append(ani)
+        else:
+            self._anis.insert(index, ani)
+
+    def setAnimation(self, duration, ease=QEasingCurve.Linear):
+        """ set the moving animation
+
+        Parameters
+        ----------
+        duration: int
+            the duration of animation in milliseconds
+
+        ease: QEasingCurve
+            the easing curve of animation
+        """
+        if not self.needAni:
+            return
+
+        self.duration = duration
+        self.ease = ease
+
+        for ani in self._anis:
+            ani.setDuration(duration)
+            ani.setEasingCurve(ease)
+
+    def count(self):
+        return len(self._items)
+
+    def itemAt(self, index: int):
+        if 0 <= index < len(self._items):
+            return self._items[index]
+
+        return None
+
+    def takeAt(self, index: int):
+        if 0 <= index < len(self._items):
+            item = self._items[index]   # type: QLayoutItem
+            ani = item.widget().property('flowAni')
+            if ani:
+                self._anis.remove(ani)
+                self._aniGroup.removeAnimation(ani)
+                ani.deleteLater()
+
+            return self._items.pop(index).widget()
+
+        return None
+
+    def removeWidget(self, widget):
+        for i, item in enumerate(self._items):
+            if item.widget() is widget:
+                return self.takeAt(i)
+
+    def removeAllWidgets(self):
+        """ remove all widgets from layout """
+        while self._items:
+            self.takeAt(0)
+
+    def takeAllWidgets(self):
+        """ remove all widgets from layout and delete them """
+        while self._items:
+            w = self.takeAt(0)
+            if w:
+                w.deleteLater()
+
+    def expandingDirections(self):
+        return Qt.Orientation(0)
+
+    def hasHeightForWidth(self):
+        return True
+
+    def heightForWidth(self, width: int):
+        """ get the minimal height according to width """
+        return self._doLayout(QRect(0, 0, width, 0), False)
+
+    def setGeometry(self, rect: QRect):
+        super().setGeometry(rect)
+
+        if self.needAni:
+            self._deBounceTimer.start(80)
+        else:
+            self._doLayout(rect, True)
+
+    def sizeHint(self):
+        return self.minimumSize()
+
+    def minimumSize(self):
+        size = QSize()
+
+        for item in self._items:
+            size = size.expandedTo(item.minimumSize())
+
+        m = self.contentsMargins()
+        size += QSize(m.left()+m.right(), m.top()+m.bottom())
+
+        return size
+
+    def setVerticalSpacing(self, spacing: int):
+        """ set vertical spacing between widgets """
+        self._verticalSpacing = spacing
+
+    def verticalSpacing(self):
+        """ get vertical spacing between widgets """
+        return self._verticalSpacing
+
+    def setHorizontalSpacing(self, spacing: int):
+        """ set horizontal spacing between widgets """
+        self._horizontalSpacing = spacing
+
+    def horizontalSpacing(self):
+        """ get horizontal spacing between widgets """
+        return self._horizontalSpacing
+
+    def eventFilter(self, obj: QObject, event: QEvent) -> bool:
+        if obj in [w.widget() for w in self._items] and event.type() == QEvent.Type.ParentChange:
+            self._wParent = obj.parent()
+            obj.parent().installEventFilter(self)
+            self._isInstalledEventFilter = True
+
+        if obj == self._wParent and event.type() == QEvent.Type.Show:
+            self._doLayout(self.geometry(), True)
+            self._isInstalledEventFilter = True
+
+        return super().eventFilter(obj, event)
+
+    def _doLayout(self, rect: QRect, move: bool):
+        """ adjust widgets position according to the window size """
+        aniRestart = False
+        margin = self.contentsMargins()
+        x = rect.x() + margin.left()
+        y = rect.y() + margin.top()
+        rowHeight = 0
+        spaceX = self.horizontalSpacing()
+        spaceY = self.verticalSpacing()
+
+        for i, item in enumerate(self._items):
+            if item.widget() and not item.widget().isVisible() and self.isTight:
+                continue
+
+            nextX = x + item.sizeHint().width() + spaceX
+
+            if nextX - spaceX > rect.right() - margin.right() and rowHeight > 0:
+                x = rect.x() + margin.left()
+                y = y + rowHeight + spaceY
+                nextX = x + item.sizeHint().width() + spaceX
+                rowHeight = 0
+
+            if move:
+                target = QRect(QPoint(x, y), item.sizeHint())
+                if not self.needAni:
+                    item.setGeometry(target)
+                elif target != self._anis[i].endValue():
+                    self._anis[i].stop()
+                    self._anis[i].setEndValue(target)
+                    aniRestart = True
+
+            x = nextX
+            rowHeight = max(rowHeight, item.sizeHint().height())
+
+        if self.needAni and aniRestart:
+            self._aniGroup.stop()
+            self._aniGroup.start()
+
+        return y + rowHeight + margin.bottom() - rect.y()

fastuiwidgets/components/layout/v_box_layout.py

@@ -0,0 +1,41 @@
+# coding:utf-8
+from typing import List
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QVBoxLayout, QWidget
+
+
+class VBoxLayout(QVBoxLayout):
+    """ Vertical box layout """
+
+    def __init__(self, parent):
+        super().__init__(parent)
+        self.widgets = []
+
+    def addWidgets(self, widgets: List[QWidget], stretch=0, alignment=Qt.AlignTop):
+        """ add widgets to layout """
+        for widget in widgets:
+            self.addWidget(widget, stretch, alignment)
+
+    def addWidget(self, widget: QWidget, stretch=0, alignment=Qt.AlignTop):
+        """ add widget to layout """
+        super().addWidget(widget, stretch, alignment)
+        self.widgets.append(widget)
+        widget.show()
+
+    def removeWidget(self, widget: QWidget):
+        """ remove widget from layout but not delete it """
+        super().removeWidget(widget)
+        self.widgets.remove(widget)
+
+    def deleteWidget(self, widget: QWidget):
+        """ remove widget from layout and delete it """
+        self.removeWidget(widget)
+        widget.hide()
+        widget.deleteLater()
+
+    def removeAllWidget(self):
+        """ remove all widgets from layout """
+        for widget in self.widgets:
+            super().removeWidget(widget)
+
+        self.widgets.clear()

fastuiwidgets/components/material/__init__.py

@@ -0,0 +1,6 @@
+from .acrylic_menu import AcrylicMenu, AcrylicLineEditMenu, AcrylicCheckableMenu, AcrylicCheckableSystemTrayMenu, AcrylicSystemTrayMenu
+from .acrylic_line_edit import AcrylicLineEditBase, AcrylicLineEdit, AcrylicSearchLineEdit
+from .acrylic_combo_box import AcrylicComboBox, AcrylicComboBoxSettingCard, AcrylicEditableComboBox
+from .acrylic_widget import AcrylicWidget, AcrylicBrush
+from .acrylic_flyout import AcrylicFlyoutView, AcrylicFlyoutViewBase, AcrylicFlyout
+from .acrylic_tool_tip import AcrylicToolTip, AcrylicToolTipFilter

fastuiwidgets/components/material/acrylic_combo_box.py

@@ -0,0 +1,96 @@
+# coding:utf-8
+from PySide6.QtCore import Qt, QPoint
+from PySide6.QtGui import QAction
+
+
+from .acrylic_menu import AcrylicMenuBase, AcrylicMenuActionListWidget
+from .acrylic_line_edit import AcrylicLineEditBase
+from ..widgets.combo_box import ComboBoxMenu, ComboBox, EditableComboBox
+from ..widgets.menu import MenuAnimationType, RoundMenu, IndicatorMenuItemDelegate
+from ..settings import SettingCard
+from ...common.config import OptionsConfigItem, qconfig
+
+
+class AcrylicComboMenuActionListWidget(AcrylicMenuActionListWidget):
+
+    def _topMargin(self):
+        return 2
+
+
+class AcrylicComboBoxMenu(AcrylicMenuBase, RoundMenu):
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self.setUpMenu(AcrylicComboMenuActionListWidget(self))
+
+        self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+        self.view.setItemDelegate(IndicatorMenuItemDelegate())
+        self.view.setObjectName('comboListWidget')
+        self.setItemHeight(33)
+
+    def exec(self, pos, ani=True, aniType=MenuAnimationType.DROP_DOWN):
+        return super().exec(pos, ani, aniType)
+
+
+class AcrylicComboBox(ComboBox):
+    """ Acrylic combo box """
+
+    def _createComboMenu(self):
+        return AcrylicComboBoxMenu(self)
+
+
+class AcrylicEditableComboBox(AcrylicLineEditBase, EditableComboBox):
+    """ Acrylic combo box """
+
+    def _createComboMenu(self):
+        return AcrylicComboBoxMenu(self)
+
+
+class AcrylicComboBoxSettingCard(SettingCard):
+    """ Setting card with a combo box """
+
+    def __init__(self, configItem: OptionsConfigItem, icon, title, content=None, texts=None, parent=None):
+        """
+        Parameters
+        ----------
+        configItem: OptionsConfigItem
+            configuration item operated by the card
+
+        icon: str | QIcon | FluentIconBase
+            the icon to be drawn
+
+        title: str
+            the title of card
+
+        content: str
+            the content of card
+
+        texts: List[str]
+            the text of items
+
+        parent: QWidget
+            parent widget
+        """
+        super().__init__(icon, title, content, parent)
+        self.configItem = configItem
+        self.comboBox = AcrylicComboBox(self)
+        self.hBoxLayout.addWidget(self.comboBox, 0, Qt.AlignRight)
+        self.hBoxLayout.addSpacing(16)
+
+        self.optionToText = {o: t for o, t in zip(configItem.options, texts)}
+        for text, option in zip(texts, configItem.options):
+            self.comboBox.addItem(text, userData=option)
+
+        self.comboBox.setCurrentText(self.optionToText[qconfig.get(configItem)])
+        self.comboBox.currentIndexChanged.connect(self._onCurrentIndexChanged)
+        configItem.valueChanged.connect(self.setValue)
+
+    def _onCurrentIndexChanged(self, index: int):
+        qconfig.set(self.configItem, self.comboBox.itemData(index))
+
+    def setValue(self, value):
+        if value not in self.optionToText:
+            return
+
+        self.comboBox.setCurrentText(self.optionToText[value])
+        qconfig.set(self.configItem, value)

fastuiwidgets/components/material/acrylic_flyout.py

@@ -0,0 +1,105 @@
+# coding:utf-8
+from typing import Union
+from PySide6.QtCore import QPoint, Qt, QRect, QRectF
+from PySide6.QtGui import QPixmap, QPainter, QColor, QPainterPath, QIcon, QImage
+from PySide6.QtWidgets import QWidget
+
+from ...common.style_sheet import isDarkTheme
+from ...common.icon import FluentIconBase
+from ..widgets.flyout import FlyoutAnimationType, FlyoutViewBase, FlyoutView, Flyout, FlyoutAnimationManager
+from .acrylic_widget import AcrylicWidget
+
+
+class AcrylicFlyoutViewBase(AcrylicWidget, FlyoutViewBase):
+    """ Acrylic flyout view base """
+
+    def acrylicClipPath(self):
+        path = QPainterPath()
+        path.addRoundedRect(QRectF(self.rect().adjusted(1, 1, -1, -1)), 8, 8)
+        return path
+
+    def paintEvent(self, e):
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.Antialiasing)
+        self._drawAcrylic(painter)
+
+        # draw border
+        painter.setBrush(Qt.NoBrush)
+        painter.setPen(self.borderColor())
+        rect = QRectF(self.rect()).adjusted(1, 1, -1, -1)
+        painter.drawRoundedRect(rect, 8, 8)
+
+
+class AcrylicFlyoutView(AcrylicWidget, FlyoutView):
+    """ Acrylic flyout view """
+
+    def acrylicClipPath(self):
+        path = QPainterPath()
+        path.addRoundedRect(QRectF(self.rect().adjusted(1, 1, -1, -1)), 8, 8)
+        return path
+
+    def paintEvent(self, e):
+        painter = QPainter(self)
+        painter.setRenderHints(QPainter.Antialiasing)
+        self._drawAcrylic(painter)
+
+        # draw border
+        painter.setBrush(Qt.NoBrush)
+        painter.setPen(self.borderColor())
+        rect = self.rect().adjusted(1, 1, -1, -1)
+        painter.drawRoundedRect(rect, 8, 8)
+
+
+class AcrylicFlyout(Flyout):
+    """ Acrylic flyout """
+
+    @classmethod
+    def create(cls, title: str, content: str, icon: Union[FluentIconBase, QIcon, str] = None,
+               image: Union[str, QPixmap, QImage] = None, isClosable=False, target: Union[QWidget, QPoint] = None,
+               parent=None, aniType=FlyoutAnimationType.PULL_UP, isDeleteOnClose=True):
+        """ create and show a flyout using the default view
+
+        Parameters
+        ----------
+        title: str
+            the title of teaching tip
+
+        content: str
+            the content of teaching tip
+
+        icon: InfoBarIcon | FluentIconBase | QIcon | str
+            the icon of teaching tip
+
+        image: str | QPixmap | QImage
+            the image of teaching tip
+
+        isClosable: bool
+            whether to show the close button
+
+        target: QWidget | QPoint
+            the target widget or position to show flyout
+
+        parent: QWidget
+            parent window
+
+        aniType: FlyoutAnimationType
+            flyout animation type
+
+        isDeleteOnClose: bool
+            whether delete flyout automatically when flyout is closed
+        """
+        view = AcrylicFlyoutView(title, content, icon, image, isClosable)
+        w = cls.make(view, target, parent, aniType, isDeleteOnClose)
+        view.closed.connect(w.close)
+        return w
+
+    def exec(self, pos: QPoint, aniType=FlyoutAnimationType.PULL_UP):
+        """ show calendar view """
+        self.aniManager = FlyoutAnimationManager.make(aniType, self)
+
+        if isinstance(self.view, AcrylicWidget):
+            pos = self.aniManager._adjustPosition(pos)
+            self.view.acrylicBrush.grabImage(QRect(pos, self.layout().sizeHint()))
+
+        self.show()
+        self.aniManager.exec(pos)

fastuiwidgets/components/material/acrylic_line_edit.py

@@ -0,0 +1,27 @@
+# coding:utf-8
+from .acrylic_menu import AcrylicCompleterMenu, AcrylicLineEditMenu
+from ..widgets.line_edit import LineEdit, SearchLineEdit
+
+
+class AcrylicLineEditBase:
+    """ Acrylic line edit base """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+    def setCompleter(self, completer):
+        super().setCompleter(completer)
+        self.setCompleterMenu(AcrylicCompleterMenu(self))
+
+    def contextMenuEvent(self, e):
+        menu = AcrylicLineEditMenu(self)
+        menu.exec(e.globalPos())
+
+
+
+class AcrylicLineEdit(AcrylicLineEditBase, LineEdit):
+    """ Acrylic line edit """
+
+
+class AcrylicSearchLineEdit(AcrylicLineEditBase, SearchLineEdit):
+    """ Acrylic search line edit """