drawsvg-ui 0.5.5__py3-none-any.whl → 0.6.0__py3-none-any.whl

canvas_view.py

@@ -14,7 +14,14 @@ from typing import Any, Callable
 from PySide6 import QtCore, QtGui, QtWidgets
 from PySide6.QtGui import QTransform
 
-from constants import PALETTE_MIME, SHAPES, DEFAULTS
+from constants import (
+    DEFAULTS,
+    HOVER_PREVIEW_COLOR,
+    HOVER_PREVIEW_STRENGTH,
+    HOVER_PREVIEW_X_COUNT,
+    PALETTE_MIME,
+    SHAPES,
+)
 from items import (
     BlockArrowItem,
     CurvyBracketItem,
@@ -224,15 +231,26 @@ class SceneHistory(QtCore.QObject):
             return
         self._timer.start()
 
-    def capture_now(self) -> None:
-        self._capture_snapshot()
-
-    def undo(self) -> None:
-        if not self.can_undo():
-            return
-        self._index -= 1
-        self._apply_current_state()
-        self._notify()
+    def capture_now(self) -> None:
+        self._capture_snapshot()
+
+    def _flush_pending_snapshot(self) -> None:
+        if self._ignore_changes or not self._timer.isActive():
+            return
+        # Only flush when we're on the latest state; otherwise we'd
+        # truncate redo history while navigating older states.
+        if self._index != len(self._states) - 1:
+            return
+        self._timer.stop()
+        self._capture_snapshot()
+
+    def undo(self) -> None:
+        self._flush_pending_snapshot()
+        if not self.can_undo():
+            return
+        self._index -= 1
+        self._apply_current_state()
+        self._notify()
 
     def redo(self) -> None:
         if not self.can_redo():
@@ -690,11 +708,12 @@ class CanvasView(QtWidgets.QGraphicsView):
         QtCore.QTimer.singleShot(0, self._fit_view_to_page)
         self._update_scene_rect()
 
-        self._panning = False
-        self._pan_start = QtCore.QPointF()
-        self._prev_drag_mode = self.dragMode()
-        self._right_button_pressed = False
-        self._suppress_context_menu = False
+        self._panning = False
+        self._pan_start = QtCore.QPointF()
+        self._prev_drag_mode = self.dragMode()
+        self._right_button_pressed = False
+        self._suppress_context_menu = False
+        self._hover_preview_item: QtWidgets.QGraphicsItem | None = None
 
         self._history = SceneHistory(self)
         self._history.capture_initial_state()
@@ -723,37 +742,61 @@ class CanvasView(QtWidgets.QGraphicsView):
             return False
         return True
 
-    def _item_sort_key(self, item: QtWidgets.QGraphicsItem) -> tuple[float, str, float, float]:
-        shape = str(item.data(0)) if item.data(0) else item.__class__.__name__
-        pos = item.pos()
-        return (
-            round(float(item.zValue()), 6),
-            shape,
-            round(float(pos.x()), 6),
-            round(float(pos.y()), 6),
-        )
-
-    def _serialize_scene_state(self) -> dict[str, Any]:
-        scene = self.scene()
-        if scene is None:
-            return {"items": [], "grid_visible": bool(self._show_grid)}
-        items = [
-            item
-            for item in scene.items()
-            if self._is_serializable_item(item) and item.parentItem() is None
-        ]
-        items.sort(key=self._item_sort_key)
-        return {
-            "items": [self._serialize_item(item) for item in items],
-            "grid_visible": bool(self._show_grid),
-        }
-
-    def _serialize_item(self, item: QtWidgets.QGraphicsItem) -> dict[str, Any]:
-        shape_value = item.data(0)
-        shape = str(shape_value) if shape_value else item.__class__.__name__
-        base: dict[str, Any] = {
-            "shape": shape,
-            "class": item.__class__.__name__,
+    def _stacking_indices(self) -> dict[int, int]:
+        scene = self.scene()
+        if scene is None:
+            return {}
+        try:
+            ordered = scene.items(QtCore.Qt.SortOrder.AscendingOrder)
+        except TypeError:
+            # Older bindings can miss the overload with explicit sort order.
+            ordered = list(reversed(scene.items()))
+        return {id(item): index for index, item in enumerate(ordered)}
+
+    def _item_sort_key(
+        self,
+        item: QtWidgets.QGraphicsItem,
+        stacking_indices: Mapping[int, int] | None = None,
+    ) -> tuple[float, int, str, float, float]:
+        shape = str(item.data(0)) if item.data(0) else item.__class__.__name__
+        pos = item.pos()
+        stack_index = -1
+        if stacking_indices is not None:
+            stack_index = int(stacking_indices.get(id(item), -1))
+        return (
+            round(float(item.zValue()), 6),
+            stack_index,
+            shape,
+            round(float(pos.x()), 6),
+            round(float(pos.y()), 6),
+        )
+
+    def _serialize_scene_state(self) -> dict[str, Any]:
+        scene = self.scene()
+        if scene is None:
+            return {"items": [], "grid_visible": bool(self._show_grid)}
+        stacking_indices = self._stacking_indices()
+        items = [
+            item
+            for item in scene.items()
+            if self._is_serializable_item(item) and item.parentItem() is None
+        ]
+        items.sort(key=lambda item: self._item_sort_key(item, stacking_indices))
+        return {
+            "items": [self._serialize_item(item, stacking_indices) for item in items],
+            "grid_visible": bool(self._show_grid),
+        }
+
+    def _serialize_item(
+        self,
+        item: QtWidgets.QGraphicsItem,
+        stacking_indices: Mapping[int, int] | None = None,
+    ) -> dict[str, Any]:
+        shape_value = item.data(0)
+        shape = str(shape_value) if shape_value else item.__class__.__name__
+        base: dict[str, Any] = {
+            "shape": shape,
+            "class": item.__class__.__name__,
             "pos": [float(item.pos().x()), float(item.pos().y())],
             "rotation": float(item.rotation()),
             "scale": float(item.scale()),
@@ -844,14 +887,18 @@ class CanvasView(QtWidgets.QGraphicsView):
             base["direction"] = item.text_direction()
         elif isinstance(item, FolderTreeItem):
             base["structure"] = item.structure()
-        elif isinstance(item, GroupItem):
-            children = [
-                child
-                for child in item.childItems()
-                if self._is_serializable_item(child)
-            ]
-            children.sort(key=self._item_sort_key)
-            base["children"] = [self._serialize_item(child) for child in children]
+        elif isinstance(item, GroupItem):
+            children = [
+                child
+                for child in item.childItems()
+                if self._is_serializable_item(child)
+            ]
+            children.sort(
+                key=lambda child: self._item_sort_key(child, stacking_indices)
+            )
+            base["children"] = [
+                self._serialize_item(child, stacking_indices) for child in children
+            ]
         else:
             width, height = self._item_dimensions(item)
             base["size"] = [width, height]
@@ -978,10 +1025,45 @@ class CanvasView(QtWidgets.QGraphicsView):
             return float(width_attr), float(height_attr)
         bounds = item.boundingRect()
         return float(bounds.width()), float(bounds.height())
-
-    def _notify_selection_snapshot(self) -> None:
-        payload = self._build_selection_snapshot()
-        self.selectionSnapshotChanged.emit(payload)
+
+    def _hover_preview_target_at(
+        self, view_pos: QtCore.QPoint
+    ) -> QtWidgets.QGraphicsItem | None:
+        candidate = self.itemAt(view_pos)
+        selectable = QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsSelectable
+        while candidate is not None and not (candidate.flags() & selectable):
+            candidate = candidate.parentItem()
+        if candidate is None:
+            return None
+        if candidate.isSelected():
+            return None
+        if isinstance(candidate, LineItem):
+            return None
+        if not self._is_serializable_item(candidate):
+            return None
+        return candidate
+
+    def _set_hover_preview_item(self, item: QtWidgets.QGraphicsItem | None) -> None:
+        if item is self._hover_preview_item:
+            return
+        self._hover_preview_item = item
+        self.viewport().update()
+
+    def _clear_hover_preview(self) -> None:
+        self._set_hover_preview_item(None)
+
+    def _notify_selection_snapshot(self) -> None:
+        hover_item = self._hover_preview_item
+        if hover_item is not None:
+            try:
+                if hover_item.isSelected():
+                    self._hover_preview_item = None
+                    self.viewport().update()
+            except RuntimeError:
+                self._hover_preview_item = None
+                self.viewport().update()
+        payload = self._build_selection_snapshot()
+        self.selectionSnapshotChanged.emit(payload)
 
     def _on_scene_contents_changed(self, _changes) -> None:
         scene = self.scene()
@@ -1414,12 +1496,13 @@ class CanvasView(QtWidgets.QGraphicsView):
             self.fitInView(padded, QtCore.Qt.AspectRatioMode.KeepAspectRatio)
         self.centerOn(self._page_item)
 
-    def clear_canvas(self):
-        """Remove all items from the scene."""
-        scene = self.scene()
-        for item in list(scene.items()):
-            if isinstance(item, A4PageItem):
-                continue
+    def clear_canvas(self):
+        """Remove all items from the scene."""
+        self._clear_hover_preview()
+        scene = self.scene()
+        for item in list(scene.items()):
+            if isinstance(item, A4PageItem):
+                continue
             if item.__class__.__name__.endswith("Handle"):
                 continue
             if item.parentItem() is not None:
@@ -1435,13 +1518,109 @@ class CanvasView(QtWidgets.QGraphicsView):
             return
         self._ensure_pages_for_items(scene.items())
 
-    def drawBackground(self, painter: QtGui.QPainter, rect: QtCore.QRectF):
-        super().drawBackground(painter, rect)
-
-    def set_grid_visible(self, visible: bool):
-        self._show_grid = visible
-        for page in self._pages.values():
-            page.set_grid_visible(visible)
+    def drawBackground(self, painter: QtGui.QPainter, rect: QtCore.QRectF):
+        super().drawBackground(painter, rect)
+
+    def drawForeground(self, painter: QtGui.QPainter, rect: QtCore.QRectF) -> None:
+        super().drawForeground(painter, rect)
+
+        del rect
+
+        strength = max(0.0, float(HOVER_PREVIEW_STRENGTH))
+        marker_count = max(0, int(HOVER_PREVIEW_X_COUNT))
+        if strength <= 0.0 or marker_count <= 0:
+            return
+
+        item = self._hover_preview_item
+        scene = self.scene()
+        if item is None or scene is None:
+            return
+
+        try:
+            if item.scene() is not scene:
+                self._hover_preview_item = None
+                return
+        except RuntimeError:
+            self._hover_preview_item = None
+            return
+
+        corners_poly = item.mapToScene(item.boundingRect())
+        if len(corners_poly) < 4:
+            return
+        c0 = QtCore.QPointF(corners_poly[0])
+        c1 = QtCore.QPointF(corners_poly[1])
+        c2 = QtCore.QPointF(corners_poly[2])
+        c3 = QtCore.QPointF(corners_poly[3])
+
+        def lerp(start: QtCore.QPointF, end: QtCore.QPointF, t: float) -> QtCore.QPointF:
+            return QtCore.QPointF(
+                start.x() + (end.x() - start.x()) * t,
+                start.y() + (end.y() - start.y()) * t,
+            )
+
+        transform = painter.worldTransform()
+        sx = math.hypot(transform.m11(), transform.m21())
+        sy = math.hypot(transform.m12(), transform.m22())
+        lod = max((sx + sy) * 0.5, 1e-6)
+        strength_for_size = max(0.5, strength)
+        marker_half = 3.0 * strength_for_size / lod
+
+        base_color = QtGui.QColor(HOVER_PREVIEW_COLOR)
+        if not base_color.isValid():
+            base_color = QtGui.QColor("#14b5ff")
+        outline_color = QtGui.QColor(base_color)
+        outline_color.setAlpha(max(0, min(255, int(round(125 * strength)))))
+        marker_color = QtGui.QColor(base_color)
+        marker_color.setAlpha(max(0, min(255, int(round(220 * strength)))))
+
+        painter.save()
+        painter.setRenderHint(QtGui.QPainter.RenderHint.Antialiasing, True)
+
+        outline_pen = QtGui.QPen(outline_color, max(0.6, 1.0 * strength_for_size))
+        outline_pen.setCosmetic(True)
+        painter.setPen(outline_pen)
+        painter.setBrush(QtCore.Qt.BrushStyle.NoBrush)
+        painter.drawPolygon(QtGui.QPolygonF([c0, c1, c2, c3]))
+
+        marker_pen = QtGui.QPen(marker_color, max(0.7, 1.3 * strength_for_size))
+        marker_pen.setCosmetic(True)
+        painter.setPen(marker_pen)
+
+        edges = ((c0, c1), (c1, c2), (c2, c3), (c3, c0))
+        edge_lengths = [QtCore.QLineF(start, end).length() for start, end in edges]
+        perimeter = sum(edge_lengths)
+        if perimeter <= 1e-6:
+            painter.restore()
+            return
+
+        points: list[QtCore.QPointF] = []
+        for idx in range(marker_count):
+            distance = perimeter * (idx / marker_count)
+            remaining = distance
+            for edge_index, edge_length in enumerate(edge_lengths):
+                if remaining <= edge_length or edge_index == len(edge_lengths) - 1:
+                    start, end = edges[edge_index]
+                    t = 0.0 if edge_length <= 1e-6 else remaining / edge_length
+                    points.append(lerp(start, end, t))
+                    break
+                remaining -= edge_length
+
+        for point in points:
+            painter.drawLine(
+                QtCore.QPointF(point.x() - marker_half, point.y() - marker_half),
+                QtCore.QPointF(point.x() + marker_half, point.y() + marker_half),
+            )
+            painter.drawLine(
+                QtCore.QPointF(point.x() - marker_half, point.y() + marker_half),
+                QtCore.QPointF(point.x() + marker_half, point.y() - marker_half),
+            )
+
+        painter.restore()
+
+    def set_grid_visible(self, visible: bool):
+        self._show_grid = visible
+        for page in self._pages.values():
+            page.set_grid_visible(visible)
         self.viewport().update()
         if hasattr(self, "_history"):
             self._history.mark_dirty()
@@ -1531,12 +1710,16 @@ class CanvasView(QtWidgets.QGraphicsView):
         else:
             return None
 
-        item.setData(0, normalized)
-        self.scene().addItem(item)
-        item.setSelected(True)
-        self._ensure_page_for_item(item, drop_reference)
-        self._update_scene_rect()
-        return item
+        scene = self.scene()
+        if scene is None:
+            return None
+        item.setData(0, normalized)
+        scene.addItem(item)
+        scene.clearSelection()
+        item.setSelected(True)
+        self._ensure_page_for_item(item, drop_reference)
+        self._update_scene_rect()
+        return item
 
     def add_shape_at_view_center(self, shape: str) -> QtWidgets.QGraphicsItem | None:
         normalized = shape.strip()
@@ -1635,13 +1818,15 @@ class CanvasView(QtWidgets.QGraphicsView):
                         return
         super().mousePressEvent(event)
 
-    def mouseMoveEvent(self, event: QtGui.QMouseEvent):
-        
-        item = self.itemAt(event.position().toPoint())
-        if item and item.flags() & QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable:
-            self.viewport().setCursor(QtCore.Qt.CursorShape.SizeAllCursor)
-        else:
-            self.viewport().setCursor(QtCore.Qt.CursorShape.ArrowCursor)
+    def mouseMoveEvent(self, event: QtGui.QMouseEvent):
+        hover_target = self._hover_preview_target_at(event.position().toPoint())
+        self._set_hover_preview_item(hover_target)
+
+        item = self.itemAt(event.position().toPoint())
+        if item and item.flags() & QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable:
+            self.viewport().setCursor(QtCore.Qt.CursorShape.SizeAllCursor)
+        else:
+            self.viewport().setCursor(QtCore.Qt.CursorShape.ArrowCursor)
 
         if self._panning or self._right_button_pressed:
             delta = event.position() - self._pan_start
@@ -1655,20 +1840,22 @@ class CanvasView(QtWidgets.QGraphicsView):
                 self.viewport().setCursor(
                     QtCore.Qt.CursorShape.ClosedHandCursor
                 )
-            if self._panning:
-                self._pan_start = event.position()
-                hbar = self.horizontalScrollBar()
-                vbar = self.verticalScrollBar()
-                hbar.setValue(hbar.value() - int(delta.x()))
-                vbar.setValue(vbar.value() - int(delta.y()))
+            if self._panning:
+                self._clear_hover_preview()
+                self._pan_start = event.position()
+                hbar = self.horizontalScrollBar()
+                vbar = self.verticalScrollBar()
+                hbar.setValue(hbar.value() - int(delta.x()))
+                vbar.setValue(vbar.value() - int(delta.y()))
                 event.accept()
                 return
-        if getattr(self, "_dup_source", None):
-            pos = self.mapToScene(event.position().toPoint())
-            delta = pos - self._dup_start
-            if self._dup_items is None:
-                # Only create clones after surpassing the threshold.
-                if delta.manhattanLength() < DUPLICATE_DRAG_THRESHOLD:
+        if getattr(self, "_dup_source", None):
+            self._clear_hover_preview()
+            pos = self.mapToScene(event.position().toPoint())
+            delta = pos - self._dup_start
+            if self._dup_items is None:
+                # Only create clones after surpassing the threshold.
+                if delta.manhattanLength() < DUPLICATE_DRAG_THRESHOLD:
                     event.accept()
                     return
                 self._dup_items = []
@@ -1684,9 +1871,13 @@ class CanvasView(QtWidgets.QGraphicsView):
                     it.setSelected(True)
             for it, start in zip(self._dup_items, self._dup_orig):
                 it.setPos(start + delta)
-            event.accept()
-            return
-        super().mouseMoveEvent(event)
+            event.accept()
+            return
+        super().mouseMoveEvent(event)
+
+    def leaveEvent(self, event: QtCore.QEvent) -> None:
+        self._clear_hover_preview()
+        super().leaveEvent(event)
 
     def mouseReleaseEvent(self, event: QtGui.QMouseEvent):
         if event.button() == QtCore.Qt.MouseButton.RightButton:
@@ -2506,9 +2697,10 @@ class CanvasView(QtWidgets.QGraphicsView):
                     items[idx + 1], items[idx] = items[idx], items[idx + 1]
                 elif action == back_act:
                     items.insert(0, items.pop(idx))
-                elif action == front_act:
-                    items.append(items.pop(idx))
-                for z, it in enumerate(items):
-                    it.setZValue(z)
-            else:
-                super().contextMenuEvent(event)
+                elif action == front_act:
+                    items.append(items.pop(idx))
+                for z, it in enumerate(items):
+                    it.setZValue(z)
+                self._history.mark_dirty()
+            else:
+                super().contextMenuEvent(event)

constants.py

@@ -1,16 +1,16 @@
-# drawsvg-ui
-# Copyright (C) 2025 Andreas Wambold
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-from PySide6 import QtCore, QtGui
-
-PALETTE_MIME = "application/x-drawsvg-shape"
-SHAPES = (
-    "Rectangle",
+# drawsvg-ui
+# Copyright (C) 2025 Andreas Wambold
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from PySide6 import QtCore, QtGui
+
+PALETTE_MIME = "application/x-drawsvg-shape"
+SHAPES = (
+    "Rectangle",
     "Rounded Rectangle",
     "Split Rounded Rectangle",
     "Ellipse",
@@ -46,8 +46,15 @@ SELECTED_COLOR = QtGui.QColor("#16CCFA")
 PEN_SELECTED = QtGui.QPen(SELECTED_COLOR, 1, QtCore.Qt.PenStyle.DashLine)
 PEN_SELECTED.setCosmetic(True)
 DEFAULT_FILL = QtGui.QBrush(QtCore.Qt.white)
-DEFAULT_TEXT_COLOR = QtGui.QColor("#000")
-DEFAULT_FONT_FAMILY = "Arial"
+DEFAULT_TEXT_COLOR = QtGui.QColor("#000")
+DEFAULT_FONT_FAMILY = "Arial"
+
+# Hover preview for selectable items in the canvas.
+# Increase/decrease strength for a stronger/weaker effect.
+HOVER_PREVIEW_STRENGTH = 0.8
+# Total number of X markers drawn around the hovered item's border.
+HOVER_PREVIEW_X_COUNT = 16
+HOVER_PREVIEW_COLOR = QtGui.QColor("#14b5ff")
 
 # Default dash patterns used when exporting/importing common pen styles.
 PEN_STYLE_DASH_ARRAYS = {

{drawsvg_ui-0.5.5.dist-info → drawsvg_ui-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drawsvg-ui
-Version: 0.5.5
+Version: 0.6.0
 Summary: GUI for creating drawsvg scenes with PySide6
 Author-email: Taron686 <Taron686@users.noreply.github.com>
 License: GPL-3.0-or-later

{drawsvg_ui-0.5.5.dist-info → drawsvg_ui-0.6.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 app_info.py,sha256=4tXMbEUlznyx0D-e6yj8kHOduMIq0zXQJpCGwpy3kQw,2059
-canvas_view.py,sha256=QcioM62JCpET6Lm0PLYUuoh_pQvLU9Ky2je8I8tqkII,100346
-constants.py,sha256=KuML4vMiZbE2WsiGDXqKAsNmv3xmNL0NgLuQv2WxQTQ,1877
-export_drawsvg.py,sha256=eGQ0egtqJZSq1AMCLgTxwoRjIJMYtKik3SnVE1VLyu8,40846
-import_drawsvg.py,sha256=-zdeMJHxx2vf0aG4cNw-gCDbBxAntASStl5awcFe7kI,37626
+canvas_view.py,sha256=ZmMyn1vikqZGG1oVTGST-uqHm-5PWZwbUnOsUUYeB1A,107421
+constants.py,sha256=L_NKMRuFqbCvg0GpgnJDWPL1dCXbYLdyS2mJbKb2EyU,2181
+export_drawsvg.py,sha256=EzZYg56cEDu19fjr2-PKMBnQsZzD0BraRpz3073GaYI,41282
+import_drawsvg.py,sha256=Sa-x6Kcio9PP0ny2XteXr6V6Qv_zYASGurdyAW7aiJY,38069
 main.py,sha256=qTDUCGJIXqO_sztIhAMU958i5RiPyiRgsFN09IevKxE,860
 main_window.py,sha256=Wq0MehrW00Z-xor0BDftSfluA2YncRME2jzVeNmYi00,9948
 palette.py,sha256=H9b8ZE3ufNupusfwOr0wP3razDEA29HLJYDfmadLLKs,21942
 properties_panel.py,sha256=j_uyn6mqFwR7_nR1seJwnPjYWl_Axj8IUF0DcfPrObg,53661
-drawsvg_ui-0.5.5.dist-info/licenses/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
+drawsvg_ui-0.6.0.dist-info/licenses/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
 items/__init__.py,sha256=2xvoyRx2GpE7scPvD0zFKZZ43zumfR0rsD7WyFrkMg0,1770
 items/base.py,sha256=RPkfjRdbRtlN98ZtLG1U8HYI7Eb6embSct_kG8d7FWs,23164
 items/labels.py,sha256=N_qR0mq-eDFdxsnhNbkgsijnogceFOqSbhuRJwB4XTU,10102
@@ -22,8 +22,8 @@ items/widgets/folder_tree.py,sha256=E3XiIAIa6rpBlr6dmgcluMQcrT8BmxXTidilVGYqhUs,
 ui/__init__.py,sha256=dfQXeMdwX6Jn8VwHpWY0sqwhl3bcOsYq13nAWhMCPFg,357
 ui/main_window.ui,sha256=OmnMIUq4T1YjP1iVMGTUd-L8VKsCgLbCHIjx_PgbBXw,4346
 ui/properties_panel.ui,sha256=v0zNct6PZBuFzhmYTPyx-toLAtJP2eFzRAUAVTsYHSA,35679
-drawsvg_ui-0.5.5.dist-info/METADATA,sha256=-8NQqmTtqErIgZZOWB7pKh6nGdeukj_HE_YvMBOXLWc,5756
-drawsvg_ui-0.5.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-drawsvg_ui-0.5.5.dist-info/entry_points.txt,sha256=SUUEwp3n44haFICb66Jv9gO8_jabgTXOUqC-FUHnpk0,37
-drawsvg_ui-0.5.5.dist-info/top_level.txt,sha256=gGj1MC4gg01_Ye4LlevrdAMIIfPJgOUi7PD1TCVE0sk,112
-drawsvg_ui-0.5.5.dist-info/RECORD,,
+drawsvg_ui-0.6.0.dist-info/METADATA,sha256=S6_QvYtfOR0E1lv79f0Z3WGfhhA2bweWlVOfbs930Os,5756
+drawsvg_ui-0.6.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+drawsvg_ui-0.6.0.dist-info/entry_points.txt,sha256=SUUEwp3n44haFICb66Jv9gO8_jabgTXOUqC-FUHnpk0,37
+drawsvg_ui-0.6.0.dist-info/top_level.txt,sha256=gGj1MC4gg01_Ye4LlevrdAMIIfPJgOUi7PD1TCVE0sk,112
+drawsvg_ui-0.6.0.dist-info/RECORD,,

{drawsvg_ui-0.5.5.dist-info → drawsvg_ui-0.6.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

export_drawsvg.py

@@ -1463,16 +1463,27 @@ def export_drawsvg_py(scene: QtWidgets.QGraphicsScene, parent: QtWidgets.QWidget
                 except Exception:
                     text_dir = None
 
-            text_x = x_top + doc_margin * s
-            text_y = y_top + doc_margin * s
-
-            base_attrs = [
-                f"fill='{color.name()}'",
-                f"font_family='{font.family()}'",
-                "text_anchor='start'",
-                "dominant_baseline='text-before-edge'",
-                "alignment_baseline='text-before-edge'",
-                f"line_height={line_ratio:.6f}",
+            text_left = x_top + doc_margin * s
+            text_right = x_top + br.width() * s - doc_margin * s
+            text_center = (text_left + text_right) / 2.0
+            if h_align == "right":
+                text_anchor = "end"
+                text_x = text_right
+            elif h_align == "center":
+                text_anchor = "middle"
+                text_x = text_center
+            else:
+                text_anchor = "start"
+                text_x = text_left
+            text_y = y_top + doc_margin * s
+
+            base_attrs = [
+                f"fill='{color.name()}'",
+                f"font_family='{font.family()}'",
+                f"text_anchor='{text_anchor}'",
+                "dominant_baseline='text-before-edge'",
+                "alignment_baseline='text-before-edge'",
+                f"line_height={line_ratio:.6f}",
                 "xml__space='preserve'",
                 f"data_doc_margin={doc_margin:.4f}",
                 f"data_font_px={pixel_size:.4f}",

import_drawsvg.py

@@ -786,10 +786,20 @@ def import_drawsvg_py(scene: QtWidgets.QGraphicsScene, parent: QtWidgets.QWidget
                     except Exception:
                         pass
 
-                doc_margin_scene = doc_margin * scale_factor
-                x_pos = text_x - doc_margin_scene
-                y_pos = text_y - doc_margin_scene
-                item.setPos(x_pos, y_pos)
+                doc_margin_scene = doc_margin * scale_factor
+                box_w_scene = (
+                    float(box_w) * scale_factor
+                    if box_w is not None
+                    else item.boundingRect().width() * scale_factor
+                )
+                if data_text_h == "right":
+                    x_pos = text_x - (box_w_scene - doc_margin_scene)
+                elif data_text_h == "center":
+                    x_pos = text_x - box_w_scene / 2.0
+                else:
+                    x_pos = text_x - doc_margin_scene
+                y_pos = text_y - doc_margin_scene
+                item.setPos(x_pos, y_pos)
                 br = item.boundingRect()
                 item.setTransformOriginPoint(br.width() / 2.0, br.height() / 2.0)
                 if "transform" in kwargs: