qpuiq 0.23__py3-none-any.whl

PUI/PySide6/table.py

@@ -0,0 +1,147 @@
+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 QtTableNodeModelAdapter(QtCore.QAbstractTableModel):
+    def __init__(self, children):
+        super().__init__()
+        self.children = children
+
+    def data(self, index, role):
+        if role == QtCore.Qt.DisplayRole:
+            data = self.children[index.row()].children[index.column()].data
+            if isinstance(data, BaseBinding):
+                return str(data.value)
+            return data
+        return None
+
+    def setData(self, index, value, role):
+        if role == QtCore.Qt.EditRole:
+            n = self.children[index.row()].children[index.column()]
+            if isinstance(n.data, BaseBinding):
+                n.data.value = value
+            else:
+                n._set(value)
+            return True
+
+    def flags(self, index):
+        flags = super().flags(index)
+        n = self.children[index.row()].children[index.column()]
+        if isinstance(n.data, BaseBinding) or n._set_callback:
+            flags |= QtCore.Qt.ItemIsEditable
+        return flags
+
+    def rowCount(self, index):
+        return len(self.children)
+
+    def columnCount(self, index):
+        if self.children:
+            return len(self.children[0].children)
+        return 0
+
+class Table(QtBaseWidget):
+    def __init__(self, model=None, 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:
+            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()
+        else:
+            self.ui.horizontalHeader().hide()
+            self.ui.verticalHeader().hide()
+            self.qt_model = QtTableNodeModelAdapter(self.children)
+            self.ui.setModel(self.qt_model)
+
+        if self.autofit:
+            self.ui.resizeColumnsToContents()
+
+        super().update(prev)
+
+class TableNode(PUINode):
+    def __init__(self, data=""):
+        super().__init__()
+        self._set_callback = None
+        self.data = data
+
+    def set(self, cb, *args, **kwargs):
+        self._set_callback = (cb, args, kwargs)
+        return self
+
+    def _set(self, data):
+        if self._set_callback:
+            cb, args, kwargs = self._set_callback
+            cb(data, *args, **kwargs)

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): # finish editing
+        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): # editing
+        node = self.get_node()
+        self.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,290 @@
+from .. import *
+from .base import *
+from PySide6.QtCore import Qt, QModelIndex, QAbstractItemModel
+
+# XXX
+# If click handler triggers a model reset, dblclick handler will not be called
+
+class QAbstractItemModelAdapter(QtCore.QAbstractItemModel):
+    def __init__(self, model: "BaseTreeAdapter"):
+        super().__init__()
+        self.model = model
+        self.node = None
+
+    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 flags(self, index):
+        if not index.isValid():
+            return QtCore.Qt.ItemIsDropEnabled
+
+        defaultFlags = super().flags(index)
+
+        return defaultFlags | QtCore.Qt.ItemIsDragEnabled | QtCore.Qt.ItemIsDropEnabled
+
+    def canDropMimeData(self, data, action, row, column, parent):
+        if parent.isValid():
+            pass
+        else:
+            return bool(self.node._onDropped)
+
+    def dropMimeData(self, data, action, row, column, parent):
+        if parent.isValid():
+            pass
+        else:
+            event = QtGui.QDropEvent(QtCore.QPoint(0,0), action, data, QtCore.Qt.MouseButton.LeftButton, QtCore.Qt.KeyboardModifier.NoModifier, QtCore.QEvent.Drop)
+            self.node._onDropped[0](event, *self.node._onDropped[1], **self.node._onDropped[2])
+
+    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
+
+    def clicked(self, node):
+        self.model.clicked(node)
+
+    def dblclicked(self, node):
+        self.model.dblclicked(node)
+
+    def expanded(self, node):
+        self.model.expanded(node)
+
+    def collapsed(self, node):
+        self.model.collapsed(node)
+
+class QTreeNodeModelAdapter(QtCore.QAbstractItemModel):
+    def __init__(self):
+        super().__init__()
+        self.node = None
+
+    def index(self, row, column, parent = QtCore.QModelIndex()):
+        parent_node = parent.internalPointer() if parent.isValid() else self.node
+        if 0 <= row and row < len(parent_node.children):
+            child = parent_node.children[row]
+            return self.createIndex(row, column, child)
+        return QtCore.QModelIndex()
+
+    def flags(self, index):
+        if not index.isValid():
+            return QtCore.Qt.ItemIsDropEnabled
+
+        defaultFlags = super().flags(index)
+
+        return defaultFlags | QtCore.Qt.ItemIsDragEnabled | QtCore.Qt.ItemIsDropEnabled
+
+    def canDropMimeData(self, data, action, row, column, parent):
+        if parent.isValid():
+            pass
+        else:
+            return bool(self.node._onDropped)
+
+    def dropMimeData(self, data, action, row, column, parent):
+        if parent.isValid():
+            pass
+        else:
+            event = QtGui.QDropEvent(QtCore.QPoint(0,0), action, data, QtCore.Qt.MouseButton.LeftButton, QtCore.Qt.KeyboardModifier.NoModifier, QtCore.QEvent.Drop)
+            self.node._onDropped[0](event, *self.node._onDropped[1], **self.node._onDropped[2])
+
+    def parent(self, index):
+        if not index.isValid():
+            return QModelIndex()
+        node = index.internalPointer()
+        parent_node = node.parent
+        if not isinstance(parent_node, TreeNode):
+            parent_node = None
+        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 node.data
+        return None
+
+    def rowCount(self, parent):
+        parent_node = parent.internalPointer() if parent.isValid() else self.node
+        return len(parent_node.children)
+
+    def columnCount(self, parent):
+        return 1
+
+    def hasChildren(self, parent):
+        parent_node = parent.internalPointer() if parent.isValid() else self.node
+        return len(parent_node.children) > 0
+
+    def clicked(self, node):
+        node._clicked(None)
+
+    def dblclicked(self, node):
+        node._dblclicked(None)
+
+    def expanded(self, node):
+        node._expanded()
+
+    def collapsed(self, node):
+        node._collapsed()
+
+class Tree(QtBaseWidget):
+    def __init__(self, model=None):
+        super().__init__()
+        self.layout_weight = 1
+        self.model = model
+        self.curr_model = None
+        self.pendings = []
+        self._expand_callback = None
+        self._collapse_callback = 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
+
+            self.ui.clicked.disconnect()
+            self.ui.doubleClicked.disconnect()
+            self.ui.expanded.disconnect()
+            self.ui.collapsed.disconnect()
+        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.model:
+            if self.curr_model.set(self.model):
+                self.qt_model = QAbstractItemModelAdapter(self.model)
+                self.qt_model.node = self
+                self.ui.setModel(self.qt_model)
+            else:
+                self.qt_model.modelReset.emit()
+        else:
+            if not self.qt_model:
+                self.qt_model = QTreeNodeModelAdapter()
+                self.qt_model.node = self
+                self.ui.setModel(self.qt_model)
+            else:
+                self.qt_model.beginResetModel()
+                self.qt_model.node = self
+                self.qt_model.endResetModel()
+
+        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 expand(self, cb, *args, **kwargs):
+        self._expand_callback = (cb, args, kwargs)
+        return self
+
+    def _expanded(self):
+        if self._expand_callback:
+            cb, args, kwargs = self._expand_callback
+            cb(*args, **kwargs)
+
+    def collapse(self, cb, *args, **kwargs):
+        self._collapse_callback = (cb, args, kwargs)
+        return self
+
+    def _collapsed(self):
+        if self._collapse_callback:
+            cb, args, kwargs = self._collapse_callback
+            cb(*args, **kwargs)
+
+    def on_item_clicked(self, index):
+        treenode = index.internalPointer()
+        self.get_node().qt_model.clicked(treenode)
+
+    def on_item_double_clicked(self, index):
+        treenode = index.internalPointer()
+        self.get_node().qt_model.dblclicked(treenode)
+
+    def on_item_expanded(self, index):
+        treenode = index.internalPointer()
+        self.get_node().qt_model.expanded(treenode)
+
+    def on_item_collapsed(self, index):
+        treenode = index.internalPointer()
+        self.get_node().qt_model.collapsed(treenode)
+
+class TreeNode(PUINode):
+    def __init__(self, data=""):
+        super().__init__()
+        self._set_callback = None
+        self.data = data
+        self._expand_callback = None
+        self._collapse_callback = None
+
+    def expand(self, cb, *args, **kwargs):
+        self._expand_callback = (cb, args, kwargs)
+        return self
+
+    def _expanded(self):
+        if self._expand_callback:
+            cb, args, kwargs = self._expand_callback
+            cb(*args, **kwargs)
+
+    def collapse(self, cb, *args, **kwargs):
+        self._collapse_callback = (cb, args, kwargs)
+        return self
+
+    def _collapsed(self):
+        if self._collapse_callback:
+            cb, args, kwargs = self._collapse_callback
+            cb(*args, **kwargs)

PUI/PySide6/window.py

@@ -0,0 +1,82 @@
+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.puinode._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.puinode = 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.puinode = 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.resize(800, 600) # workaround on windows ref: https://stackoverflow.com/questions/27157312/qt-showmaximized-not-working-in-windows
+            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])