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

meerk40t/gui/scenewidgets/laserpathwidget.py

@@ -1,66 +1,66 @@
-"""
-This widget draws laser position updates in blue lines to highlight the changes in the laser positions.
-"""
-
-import wx
-
-from meerk40t.gui.laserrender import DRAW_MODE_LASERPATH
-from meerk40t.gui.scene.widget import Widget
-
-
-class LaserPathWidget(Widget):
-    """
-    Scene Widget.
-
-    Draw the laserpath.
-
-    These are blue lines that track the previous position of the laser-head.
-    """
-
-    def __init__(self, scene):
-        Widget.__init__(self, scene, all=False)
-        self.buffer_size = 1000
-        self.laserpath = [[0, 0] for _ in range(self.buffer_size)], [
-            [0, 0] for _ in range(self.buffer_size)
-        ]
-        self.laserpath_index = 0
-
-    def init(self, context):
-        context.listen("driver;position", self.on_update)
-        context.listen("emulator;position", self.on_update)
-
-    def final(self, context):
-        context.unlisten("driver;position", self.on_update)
-        context.unlisten("emulator;position", self.on_update)
-
-    def on_update(self, origin, pos):
-        laserpath = self.laserpath
-        index = self.laserpath_index
-        laserpath[0][index][0] = pos[0]
-        laserpath[0][index][1] = pos[1]
-        laserpath[1][index][0] = pos[2]
-        laserpath[1][index][1] = pos[3]
-        index += 1
-        index %= len(laserpath[0])
-        self.laserpath_index = index
-
-    def clear_laserpath(self):
-        self.laserpath = [[0, 0] for _ in range(self.buffer_size)], [
-            [0, 0] for _ in range(self.buffer_size)
-        ]
-        self.laserpath_index = 0
-
-    def process_draw(self, gc):
-        """
-        Draw the blue lines of the LaserPath
-        """
-        context = self.scene.context
-        if context.draw_mode & DRAW_MODE_LASERPATH == 0:
-            mycol = self.scene.colors.color_laserpath
-            pen = wx.Pen(mycol)
-            gc.SetPen(pen)
-            starts, ends = self.laserpath
-            try:
-                gc.StrokeLineSegments(starts, ends)
-            except OverflowError:
-                pass  # I don't actually know why this would happen.
+"""
+This widget draws laser position updates in blue lines to highlight the changes in the laser positions.
+"""
+
+import wx
+
+from meerk40t.gui.laserrender import DRAW_MODE_LASERPATH
+from meerk40t.gui.scene.widget import Widget
+
+
+class LaserPathWidget(Widget):
+    """
+    Scene Widget.
+
+    Draw the laserpath.
+
+    These are blue lines that track the previous position of the laser-head.
+    """
+
+    def __init__(self, scene):
+        Widget.__init__(self, scene, all=False)
+        self.buffer_size = 1000
+        self.laserpath = [[0, 0] for _ in range(self.buffer_size)], [
+            [0, 0] for _ in range(self.buffer_size)
+        ]
+        self.laserpath_index = 0
+
+    def init(self, context):
+        context.listen("driver;position", self.on_update)
+        context.listen("emulator;position", self.on_update)
+
+    def final(self, context):
+        context.unlisten("driver;position", self.on_update)
+        context.unlisten("emulator;position", self.on_update)
+
+    def on_update(self, origin, pos):
+        laserpath = self.laserpath
+        index = self.laserpath_index
+        laserpath[0][index][0] = pos[0]
+        laserpath[0][index][1] = pos[1]
+        laserpath[1][index][0] = pos[2]
+        laserpath[1][index][1] = pos[3]
+        index += 1
+        index %= len(laserpath[0])
+        self.laserpath_index = index
+
+    def clear_laserpath(self):
+        self.laserpath = [[0, 0] for _ in range(self.buffer_size)], [
+            [0, 0] for _ in range(self.buffer_size)
+        ]
+        self.laserpath_index = 0
+
+    def process_draw(self, gc):
+        """
+        Draw the blue lines of the LaserPath
+        """
+        context = self.scene.context
+        if context.draw_mode & DRAW_MODE_LASERPATH == 0:
+            mycol = self.scene.colors.color_laserpath
+            pen = wx.Pen(mycol)
+            gc.SetPen(pen)
+            starts, ends = self.laserpath
+            try:
+                gc.StrokeLineSegments(starts, ends)
+            except OverflowError:
+                pass  # I don't actually know why this would happen.

meerk40t/gui/scenewidgets/machineoriginwidget.py

@@ -1,86 +1,86 @@
-"""
-This widget draws the machine origin as well as the X and Y directions for the coordinate system being used.
-
-The machine origin is actually the position of the 0,0 location for the device being used, whereas the coordinate
-system is the user display space.
-"""
-
-import wx
-
-from meerk40t.gui.laserrender import DRAW_MODE_ORIGIN
-from meerk40t.gui.scene.sceneconst import HITCHAIN_HIT, RESPONSE_CHAIN
-from meerk40t.gui.scene.widget import Widget
-
-
-class MachineOriginWidget(Widget):
-    """
-    Machine Origin Interface Widget
-    """
-
-    def __init__(self, scene, name=None):
-        Widget.__init__(self, scene, all=True)
-        self.name = name
-        self.brush = wx.Brush(
-            colour=wx.Colour(255, 0, 0, alpha=127), style=wx.BRUSHSTYLE_SOLID
-        )
-        self.x_axis_pen = wx.Pen(colour=wx.Colour(255, 0, 0))
-        self.x_axis_pen.SetWidth(1000)
-        self.y_axis_pen = wx.Pen(colour=wx.Colour(0, 255, 0))
-        self.y_axis_pen.SetWidth(1000)
-
-    def hit(self):
-        return HITCHAIN_HIT
-
-    def event(self, window_pos=None, space_pos=None, event_type=None, **kwargs):
-        return RESPONSE_CHAIN
-
-    def process_draw(self, gc):
-        """
-        Draws the background on the scene.
-        """
-        if self.scene.context.draw_mode & DRAW_MODE_ORIGIN != 0:
-            return
-        gcmat = gc.GetTransform()
-        mat_param = gcmat.Get()
-        if mat_param[0] == 1 and mat_param[3] == 1:
-            # We were called without a matrix applied, that's plain wrong
-            return
-        margin = 5000
-        space = self.scene.context.space
-        x, y = space.display.iposition(0, 0)
-        x_dx, x_dy = space.display.iposition(50000, 0)
-        xa1_dx, xa1_dy = space.display.iposition(45000, 5000)
-        xa2_dx, xa2_dy = space.display.iposition(45000, -5000)
-        y_dx, y_dy = space.display.iposition(0, 50000)
-        ya1_dx, ya1_dy = space.display.iposition(5000, 45000)
-        ya2_dx, ya2_dy = space.display.iposition(-5000, 45000)
-        gc.SetBrush(self.brush)
-        try:
-            dev0x, dev0y = space.device.view.iposition(0, 0)
-            gc.DrawRectangle(dev0x - margin, dev0y - margin, margin * 2, margin * 2)
-        except AttributeError:
-            # device view does not exist, so we cannot draw the device machine origin widget
-            pass
-
-        gc.SetBrush(wx.NullBrush)
-        gc.SetPen(self.x_axis_pen)
-        # gc.DrawLines will draw a polygon according to the documentation!
-        # While the windows implementation of wxPython does not care
-        # and draws a polyline, the Linux implementation does and closes the
-        # polygon!
-        arrow1 = gc.CreatePath()
-        arrow1.MoveToPoint((x, y))
-        arrow1.AddLineToPoint((x_dx, x_dy))
-        arrow1.AddLineToPoint((xa1_dx, xa1_dy))
-        arrow1.MoveToPoint((x_dx, x_dy))
-        arrow1.AddLineToPoint((xa2_dx, xa2_dy))
-        gc.DrawPath(arrow1)
-
-        gc.SetPen(self.y_axis_pen)
-        arrow2 = gc.CreatePath()
-        arrow2.MoveToPoint((x, y))
-        arrow2.AddLineToPoint((y_dx, y_dy))
-        arrow2.AddLineToPoint((ya1_dx, ya1_dy))
-        arrow2.MoveToPoint((y_dx, y_dy))
-        arrow2.AddLineToPoint((ya2_dx, ya2_dy))
-        gc.DrawPath(arrow2)
+"""
+This widget draws the machine origin as well as the X and Y directions for the coordinate system being used.
+
+The machine origin is actually the position of the 0,0 location for the device being used, whereas the coordinate
+system is the user display space.
+"""
+
+import wx
+
+from meerk40t.gui.laserrender import DRAW_MODE_ORIGIN
+from meerk40t.gui.scene.sceneconst import HITCHAIN_HIT, RESPONSE_CHAIN
+from meerk40t.gui.scene.widget import Widget
+
+
+class MachineOriginWidget(Widget):
+    """
+    Machine Origin Interface Widget
+    """
+
+    def __init__(self, scene, name=None):
+        Widget.__init__(self, scene, all=True)
+        self.name = name
+        self.brush = wx.Brush(
+            colour=wx.Colour(255, 0, 0, alpha=127), style=wx.BRUSHSTYLE_SOLID
+        )
+        self.x_axis_pen = wx.Pen(colour=wx.Colour(255, 0, 0))
+        self.x_axis_pen.SetWidth(1000)
+        self.y_axis_pen = wx.Pen(colour=wx.Colour(0, 255, 0))
+        self.y_axis_pen.SetWidth(1000)
+
+    def hit(self):
+        return HITCHAIN_HIT
+
+    def event(self, window_pos=None, space_pos=None, event_type=None, **kwargs):
+        return RESPONSE_CHAIN
+
+    def process_draw(self, gc):
+        """
+        Draws the background on the scene.
+        """
+        if self.scene.context.draw_mode & DRAW_MODE_ORIGIN != 0:
+            return
+        gcmat = gc.GetTransform()
+        mat_param = gcmat.Get()
+        if mat_param[0] == 1 and mat_param[3] == 1:
+            # We were called without a matrix applied, that's plain wrong
+            return
+        margin = 5000
+        space = self.scene.context.space
+        x, y = space.display.iposition(0, 0)
+        x_dx, x_dy = space.display.iposition(50000, 0)
+        xa1_dx, xa1_dy = space.display.iposition(45000, 5000)
+        xa2_dx, xa2_dy = space.display.iposition(45000, -5000)
+        y_dx, y_dy = space.display.iposition(0, 50000)
+        ya1_dx, ya1_dy = space.display.iposition(5000, 45000)
+        ya2_dx, ya2_dy = space.display.iposition(-5000, 45000)
+        gc.SetBrush(self.brush)
+        try:
+            dev0x, dev0y = space.device.view.iposition(0, 0)
+            gc.DrawRectangle(dev0x - margin, dev0y - margin, margin * 2, margin * 2)
+        except AttributeError:
+            # device view does not exist, so we cannot draw the device machine origin widget
+            pass
+
+        gc.SetBrush(wx.NullBrush)
+        gc.SetPen(self.x_axis_pen)
+        # gc.DrawLines will draw a polygon according to the documentation!
+        # While the windows implementation of wxPython does not care
+        # and draws a polyline, the Linux implementation does and closes the
+        # polygon!
+        arrow1 = gc.CreatePath()
+        arrow1.MoveToPoint((x, y))
+        arrow1.AddLineToPoint((x_dx, x_dy))
+        arrow1.AddLineToPoint((xa1_dx, xa1_dy))
+        arrow1.MoveToPoint((x_dx, x_dy))
+        arrow1.AddLineToPoint((xa2_dx, xa2_dy))
+        gc.DrawPath(arrow1)
+
+        gc.SetPen(self.y_axis_pen)
+        arrow2 = gc.CreatePath()
+        arrow2.MoveToPoint((x, y))
+        arrow2.AddLineToPoint((y_dx, y_dy))
+        arrow2.AddLineToPoint((ya1_dx, ya1_dy))
+        arrow2.MoveToPoint((y_dx, y_dy))
+        arrow2.AddLineToPoint((ya2_dx, ya2_dy))
+        gc.DrawPath(arrow2)

meerk40t/gui/scenewidgets/nodeselector.py

@@ -1,28 +1,28 @@
-"""
-Node selector stub
-"""
-import wx
-
-from meerk40t.gui.scene.widget import Widget
-
-
-class NodeSelector(Widget):
-    def __init__(self, scene):
-        Widget.__init__(self, scene, all=True)
-
-    def process_draw(self, gc: wx.GraphicsContext):
-        """
-        Widget-Routine to draw the different elements on the provided GraphicContext
-        """
-        gc.PushState()
-        offset = 2500
-        gc.SetPen(wx.RED_PEN)
-        gc.SetBrush(wx.RED_BRUSH)
-        points = self.scene.context.elements.points
-        for data in points:
-            index_line, index_pos, geom_t, node = data
-            g = geom_t.segments[index_line][index_pos]
-            ptx = g.real
-            pty = g.imag
-            gc.DrawEllipse(ptx - offset, pty - offset, offset * 2, offset * 2)
-        gc.PopState()
+"""
+Node selector stub
+"""
+import wx
+
+from meerk40t.gui.scene.widget import Widget
+
+
+class NodeSelector(Widget):
+    def __init__(self, scene):
+        Widget.__init__(self, scene, all=True)
+
+    def process_draw(self, gc: wx.GraphicsContext):
+        """
+        Widget-Routine to draw the different elements on the provided GraphicContext
+        """
+        gc.PushState()
+        offset = 2500
+        gc.SetPen(wx.RED_PEN)
+        gc.SetBrush(wx.RED_BRUSH)
+        points = self.scene.context.elements.points
+        for data in points:
+            index_line, index_pos, geom_t, node = data
+            g = geom_t.segments[index_line][index_pos]
+            ptx = g.real
+            pty = g.imag
+            gc.DrawEllipse(ptx - offset, pty - offset, offset * 2, offset * 2)
+        gc.PopState()