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

fastuiwidgets/common/image_utils.py

@@ -0,0 +1,198 @@
+# coding:utf-8
+from math import floor
+from io import BytesIO
+from typing import Union
+
+import numpy as np
+from colorthief import ColorThief
+from PIL import Image
+from PySide6.QtGui import QImage, QPixmap
+from PySide6.QtCore import QIODevice, QBuffer
+from scipy.ndimage.filters import gaussian_filter
+
+from .exception_handler import exceptionHandler
+
+
+
+def gaussianBlur(image, blurRadius=18, brightFactor=1, blurPicSize= None):
+    if isinstance(image, str) and not image.startswith(':'):
+        image = Image.open(image)
+    else:
+        image = fromqpixmap(QPixmap(image))
+
+    if blurPicSize:
+        # adjust image size to reduce computation
+        w, h = image.size
+        ratio = min(blurPicSize[0] / w, blurPicSize[1] / h)
+        w_, h_ = w * ratio, h * ratio
+
+        if w_ < w:
+            image = image.resize((int(w_), int(h_)), Image.ANTIALIAS)
+
+    image = np.array(image)
+
+    # handle gray image
+    if len(image.shape) == 2:
+        image = np.stack([image, image, image], axis=-1)
+
+    # blur each channel
+    for i in range(3):
+        image[:, :, i] = gaussian_filter(
+            image[:, :, i], blurRadius) * brightFactor
+
+    # convert ndarray to QPixmap
+    h, w, c = image.shape
+    if c == 3:
+        format = QImage.Format_RGB888
+    else:
+        format = QImage.Format_RGBA8888
+
+    return QPixmap.fromImage(QImage(image.data, w, h, c*w, format))
+
+
+# https://github.com/python-pillow/Pillow/blob/main/src/PIL/ImageQt.py
+def fromqpixmap(im: Union[QImage, QPixmap]):
+    """
+    :param im: QImage or PIL ImageQt object
+    """
+    buffer = QBuffer()
+    buffer.open(QIODevice.OpenModeFlag.ReadWrite)
+
+    # preserve alpha channel with png
+    # otherwise ppm is more friendly with Image.open
+    if im.hasAlphaChannel():
+        im.save(buffer, "png")
+    else:
+        im.save(buffer, "ppm")
+
+    b = BytesIO()
+    b.write(buffer.data())
+    buffer.close()
+    b.seek(0)
+
+    return Image.open(b)
+
+
+class DominantColor:
+    """ Dominant color class """
+
+    @classmethod
+    @exceptionHandler((24, 24, 24))
+    def getDominantColor(cls, imagePath):
+        """ extract dominant color from image
+
+        Parameters
+        ----------
+        imagePath: str
+            image path
+
+        Returns
+        -------
+        r, g, b: int
+            gray value of each color channel
+        """
+        if imagePath.startswith(':'):
+            return (24, 24, 24)
+
+        colorThief = ColorThief(imagePath)
+
+        # scale image to speed up the computation speed
+        if max(colorThief.image.size) > 400:
+            colorThief.image = colorThief.image.resize((400, 400))
+
+        palette = colorThief.get_palette(quality=9)
+
+        # adjust the brightness of palette
+        palette = cls.__adjustPaletteValue(palette)
+        for rgb in palette[:]:
+            h, s, v = cls.rgb2hsv(rgb)
+            if h < 0.02:
+                palette.remove(rgb)
+                if len(palette) <= 2:
+                    break
+
+        palette = palette[:5]
+        palette.sort(key=lambda rgb: cls.colorfulness(*rgb), reverse=True)
+
+        return palette[0]
+
+    @classmethod
+    def __adjustPaletteValue(cls, palette):
+        """ adjust the brightness of palette """
+        newPalette = []
+        for rgb in palette:
+            h, s, v = cls.rgb2hsv(rgb)
+            if v > 0.9:
+                factor = 0.8
+            elif 0.8 < v <= 0.9:
+                factor = 0.9
+            elif 0.7 < v <= 0.8:
+                factor = 0.95
+            else:
+                factor = 1
+            v *= factor
+            newPalette.append(cls.hsv2rgb(h, s, v))
+
+        return newPalette
+
+    @staticmethod
+    def rgb2hsv(rgb):
+        """ convert rgb to hsv """
+        r, g, b = [i / 255 for i in rgb]
+        mx = max(r, g, b)
+        mn = min(r, g, b)
+        df = mx - mn
+        if mx == mn:
+            h = 0
+        elif mx == r:
+            h = (60 * ((g - b) / df) + 360) % 360
+        elif mx == g:
+            h = (60 * ((b - r) / df) + 120) % 360
+        elif mx == b:
+            h = (60 * ((r - g) / df) + 240) % 360
+        s = 0 if mx == 0 else df / mx
+        v = mx
+        return (h, s, v)
+
+    @staticmethod
+    def hsv2rgb(h, s, v):
+        """ convert hsv to rgb """
+        h60 = h / 60.0
+        h60f = floor(h60)
+        hi = int(h60f) % 6
+        f = h60 - h60f
+        p = v * (1 - s)
+        q = v * (1 - f * s)
+        t = v * (1 - (1 - f) * s)
+        r, g, b = 0, 0, 0
+        if hi == 0:
+            r, g, b = v, t, p
+        elif hi == 1:
+            r, g, b = q, v, p
+        elif hi == 2:
+            r, g, b = p, v, t
+        elif hi == 3:
+            r, g, b = p, q, v
+        elif hi == 4:
+            r, g, b = t, p, v
+        elif hi == 5:
+            r, g, b = v, p, q
+        r, g, b = int(r * 255), int(g * 255), int(b * 255)
+        return (r, g, b)
+
+    @staticmethod
+    def colorfulness(r: int, g: int, b: int):
+        rg = np.absolute(r - g)
+        yb = np.absolute(0.5 * (r + g) - b)
+
+        # Compute the mean and standard deviation of both `rg` and `yb`.
+        rg_mean, rg_std = (np.mean(rg), np.std(rg))
+        yb_mean, yb_std = (np.mean(yb), np.std(yb))
+
+        # Combine the mean and standard deviations.
+        std_root = np.sqrt((rg_std ** 2) + (yb_std ** 2))
+        mean_root = np.sqrt((rg_mean ** 2) + (yb_mean ** 2))
+
+        return std_root + (0.3 * mean_root)
+
+

fastuiwidgets/common/overload.py

@@ -0,0 +1,47 @@
+# coding: utf-8
+from functools import singledispatch, update_wrapper
+
+
+class singledispatchmethod:
+    """Single-dispatch generic method descriptor.
+
+    Supports wrapping existing descriptors and handles non-descriptor
+    callables as instance methods.
+    """
+
+    def __init__(self, func):
+        if not callable(func) and not hasattr(func, "__get__"):
+            raise TypeError(f"{func!r} is not callable or a descriptor")
+
+        self.dispatcher = singledispatch(func)
+        self.func = func
+
+    def register(self, cls, method=None):
+        """generic_method.register(cls, func) -> func
+
+        Registers a new implementation for the given *cls* on a *generic_method*.
+        """
+        return self.dispatcher.register(cls, func=method)
+
+    def __get__(self, obj, cls=None):
+        def _method(*args, **kwargs):
+            if args:
+                method = self.dispatcher.dispatch(args[0].__class__)
+            else:
+                method = self.func
+                for v in kwargs.values():
+                    if v.__class__ in self.dispatcher.registry:
+                        method = self.dispatcher.dispatch(v.__class__)
+                        if method is not self.func:
+                            break
+
+            return method.__get__(obj, cls)(*args, **kwargs)
+
+        _method.__isabstractmethod__ = self.__isabstractmethod__
+        _method.register = self.register
+        update_wrapper(_method, self.func)
+        return _method
+
+    @property
+    def __isabstractmethod__(self):
+        return getattr(self.func, '__isabstractmethod__', False)

fastuiwidgets/common/router.py

@@ -0,0 +1,133 @@
+# coding:utf-8
+from typing import Dict, List
+from itertools import groupby
+
+from PySide6.QtCore import Qt, QObject, Signal
+from PySide6.QtWidgets import QWidget, QStackedWidget
+
+
+class RouteItem:
+    """ Route item """
+
+    def __init__(self, stacked: QStackedWidget, routeKey: str):
+        self.stacked = stacked
+        self.routeKey = routeKey
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+
+        return other.stacked is self.stacked and self.routeKey == other.routeKey
+
+
+class StackedHistory:
+    """ Stacked history """
+
+    def __init__(self, stacked: QStackedWidget):
+        self.stacked = stacked
+        self.defaultRouteKey = None  # type: str
+        self.history = [self.defaultRouteKey]   # type: List[str]
+
+    def __len__(self):
+        return len(self.history)
+
+    def isEmpty(self):
+        return len(self) <= 1
+
+    def push(self, routeKey: str):
+        if self.history[-1] == routeKey:
+            return False
+
+        self.history.append(routeKey)
+        return True
+
+    def pop(self):
+        if self.isEmpty():
+            return
+
+        self.history.pop()
+        self.goToTop()
+
+    def remove(self, routeKey: str):
+        if routeKey not in self.history:
+            return
+
+        self.history[1:] = [i for i in self.history[1:] if i != routeKey]
+        self.history = [k for k, g in groupby(self.history)]
+        self.goToTop()
+
+    def top(self):
+        return self.history[-1]
+
+    def setDefaultRouteKey(self, routeKey: str):
+        self.defaultRouteKey = routeKey
+        self.history[0] = routeKey
+
+    def goToTop(self):
+        w = self.stacked.findChild(QWidget, self.top())
+        if w:
+            self.stacked.setCurrentWidget(w)
+
+
+class Router(QObject):
+    """ Router """
+
+    emptyChanged = Signal(bool)
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent)
+        self.history = []   # type: List[RouteItem]
+        self.stackHistories = {}  # type: Dict[QStackedWidget, StackedHistory]
+
+    def setDefaultRouteKey(self, stacked: QStackedWidget, routeKey: str):
+        """ set the default route key of stacked widget """
+        if stacked not in self.stackHistories:
+            self.stackHistories[stacked] = StackedHistory(stacked)
+
+        self.stackHistories[stacked].setDefaultRouteKey(routeKey)
+
+    def push(self, stacked: QStackedWidget, routeKey: str):
+        """ push history
+
+        Parameters
+        ----------
+        stacked: QStackedWidget
+            stacked widget
+
+        routeKey: str
+            route key of sub insterface, it should be the object name of sub interface
+        """
+        item = RouteItem(stacked, routeKey)
+
+        if stacked not in self.stackHistories:
+            self.stackHistories[stacked] = StackedHistory(stacked)
+
+        # don't add duplicated history
+        success = self.stackHistories[stacked].push(routeKey)
+        if success:
+            self.history.append(item)
+
+        self.emptyChanged.emit(not bool(self.history))
+
+    def pop(self):
+        """ pop history """
+        if not self.history:
+            return
+
+        item = self.history.pop()
+        self.emptyChanged.emit(not bool(self.history))
+        self.stackHistories[item.stacked].pop()
+
+    def remove(self, routeKey: str):
+        """ remove history """
+        self.history = [i for i in self.history if i.routeKey != routeKey]
+        self.history = [list(g)[0] for k, g in groupby(self.history, lambda i: i.routeKey)]
+        self.emptyChanged.emit(not bool(self.history))
+
+        for stacked, history in self.stackHistories.items():
+            w = stacked.findChild(QWidget, routeKey)
+            if w:
+                return history.remove(routeKey)
+
+
+qrouter = Router()

fastuiwidgets/common/screen.py

@@ -0,0 +1,25 @@
+from PySide6.QtCore import QPoint, QRect
+from PySide6.QtGui import QCursor
+from PySide6.QtWidgets import QApplication
+
+
+def getCurrentScreen():
+    """ get current screen """
+    cursorPos = QCursor.pos()
+
+    for s in QApplication.screens():
+        if s.geometry().contains(cursorPos):
+            return s
+
+    return None
+
+
+def getCurrentScreenGeometry(avaliable=True):
+    """ get current screen geometry """
+    screen = getCurrentScreen() or QApplication.primaryScreen()
+
+    # this should not happen
+    if not screen:
+        return QRect(0, 0, 1920, 1080)
+
+    return screen.availableGeometry() if avaliable else screen.geometry()

fastuiwidgets/common/smooth_scroll.py

@@ -0,0 +1,141 @@
+# coding:utf-8
+from collections import deque
+from enum import Enum
+from math import cos, pi, ceil
+
+from PySide6.QtCore import QDateTime, Qt, QTimer, QPoint
+from PySide6.QtGui import QWheelEvent
+from PySide6.QtWidgets import QApplication, QScrollArea, QAbstractScrollArea
+
+
+class SmoothScroll:
+    """ Scroll smoothly """
+
+    def __init__(self, widget: QScrollArea, orient=Qt.Vertical):
+        """
+        Parameters
+        ----------
+        widget: QScrollArea
+            scroll area to scroll smoothly
+
+        orient: Orientation
+            scroll orientation
+        """
+        self.widget = widget
+        self.orient = orient
+        self.fps = 60
+        self.duration = 400
+        self.stepsTotal = 0
+        self.stepRatio = 1.5
+        self.acceleration = 1
+        self.lastWheelEvent = None
+        self.scrollStamps = deque()
+        self.stepsLeftQueue = deque()
+        self.smoothMoveTimer = QTimer(widget)
+        self.smoothMode = SmoothMode(SmoothMode.LINEAR)
+        self.smoothMoveTimer.timeout.connect(self.__smoothMove)
+
+    def setSmoothMode(self, smoothMode):
+        """ set smooth mode """
+        self.smoothMode = smoothMode
+
+    def wheelEvent(self, e):
+        # only process the wheel events triggered by mouse, fixes issue #75
+        delta = e.angleDelta().y() if e.angleDelta().y() != 0 else e.angleDelta().x()
+        if self.smoothMode == SmoothMode.NO_SMOOTH or abs(delta) % 120 != 0:
+            QAbstractScrollArea.wheelEvent(self.widget, e)
+            return
+
+        # push current time to queque
+        now = QDateTime.currentDateTime().toMSecsSinceEpoch()
+        self.scrollStamps.append(now)
+        while now - self.scrollStamps[0] > 500:
+            self.scrollStamps.popleft()
+
+        # adjust the acceration ratio based on unprocessed events
+        accerationRatio = min(len(self.scrollStamps) / 15, 1)
+        self.lastWheelPos = e.position()
+        self.lastWheelGlobalPos = e.globalPosition()
+
+        # get the number of steps
+        self.stepsTotal = self.fps * self.duration / 1000
+
+        # get the moving distance corresponding to each event
+        delta = delta* self.stepRatio
+        if self.acceleration > 0:
+            delta += delta * self.acceleration * accerationRatio
+
+        # form a list of moving distances and steps, and insert it into the queue for processing.
+        self.stepsLeftQueue.append([delta, self.stepsTotal])
+
+        # overflow time of timer: 1000ms/frames
+        self.smoothMoveTimer.start(int(1000 / self.fps))
+
+    def __smoothMove(self):
+        """ scroll smoothly when timer time out """
+        totalDelta = 0
+
+        # Calculate the scrolling distance of all unprocessed events,
+        # the timer will reduce the number of steps by 1 each time it overflows.
+        for i in self.stepsLeftQueue:
+            totalDelta += self.__subDelta(i[0], i[1])
+            i[1] -= 1
+
+        # If the event has been processed, move it out of the queue
+        while self.stepsLeftQueue and self.stepsLeftQueue[0][1] == 0:
+            self.stepsLeftQueue.popleft()
+
+        # construct wheel event
+        if self.orient == Qt.Vertical:
+            pixelDelta = QPoint(round(totalDelta), 0)
+            bar = self.widget.verticalScrollBar()
+        else:
+            pixelDelta = QPoint(0, round(totalDelta))
+            bar = self.widget.horizontalScrollBar()
+
+        e = QWheelEvent(
+            self.lastWheelPos,
+            self.lastWheelGlobalPos,
+            pixelDelta,
+            QPoint(round(totalDelta), 0),
+            Qt.MouseButton.LeftButton,
+            Qt.KeyboardModifier.NoModifier,
+            Qt.ScrollPhase.ScrollBegin,
+            False,
+        )
+
+        # send wheel event to app
+        QApplication.sendEvent(bar, e)
+
+        # stop scrolling if the queque is empty
+        if not self.stepsLeftQueue:
+            self.smoothMoveTimer.stop()
+
+    def __subDelta(self, delta, stepsLeft):
+        """ get the interpolation for each step """
+        m = self.stepsTotal / 2
+        x = abs(self.stepsTotal - stepsLeft - m)
+
+        res = 0
+        if self.smoothMode == SmoothMode.NO_SMOOTH:
+            res = 0
+        elif self.smoothMode == SmoothMode.CONSTANT:
+            res = delta / self.stepsTotal
+        elif self.smoothMode == SmoothMode.LINEAR:
+            res = 2 * delta / self.stepsTotal * (m - x) / m
+        elif self.smoothMode == SmoothMode.QUADRATI:
+            res = 3 / 4 / m * (1 - x * x / m / m) * delta
+        elif self.smoothMode == SmoothMode.COSINE:
+            res = (cos(x * pi / m) + 1) / (2 * m) * delta
+
+        return res
+
+
+class SmoothMode(Enum):
+    """ Smooth mode """
+    NO_SMOOTH = 0
+    CONSTANT = 1
+    LINEAR = 2
+    QUADRATI = 3
+    COSINE = 4
+