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

meerk40t/core/node/util_goto.py

@@ -1,65 +1,84 @@
-from meerk40t.core.cutcode.gotocut import GotoCut
-from meerk40t.core.elements.element_types import *
-from meerk40t.core.node.node import Node
-
-
-class GotoOperation(Node):
-    """
-    GotoOperation tells the controller to return to origin.
-
-    Node type "util goto"
-    """
-
-    def __init__(self, **kwargs):
-        self.output = True
-        self.x = 0.0
-        self.y = 0.0
-        super().__init__(type="util goto", **kwargs)
-        self._formatter = "{enabled}{element_type} {x} {y}"
-
-    def __repr__(self):
-        return f"GotoOperation('{self.x}, {self.y}')"
-
-    def __len__(self):
-        return 1
-
-    @property
-    def implicit_passes(self):
-        return 1
-
-    def default_map(self, default_map=None):
-        default_map = super().default_map(default_map=default_map)
-        origin = self.x == 0 and self.y == 0
-        default_map["element_type"] = "Origin" if origin else "Goto"
-        default_map["enabled"] = "(Disabled) " if not self.output else ""
-        default_map["adjust"] = f" ({self.x}, {self.y})" if not origin else ""
-        default_map.update(self.__dict__)
-        return default_map
-
-    def drop(self, drag_node, modify=True):
-        drop_node = self
-        if drag_node.type in op_nodes:
-            if modify:
-                drop_node.insert_sibling(drag_node)
-            return True
-        elif drop_node.type == "branch ops":
-            # Dragging operation to op branch to effectively move to bottom.
-            if modify:
-                drop_node.append_child(drag_node)
-            return True
-        return False
-
-    def as_cutobjects(self, closed_distance=15, passes=1):
-        """
-        Generator of cutobjects for a raster operation. This takes any image node children
-        and converts them into rastercut objects. These objects should have already been converted
-        from vector shapes.
-
-        The preference for raster shapes is to use the settings set on this operation rather than on the image-node.
-        """
-        cut = GotoCut((self.x, self.y))
-        cut.original_op = self.type
-        yield cut
-
-    def generate(self):
-        yield "move_abs", self.x, self.y
+from meerk40t.core.cutcode.gotocut import GotoCut
+from meerk40t.core.elements.element_types import op_nodes
+from meerk40t.core.node.node import Node
+
+
+class GotoOperation(Node):
+    """
+    GotoOperation tells the controller to return to origin.
+
+    Node type "util goto"
+    """
+
+    def __init__(self, **kwargs):
+        self.output = True
+        self.x = 0.0
+        self.y = 0.0
+        self.absolute = False
+        super().__init__(type="util goto", **kwargs)
+        self._formatter = "{enabled}{element_type} {absolute}{x} {y} "
+
+    def __repr__(self):
+        return f"GotoOperation('{self.x}, {self.y}')"
+
+    def __len__(self):
+        return 1
+
+    @property
+    def implicit_passes(self):
+        return 1
+
+    def default_map(self, default_map=None):
+        default_map = super().default_map(default_map=default_map)
+        origin = self.x == 0 and self.y == 0
+        default_map["element_type"] = "Origin" if origin else "Goto"
+        default_map["enabled"] = "(Disabled) " if not self.output else ""
+        default_map["adjust"] = f" ({self.x}, {self.y})" if not origin else ""
+        default_map.update(self.__dict__)
+        default_map["absolute"] = "=" if self.absolute else ""
+        return default_map
+
+    def can_drop(self, drag_node):
+        # Move operation to a different position.
+        return bool(drag_node.type in op_nodes)
+
+    def drop(self, drag_node, modify=True, flag=False):
+        # Default routine for drag + drop for an op node - irrelevant for others...
+        drop_node = self
+        if not self.can_drop(drag_node):
+            return False
+        if modify:
+            drop_node.insert_sibling(drag_node)
+        return True
+
+    def preprocess(self, context, matrix, plan):
+        """
+        Preprocess util goto
+
+        @param context:
+        @param matrix:
+        @param plan: Plan value during preprocessor call
+        @return:
+        """
+        self.x, self.y = context.space.display.position(
+            self.x, self.y, vector=not self.absolute
+        )
+        if self.absolute:
+            self.x, self.y = matrix.point_in_matrix_space((self.x, self.y))
+        else:
+            self.x, self.y = matrix.transform_vector([self.x, self.y])
+
+    def as_cutobjects(self, closed_distance=15, passes=1):
+        """
+        Generator of cutobjects for a raster operation. This takes any image node children
+        and converts them into rastercut objects. These objects should have already been converted
+        from vector shapes.
+
+        The preference for raster shapes is to use the settings set on this operation rather than on the image-node.
+        """
+        cut = GotoCut((self.x, self.y))
+        cut.original_op = self.type
+        yield cut
+
+    def generate(self):
+        yield "move_abs", self.x, self.y

meerk40t/core/node/util_home.py

@@ -1,61 +1,61 @@
-from meerk40t.core.cutcode.homecut import HomeCut
-from meerk40t.core.elements.element_types import *
-from meerk40t.core.node.node import Node
-
-
-class HomeOperation(Node):
-    """
-    HomeOperation tells the controller to perform homing.
-
-    Node type "util home"
-    """
-
-    def __init__(self, **kwargs):
-        self.output = True
-        super().__init__(type="util home", **kwargs)
-        self._formatter = "{enabled}{element_type}"
-
-    def __repr__(self):
-        return "HomeOperation()"
-
-    def __len__(self):
-        return 1
-
-    @property
-    def implicit_passes(self):
-        return 1
-
-    def default_map(self, default_map=None):
-        default_map = super().default_map(default_map=default_map)
-        default_map["element_type"] = "Home"
-        default_map["enabled"] = "(Disabled) " if not self.output else ""
-        default_map.update(self.__dict__)
-        return default_map
-
-    def drop(self, drag_node, modify=True):
-        drop_node = self
-        if drag_node.type in op_nodes:
-            if modify:
-                drop_node.insert_sibling(drag_node)
-            return True
-        elif drop_node.type == "branch ops":
-            # Dragging operation to op branch to effectively move to bottom.
-            if modify:
-                drop_node.append_child(drag_node)
-            return True
-        return False
-
-    def as_cutobjects(self, closed_distance=15, passes=1):
-        """
-        Generator of cutobjects for a raster operation. This takes any image node children
-        and converts them into rastercut objects. These objects should have already been converted
-        from vector shapes.
-
-        The preference for raster shapes is to use the settings set on this operation rather than on the image-node.
-        """
-        cut = HomeCut()
-        cut.original_op = self.type
-        yield cut
-
-    def generate(self):
-        yield "home"
+from meerk40t.core.cutcode.homecut import HomeCut
+from meerk40t.core.elements.element_types import op_nodes
+from meerk40t.core.node.node import Node
+
+
+class HomeOperation(Node):
+    """
+    HomeOperation tells the controller to perform homing.
+
+    Node type "util home"
+    """
+
+    def __init__(self, **kwargs):
+        self.output = True
+        super().__init__(type="util home", **kwargs)
+        self._formatter = "{enabled}{element_type}"
+
+    def __repr__(self):
+        return "HomeOperation()"
+
+    def __len__(self):
+        return 1
+
+    @property
+    def implicit_passes(self):
+        return 1
+
+    def default_map(self, default_map=None):
+        default_map = super().default_map(default_map=default_map)
+        default_map["element_type"] = "Home"
+        default_map["enabled"] = "(Disabled) " if not self.output else ""
+        default_map.update(self.__dict__)
+        return default_map
+
+    def can_drop(self, drag_node):
+        # Move operation to a different position.
+        return bool(drag_node.type in op_nodes)
+
+    def drop(self, drag_node, modify=True, flag=False):
+        # Default routine for drag + drop for an op node - irrelevant for others...
+        drop_node = self
+        if not self.can_drop(drag_node):
+            return False
+        if modify:
+            drop_node.insert_sibling(drag_node)
+        return True
+
+    def as_cutobjects(self, closed_distance=15, passes=1):
+        """
+        Generator of cutobjects for a raster operation. This takes any image node children
+        and converts them into rastercut objects. These objects should have already been converted
+        from vector shapes.
+
+        The preference for raster shapes is to use the settings set on this operation rather than on the image-node.
+        """
+        cut = HomeCut()
+        cut.original_op = self.type
+        yield cut
+
+    def generate(self):
+        yield "home"

meerk40t/core/node/util_input.py

@@ -1,102 +1,102 @@
-from meerk40t.core.cutcode.inputcut import InputCut
-from meerk40t.core.elements.element_types import *
-from meerk40t.core.node.node import Node
-
-
-class InputOperation(Node):
-    """
-    InputOperation sets GPIO values.
-
-    Node type "util input"
-    """
-
-    def __init__(self, **kwargs):
-        self.input_mask = 0
-        self.input_value = 0
-        self.input_message = None
-        self.output = True
-        super().__init__(type="util input", **kwargs)
-        self._formatter = "{enabled}{element_type} {bits}"
-
-    def __repr__(self):
-        return f"InputOperation('{self.input_mask}')"
-
-    def __len__(self):
-        return 1
-
-    def bitstring(self):
-        mask = self.input_mask
-        value = self.input_value
-        bits = bytearray(b"X" * 16)
-        for m in range(16):
-            if (mask >> m) & 1:
-                bits[m] = ord("1") if (value >> m) & 1 else ord("0")
-        return bits.decode("utf8")
-
-    @property
-    def implicit_passes(self):
-        return 1
-
-    def get_mask(self, bit=None):
-        if bit is None:
-            return self.input_mask
-        return (self.input_mask >> bit) & 1
-
-    def get_value(self, bit=None):
-        if bit is None:
-            return self.input_value
-        return (self.input_value >> bit) & 1
-
-    def mask_toggle(self, bit):
-        self.input_mask = self.input_mask ^ (1 << bit)
-
-    def mask_on(self, bit):
-        self.input_mask = self.input_mask | (1 << bit)
-
-    def mask_off(self, bit):
-        self.input_mask = ~((~self.input_mask) | (1 << bit))
-
-    def value_toggle(self, bit):
-        self.input_value = self.input_value ^ (1 << bit)
-
-    def value_on(self, bit):
-        self.input_value = self.input_value | (1 << bit)
-
-    def value_off(self, bit):
-        self.input_value = ~((~self.input_value) | (1 << bit))
-
-    def default_map(self, default_map=None):
-        default_map = super().default_map(default_map=default_map)
-        default_map["element_type"] = "Input"
-        default_map["enabled"] = "(Disabled) " if not self.output else ""
-        default_map["mask"] = self.input_mask
-        default_map["value"] = self.input_value
-        default_map["message"] = self.input_message
-        default_map["bits"] = self.bitstring()
-        default_map.update(self.__dict__)
-        return default_map
-
-    def drop(self, drag_node, modify=True):
-        drop_node = self
-        if drag_node.type in op_nodes:
-            if modify:
-                drop_node.insert_sibling(drag_node)
-            return True
-        elif drop_node.type == "branch ops":
-            # Dragging operation to op branch to effectively move to bottom.
-            if modify:
-                drop_node.append_child(drag_node)
-            return True
-        return False
-
-    def as_cutobjects(self, closed_distance=15, passes=1):
-        """
-        Generator of cutobjects for a raster operation. This takes any image node children
-        and converts them into rastercut objects. These objects should have already been converted
-        from vector shapes.
-
-        The preference for raster shapes is to use the settings set on this operation rather than on the image-node.
-        """
-        input = InputCut(self.input_mask, self.input_value, self.input_message)
-        input.original_op = self.type
-        yield input
+from meerk40t.core.cutcode.inputcut import InputCut
+from meerk40t.core.elements.element_types import op_nodes
+from meerk40t.core.node.node import Node
+
+
+class InputOperation(Node):
+    """
+    InputOperation sets GPIO values.
+
+    Node type "util input"
+    """
+
+    def __init__(self, **kwargs):
+        self.input_mask = 0
+        self.input_value = 0
+        self.input_message = None
+        self.output = True
+        super().__init__(type="util input", **kwargs)
+        self._formatter = "{enabled}{element_type} {bits}"
+
+    def __repr__(self):
+        return f"InputOperation('{self.input_mask}')"
+
+    def __len__(self):
+        return 1
+
+    def bitstring(self):
+        mask = self.input_mask
+        value = self.input_value
+        bits = bytearray(b"X" * 16)
+        for m in range(16):
+            if (mask >> m) & 1:
+                bits[m] = ord("1") if (value >> m) & 1 else ord("0")
+        return bits.decode("utf8")
+
+    @property
+    def implicit_passes(self):
+        return 1
+
+    def get_mask(self, bit=None):
+        if bit is None:
+            return self.input_mask
+        return (self.input_mask >> bit) & 1
+
+    def get_value(self, bit=None):
+        if bit is None:
+            return self.input_value
+        return (self.input_value >> bit) & 1
+
+    def mask_toggle(self, bit):
+        self.input_mask = self.input_mask ^ (1 << bit)
+
+    def mask_on(self, bit):
+        self.input_mask = self.input_mask | (1 << bit)
+
+    def mask_off(self, bit):
+        self.input_mask = ~((~self.input_mask) | (1 << bit))
+
+    def value_toggle(self, bit):
+        self.input_value = self.input_value ^ (1 << bit)
+
+    def value_on(self, bit):
+        self.input_value = self.input_value | (1 << bit)
+
+    def value_off(self, bit):
+        self.input_value = ~((~self.input_value) | (1 << bit))
+
+    def default_map(self, default_map=None):
+        default_map = super().default_map(default_map=default_map)
+        default_map["element_type"] = "Input"
+        default_map["enabled"] = "(Disabled) " if not self.output else ""
+        default_map["mask"] = self.input_mask
+        default_map["value"] = self.input_value
+        default_map["message"] = self.input_message
+        default_map["bits"] = self.bitstring()
+        default_map.update(self.__dict__)
+        return default_map
+
+    def can_drop(self, drag_node):
+        # Move operation to a different position.
+        return bool(drag_node.type in op_nodes)
+
+    def drop(self, drag_node, modify=True, flag=False):
+        # Default routine for drag + drop for an op node - irrelevant for others...
+        drop_node = self
+        if not self.can_drop(drag_node):
+            return False
+        if modify:
+            drop_node.insert_sibling(drag_node)
+        return True
+
+    def as_cutobjects(self, closed_distance=15, passes=1):
+        """
+        Generator of cutobjects for a raster operation. This takes any image node children
+        and converts them into rastercut objects. These objects should have already been converted
+        from vector shapes.
+
+        The preference for raster shapes is to use the settings set on this operation rather than on the image-node.
+        """
+        _input = InputCut(self.input_mask, self.input_value, self.input_message)
+        _input.original_op = self.type
+        yield _input