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

meerk40t/gui/toolwidgets/toolline.py

@@ -1,144 +1,39 @@
-import math
-
-import wx
-
-from meerk40t.gui.laserrender import swizzlecolor
-from meerk40t.gui.scene.sceneconst import (
-    RESPONSE_ABORT,
-    RESPONSE_CHAIN,
-    RESPONSE_CONSUME,
-)
-from meerk40t.gui.toolwidgets.toolwidget import ToolWidget
-from meerk40t.tools.geomstr import Geomstr
-
-_ = wx.GetTranslation
-
-
-class LineTool(ToolWidget):
-    """
-    Line Drawing Tool.
-
-    Adds Line with click and drag.
-    """
-
-    def __init__(self, scene):
-        ToolWidget.__init__(self, scene)
-        self.start_position = None
-        self.p1 = None
-        self.p2 = None
-
-    def process_draw(self, gc: wx.GraphicsContext):
-        if self.p1 is not None and self.p2 is not None:
-            matrix = gc.GetTransform().Get()
-            # pixel = 1.0 / matrix[0]
-            x0 = self.p1.real
-            y0 = self.p1.imag
-            x1 = self.p2.real
-            y1 = self.p2.imag
-            elements = self.scene.context.elements
-            if elements.default_stroke is None:
-                self.pen.SetColour(wx.BLUE)
-            else:
-                self.pen.SetColour(wx.Colour(swizzlecolor(elements.default_stroke)))
-            gc.SetPen(self.pen)
-            gc.StrokeLine(
-                x0,
-                y0,
-                x1,
-                y1,
-            )
-            s = f"Draw line from {x0}, {y0} to {x0}, {y0}"
-            self.scene.context.signal("statusmsg", s)
-
-    def event(
-        self,
-        window_pos=None,
-        space_pos=None,
-        event_type=None,
-        nearest_snap=None,
-        modifiers=None,
-        keycode=None,
-        **kwargs,
-    ):
-        response = RESPONSE_CHAIN
-        update_required = False
-        if event_type == "leftdown":
-            self.scene.pane.tool_active = True
-            if nearest_snap is None:
-                sx, sy = self.scene.get_snap_point(
-                    space_pos[0], space_pos[1], modifiers
-                )
-                self.p1 = complex(sx, sy)
-            else:
-                self.p1 = complex(nearest_snap[0], nearest_snap[1])
-            response = RESPONSE_CONSUME
-        elif event_type == "move":
-            if self.p1 is not None:
-                self.p2 = complex(space_pos[0], space_pos[1])
-                if "shift" in modifiers:
-                    r = abs(self.p1 - self.p2)
-                    a = Geomstr.angle(None, self.p1, self.p2)
-                    delta = math.tau / 32
-
-                    for i in range(-4, 4):
-                        s = i * math.tau / 8 - delta
-                        e = i * math.tau / 8 + delta
-                        if s <= a <= e:
-                            self.p2 = Geomstr.polar(None, self.p1, i * math.tau / 8, r)
-                else:
-                    if nearest_snap is not None:
-                        self.p2 = complex(nearest_snap[0], nearest_snap[1])
-                self.scene.request_refresh()
-                response = RESPONSE_CONSUME
-        elif event_type == "leftclick":
-            # Dear user: that's too quick for my taste - take your time...
-            self.p1 = None
-            self.p2 = None
-            self.scene.pane.tool_active = False
-            self.scene.request_refresh()
-            # Allow other widgets (like the selection widget to take over)
-            response = RESPONSE_CHAIN
-        elif event_type == "leftup":
-            self.scene.pane.tool_active = False
-            try:
-                if self.p1 is None or self.p2 is None:
-                    return RESPONSE_ABORT
-                x1 = self.p1.real
-                y1 = self.p1.imag
-                x2 = self.p2.real
-                y2 = self.p2.imag
-                elements = self.scene.context.elements
-                node = elements.elem_branch.add(
-                    x1=x1,
-                    y1=y1,
-                    x2=x2,
-                    y2=y2,
-                    stroke_width=elements.default_strokewidth,
-                    stroke=elements.default_stroke,
-                    fill=elements.default_fill,
-                    type="elem line",
-                )
-                if elements.classify_new:
-                    elements.classify([node])
-                self.notify_created(node)
-                self.p1 = None
-                self.p2 = None
-            except IndexError:
-                pass
-            self.scene.request_refresh()
-            self.scene.context.signal("statusmsg", "")
-            response = RESPONSE_ABORT
-        elif event_type == "lost" or (event_type == "key_up" and modifiers == "escape"):
-            if self.scene.pane.tool_active:
-                self.scene.pane.tool_active = False
-                self.scene.request_refresh()
-                response = RESPONSE_CONSUME
-            else:
-                response = RESPONSE_CHAIN
-            self.p1 = None
-            self.p2 = None
-            self.scene.context.signal("statusmsg", "")
-        elif update_required:
-            self.scene.request_refresh()
-            response = RESPONSE_CONSUME
-        return response
+from .toolpointlistbuilder import PointListTool
+
+
+class LineTool(PointListTool):
+    """
+    Line Drawing Tool.
+
+    Adds Line with two clicks.
+    """
+
+    def __init__(self, scene, mode=None):
+        PointListTool.__init__(self, scene, mode=mode)
+
+    def create_node(self):
+        if len(self.point_series) > 1:
+            x1 = self.point_series[0][0]
+            y1 = self.point_series[0][1]
+            x2 = self.point_series[1][0]
+            y2 = self.point_series[1][1]
+            elements = self.scene.context.elements
+            # _("Create line")
+            with elements.undoscope("Create line"):
+                node = elements.elem_branch.add(
+                    x1=x1,
+                    y1=y1,
+                    x2=x2,
+                    y2=y2,
+                    stroke_width=elements.default_strokewidth,
+                    stroke=elements.default_stroke,
+                    fill=elements.default_fill,
+                    type="elem line",
+                )
+                if elements.classify_new:
+                    elements.classify([node])
+            self.notify_created(node)
+
+    def point_added(self):
+        if len(self.point_series) > 1:
+            self.end_tool()  # That will call everything

meerk40t/gui/toolwidgets/toollinetext.py

@@ -1,236 +1,79 @@
-from time import time
-
-import wx
-
-from meerk40t.core.units import Length
-from meerk40t.extra.hershey import create_linetext_node, update_linetext
-from meerk40t.gui.laserrender import swizzlecolor
-from meerk40t.gui.scene.sceneconst import RESPONSE_CHAIN, RESPONSE_CONSUME
-from meerk40t.gui.toolwidgets.toolwidget import ToolWidget
-from meerk40t.svgelements import Color
-
-_ = wx.GetTranslation
-
-
-class LineTextTool(ToolWidget):
-    """
-    Linetext Creation Tool.
-
-    Adds a linetext, first point click then Text-Entry
-    """
-
-    def __init__(self, scene):
-        ToolWidget.__init__(self, scene)
-        self.start_position = None
-        self.p1 = None
-        self.node = None
-        self.color = None
-        self.tsize = 0
-        self.vtext = ""
-        self.anim_count = 0
-        self.last_anim = 0
-
-    def process_draw(self, gc: wx.GraphicsContext):
-        # We just draw a cursor rectangle...
-        if self.p1 is not None:
-            cursorwidth = float(Length("1mm"))
-            cursorheight = float(Length("8mm"))
-            offsetx = 0
-            offsety = 0
-            x0 = self.p1.real + offsetx
-            y0 = self.p1.imag - cursorheight
-            elements = self.scene.context.elements
-
-            if self.node is None or self.node.bounds is None:
-                # if self.node is not None:
-                #     if hasattr(self.node, "mkfont"):
-                #         fname = self.node.mkfont
-                #         if fname.lower().endswith(".jhf"):
-                #             offsety = 0.5 * cursorheight
-
-                if elements.default_stroke is None:
-                    self.color = Color("black")
-                else:
-                    self.color = elements.default_stroke
-                if elements.default_stroke is None:
-                    self.pen.SetColour(wx.BLUE)
-                else:
-                    self.pen.SetColour(wx.Colour(swizzlecolor(elements.default_stroke)))
-            else:
-                self.color = self.node.stroke
-                offsetx = self.node.bounds[2] - self.node.bounds[0]
-                cursorheight = self.node.bounds[3] - self.node.bounds[1]
-                # if hasattr(self.node, "mkfont"):
-                #     fname = self.node.mkfont
-                #     if fname.lower().endswith(".jhf"):
-                #         offsety = 0.5 * cursorheight
-                self.pen.SetColour(wx.Colour(swizzlecolor(self.node.stroke)))
-                x0 = self.node.bounds[2]
-                y0 = self.node.bounds[1]
-
-            mycol = wx.Colour(swizzlecolor(self.color))
-            self.pen.SetColour(mycol)
-            gc.SetPen(self.pen)
-            if self.anim_count == 0:
-                self.anim_count = 1
-                gc.SetBrush(wx.Brush(mycol, wx.BRUSHSTYLE_SOLID))
-            else:
-                self.anim_count = 0
-                gc.SetBrush(wx.Brush(mycol, wx.BRUSHSTYLE_TRANSPARENT))
-            gc.DrawRectangle(x0, y0, cursorwidth, cursorheight)
-
-    def event(
-        self,
-        window_pos=None,
-        space_pos=None,
-        event_type=None,
-        nearest_snap=None,
-        modifiers=None,
-        keycode=None,
-        **kwargs,
-    ):
-        def done():
-            self.p1 = None
-            if self.node is not None:
-                self.node.stroke = self.color
-                self.node.altered()
-                self.node.focus()
-                self.scene.pane.tool_active = False
-                self.scene.context.signal("element_property_update", [self.node])
-                self.scene.request_refresh()
-            self.node = None
-            self.scene.context("tool none\n")
-            self.scene.context("window close HersheyFontSelector\n")
-            self.scene.context.signal("statusmsg", "")
-
-        response = RESPONSE_CHAIN
-        # if event_type == "key_up":
-        #     print (f"Event {event_type}, Key: {keycode}, Modifiers: {modifiers}")
-        if event_type == "leftdown":
-            if self.p1 is None:
-                self.scene.pane.tool_active = True
-                self.scene.animate(self)
-                elements = self.scene.context.elements
-                if elements.default_stroke is None:
-                    self.color = Color("black")
-                else:
-                    self.color = elements.default_stroke
-                if nearest_snap is None:
-                    sx, sy = self.scene.get_snap_point(
-                        space_pos[0], space_pos[1], modifiers
-                    )
-                    self.p1 = complex(sx, sy)
-                else:
-                    self.p1 = complex(nearest_snap[0], nearest_snap[1])
-                x = self.p1.real
-                y = self.p1.imag
-                self.vtext = "Text"
-                self.node = create_linetext_node(self.scene.context, x, y, self.vtext)
-                if self.node is not None:
-                    self.node.stroke = self.color
-                    self.node.stroke_width = elements.default_strokewidth
-                    elements.elem_branch.add_node(self.node)
-                    self.scene.context.signal("element_added", self.node)
-                    self.scene.context.signal(
-                        "statusmsg",
-                        _("Complete text-entry by pressing either Enter or Escape"),
-                    )
-                    if elements.classify_new:
-                        elements.classify([self.node])
-                    self.notify_created(self.node)
-                    self.node.emphasized = False
-                    self.scene.context("window open HersheyFontSelector\n")
-                    # Refocus, to allow typing...
-                    self.scene.gui.scene_panel.SetFocus()
-                else:
-                    # Node creation failed!
-                    done()
-
-            response = RESPONSE_CONSUME
-        elif event_type == "doubleclick":
-            done()
-            response = RESPONSE_CONSUME
-        elif event_type == "rightdown":
-            done()
-            response = RESPONSE_CONSUME
-        elif event_type == "key_up" and modifiers == "escape":
-            if self.scene.pane.tool_active:
-                done()
-                response = RESPONSE_CONSUME
-            else:
-                response = RESPONSE_CHAIN
-        elif event_type == "key_up" and modifiers == "return":
-            if self.scene.pane.tool_active:
-                done()
-                response = RESPONSE_CONSUME
-            else:
-                response = RESPONSE_CHAIN
-        elif event_type == "key_up":
-            if self.scene.pane.tool_active:
-                response = RESPONSE_CONSUME
-                to_add = ""
-                if keycode is not None:
-                    to_add = keycode
-                # if modifiers.startswith("shift+") and modifiers != "shift+":
-                #     to_add = modifiers[-1].upper()
-                # elif len(modifiers) == 1:
-                #     to_add = modifiers
-                # elif modifiers == "space":
-                #     to_add = " "
-                # elif modifiers == "back":
-                if modifiers == "back":
-                    to_add = ""
-                    if len(self.vtext) > 0:
-                        self.vtext = self.vtext[:-1]
-                if len(to_add) > 0:
-                    self.vtext += to_add
-                # print(f"Keyup: {keycode} - {modifiers}: '{self.vtext}'")
-                if self.node is None:
-                    x = self.p1.real
-                    y = self.p1.imag
-                    self.node = create_linetext_node(
-                        self.scene.context, x, y, self.vtext
-                    )
-                else:
-                    update_linetext(self.scene.context, self.node, self.vtext)
-                # self.node.stroke = self.color
-                # self.node.modified()
-                if self.node is not None:
-                    self.node.emphasized = False
-
-                self.scene.request_refresh()
-            else:
-                response = RESPONSE_CHAIN
-        return response
-
-    # Animation logic
-    def tick(self):
-        if self.p1 is None:
-            return False
-        t = time()
-        if t - self.last_anim > 0.5:
-            self.last_anim = t
-            self.scene.request_refresh_for_animation()
-
-        return True
-
-    def signal(self, signal, *args, **kwargs):
-        if self.node is None:
-            return
-        if signal == "linetext" and args[0] == "bigger":
-            self.node.mkfontsize *= 1.2
-            update_linetext(self.scene.context, self.node, self.node.mktext)
-            self.node.emphasized = False
-            self.scene.request_refresh()
-        elif signal == "linetext" and args[0] == "smaller":
-            self.node.mkfontsize /= 1.2
-            update_linetext(self.scene.context, self.node, self.node.mktext)
-            self.node.emphasized = False
-            self.scene.request_refresh()
-        elif signal == "linetext" and args[0] == "font":
-            if len(args) > 1:
-                font = args[1]
-                self.node.mkfont = font
-                update_linetext(self.scene.context, self.node, self.node.mktext)
-                self.node.emphasized = False
-                self.scene.request_refresh()
+import wx
+
+from meerk40t.core.units import Length
+from meerk40t.gui.scene.sceneconst import RESPONSE_CHAIN, RESPONSE_CONSUME
+
+# from meerk40t.gui.toolwidgets.textentry import TextEntry
+from meerk40t.gui.toolwidgets.toolwidget import ToolWidget
+from meerk40t.svgelements import Color, Matrix
+
+_ = wx.GetTranslation
+
+
+class LineTextTool(ToolWidget):
+    """
+    Text Drawing Tool
+
+    Adds Vectortext at set location.
+    """
+
+    def __init__(self, scene, mode=None):
+        ToolWidget.__init__(self, scene)
+        self.start_position = None
+        self.scene.context.setting(float, "last_font_size", float(Length("20px")))
+        self.scene.context.setting(str, "last_font", "")
+        self.last_node_created = None
+
+    def process_draw(self, gc: wx.GraphicsContext):
+        pass
+
+    def end_tool(self, force=False):
+        self.scene.context.signal("statusmsg", "")
+        self.scene.request_refresh()
+        if force or self.scene.context.just_a_single_element:
+            self.scene.pane.tool_active = False
+            self.scene.context("tool none\n")
+
+    def event(
+        self,
+        window_pos=None,
+        space_pos=None,
+        event_type=None,
+        nearest_snap=None,
+        modifiers=None,
+        **kwargs,
+    ):
+        response = RESPONSE_CHAIN
+        self.scene.cursor("text")
+        if event_type == "leftdown":
+            if nearest_snap is None:
+                x, y = self.scene.get_snap_point(space_pos[0], space_pos[1], modifiers)
+            else:
+                x = nearest_snap[0]
+                y = nearest_snap[1]
+            elements = self.scene.context.elements
+            # if elements.default_stroke is None:
+            #     text_color = Color("black")
+            # else:
+            #     text_color = elements.default_stroke
+            text_content = "Text"
+            fsize = self.scene.context.last_font_size
+            font = self.scene.context.last_font
+            if font:
+                font = f'-f "{font}"'
+            self.scene.context(f'linetext {x} {y} "{text_content}" {font} -s {fsize}\n')
+            self.scene.context(".window open Properties\n")
+            self.scene.context.signal("textselect")
+            self.end_tool()
+            response = RESPONSE_CONSUME
+        elif event_type == "lost" or (event_type == "key_up" and modifiers == "escape") or (event_type=="rightdown"):
+            if self.scene.pane.tool_active:
+                response = RESPONSE_CONSUME
+            else:
+                response = RESPONSE_CHAIN
+            self.end_tool(force=True)
+        return response
+
+    # @staticmethod
+    # def sub_register(kernel):
+    #     kernel.register("window/TextEntry", TextEntry)