qpuiq 0.23__py3-none-any.whl

PUI/PySide6/canvas.py

@@ -0,0 +1,345 @@
+from .. import *
+from .base import *
+
+from PySide6 import QtWidgets, QtGui
+from PySide6.QtGui import QPainter, QColor, QPainterPath, QImage
+
+class PUIQtCanvas(QtWidgets.QWidget):
+    def __init__(self, node, width=None, height=None):
+        self.puinode = 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.puinode._dblclicked(e)
+
+    def mousePressEvent(self, event):
+        e = PUIEvent()
+        e.button = event.button().value
+        e.x, e.y = event.position().toPoint().toTuple()
+        self.puinode._mousedown(e)
+
+    def mouseReleaseEvent(self, event):
+        e = PUIEvent()
+        e.button = event.button().value
+        e.x, e.y = event.position().toPoint().toTuple()
+        self.puinode._mouseup(e)
+
+    def mouseMoveEvent(self, event):
+        e = PUIEvent()
+        e.button = event.button().value
+        e.x, e.y = event.position().toPoint().toTuple()
+        self.puinode._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()
+        modifier = 0
+        emodifiers = event.modifiers()
+        if emodifiers & QtCore.Qt.ShiftModifier:
+            modifier |= KeyModifier.SHIFT
+        if emodifiers & QtCore.Qt.ControlModifier:
+            modifier |= KeyModifier.CTRL
+        if emodifiers & QtCore.Qt.AltModifier:
+            modifier |= KeyModifier.ALT
+        if emodifiers & QtCore.Qt.MetaModifier:
+            modifier |= KeyModifier.META
+        e.modifiers = modifier
+        self.puinode._wheel(e)
+
+    def paintEvent(self, event):
+        puinode = self.puinode.get_node()
+        puinode.qpainter = QPainter()
+        puinode.qpainter.begin(self)
+        puinode.qpainter.setRenderHints(QtGui.QPainter.Antialiasing, True)
+
+        if not puinode.style_bgcolor is None:
+            bgBrush = QtGui.QBrush()
+            bgBrush.setColor(QtGui.QColor(puinode.style_bgcolor))
+            bgBrush.setStyle(QtCore.Qt.SolidPattern)
+            rect = QtCore.QRect(0, 0, self.width or self.geometry().width(), self.height or self.geometry().height())
+            puinode.qpainter.fillRect(rect, bgBrush)
+
+        puinode.width = self.geometry().width()
+        puinode.height = self.geometry().height()
+        immediate = puinode.painter(puinode, *puinode.args)
+        puinode.qpainter.end()
+        puinode.qpainter = None
+        if immediate:
+            self.update()
+
+class ImageResource():
+    @staticmethod
+    def load(path):
+        ir = ImageResource()
+        ir.qimage = QImage(path)
+        return ir
+
+    def crop(self, x, y, width, height):
+        ir = ImageResource()
+        ir.qimage = self.qimage.copy(x, y, width, height)
+        return ir
+
+    def scale(self, width, height, keepAspectRatio=True, quality=0):
+        ir = ImageResource()
+        method = {
+            0: QtCore.Qt.TransformationMode.FastTransformation
+        }.get(quality, QtCore.Qt.TransformationMode.SmoothTransformation)
+        ir.qimage = self.qimage.scaled(width, height, QtCore.Qt.AspectRatioMode.KeepAspectRatio if keepAspectRatio else QtCore.Qt.IgnoreAspectRatio, method)
+        return ir
+
+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)}")
+
+    def loadImage(self, image_path):
+        return ImageResource.load(image_path)
+
+    def drawImage(self, image, x=0, y=0, width=None, height=None, src_x=0, src_y=0, src_width=None, src_height=None, opacity=1.0):
+        if image.qimage.isNull():
+            return
+
+        if src_width is None:
+            src_width = image.qimage.width() - src_x
+        if src_height is None:
+            src_height = image.qimage.height() - src_y
+
+        source_rect = QtCore.QRect(src_x, src_y, src_width, src_height)
+
+        if width is None:
+            width = src_width
+        if height is None:
+            height = src_height
+
+        dest_rect = QtCore.QRect(x, y, width, height)
+        self.qpainter.setOpacity(opacity)
+        self.qpainter.drawImage(dest_rect, image.qimage, source_rect)
+        self.qpainter.setOpacity(1.0)

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)

PUI/PySide6/combobox.py

@@ -0,0 +1,85 @@
+from .. import *
+from .base import *
+
+class ComboBox(QtBaseWidget):
+    pui_terminal = False
+    def __init__(self, editable=False, index_model=None, text_model=None):
+        super().__init__()
+        self.editable = editable
+        self.index_model = index_model
+        self.text_model = text_model
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.curr_index = prev.curr_index
+            self.curr_text = prev.curr_text
+            self.signal_connected = prev.signal_connected
+            self.ui = prev.ui
+        else:
+            self.curr_index = Prop()
+            self.curr_text = Prop()
+            self.signal_connected = False
+            self.ui = QtWidgets.QComboBox()
+        self.ui.setEditable(self.editable)
+        super().update(prev)
+
+    def postSync(self):
+        index = -1
+        text = ""
+
+        if self.index_model:
+            index = self.index_model.value
+            text = self.children[index].text
+        elif self.text_model:
+            text = str(self.text_model.value)
+            try:
+                index = [c.value for c in self.children].index(text)
+            except:
+                index = -1
+
+        if self.signal_connected:
+            self.ui.currentIndexChanged.disconnect()
+            self.ui.currentTextChanged.disconnect()
+
+        if self.curr_index.set(index):
+            self.ui.setCurrentIndex(index)
+
+        if self.curr_text.set(text):
+            self.ui.setCurrentText(text)
+
+        self.ui.currentIndexChanged.connect(self.on_currentIndexChanged)
+        self.ui.currentTextChanged.connect(self.on_currentTextChanged)
+
+
+    def on_currentIndexChanged(self, idx):
+        if self.index_model:
+            self.index_model.value = idx
+        if self.text_model:
+            self.text_model.value = self.children[idx].value
+        e = PUIEvent()
+        e.value = idx
+        self._change(e)
+
+    def on_currentTextChanged(self, text):
+        if not self.editable:
+            return
+        if self.text_model:
+            self.text_model.value = text
+        e = PUIEvent()
+        e.value = text
+        self._change(e)
+
+    def addChild(self, idx, child):
+        self.ui.insertItem(idx, child.text)
+
+    def removeChild(self, idx, child):
+        self.ui.removeItem(idx)
+
+class ComboBoxItem(PUINode):
+    def __init__(self, text, value=None):
+        super().__init__()
+        self.id(text)
+        self.text = text
+        if value is None:
+            value = text
+        self.value = value

PUI/PySide6/dialog.py

@@ -0,0 +1,72 @@
+from .. import *
+from .base import *
+
+def OpenDirectory(title="Open Directory", dir=None):
+    res = QtWidgets.QFileDialog.getExistingDirectory(None, title, dir)
+    return res
+
+def OpenFile(title="Open File", dir=None, types=None):
+    if types:
+        types = types.replace("|", ";;")
+    res = QtWidgets.QFileDialog.getOpenFileName(None, title, dir, types)
+    return res[0] or None
+
+def OpenFiles(title="Open Files", dir=None, types=None):
+    if types:
+        types = types.replace("|", ";;")
+    res = QtWidgets.QFileDialog.getOpenFileNames(None, title, dir, types)
+    return res[0] or None
+
+def SaveFile(default, title="Save File", dir=None, types=None):
+    if types:
+        types = types.replace("|", ";;")
+    if not dir:
+        value = default
+        if isinstance(value, str):
+            dir = value
+    res = QtWidgets.QFileDialog.getSaveFileName(None, title, dir, types)
+    return res[0] or None
+
+def Information(message="Information", title="Information Dialog"):
+    dlg = QtWidgets.QMessageBox(None)
+    dlg.setWindowTitle(title)
+    dlg.setText(message)
+    dlg.setStandardButtons(QtWidgets.QMessageBox.Ok)
+    dlg.setIcon(QtWidgets.QMessageBox.Information)
+    dlg.exec_()
+
+def Warning(message="Warning", title="Warning Dialog"):
+    dlg = QtWidgets.QMessageBox(None)
+    dlg.setWindowTitle(title)
+    dlg.setText(message)
+    dlg.setStandardButtons(QtWidgets.QMessageBox.Ok)
+    dlg.setIcon(QtWidgets.QMessageBox.Warning)
+    dlg.exec_()
+
+def Critical(message="Critical", title="Critical Dialog"):
+    dlg = QtWidgets.QMessageBox(None)
+    dlg.setWindowTitle(title)
+    dlg.setText(message)
+    dlg.setStandardButtons(QtWidgets.QMessageBox.Ok)
+    dlg.setIcon(QtWidgets.QMessageBox.Critical)
+    dlg.exec_()
+
+def Confirm(message="Confirm", title="Confirm Dialog"):
+    dlg = QtWidgets.QMessageBox(None)
+    dlg.setWindowTitle(title)
+    dlg.setText(message)
+    dlg.setStandardButtons(QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
+    dlg.setIcon(QtWidgets.QMessageBox.Question)
+    button = dlg.exec_()
+
+    if button == QtWidgets.QMessageBox.Yes:
+        return True
+    else:
+        return False
+
+def Prompt(prompt="Input", title="Input Dialog", default=""):
+    text, ok = QtWidgets.QInputDialog.getText(None, title, prompt, QtWidgets.QLineEdit.Normal, default)
+    if ok:
+        return text
+    else:
+        return None

PUI/PySide6/divider.py

@@ -0,0 +1,23 @@
+from .. import *
+from .base import *
+from .layout import *
+
+class Divider(QtBaseWidget):
+    def __init__(self):
+        super().__init__()
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+        else:
+            self.ui = QtWidgets.QFrame()
+            parent = self.non_virtual_parent
+            if isinstance(parent, VBox):
+                self.ui.setFrameShape(QtWidgets.QFrame.Shape.HLine)
+            elif isinstance(parent, HBox):
+                self.ui.setFrameShape(QtWidgets.QFrame.Shape.VLine)
+            else:
+                self.ui.setFrameShape(QtWidgets.QFrame.Shape.NoFrame)
+            self.ui.setFrameShadow(QtWidgets.QFrame.Shadow.Sunken)
+
+        super().update(prev)

PUI/PySide6/image.py

@@ -0,0 +1,48 @@
+from .. import *
+from .base import *
+from .label import ClickableQLabel
+from PySide6.QtWidgets import QSizePolicy
+import os
+
+class Image(QtBaseWidget):
+    def __init__(self, path):
+        super().__init__()
+        self.path = path
+        self.pixmap = None
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            self.eventFilter = prev.eventFilter
+            self.curr_path = prev.curr_path
+            self.curr_path_mtime = prev.curr_path_mtime
+            self.pixmap = prev.pixmap
+        else:
+            self.ui = ClickableQLabel()
+            self.ui.clicked.connect(self._clicked)
+            self.curr_path = Prop()
+            self.curr_path_mtime = Prop()
+
+        if self._onClicked:
+            self.ui.setCursor(QtCore.Qt.PointingHandCursor)
+
+        if self.layout_weight:
+            # XXX keep aspect ratio
+            self.ui.setScaledContents(True)
+            self.ui.setSizePolicy(QSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored))
+        else:
+            self.ui.setScaledContents(False)
+            self.ui.setSizePolicy(QSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Preferred))
+
+        if self.curr_path.set(self.path) or self.curr_path_mtime.set(os.path.getmtime(self.path)):
+            self.pixmap = QtGui.QPixmap(self.path)
+            if self.layout_width is not None and self.layout_height is not None:
+                self.pixmap = self.pixmap.scaled(self.layout_width, self.layout_height, QtCore.Qt.KeepAspectRatio, mode=QtCore.Qt.SmoothTransformation)
+            elif self.layout_width is not None:
+                self.pixmap = self.pixmap.scaledToWidth(self.layout_width, mode=QtCore.Qt.SmoothTransformation)
+            elif self.layout_height is not None:
+                self.pixmap = self.pixmap.scaledToHeight(self.layout_height, mode=QtCore.Qt.SmoothTransformation)
+
+            self.ui.setPixmap(self.pixmap)
+
+        super().update(prev)

PUI/PySide6/label.py

@@ -0,0 +1,33 @@
+from .. import *
+from .base import *
+
+class ClickableQLabel(QtWidgets.QLabel):
+    clicked  = QtCore.Signal()
+
+    def mousePressEvent(self, ev):
+        self.clicked.emit()
+        super().mousePressEvent(ev)
+
+class Label(QtBaseWidget):
+    def __init__(self, text, selectable=False):
+        super().__init__()
+        self.text = str(text)
+        self.selectable = selectable
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            self.ui.setText(self.text)
+        else:
+            self.ui = ClickableQLabel(self.text)
+            self.ui.setTextFormat(QtCore.Qt.TextFormat.PlainText)
+            self.ui.clicked.connect(self._clicked)
+        if self._onClicked:
+            self.ui.setCursor(QtCore.Qt.PointingHandCursor)
+
+        if self.selectable:
+            self.ui.setTextInteractionFlags(QtCore.Qt.TextInteractionFlag.TextSelectableByMouse)
+        else:
+            self.ui.setTextInteractionFlags(QtCore.Qt.TextInteractionFlag.NoTextInteraction)
+
+        super().update(prev)