qpuiq 0.10__py3-none-any.whl

PUI/PySide6/__init__.py

@@ -0,0 +1,49 @@
+from PySide6.QtWidgets import QSizePolicy, QLayout
+
+from .application import *
+from .button import *
+from .canvas import *
+from .checkbox import *
+from .combobox import *
+from .dialog import *
+from .divider import *
+from .image import *
+from .label import *
+from .layout import *
+from .modal import *
+from .matplotlib import *
+from .progressbar import *
+from .radiobutton import *
+from .scroll import *
+from .splitter import *
+from .table import *
+from .tab import *
+from .text import *
+from .textfield import *
+from .tree import *
+from .window import *
+from .mdi import *
+from .toolbar import *
+
+PUIView = QtPUIView
+
+def PUI(func):
+    """
+    PUI.PySide6.PUI triggers update() by signal/slot
+    """
+    def func_wrapper(*args, **kwargs):
+        class PUIViewWrapper(QtPUIView):
+            pui_virtual = True
+            def __init__(self, name):
+                self.name = name
+                super().__init__()
+
+            def content(self):
+                return func(*args, **kwargs)
+
+        ret = PUIViewWrapper(func.__name__)
+        return ret
+
+    return func_wrapper
+
+PUI_BACKEND = "PySide6"

PUI/PySide6/application.py

@@ -0,0 +1,58 @@
+from .. import *
+from .base import *
+
+class QtApplicationSignal(QtCore.QObject):
+    quit = QtCore.Signal()
+
+class Application(QtPUIView):
+    def __init__(self, icon=None):
+        super().__init__()
+        self.ui = None
+        self.icon = icon
+        self._qtappsignal = QtApplicationSignal()
+        self._qtappsignal.quit.connect(self._quit, QtCore.Qt.ConnectionType.QueuedConnection) # Use QueuedConnection to prevent nested trigger
+
+    def redraw(self):
+        if self.ui:
+            super().redraw()
+        else:
+            self.sync()
+
+    def update(self, prev=None):
+        if not self.ui:
+            from PySide6 import QtWidgets
+            self.ui = QtWidgets.QApplication([])
+            if self.icon:
+                self.ui.setWindowIcon(QtGui.QIcon(self.icon))
+
+        super().update(prev)
+
+    def addChild(self, idx, child):
+        child.outer.show()
+
+    def removeChild(self, idx, child):
+        child.outer.close()
+
+    def start(self):
+        self.ui.exec()
+
+    def quit(self):
+        self._qtappsignal.quit.emit()
+
+    def _quit(self):
+        self.ui.quit()
+
+def PUIApp(func):
+    def func_wrapper(*args, **kwargs):
+        class PUIAppWrapper(Application):
+            def __init__(self, name):
+                self.name = name
+                super().__init__()
+
+            def content(self):
+                return func(*args, **kwargs)
+
+        ret = PUIAppWrapper(func.__name__)
+        return ret
+
+    return func_wrapper

PUI/PySide6/base.py

@@ -0,0 +1,222 @@
+from .. import *
+from PySide6 import QtCore, QtWidgets, QtGui
+
+class QtViewSignal(QtCore.QObject):
+    redraw = QtCore.Signal()
+
+def _apply_params(ui, node):
+    styles = {}
+    if node.style_fontsize:
+        styles["font"] = f"{node.style_fontsize}pt"
+    if node.style_fontfamily:
+        styles["font-family"] = node.style_fontfamily
+    if node.style_color:
+        styles["color"] = f"#{node.style_color:06X}"
+    if node.style_bgcolor:
+        styles["background-color"] = f"#{node.style_bgcolor:06X}"
+
+    style = node.qt_params.get("Style")
+    if not style is None:
+        ui.setStyle(style)
+
+    HorizontalPolicy = node.qt_params.get("HorizontalPolicy")
+    if not HorizontalPolicy is None:
+        ui.sizePolicy().setHorizontalPolicy(HorizontalPolicy)
+
+    VerticalPolicy = node.qt_params.get("VerticalPolicy")
+    if not VerticalPolicy is None:
+        ui.sizePolicy().setVerticalPolicy(VerticalPolicy)
+
+    SizeConstraint = node.qt_params.get("SizeConstraint")
+    if not SizeConstraint is None:
+        ui.setSizeConstraint(SizeConstraint)
+
+    StyleSheet = node.qt_params.get("StyleSheet", {})
+    for k,v in StyleSheet.items():
+        styles[k] = v
+
+    if hasattr(ui, "setStyleSheet"):
+        ui.setStyleSheet("".join([f"{k}:{v};" for k,v in styles.items()]))
+
+    if node.layout_padding:
+        ui.setContentsMargins(*trbl2ltrb(node.layout_padding))
+
+class QtPUIView(PUIView):
+    pui_virtual = True
+    def __init__(self):
+        super().__init__()
+        self.qt_params = {}
+        self._qtsignal = QtViewSignal()
+        self._qtsignal.redraw.connect(self.sync, QtCore.Qt.ConnectionType.QueuedConnection) # Use QueuedConnection to prevent nested trigger
+
+    def destroy(self, direct):
+        if direct:
+            if self.ui: # PUIView doesn't have ui
+                self.ui.deleteLater()
+        self.ui = None
+        super().destroy(direct)
+
+    def redraw(self):
+        self.dirty = True
+        if self.updating:
+            return
+        self.updating = True
+        self._qtsignal.redraw.emit()
+
+    def update(self, prev=None):
+        super().update(prev)
+        _apply_params(self.ui, self)
+
+    def qt(self, **kwargs):
+        for k,v in kwargs.items():
+            self.qt_params[k] = v
+        return self
+
+class QtBaseWidget(PUINode):
+    pui_terminal = True
+
+    def __init__(self):
+        super().__init__()
+        self.qt_params = {}
+
+    def destroy(self, direct):
+        if direct:
+            if self.ui:
+                self.ui.deleteLater()
+        self.ui = None
+        super().destroy(direct)
+
+    def update(self, prev=None):
+        super().update(prev)
+
+        sizePolicy = self.ui.sizePolicy()
+        if self.layout_width is not None:
+            sizePolicy.setHorizontalPolicy(QtWidgets.QSizePolicy.Preferred)
+        if self.layout_height is not None:
+            sizePolicy.setVerticalPolicy(QtWidgets.QSizePolicy.Preferred)
+        self.ui.setSizePolicy(sizePolicy)
+
+        if not hasattr(self.ui, "origSizeHint"):
+            self.ui.origSizeHint = self.ui.sizeHint
+        self.ui.sizeHint = self.qtSizeHint
+
+        _apply_params(self.ui, self)
+
+    def qtSizeHint(self):
+        node = self.get_node()
+        if not node.ui:
+            return QtCore.QSize(0, 0)
+        sh = node.ui.origSizeHint()
+        w = sh.width()
+        h = sh.height()
+        if not node.layout_width is None:
+            w = node.layout_width
+        if not node.layout_height is None:
+            h = node.layout_height
+        return QtCore.QSize(w, h)
+
+    def qt(self, **kwargs):
+        for k,v in kwargs.items():
+            self.qt_params[k] = v
+        return self
+
+class QtBaseLayout(PUINode):
+    def __init__(self):
+        super().__init__()
+        self.qt_params = {}
+        if not isinstance(self.non_virtual_parent, QtBaseLayout):
+            self.layout_padding = (11,11,11,11)
+
+    @property
+    def outer(self):
+        return self.ui
+
+    @property
+    def inner(self):
+        return self.layout
+
+    def destroy(self, direct):
+        if direct:
+            if self.ui:
+                self.ui.deleteLater()
+        self.layout = None
+        self.ui = None
+        super().destroy(direct)
+
+    def update(self, prev=None):
+        super().update(prev)
+        _apply_params(self.ui, self)
+
+    def addChild(self, idx, child):
+        from .modal import Modal
+        from .layout import Spacer
+        if isinstance(child, Spacer):
+            self.layout.insertItem(idx, child.outer)
+        elif isinstance(child, Modal):
+            pass
+        elif isinstance(child, QtBaseWidget) or isinstance(child, QtBaseLayout):
+            params = {}
+            if not child.layout_weight is None:
+                params["stretch"] = child.layout_weight
+            self.layout.insertWidget(idx, child.outer, **params)
+
+    def removeChild(self, idx, child):
+        from .modal import Modal
+        from .layout import Spacer
+        if isinstance(child, Spacer):
+            self.layout.removeItem(child.outer)
+        elif isinstance(child, Modal):
+            pass
+        elif isinstance(child, QtBaseWidget) or isinstance(child, QtBaseLayout):
+            child.outer.setParent(None)
+
+    def qt(self, **kwargs):
+        for k,v in kwargs.items():
+            self.qt_params[k] = v
+        return self
+
+class QtBaseFrame(QtBaseWidget):
+    pui_terminal = False
+
+    def destroy(self, direct):
+        if direct:
+            if self.ui:
+                self.ui.deleteLater()
+                self.ui = None
+
+    def addChild(self, idx, child):
+        if idx != 0:
+            return
+        if isinstance(child, QtBaseWidget) or isinstance(child, QtBaseLayout):
+            self.ui.setWidget(child.outer)
+        elif child.children:
+            self.addChild(idx, child.children[0])
+
+    def removeChild(self, idx, child):
+        if idx != 0:
+            return
+        if isinstance(child, QtBaseWidget) or isinstance(child, QtBaseLayout):
+            child.outer.setParent(None)
+        elif child.children:
+            self.removeChild(idx, child.children[0])
+
+class QtInPui(QtBaseWidget):
+    def __init__(self, widget, *args):
+        self._internal_tag = str(id(widget))
+        super().__init__(*args)
+        self.ui = widget
+
+    def destroy(self, direct):
+        pass
+
+class PuiInQt(QtPUIView):
+    def __init__(self, ui):
+        super().__init__()
+        self.ui = ui
+        self.ui.update()
+
+    def addChild(self, idx, child):
+        self.ui.addChild(idx, child)
+
+    def removeChild(self, idx, child):
+        self.ui.removeChild(idx, child)

PUI/PySide6/button.py

@@ -0,0 +1,21 @@
+from .. import *
+from .base import *
+
+class Button(QtBaseWidget):
+    def __init__(self, text):
+        super().__init__()
+        self.text = text
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            self.ui.setText(self.text)
+            try:
+                self.ui.clicked.disconnect()
+            except:
+                pass
+            prev.callback = None
+        else:
+            self.ui = QtWidgets.QPushButton(text=self.text)
+        self.ui.clicked.connect(self._clicked)
+        super().update(prev)

PUI/PySide6/canvas.py

@@ -0,0 +1,288 @@
+from .. import *
+from .base import *
+
+from PySide6 import QtWidgets, QtGui
+from PySide6.QtGui import QPainter, QColor, QPainterPath
+from PySide6.QtCore import QPoint
+
+class PUIQtCanvas(QtWidgets.QWidget):
+    def __init__(self, node, width=None, height=None):
+        self.node = node
+        self.width = width
+        self.height = height
+        super().__init__()
+
+    def minimumSizeHint(self):
+        return QtCore.QSize(self.width, self.height)
+
+    def mouseDoubleClickEvent(self, event):
+        e = PUIEvent()
+        e.button = event.button().value
+        e.x, e.y = event.position().toPoint().toTuple()
+        self.node._dblclicked(e)
+
+    def mousePressEvent(self, event):
+        e = PUIEvent()
+        e.button = event.button().value
+        e.x, e.y = event.position().toPoint().toTuple()
+        self.node._mousedown(e)
+
+    def mouseReleaseEvent(self, event):
+        e = PUIEvent()
+        e.button = event.button().value
+        e.x, e.y = event.position().toPoint().toTuple()
+        self.node._mouseup(e)
+
+    def mouseMoveEvent(self, event):
+        e = PUIEvent()
+        e.button = event.button().value
+        e.x, e.y = event.position().toPoint().toTuple()
+        self.node._mousemove(e)
+
+    def wheelEvent(self, event):
+        e = PUIEvent()
+        e.x, e.y = event.position().toPoint().toTuple()
+        e.y_delta = event.pixelDelta().y()
+        e.x_delta = event.pixelDelta().x()
+        e.v_delta = event.angleDelta().y()
+        e.h_delta = event.angleDelta().x()
+        self.node._wheel(e)
+
+    def paintEvent(self, event):
+        node = self.node.get_node()
+        node.qpainter = QPainter()
+        node.qpainter.begin(self)
+        node.qpainter.setRenderHints(QtGui.QPainter.Antialiasing, True)
+
+        if not node.style_bgcolor is None:
+            bgBrush = QtGui.QBrush()
+            bgBrush.setColor(QtGui.QColor(node.style_bgcolor))
+            bgBrush.setStyle(QtCore.Qt.SolidPattern)
+            rect = QtCore.QRect(0, 0, self.width or self.geometry().width(), self.height or self.geometry().height())
+            node.qpainter.fillRect(rect, bgBrush)
+
+        node.painter(node, *node.args)
+
+        node.qpainter.end()
+        node.qpainter = None
+
+class Canvas(QtBaseWidget):
+    def __init__(self, painter, *args):
+        super().__init__()
+        self.ui = None
+        self.painter = painter
+        self.args = args
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            self.ui.puinode = self
+            self.ui.width = self.layout_width or 0
+            self.ui.height = self.layout_height or 0
+        else:
+            self.ui = PUIQtCanvas(self, self.layout_width or 0, self.layout_height or 0)
+        self.ui.setMouseTracking(bool(self._onMouseMove))
+        self.ui.update()
+        super().update(prev)
+
+    def drawText(self, x, y, text, w=None, h=None, size=12, color=None, rotate=0, anchor=Anchor.LEFT_TOP):
+        if w is None:
+            w = self.ui.geometry().width()
+        if h is None:
+            h = self.ui.geometry().height()
+        self.qpainter.save()
+        br = self.qpainter.boundingRect(0, 0, w, h, 0, text)
+        self.qpainter.restore()
+
+        dx = 0
+        dy = 0
+        if anchor.value[0]=="center":
+            dx = br.width()/2
+        elif anchor.value[0]=="right":
+            dx = br.width()
+
+        if anchor.value[1]=="center":
+            dy = br.height()/2
+        elif anchor.value[1]=="bottom":
+            dy = br.height()
+
+        self.qpainter.save()
+        self.qpainter.translate(int(x+dx), int(y+dy))
+        self.qpainter.rotate(rotate)
+        self.qpainter.translate(int(-dx), int(-dy))
+
+        if size is not None:
+            font = self.qpainter.font()
+            font.setPointSize(size)
+            self.qpainter.setFont(font)
+
+        if color is not None:
+            self.qpainter.setPen(QColor(color))
+
+        self.qpainter.drawText(0, 0, w, h, 0, text)
+        self.qpainter.restore()
+
+    def drawLine(self, x1, y1, x2, y2, color=None, width=1):
+        self.qpainter.save()
+
+        pen = self.qpainter.pen()
+        if color is None:
+            pen.setStyle(QtCore.Qt.NoPen)
+        else:
+            pen.setStyle(QtCore.Qt.SolidLine)
+            pen.setColor(QColor(color))
+            pen.setWidth(width)
+        self.qpainter.setPen(pen)
+
+        self.qpainter.drawLine(x1, y1, x2, y2)
+
+        self.qpainter.restore()
+
+    def drawPolyline(self, coords, color=None, width=1):
+        self.qpainter.save()
+
+        pen = self.qpainter.pen()
+        if color is None:
+            pen.setStyle(QtCore.Qt.NoPen)
+        else:
+            pen.setStyle(QtCore.Qt.SolidLine)
+            pen.setColor(QColor(color))
+            pen.setWidth(width)
+        self.qpainter.setPen(pen)
+
+        self.qpainter.drawPolyline([QtCore.QPointF(x,y) for x,y in coords])
+
+        self.qpainter.restore()
+
+    def drawPolygon(self, coords, fill=None, stroke=None, width=1):
+        self.qpainter.save()
+
+        brush = self.qpainter.brush()
+        if fill is None:
+            brush.setStyle(QtCore.Qt.NoBrush)
+        else:
+            brush.setStyle(QtCore.Qt.SolidPattern)
+            brush.setColor(QColor(fill))
+        self.qpainter.setBrush(brush)
+
+        pen = self.qpainter.pen()
+        if stroke is None:
+            pen.setStyle(QtCore.Qt.NoPen)
+        else:
+            pen.setStyle(QtCore.Qt.SolidLine)
+            pen.setColor(QColor(stroke))
+            pen.setWidth(width)
+        self.qpainter.setPen(pen)
+
+        polygon = QtGui.QPolygonF()
+        for p in coords:
+            polygon.append(QtCore.QPointF(*p))
+        self.qpainter.drawPolygon(polygon)
+
+        self.qpainter.restore()
+
+    def drawRect(self, x1, y1, x2, y2, fill=None, stroke=None, width=1):
+        self.qpainter.save()
+
+        x = min(x1, x2)
+        y = min(y1, y2)
+        w = abs(x2-x1)
+        h = abs(y2-y1)
+
+        brush = self.qpainter.brush()
+        if fill is None:
+            brush.setStyle(QtCore.Qt.NoBrush)
+        else:
+            brush.setStyle(QtCore.Qt.SolidPattern)
+            brush.setColor(QColor(fill))
+        self.qpainter.setBrush(brush)
+
+        pen = self.qpainter.pen()
+        if stroke is None:
+            pen.setStyle(QtCore.Qt.NoPen)
+        else:
+            pen.setStyle(QtCore.Qt.SolidLine)
+            pen.setColor(QColor(stroke))
+            pen.setWidth(width)
+        self.qpainter.setPen(pen)
+
+        self.qpainter.drawRect(x, y, w, h)
+
+        self.qpainter.restore()
+
+    def drawEllipse(self, x, y, rx, ry, fill=None, stroke=None, width=1):
+        self.qpainter.save()
+
+        brush = self.qpainter.brush()
+        if fill is None:
+            brush.setStyle(QtCore.Qt.NoBrush)
+        else:
+            brush.setStyle(QtCore.Qt.SolidPattern)
+            brush.setColor(QColor(fill))
+        self.qpainter.setBrush(brush)
+
+        pen = self.qpainter.pen()
+        if stroke is None:
+            pen.setStyle(QtCore.Qt.NoPen)
+        else:
+            pen.setStyle(QtCore.Qt.SolidLine)
+            pen.setColor(QColor(stroke))
+            pen.setWidth(width)
+        self.qpainter.setPen(pen)
+
+        self.qpainter.drawEllipse(QtCore.QPointF(x,y), rx, ry)
+
+        self.qpainter.restore()
+
+    def drawShapely(self, shape, fill=None, stroke=None, width=1):
+        self.qpainter.save()
+
+        brush = self.qpainter.brush()
+        if fill is None:
+            brush.setStyle(QtCore.Qt.NoBrush)
+        else:
+            brush.setStyle(QtCore.Qt.SolidPattern)
+            brush.setColor(QColor(fill))
+        self.qpainter.setBrush(brush)
+
+        pen = self.qpainter.pen()
+        if stroke is None:
+            pen.setStyle(QtCore.Qt.NoPen)
+        else:
+            pen.setStyle(QtCore.Qt.SolidLine)
+            pen.setColor(QColor(stroke))
+            pen.setWidth(width)
+        self.qpainter.setPen(pen)
+
+        self._drawShapely(shape, fill, stroke, width)
+
+        self.qpainter.restore()
+
+
+    def _drawShapely(self, shape, fill=None, stroke=None, width=1):
+        if hasattr(shape, "geoms"):
+            for g in shape.geoms:
+                self.drawShapely(g, fill, stroke, width)
+        elif hasattr(shape, "exterior"): # polygon
+            path = QPainterPath()
+
+            exterior = QtGui.QPolygonF()
+            for p in shape.exterior.coords:
+                exterior.append(QtCore.QPointF(*p))
+            path.addPolygon(exterior)
+
+            for h in shape.interiors:
+                hole = QtGui.QPolygonF()
+                for p in h.coords:
+                    hole.append(QtCore.QPointF(*p))
+                hpoly = QPainterPath()
+                hpoly.addPolygon(hole)
+                path = path.subtracted(hpoly)
+
+            self.qpainter.drawPath(path)
+        elif hasattr(shape, "x") and hasattr(shape, "y"): # point
+            self.drawEllipse(shape.x, shape.y, width/2, width/2, fill=stroke)
+        elif hasattr(shape, "coords"): # linestring, linearring
+            self.drawPolyline(shape.coords, color=stroke, width=width)
+        else:
+            raise RuntimeError(f"Not implemented: drawShapely({type(shape).__name__}) {dir(shape)}")

PUI/PySide6/checkbox.py

@@ -0,0 +1,32 @@
+from .. import *
+from .base import *
+from ..utils import *
+from PySide6.QtWidgets import QSizePolicy
+
+class Checkbox(QtBaseWidget):
+    def __init__(self, text, model):
+        super().__init__()
+        self.text = text
+        self.model = model
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            try:
+                self.ui.stateChanged.disconnect()
+            except:
+                pass
+            try:
+                self.ui.clicked.disconnect()
+            except:
+                pass
+        else:
+            self.ui = QtWidgets.QCheckBox()
+        self.ui.setText(self.text)
+        self.ui.setChecked(bool(self.model.value))
+        self.ui.stateChanged.connect(self._stateChanged)
+        self.ui.clicked.connect(self._clicked)
+        super().update(prev)
+
+    def _stateChanged(self, value):
+        self.model.value = bool(value)