meerk40t 0.9.3001__py2.py3-none-any.whl → 0.9.7010__py2.py3-none-any.whl

meerk40t/core/node/blobnode.py

@@ -1,86 +1,83 @@
-from meerk40t.core.node.node import Node
-
-
-class BlobNode(Node):
-    """
-    BlobNode is a basic operation containing raw data of some type. This consists of a series of bytes.
-
-    Node type "blob"
-    """
-
-    def __init__(self, **kwargs):
-        self.data = None
-        self.data_type = None
-        self.views = {}
-        self.label = "Blob"
-        self.output = True
-        super().__init__(type="blob", **kwargs)
-        self._formatter = "{element_type}:{data_type}:{label} @{length}"
-
-    def __len__(self):
-        if self.data is None:
-            return 0
-        return len(self.data)
-
-    def default_map(self, default_map=None):
-        default_map = super().default_map(default_map=default_map)
-        default_map["element_type"] = "Blob"
-        default_map["data_type"] = self.data_type
-        default_map["label"] = self.label
-        d = 0
-        if self.data is not None:
-            d = len(self.data)
-        default_map["length"] = d
-        return default_map
-
-    def drop(self, drag_node, modify=True):
-        return False
-
-    def allow_save(self):
-        """
-        Returns false to prevent saving of blob types into operations.
-        @return:
-        """
-        return False
-
-    @staticmethod
-    def hex_view(data, data_type):
-        header1 = f"Data-Type: {data_type}, Length={len(data)}\n"
-        header2 = "Offset | Hex                                             | Ascii          \n"
-        header2 += "-------+-------------------------------------------------+----------------\n"
-        if isinstance(data, str):
-            data = data.encode("latin-1")
-
-        def create_table():
-            ascii_list = list()
-            for i, c in enumerate(data):
-                q = i % 16
-                if q == 0:
-                    yield f"{i:06x}  "
-                yield f"{c:02x} "
-                if c in (0x00, 0x0D, 0x0A, 0x09) or c > 0x80:
-                    ascii_list.append(".")
-                else:
-                    ascii_list.append(chr(c))
-                if q == 7:
-                    yield " "
-                if q == 15:
-                    ascii_line = "".join(ascii_list)
-                    ascii_list.clear()
-                    yield f" {ascii_line}\n"
-
-        hex_data = list(create_table())
-        return header1 + header2 + "".join(hex_data)
-
-    @staticmethod
-    def ascii_view(data, data_type):
-        header1 = f"Data-Type: {data_type}, Length={len(data)}\n"
-        header2 = "Offset | Hex                                             | Ascii          \n"
-        header2 += "-------+-------------------------------------------------+----------------\n"
-        if isinstance(data, str):
-            data = data.encode("latin-1")
-        return header1 + data.decode("latin-1")
-
-    def generate(self):
-        if self.data:
-            yield "blob", self.data_type, self.data
+from meerk40t.core.node.node import Node
+
+
+class BlobNode(Node):
+    """
+    BlobNode is a basic operation containing raw data of some type. This consists of a series of bytes.
+
+    Node type "blob"
+    """
+
+    def __init__(self, **kwargs):
+        self.data = None
+        self.data_type = None
+        self.views = {}
+        self.label = "Blob"
+        self.output = True
+        super().__init__(type="blob", **kwargs)
+        self._formatter = "{element_type}:{data_type}:{label} @{length}"
+
+    def __len__(self):
+        if self.data is None:
+            return 0
+        return len(self.data)
+
+    def default_map(self, default_map=None):
+        default_map = super().default_map(default_map=default_map)
+        default_map["element_type"] = "Blob"
+        default_map["data_type"] = self.data_type
+        default_map["label"] = self.label
+        d = 0
+        if self.data is not None:
+            d = len(self.data)
+        default_map["length"] = d
+        return default_map
+
+    def allow_save(self):
+        """
+        Returns false to prevent saving of blob types into operations.
+        @return:
+        """
+        return False
+
+    @staticmethod
+    def hex_view(data, data_type):
+        header1 = f"Data-Type: {data_type}, Length={len(data)}\n"
+        header2 = "Offset | Hex                                             | Ascii          \n"
+        header2 += "-------+-------------------------------------------------+----------------\n"
+        if isinstance(data, str):
+            data = data.encode("latin-1")
+
+        def create_table():
+            ascii_list = list()
+            for i, c in enumerate(data):
+                q = i % 16
+                if q == 0:
+                    yield f"{i:06x}  "
+                yield f"{c:02x} "
+                if c in (0x00, 0x0D, 0x0A, 0x09) or c > 0x80:
+                    ascii_list.append(".")
+                else:
+                    ascii_list.append(chr(c))
+                if q == 7:
+                    yield " "
+                if q == 15:
+                    ascii_line = "".join(ascii_list)
+                    ascii_list.clear()
+                    yield f" {ascii_line}\n"
+
+        hex_data = list(create_table())
+        return header1 + header2 + "".join(hex_data)
+
+    @staticmethod
+    def ascii_view(data, data_type):
+        header1 = f"Data-Type: {data_type}, Length={len(data)}\n"
+        header2 = "Offset | Hex                                             | Ascii          \n"
+        header2 += "-------+-------------------------------------------------+----------------\n"
+        if isinstance(data, str):
+            data = data.encode("latin-1")
+        return header1 + data.decode("latin-1")
+
+    def generate(self):
+        if self.data:
+            yield "blob", self.data_type, self.data

meerk40t/core/node/bootstrap.py

@@ -1,103 +1,105 @@
-from meerk40t.core.node.blobnode import BlobNode
-from meerk40t.core.node.branch_elems import BranchElementsNode
-from meerk40t.core.node.branch_ops import BranchOperationsNode
-from meerk40t.core.node.branch_regmark import BranchRegmarkNode
-from meerk40t.core.node.cutnode import CutNode
-from meerk40t.core.node.effect_hatch import HatchEffectNode
-from meerk40t.core.node.effect_wobble import WobbleEffectNode
-from meerk40t.core.node.elem_ellipse import EllipseNode
-from meerk40t.core.node.elem_image import ImageNode
-from meerk40t.core.node.elem_line import LineNode
-from meerk40t.core.node.elem_path import PathNode
-from meerk40t.core.node.elem_point import PointNode
-from meerk40t.core.node.elem_polyline import PolylineNode
-from meerk40t.core.node.elem_rect import RectNode
-from meerk40t.core.node.elem_text import TextNode
-from meerk40t.core.node.filenode import FileNode
-from meerk40t.core.node.groupnode import GroupNode
-from meerk40t.core.node.image_raster import ImageRasterNode
-from meerk40t.core.node.layernode import LayerNode
-from meerk40t.core.node.op_cut import CutOpNode
-from meerk40t.core.node.op_dots import DotsOpNode
-from meerk40t.core.node.op_engrave import EngraveOpNode
-from meerk40t.core.node.op_image import ImageOpNode
-from meerk40t.core.node.op_raster import RasterOpNode
-from meerk40t.core.node.place_current import PlaceCurrentNode
-from meerk40t.core.node.place_point import PlacePointNode
-from meerk40t.core.node.refnode import ReferenceNode
-from meerk40t.core.node.rootnode import RootNode
-from meerk40t.core.node.util_console import ConsoleOperation
-from meerk40t.core.node.util_goto import GotoOperation
-from meerk40t.core.node.util_home import HomeOperation
-from meerk40t.core.node.util_input import InputOperation
-from meerk40t.core.node.util_output import OutputOperation
-from meerk40t.core.node.util_wait import WaitOperation
-
-defaults = {
-    "root": {},
-    "op cut": {"speed": 12.0, "color": "red", "frequency": 30.0},
-    "op engrave": {"speed": 35.0, "color": "blue", "frequency": 30.0},
-    "op raster": {"speed": 150.0, "dpi": 500, "color": "black", "frequency": 30.0},
-    "op image": {"speed": 150.0, "color": "transparent", "frequency": 30.0},
-    "op dots": {"speed": 150.0, "color": "transparent", "frequency": 30.0},
-    "util console": {},
-    "util wait": {},
-    "util home": {},
-    "util goto": {},
-    "util input": {},
-    "util output": {},
-    "blob": {},
-    "group": {},
-    "layer": {},
-    "elem ellipse": {},
-    "elem line": {},
-    "elem rect": {},
-    "elem path": {},
-    "elem point": {},
-    "elem polyline": {},
-    "elem image": {"dpi": 500},
-    "elem text": {},
-    "reference": {},
-    "cutcode": {},
-    "branch ops": {},
-    "branch elems": {},
-    "branch reg": {},
-    "file": {},
-}
-
-bootstrap = {
-    "root": RootNode,
-    "op cut": CutOpNode,
-    "op engrave": EngraveOpNode,
-    "op raster": RasterOpNode,
-    "op image": ImageOpNode,
-    "op dots": DotsOpNode,
-    "effect hatch": HatchEffectNode,
-    "effect wobble": WobbleEffectNode,
-    "util console": ConsoleOperation,
-    "util wait": WaitOperation,
-    "util home": HomeOperation,
-    "util goto": GotoOperation,
-    "util input": InputOperation,
-    "util output": OutputOperation,
-    "place point": PlacePointNode,
-    "place current": PlaceCurrentNode,
-    "blob": BlobNode,
-    "group": GroupNode,
-    "layer": LayerNode,
-    "elem ellipse": EllipseNode,
-    "elem line": LineNode,
-    "elem rect": RectNode,
-    "elem path": PathNode,
-    "elem point": PointNode,
-    "elem polyline": PolylineNode,
-    "elem image": ImageNode,
-    "elem text": TextNode,
-    "image raster": ImageRasterNode,
-    "reference": ReferenceNode,
-    "cutcode": CutNode,
-    "branch ops": BranchOperationsNode,
-    "branch elems": BranchElementsNode,
-    "branch reg": BranchRegmarkNode,
-    "file": FileNode,
-}
+from meerk40t.core.node.blobnode import BlobNode
+from meerk40t.core.node.branch_elems import BranchElementsNode
+from meerk40t.core.node.branch_ops import BranchOperationsNode
+from meerk40t.core.node.branch_regmark import BranchRegmarkNode
+from meerk40t.core.node.cutnode import CutNode
+from meerk40t.core.node.effect_hatch import HatchEffectNode
+from meerk40t.core.node.effect_warp import WarpEffectNode
+from meerk40t.core.node.effect_wobble import WobbleEffectNode
+from meerk40t.core.node.elem_ellipse import EllipseNode
+from meerk40t.core.node.elem_image import ImageNode
+from meerk40t.core.node.elem_line import LineNode
+from meerk40t.core.node.elem_path import PathNode
+from meerk40t.core.node.elem_point import PointNode
+from meerk40t.core.node.elem_polyline import PolylineNode
+from meerk40t.core.node.elem_rect import RectNode
+from meerk40t.core.node.elem_text import TextNode
+from meerk40t.core.node.filenode import FileNode
+from meerk40t.core.node.groupnode import GroupNode
+from meerk40t.core.node.image_raster import ImageRasterNode
+from meerk40t.core.node.layernode import LayerNode
+from meerk40t.core.node.op_cut import CutOpNode
+from meerk40t.core.node.op_dots import DotsOpNode
+from meerk40t.core.node.op_engrave import EngraveOpNode
+from meerk40t.core.node.op_image import ImageOpNode
+from meerk40t.core.node.op_raster import RasterOpNode
+from meerk40t.core.node.place_current import PlaceCurrentNode
+from meerk40t.core.node.place_point import PlacePointNode
+from meerk40t.core.node.refnode import ReferenceNode
+from meerk40t.core.node.rootnode import RootNode
+from meerk40t.core.node.util_console import ConsoleOperation
+from meerk40t.core.node.util_goto import GotoOperation
+from meerk40t.core.node.util_home import HomeOperation
+from meerk40t.core.node.util_input import InputOperation
+from meerk40t.core.node.util_output import OutputOperation
+from meerk40t.core.node.util_wait import WaitOperation
+
+defaults = {
+    "root": {},
+    "op cut": {"speed": 12.0, "color": "red", "frequency": 30.0},
+    "op engrave": {"speed": 35.0, "color": "blue", "frequency": 30.0},
+    "op raster": {"speed": 150.0, "dpi": 500, "color": "black", "frequency": 30.0},
+    "op image": {"speed": 150.0, "color": "transparent", "frequency": 30.0},
+    "op dots": {"speed": 150.0, "color": "transparent", "frequency": 30.0},
+    "util console": {},
+    "util wait": {},
+    "util home": {},
+    "util goto": {},
+    "util input": {},
+    "util output": {},
+    "blob": {},
+    "group": {},
+    "layer": {},
+    "elem ellipse": {},
+    "elem line": {},
+    "elem rect": {},
+    "elem path": {},
+    "elem point": {},
+    "elem polyline": {},
+    "elem image": {"dpi": 500},
+    "elem text": {},
+    "reference": {},
+    "cutcode": {},
+    "branch ops": {},
+    "branch elems": {},
+    "branch reg": {},
+    "file": {},
+}
+
+bootstrap = {
+    "root": RootNode,
+    "op cut": CutOpNode,
+    "op engrave": EngraveOpNode,
+    "op raster": RasterOpNode,
+    "op image": ImageOpNode,
+    "op dots": DotsOpNode,
+    "effect hatch": HatchEffectNode,
+    "effect wobble": WobbleEffectNode,
+    "effect warp": WarpEffectNode,
+    "util console": ConsoleOperation,
+    "util wait": WaitOperation,
+    "util home": HomeOperation,
+    "util goto": GotoOperation,
+    "util input": InputOperation,
+    "util output": OutputOperation,
+    "place point": PlacePointNode,
+    "place current": PlaceCurrentNode,
+    "blob": BlobNode,
+    "group": GroupNode,
+    "layer": LayerNode,
+    "elem ellipse": EllipseNode,
+    "elem line": LineNode,
+    "elem rect": RectNode,
+    "elem path": PathNode,
+    "elem point": PointNode,
+    "elem polyline": PolylineNode,
+    "elem image": ImageNode,
+    "elem text": TextNode,
+    "image raster": ImageRasterNode,
+    "reference": ReferenceNode,
+    "cutcode": CutNode,
+    "branch ops": BranchOperationsNode,
+    "branch elems": BranchElementsNode,
+    "branch reg": BranchRegmarkNode,
+    "file": FileNode,
+}

meerk40t/core/node/branch_elems.py

@@ -1,31 +1,40 @@
-from meerk40t.core.node.node import Node
-
-
-class BranchElementsNode(Node):
-    """
-    Branch Element Node.
-    Bootstrapped type: 'branch elems'
-    """
-
-    def __init__(self, **kwargs):
-        super().__init__(type="branch elems", **kwargs)
-        self._formatter = "{element_type}"
-
-    def default_map(self, default_map=None):
-        default_map = super().default_map(default_map=default_map)
-        default_map["element_type"] = "Elements"
-        return default_map
-
-    def drop(self, drag_node, modify=True):
-        if drag_node.type.startswith("elem"):
-            if modify:
-                self.append_child(drag_node)
-            return True
-        elif drag_node.type == "group":
-            if modify:
-                self.append_child(drag_node)
-            return True
-        return False
-
-    def is_draggable(self):
-        return False
+from meerk40t.core.node.node import Node
+
+
+class BranchElementsNode(Node):
+    """
+    Branch Element Node.
+    Bootstrapped type: 'branch elems'
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(type="branch elems", **kwargs)
+        self._formatter = "{element_type}"
+
+    def default_map(self, default_map=None):
+        default_map = super().default_map(default_map=default_map)
+        default_map["element_type"] = "Elements"
+        return default_map
+
+    def can_drop(self, drag_node):
+        return bool(
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type == "group"
+        )
+    
+    def drop(self, drag_node, modify=True, flag=False):
+        if not self.can_drop(drag_node):
+            return False
+        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image"):
+            if modify:
+                self.append_child(drag_node)
+            return True
+        elif drag_node.type == "group":
+            if modify:
+                self.append_child(drag_node)
+            return True
+        return False
+    
+    def is_draggable(self):
+        return False

meerk40t/core/node/branch_ops.py

@@ -1,38 +1,45 @@
-from meerk40t.core.node.node import Node
-
-
-class BranchOperationsNode(Node):
-    """
-    Branch Operations Node.
-    Bootstrapped type: 'branch reg'
-    """
-
-    def __init__(self, **kwargs):
-        self.loop_enabled = False
-        self.loop_continuous = False
-        self.loop_n = 1
-        super().__init__(type="branch ops", **kwargs)
-        self._formatter = "{element_type} {loops}"
-
-    def default_map(self, default_map=None):
-        default_map = super().default_map(default_map=default_map)
-        default_map["element_type"] = "Operations"
-        if self.loop_continuous:
-            default_map["loops"] = "∞"
-        else:
-            if self.loop_enabled:
-                default_map["loops"] = str(self.loop_n)
-            else:
-                default_map["loops"] = ""
-        return default_map
-
-    def drop(self, drag_node, modify=True):
-        if drag_node.type.startswith("op"):
-            # Dragging operation to op branch to effectively move to bottom.
-            if modify:
-                self.append_child(drag_node)
-            return True
-        return False
-
-    def is_draggable(self):
-        return False
+from meerk40t.core.node.node import Node
+
+
+class BranchOperationsNode(Node):
+    """
+    Branch Operations Node.
+    Bootstrapped type: 'branch reg'
+    """
+
+    def __init__(self, **kwargs):
+        self.loop_enabled = False
+        self.loop_continuous = False
+        self.loop_n = 1
+        super().__init__(type="branch ops", **kwargs)
+        self._formatter = "{element_type} {loops}"
+
+    def default_map(self, default_map=None):
+        default_map = super().default_map(default_map=default_map)
+        default_map["element_type"] = "Operations"
+        if self.loop_continuous:
+            default_map["loops"] = "∞"
+        else:
+            if self.loop_enabled:
+                default_map["loops"] = str(self.loop_n)
+            else:
+                default_map["loops"] = ""
+        return default_map
+
+    def can_drop(self, drag_node):
+        return bool(
+            drag_node.type.startswith("op ") or drag_node.type.startswith("util ")
+        )
+
+    def drop(self, drag_node, modify=True, flag=False):
+        if not self.can_drop(drag_node):
+            return False
+        if drag_node.type.startswith("op ") or drag_node.type.startswith("util "):
+            # Dragging operation to op branch to effectively move to bottom.
+            if modify:
+                self.append_child(drag_node)
+            return True
+        return False
+        
+    def is_draggable(self):
+        return False

meerk40t/core/node/branch_regmark.py

@@ -1,41 +1,48 @@
-from meerk40t.core.node.node import Node
-
-
-class BranchRegmarkNode(Node):
-    """
-    Branch Regmark Node.
-    Bootstrapped type: 'branch reg'
-    """
-
-    def __init__(self, **kwargs):
-        super().__init__(type="branch reg", **kwargs)
-        self._formatter = "{element_type}"
-
-    def default_map(self, default_map=None):
-        default_map = super().default_map(default_map=default_map)
-        default_map["element_type"] = "Regmarks"
-        return default_map
-
-    def remove_references(self, node):
-        ct = 0
-        for ref in list(node.references):
-            ct += 1
-            ref.remove_node(fast=False)
-        for ref in list(node.children):
-            self.remove_references(ref)
-
-    def drop(self, drag_node, modify=True):
-        if drag_node.type.startswith("elem"):
-            if modify:
-                self.remove_references(drag_node)
-                self.append_child(drag_node)
-            return True
-        elif drag_node.type == "group":
-            if modify:
-                self.remove_references(drag_node)
-                self.append_child(drag_node)
-            return True
-        return False
-
-    def is_draggable(self):
-        return False
+from meerk40t.core.node.node import Node
+
+
+class BranchRegmarkNode(Node):
+    """
+    Branch Regmark Node.
+    Bootstrapped type: 'branch reg'
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(type="branch reg", **kwargs)
+        self._formatter = "{element_type}"
+
+    def default_map(self, default_map=None):
+        default_map = super().default_map(default_map=default_map)
+        default_map["element_type"] = "Regmarks"
+        return default_map
+
+    def remove_references(self, node):
+        ct = 0
+        for ref in list(node.references):
+            ct += 1
+            ref.remove_node(fast=False)
+        for ref in list(node.children):
+            self.remove_references(ref)
+
+    def can_drop(self, drag_node):
+        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type == "group":
+            return True
+        return False
+    
+    def drop(self, drag_node, modify=True, flag=False):
+        if not self.can_drop(drag_node):
+            return False
+        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image"):
+            if modify:
+                self.remove_references(drag_node)
+                self.append_child(drag_node)
+            return True
+        elif drag_node.type == "group":
+            if modify:
+                self.remove_references(drag_node)
+                self.append_child(drag_node)
+            return True
+        return False
+
+    def is_draggable(self):
+        return False