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

meerk40t/grbl/gui/gui.py

@@ -1,116 +1,147 @@
-def plugin(service, lifecycle):
-    if lifecycle == "invalidate":
-        try:
-            import serial  # pylint: disable=unused-import
-        except ImportError:
-            return True
-        return not service.has_feature("wx")
-    if lifecycle == "service":
-        return "provider/device/grbl"
-
-    if lifecycle == "assigned":
-        service("window toggle Configuration\n")
-
-    if lifecycle == "added":
-        from meerk40t.grbl.gui.grblconfiguration import GRBLConfiguration
-        from meerk40t.grbl.gui.grblcontroller import GRBLController
-        from meerk40t.grbl.gui.grblhardwareconfig import GRBLHardwareConfig
-        from meerk40t.gui.icons import (
-            icons8_computer_support,
-            icons8_connected,
-            icons8_emergency_stop_button,
-            icons8_flash_off,
-            icons8_flash_on,
-            icons8_info,
-            icons8_pause,
-        )
-
-        service.register("window/GRBLController", GRBLController)
-        service.register("winpath/GRBLController", service)
-
-        service.register("window/Configuration", GRBLConfiguration)
-        service.register("winpath/Configuration", service)
-
-        service.register("window/GrblHardwareConfig", GRBLHardwareConfig)
-
-        _ = service._
-
-        service.register(
-            "button/control/Controller",
-            {
-                "label": _("Controller"),
-                "icon": icons8_connected,
-                "tip": _("Opens Controller Window"),
-                "action": lambda v: service("window toggle GRBLController\n"),
-            },
-        )
-        service.register(
-            "button/device/Configuration",
-            {
-                "label": _("Config"),
-                "icon": icons8_computer_support,
-                "tip": _("Opens device-specific configuration window"),
-                "action": lambda v: service("window toggle Configuration\n"),
-            },
-        )
-        service.register(
-            "button/control/Pause",
-            {
-                "label": _("Pause"),
-                "icon": icons8_pause,
-                "tip": _("Pause the laser"),
-                "action": lambda v: service("pause\n"),
-            },
-        )
-
-        service.register(
-            "button/control/Stop",
-            {
-                "label": _("Stop"),
-                "icon": icons8_emergency_stop_button,
-                "tip": _("Emergency stop the laser"),
-                "action": lambda v: service("estop\n"),
-            },
-        )
-
-        def has_red_dot_enabled():
-            # Does the current device have an active use_red_dot?
-            res = False
-            if hasattr(service, "use_red_dot"):
-                if service.use_red_dot:
-                    res = True
-            return res
-
-        service.register(
-            "button/control/Redlight",
-            {
-                "label": _("Red Dot On"),
-                "icon": icons8_flash_on,
-                "tip": _("Turn Redlight On"),
-                "action": lambda v: service("red on\n"),
-                "toggle": {
-                    "label": _("Red Dot Off"),
-                    "action": lambda v: service("red off\n"),
-                    "icon": icons8_flash_off,
-                    "signal": "grbl_red_dot",
-                },
-                "rule_enabled": lambda v: has_red_dot_enabled(),
-            },
-        )
-
-        service.register(
-            "button/control/ClearAlarm",
-            {
-                "label": _("Clear Alarm"),
-                "icon": icons8_info,
-                "tip": _("Send a GRBL Clear Alarm command"),
-                "action": lambda v: service("clear_alarm\n"),
-            },
-        )
-        service.add_service_delegate(GRBLGui(service))
-
-
-class GRBLGui:
-    def __init__(self, context):
-        self.context = context
-        # This is a stub.
+def plugin(service, lifecycle):
+    if lifecycle == "invalidate":
+        try:
+            import serial  # pylint: disable=unused-import
+        except ImportError:
+            return True
+        return not service.has_feature("wx")
+    if lifecycle == "service":
+        return "provider/device/grbl"
+
+    if lifecycle == "assigned":
+        service("window toggle Configuration\n")
+
+    if lifecycle == "added":
+        from meerk40t.grbl.gui.grblconfiguration import GRBLConfiguration
+        from meerk40t.grbl.gui.grblcontroller import GRBLController
+        from meerk40t.grbl.gui.grblhardwareconfig import GRBLHardwareConfig
+        from meerk40t.grbl.gui.grbloperationconfig import GRBLAdvancedPanel
+        from meerk40t.gui.icons import (
+            icons8_computer_support,
+            icons8_connected,
+            icons8_emergency_stop_button,
+            icons8_flash_off,
+            icons8_flash_on,
+            icons8_info,
+            icons8_pause,
+            icons8_home_filled,
+        )
+
+        service.register("window/GRBLController", GRBLController)
+        service.register("winpath/GRBLController", service)
+
+        service.register("window/Configuration", GRBLConfiguration)
+        service.register("winpath/Configuration", service)
+
+        service.register("window/GrblHardwareConfig", GRBLHardwareConfig)
+
+        service.register("property/RasterOpNode/GRBL", GRBLAdvancedPanel)
+        service.register("property/CutOpNode/GRBL", GRBLAdvancedPanel)
+        service.register("property/EngraveOpNode/GRBL", GRBLAdvancedPanel)
+        service.register("property/ImageOpNode/GRBL", GRBLAdvancedPanel)
+        service.register("property/DotsOpNode/GRBL", GRBLAdvancedPanel)
+        _ = service._
+
+        service.register(
+            "button/control/Controller",
+            {
+                "label": _("Controller"),
+                "icon": icons8_connected,
+                "tip": _("Opens Controller Window"),
+                "help": "devicegrbl",
+                "action": lambda v: service("window toggle GRBLController\n"),
+            },
+        )
+        kernel = service.kernel
+        if not (
+            hasattr(kernel.args, "lock_device_config")
+            and kernel.args.lock_device_config
+        ):
+            service.register(
+                "button/device/Configuration",
+                {
+                    "label": _("Config"),
+                    "icon": icons8_computer_support,
+                    "tip": _("Opens device-specific configuration window"),
+                    "help": "devicegrbl",
+                    "action": lambda v: service("window toggle Configuration\n"),
+                },
+            )
+        service.register(
+            "button/control/Pause",
+            {
+                "label": _("Pause"),
+                "icon": icons8_pause,
+                "tip": _("Pause the laser"),
+                "help": "devicegrbl",
+                "action": lambda v: service("pause\n"),
+            },
+        )
+
+        service.register(
+            "button/control/Stop",
+            {
+                "label": _("Stop"),
+                "icon": icons8_emergency_stop_button,
+                "tip": _("Emergency stop the laser"),
+                "help": "devicegrbl",
+                "action": lambda v: service("estop\n"),
+            },
+        )
+
+        def has_red_dot_enabled():
+            # Does the current device have an active use_red_dot?
+            res = False
+            if hasattr(service, "use_red_dot"):
+                if service.use_red_dot:
+                    res = True
+            return res
+
+        service.register(
+            "button/control/Redlight",
+            {
+                "label": _("Red Dot On"),
+                "icon": icons8_flash_on,
+                "tip": _("Turn Redlight On"),
+                "help": "devicegrbl",
+                "action": lambda v: service("red on\n"),
+                "toggle": {
+                    "label": _("Red Dot Off"),
+                    "help": "devicegrbl",
+                    "action": lambda v: service("red off\n"),
+                    "icon": icons8_flash_off,
+                    "signal": "grbl_red_dot",
+                },
+                "rule_enabled": lambda v: has_red_dot_enabled(),
+            },
+        )
+
+        service.register(
+            "button/control/ClearAlarm",
+            {
+                "label": _("Clear Alarm"),
+                "icon": icons8_info,
+                "tip": _("Send a GRBL Clear Alarm command"),
+                "help": "devicegrbl",
+                "action": lambda v: service("clear_alarm\n"),
+            },
+        )
+
+        service.register(
+            "button/control/GoHome",
+            {
+                "label": _("Home"),
+                "icon": icons8_home_filled,
+                "tip": _("Send laser to home position (right click: to physical home)"),
+                "help": "devicegrbl",
+                "action": lambda v: service("home\n"),
+                "action_right": lambda v: service("physical_home\n"),
+            },
+        )
+        service.add_service_delegate(GRBLGui(service))
+
+
+class GRBLGui:
+    def __init__(self, context):
+        self.context = context
+        # This is a stub.

meerk40t/grbl/interpreter.py

@@ -1,44 +1,44 @@
-"""
-GRBL Interpreter
-
-The Interpreter listens to the local GRBL code being sent to the Controller and parses it. This allows it GRBL to track
-position based on the data sent, and debug the device. This listens to the current device and thus must be attached
-to a GRBL device.
-"""
-from meerk40t.grbl.emulator import GRBLEmulator
-from meerk40t.kernel import Module
-
-
-class GRBLInterpreter(Module):
-    def __init__(self, service, path):
-        Module.__init__(self, service, path)
-        self.emulator = GRBLEmulator(self, service.space.display.matrix())
-        self._attached_device = None
-
-    def __repr__(self):
-        return f"GcodeInterpreter({self.name})"
-
-    def move_abs(self, x, y):
-        self.context.signal("emulator;position", (x, y, x, y))
-
-    def move_rel(self, x, y):
-        self.context.signal("emulator;position", (x, y, x, y))
-
-    def plot(self, cutobject):
-        try:
-            start = cutobject.start
-            end = cutobject.end
-        except AttributeError:
-            return
-        self.context.signal("emulator;position", (start[0], start[1], end[0], end[1]))
-
-    def module_open(self, *args, **kwargs):
-        self._attached_device = "none"
-        if hasattr(self.context, "serial_port"):
-            self._attached_device = self.context.serial_port.lower()
-        send = self.context.channel(f"send-{self._attached_device}")
-        send.watch(self.emulator.write)
-
-    def module_close(self, *args, **kwargs):
-        send = self.context.channel(f"send-{self._attached_device}")
-        send.unwatch(self.emulator.write)
+"""
+GRBL Interpreter
+
+The Interpreter listens to the local GRBL code being sent to the Controller and parses it. This allows it GRBL to track
+position based on the data sent, and debug the device. This listens to the current device and thus must be attached
+to a GRBL device.
+"""
+from meerk40t.grbl.emulator import GRBLEmulator
+from meerk40t.kernel import Module
+
+
+class GRBLInterpreter(Module):
+    def __init__(self, service, path):
+        Module.__init__(self, service, path)
+        self.emulator = GRBLEmulator(self, service.space.display.matrix())
+        self._attached_device = None
+
+    def __repr__(self):
+        return f"GcodeInterpreter({self.name})"
+
+    def move_abs(self, x, y):
+        self.context.signal("emulator;position", (x, y, x, y))
+
+    def move_rel(self, x, y):
+        self.context.signal("emulator;position", (x, y, x, y))
+
+    def plot(self, cutobject):
+        try:
+            start = cutobject.start
+            end = cutobject.end
+        except AttributeError:
+            return
+        self.context.signal("emulator;position", (start[0], start[1], end[0], end[1]))
+
+    def module_open(self, *args, **kwargs):
+        self._attached_device = "none"
+        if hasattr(self.context, "serial_port"):
+            self._attached_device = self.context.serial_port.lower()
+        send = self.context.channel(f"send-{self._attached_device}")
+        send.watch(self.emulator.write)
+
+    def module_close(self, *args, **kwargs):
+        send = self.context.channel(f"send-{self._attached_device}")
+        send.unwatch(self.emulator.write)

meerk40t/grbl/loader.py

@@ -1,22 +1,22 @@
-"""
-GCode Loader
-
-Provides the required hooks to register the loader of gcode file.
-"""
-
-import os
-
-
-class GCodeLoader:
-    @staticmethod
-    def load_types():
-        yield "Gcode File", ("gcode", "nc", "gc"), "application/x-gcode"
-
-    @staticmethod
-    def load(kernel, service, pathname, **kwargs):
-        basename = os.path.basename(pathname)
-        with open(pathname, "rb") as f:
-            op_branch = service.get(type="branch ops")
-            op_branch.add(data=f.read(), data_type="grbl", type="blob", label=basename)
-            kernel.root.close(basename)
-            return True
+"""
+GCode Loader
+
+Provides the required hooks to register the loader of gcode file.
+"""
+
+import os
+
+
+class GCodeLoader:
+    @staticmethod
+    def load_types():
+        yield "Gcode File", ("gcode", "nc", "gc"), "application/x-gcode"
+
+    @staticmethod
+    def load(kernel, service, pathname, **kwargs):
+        basename = os.path.basename(pathname)
+        with open(pathname, "rb") as f:
+            op_branch = service.get(type="branch ops")
+            op_branch.add(data=f.read(), data_type="grbl", type="blob", label=basename)
+            kernel.root.close(basename)
+            return True

meerk40t/grbl/mock_connection.py

@@ -1,56 +1,56 @@
-"""
-Mock Connection for GRBL
-
-
-The mock connection is used for debug and research purposes. And simply prints the data sent to it rather than engaging
-any hardware.
-"""
-from meerk40t.grbl.emulator import GRBLEmulator
-
-
-class MockConnection:
-    def __init__(self, service, controller):
-        self.service = service
-        self.controller = controller
-        self.laser = None
-        self.read_buffer = bytearray()
-        self.emulator = GRBLEmulator(
-            device=None, units_to_device_matrix=service.view.matrix, reply=self.add_read
-        )
-
-    @property
-    def connected(self):
-        return self.laser is not None
-
-    def add_read(self, code):
-        self.read_buffer += bytes(code, encoding="raw_unicode_escape")
-
-    def read(self):
-        f = self.read_buffer.find(b"\n")
-        if f == -1:
-            return None
-        response = self.read_buffer[:f]
-        self.read_buffer = self.read_buffer[f + 1 :]
-        str_response = str(response, "raw_unicode_escape")
-        str_response = str_response.strip()
-        return str_response
-
-    def write(self, line: str):
-        self.emulator.write(line)
-
-    def connect(self):
-        if self.laser:
-            self.controller.log("Already connected", type="connection")
-            return
-        try:
-            self.controller.log("Attempting to Connect...", type="connection")
-            self.laser = True
-            self.controller.log("Connected", type="connection")
-            self.service.signal("grbl;status", "connected")
-        except ConnectionError:
-            self.controller.log("Connection Failed.", type="connection")
-
-    def disconnect(self):
-        self.laser = None
-        self.controller.log("Disconnected", type="connection")
-        self.service.signal("grbl;status", "disconnected")
+"""
+Mock Connection for GRBL
+
+
+The mock connection is used for debug and research purposes. And simply prints the data sent to it rather than engaging
+any hardware.
+"""
+from meerk40t.grbl.emulator import GRBLEmulator
+
+
+class MockConnection:
+    def __init__(self, service, controller):
+        self.service = service
+        self.controller = controller
+        self.laser = None
+        self.read_buffer = bytearray()
+        self.emulator = GRBLEmulator(
+            device=None, units_to_device_matrix=service.view.matrix, reply=self.add_read
+        )
+
+    @property
+    def connected(self):
+        return self.laser is not None
+
+    def add_read(self, code):
+        self.read_buffer += bytes(code, encoding="raw_unicode_escape")
+
+    def read(self):
+        f = self.read_buffer.find(b"\n")
+        if f == -1:
+            return None
+        response = self.read_buffer[:f]
+        self.read_buffer = self.read_buffer[f + 1 :]
+        str_response = str(response, "raw_unicode_escape")
+        str_response = str_response.strip()
+        return str_response
+
+    def write(self, line: str):
+        self.emulator.write(line)
+
+    def connect(self):
+        if self.laser:
+            self.controller.log("Already connected", type="connection")
+            return
+        try:
+            self.controller.log("Attempting to Connect...", type="connection")
+            self.laser = True
+            self.controller.log("Connected", type="connection")
+            self.service.signal("grbl;status", "connected")
+        except ConnectionError:
+            self.controller.log("Connection Failed.", type="connection")
+
+    def disconnect(self):
+        self.laser = None
+        self.controller.log("Disconnected", type="connection")
+        self.service.signal("grbl;status", "disconnected")