qpuiq 0.10__py3-none-any.whl

PUI/__init__.py

@@ -0,0 +1,46 @@
+__version__ = "0.10"
+
+from .node import *
+from .view import *
+from .state import *
+from .timeline import *
+from .decorator import *
+from .common import *
+from .interfaces import *
+
+try:
+    import jurigged
+    w = jurigged.watch("/")
+    def postrun(path, cf):
+        PUIView.reload()
+    w.postrun.register(postrun)
+except ImportError:
+    pass
+
+class Prop():
+    def __init__(self, value=None):
+        self.value = value
+
+    def set(self, value):
+        changed = (self.value != value)
+        self.value = value
+        return changed
+
+class NotImplementedNode():
+    def __init__(self, *args, **kwargs):
+        print("Not Implemented")
+        import traceback
+        import inspect
+        traceback.print_stack(inspect.currentframe().f_back, 1)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+    def layout(self, *args, **kwargs):
+        return self
+
+    def style(self, *args, **kwargs):
+        return self

PUI/common.py

@@ -0,0 +1,20 @@
+from enum import Enum
+from enum import IntEnum
+class Anchor(Enum):
+    LEFT_TOP = ("left" ,"top")
+    LEFT_CENTER = ("left" ,"center")
+    LEFT_BOTTOM = ("left" ,"bottom")
+    CENTER_TOP = ("center" ,"top")
+    CENTER = ("center" ,"center")
+    CENTER_BOTTOM = ("center" ,"bottom")
+    RIGHT_TOP = ("right" ,"top")
+    RIGHT_CENTER = ("right" ,"center")
+    RIGHT_BOTTOM = ("right" ,"bottom")
+
+class MouseButton(IntEnum):
+    NONE = 0
+    LEFT = 1
+    RIGHT = 2
+    MIDDLE = 4
+    X1 = 8
+    X2 = 16

PUI/decorator.py

@@ -0,0 +1,20 @@
+from .view import *
+
+def PUI(func):
+    """
+    PUI.PUI triggers update() directly by redraw()
+    """
+    def func_wrapper(*args, **kwargs):
+        class PUIViewWrapper(PUIView):
+            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/dom.py

@@ -0,0 +1,238 @@
+DEBUG = False
+
+class VDomError(Exception):
+    pass
+
+def recur_delete(node, child, direct):
+    child.destroyed = True
+    for sc in child.children:
+        if sc is not None:
+            recur_delete(child, sc, False)
+    if DEBUG:
+        print("recur_delete", node.key, child.key, direct)
+    child.destroy(direct)
+
+def sortGridDOMInPlace(dom):
+    dom[:] = [c for c in dom if c.grid_row is not None and c.grid_column is not None]
+    dom.sort(key=lambda c:(c.grid_row, c.grid_column, c.grid_rowspan, c.grid_columnspan))
+
+def dom_remove_node(dom_parent, dom_offset, child):
+    if child.pui_virtual:
+        ret = [child]
+        for c in child.children:
+            ret.extend(dom_remove_node(dom_parent, dom_offset, c))
+        return ret
+    else:
+        dom_parent.removeChild(dom_offset , child)
+        return [child]
+
+def dom_add_nodes(dom_parent, dom_offset, children):
+    for childIdx, c in enumerate([n for n in children if not n.pui_virtual]):
+        dom_parent.addChild(dom_offset+childIdx, c)
+
+def countDomChildren(nodes):
+    num = 0
+    for c in nodes:
+        if c.pui_virtual:
+            num += countDomChildren(c.children)
+        elif not c.pui_outoforder:
+            num += 1
+    return num
+
+def sync(node, dom_parent, dom_offset, oldVDOM, newVDOM, depth=0):
+    orig_dom_children_num = dom_children_num = countDomChildren(oldVDOM)
+    dom_children_curr = 0
+
+    if DEBUG:
+        print(f"{(depth)*'    '}Syncing {node.key}@{id(node)} parent={dom_parent.key}@{id(dom_parent)} dom_offset={dom_offset} dom_children_num={dom_children_num} old={len(oldVDOM)} new={len(newVDOM)}")
+
+    if node.pui_grid_layout:
+        sortGridDOMInPlace(oldVDOM)
+        sortGridDOMInPlace(newVDOM)
+
+    if DEBUG:
+        print(f"{(depth+1)*'    '}===OLD===")
+        for c in oldVDOM:
+            print(f"{(depth+1)*'    '}{c.key} virtual={c.pui_virtual} ui={c.ui}")
+
+        print(f"{(depth+1)*'    '}===NEW===")
+        for c in newVDOM:
+            print(f"{(depth+1)*'    '}{c.key} virtual={c.pui_virtual}")
+
+    oldVMap = [x.key for x in oldVDOM]
+    newVMap = [x.key for x in newVDOM]
+
+    node.preSync()
+
+    toBeDeleted = []
+    for childIdx, new in enumerate(newVDOM):
+        if DEBUG:
+            print(f"{(depth+1)*'    '}sync child {childIdx}, {new.key} dom_parent={dom_parent.key} virtual={new.pui_virtual}")
+        new.pui_dom_parent = dom_parent
+
+        while True:
+            # Step 1. just matched
+            if childIdx < len(oldVDOM) and oldVMap[childIdx] == new.key: # matched
+                if DEBUG:
+                    print(f"{(depth+1)*'    '}S1. MATCHED {childIdx} {new.key}")
+                old = oldVDOM[childIdx]
+
+                if old.pui_isview: # must also be virtual
+                    n = countDomChildren(old.children)
+                    dom_children_curr += n
+                    if DEBUG:
+                        print(f"{(depth+1)*'    '}    dom_children_curr += {n} => {dom_children_curr} dom_children_num={dom_children_num}")
+
+                    old.parent = new.parent
+                    old.pui_dom_parent = new.pui_dom_parent
+                    newVDOM[childIdx] = old
+                    new.destroy(True) # deregister old view from PUIView.__ALLVIEWS__
+                else:
+                    try:
+                        new.update(old)
+                    except:
+                        import traceback
+                        print("## <ERROR OF update() >")
+                        print(new.key)
+                        traceback.print_exc()
+                        print("## </ERROR OF update()>")
+
+                    if new.pui_virtual:
+                        num, delta = sync(new, node, dom_offset + dom_children_curr, old.children, new.children, depth+1)
+                        dom_children_curr += num
+                        dom_children_num += delta
+                        if DEBUG:
+                            print(f"{(depth+2)*'    '}dom_children_curr += {num} => {dom_children_curr} dom_children_num += {delta} => {dom_children_num}")
+                    else:
+                        if not new.pui_outoforder:
+                            dom_children_curr += 1
+                            if DEBUG:
+                                print(f"{(depth+2)*'    '}dom_children_curr += 1 => {dom_children_curr} dom_children_num={dom_children_num}")
+
+                        if not new.pui_terminal:
+                            sync(new, new, 0, old.children, new.children, depth+1)
+
+                break # finish
+
+            # Step 2. trim removed nodes after common prefix
+            trimmed = False
+            while childIdx < len(oldVDOM) and not oldVDOM[childIdx].key in newVMap[childIdx:]: # trim old nodes
+                if DEBUG:
+                    print(f"{(depth+1)*'    '}S2. TRIM {childIdx} {oldVDOM[childIdx].key}")
+                old = oldVDOM.pop(childIdx)
+                oldVMap.pop(childIdx)
+                nodes = dom_remove_node(dom_parent, dom_offset + dom_children_curr, old)
+                n = len([n for n in nodes if not n.pui_virtual and not n.pui_outoforder])
+                dom_children_num -= n
+                if DEBUG:
+                    print(f"{(depth+2)*'    '}dom_children_num -= {n} => {dom_children_num}")
+                toBeDeleted.extend(nodes)
+                trimmed = True
+
+            if trimmed:
+                continue # restart
+
+            # Step 3. setup target node
+
+            try:
+                matchedIdx = oldVMap[childIdx+1:].index(new.key) + childIdx + 1
+            except ValueError:
+                matchedIdx = None
+
+            ## Step 3-1. new node
+            if matchedIdx is None:
+                if DEBUG:
+                    print(f"{(depth+1)*'    '}S3-1. NEW {childIdx} {new.key}")
+                # always populate new node regardless of isview or not
+                try:
+                    new.update(None)
+                except:
+                    import traceback
+                    print("## <ERROR OF update() >")
+                    print(new.key)
+                    traceback.print_exc()
+                    print("## </ERROR OF update()>")
+
+                if new.pui_virtual:
+                    num, delta = sync(new, dom_parent, dom_offset + dom_children_curr, [], new.children, depth+1)
+                    dom_children_curr += num
+                    dom_children_num += num
+                    if DEBUG:
+                        print(f"{(depth+2)*'    '}dom_children_curr += {num} => {dom_children_curr} dom_children_num += {num} => {dom_children_num}")
+                else:
+                    if DEBUG:
+                        print(f"{(depth+1)*'    '}addChild", dom_parent.key, dom_offset + dom_children_curr, new.key)
+                    dom_parent.addChild(dom_offset + dom_children_curr, new)
+
+                    if not new.pui_outoforder:
+                        dom_children_curr += 1
+                        dom_children_num += 1
+                        if DEBUG:
+                            print(f"{(depth+2)*'    '}dom_children_curr += 1 => {dom_children_curr} dom_children_num += 1 => {dom_children_num}")
+
+                    if not new.pui_terminal:
+                        sync(new, new, 0, [], new.children, depth+1)
+
+                oldVDOM.insert(childIdx, new) # put new node back for later findDomOffsetForNode
+                oldVMap.insert(childIdx, new.key)
+
+            ## Step 3-2. existed node
+            else:
+                # if the target node is in just next position, requeue the blocker to prevent repositioning every nodes coming after
+                # eg. when an element is removed from a long list, do single 3-2-1 instead of many 3-2-2
+
+                ### Step 3-2-1. yield the next position for the target node
+                if matchedIdx == childIdx + 1:
+                    if DEBUG:
+                        print(f"{(depth+1)*'    '}S3-2-1. YIELD {childIdx} {new.key}")
+                    oldVMap.pop(childIdx)
+                    toBeRequeued = oldVDOM.pop(childIdx)
+                    nodes = dom_remove_node(dom_parent, dom_offset + dom_children_curr, toBeRequeued)
+                    n = len([n for n in nodes if not n.pui_virtual and not n.pui_outoforder])
+                    dom_add_nodes(dom_parent, dom_children_num - n, nodes)
+                    oldVMap.append(toBeRequeued.key)
+                    oldVDOM.append(toBeRequeued)
+
+                ### Step 3-2-2. move target node
+                else:
+                    if DEBUG:
+                        print(f"{(depth+1)*'    '}S3-2-2. MOVE {childIdx} {new.key}")
+                    oldVMap.pop(matchedIdx)
+                    old = oldVDOM.pop(matchedIdx)
+                    found, offset = dom_parent.findDomOffsetForNode(old)
+                    if not found:
+                        raise VDomError(f"findDomOffsetForNode() failed for {old.key} on {dom_parent.key}")
+                    nodes = dom_remove_node(dom_parent, offset, old)
+                    dom_add_nodes(dom_parent, dom_offset + dom_children_curr, nodes)
+
+                    oldVDOM.insert(childIdx, new) # put new node back for later findDomOffsetForNode
+                    oldVMap.insert(childIdx, new.key)
+
+                continue # restart, sync will be peformed in next step 1
+
+            break # finish
+
+    # Step 4. trim removed trail
+    nl = len(newVDOM)
+    while len(oldVDOM) > nl:
+        old = oldVDOM.pop(nl)
+        oldVMap.pop(nl)
+        nodes = dom_remove_node(dom_parent, dom_offset + nl, old)
+        dom_children_num -= len([n for n in nodes if not n.pui_virtual and not n.pui_outoforder])
+        toBeDeleted.extend(nodes)
+
+    for c in newVDOM:
+        c.postUpdate()
+
+    node.postSync()
+
+    # release deleted nodes
+    for old in toBeDeleted:
+        recur_delete(node, old, True)
+
+    if DEBUG:
+        print(f"{(depth)*'    '}sync end {node.key} -> {dom_children_curr},{dom_children_num}")
+
+    if dom_children_curr != dom_children_num:
+        raise VDomError(f"dom_children_curr != dom_children_num for {node.key} -> {dom_children_curr},{dom_children_num}")
+    return dom_children_curr, dom_children_num - orig_dom_children_num

PUI/flet/__init__.py

@@ -0,0 +1,21 @@
+from .application import *
+from .button import *
+from .canvas import *
+from .checkbox import *
+from .label import *
+from .layout import *
+from .progressbar import *
+from .radiobutton import *
+from .scroll import *
+from .tab import *
+from .text import *
+from .textfield import *
+from .window import *
+from .. import NotImplementedNode
+
+Combobox = NotImplementedNode
+ComboboxItem = NotImplementedNode
+
+PUIView = FView
+
+PUI_BACKEND = "flet"

PUI/flet/application.py

@@ -0,0 +1,42 @@
+from .. import *
+from .base import *
+
+class Application(PUIView):
+    def __init__(self):
+        super().__init__()
+        self.ready = False
+
+    def sync(self):
+        if not self.ready:
+            return
+        super().sync()
+
+    def flet_app(self, page: ft.Page):
+        self.ui = page
+        self.ready = True
+        self.sync()
+
+    def addChild(self, idx, child):
+        if idx > 0:
+            print("Flet backend only support single window")
+
+    def removeChild(self, idx, child):
+        pass
+
+    def start(self):
+        ft.app(self.flet_app)
+
+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/flet/base.py

@@ -0,0 +1,37 @@
+from .. import *
+import flet as ft
+
+def _apply_params(ui, params):
+    for k,v in params.items():
+        setattr(ui, k, v)
+
+class FView(PUIView):
+    pui_virtual = True
+
+class FBase(PUINode):
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.child_weight = None
+        if self.fparent:
+            self.layout_weight = self.fparent.child_weight
+
+        self.flet_params = {}
+
+    def flet(self, **kwargs):
+        for k,v in kwargs.items():
+            self.flet_params[k] = v
+        return self
+
+    def update(self, prev):
+        _apply_params(self.ui, self.flet_params)
+        super().update(prev)
+
+    @property
+    def fparent(self):
+        parent = self.parent
+        while True:
+            if isinstance(parent, FBase):
+                return parent
+            if parent.parent == parent:
+                return None
+            parent = parent.parent

PUI/flet/button.py

@@ -0,0 +1,20 @@
+from .. import *
+from .base import *
+
+class Button(FBase):
+    def __init__(self, text):
+        super().__init__()
+        self.text = text
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+            self.ui.text = self.text
+            self.ui.on_click = self._clicked
+            try:
+                self.ui.update()
+            except:
+                pass
+        else:
+            self.ui = ft.ElevatedButton(text=self.text, on_click=self._clicked)
+        self.ui.expand = self.layout_weight

PUI/flet/canvas.py

@@ -0,0 +1,86 @@
+from .. import *
+from .base import *
+import flet.canvas as cv
+
+class Canvas(FBase):
+    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
+        else:
+            self.ui = cv.Canvas()
+        if self.layout_width:
+            self.ui.width = self.layout_width
+        else:
+            self.ui.width = float("inf")
+        if self.layout_height:
+            self.ui.height = self.layout_height
+        else:
+            self.ui.height = float("inf")
+        self.ui.shapes.clear()
+        self.painter(self, *self.args)
+        try:
+            self.ui.update()
+        except:
+            pass
+        super().update(prev)
+
+    def drawText(self, x, y, text, w=None, h=None, rotate=0, anchor=Anchor.LEFT_TOP):
+        if rotate !=0:
+            print("drawText: rotate not implemented")
+        self.ui.shapes.append(
+            cv.Text(
+                x,
+                y,
+                text,
+            )
+        )
+
+    def drawLine(self, x1, y1, x2, y2, color=None, width=None):
+        params = {}
+        if not color is None:
+            params["color"] = f"#{color:06X}"
+        if not width is None:
+            params["stroke_width"] = width
+        self.ui.shapes.append(
+            cv.Line(
+                x1,
+                y1,
+                x2,
+                y2,
+                ft.Paint(**params, style=ft.PaintingStyle.STROKE)
+            ),
+        )
+
+    def drawPolyline(self, coords, color=None, width=None):
+        params = {}
+        if not color is None:
+            params["color"] = f"#{color:06X}"
+        if not width is None:
+            params["stroke_width"] = width
+        paint = ft.Paint(**params, style=ft.PaintingStyle.STROKE)
+        for i in range(1, len(coords)):
+            self.ui.shapes.append(
+                cv.Line(
+                    coords[i-1][0],
+                    coords[i-1][1],
+                    coords[i][0],
+                    coords[i][1],
+                    paint
+                ),
+            )
+
+    def drawPolygon(self, coords, fill=None, stroke=None, width=1):
+        print("drawPolygon not implemented")
+
+    def drawRect(self, x1, y1, x2, y2, fill=None, stroke=None, width=1):
+        print("drawRect not implemented")
+
+    def drawEllipse(self, x, y, rx, ry, fill=None, stroke=None, width=1):
+        print("drawEllipse not implemented")

PUI/flet/checkbox.py

@@ -0,0 +1,23 @@
+from .. import *
+from .base import *
+
+class Checkbox(FBase):
+    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
+            self.ui.value = self.model.value
+            self.ui.on_change = self._changed
+            self.ui.update()
+        else:
+            self.ui = ft.Checkbox(label=self.text, value=self.model.value, on_change=self._changed)
+
+        super().update(prev)
+
+    def _changed(self, event):
+        node = self.get_node()
+        self.model.value = node.ui.value

PUI/flet/label.py

@@ -0,0 +1,27 @@
+from .. import *
+from .base import *
+
+class Label(FBase):
+    def __init__(self, text, selectable=False):
+        super().__init__()
+        self.text = text
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+        else:
+            self.ui = ft.Text(spans=[])
+        self.ui.expand = self.layout_weight
+        if self._onClicked:
+            self.ui.spans = [
+                ft.TextSpan(self.text, on_click=self._clicked)
+            ]
+        else:
+            self.ui.spans = [
+                ft.TextSpan(self.text)
+            ]
+        try:
+            self.ui.update()
+        except:
+            pass
+        super().update(prev)

PUI/flet/layout.py

@@ -0,0 +1,50 @@
+from .. import *
+from .base import *
+
+class HBox(FBase):
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+        else:
+            self.ui = ft.Row()
+        self.ui.expand = self.layout_weight
+        super().update(prev)
+
+    def addChild(self, idx, child):
+        self.ui.controls.insert(idx, child.outer)
+        try:
+            self.ui.update()
+        except:
+            pass
+
+    def removeChild(self, idx, child):
+        self.ui.controls.pop(idx)
+        self.ui.update()
+
+class VBox(FBase):
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+        else:
+            self.ui = ft.Column()
+        self.ui.expand = self.layout_weight
+        super().update(prev)
+
+    def addChild(self, idx, child):
+        self.ui.controls.insert(idx, child.outer)
+        try:
+            self.ui.update()
+        except:
+            pass
+
+    def removeChild(self, idx, child):
+        self.ui.controls.pop(idx)
+        self.ui.update()
+
+class Spacer(FBase):
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+        else:
+            self.ui = ft.Container()
+        super().update(prev)

PUI/flet/progressbar.py

@@ -0,0 +1,21 @@
+from .. import *
+from .base import *
+
+class ProgressBar(FBase):
+    def __init__(self, progress, maximum=1):
+        super().__init__()
+        self.progress = progress
+        self.maximum = maximum
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.ui = prev.ui
+        else:
+            self.ui = ft.ProgressBar(width=300) # XXX
+        self.ui.value = max(self.progress / self.maximum, 0)
+        self.ui.expand = self.layout_weight
+        try:
+            self.ui.update()
+        except:
+            pass
+        super().update(prev)

PUI/flet/radiobutton.py

@@ -0,0 +1,27 @@
+from .. import *
+from .base import *
+
+class RadioButton(FBase):
+    def __init__(self, text, value, model):
+        super().__init__()
+        self.text = text
+        self.value = value
+        self.model = model
+
+    def update(self, prev):
+        if prev and prev.ui:
+            self.radio = prev.radio
+            self.ui = prev.ui
+            self.radio.value = self.value
+            self.ui.value = self.model.value
+            self.ui.on_change = self._changed
+            self.ui.update()
+        else:
+            self.radio = ft.Radio(value=self.value, label=self.text)
+            self.ui = ft.RadioGroup(content=self.radio, on_change=self._changed)
+        super().update(prev)
+
+    def _changed(self, event):
+        node = self.get_node()
+        if event.control.value:
+            self.model.value = node.value