meerk40t 0.9.7051__py2.py3-none-any.whl → 0.9.7900__py2.py3-none-any.whl

meerk40t/gui/laserpanel.py

@@ -29,7 +29,6 @@ from meerk40t.gui.wxutils import (
     wxButton,
     wxCheckBox,
     wxComboBox,
-    wxStaticBitmap,
     wxStaticText,
 )
 from meerk40t.kernel import lookup_listener, signal_listener
@@ -262,7 +261,7 @@ class LaserPanel(wx.Panel):
         self.check_laser_arm()
 
         self.button_outline = wxButton(self, wx.ID_ANY, _("Outline"))
-        self.button_outline.SetToolTip(_("Trace the outline the job"))
+        self.button_outline.SetToolTip(_("Trace the outline of the job"))
         self.button_outline.SetBitmap(
             icons8_pentagon.GetBitmap(
                 resize=self.icon_size,
@@ -332,6 +331,7 @@ class LaserPanel(wx.Panel):
         lb_speed = wxStaticText(self, wx.ID_ANY, _("Speed"))
         self.label_speed = wxStaticText(self, wx.ID_ANY, "0%")
         self.slider_size = 20
+        self.power_mode = "relative"
         self.slider_speed = wx.Slider(
             self, wx.ID_ANY, value=10, minValue=1, maxValue=20
         )
@@ -380,33 +380,67 @@ class LaserPanel(wx.Panel):
         self.button_start_was_clicked = False
 
     def update_override_controls(self):
+        def set_boundaries(slider, current_value, min_value, max_value):
+            slider.SetMin(min_value)
+            slider.SetMax(max_value)
+            slider.SetValue(current_value)
+
         flag_power = False
         override = False
-        if hasattr(self.context.device.driver, "has_adjustable_power"):
-            if self.context.device.driver.has_adjustable_power:
-                flag_power = True
-                # Let's establish the value and update the slider...
-                value = self.context.device.driver.power_scale
-                if value != 1:
-                    override = True
-                half = self.slider_size / 2
-                sliderval = int(value * half)
-                sliderval = max(1, min(self.slider_size, sliderval))
-                self.slider_power.SetValue(sliderval)
-                self.on_slider_speed(None)
+        if (
+            hasattr(self.context.device.driver, "has_adjustable_power")
+            and self.context.device.driver.has_adjustable_power
+        ):
+            flag_power = True
+            # Let's establish the value and update the slider...
+            value = self.context.device.driver.power_scale
+            if value != 1:
+                override = True
+            half = self.slider_size / 2
+            sliderval = int(value * half)
+            sliderval = max(1, min(self.slider_size, sliderval))
+            set_boundaries(self.slider_power, sliderval, 1, self.slider_size)
+            self.slider_power.SetToolTip(
+                _("Increases/decreases the regular laser power by this amount.")
+                + "\n"
+                + _("This affects running jobs, so use with care!")
+            )
+            self.power_mode = "relative"
+            self.on_slider_power(None)
+        elif (
+            hasattr(self.context.device.driver, "has_adjustable_maximum_power")
+            and self.context.device.driver.has_adjustable_maximum_power
+        ):
+            flag_power = True
+            override = True
+            dev_mode = getattr(self.context.kernel.root, "developer_mode", False)
+            # Let's establish the value and update the slider...
+            min_value = 1
+            max_value = 100 if dev_mode else 50
+            sliderval = min(max_value, self.context.device.driver.max_power_scale)
+            set_boundaries(self.slider_power, sliderval, min_value, max_value)
+            self.slider_power.SetToolTip(
+                _("Sets the maximum laser power level.")
+                + "\n"
+                + _("Setting this too high may cause damage to your laser tube!")
+            )
+            self.power_mode = "maximum"
+            self.on_slider_power(None)
         flag_speed = False
-        if hasattr(self.context.device.driver, "has_adjustable_speed"):
-            if self.context.device.driver.has_adjustable_speed:
-                flag_speed = True
-                # Let's establish the value and update the slider...
-                value = self.context.device.driver.speed_scale
-                if value != 1:
-                    override = True
-                half = self.slider_size / 2
-                sliderval = int(value * half)
-                sliderval = max(1, min(self.slider_size, sliderval))
-                self.slider_speed.SetValue(sliderval)
-                self.on_slider_speed(None)
+        if (
+            hasattr(self.context.device.driver, "has_adjustable_speed")
+            and self.context.device.driver.has_adjustable_speed
+        ):
+            flag_speed = True
+            # Let's establish the value and update the slider...
+            value = self.context.device.driver.speed_scale
+            if value != 1:
+                override = True
+            half = self.slider_size / 2
+            sliderval = int(value * half)
+            sliderval = max(1, min(self.slider_size, sliderval))
+            set_boundaries(self.slider_speed, sliderval, 1, self.slider_size)
+            self.on_slider_speed(None)
 
         self.sizer_power.Show(flag_power)
         self.sizer_power.ShowItems(flag_power)
@@ -427,18 +461,22 @@ class LaserPanel(wx.Panel):
         else:
             self.slider_power.Enable(False)
             self.slider_speed.Enable(False)
-            if hasattr(self.context.device.driver, "has_adjustable_power"):
-                if self.context.device.driver.has_adjustable_power:
-                    if event is not None:
-                        self.context.device.driver.set_power_scale(1.0)
-                    self.slider_power.SetValue(10)
-                    self.on_slider_power(None)
-            if hasattr(self.context.device.driver, "has_adjustable_speed"):
-                if self.context.device.driver.has_adjustable_speed:
-                    if event is not None:
-                        self.context.device.driver.set_speed_scale(1.0)
-                    self.slider_speed.SetValue(10)
-                    self.on_slider_speed(None)
+            if (
+                hasattr(self.context.device.driver, "has_adjustable_power")
+                and self.context.device.driver.has_adjustable_power
+            ):
+                if event is not None:
+                    self.context.device.driver.set_power_scale(1.0)
+                self.slider_power.SetValue(10)
+                self.on_slider_power(None)
+            if (
+                hasattr(self.context.device.driver, "has_adjustable_speed")
+                and self.context.device.driver.has_adjustable_speed
+            ):
+                if event is not None:
+                    self.context.device.driver.set_speed_scale(1.0)
+                self.slider_speed.SetValue(10)
+                self.on_slider_speed(None)
 
     def on_slider_speed(self, event):
         sliderval = self.slider_speed.GetValue()
@@ -452,12 +490,18 @@ class LaserPanel(wx.Panel):
 
     def on_slider_power(self, event):
         sliderval = self.slider_power.GetValue()
-        half = self.slider_size / 2
-        newvalue = sliderval - half  # -> -9 to +10
-        factor = 1 + newvalue / half
-        if event is not None:
-            self.context.device.driver.set_power_scale(factor)
-        msg = f"{'+' if factor > 1 else ''}{100 * (factor - 1.0):.0f}%"
+        if self.power_mode == "maximum":
+            # Maximum power mode, so we just set the value.
+            if event is not None:
+                self.context.device.driver.max_power_scale = sliderval
+            msg = f"{sliderval}%"
+        else:
+            half = self.slider_size / 2
+            newvalue = sliderval - half  # -> -9 to +10
+            factor = 1 + newvalue / half
+            if event is not None:
+                self.context.device.driver.set_power_scale(factor)
+            msg = f"{'+' if factor > 1 else ''}{100 * (factor - 1.0):.0f}%"
         self.label_power.SetLabel(msg)
 
     def on_optimize(self, event):
@@ -478,6 +522,14 @@ class LaserPanel(wx.Panel):
         if self.checkbox_optimize.GetValue() != newvalue:
             self.checkbox_optimize.SetValue(newvalue)
 
+    @signal_listener("pwm_mode_changed")
+    def on_pwm_mode_changed(self, origin, *message):
+        """
+        This is called when the power scale of the device changes.
+        It updates the slider and label accordingly.
+        """
+        self.update_override_controls()
+
     @signal_listener("device;modified")
     @signal_listener("device;renamed")
     @lookup_listener("service/device/active")
@@ -655,13 +707,12 @@ class LaserPanel(wx.Panel):
         self.context.setting(bool, "laserpane_hold", False)
         if plan.plan and self.context.laserpane_hold:
             self.context("planz spool\n")
+        elif self.checkbox_optimize.GetValue():
+            self.context(
+                "planz clear copy preprocess validate blob preopt optimize spool\n"
+            )
         else:
-            if self.checkbox_optimize.GetValue():
-                self.context(
-                    "planz clear copy preprocess validate blob preopt optimize spool\n"
-                )
-            else:
-                self.context("planz clear copy preprocess validate blob spool\n")
+            self.context("planz clear copy preprocess validate blob spool\n")
         self.armed = False
         self.check_laser_arm()
         if self.context.auto_spooler:
@@ -807,10 +858,7 @@ class JobPanel(wx.Panel):
 
             if not pathname.lower().endswith(f".{extension}"):
                 pathname += f".{extension}"
-            if self.context.planner.do_optimization:
-                optpart = "preopt optimize "
-            else:
-                optpart = ""
+            optpart = "preopt optimize " if self.context.planner.do_optimization else ""
             self.context(
                 f'planz clear copy preprocess validate blob {optpart}save_job "{pathname}"\n'
             )

meerk40t/gui/materialtest.py

@@ -947,6 +947,11 @@ class TemplatePanel(wx.Panel):
                 standard_items = False
                 choices = self.parameters[idx][7]
                 self.list_options_1.Set(choices)
+                self.list_options_1.SetToolTip(
+                    _("Select the values you want to test for {param}").format(
+                        param=self.parameters[idx][2]
+                    )
+                )
                 checked_strings = [
                     s for s in self.context.template_list1.split("|") if s
                 ]
@@ -981,6 +986,11 @@ class TemplatePanel(wx.Panel):
                 standard_items = False
                 choices = self.parameters[idx][7]
                 self.list_options_2.Set(choices)
+                self.list_options_2.SetToolTip(
+                    _("Select the values you want to test for {param}").format(
+                        param=self.parameters[idx][2]
+                    )
+                )
                 checked_strings = [
                     s for s in self.context.template_list2.split("|") if s
                 ]

meerk40t/gui/mkdebug.py

@@ -1,7 +1,7 @@
 """
-    This module contains panels that display internal developer information.
-    They will become visible if you type 'set debug_mode True' in the
-    console and restart the program.
+This module contains panels that display internal developer information.
+They will become visible if you type 'set debug_mode True' in the
+console and restart the program.
 """
 
 import time
@@ -10,6 +10,17 @@ import wx
 from wx import aui
 
 import meerk40t.gui.icons as mkicons
+from meerk40t.constants import (
+    RASTER_B2T,
+    RASTER_CROSSOVER,
+    RASTER_GREEDY_H,
+    RASTER_GREEDY_V,
+    RASTER_HATCH,
+    RASTER_L2R,
+    RASTER_R2L,
+    RASTER_SPIRAL,
+    RASTER_T2B,
+)
 from meerk40t.core.units import Angle, Length
 from meerk40t.gui.wxutils import (
     ScrolledPanel,
@@ -123,6 +134,25 @@ def register_panel_window(window, context):
     context.register("pane/debug_window", pane)
 
 
+def register_panel_plotter(window, context):
+    pane = (
+        aui.AuiPaneInfo()
+        .Float()
+        .MinSize(225, 110)
+        .FloatingSize(400, 400)
+        .Caption(_("Plotter Test"))
+        .CaptionVisible(not context.pane_lock)
+        .Name("debug_plotter")
+        .Hide()
+    )
+    pane.dock_proportion = 225
+    pane.control = DebugRasterPlotterPanel(window, wx.ID_ANY, context=context)
+    pane.submenu = "_ZZ_" + _("Debug")
+    pane.helptext = _("Raster plotter test")
+    window.on_pane_create(pane)
+    context.register("pane/debug_plotter", pane)
+
+
 class ShutdownPanel(wx.Panel):
     """
     Tries to create a scenario that has led to multiple runtime errors durign shutdown
@@ -339,7 +369,7 @@ class DebugColorPanel(ScrolledPanel):
                     sizer_main.Add(sizer_line, 0, wx.EXPAND, 0)
                     count = 0
 
-                col:wx.Colour = wx.SystemSettings().GetColour(getattr(wx, prop))
+                col: wx.Colour = wx.SystemSettings().GetColour(getattr(wx, prop))
                 infosizer = wx.BoxSizer(wx.VERTICAL)
                 box = wxStaticBitmap(
                     self, wx.ID_ANY, size=wx.Size(32, 32), style=wx.SB_RAISED
@@ -518,8 +548,13 @@ class DebugIconPanel(wx.Panel):
             if obj is not None:
                 if isinstance(obj, (mkicons.VectorIcon, mkicons.PyEmbeddedImage)):
                     imgs = self.icon_show.Size
-                    ms = min(imgs[0], imgs[1]) * self.context.root.bitmap_correction_scale
-                    bmp = obj.GetBitmap(resize=ms, force_darkmode=self.context.themes.dark)
+                    ms = (
+                        min(imgs[0], imgs[1])
+                        * self.context.root.bitmap_correction_scale
+                    )
+                    bmp = obj.GetBitmap(
+                        resize=ms, force_darkmode=self.context.themes.dark
+                    )
                     self.icon_show.SetBitmap(bmp)
 
     def pane_show(self, *args):
@@ -578,11 +613,19 @@ class DebugWindowPanel(wx.Panel):
         toggle_left = wx.ToggleButton(self, wx.ID_ANY, "Toggle")
         radio_left = wx.RadioBox(self, wx.ID_ANY, choices=("Yes", "No", "Maybe"))
         btn_bmap_left = wx.BitmapButton(
-            self, wx.ID_ANY, mkicons.icon_bell.GetBitmap(resize=mkicons.get_default_icon_size(self.context)/2)
+            self,
+            wx.ID_ANY,
+            mkicons.icon_bell.GetBitmap(
+                resize=mkicons.get_default_icon_size(self.context) / 2
+            ),
         )
         slider_left = wx.Slider(self, wx.ID_ANY, value=0, minValue=0, maxValue=100)
         static_left = wx.StaticBitmap(
-            self, wx.ID_ANY, mkicons.icon_closed_door.GetBitmap(resize=mkicons.get_default_icon_size(self.context))
+            self,
+            wx.ID_ANY,
+            mkicons.icon_closed_door.GetBitmap(
+                resize=mkicons.get_default_icon_size(self.context)
+            ),
         )
         left_side.Add(cb_left, 0, 0, 0)
         left_side.Add(text_left, 0, 0, 0)
@@ -605,7 +648,11 @@ class DebugWindowPanel(wx.Panel):
         toggle_right = wxToggleButton(self, wx.ID_ANY, "Toggle")
         radio_right = wxRadioBox(self, wx.ID_ANY, choices=("Yes", "No", "Maybe"))
         static_right = wxStaticBitmap(
-            self, wx.ID_ANY, mkicons.icon_closed_door.GetBitmap(resize=mkicons.get_default_icon_size(self.context))
+            self,
+            wx.ID_ANY,
+            mkicons.icon_closed_door.GetBitmap(
+                resize=mkicons.get_default_icon_size(self.context)
+            ),
         )
         # right_side.Add(cb_right, 0, 0, 0)
         right_side.Add(text_right, 0, 0, 0)
@@ -644,3 +691,215 @@ class DebugWindowPanel(wx.Panel):
 
     def pane_hide(self, *args):
         return
+
+
+class DebugRasterPlotterPanel(wx.Panel):
+    def __init__(self, *args, context=None, **kwds):
+        # begin wxGlade: PositionPanel.__init__
+        kwds["style"] = kwds.get("style", 0) | wx.TAB_TRAVERSAL
+        wx.Panel.__init__(self, *args, **kwds)
+
+        self.context = context
+        self.context.themes.set_window_colors(self)
+
+        sizer_main = wx.BoxSizer(wx.VERTICAL)
+        info = StaticBoxSizer(
+            self, wx.ID_ANY, _("Raster Plotter Test Info"), wx.HORIZONTAL
+        )
+        info.Add(
+            wxStaticText(self, wx.ID_ANY, "Dimensions:"), 0, wx.ALIGN_CENTER_VERTICAL, 0
+        )
+        self.text_x = TextCtrl(self, wx.ID_ANY, "1", check="int")
+        self.text_y = TextCtrl(self, wx.ID_ANY, "1", check="int")
+        info.Add(self.text_x, 1, wx.EXPAND, 0)
+        info.Add(wxStaticText(self, wx.ID_ANY, "x"), 0, wx.ALIGN_CENTER_VERTICAL, 0)
+        info.Add(self.text_y, 1, wx.EXPAND, 0)
+        info.Add(wxStaticText(self, wx.ID_ANY, "pixel"), 0, wx.ALIGN_CENTER_VERTICAL, 0)
+        # raster properties
+        raster_sizer = StaticBoxSizer(
+            self, wx.ID_ANY, _("Raster Properties"), wx.VERTICAL
+        )
+        raster_type_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        raster_sizer.Add(raster_type_sizer, 0, wx.EXPAND, 0)    
+        self.raster_terms = [
+            (RASTER_T2B, "Top To Bottom"),
+            (RASTER_B2T, "Bottom To Top"),
+            (RASTER_R2L, "Right To Left"),
+            (RASTER_L2R, "Left To Right"),
+            (RASTER_HATCH, "Crosshatch"),
+            (RASTER_GREEDY_H, "Greedy horizontal"),
+            (RASTER_GREEDY_V, "Greedy vertical"),
+            (RASTER_CROSSOVER, "Crossover"),
+            (RASTER_SPIRAL, "Spiral"),
+        ]
+        # Look for registered raster (image) preprocessors,
+        # these are routines that take one image as parameter
+        # and deliver a set of (result image, method (aka raster_direction) )
+        # that will be dealt with independently
+        # The registered datastructure is (rasterid, description, method)
+        self.raster_terms.extend(
+            (key, description)
+            for key, description, method in self.context.kernel.lookup_all(
+                "raster_preprocessor/.*"
+            )
+        )
+        # Add a couple of testcases
+        # test_methods = (
+        #     (-1, "Test: Horizontal Rectangle"),
+        #     (-2, "Test: Vertical Rectangle"),
+        #     (-3, "Test: Horizontal Snake"),
+        #     (-4, "Test: Vertical Snake"),
+        #     (-5,  "Test: Spiral"),
+        # )
+        # self.raster_terms.extend(test_methods)
+
+        self.raster_methods = [key for key, info in self.raster_terms]
+
+        self.combo_raster_direction = wxComboBox(
+            self,
+            wx.ID_ANY,
+            style=wx.CB_DROPDOWN | wx.CB_READONLY,
+        )
+        raster_type_sizer.Add(
+            wxStaticText(self, wx.ID_ANY, "Raster Direction:"),
+            0,
+            wx.ALIGN_CENTER_VERTICAL,
+            0,
+        )
+        self.combo_raster_direction.AppendItems(
+            [info for key, info in self.raster_terms]
+        )
+        raster_type_sizer.Add(
+            self.combo_raster_direction, 1, wx.ALIGN_CENTER_VERTICAL, 0
+        )
+        self.check_raster_bidirectional = wxCheckBox(self, wx.ID_ANY, "Bidirectional")
+
+        raster_type_sizer.Add(
+            self.check_raster_bidirectional, 0, wx.ALIGN_CENTER_VERTICAL, 0
+        )
+        self.combo_raster_direction.SetSelection(0)
+
+        buttons = wx.BoxSizer(wx.HORIZONTAL)
+        self.btn_test_onepixel_black = wxButton(self, wx.ID_ANY, "Fully Black")
+        self.btn_test_onepixel_white = wxButton(self, wx.ID_ANY, "Fully White")
+        buttons.Add(self.btn_test_onepixel_black, 1, wx.EXPAND, 0)
+        buttons.Add(self.btn_test_onepixel_white, 1, wx.EXPAND, 0)
+        self.text_result = TextCtrl(
+            self, wx.ID_ANY, style=wx.TE_MULTILINE | wx.TE_READONLY
+        )
+
+        sizer_main.Add(info, 0, wx.EXPAND, 0)
+        sizer_main.Add(raster_sizer, 0, wx.EXPAND, 0)
+        sizer_main.Add(buttons, 0, wx.EXPAND, 0)
+        sizer_main.Add(self.text_result, 1, wx.EXPAND, 0)
+
+        self.SetSizer(sizer_main)
+        sizer_main.Fit(self)
+        self.Layout()
+
+        self.btn_test_onepixel_black.Bind(wx.EVT_BUTTON, self.test_empty_image)
+        self.btn_test_onepixel_white.Bind(wx.EVT_BUTTON, self.test_fully_covered_image)
+
+    def test_empty_image(self, event):
+        """
+        Tests the speed of rasterplotter for a fully black image.
+        """
+        import numpy as np
+        from PIL import Image, ImageDraw
+
+        from meerk40t.tools.rasterplotter import RasterPlotter
+
+        try:
+            x = int(self.text_x.GetValue())
+            y = int(self.text_y.GetValue())
+        except ValueError:
+            self.text_result.SetValue("Invalid dimensions. Please enter integers.")
+            return
+        raster_string = self.combo_raster_direction.GetStringSelection()
+        raster_direction = -1
+        for key, info in self.raster_terms:
+            if raster_string == info:
+                raster_direction = key
+                break   
+        if raster_direction < 0:
+            self.text_result.SetValue("Invalid raster direction selected.")
+            return
+        bidir = self.check_raster_bidirectional.GetValue()
+
+        # Notabene: a black pixel is a non-burnt one, so we invert the logic here
+        image = Image.new("RGBA", (x, y), "white")
+        image = image.convert("L")
+        plotter = RasterPlotter(image.load(), x, y, direction=raster_direction, bidirectional=bidir)  
+        t = time.time()
+        i = 0
+        res = []
+        pixels = 0
+        last_x, last_y = plotter.initial_position_in_scene()
+        for x, y, on in plotter.plot():
+            i += 1
+            if on:
+                pixels += (abs(x - last_x) + 1) * (abs(y - last_y) + 1)
+            res.append(f"{i}: ({x}, {y}) {'on' if on else 'off'}")
+            last_x, last_y = x, y
+        ipos = plotter.initial_position_in_scene()
+        lpos = plotter.final_position_in_scene()
+        res.insert(
+            0,
+            f"Black found: {pixels} pixels: ranging from ({ipos[0]}, {ipos[1]}) to ({lpos[0]}, {lpos[1]})",
+        )
+        res.append(f"Time taken to finish process {time.time() - t:.3f}s\n")
+        self.text_result.SetValue("\n".join(res))
+
+    def test_fully_covered_image(self, event):
+        """
+        Tests the speed of rasterplotter for a fully black image.
+        """
+        import numpy as np
+        from PIL import Image, ImageDraw
+
+        from meerk40t.tools.rasterplotter import RasterPlotter
+
+        try:
+            x = int(self.text_x.GetValue())
+            y = int(self.text_y.GetValue())
+        except ValueError:
+            self.text_result.SetValue("Invalid dimensions. Please enter integers.")
+            return
+        if self.combo_raster_direction.GetSelection() < 0:
+            self.text_result.SetValue("Please select a raster direction.")
+            return
+        raster_string = self.combo_raster_direction.GetStringSelection()
+        raster_direction = -1
+        for key, info in self.raster_terms:
+            if raster_string == info:
+                raster_direction = key
+                break   
+        if raster_direction < 0:
+            self.text_result.SetValue("Invalid raster direction selected.")
+            return
+        bidir = self.check_raster_bidirectional.GetValue()
+
+        # Notabene: a black pixel is a non-burnt one, so we invert the logic here
+        image = Image.new("RGBA", (x, y), "black")
+        image = image.convert("L")
+        
+        plotter = RasterPlotter(image.load(), x, y, direction=raster_direction, bidirectional=bidir)   
+        t = time.time()
+        i = 0
+        res = []
+        pixels = 0
+        ipos = plotter.initial_position_in_scene()
+        lpos = plotter.final_position_in_scene()
+        last_x, last_y = ipos
+        for x, y, on in plotter.plot():
+            i += 1
+            if on:
+                pixels += (abs(x - last_x) + 1) * (abs(y - last_y) + 1)
+            res.append(f"{i}: ({x}, {y}) {'on' if on else 'off'}")
+            last_x, last_y = x, y
+        res.insert(
+            0,
+            f"White found: {pixels} pixels: ranging from ({ipos[0]}, {ipos[1]}) to ({lpos[0]}, {lpos[1]})",
+        )
+        res.append(f"Time taken to finish process {time.time() - t:.3f}s\n")
+        self.text_result.SetValue("\n".join(res))

meerk40t/gui/navigationpanels.py

@@ -1789,8 +1789,13 @@ class PulsePanel(wx.Panel):
         self.spin_pulse_duration = wx.SpinCtrl(
             self, wx.ID_ANY, style=wx.TE_PROCESS_ENTER, value="50", min=1, max=1000
         )
+        self.text_power = TextCtrl(
+            self, wx.ID_ANY, style=wx.TE_PROCESS_ENTER, value="1000", check="float"
+        )
+        self.label_power = wxStaticText(self, wx.ID_ANY, "ppi")
         self.__set_properties()
         self.__do_layout()
+        self.update_power_controls()
 
         self.Bind(
             wx.EVT_BUTTON, self.on_button_navigate_pulse, self.button_navigate_pulse
@@ -1813,13 +1818,17 @@ class PulsePanel(wx.Panel):
 
     def __do_layout(self):
         # begin wxGlade: PulsePanel.__do_layout
-        sizer_5 = StaticBoxSizer(self, wx.ID_ANY, _("Short Pulse:"), wx.HORIZONTAL)
-        sizer_5.Add(self.button_navigate_pulse, 0, wx.ALIGN_CENTER_VERTICAL, 0)
-        sizer_5.Add(self.spin_pulse_duration, 1, wx.ALIGN_CENTER_VERTICAL, 0)
+        self.main_sizer = StaticBoxSizer(
+            self, wx.ID_ANY, _("Short Pulse:"), wx.HORIZONTAL
+        )
+        self.main_sizer.Add(self.button_navigate_pulse, 0, wx.ALIGN_CENTER_VERTICAL, 0)
+        self.main_sizer.Add(self.spin_pulse_duration, 1, wx.ALIGN_CENTER_VERTICAL, 0)
         label_4 = wxStaticText(self, wx.ID_ANY, _(" ms"))
-        sizer_5.Add(label_4, 0, wx.ALIGN_CENTER_VERTICAL, 0)
-        self.SetSizer(sizer_5)
-        sizer_5.Fit(self)
+        self.main_sizer.Add(label_4, 0, wx.ALIGN_CENTER_VERTICAL, 0)
+        self.main_sizer.Add(self.text_power, 1, wx.ALIGN_CENTER_VERTICAL, 0)
+        self.main_sizer.Add(self.label_power, 0, wx.ALIGN_CENTER_VERTICAL, 0)
+        self.SetSizer(self.main_sizer)
+        self.main_sizer.Fit(self)
         self.Layout()
         # end wxGlade
 
@@ -1827,11 +1836,60 @@ class PulsePanel(wx.Panel):
         self, event=None
     ):  # wxGlade: Navigation.<event_handler>
         value = self.spin_pulse_duration.GetValue()
-        self.context(f"pulse {value}\n")
+        powerstr = ""
+        if self.text_power.IsShown():
+            power = self.text_power.GetValue()
+            if power:
+                try:
+                    power = float(power)
+                except ValueError:
+                    power = None
+            if power:
+                if self.context.device.setting(
+                    bool, "use_percent_for_power_display", False
+                ):
+                    # Convert percent to ppi
+                    power = power * 10
+                power = max(0, min(1000, int(power)))
+                self.context.device.setting(float, "last_pulse_power", 1000)
+                self.context.device.last_pulse_power = power
+                powerstr = f" -p {power}"
+        self.context(f"pulse {value}{powerstr}\n")
 
     def on_spin_pulse_duration(self, event=None):  # wxGlade: Navigation.<event_handler>
         self.context.navigate_pulse = float(self.spin_pulse_duration.GetValue())
 
+    def pane_show(self, *args):
+        # Is the current device pwm pulse capable?
+        self.context.listen("activate;device", self.on_update)
+        self.update_power_controls()
+
+    def pane_hide(self, *args):
+        self.context.unlisten("activate;device", self.on_update)
+
+    def on_update(self, origin, *args):
+        self.update_power_controls()
+
+    def update_power_controls(self):
+        show_power = getattr(self.context.device, "supports_pwm", False)
+        self.text_power.Show(show_power)
+        self.label_power.Show(show_power)
+        pval = self.context.device.setting(float, "last_pulse_power", 1000)
+        if pval is None:
+            pval = 1000
+        if self.context.device.setting(bool, "use_percent_for_power_display", False):
+            self.text_power.SetValue(f"{pval/10.0:.1f}")
+            self.text_power.set_range(0, 100)
+            self.text_power.SetToolTip(_("Set the power of the laser pulse in percent"))
+            self.label_power.SetLabel("%")
+        else:
+            self.text_power.SetValue(f"{pval}")
+            self.text_power.set_range(0, 1000)
+            self.text_power.SetToolTip(_("Set the power of the laser pulse in ppi"))
+            self.label_power.SetLabel("ppi")
+
+        self.main_sizer.Layout()
+
 
 # class SizePanel(wx.Panel):
 #     object_ratio = None