qpuiq 0.10__py3-none-any.whl

PUI/PySide6/scroll.py

@@ -0,0 +1,153 @@
+from .. import *
+from .base import *
+from PySide6.QtWidgets import QSizePolicy
+import math
+
+class Scroll(QtBaseWidget):
+    pui_terminal = False
+    END = -0.0
+
+    def __init__(self, vertical=None, horizontal=False):
+        self.vertical = vertical
+        self.horizontal = horizontal
+        self.align_x = 0
+        self.align_y = 0
+        super().__init__()
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            self.align_x = prev.align_x
+            self.align_y = prev.align_y
+            if prev.vsb_conn:
+                vsb = self.ui.verticalScrollBar()
+                vsb.valueChanged.disconnect(prev.vsb_conn)
+                vsb.rangeChanged.disconnect(prev.vsb_range_conn)
+            if prev.hsb_conn:
+                hsb = self.ui.horizontalScrollBar()
+                hsb.valueChanged.disconnect(prev.hsb_conn)
+                hsb.rangeChanged.disconnect(prev.hsb_range_conn)
+        else:
+            self.ui = QtWidgets.QScrollArea()
+            self.ui.setWidgetResizable(True)
+            if self.vertical is None:
+                self.ui.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+            elif self.vertical:
+                self.ui.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOn)
+            else:
+                self.ui.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+            if self.horizontal is None:
+                self.ui.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+            elif self.horizontal:
+                self.ui.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOn)
+            else:
+                self.ui.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        vsb = self.ui.verticalScrollBar()
+        self.vsb_conn = vsb.valueChanged.connect(self.vsb_changed)
+        self.vsb_range_conn = vsb.rangeChanged.connect(self.vsb_range_changed)
+        hsb = self.ui.horizontalScrollBar()
+        self.hsb_conn = hsb.valueChanged.connect(self.hsb_changed)
+        self.hsb_range_conn = hsb.rangeChanged.connect(self.hsb_range_changed)
+        super().update(prev)
+
+    def addChild(self, idx, child):
+        if idx != 0:
+            return
+        if isinstance(child, QtBaseWidget) or isinstance(child, QtBaseLayout):
+            self.ui.setWidget(child.outer)
+            if not hasattr(child.outer, "origResizeEvent"):
+                child.outer.origResizeEvent = child.outer.resizeEvent
+                child.outer.setSizePolicy(QSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Preferred))
+            child.outer.resizeEvent = self.onUiResized
+        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])
+
+    def onUiResized(self, event):
+        node = self.get_node()
+        if node.destroyed:
+            return
+        node.children[0].outer.origResizeEvent(event)
+        node.children[0].outer.resizeEvent = self.onUiResized
+        if node.horizontal is False:
+            if isinstance(node.children[0], QtBaseLayout):
+                node.outer.setMinimumWidth(node.children[0].outer.sizeHint().width())
+            elif isinstance(node.children[0], QtBaseWidget):
+                node.outer.setMinimumWidth(node.children[0].outer.sizeHint().width())
+
+        if node.vertical is False:
+            if isinstance(node.children[0], QtBaseLayout):
+                node.outer.setMinimumHeight(node.children[0].outer.sizeHint().height())
+            elif isinstance(node.children[0], QtBaseWidget):
+                node.outer.setMinimumHeight(node.children[0].outer.sizeHint().height())
+
+    def scrollX(self, pos=0):
+        if math.copysign(1, pos) >= 0:
+            self.align_x = 0
+            self.hsb_offset = pos
+        else:
+            self.align_x = 1
+            self.hsb_offset = abs(pos)
+        return self
+
+    def scrollY(self, pos=0):
+        if math.copysign(1, pos) >= 0:
+            self.align_y = 0
+            self.vsb_offset = pos
+        else:
+            self.align_y = 1
+            self.vsb_offset = abs(pos)
+        return self
+
+    def hsb_changed(self, *args, **kwargs):
+        hsb = self.ui.horizontalScrollBar()
+        v = hsb.value()
+        if v < 10 and v > hsb.maximum() - 10:
+            pass
+        elif v < 10:
+            self.align_x = 0
+        elif v > hsb.maximum() - 10:
+            self.align_x = 1
+
+    def vsb_changed(self, *args, **kwargs):
+        vsb = self.ui.verticalScrollBar()
+        v = vsb.value()
+        if v < 10 and v > vsb.maximum() - 10:
+            pass
+        elif v < 10:
+            self.align_y = 0
+        elif v > vsb.maximum() - 10:
+            self.align_y = 1
+
+    def preSync(self):
+        hsb = self.ui.horizontalScrollBar()
+        if self.align_x == 0:
+            self.hsb_offset = hsb.value()
+        else:
+            self.hsb_offset = hsb.maximum() - hsb.value()
+        vsb = self.ui.verticalScrollBar()
+        if self.align_y == 0:
+            self.vsb_offset = vsb.value()
+        else:
+            self.vsb_offset = vsb.maximum() - vsb.value()
+
+    def vsb_range_changed(self, min, max):
+        vsb = self.ui.verticalScrollBar()
+        if self.align_y == 0:
+            vsb.setValue(self.vsb_offset)
+        else:
+            vsb.setValue(max - self.vsb_offset)
+
+    def hsb_range_changed(self, min, max):
+        hsb = self.ui.verticalScrollBar()
+        if self.align_y == 0:
+            hsb.setValue(self.hsb_offset)
+        else:
+            hsb.setValue(max - self.hsb_offset)

PUI/PySide6/splitter.py

@@ -0,0 +1,25 @@
+from .. import *
+from .base import *
+
+class Splitter(QtBaseWidget):
+    pui_terminal = False
+    def __init__(self, vertical=False):
+        super().__init__()
+        self.vertical = vertical
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+        else:
+            self.ui = QtWidgets.QSplitter()
+        self.ui.setOrientation(QtCore.Qt.Orientation.Vertical if self.vertical else QtCore.Qt.Orientation.Horizontal)
+        super().update(prev)
+
+    def addChild(self, idx, child):
+        if isinstance(child, QtBaseWidget) or isinstance(child, QtBaseLayout):
+            self.ui.insertWidget(idx, child.outer)
+        else:
+            self.addChild(idx, child.children[0])
+    
+    def removeChild(self, idx, child):
+        child.outer.setParent(None)

PUI/PySide6/tab.py

@@ -0,0 +1,39 @@
+from .. import *
+from .base import *
+
+class Tabs(QtBaseWidget):
+    NORTH = "n"
+    SOUTH = "s"
+    EAST = "e"
+    WEST = "w"
+    pui_terminal = False
+    def __init__(self, tabposition=NORTH):
+        super().__init__()
+        self.tabposition = tabposition
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+        else:
+            self.ui = QtWidgets.QTabWidget()
+        super().update(prev)
+
+    def addChild(self, idx, child):
+        parent = child.parent
+        while not isinstance(parent, Tab):
+            parent = parent.parent
+        self.ui.insertTab(idx, child.outer, parent.label)
+
+    def removeChild(self, idx, child):
+        self.ui.removeTab(idx)
+
+    def postSync(self):
+        for i,c in enumerate(self.children):
+            self.ui.setTabText(i, c.label)
+
+
+class Tab(PUINode):
+    pui_virtual = True
+    def __init__(self, label):
+        super().__init__()
+        self.label = label

PUI/PySide6/table.py

@@ -0,0 +1,89 @@
+from .. import *
+from .base import *
+
+class QtTableModelAdapter(QtCore.QAbstractTableModel):
+    def __init__(self, model: "BaseTableAdapter"):
+        super().__init__()
+        self.model = model
+
+    def data(self, index, role):
+        if role == QtCore.Qt.DisplayRole:
+            return self.model.data(index.row(), index.column())
+        elif role == QtCore.Qt.EditRole:
+            return self.model.editData(index.row(), index.column())
+
+    def setData(self, index, value, role):
+        if role == QtCore.Qt.EditRole:
+            self.model.setData(index.row(), index.column(), value)
+            return True
+
+    def flags(self, index):
+        flags = super().flags(index)
+        if self.model.editable(index.row(), index.column()):
+            flags |= QtCore.Qt.ItemIsEditable
+        return flags
+
+    def headerData(self, section, orientation, role):
+        if role == QtCore.Qt.DisplayRole:
+            if orientation == QtCore.Qt.Horizontal:
+                if hasattr(self.model, "columnHeader"):
+                    if self.model.columnHeader is None:
+                        return None
+                    else:
+                        return self.model.columnHeader(section)
+                else:
+                    return super().headerData(section, orientation, role)
+            else:
+                if hasattr(self.model, "rowHeader"):
+                    if self.model.rowHeader is None:
+                        return None
+                    else:
+                        return self.model.rowHeader(section)
+                else:
+                    return super().headerData(section, orientation, role)
+
+    def rowCount(self, index):
+        return self.model.rowCount()
+
+    def columnCount(self, index):
+        return self.model.columnCount()
+
+
+class Table(QtBaseWidget):
+    def __init__(self, model, autofit=True):
+        super().__init__()
+        self.layout_weight = 1
+        self.model = model
+        self.autofit = autofit
+        self.curr_model = None
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            self.qt_model = prev.qt_model
+            self.curr_model = prev.curr_model
+        else:
+            self.qt_model = None
+            self.curr_model = Prop()
+            self.ui = QtWidgets.QTableView()
+
+        if self.model.columnHeader is None:
+            self.ui.horizontalHeader().hide()
+        else:
+            self.ui.horizontalHeader().show()
+
+        if self.model.rowHeader is None:
+            self.ui.verticalHeader().hide()
+        else:
+            self.ui.verticalHeader().show()
+
+        if self.curr_model.set(self.model):
+            self.qt_model = QtTableModelAdapter(self.model)
+            self.ui.setModel(self.qt_model)
+        else:
+            self.qt_model.refresh()
+
+        if self.autofit:
+            self.ui.resizeColumnsToContents()
+
+        super().update(prev)

PUI/PySide6/text.py

@@ -0,0 +1,35 @@
+from .. import *
+from .base import *
+from ..utils import *
+from PySide6.QtWidgets import QSizePolicy
+
+class Text(QtBaseWidget):
+    textformat = QtCore.Qt.TextFormat.PlainText
+    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 = QtWidgets.QLabel(self.text)
+            self.ui.setTextFormat(self.textformat)
+            self.ui.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)
+            self.ui.setWordWrap(True)
+
+        if self.selectable:
+            self.ui.setTextInteractionFlags(QtCore.Qt.TextInteractionFlag.TextSelectableByMouse)
+        else:
+            self.ui.setTextInteractionFlags(QtCore.Qt.TextInteractionFlag.NoTextInteraction)
+
+        super().update(prev)
+
+
+class Html(Text):
+    textformat = QtCore.Qt.TextFormat.RichText
+
+class MarkDown(Text):
+    textformat = QtCore.Qt.TextFormat.MarkdownText

PUI/PySide6/textfield.py

@@ -0,0 +1,62 @@
+from .. import *
+from .base import *
+
+class TextField(QtBaseWidget):
+    def __init__(self, model, edit_model=None):
+        super().__init__()
+        self.model = model
+        self.edit_model = edit_model
+        self.editing = False
+
+    def update(self, prev):
+        model_value = str(self.model.value)
+        if prev and prev.ui:
+            self.editing = prev.editing
+            self.ui = prev.ui
+            self.curr_value = prev.curr_value
+            self.ui.node = self
+            self.ui.textChanged.disconnect()
+            if self.curr_value.set(model_value) and not self.editing:
+                self.ui.setText(model_value)
+            self.ui.textChanged.connect(self.on_textchanged)
+            self.ui.editingFinished.disconnect()
+            self.ui.editingFinished.connect(self.on_editing_finished)
+        else:
+            self.ui = QtWidgets.QLineEdit()
+            self.ui.setFocusPolicy(QtCore.Qt.ClickFocus | QtCore.Qt.NoFocus)
+            self.ui.node = self
+            self.ui.setText(model_value)
+            self.curr_value = Prop(model_value)
+            self.ui.textChanged.connect(self.on_textchanged)
+            self.ui.editingFinished.connect(self.on_editing_finished)
+
+        if self.edit_model and not self.editing:
+            self.edit_model.value = model_value
+
+        super().update(prev)
+
+    def on_editing_finished(self):
+        node = self.get_node()
+        node.editing = False
+        value = self.ui.text()
+        node.model.value = value
+        if node.edit_model:
+            node.edit_model.value = value
+        model_value = str(self.model.value)
+        self.ui.blockSignals(True)
+        self.ui.setText(model_value)
+        self.ui.blockSignals(False)
+        e = PUIEvent()
+        e.value = value
+        self._change(e)
+        node.ui.clearFocus()
+
+    def on_textchanged(self):
+        node = self.get_node()
+        node.editing = True
+        value = self.ui.text()
+        if node.edit_model:
+           node.edit_model.value = value
+        e = PUIEvent()
+        e.value = value
+        self._input(e)

PUI/PySide6/toolbar.py

@@ -0,0 +1,57 @@
+from .. import *
+from .base import *
+
+class ToolBar(PUINode):
+    pui_outoforder = True
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            self.actions = prev.actions
+        else:
+            self.ui = QtWidgets.QToolBar()
+            self.actions = []
+
+        super().update(prev)
+
+    def addChild(self, idx, child):
+        if idx < len(self.actions):
+            if isinstance(child, ToolBarAction):
+                self.actions.insert(idx, self.ui.insertAction(self.actions[idx], child.outer))
+            else:
+                self.actions.insert(idx, self.ui.insertWidget(self.actions[idx], child.outer))
+        else:
+            if isinstance(child, ToolBarAction):
+                self.actions.append(self.ui.addAction(child.outer))
+            else:
+                self.actions.append(self.ui.addWidget(child.outer))
+
+    def removeChild(self, idx, child):
+        self.ui.removeAction(self.actions[idx])
+
+class ToolBarAction(PUINode):
+    def __init__(self, text, icon=None):
+        super().__init__()
+        self.text = text
+        self.icon = icon
+        self.onTriggered = None
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            self.ui.setText(self.text)
+            self.ui.triggered.disconnect()
+        else:
+            self.ui = QtGui.QAction(self.text)
+        if self.icon:
+            self.ui.setIcon(self.icon)
+        self.ui.triggered.connect(self._triggered)
+
+        super().update(prev)
+
+    def _triggered(self):
+        node = self.get_node()
+        if node.onTriggered:
+            node.onTriggered[0](*node.onTriggered[1], **node.onTriggered[2])
+
+    def trigger(self, callback, *cb_args, **cb_kwargs):
+        self.onTriggered = (callback, cb_args, cb_kwargs)

PUI/PySide6/tree.py

@@ -0,0 +1,120 @@
+from .. import *
+from .base import *
+from PySide6.QtCore import Qt, QModelIndex, QAbstractItemModel
+
+class QAbstractItemModelAdapter(QtCore.QAbstractItemModel):
+    def __init__(self, model: "BaseTreeAdapter"):
+        super().__init__()
+        self.model = model
+
+    def index(self, row, column, parent = QtCore.QModelIndex()):
+        parent_node = parent.internalPointer() if parent.isValid() else None
+        if 0 <= row and row < self.model.rowCount(parent_node):
+            child = self.model.child(parent_node, row)
+            return self.createIndex(row, column, child)
+        return QtCore.QModelIndex()
+
+    def parent(self, index):
+        if not index.isValid():
+            return QModelIndex()
+        node = index.internalPointer()
+        parent_node = self.model.parent(node)
+        if parent_node:
+            return self.createIndex(0, 0, parent_node)
+        return QModelIndex()
+
+    def data(self, index, role):
+        if not index.isValid():
+            return None
+        node = index.internalPointer()
+        if role == QtCore.Qt.DisplayRole:
+            return self.model.data(node)
+        return None
+
+    def rowCount(self, parent):
+        parent_node = parent.internalPointer() if parent.isValid() else None
+        return self.model.rowCount(parent_node)
+
+    def columnCount(self, parent):
+        return 1
+
+    def hasChildren(self, parent):
+        parent_node = parent.internalPointer() if parent.isValid() else None
+        return self.model.rowCount(parent_node) > 0
+
+
+class Tree(QtBaseWidget):
+    def __init__(self, model):
+        super().__init__()
+        self.layout_weight = 1
+        self.model = model
+        self.curr_model = None
+        self.pendings = []
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            self.qt_model = prev.qt_model
+            self.curr_model = prev.curr_model
+        else:
+            self.qt_model = None
+            self.curr_model = Prop()
+            self.ui = QtWidgets.QTreeView()
+            self.ui.setHeaderHidden(True)
+            self.ui.clicked.connect(self.on_item_clicked)
+            self.ui.doubleClicked.connect(self.on_item_double_clicked)
+            self.ui.expanded.connect(self.on_item_expanded)
+            self.ui.collapsed.connect(self.on_item_collapsed)
+
+        if self.curr_model.set(self.model):
+            self.qt_model = QAbstractItemModelAdapter(self.model)
+            self.ui.setModel(self.qt_model)
+        else:
+            self.qt_model.modelReset.emit()
+
+        for pending in self.pendings:
+            pending[0](*pending[1:])
+        self.pendings = []
+
+        super().update(prev)
+
+    def expandAll(self):
+        if self.ui:
+            self.ui.expandAll()
+        else:
+            self.pendings.append([self.expandAll])
+        return self
+
+    def collapseAll(self):
+        if self.ui:
+            self.ui.collapseAll()
+        else:
+            self.pendings.append([self.collapseAll])
+        return self
+
+    def expandable(self, enabled):
+        if self.ui:
+            self.ui.setItemsExpandable(enabled)
+        else:
+            self.pendings.append([self.expandable, enabled])
+        return self
+
+    def on_item_clicked(self, index):
+        node = self.get_node()
+        treenode = index.internalPointer()
+        node.model.clicked(treenode)
+
+    def on_item_double_clicked(self, index):
+        node = self.get_node()
+        treenode = index.internalPointer()
+        node.model.dblclicked(treenode)
+
+    def on_item_expanded(self, index):
+        node = self.get_node()
+        treenode = index.internalPointer()
+        node.model.expanded(treenode)
+
+    def on_item_collapsed(self, index):
+        node = self.get_node()
+        treenode = index.internalPointer()
+        node.model.collapsed(treenode)

PUI/PySide6/window.py

@@ -0,0 +1,81 @@
+from .. import *
+from .base import *
+from .menu import *
+from .modal import *
+from .toolbar import *
+from PySide6 import QtWidgets
+
+class QMainWindow(QtWidgets.QMainWindow):
+    def keyPressEvent(self, event):
+        e = PUIEvent()
+        e.text = event.text()
+        self.node._keypress(e)
+
+    def mousePressEvent(self, event):
+        focused_widget = QtWidgets.QApplication.focusWidget()
+        if isinstance(focused_widget, QtWidgets.QLineEdit):
+            focused_widget.clearFocus()
+        super().mousePressEvent(event)
+
+class Window(QtBaseWidget):
+    pui_terminal = False
+
+    def __init__(self, title=None, icon=None, size=None, maximize=None, fullscreen=None):
+        super().__init__()
+        self.title = title
+        if icon:
+            self.icon = QtGui.QIcon(icon)
+        else:
+            self.icon = None
+        self.size = size
+        self.maximize = maximize
+        self.fullscreen = fullscreen
+
+    def update(self, prev=None):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            self.ui.node = self
+            self.curr_size = prev.curr_size
+            self.curr_maximize = prev.curr_maximize
+            self.curr_fullscreen = prev.curr_fullscreen
+        else:
+            self.ui = QMainWindow()
+            self.ui.node = self
+            self.ui.show()
+            self.curr_size = Prop()
+            self.curr_maximize = Prop()
+            self.curr_fullscreen = Prop()
+
+        if self.curr_size.set(self.size):
+            self.ui.resize(*self.size)
+        if self.curr_maximize.set(self.maximize):
+            self.ui.showMaximized()
+        if self.curr_fullscreen.set(self.fullscreen):
+            self.ui.showFullScreen()
+        if not self.title is None:
+            self.ui.setWindowTitle(self.title)
+        if not self.icon is None:
+            self.ui.setWindowIcon(self.icon)
+        super().update(prev)
+
+    def addChild(self, idx, child):
+        if isinstance(child, MenuBar):
+            self.ui.setMenuBar(child.outer)
+        elif isinstance(child, ToolBar):
+            self.ui.addToolBar(child.outer)
+        elif isinstance(child, Modal):
+            pass
+        elif isinstance(child, QtBaseWidget) or isinstance(child, QtBaseLayout):
+            self.ui.setCentralWidget(child.outer)
+        else:
+            self.addChild(idx, child.children[0])
+
+    def removeChild(self, idx, child):
+        if isinstance(child, MenuBar):
+            child.outer.close()
+        elif isinstance(child, Modal):
+            pass
+        elif isinstance(child, QtBaseWidget) or isinstance(child, QtBaseLayout):
+            child.outer.setParent(None)
+        else:
+            self.removeChild(idx, child.children[0])