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

meerk40t/core/treeop.py

@@ -2,12 +2,28 @@
 Tree Operation decorators help define the Tree Operations found mostly in element_treeop class. We create dynamic menus
 and thus need to classify the various different methods to access a node, without actually creating giant and
 redundant code for each command on each code type.
+
+These functions are overwhelmingly decorators. The `tree_operation` decorator sets the default values for the function
+and all the other decorators set those values.
+
+This data is expected to be called in a menu, but can be called via the console or through other methods.
 """
 
 import functools
 
 
 def tree_calc(value_name, calc_func):
+    """
+    Decorate a calc function.
+
+    A calculator function will be called for each `value` in values or iterator, and will be permitted to calculate
+    some dynamic value from that function.
+
+    @param value_name:
+    @param calc_func:
+    @return:
+    """
+
     def decor(func):
         func.calcs.append((value_name, calc_func))
         return func
@@ -16,6 +32,13 @@ def tree_calc(value_name, calc_func):
 
 
 def tree_values(value_name, values):
+    """
+    Append explicit list of values and value_name to the function.
+    @param value_name:
+    @param values:
+    @return:
+    """
+
     def decor(func):
         func.value_name = value_name
         func.values = values
@@ -25,6 +48,16 @@ def tree_values(value_name, values):
 
 
 def tree_iterate(value_name, start, stop, step=1):
+    """
+    Append range list of values to function.
+
+    @param value_name:
+    @param start: Start value
+    @param stop: stop value
+    @param step: step amount
+    @return:
+    """
+
     def decor(func):
         func.value_name = value_name
         func.values = range(start, stop, step)
@@ -34,6 +67,13 @@ def tree_iterate(value_name, start, stop, step=1):
 
 
 def tree_radio(radio_function):
+    """
+    Append radio value to the operation for menus.
+
+    @param radio_function:
+    @return:
+    """
+
     def decor(func):
         func.radio = radio_function
         return func
@@ -42,6 +82,13 @@ def tree_radio(radio_function):
 
 
 def tree_check(check_function):
+    """
+    Append checkbox function to the operation for menus.
+
+    @param check_function:
+    @return:
+    """
+
     def decor(func):
         func.check = check_function
         return func
@@ -50,6 +97,13 @@ def tree_check(check_function):
 
 
 def tree_submenu(submenu):
+    """
+    Decorate a submenu on to the operation for menus.
+
+    @param submenu: submenu to use.
+    @return:
+    """
+
     def decor(func):
         func.submenu = submenu
         return func
@@ -58,6 +112,16 @@ def tree_submenu(submenu):
 
 
 def tree_prompt(attr, prompt, data_type=str):
+    """
+    Decorate a tree_prompt for the operations for menu, this function will request this information from the user
+    before calling the tree_operation function with the given attr.
+
+    @param attr:
+    @param prompt:
+    @param data_type:
+    @return:
+    """
+
     def decor(func):
         func.user_prompt.append(
             {
@@ -72,6 +136,15 @@ def tree_prompt(attr, prompt, data_type=str):
 
 
 def tree_conditional(conditional):
+    """
+    Decorate a conditional to the operation for menus.
+
+    Each conditional decorated to a function must pass for this menu item to show to the user.
+
+    @param conditional:
+    @return:
+    """
+
     def decor(func):
         func.conditionals.append(conditional)
         return func
@@ -80,6 +153,15 @@ def tree_conditional(conditional):
 
 
 def tree_conditional_try(conditional):
+    """
+    Decorate a try conditional on this operation for menu.
+
+    Try conditionals will not crash for the node, and can query states that may not exist.
+
+    @param conditional:
+    @return:
+    """
+
     def decor(func):
         func.try_conditionals.append(conditional)
         return func
@@ -88,6 +170,12 @@ def tree_conditional_try(conditional):
 
 
 def tree_reference(node):
+    """
+    Decorate a reference to on the tree.
+    @param node:
+    @return:
+    """
+
     def decor(func):
         func.reference = node
         return func
@@ -96,6 +184,12 @@ def tree_reference(node):
 
 
 def tree_separator_after():
+    """
+    Decorator to flag this operation as having a separator after it.
+
+    @return:
+    """
+
     def decor(func):
         func.separate_after = True
         return func
@@ -104,6 +198,12 @@ def tree_separator_after():
 
 
 def tree_separator_before():
+    """
+    Decorator to flag this operation as having a separator before it.
+
+    @return:
+    """
+
     def decor(func):
         func.separate_before = True
         return func
@@ -114,9 +214,28 @@ def tree_separator_before():
 def tree_operation(
     registration, name, node_type=None, help=None, enable=True, **kwargs
 ):
+    """
+    Main tree registration decorator. Registers the tree operation with the given help and set the enabled state.
+
+    @param registration: This is either a service or a kernel.
+    @param name: Name of the tree operation being registered (required)
+    @param node_type: types of node this operation applies to.
+    @param help: Help data to be displayed in menu or other help information locations.
+    @param enable: Should this be enabled.
+    @param kwargs: Any remaining keywords.
+    @return:
+    """
+
     def decorator(func):
         @functools.wraps(func)
         def inner(node, **ik):
+            """
+            Wrapped inner function executes the operation.
+
+            @param node:
+            @param ik:
+            @return:
+            """
             returned = func(node, **ik, **kwargs)
             return returned
 
@@ -127,32 +246,70 @@ def tree_operation(
 
         # inner.long_help = func.__doc__
         inner.help = help
+
+        # Tuple of node types this applies to.
         inner.node_type = ins
+
+        # Name of function.
         inner.name = name
+
+        # attached radio commands.
         inner.radio = None
+
+        # submenu of the operation
         inner.submenu = None
+
+        # Optional information
         inner.reference = None
+
+        # Should add a separator after this function.
         inner.separate_after = False
+
+        # Should add a separator before this function.
         inner.separate_before = False
+
+        # Conditionals required to be true to enable function.
         inner.conditionals = list()
+
+        # Conditional attempted in a try-execute block (these may throw errors)
         inner.try_conditionals = list()
+
+        # Prompt the user to discover this information.
         inner.user_prompt = list()
+
+        # Calculations for the values.
         inner.calcs = list()
+
+        # List of accepted values.
         inner.values = [0]
+
+        # Function enabled/disabled
         inner.enabled = enable
+
+        # Registered name is the same as the function name this is attached to.
         registered_name = inner.__name__
 
         for _in in ins:
+            # Register tree/node/name for each node within the registration.
             p = f"tree/{_in}/{registered_name}"
             if p in registration._registered:
+                # We used the name so we may not have duplicate tree operations with the same name.
                 raise NameError(f"A function of this name was already registered: {p}")
             registration.register(p, inner)
         return inner
 
+    # Return the entire decorator.
     return decorator
 
 
 def get_tree_operation(registration):
+    """
+    Returns a tree op for all the function calls with the registration already set.
+
+    @param registration:
+    @return:
+    """
+
     def treeop(name, node_type=None, help=None, enable=True, **kwargs):
         return tree_operation(
             registration, name, node_type=node_type, help=help, enable=enable, **kwargs
@@ -162,17 +319,26 @@ def get_tree_operation(registration):
 
 
 def tree_operations_for_node(registration, node):
+    """
+    Generator to produce all tree operations for the given node.
+
+    @param registration: kernel or service on which to find these operations
+    @param node:
+    @return:
+    """
     if node.type is None:
         return
     for func, m, sname in registration.find("tree", node.type, ".*"):
         reject = False
         for cond in func.conditionals:
+            # Do not provide this if the conditionals fail.
             if not cond(node):
                 reject = True
                 break
         if reject:
             continue
         for cond in func.try_conditionals:
+            # Do not provide this if the try conditional fail. Crash is a pass.
             try:
                 if not cond(node):
                     reject = True
@@ -193,6 +359,13 @@ def tree_operations_for_node(registration, node):
         )
 
         def unescaped(filename):
+            """
+            Provide unescaped name/label.
+            OS dependency is moot.
+
+            @param filename:
+            @return:
+            """
             from platform import system
 
             OS_NAME = system()
@@ -202,11 +375,13 @@ def tree_operations_for_node(registration, node):
                 newstring = filename.replace("&", "&&")
             return newstring
 
+        # Create the operation calling dictionary.
         func_dict = {
             "name": unescaped(node_name),
             "label": unescaped(node_label),
         }
 
+        # @tree_values / @tree_iterate values to be appended to function dictionary.
         iterator = func.values
         if iterator is None:
             iterator = [0]
@@ -215,7 +390,9 @@ def tree_operations_for_node(registration, node):
                 iterator = list(iterator())
             except TypeError:
                 pass
+
         for i, value in enumerate(iterator):
+            # Every value in the func.values gets an operation for the node.
             func_dict["iterator"] = i
             func_dict["value"] = value
             try:
@@ -224,30 +401,44 @@ def tree_operations_for_node(registration, node):
                 pass
 
             for calc in func.calcs:
+                # Calculators are done called for the given value, result is set in the call dictionary.
                 key, c = calc
                 value = c(value)
                 func_dict[key] = value
             if func.radio is not None:
+                # Sets the radio state by the radio function.
                 try:
                     func.radio_state = func.radio(node, **func_dict)
                 except:
                     func.radio_state = False
             else:
                 func.radio_state = None
+
             if hasattr(func, "check") and func.check is not None:
+                # Sets the checkbox state by the checkbox function.
                 try:
                     func.check_state = func.check(node, **func_dict)
                 except:
                     func.check_state = False
             else:
                 func.check_state = None
+
+            # Function name is formatted such that any {} format brackets are filled with their values.
             name = func.name.format_map(func_dict)
+
+            # Set the function and real name and provide it to the caller.
             func.func_dict = func_dict
             func.real_name = name
             yield func
 
 
 def get_tree_operation_for_node(registration):
+    """
+    Provide treeops for the given registration without needing to provide the registration each time, only the node.
+    @param registration:
+    @return:
+    """
+
     def treeop(node):
         return tree_operations_for_node(registration, node)
 

meerk40t/core/undos.py

@@ -20,7 +20,8 @@ class UndoState:
 
 
 class Undo:
-    def __init__(self, tree):
+    def __init__(self, service, tree):
+        self.service = service
         self.tree = tree
         self._lock = threading.Lock()
         self._undo_stack = []
@@ -53,6 +54,7 @@ class Undo:
                 pass
             del self._undo_stack[self._undo_index + 1 :]
             self.message = None
+        self.service.signal("undoredo")
 
     def undo(self):
         """
@@ -81,6 +83,7 @@ class Undo:
                 undo.state = self.tree.backup_tree()  # Get unused copy
             except KeyError:
                 pass
+            self.service.signal("undoredo")
             return True
 
     def redo(self):
@@ -102,9 +105,20 @@ class Undo:
                 redo.state = self.tree.backup_tree()  # Get unused copy
             except KeyError:
                 pass
+            self.service.signal("undoredo")
             return True
 
     def undolist(self):
         for i, v in enumerate(self._undo_stack):
             q = "*" if i == self._undo_index else " "
             yield f"{q}{str(i).ljust(5)}: state {str(v)}"
+
+    def has_undo(self, *args):
+        if self._undo_index == 0:
+            # At bottom of stack.
+            return False
+        # Stack is entirely empty.
+        return len(self._undo_stack) != 0
+
+    def has_redo(self, *args):
+        return self._undo_index < len(self._undo_stack) - 1

meerk40t/core/units.py

@@ -462,7 +462,7 @@ class Angle:
     converts to other forms of angle. Failures to parse raise ValueError.
     """
 
-    def __init__(self, angle, digits=None):
+    def __init__(self, angle, digits=None, preferred_units="rad"):
         if isinstance(angle, Angle):
             self._digits = angle._digits
             self.angle = angle.angle
@@ -471,7 +471,7 @@ class Angle:
         self._digits = digits
         if not isinstance(angle, str):
             self.angle = float(angle)
-            self.preferred_units = "rad"
+            self.preferred_units = preferred_units
             return
         angle = angle.lower()
         if angle.endswith("deg"):
@@ -492,13 +492,15 @@ class Angle:
             self.preferred_units = "%"
         else:
             self.angle = float(angle)
-            self.preferred_units = "rad"
+            self.preferred_units = preferred_units
 
     def __str__(self):
         return self.angle_preferred
 
     def __copy__(self):
-        return Angle(self.angle)
+        return Angle(
+            self.angle, preferred_units=self.preferred_units, digits=self._digits
+        )
 
     def __eq__(self, other):
         if hasattr(other, "angle"):
@@ -506,6 +508,14 @@ class Angle:
         c1 = abs((self.angle % tau) - (other % tau)) <= 1e-11
         return c1
 
+    def __float__(self):
+        return self.radians
+
+    def __neg__(self):
+        return Angle(
+            -self.angle, preferred_units=self.preferred_units, digits=self._digits
+        )
+
     def normalize(self):
         self.angle /= tau
 

meerk40t/device/dummydevice.py

@@ -2,7 +2,7 @@ from meerk40t.core.spoolers import Spooler
 from meerk40t.core.view import View
 from meerk40t.kernel import Service
 
-from ..core.units import UNITS_PER_MIL
+from .mixins import Status
 
 
 def plugin(kernel, lifecycle=None):
@@ -27,7 +27,7 @@ def plugin(kernel, lifecycle=None):
         )
 
 
-class DummyDevice(Service):
+class DummyDevice(Service, Status):
     """
     DummyDevice is a mock device service. It provides no actual device.
 
@@ -36,6 +36,7 @@ class DummyDevice(Service):
 
     def __init__(self, kernel, path, *args, choices=None, **kwargs):
         Service.__init__(self, kernel, path)
+        Status.__init__(self)
         self.name = "Dummy Device"
         if choices is not None:
             for c in choices:

meerk40t/device/gui/defaultactions.py

@@ -2,18 +2,18 @@ import wx
 
 from meerk40t.gui.icons import (
     STD_ICON_SIZE,
-    icons8_bell_20,
-    icons8_close_window_20,
-    icons8_down_50,
-    icons8_home_20,
-    icons8_input_20,
-    icons8_output_20,
-    icons8_remove_25,
-    icons8_return_20,
-    icons8_stop_gesture_20,
-    icons8_system_task_20,
-    icons8_timer_20,
-    icons8_up_50,
+    icon_bell,
+    icon_close_window,
+    icon_console,
+    icon_external,
+    icon_internal,
+    icon_return,
+    icon_round_stop,
+    icon_timer,
+    icon_trash,
+    icons8_down,
+    icons8_home_filled,
+    icons8_up,
 )
 from meerk40t.gui.wxutils import StaticBoxSizer, dip_size
 
@@ -41,17 +41,17 @@ class DefaultActionPanel(wx.Panel):
             ("Console", "util console", ""),
         )
         self.default_images = [
-            ["console home -f", icons8_home_20],
-            ["console move_abs", icons8_return_20],
-            ["console beep", icons8_bell_20],
-            ["console interrupt", icons8_stop_gesture_20],
-            ["console quit", icons8_close_window_20],
-            ["util wait", icons8_timer_20],
-            ["util home", icons8_home_20],
-            ["util goto", icons8_return_20],  # icons8_visit_20
-            ["util output", icons8_output_20],
-            ["util input", icons8_input_20],
-            ["util console", icons8_system_task_20],
+            ["console home -f", icons8_home_filled],
+            ["console move_abs", icon_return],
+            ["console beep", icon_bell],
+            ["console interrupt", icon_round_stop],
+            ["console quit", icon_close_window],
+            ["util wait", icon_timer],
+            ["util home", icons8_home_filled],
+            ["util goto", icon_return],  # icon_marker
+            ["util output", icon_external],
+            ["util input", icon_internal],
+            ["util console", icon_console],
         ]
         self.prepend_ops = []
         self.append_ops = []
@@ -61,6 +61,8 @@ class DefaultActionPanel(wx.Panel):
         sizer_after = StaticBoxSizer(self, wx.ID_ANY, _("At job end"), wx.VERTICAL)
         sizer_middle = wx.BoxSizer(wx.VERTICAL)
 
+        iconsize = dip_size(self, 30, 20)
+        bmpsize = min(iconsize[0], iconsize[1])
         self.option_list = wx.ListCtrl(
             self,
             wx.ID_ANY,
@@ -77,42 +79,24 @@ class DefaultActionPanel(wx.Panel):
 
         self.append_list = wx.ListCtrl(self, wx.ID_ANY, style=wx.LC_LIST)
         self.text_param_append = wx.TextCtrl(self, wx.ID_ANY)
-        self.button_del_prepend = wx.StaticBitmap(
-            self, wx.ID_ANY, size=dip_size(self, 30, 30)
-        )
-        self.button_up_prepend = wx.StaticBitmap(
-            self, wx.ID_ANY, size=dip_size(self, 30, 30)
-        )
-        self.button_down_prepend = wx.StaticBitmap(
-            self, wx.ID_ANY, size=dip_size(self, 30, 20)
-        )
+        self.button_del_prepend = wx.StaticBitmap(self, wx.ID_ANY, size=iconsize)
+        self.button_up_prepend = wx.StaticBitmap(self, wx.ID_ANY, size=iconsize)
+        self.button_down_prepend = wx.StaticBitmap(self, wx.ID_ANY, size=iconsize)
         self.button_del_prepend.SetBitmap(
-            icons8_remove_25.GetBitmap(resize=STD_ICON_SIZE / 2)
-        )
-        self.button_up_prepend.SetBitmap(
-            icons8_up_50.GetBitmap(resize=STD_ICON_SIZE / 2)
+            icon_trash.GetBitmap(resize=bmpsize, buffer=1)
         )
+        self.button_up_prepend.SetBitmap(icons8_up.GetBitmap(resize=bmpsize, buffer=1))
         self.button_down_prepend.SetBitmap(
-            icons8_down_50.GetBitmap(resize=STD_ICON_SIZE / 2)
+            icons8_down.GetBitmap(resize=bmpsize, buffer=1)
         )
 
-        self.button_del_append = wx.StaticBitmap(
-            self, wx.ID_ANY, size=dip_size(self, 30, 30)
-        )
-        self.button_up_append = wx.StaticBitmap(
-            self, wx.ID_ANY, size=dip_size(self, 30, 30)
-        )
-        self.button_down_append = wx.StaticBitmap(
-            self, wx.ID_ANY, size=dip_size(self, 30, 30)
-        )
-        self.button_del_append.SetBitmap(
-            icons8_remove_25.GetBitmap(resize=STD_ICON_SIZE / 2)
-        )
-        self.button_up_append.SetBitmap(
-            icons8_up_50.GetBitmap(resize=STD_ICON_SIZE / 2)
-        )
+        self.button_del_append = wx.StaticBitmap(self, wx.ID_ANY, size=iconsize)
+        self.button_up_append = wx.StaticBitmap(self, wx.ID_ANY, size=iconsize)
+        self.button_down_append = wx.StaticBitmap(self, wx.ID_ANY, size=iconsize)
+        self.button_del_append.SetBitmap(icon_trash.GetBitmap(resize=bmpsize, buffer=1))
+        self.button_up_append.SetBitmap(icons8_up.GetBitmap(resize=bmpsize, buffer=1))
         self.button_down_append.SetBitmap(
-            icons8_down_50.GetBitmap(resize=STD_ICON_SIZE / 2)
+            icons8_down.GetBitmap(resize=bmpsize, buffer=1)
         )
 
         sizer_param = StaticBoxSizer(
@@ -479,7 +463,9 @@ class DefaultActionPanel(wx.Panel):
         setattr(self.context, str_count, len(self.append_ops))
 
     def setup_state_images(self):
-        iconsize = 20
+        testsize = dip_size(self, 20, 20)
+        iconsize = testsize[1]
+
         self.options_images = wx.ImageList()
         self.options_images.Create(width=iconsize, height=iconsize)
         self.prepend_images = wx.ImageList()
@@ -487,7 +473,9 @@ class DefaultActionPanel(wx.Panel):
         self.append_images = wx.ImageList()
         self.append_images.Create(width=iconsize, height=iconsize)
         for entry in self.default_images:
-            image = entry[1].GetBitmap(resize=(iconsize, iconsize), noadjustment=True)
+            image = entry[1].GetBitmap(
+                resize=(iconsize, iconsize), buffer=2, noadjustment=True
+            )
             image_id1 = self.options_images.Add(bitmap=image)
             image_id2 = self.prepend_images.Add(bitmap=image)
             image_id3 = self.append_images.Add(bitmap=image)