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

meerk40t/gui/toolwidgets/toolmeasure.py

@@ -3,7 +3,7 @@ from math import atan2, cos, sin, sqrt, tau
 import wx
 
 from meerk40t.core.units import Length
-from meerk40t.gui.wxutils import get_matrix_scale, get_gc_scale
+from meerk40t.gui.wxutils import get_matrix_scale, get_gc_scale, dip_size
 
 from .toolpointlistbuilder import PointListTool
 
@@ -24,6 +24,8 @@ class MeasureTool(PointListTool):
         self.line_pen.SetColour(self.scene.colors.color_measure_line)
         self.line_pen.SetStyle(wx.PENSTYLE_DOT)
         self.line_pen.SetWidth(1000)
+        fact = dip_size(self.scene.pane, 100, 100)
+        self.font_size_factor = (fact[0] + fact[1]) / 100 * 0.5
 
     def create_node(self):
         # No need to create anything
@@ -43,6 +45,7 @@ class MeasureTool(PointListTool):
             font_size = 5000
         if font_size > 1e8:
             font_size = 5000
+        font_size *= self.font_size_factor            
         # print ("Fontsize=%.3f, " % self.font_size)
         if font_size < 1.0:
             font_size = 1.0  # Mac does not allow values lower than 1.

meerk40t/gui/wxmeerk40t.py

@@ -24,6 +24,7 @@ from meerk40t.gui.wxmscene import SceneWindow
 from meerk40t.gui.wxutils import TextCtrl, wxButton, wxStaticText
 from meerk40t.kernel import CommandSyntaxError, Module, get_safe_path
 from meerk40t.kernel.kernel import Job
+from meerk40t.core.units import Length
 
 from ..main import APPLICATION_NAME, APPLICATION_VERSION
 from ..tools.kerftest import KerfTool
@@ -500,7 +501,8 @@ class wxMeerK40t(wx.App, Module):
 
     def OnInit(self):
         self.name = f"MeerK40t-{wx.GetUserId()}"
-        self.instance = wx.SingleInstanceChecker(self.name)
+        mkdir = self.context.kernel.os_information["OS_TEMPDIR"]
+        self.instance = wx.SingleInstanceChecker(self.name, path=mkdir)
         self.context.setting(bool, "single_instance_only", True)
         if self.context.kernel._was_restarted:
             return True
@@ -560,15 +562,17 @@ class wxMeerK40t(wx.App, Module):
     def MacOpenFile(self, filename):
         try:
             if self.context is not None:
-                self.context.elements.load(os.path.realpath(filename))
+                channel = self.context.kernel.channel("console")
+                self.context.elements.load(os.path.realpath(filename), svg_ppi=self.context.elements.svg_ppi, channel=channel)
         except AttributeError:
             pass
 
     def MacOpenFiles(self, filenames):
         try:
             if self.context is not None:
+                channel = self.context.kernel.channel("console")
                 for filename in filenames:
-                    self.context.elements.load(os.path.realpath(filename))
+                    self.context.elements.load(os.path.realpath(filename), svg_ppi=self.context.elements.svg_ppi, channel=channel)
         except AttributeError:
             pass
 
@@ -832,6 +836,31 @@ class wxMeerK40t(wx.App, Module):
                 dialog.cancel_it()
             dialog.Destroy()
 
+        @kernel.console_argument("info", type=str, help=_("Unit to translate"))
+        @kernel.console_command("unit", help=_("Translate units"))
+        def show_unit_info(command, channel, _, info=None, **kwargs):
+            if info is None:
+                channel(_("You need to provide a value to translate"))
+            device = kernel.root.device
+            try:
+                valuex = Length(info, relative_length=device.view.width, digits=4)
+            except ValueError:
+                channel(f"Invalid value: '{info}'")
+                return
+            channel(f"{info} translates to:")
+            channel(f"tat          :  {float(valuex):.4f}")
+            channel(f"mil          :  {valuex.mil}")
+            channel(f"um           :  {valuex.um}")
+            channel(f"nm           :  {valuex.nm}")
+            channel(f"mm           :  {valuex.mm}")
+            channel(f"cm           :  {valuex.cm}")
+            channel(f"Pixels       :  {valuex.pixels}")
+            channel(f"Point        :  {valuex.pt}")
+            channel(f"spx (screen) :  {valuex.spx}")
+            channel(f"inch         :  {valuex.inches}")
+            channel(f"Device units :  {float(valuex) / device.view.native_scale_x:.4f}")
+            
+
     def module_open(self, *args, **kwargs):
         context = self.context
         kernel = context.kernel

meerk40t/gui/wxmmain.py

@@ -2,6 +2,7 @@ import datetime
 import os
 import platform
 import sys
+import threading
 from functools import partial
 from math import isinf
 
@@ -126,6 +127,42 @@ from .mwindow import MWindow
 _ = wx.GetTranslation
 MULTIPLE = "<Multiple files loaded>"
 
+class GUIThread:
+    """
+    This will take from any thread a command to be executed and inserts it into the main thread
+    This prevents threading & lock issues exhibited by passing along commands 
+    via ``consoleserver`` or ``webserver``
+    """
+    def __init__(self, context, *args, **kwargs):
+        self.context = context
+        self._execution_lock = threading.Lock()
+        self._execution_buffer = []
+        self._execution_timer = Job(
+            process=self.execute_command,
+            job_name="console-execute",
+            interval=0.1,
+            run_main=True,
+        )
+        self.context.kernel.register("gui/handover", self.process_command)
+
+    def execute_command(self):
+        cmd = ""
+        another = False
+        with self._execution_lock:
+            if self._execution_buffer:
+                cmd = self._execution_buffer[0]
+                self._execution_buffer.pop(0)
+                another = len(self._execution_buffer) > 0
+        if cmd:
+            self.context(cmd + "\n")
+            if another:
+                self.context.kernel.schedule(self._execution_timer)
+
+    def process_command(self, command):
+        with self._execution_lock:
+            self._execution_buffer.append(command)
+            self.context.kernel.schedule(self._execution_timer)        
+
 class Autosaver:
     """
     Minimal autosave functionality.
@@ -137,7 +174,7 @@ class Autosaver:
     def __init__(self, context, *args, **kwargs):
         self.context = context
         self.needs_saving = False
-        safe_dir = os.path.realpath(get_safe_path(self.context.kernel.name))
+        safe_dir = self.context.kernel.os_information["WORKDIR"]
         self.autosave_file = os.path.join(safe_dir, "_autosave.svg")
 
         choices = [
@@ -394,6 +431,7 @@ class MeerK40t(MWindow):
         self.tips_at_startup()
         self.parametric_info = None
         self.autosave = Autosaver(self.context)
+        self.handover = GUIThread(self.context)
         kernel = self.context.kernel
         if hasattr(kernel.args, "maximized") and kernel.args.maximized:
             self.Maximize()
@@ -538,10 +576,18 @@ class MeerK40t(MWindow):
                     myPilImage = Image.new(
                         "RGB", (myWxImage.GetWidth(), myWxImage.GetHeight())
                     )
-                    myPilImage.frombytes(myWxImage.GetData())
+                    try:
+                        byte_data = bytes(myWxImage.GetData())
+                        myPilImage.frombytes(byte_data)
+                    except TypeError as e:
+                        console = self.context.root.channel("console")
+                        console(f"Error while pasting image: {e}")
+                        return None
                     return myPilImage
 
                 image = imageToPil(WxBitmapToWxImage(bmp))
+                if image is None:
+                    return
                 dpi = DEFAULT_PPI
                 matrix = Matrix(f"scale({UNITS_PER_PIXEL})")
                 # _("Paste image")
@@ -2345,6 +2391,22 @@ class MeerK40t(MWindow):
                 > 0,
             },
         )
+        secondary_commands = [
+            "element union",
+            "element difference",
+            "element xor",
+            "element intersection",
+        ]
+        try:
+            import pyclipr
+            primary_commands = [
+                "clipper union",
+                "clipper difference",
+                "clipper xor",
+                "clipper intersection",
+            ]
+        except ImportError:
+            primary_commands = list(secondary_commands)
         kernel.register(
             "button/geometry/Union",
             {
@@ -2352,7 +2414,8 @@ class MeerK40t(MWindow):
                 "icon": icon_cag_union,
                 "tip": _("Create a union of the selected elements"),
                 "help": "cag",
-                "action": exec_in_undo_scope("Union", "element union\n"),
+                "action": exec_in_undo_scope("Union", f"{primary_commands[0]}\n"),
+                "action_right": exec_in_undo_scope("Union", f"{secondary_commands[0]}\n"),
                 "size": bsize_small,
                 "rule_enabled": lambda cond: len(
                     list(kernel.elements.elems(emphasized=True))
@@ -2367,7 +2430,8 @@ class MeerK40t(MWindow):
                 "icon": icon_cag_subtract,
                 "tip": _("Create a difference of the selected elements"),
                 "help": "cag",
-                "action": exec_in_undo_scope("Difference", "element difference\n"),
+                "action": exec_in_undo_scope("Difference", f"{primary_commands[1]}\n"),
+                "action_right": exec_in_undo_scope("Difference", f"{secondary_commands[1]}\n"),
                 "size": bsize_small,
                 "rule_enabled": lambda cond: len(
                     list(kernel.elements.elems(emphasized=True))
@@ -2382,7 +2446,8 @@ class MeerK40t(MWindow):
                 "icon": icon_cag_xor,
                 "tip": _("Create a xor of the selected elements"),
                 "help": "cag",
-                "action": exec_in_undo_scope("Xor", "element xor\n"),
+                "action": exec_in_undo_scope("XOR", f"{primary_commands[2]}\n"),
+                "action_right": exec_in_undo_scope("XOR", f"{secondary_commands[2]}\n"),
                 "size": bsize_small,
                 "rule_enabled": lambda cond: len(
                     list(kernel.elements.elems(emphasized=True))
@@ -2397,7 +2462,8 @@ class MeerK40t(MWindow):
                 "icon": icon_cag_common,
                 "tip": _("Create a intersection of the selected elements"),
                 "help": "cag",
-                "action": exec_in_undo_scope("Intersection", "element intersection\n"),
+                "action": exec_in_undo_scope("Intersection", f"{primary_commands[3]}\n"),
+                "action_right": exec_in_undo_scope("Intersection", f"{secondary_commands[3]}\n"),
                 "size": bsize_small,
                 "rule_enabled": lambda cond: len(
                     list(kernel.elements.elems(emphasized=True))

meerk40t/gui/wxmscene.py

@@ -156,13 +156,9 @@ class MeerK40tScenePanel(wx.Panel):
         self.context.setting(bool, "clear_magnets", True)
 
         # Save / Load the content of magnets
-        from os.path import join, realpath
+        from os.path import join
 
-        from meerk40t.kernel.functions import get_safe_path
-
-        self._magnet_file = join(
-            realpath(get_safe_path(self.context.kernel.name)), "magnets.cfg"
-        )
+        self._magnet_file = join(self.context.kernel.os_information["WORKDIR"], "magnets.cfg")
         self.load_magnets()
         # Add a plugin routine to be called at the time of a full new start
         context.kernel.register(
@@ -872,6 +868,99 @@ class MeerK40tScenePanel(wx.Panel):
                 else:
                     channel(_("Target needs to be one of primary, secondary, circular"))
 
+        # Establishes magnet commands
+        @context.console_argument(
+            "action", type=str, help=_("Action: clear or set / delete with coordinate")
+        )
+        @context.console_argument(
+            "axis", type=str, help=_("Axis (X or Y)")
+        )
+        @context.console_argument("pos", type=str, help=_("Position for magnetline"))
+        @context.console_command(
+            "magnet",
+            help=_("magnet <action> <axis> <position>"),
+            input_type="scene",
+        )
+        def magnet_set(
+            command,
+            channel,
+            _,
+            action=None,
+            axis=None,
+            pos=None,
+            **kwarg,
+        ):
+            def info(opt_msg):
+                channel(
+                    _("You need to provide the intended action:") + "\n" +
+                    _("clear x - clear y : will clear all magnets on the given axis") + "\n" +
+                    _("set x <pos> - set y <pos>: will set a magnet line on the given axis") + "\n" +
+                    _("delete x <pos> - delete y <pos>: will delete the magnet line on the given axis")
+                )
+                if opt_msg:
+                    channel(opt_msg)
+
+            if action is None or axis is None or axis.upper() not in ("X", "Y"):
+                info("")
+                return
+            action = action.lower()
+            axis = axis.upper()
+            value = None
+            if pos:
+                try:
+                    rel_len = self.context.device.view.width if axis == "X" else self.context.device.view.height
+                    value = float(Length(pos, relative_length=rel_len))
+                except ValueError:
+                    info (f"Invalid length: {pos}")
+                    return
+
+            if action != "clear" and value is None:
+                info(_("You need to provide a position"))
+                return
+
+            if action == "clear":
+                if axis == "X":
+                    count = len(self.magnet_x)
+                    self.magnet_x.clear()
+                else:
+                    count = len(self.magnet_y)
+                    self.magnet_y.clear()
+                self.save_magnets()
+                self.context.signal("refresh_scene", "Scene")
+                channel (_("Deleted {count} magnet lines on axis {axis}").format(axis=axis, count=count))
+            elif action == "set":
+                done = False
+                if axis == "X":
+                    if not value in self.magnet_x:
+                        done = True
+                        self.magnet_x.append(value)
+                else:
+                    if not value in self.magnet_y:
+                        done = True
+                        self.magnet_y.append(value)
+                self.save_magnets()
+                self.context.signal("refresh_scene", "Scene")
+                if done:
+                    channel(_("Magnetline appended at {pos} on axis {axis}").format(pos=pos, axis=axis))
+                else:
+                    channel(_("Magnetline was already present"))
+            elif action.startswith("del"):
+                done = False
+                if axis == "X":
+                    if value in self.magnet_x:
+                        done = True
+                        self.magnet_x.remove(value)
+                else:
+                    if value in self.magnet_y:
+                        done = True
+                        self.magnet_y.remove(value)
+                self.save_magnets()
+                self.context.signal("refresh_scene", "Scene")
+                if done:
+                    channel(_("Magnetline removed at {pos} on axis {axis}").format(pos=pos, axis=axis))
+                else:
+                    channel(_("Magnetline was not existing"))
+
     def toggle_ref_obj(self):
         for e in self.scene.context.elements.flat(types=elem_nodes, emphasized=True):
             if self.reference_object == e:

meerk40t/gui/wxmtree.py

@@ -580,7 +580,7 @@ class ShadowTree:
         self.tree_images = None
         self.name = "Project"
         self._freeze = False
-        testsize = dip_size(self, 20, 20)
+        testsize = dip_size(self.wxtree, 20, 20)
         self.iconsize = testsize[1]
         self.iconstates = {}
         self.last_call = 0
@@ -1430,17 +1430,23 @@ class ShadowTree:
         @param kwargs:
         @return:
         """
-        parent = node.parent
-        parent_item = parent._item
-        if parent_item is None:
-            # We are appending items in tree before registration.
+        try:
+            parent = node.parent
+            parent_item = parent._item
+            if parent_item is None:
+                # We are appending items in tree before registration.
+                return
+            tree = self.wxtree
+            if pos is None:
+                node._item = tree.AppendItem(parent_item, self.name)
+            else:
+                node._item = tree.InsertItem(parent_item, pos, self.name)
+            tree.SetItemData(node._item, node)
+        except Exception as e:
+            # Invalid tree?
+            self.context.signal("rebuild_tree", "all")
+            print (f"We encountered an error at node registration: {e}")
             return
-        tree = self.wxtree
-        if pos is None:
-            node._item = tree.AppendItem(parent_item, self.name)
-        else:
-            node._item = tree.InsertItem(parent_item, pos, self.name)
-        tree.SetItemData(node._item, node)
         self.update_decorations(node, False)
         wxcolor = self.wxtree.GetForegroundColour()
         attribute_to_try = "fill" if node.type == "elem text" else "stroke"

meerk40t/gui/wxutils.py

@@ -1222,7 +1222,7 @@ class StaticBoxSizer(wx.StaticBoxSizer):
         if label is None:
             label = ""
         self.sbox = wx.StaticBox(parent, id, label=label)
-        self.sbox.SetMinSize(dip_size(self, 50, 50))
+        self.sbox.SetMinSize(dip_size(self.sbox, 50, 50))
         super().__init__(self.sbox, orientation)
         self.parent = parent
 

meerk40t/image/imagetools.py

@@ -43,7 +43,12 @@ def img_to_polygons(
     _, th2 = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
 
     # Find contours in the binary image
-    contours, hierarchies = cv2.findContours(th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+    try:
+        contours, hierarchies = cv2.findContours(th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+    except ValueError:
+        # Invalid data
+        return ([], [])
+
     # print(f"Found {len(contours)} contours and {len(hierarchies)} hierarchies")
     width, height = node_image.size
     minarea = int(minimal / 100.0 * width * height)
@@ -147,9 +152,14 @@ def do_innerwhite(
         _, thresh = cv2.threshold(gray, 250, 255, cv2.THRESH_BINARY)
 
         # Find contours
-        contours, hierarchy = cv2.findContours(
-            thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
-        )
+        try:
+            contours, hierarchy = cv2.findContours(
+                thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
+            )
+        except ValueError:
+            # Invalid data
+            continue
+
         linecandidates = list()
 
         minarea = int(minimal / 100.0 * width * height)
@@ -402,7 +412,12 @@ def img_to_rectangles(
     _, th2 = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
 
     # Find contours in the binary image
-    contours, hierarchies = cv2.findContours(th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+    try:
+        contours, hierarchies = cv2.findContours(th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+    except ValueError:
+        # Invalid data
+        return ([], [])
+
     # print(f"Found {len(contours)} contours and {len(hierarchies)} hierarchies")
     width, height = node_image.size
     minarea = int(minimal / 100.0 * width * height)
@@ -1480,7 +1495,7 @@ def plugin(kernel, lifecycle=None):
     )
     @context.console_command(
         "linecut",
-        help=_("Cuts and image with a line"),
+        help=_("Cuts an image with a line"),
         input_type="image",
         output_type="image",
         hidden=True,

meerk40t/kernel/kernel.py

@@ -1,7 +1,6 @@
 import functools
 import inspect
 import os
-import platform
 import re
 import subprocess
 import threading
@@ -181,9 +180,20 @@ class Kernel(Settings):
         # Arguments Objects
         self.args = None
 
+        self.os_information = self._get_environment()
+
     def __str__(self):
         return f"Kernel({self.name}, {self.profile}, {self.version})"
 
+    def _get_environment(self):
+        from platform import system
+        from tempfile import gettempdir
+        return {
+            "OS_NAME":  system(),
+            "OS_TEMPDIR": os.path.realpath(gettempdir()),
+            "WORKDIR": os.path.realpath(get_safe_path(self.name, create=True)),
+        }
+
     def set_language(self, language, localedir="locale"):
         from . import set_language
 
@@ -244,15 +254,21 @@ class Kernel(Settings):
                 kwargs_repr = [f"{k}={v}" for k, v in kwargs.items()]
                 signature = ", ".join(args_repr + kwargs_repr)
                 start = f"Calling {str(obj)}.{func.__name__}({signature})"
-                debug_file.write(start + "\n")
+                try:
+                    debug_file.write(start + "\n")
+                except (ValueError, OSError):
+                    pass
                 print(start)
                 t = time.time()
                 value = func(*args, **kwargs)
                 t = time.time() - t
                 finish = f"    {func.__name__} returned {value} after {t * 1000}ms"
                 print(finish)
-                debug_file.write(finish + "\n")
-                debug_file.flush()
+                try:
+                    debug_file.write(finish + "\n")
+                    debug_file.flush()
+                except (ValueError, OSError):
+                    pass
                 return value
 
             return wrapper_debug
@@ -1226,7 +1242,7 @@ class Kernel(Settings):
 
                     line = await loop.run_in_executor(None, sys.stdin.readline)
                     line = line.strip()
-                    if line in ("quit", "shutdown", "restart"):
+                    if line in ("quit", "shutdown", "exit", "restart"):
                         self._quit = True
                         if line == "restart":
                             self._restart = True
@@ -1906,6 +1922,8 @@ class Kernel(Settings):
             # Could be recurring job. Reset on reschedule.
         except AttributeError:
             pass
+        if job.job_name is None:
+            job.job_name = f"job_{id(job)}"
         self.jobs[job.job_name] = job
         return job
 
@@ -2667,6 +2685,9 @@ class Kernel(Settings):
             channel(_("----------"))
             channel(_("Scheduled Processes:"))
             for i, job_name in enumerate(self.jobs):
+                if job_name is None:
+                    channel(_("Empty job definition..."))
+                    continue
                 job = self.jobs[job_name]
                 parts = list()
                 parts.append(f"{i + 1}:")
@@ -2737,6 +2758,8 @@ class Kernel(Settings):
                 channel(_("Timers:"))
                 i = 0
                 for job_name in self.jobs:
+                    if job_name is None:
+                        continue
                     if not job_name.startswith("timer"):
                         continue
                     i += 1
@@ -2772,6 +2795,8 @@ class Kernel(Settings):
                     skipped = False
                     canceled = False
                     for job_name in list(self.jobs):
+                        if job_name is None:
+                            continue
                         if not job_name.startswith("timer"):
                             continue
                         timer_name = job_name[5:]
@@ -2830,7 +2855,7 @@ class Kernel(Settings):
 
         @self.console_command("beep", _("Perform beep"))
         def beep(channel, _, **kwargs):
-            OS_NAME = platform.system()
+            OS_NAME = self.os_information["OS_NAME"]
             system_sound = {
                 "Windows": r"c:\Windows\Media\Sounds\Alarm01.wav",
                 "Darwin": "/System/Library/Sounds/Ping.aiff",

meerk40t/kernel/settings.py

@@ -54,6 +54,8 @@ class Settings:
             FileNotFoundError,
         ):
             return
+        except UnicodeDecodeError as e:
+            print ("The config file contained unsupported characters, please share the file with the dev team")
         except (configparser.DuplicateOptionError, configparser.DuplicateSectionError) as e:
             print (f"We had a duplication error in the config, try to recover from {e}")
         for section in parser.sections():

meerk40t/lihuiyu/device.py

@@ -6,14 +6,16 @@ the given device type.
 """
 
 from hashlib import md5
+import platform
+
 import meerk40t.constants as mkconst
 from meerk40t.core.laserjob import LaserJob
 from meerk40t.core.spoolers import Spooler
 from meerk40t.core.view import View
 from meerk40t.kernel import CommandSyntaxError, Service, signal_listener
 
-from ..core.units import UNITS_PER_MIL, Length
-from ..device.mixins import Status
+from meerk40t.core.units import UNITS_PER_MIL, Length
+from meerk40t.device.mixins import Status
 from .controller import LihuiyuController
 from .driver import LihuiyuDriver
 from .tcp_connection import TCPOutput
@@ -514,7 +516,10 @@ class LihuiyuDevice(Service, Status):
         self.setting(str, "serial", None)
         self.setting(bool, "serial_enable", False)
 
-        self.setting(int, "port", 1022)
+        # Linux prevents ports below 1024 to be used in an non-root context
+        def_port = 1022 if platform.system() == "Windows" else "1025"
+
+        self.setting(int, "port", def_port)
         self.setting(str, "address", "localhost")
 
         self.driver = LihuiyuDriver(self)
@@ -978,6 +983,7 @@ class LihuiyuDevice(Service, Status):
                 server = self.open_as("module/TCPServer", server_name, port=port)
                 if quit:
                     self.close(server_name)
+                    channel(_("TCP Server for lihuiyu has been closed"))
                     return
                 channel(_("TCP Server for lihuiyu on port: {port}").format(port=port))
                 if verbose:

meerk40t/main.py

@@ -11,7 +11,7 @@ import os.path
 import sys
 
 APPLICATION_NAME = "MeerK40t"
-APPLICATION_VERSION = "0.9.7010"
+APPLICATION_VERSION = "0.9.7030"
 
 if not getattr(sys, "frozen", False):
     # If .git directory does not exist we are running from a package like pypi
@@ -151,6 +151,9 @@ parser.add_argument(
     action="store_true",
     help="start window maximized",
 )
+parser.add_argument(
+    "-d", "--daemon", action="store_true", help="keep MeerK40t in background"
+)
 
 
 def run():
@@ -220,12 +223,26 @@ def _exe(restarted, args):
     kernel.add_plugin(internal_plugins)
     kernel.add_plugin(external_plugins)
     auto = hasattr(kernel.args, "auto") and kernel.args.auto
+    command = hasattr(kernel.args, "execute") and kernel.args.execute
     console = hasattr(kernel.args, "console") and kernel.args.console
+    daemon = hasattr(kernel.args, "daemon") and kernel.args.daemon
+    server_mode = False
+    if command:
+        for c in command:
+            server_mode = server_mode or any(substring in c for substring in ("lhyserver", "grblserver", "ruidacontrol", "grblcontrol", "webserver"))
+    nogui = (
+        (hasattr(kernel.args, "gui_suppress") and kernel.args.gui_suppress) or
+        (hasattr(kernel.args, "no_gui") and kernel.args.no_gui) 
+    )
     for idx, attrib in enumerate(("mktablength", "mktabpositions")):
         kernel.register(f"registered_mk_svg_parameters/tabs{idx}", attrib)
 
-    if auto and not console:
-        kernel(partial=True)
-    else:
-        kernel()
+    require_partial_mode = False
+    if (
+        (not console or nogui) and
+        (auto or daemon or server_mode)
+    ):
+        require_partial_mode = True
+    # print (f"Auto: {auto}, Command: {command}, Console: {console}, daemon: {daemon}, nogui:{nogui}, Server: {server_mode} -> {require_partial_mode}")
+    kernel(partial=require_partial_mode)
     return hasattr(kernel, "restart") and kernel.restart