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

meerk40t/gui/materialtest.py

@@ -5,6 +5,7 @@ import wx
 from wx import aui
 
 from meerk40t.core.node.effect_hatch import HatchEffectNode
+from meerk40t.core.node.effect_wobble import WobbleEffectNode
 from meerk40t.core.node.op_cut import CutOpNode
 from meerk40t.core.node.op_engrave import EngraveOpNode
 from meerk40t.core.node.op_image import ImageOpNode
@@ -18,6 +19,7 @@ from meerk40t.gui.wxutils import (
     dip_size,
     wxButton,
     wxCheckBox,
+    wxCheckListBox,
     wxComboBox,
     wxListBox,
     wxStaticText,
@@ -184,21 +186,45 @@ class TemplatePanel(wx.Panel):
         self.storage = storage
         self.callback = None
         self.current_op = None
-        opchoices = [_("Cut"), _("Engrave"), _("Raster"), _("Image"), _("Hatch")]
+        opchoices = [
+            _("Cut"),
+            _("Engrave"),
+            _("Raster"),
+            _("Image"),
+            _("Hatch"),
+            _("Wobble"),
+        ]
         # Setup 5 Op nodes - they aren't saved yet
         self.default_op = []
+        self.secondary_default_op = []
         # A tuple defining whether a free color-selection scheme is allowed, linked to default_op
         self.color_scheme_free = []
         self.default_op.append(CutOpNode())
+        self.secondary_default_op.append(None)
         self.color_scheme_free.append(True)
+
         self.default_op.append(EngraveOpNode())
         self.color_scheme_free.append(True)
+        self.secondary_default_op.append(None)
+
         self.default_op.append(RasterOpNode())
         self.color_scheme_free.append(False)
+        self.secondary_default_op.append(None)
+
         self.default_op.append(ImageOpNode())
         self.color_scheme_free.append(True)
+        self.secondary_default_op.append(None)
+
+        # Hatch = Engrave
         op = EngraveOpNode()
         self.default_op.append(op)
+        self.secondary_default_op.append(HatchEffectNode())
+        self.color_scheme_free.append(True)
+
+        # Wobble = Cut
+        op = CutOpNode()
+        self.default_op.append(op)
+        self.secondary_default_op.append(WobbleEffectNode())
         self.color_scheme_free.append(True)
 
         self.use_image = [False] * len(self.default_op)
@@ -257,6 +283,10 @@ class TemplatePanel(wx.Panel):
         self.text_dim_1.set_range(0, 50)
         self.text_delta_1 = TextCtrl(self, wx.ID_ANY, limited=True, check="float")
         self.text_delta_1.set_range(0, 50)
+        self.list_options_1 = wxCheckListBox(
+            self, wx.ID_ANY, label=_("Pick values"), majorDimension=3
+        )
+
         self.unit_param_1a = wxStaticText(self, wx.ID_ANY, "")
         self.unit_param_1b = wxStaticText(self, wx.ID_ANY, "")
 
@@ -276,6 +306,9 @@ class TemplatePanel(wx.Panel):
         self.text_max_2 = TextCtrl(self, wx.ID_ANY, limited=True, check="float")
         self.text_dim_2 = TextCtrl(self, wx.ID_ANY, limited=True, check="float")
         self.text_dim_2.set_range(0, 50)
+        self.list_options_2 = wxCheckListBox(
+            self, wx.ID_ANY, label=_("Pick values"), majorDimension=3
+        )
         self.text_delta_2 = TextCtrl(self, wx.ID_ANY, limited=True, check="float")
         self.text_delta_2.set_range(0, 50)
         self.unit_param_2a = wxStaticText(self, wx.ID_ANY, "")
@@ -318,7 +351,7 @@ class TemplatePanel(wx.Panel):
         sizer_param_optype.Add(sizer_param_check, 1, wx.EXPAND, 0)
 
         sizer_param_xy = wx.BoxSizer(wx.HORIZONTAL)
-        sizer_param_x = StaticBoxSizer(
+        self.sizer_param_x = StaticBoxSizer(
             self, wx.ID_ANY, _("First parameter (X-Axis)"), wx.VERTICAL
         )
 
@@ -327,7 +360,7 @@ class TemplatePanel(wx.Panel):
         size_it(mylbl, LABEL_WIDTH)
         hline_param_1.Add(mylbl, 0, wx.ALIGN_CENTER_VERTICAL, 0)
         hline_param_1.Add(self.combo_param_1, 1, wx.ALIGN_CENTER_VERTICAL, 0)
-
+        self.min_max_container_1 = wx.BoxSizer(wx.VERTICAL)
         hline_count_1 = wx.BoxSizer(wx.HORIZONTAL)
         mylbl = wxStaticText(self, wx.ID_ANY, _("Count:"))
         size_it(mylbl, LABEL_WIDTH)
@@ -350,6 +383,9 @@ class TemplatePanel(wx.Panel):
         hline_max_1.Add(mylbl, 0, wx.ALIGN_CENTER_VERTICAL, 0)
         hline_max_1.Add(self.text_max_1, 1, wx.ALIGN_CENTER_VERTICAL, 0)
         hline_max_1.Add(self.unit_param_1b, 0, wx.ALIGN_CENTER_VERTICAL, 0)
+        self.min_max_container_1.Add(hline_count_1, 0, wx.EXPAND, 0)
+        self.min_max_container_1.Add(hline_min_1, 0, wx.EXPAND, 0)
+        self.min_max_container_1.Add(hline_max_1, 0, wx.EXPAND, 0)
 
         hline_dim_1 = wx.BoxSizer(wx.HORIZONTAL)
         mylbl = wxStaticText(self, wx.ID_ANY, _("Width:"))
@@ -374,15 +410,14 @@ class TemplatePanel(wx.Panel):
         hline_color_1.Add(self.combo_color_1, 1, wx.ALIGN_CENTER_VERTICAL, 0)
         hline_color_1.Add(self.check_color_direction_1, 1, wx.ALIGN_CENTER_VERTICAL, 0)
 
-        sizer_param_x.Add(hline_param_1, 0, wx.EXPAND, 0)
-        sizer_param_x.Add(hline_count_1, 0, wx.EXPAND, 0)
-        sizer_param_x.Add(hline_min_1, 0, wx.EXPAND, 0)
-        sizer_param_x.Add(hline_max_1, 0, wx.EXPAND, 0)
-        sizer_param_x.Add(hline_dim_1, 0, wx.EXPAND, 0)
-        sizer_param_x.Add(hline_delta_1, 0, wx.EXPAND, 0)
-        sizer_param_x.Add(hline_color_1, 0, wx.EXPAND, 0)
+        self.sizer_param_x.Add(hline_param_1, 0, wx.EXPAND, 0)
+        self.sizer_param_x.Add(self.min_max_container_1, 0, wx.EXPAND, 0)
+        self.sizer_param_x.Add(self.list_options_1, 0, wx.EXPAND, 0)
+        self.sizer_param_x.Add(hline_dim_1, 0, wx.EXPAND, 0)
+        self.sizer_param_x.Add(hline_delta_1, 0, wx.EXPAND, 0)
+        self.sizer_param_x.Add(hline_color_1, 0, wx.EXPAND, 0)
 
-        sizer_param_y = StaticBoxSizer(
+        self.sizer_param_y = StaticBoxSizer(
             self, wx.ID_ANY, _("Second parameter (Y-Axis)"), wx.VERTICAL
         )
 
@@ -392,6 +427,7 @@ class TemplatePanel(wx.Panel):
         hline_param_2.Add(mylbl, 0, wx.ALIGN_CENTER_VERTICAL, 0)
         hline_param_2.Add(self.combo_param_2, 1, wx.ALIGN_CENTER_VERTICAL, 0)
 
+        self.min_max_container_2 = wx.BoxSizer(wx.VERTICAL)
         hline_count_2 = wx.BoxSizer(wx.HORIZONTAL)
         mylbl = wxStaticText(self, wx.ID_ANY, _("Count:"))
         size_it(mylbl, LABEL_WIDTH)
@@ -414,6 +450,10 @@ class TemplatePanel(wx.Panel):
         hline_max_2.Add(self.text_max_2, 1, wx.ALIGN_CENTER_VERTICAL, 0)
         hline_max_2.Add(self.unit_param_2b, 0, wx.ALIGN_CENTER_VERTICAL, 0)
 
+        self.min_max_container_2.Add(hline_count_2, 0, wx.EXPAND, 0)
+        self.min_max_container_2.Add(hline_min_2, 0, wx.EXPAND, 0)
+        self.min_max_container_2.Add(hline_max_2, 0, wx.EXPAND, 0)
+
         hline_dim_2 = wx.BoxSizer(wx.HORIZONTAL)
         mylbl = wxStaticText(self, wx.ID_ANY, _("Height:"))
         size_it(mylbl, LABEL_WIDTH)
@@ -437,16 +477,15 @@ class TemplatePanel(wx.Panel):
         hline_color_2.Add(self.combo_color_2, 1, wx.ALIGN_CENTER_VERTICAL, 0)
         hline_color_2.Add(self.check_color_direction_2, 1, wx.ALIGN_CENTER_VERTICAL, 0)
 
-        sizer_param_y.Add(hline_param_2, 0, wx.EXPAND, 0)
-        sizer_param_y.Add(hline_count_2, 0, wx.EXPAND, 0)
-        sizer_param_y.Add(hline_min_2, 0, wx.EXPAND, 0)
-        sizer_param_y.Add(hline_max_2, 0, wx.EXPAND, 0)
-        sizer_param_y.Add(hline_dim_2, 0, wx.EXPAND, 0)
-        sizer_param_y.Add(hline_delta_2, 0, wx.EXPAND, 0)
-        sizer_param_y.Add(hline_color_2, 0, wx.EXPAND, 0)
+        self.sizer_param_y.Add(hline_param_2, 0, wx.EXPAND, 0)
+        self.sizer_param_y.Add(self.min_max_container_2, 0, wx.EXPAND, 0)
+        self.sizer_param_y.Add(self.list_options_2, 0, wx.EXPAND, 0)
+        self.sizer_param_y.Add(hline_dim_2, 0, wx.EXPAND, 0)
+        self.sizer_param_y.Add(hline_delta_2, 0, wx.EXPAND, 0)
+        self.sizer_param_y.Add(hline_color_2, 0, wx.EXPAND, 0)
 
-        sizer_param_xy.Add(sizer_param_x, 1, wx.EXPAND, 0)
-        sizer_param_xy.Add(sizer_param_y, 1, wx.EXPAND, 0)
+        sizer_param_xy.Add(self.sizer_param_x, 1, wx.EXPAND, 0)
+        sizer_param_xy.Add(self.sizer_param_y, 1, wx.EXPAND, 0)
 
         sizer_main.Add(sizer_param_optype, 0, wx.EXPAND, 0)
         sizer_main.Add(sizer_param_xy, 0, wx.EXPAND, 0)
@@ -556,6 +595,8 @@ class TemplatePanel(wx.Panel):
         self.combo_images.Bind(wx.EVT_COMBOBOX, self.on_combo_image)
         self.spin_count_1.Bind(wx.EVT_SPINCTRL, self.validate_input)
         self.spin_count_2.Bind(wx.EVT_SPINCTRL, self.validate_input)
+        self.Bind(wx.EVT_CHECKLISTBOX, self.validate_input, self.list_options_1)
+        self.Bind(wx.EVT_CHECKLISTBOX, self.validate_input, self.list_options_2)
 
         self.SetSizer(sizer_main)
         self.Layout()
@@ -577,6 +618,7 @@ class TemplatePanel(wx.Panel):
         return result
 
     def on_combo_image(self, event):
+        self.validate_input(event)
         op = self.combo_ops.GetSelection()
         if op != 3:  # No Image?
             return
@@ -589,11 +631,19 @@ class TemplatePanel(wx.Panel):
                 self.text_dim_1.SetValue(f"{wd.mm:.1f}")
                 self.text_dim_2.SetValue(f"{ht.mm:.1f}")
 
+    def on_selection_list(self, event):
+        return
+
     def set_callback(self, routine):
         self.callback = routine
         idx = self.combo_ops.GetSelection()
+        opnode = None
+        secondary_node = None
+        if idx >= 0:
+            opnode = self.default_op[idx]
+            secondary_node = self.secondary_default_op[idx]
         if self.callback is not None and idx >= 0:
-            self.callback(self.default_op[idx])
+            self.callback(opnode, secondary_node)
 
     def use_percent(self):
         self.context.device.setting(bool, "use_percent_for_power_display", False)
@@ -653,25 +703,28 @@ class TemplatePanel(wx.Panel):
         self.Freeze()
         if opidx < 0:
             opnode = None
+            secondary_node = None
             self._freecolor = True
             self.combo_images.Show(False)
             self.text_dim_1.Enable(True)
             self.text_dim_2.Enable(True)
         else:
             opnode = self.default_op[opidx]
+            secondary_node = self.secondary_default_op[opidx]
             self._freecolor = self.color_scheme_free[opidx]
             self.combo_images.Show(self.use_image[opidx])
             self.text_dim_1.Enable(not self.use_image[opidx])
             self.text_dim_2.Enable(not self.use_image[opidx])
+
         self.sizer_param_op.Layout()
         if self.callback is not None:
-            self.callback(opnode)
+            self.callback(opnode, secondary_node)
         self.combo_color_1.Enable(self._freecolor)
         self.combo_color_2.Enable(self._freecolor)
         self.check_color_direction_1.Enable(self._freecolor)
         self.check_color_direction_2.Enable(self._freecolor)
 
-        # (internal_attribute, secondary_attribute, Label, unit, keep_unit, needs_to_be_positive)
+        # (internal_attribute, secondary_attribute, Label, unit, keep_unit, needs_to_be_positive, choices)
         if self.use_percent():
             ppi = "%"
         else:
@@ -681,64 +734,159 @@ class TemplatePanel(wx.Panel):
         else:
             speed_unit = "mm/s"
         self.parameters = [
-            ("speed", None, _("Speed"), speed_unit, False, True),
-            ("power", None, _("Power"), ppi, False, True),
-            ("passes", preset_passes, _("Passes"), "x", False, True),
+            ("speed", None, _("Speed"), speed_unit, False, True, None),
+            ("power", None, _("Power"), ppi, False, True, None),
+            ("passes", preset_passes, _("Passes"), "x", False, True, None),
         ]
 
         if opidx == 0:
             # Cut
             # (internal_attribute, secondary_attribute, Label, unit, keep_unit, needs_to_be_positive, type)
             self.parameters = [
-                ("speed", None, _("Speed"), speed_unit, False, True, None),
-                ("power", None, _("Power"), ppi, False, True, None),
-                ("passes", preset_passes, _("Passes"), "x", False, True, int),
+                ("speed", None, _("Speed"), speed_unit, False, True, None, None),
+                ("power", None, _("Power"), ppi, False, True, None, None),
+                ("passes", preset_passes, _("Passes"), "x", False, True, int, None),
             ]
         elif opidx == 1:
             # Engrave
             self.parameters = [
-                ("speed", None, _("Speed"), speed_unit, False, True, None),
-                ("power", None, _("Power"), ppi, False, True, None),
-                ("passes", preset_passes, _("Passes"), "x", False, True, int),
+                ("speed", None, _("Speed"), speed_unit, False, True, None, None),
+                ("power", None, _("Power"), ppi, False, True, None, None),
+                ("passes", preset_passes, _("Passes"), "x", False, True, int, None),
             ]
         elif opidx == 2:
             # Raster
             self.parameters = [
-                ("speed", None, _("Speed"), speed_unit, False, True, None),
-                ("power", None, _("Power"), ppi, False, True, None),
-                ("passes", preset_passes, _("Passes"), "x", False, True, int),
-                ("dpi", None, _("DPI"), "dpi", False, True, int),
-                ("overscan", None, _("Overscan"), "mm", False, True, None),
+                ("speed", None, _("Speed"), speed_unit, False, True, None, None),
+                ("power", None, _("Power"), ppi, False, True, None, None),
+                ("passes", preset_passes, _("Passes"), "x", False, True, int, None),
+                ("dpi", None, _("DPI"), "dpi", False, True, int, None),
+                ("overscan", None, _("Overscan"), "mm", False, True, None, None),
             ]
         elif opidx == 3:
             # Image
             self.parameters = [
-                ("speed", None, _("Speed"), speed_unit, False, True, None),
-                ("power", None, _("Power"), ppi, False, True, None),
-                ("passes", preset_passes, _("Passes"), "x", False, True, int),
-                ("dpi", preset_image_dpi, _("DPI"), "dpi", False, True, int),
-                ("overscan", None, _("Overscan"), "mm", False, True, None),
+                ("speed", None, _("Speed"), speed_unit, False, True, None, None),
+                ("power", None, _("Power"), ppi, False, True, None, None),
+                ("passes", preset_passes, _("Passes"), "x", False, True, int, None),
+                ("dpi", preset_image_dpi, _("DPI"), "dpi", False, True, int, None),
+                ("overscan", None, _("Overscan"), "mm", False, True, None, None),
             ]
         elif opidx == 4:
             # Hatch
             self.parameters = [
-                ("speed", None, _("Speed"), speed_unit, False, True, None),
-                ("power", None, _("Power"), ppi, False, True, None),
-                ("passes", preset_passes, _("Passes"), "x", False, True, int),
-                ("hatch_distance", None, _("Hatch Distance"), "mm", False, True, None),
-                ("hatch_angle", None, _("Hatch Angle"), "deg", False, True, None),
+                ("speed", None, _("Speed"), speed_unit, False, True, None, None),
+                ("power", None, _("Power"), ppi, False, True, None, None),
+                ("passes", preset_passes, _("Passes"), "x", False, True, int, None),
+                (
+                    "hatch_distance",
+                    None,
+                    _("Hatch Distance"),
+                    "mm",
+                    False,
+                    True,
+                    None,
+                    None,
+                ),
+                ("hatch_angle", None, _("Hatch Angle"), "deg", False, True, None, None),
+            ]
+        elif opidx == 5:
+            # Wobble
+            # (internal_attribute, secondary_attribute, Label, unit, keep_unit, needs_to_be_positive, type)
+            wobble_choices = list(self.context.match("wobble", suffix=True))
+            self.parameters = [
+                ("speed", None, _("Speed"), speed_unit, False, True, None, None),
+                ("power", None, _("Power"), ppi, False, True, None, None),
+                ("passes", preset_passes, _("Passes"), "x", False, True, int, None),
+                # wobble_radius
+                (
+                    "wobble_radius",
+                    preset_balor_wobble,
+                    _("Wobble Radius"),
+                    "mm",
+                    True,
+                    True,
+                    None,
+                    None,
+                ),
+                (
+                    "wobble_interval",
+                    preset_balor_wobble,
+                    _("Wobble Interval"),
+                    "mm",
+                    True,
+                    True,
+                    None,
+                    None,
+                ),
+                (
+                    "wobble_speed",
+                    preset_balor_wobble,
+                    _("Wobble Speed Multiplier"),
+                    "x",
+                    False,
+                    True,
+                    None,
+                    None,
+                ),
             ]
+            if wobble_choices:
+                self.parameters.append(
+                    (
+                        "wobble_type",
+                        preset_balor_wobble,
+                        _("Wobble Type"),
+                        "",
+                        True,
+                        True,
+                        None,
+                        wobble_choices,
+                    ),
+                )
 
         if "balor" in self.context.device.path:
             balor_choices = [
-                ("frequency", None, _("Frequency"), "kHz", False, True, None),
-                ("rapid_speed", preset_balor_rapid, _("Rapid Speed"), "mm/s", False, True, None,),
-                ("delay_laser_on", preset_balor_timings, _("Laser On Delay"), "µs", False, False, None,),
-                ("delay_laser_off", preset_balor_timings, _("Laser Off Delay"), "µs", False, False, None,),
-                ("delay_polygon", preset_balor_timings, _("Polygon Delay"), "µs", False, False, None,),
-                ("wobble_radius", preset_balor_wobble, _("Wobble Radius"), "mm", True, True, None,),
-                ("wobble_interval", preset_balor_wobble, _("Wobble Interval"), "mm", True, True, None,),
-                ("wobble_speed", preset_balor_wobble, _("Wobble Speed Multiplier"), "x", False, True, None,),
+                ("frequency", None, _("Frequency"), "kHz", False, True, None, None),
+                (
+                    "rapid_speed",
+                    preset_balor_rapid,
+                    _("Rapid Speed"),
+                    "mm/s",
+                    False,
+                    True,
+                    None,
+                    None,
+                ),
+                (
+                    "delay_laser_on",
+                    preset_balor_timings,
+                    _("Laser On Delay"),
+                    "µs",
+                    False,
+                    False,
+                    None,
+                    None,
+                ),
+                (
+                    "delay_laser_off",
+                    preset_balor_timings,
+                    _("Laser Off Delay"),
+                    "µs",
+                    False,
+                    False,
+                    None,
+                    None,
+                ),
+                (
+                    "delay_polygon",
+                    preset_balor_timings,
+                    _("Polygon Delay"),
+                    "µs",
+                    False,
+                    False,
+                    None,
+                    None,
+                ),
             ]
             if self.context.device.pulse_width_enabled:
                 balor_choices.append(
@@ -750,11 +898,11 @@ class TemplatePanel(wx.Panel):
                         False,
                         True,
                         None,
+                        None,
                     )
                 )
 
-            for entry in balor_choices:
-                self.parameters.append(entry)
+            self.parameters.extend(balor_choices)
         # for p in self.parameters:
         #     if len(p) != 7:
         #         print (f"No good: {p}")
@@ -787,11 +935,32 @@ class TemplatePanel(wx.Panel):
         # 0 = internal_attribute, 1 = secondary_attribute,
         # 2 = Label, 3 = unit,
         # 4 = keep_unit, 5 = needs_to_be_positive)
+        standard_items = True
+        choices = []
         if 0 <= idx < len(self.parameters):
             s_unit = self.parameters[idx][3]
             b_positive = self.parameters[idx][5]
+            if self.parameters[idx][7] is not None:
+                self.context.template_list1 = "|".join(
+                    self.list_options_1.GetCheckedStrings()
+                )
+                standard_items = False
+                choices = self.parameters[idx][7]
+                self.list_options_1.Set(choices)
+                checked_strings = [
+                    s for s in self.context.template_list1.split("|") if s
+                ]
+                if not checked_strings:
+                    checked_strings = choices
+                self.list_options_1.SetCheckedStrings(checked_strings)
+
         self.unit_param_1a.SetLabel(s_unit)
         self.unit_param_1b.SetLabel(s_unit)
+        self.min_max_container_1.ShowItems(standard_items)
+        self.list_options_1.Show(not standard_items)
+        self.sizer_param_x.Layout()
+        self.Layout()
+
         # And now enter validation...
         self.validate_input(None)
 
@@ -801,10 +970,29 @@ class TemplatePanel(wx.Panel):
         # 0 = internal_attribute, 1 = secondary_attribute,
         # 2 = Label, 3 = unit,
         # 4 = keep_unit, 5 = needs_to_be_positive)
+        standard_items = True
+        choices = []
         if 0 <= idx < len(self.parameters):
             s_unit = self.parameters[idx][3]
+            if self.parameters[idx][7] is not None:
+                self.context.template_list2 = "|".join(
+                    self.list_options_2.GetCheckedStrings()
+                )
+                standard_items = False
+                choices = self.parameters[idx][7]
+                self.list_options_2.Set(choices)
+                checked_strings = [
+                    s for s in self.context.template_list2.split("|") if s
+                ]
+                if not checked_strings:
+                    checked_strings = choices
+                self.list_options_2.SetCheckedStrings(checked_strings)
         self.unit_param_2a.SetLabel(s_unit)
         self.unit_param_2b.SetLabel(s_unit)
+        self.min_max_container_2.ShowItems(standard_items)
+        self.list_options_2.Show(not standard_items)
+        self.sizer_param_y.Layout()
+        self.Layout()
         # And now enter validation...
         self.validate_input(None)
 
@@ -820,83 +1008,97 @@ class TemplatePanel(wx.Panel):
                     result = False
             return result
 
-        active = True
-        valid_interval_1 = True
-        valid_interval_2 = True
-        optype = self.combo_ops.GetSelection()
-        if optype < 0:
-            active = False
-        if (
-            optype == 3 and self.combo_images.GetSelection() < 1
-        ):  # image and no valid image chosen
-            active = False
-        idx1 = self.combo_param_1.GetSelection()
-        if idx1 < 0:
-            active = False
-        idx2 = self.combo_param_2.GetSelection()
-        if idx2 < 0:
-            active = False
-        if idx1 == idx2:
-            active = False
-        if not valid_float(self.text_min_1):
-            active = False
-            valid_interval_1 = False
-        if not valid_float(self.text_max_1):
-            active = False
-            valid_interval_1 = False
-        if not valid_float(self.text_min_2):
-            active = False
-            valid_interval_2 = False
-        if not valid_float(self.text_max_2):
-            active = False
-            valid_interval_2 = False
-        if not valid_float(self.text_dim_1):
-            active = False
-        if not valid_float(self.text_delta_1):
-            active = False
-        if not valid_float(self.text_dim_2):
-            active = False
-        if not valid_float(self.text_delta_2):
-            active = False
-        if valid_interval_1:
-            minv = float(self.text_min_1.GetValue())
-            maxv = float(self.text_max_1.GetValue())
-            count = self.spin_count_1.GetValue()
-            delta = maxv - minv
-            if count > 1:
-                delta /= count - 1
-            s_unit = ""
-            idx = self.combo_param_1.GetSelection()
-            # 0 = internal_attribute, 1 = secondary_attribute,
-            # 2 = Label, 3 = unit,
-            # 4 = keep_unit, 5 = needs_to_be_positive)
-            if 0 <= idx < len(self.parameters):
-                s_unit = self.parameters[idx][3]
-            self.info_delta_1.SetLabel(
-                _("Every {dist}").format(dist=self.shortened(delta, 3) + s_unit)
-            )
-        else:
-            self.info_delta_1.SetLabel("---")
-        if valid_interval_2:
-            minv = float(self.text_min_2.GetValue())
-            maxv = float(self.text_max_2.GetValue())
-            count = self.spin_count_2.GetValue()
-            delta = maxv - minv
-            if count > 1:
-                delta /= count - 1
-            s_unit = ""
-            idx = self.combo_param_2.GetSelection()
-            # 0 = internal_attribute, 1 = secondary_attribute,
-            # 2 = Label, 3 = unit,
-            # 4 = keep_unit, 5 = needs_to_be_positive)
-            if 0 <= idx < len(self.parameters):
-                s_unit = self.parameters[idx][3]
-            self.info_delta_2.SetLabel(
-                _("Every {dist}").format(dist=self.shortened(delta, 3) + s_unit)
-            )
-        else:
-            self.info_delta_2.SetLabel("---")
+        def check_for_active():
+            active = True
+            valid_interval_1 = True
+            valid_interval_2 = True
+            optype = self.combo_ops.GetSelection()
+            if optype < 0:
+                return False
+            if (
+                optype == 3 and self.combo_images.GetSelection() < 1
+            ):  # image and no valid image chosen
+                return False
+            idx1 = self.combo_param_1.GetSelection()
+            if idx1 < 0:
+                return False
+            idx2 = self.combo_param_2.GetSelection()
+            if idx2 < 0:
+                return False
+            if idx1 == idx2:
+                return False
+            # Proper check for standard / non-standard parameters
+            if self.parameters[idx1][7] is not None:
+                if not self.list_options_1.GetCheckedStrings():
+                    active = False
+                valid_interval_1 = True
+            else:
+                if not valid_float(self.text_min_1):
+                    active = False
+                    valid_interval_1 = False
+                if not valid_float(self.text_max_1):
+                    active = False
+                    valid_interval_1 = False
+            if self.parameters[idx2][7] is not None:
+                if not self.list_options_2.GetCheckedStrings():
+                    active = False
+                valid_interval_2 = True
+            else:
+                if not valid_float(self.text_min_2):
+                    active = False
+                    valid_interval_2 = False
+                if not valid_float(self.text_max_2):
+                    active = False
+                    valid_interval_2 = False
+            if not valid_float(self.text_dim_1):
+                active = False
+            if not valid_float(self.text_delta_1):
+                active = False
+            if not valid_float(self.text_dim_2):
+                active = False
+            if not valid_float(self.text_delta_2):
+                active = False
+            if valid_interval_1:
+                minv = float(self.text_min_1.GetValue())
+                maxv = float(self.text_max_1.GetValue())
+                count = self.spin_count_1.GetValue()
+                delta = maxv - minv
+                if count > 1:
+                    delta /= count - 1
+                s_unit = ""
+                idx = self.combo_param_1.GetSelection()
+                # 0 = internal_attribute, 1 = secondary_attribute,
+                # 2 = Label, 3 = unit,
+                # 4 = keep_unit, 5 = needs_to_be_positive)
+                if 0 <= idx < len(self.parameters):
+                    s_unit = self.parameters[idx][3]
+                self.info_delta_1.SetLabel(
+                    _("Every {dist}").format(dist=self.shortened(delta, 3) + s_unit)
+                )
+            else:
+                self.info_delta_1.SetLabel("---")
+            if valid_interval_2:
+                minv = float(self.text_min_2.GetValue())
+                maxv = float(self.text_max_2.GetValue())
+                count = self.spin_count_2.GetValue()
+                delta = maxv - minv
+                if count > 1:
+                    delta /= count - 1
+                s_unit = ""
+                idx = self.combo_param_2.GetSelection()
+                # 0 = internal_attribute, 1 = secondary_attribute,
+                # 2 = Label, 3 = unit,
+                # 4 = keep_unit, 5 = needs_to_be_positive)
+                if 0 <= idx < len(self.parameters):
+                    s_unit = self.parameters[idx][3]
+                self.info_delta_2.SetLabel(
+                    _("Every {dist}").format(dist=self.shortened(delta, 3) + s_unit)
+                )
+            else:
+                self.info_delta_2.SetLabel("---")
+            return active
 
+        active = check_for_active()
         self.button_create.Enable(active)
 
     def on_device_update(self):
@@ -950,8 +1152,38 @@ class TemplatePanel(wx.Panel):
             self.context.elements.clear_operations(fast=True)
             self.context.elements.clear_elements(fast=True)
 
-        def create_operations():
+        def create_operations(range1, range2):
             # opchoices = [_("Cut"), _("Engrave"), _("Raster"), _("Image"), _("Hatch")]
+            count_1 = len(range1)
+            count_2 = len(range2)
+            try:
+                dimension_1 = float(self.text_dim_1.GetValue())
+            except ValueError:
+                dimension_1 = -1
+            try:
+                dimension_2 = float(self.text_dim_2.GetValue())
+            except ValueError:
+                dimension_2 = -1
+            if dimension_1 <= 0:
+                dimension_1 = 5
+            if dimension_2 <= 0:
+                dimension_2 = 5
+
+            try:
+                gap_1 = float(self.text_delta_1.GetValue())
+            except ValueError:
+                gap_1 = -1
+            try:
+                gap_2 = float(self.text_delta_2.GetValue())
+            except ValueError:
+                gap_2 = -1
+
+            if gap_1 < 0:
+                gap_1 = 0
+            if gap_2 < 0:
+                gap_2 = 5
+
+            # print (f"Creating operations for {len(range1)} x {len(range2)}")
             display_labels = self.check_labels.GetValue()
             display_values = self.check_values.GetValue()
             color_aspect_1 = max(0, self.combo_color_1.GetSelection())
@@ -959,8 +1191,6 @@ class TemplatePanel(wx.Panel):
             color_growing_1 = self.check_color_direction_1.GetValue()
             color_growing_2 = self.check_color_direction_2.GetValue()
 
-            if optype < 0 or optype > 4:
-                return
             if optype == 3:
                 shapetype = "image"
             else:
@@ -997,8 +1227,9 @@ class TemplatePanel(wx.Panel):
             if display_labels:
                 text_x = start_x + expected_width / 2
                 text_y = start_y - min(float(Length("10mm")), 3 * gap_y)
-                node = self.context.elements.elem_branch.add(
-                    text=f"{param_name_1} [{param_unit_1}]",
+                unit_str = f" [{param_unit_1}]" if param_unit_1 else ""
+                node = element_branch.add(
+                    text=f"{param_name_1}{unit_str}",
                     matrix=Matrix(
                         f"translate({text_x}, {text_y}) scale({2 * max(text_scale_x, text_scale_y) * UNITS_PER_PIXEL})"
                     ),
@@ -1010,8 +1241,9 @@ class TemplatePanel(wx.Panel):
 
                 text_x = start_x - min(float(Length("10mm")), 3 * gap_x)
                 text_y = start_y + expected_height / 2
-                node = self.context.elements.elem_branch.add(
-                    text=f"{param_name_2} [{param_unit_2}]",
+                unit_str = f" [{param_unit_2}]" if param_unit_2 else ""
+                node = element_branch.add(
+                    text=f"{param_name_2}{unit_str}",
                     matrix=Matrix(
                         f"translate({text_x}, {text_y}) scale({2 * max(text_scale_x, text_scale_y) * UNITS_PER_PIXEL})"
                     ),
@@ -1023,10 +1255,9 @@ class TemplatePanel(wx.Panel):
                 node.modified()
                 text_op_y.add_reference(node, 0)
 
-            _p_value_1 = min_value_1
-
             xx = start_x
-            for idx1 in range(count_1):
+            for idx1, _p_value_1 in enumerate(range1):
+                # print (f"Creating row {idx1} of {len(range1)} with value {_p_value_1}")
                 p_value_1 = _p_value_1
                 if param_value_type_1 is not None:
                     try:
@@ -1034,16 +1265,18 @@ class TemplatePanel(wx.Panel):
                         p_value_1 = _pp
                     except ValueError:
                         pass
-                pval1 = self.shortened(p_value_1, 3)
+                if isinstance(p_value_1, str):
+                    pval1 = p_value_1
+                else:
+                    pval1 = self.shortened(p_value_1, 3)
 
-                _p_value_2 = min_value_2
                 yy = start_y
 
                 if display_values:
                     # Add a text above for each column
                     text_x = xx + 0.5 * size_x
                     text_y = yy - min(float(Length("5mm")), 1.5 * gap_y)
-                    node = self.context.elements.elem_branch.add(
+                    node = element_branch.add(
                         text=f"{pval1}",
                         matrix=Matrix(
                             f"translate({text_x}, {text_y}) scale({text_scale_x * UNITS_PER_PIXEL})"
@@ -1056,7 +1289,8 @@ class TemplatePanel(wx.Panel):
                     node.modified()
                     text_op_x.add_reference(node, 0)
 
-                for idx2 in range(count_2):
+                for idx2, _p_value_2 in enumerate(range2):
+                    # print (f"Creating column {idx2} of {len(range2)} with value {_p_value_2}")
                     p_value_2 = _p_value_2
                     if param_value_type_2 is not None:
                         try:
@@ -1064,14 +1298,16 @@ class TemplatePanel(wx.Panel):
                             p_value_2 = _pp
                         except ValueError:
                             pass
-
-                    pval2 = self.shortened(p_value_2, 3)
+                    if isinstance(p_value_2, str):
+                        pval2 = p_value_2
+                    else:
+                        pval2 = self.shortened(p_value_2, 3)
                     s_lbl = f"{param_type_1}={pval1}{param_unit_1}"
                     s_lbl += f"- {param_type_2}={pval2}{param_unit_2}"
                     if display_values and idx1 == 0:  # first row, so add a text above
                         text_x = xx - min(float(Length("5mm")), 1.5 * gap_x)
                         text_y = yy + 0.5 * size_y
-                        node = self.context.elements.elem_branch.add(
+                        node = element_branch.add(
                             text=f"{pval2}",
                             matrix=Matrix(
                                 f"translate({text_x}, {text_y}) scale({text_scale_y * UNITS_PER_PIXEL})"
@@ -1100,18 +1336,25 @@ class TemplatePanel(wx.Panel):
                         usefill = False
                     elif optype == 4:  # Hatch
                         master_op = copy(self.default_op[optype])
-                        this_op = HatchEffectNode()
+                        this_op = copy(self.secondary_default_op[optype])
                         master_op.add_node(this_op)
 
                         # We need to add a hatch node and make this the target for parameter application
                         usefill = False
+                    elif optype == 5:  # Wobble
+                        # Wobble is a special case, we need to create a master op and a secondary op
+                        # We need to add a wobble node and make this the target for parameter application
+                        master_op = copy(self.default_op[optype])
+                        this_op = copy(self.secondary_default_op[optype])
+                        master_op.add_node(this_op)
+                        usefill = False
                     else:
                         return
                     this_op.label = s_lbl
 
                     # Do we need to prep the op?
                     if param_prepper_1 is not None:
-                        param_prepper_1(this_op)
+                        param_prepper_1(master_op)
 
                     if param_keep_unit_1:
                         value = str(p_value_1) + param_unit_1
@@ -1125,9 +1368,10 @@ class TemplatePanel(wx.Panel):
                         # quick and dirty
                         if param_type_1 == "passes":
                             value = int(value)
-                        if param_type_1 == "hatch_distance":
-                            if not str(value).endswith("mm"):
-                                value = f"{value}mm"
+                        if param_type_1 == "hatch_distance" and not str(value).endswith(
+                            "mm"
+                        ):
+                            value = f"{value}mm"
                         setattr(master_op, param_type_1, value)
                     # else:  # Try setting
                     #     master_op.settings[param_type_1] = value
@@ -1135,16 +1379,21 @@ class TemplatePanel(wx.Panel):
                         # quick and dirty
                         if param_type_1 == "passes":
                             value = int(value)
-                        if param_type_1 == "hatch_distance":
-                            if not str(value).endswith("mm"):
-                                value = f"{value}mm"
+                        elif param_type_1 == "hatch_distance" and not str(
+                            value
+                        ).endswith("mm"):
+                            value = f"{value}mm"
+                        elif param_type_1 == "hatch_angle" and not str(value).endswith(
+                            "deg"
+                        ):
+                            value = f"{value}deg"
                         setattr(this_op, param_type_1, value)
                     elif hasattr(this_op, "settings"):  # Try setting
                         this_op.settings[param_type_1] = value
 
                     # Do we need to prep the op?
                     if param_prepper_2 is not None:
-                        param_prepper_2(this_op)
+                        param_prepper_2(master_op)
 
                     if param_keep_unit_2:
                         value = str(p_value_2) + param_unit_2
@@ -1158,25 +1407,31 @@ class TemplatePanel(wx.Panel):
                         # quick and dirty
                         if param_type_2 == "passes":
                             value = int(value)
-                        if param_type_2 == "hatch_distance":
-                            if not str(value).endswith("mm"):
-                                value = f"{value}mm"
+                        if param_type_2 == "hatch_distance" and not str(value).endswith(
+                            "mm"
+                        ):
+                            value = f"{value}mm"
                         setattr(master_op, param_type_2, value)
                     if hasattr(this_op, param_type_2):
                         if param_type_2 == "passes":
                             value = int(value)
-                        if param_type_2 == "hatch_distance":
-                            if not str(value).endswith("mm"):
-                                value = f"{value}mm"
+                        elif param_type_2 == "hatch_distance" and not str(
+                            value
+                        ).endswith("mm"):
+                            value = f"{value}mm"
+                        elif param_type_2 == "hatch_angle" and not str(value).endswith(
+                            "deg"
+                        ):
+                            value = f"{value}deg"
                         setattr(this_op, param_type_2, value)
                     elif hasattr(this_op, "settings"):  # Try setting
                         this_op.settings[param_type_2] = value
 
                     set_color = make_color(
                         idx1,
-                        count_1,
+                        len(range1),
                         idx2,
-                        count_2,
+                        len(range2),
                         color_aspect_1,
                         color_growing_1,
                         color_aspect_2,
@@ -1186,19 +1441,17 @@ class TemplatePanel(wx.Panel):
                     # Add op to tree.
                     operation_branch.add_node(master_op)
                     # Now add a rectangle to the scene and assign it to the newly created op
-                    if usefill:
-                        fill_color = set_color
-                    else:
-                        fill_color = None
+                    fill_color = set_color if usefill else None
+                    elemnode = None
                     if shapetype == "image":
                         idx = self.combo_images.GetSelection() - 1
                         if 0 <= idx < len(self.images):
                             elemnode = copy(self.images[idx])
                             elemnode.matrix.post_translate(xx, yy)
                             elemnode.modified()
-                            self.context.elements.elem_branch.add_node(elemnode)
+                            element_branch.add_node(elemnode)
                     elif shapetype == "rect":
-                        elemnode = self.context.elements.elem_branch.add(
+                        elemnode = element_branch.add(
                             x=xx,
                             y=yy,
                             width=size_x,
@@ -1208,7 +1461,7 @@ class TemplatePanel(wx.Panel):
                             type="elem rect",
                         )
                     elif shapetype == "circle":
-                        elemnode = self.context.elements.elem_branch.add(
+                        elemnode = element_branch.add(
                             cx=xx + size_x / 2,
                             cy=yy + size_y / 2,
                             rx=size_x / 2,
@@ -1217,138 +1470,106 @@ class TemplatePanel(wx.Panel):
                             fill=fill_color,
                             type="elem ellipse",
                         )
-                    elemnode.label = s_lbl
-                    this_op.add_reference(elemnode, 0)
-                    _p_value_2 += delta_2
+                    if elemnode is not None:
+                        elemnode.label = s_lbl
+                        this_op.add_reference(elemnode, 0)
                     yy = yy + gap_y + size_y
-                _p_value_1 += delta_1
                 xx = xx + gap_x + size_x
 
         # Read the parameters and user input
         optype = self.combo_ops.GetSelection()
         if optype < 0:
             return
-        idx = self.combo_param_1.GetSelection()
-        if idx < 0:
+        idx1 = self.combo_param_1.GetSelection()
+        if idx1 < 0:
             return
         # 0 = internal_attribute, 1 = secondary_attribute,
         # 2 = Label, 3 = unit,
         # 4 = keep_unit, 5 = needs_to_be_positive)
-        param_name_1 = self.parameters[idx][2]
-        param_type_1 = self.parameters[idx][0]
-        param_value_type_1 = self.parameters[idx][6]
-        param_prepper_1 = self.parameters[idx][1]
+        param_name_1 = self.parameters[idx1][2]
+        param_type_1 = self.parameters[idx1][0]
+        param_value_type_1 = self.parameters[idx1][6]
+        param_prepper_1 = self.parameters[idx1][1]
         if param_prepper_1 == "":
             param_prepper_1 = None
-        param_unit_1 = self.parameters[idx][3]
-        param_keep_unit_1 = self.parameters[idx][4]
-        param_positive_1 = self.parameters[idx][5]
+        param_unit_1 = self.parameters[idx1][3]
+        param_keep_unit_1 = self.parameters[idx1][4]
 
-        idx = self.combo_param_2.GetSelection()
-        if idx < 0:
+        idx2 = self.combo_param_2.GetSelection()
+        if idx2 < 0:
             return
-        param_name_2 = self.parameters[idx][2]
-        param_type_2 = self.parameters[idx][0]
-        param_value_type_2 = self.parameters[idx][6]
-        param_prepper_2 = self.parameters[idx][1]
+        param_name_2 = self.parameters[idx2][2]
+        param_type_2 = self.parameters[idx2][0]
+        param_value_type_2 = self.parameters[idx2][6]
+        param_prepper_2 = self.parameters[idx2][1]
         if param_prepper_2 == "":
             param_prepper_2 = None
-        param_unit_2 = self.parameters[idx][3]
-        param_keep_unit_2 = self.parameters[idx][4]
-        param_positive_2 = self.parameters[idx][5]
+        param_unit_2 = self.parameters[idx2][3]
+        param_keep_unit_2 = self.parameters[idx2][4]
         if param_type_1 == param_type_2:
             return
-        if self.text_min_1.GetValue() == "":
-            return
-        try:
-            min_value_1 = float(self.text_min_1.GetValue())
-        except ValueError:
-            return
-        if self.text_min_2.GetValue() == "":
-            return
-        try:
-            min_value_2 = float(self.text_min_2.GetValue())
-        except ValueError:
-            return
-        if self.text_max_1.GetValue() == "":
-            return
-        try:
-            max_value_1 = float(self.text_max_1.GetValue())
-        except ValueError:
-            return
-        if self.text_max_2.GetValue() == "":
-            return
-        try:
-            max_value_2 = float(self.text_max_2.GetValue())
-        except ValueError:
-            return
 
-        if param_unit_1 == "deg":
-            min_value_1 = Angle(self.text_min_1.GetValue()).degrees
-            max_value_1 = Angle(self.text_max_1.GetValue()).degrees
-        elif param_unit_1 == "ppi":
-            min_value_1 = max(min_value_1, 0)
-            max_value_1 = min(max_value_1, 1000)
-        elif param_unit_1 == "%":
-            min_value_1 = max(min_value_1, 0)
-            max_value_1 = min(max_value_1, 100)
-        else:
-            # > 0
-            if param_positive_1:
-                min_value_1 = max(min_value_1, 0)
-                max_value_1 = max(max_value_1, 0)
-
-        if param_unit_2 == "deg":
-            min_value_2 = Angle(self.text_min_2.GetValue()).degrees
-            max_value_2 = Angle(self.text_max_2.GetValue()).degrees
-        elif param_unit_2 == "ppi":
-            min_value_2 = max(min_value_2, 0)
-            max_value_2 = min(max_value_2, 1000)
-        elif param_unit_2 == "%":
-            min_value_2 = max(min_value_2, 0)
-            max_value_2 = min(max_value_2, 100)
-        else:
-            # > 0
-            if param_positive_2:
-                min_value_2 = max(min_value_2, 0)
-                max_value_2 = max(max_value_2, 0)
-
-        count_1 = int(self.spin_count_1.GetValue())
-        count_2 = int(self.spin_count_2.GetValue())
-        if count_1 > 1:
-            delta_1 = (max_value_1 - min_value_1) / (count_1 - 1)
-        else:
-            delta_1 = 0
-        if count_2 > 1:
-            delta_2 = (max_value_2 - min_value_2) / (count_2 - 1)
-        else:
-            delta_2 = 0
-        try:
-            dimension_1 = float(self.text_dim_1.GetValue())
-        except ValueError:
-            dimension_1 = -1
-        try:
-            dimension_2 = float(self.text_dim_2.GetValue())
-        except ValueError:
-            dimension_2 = -1
-        if dimension_1 <= 0:
-            dimension_1 = 5
-        if dimension_2 <= 0:
-            dimension_2 = 5
+        def get_range(isx: bool, idx: int) -> list:
+            value_range = []
+            if idx < 0 or idx >= len(self.parameters):
+                return value_range
+            if self.parameters[idx][7] is not None:
+                # Non-standard parameter, so we need to get the checked strings
+                value_range = (
+                    self.list_options_1.GetCheckedStrings()
+                    if isx
+                    else self.list_options_2.GetCheckedStrings()
+                )
+                if not value_range:
+                    return []
+            else:
+                param_unit = self.parameters[idx][3]
+                param_positive = self.parameters[idx][5]
+                if isx:
+                    text_min = self.text_min_1.GetValue()
+                    text_max = self.text_max_1.GetValue()
+                    text_count = self.spin_count_1.GetValue()
+                else:
+                    text_min = self.text_min_2.GetValue()
+                    text_max = self.text_max_2.GetValue()
+                    text_count = self.spin_count_2.GetValue()
+                if text_min == "" or text_max == "" or text_count <= 0:
+                    return value_range
+                try:
+                    min_value = float(text_min)
+                    max_value = float(text_max)
+                    count = int(text_count)
+                except ValueError:
+                    return value_range
+                if param_unit == "deg":
+                    min_value = float(text_min)
+                    max_value = float(text_max)
+                elif param_unit == "ppi":
+                    min_value = max(min_value, 0)
+                    max_value = min(max_value, 1000)
+                elif param_unit == "%":
+                    min_value = max(min_value, 0)
+                    max_value = min(max_value, 100)
+                else:
+                    # > 0
+                    if param_positive:
+                        min_value = max(min_value, 0)
+                        max_value = max(max_value, 0)
+                delta = (max_value - min_value) / (count - 1) if count > 1 else 0
+                if delta == 0:
+                    value_range = [min_value]
+                else:
+                    value_range = [min_value + i * delta for i in range(count)]
 
-        try:
-            gap_1 = float(self.text_delta_1.GetValue())
-        except ValueError:
-            gap_1 = -1
-        try:
-            gap_2 = float(self.text_delta_2.GetValue())
-        except ValueError:
-            gap_2 = -1
+            return value_range
+
+        valid_range_1 = get_range(True, idx1)
+        valid_range_2 = get_range(False, idx2)
+        # print (valid_range_1)
+        # print (valid_range_2)
 
-        if gap_1 < 0:
-            gap_1 = 0
-        if gap_2 < 0:
-            gap_2 = 5
+        if len(valid_range_1) == 0 or len(valid_range_2) == 0:
+            return
 
         message = _("This will delete all existing operations and elements") + "\n"
         message += (
@@ -1369,7 +1590,7 @@ class TemplatePanel(wx.Panel):
         elif result == wx.ID_CANCEL:
             return
 
-        create_operations()
+        create_operations(range1=valid_range_1, range2=valid_range_2)
 
         self.context.signal("rebuild_tree")
         self.context.signal("refresh_scene", "Scene")
@@ -1395,6 +1616,8 @@ class TemplatePanel(wx.Panel):
         self.context.setting(int, "template_color2", 2)
         self.context.setting(bool, "template_coldir1", False)
         self.context.setting(bool, "template_coldir2", False)
+        self.context.setting(str, "template_list1", "")
+        self.context.setting(str, "template_list2", "")
 
     def _set_settings(self, templatename):
         info_field = (
@@ -1417,6 +1640,8 @@ class TemplatePanel(wx.Panel):
             self.context.template_color2,
             self.context.template_coldir1,
             self.context.template_coldir2,
+            self.context.template_list1,
+            self.context.template_list2,
         )
         # print (f"Save data to {templatename}, infofield-len={len(info_field)}")
         key = f"{templatename}"
@@ -1429,20 +1654,27 @@ class TemplatePanel(wx.Panel):
         if (
             info_field is not None
             and isinstance(info_field, (tuple, list))
-            and len(info_field) == 19
+            and len(info_field) >= 19
         ):
+
+            def get_setting(idx, default):
+                try:
+                    return info_field[idx]
+                except IndexError:
+                    return default
+
             # print (f"Load data from {templatename}")
-            self.context.template_show_values = info_field[0]
-            self.context.template_show_labels = info_field[1]
+            self.context.template_show_values = get_setting(0, True)
+            self.context.template_show_labels = get_setting(1, True)
             self.context.template_optype = info_field[2]
             self.context.template_param1 = info_field[3]
             self.context.template_param2 = info_field[4]
-            self.context.template_min1 = info_field[5]
-            self.context.template_max1 = info_field[6]
-            self.context.template_min2 = info_field[7]
-            self.context.template_max2 = info_field[8]
-            self.context.template_count1 = info_field[9]
-            self.context.template_count2 = info_field[10]
+            self.context.template_min1 = get_setting(5, 0)
+            self.context.template_max1 = get_setting(6, 100)
+            self.context.template_min2 = get_setting(7, 0)
+            self.context.template_max2 = get_setting(8, 100)
+            self.context.template_count1 = get_setting(9, 5)
+            self.context.template_count2 = get_setting(10, 5)
             self.context.template_dim_1 = info_field[11]
             self.context.template_dim_2 = info_field[12]
             self.context.template_gap_1 = info_field[13]
@@ -1451,6 +1683,8 @@ class TemplatePanel(wx.Panel):
             self.context.template_color2 = info_field[16]
             self.context.template_coldir1 = info_field[17]
             self.context.template_coldir2 = info_field[18]
+            self.context.template_list1 = get_setting(19, "")
+            self.context.template_list2 = get_setting(20, "")
 
     def save_settings(self, templatename=None):
         self.context.template_show_values = self.check_values.GetValue()
@@ -1472,6 +1706,8 @@ class TemplatePanel(wx.Panel):
         self.context.template_color2 = self.combo_color_2.GetSelection()
         self.context.template_coldir1 = self.check_color_direction_1.GetValue()
         self.context.template_coldir2 = self.check_color_direction_2.GetValue()
+        self.context.template_list1 = "|".join(self.list_options_1.GetCheckedStrings())
+        self.context.template_list2 = "|".join(self.list_options_2.GetCheckedStrings())
         if templatename:
             # let's try to restore the settings
             self._set_settings(templatename)
@@ -1510,6 +1746,12 @@ class TemplatePanel(wx.Panel):
             self.text_dim_2.SetValue(self.context.template_dim_2)
             self.text_delta_1.SetValue(self.context.template_gap_1)
             self.text_delta_2.SetValue(self.context.template_gap_2)
+            self.list_options_1.SetCheckedStrings(
+                self.context.template_list1.split("|")
+            )
+            self.list_options_2.SetCheckedStrings(
+                self.context.template_list2.split("|")
+            )
         except (AttributeError, ValueError):
             pass
 
@@ -1543,7 +1785,8 @@ class TemplateTool(MWindow):
 
         self.storage = Settings(self.context.kernel.name, "templates.cfg")
         self.storage.read_configuration()
-        self.panel_instances = list()
+        self.panel_instances = []
+        self.primary_prop_panels = []
         self.panel_template = TemplatePanel(
             self,
             wx.ID_ANY,
@@ -1614,7 +1857,7 @@ class TemplateTool(MWindow):
 
         return None
 
-    def set_node(self, node):
+    def set_node(self, primary_node, secondary_node=None):
         def sort_priority(prop):
             prop_sheet, node = prop
             return (
@@ -1623,25 +1866,26 @@ class TemplateTool(MWindow):
                 else 0
             )
 
-        if node is None:
+        if primary_node is None:
             return
         busy = wx.BusyCursor()
         self.Freeze()
-        pages_to_instance = []
-        pages_in_node = []
-        found = False
+        primary_panels = []
+        secondary_panels = []
         for property_sheet in self.context.lookup_all(
-            f"property/{node.__class__.__name__}/.*"
+            f"property/{primary_node.__class__.__name__}/.*"
         ):
-            if not hasattr(property_sheet, "accepts") or property_sheet.accepts(node):
-                pages_in_node.append((property_sheet, node))
-                found = True
+            if not hasattr(property_sheet, "accepts") or property_sheet.accepts(
+                primary_node
+            ):
+                primary_panels.append((property_sheet, primary_node))
+        found = len(primary_panels) > 0
         # If we did not have any hits and the node is a reference
         # then we fall back to the master. So if in the future we
         # would have a property panel dealing with reference-nodes
         # then this would no longer apply.
-        if node.type == "reference" and not found:
-            snode = node.node
+        if primary_node.type == "reference" and not found:
+            snode = primary_node.node
             found = False
             for property_sheet in self.context.lookup_all(
                 f"property/{snode.__class__.__name__}/.*"
@@ -1649,11 +1893,19 @@ class TemplateTool(MWindow):
                 if not hasattr(property_sheet, "accepts") or property_sheet.accepts(
                     snode
                 ):
-                    pages_in_node.append((property_sheet, snode))
-                    found = True
+                    primary_panels.append((property_sheet, snode))
+        if secondary_node is not None:
+            for property_sheet in self.context.lookup_all(
+                f"property/{secondary_node.__class__.__name__}/.*"
+            ):
+                if not hasattr(property_sheet, "accepts") or property_sheet.accepts(
+                    secondary_node
+                ):
+                    secondary_panels.append((property_sheet, secondary_node))
 
-        pages_in_node.sort(key=sort_priority, reverse=True)
-        pages_to_instance.extend(pages_in_node)
+        primary_panels.sort(key=sort_priority, reverse=True)
+        secondary_panels.sort(key=sort_priority, reverse=True)
+        pages_to_instance = primary_panels + secondary_panels
 
         for p in self.panel_instances:
             try:
@@ -1661,10 +1913,15 @@ class TemplateTool(MWindow):
             except AttributeError:
                 pass
             self.remove_module_delegate(p)
+        self.panel_instances.clear()
 
         # Delete all but the first and last page...
         while self.notebook_main.GetPageCount() > 2:
             self.notebook_main.DeletePage(1)
+        # print(
+        #     f"Adding {len(pages_to_instance)} pages to the notebook, remaining {self.notebook_main.GetPageCount()} pages: content={self.notebook_main.GetPageText(0)} and {self.notebook_main.GetPageText(1)}"
+        # )
+        # Add the primary property panels
         for prop_sheet, instance in pages_to_instance:
             page_panel = prop_sheet(
                 self.notebook_main, wx.ID_ANY, context=self.context, node=instance
@@ -1693,6 +1950,8 @@ class TemplateTool(MWindow):
 
         self.Layout()
         self.Thaw()
+        self.notebook_main.SetSelection(1)
+        self.notebook_main.SetSelection(0)
         del busy
 
     def window_open(self):