feat(svg-editor): add drag-to-move, arrow nudge, and overlap picker

Direct canvas manipulation in live preview: press-drag a selected
element to reposition (whole selection under multi-select), arrow keys
nudge 1px (Shift=10px), right-click lists stacked elements to
disambiguate. Moves reuse attrsForMove + staging + backend coalescing
with optimistic preview and rollback on failure.

Moved tspans promote to standalone <text> to avoid shifting sibling
baselines; icon moves persist via data-use-x/y + transform so the
finalize/export pipeline reproduces the edited geometry. convert_text
now absorbs pure-translate transforms on text into the frame position.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: hugohe3

skills/ppt-master/scripts/svg_editor/annotations.py

@@ -14,6 +14,8 @@
 """
 
 import xml.etree.ElementTree as ET
+import re
+from copy import deepcopy
 from typing import Optional
 
 SVG_NS = 'http://www.w3.org/2000/svg'
@@ -50,6 +52,154 @@ def _find_by_id(root: ET.Element, element_id: str) -> Optional[ET.Element]:
     return None
 
 
+def _find_with_parent(
+    root: ET.Element, element_id: str,
+) -> tuple[Optional[ET.Element], Optional[ET.Element]]:
+    """Find an element and its parent by id."""
+    for parent in root.iter():
+        for child in list(parent):
+            if child.get('id') == element_id:
+                return child, parent
+    return None, None
+
+
+def _local_name(elem: ET.Element) -> str:
+    return elem.tag.split('}', 1)[1] if '}' in elem.tag else elem.tag
+
+
+def _first_number(value: Optional[str]) -> Optional[float]:
+    if value is None:
+        return None
+    match = re.search(r'-?\d+(?:\.\d+)?', value)
+    return float(match.group(0)) if match else None
+
+
+def _format_number(value: float) -> str:
+    text = f'{value:.3f}'.rstrip('0').rstrip('.')
+    return text or '0'
+
+
+def _tspan_baseline(text_el: ET.Element, tspan_el: ET.Element) -> Optional[tuple[float, float]]:
+    cur_x = _first_number(text_el.get('x'))
+    cur_y = _first_number(text_el.get('y'))
+    for child in list(text_el):
+        if _local_name(child) != 'tspan':
+            continue
+        x_val = _first_number(child.get('x'))
+        y_val = _first_number(child.get('y'))
+        dx_val = _first_number(child.get('dx'))
+        dy_val = _first_number(child.get('dy'))
+        if x_val is not None:
+            cur_x = x_val
+        elif dx_val is not None:
+            cur_x = (cur_x or 0.0) + dx_val
+        if y_val is not None:
+            cur_y = y_val
+        elif dy_val is not None:
+            cur_y = (cur_y or 0.0) + dy_val
+        if child is tspan_el:
+            break
+    if cur_x is None or cur_y is None:
+        return None
+    return cur_x, cur_y
+
+
+def _adjust_following_tspan_dy(
+    text_el: ET.Element,
+    target: ET.Element,
+) -> None:
+    """Keep later line-break tspans visually stable when one sibling is removed."""
+    children = list(text_el)
+    try:
+        idx = children.index(target)
+    except ValueError:
+        return
+    if idx + 1 >= len(children):
+        return
+    next_el = children[idx + 1]
+    if _local_name(next_el) != 'tspan' or next_el.get('y') is not None or next_el.get('dy') is None:
+        return
+    next_baseline = _tspan_baseline(text_el, next_el)
+    if next_baseline is None:
+        return
+    prev_y: Optional[float] = None
+    for prior in reversed(children[:idx]):
+        if _local_name(prior) != 'tspan':
+            continue
+        prior_baseline = _tspan_baseline(text_el, prior)
+        if prior_baseline is not None:
+            prev_y = prior_baseline[1]
+            break
+    if prev_y is None:
+        prev_y = _first_number(text_el.get('y')) or 0.0
+    next_el.set('dy', _format_number(next_baseline[1] - prev_y))
+
+
+def _copy_text_attrs(src: ET.Element, dst: ET.Element, skip: set[str]) -> None:
+    for key, value in src.attrib.items():
+        if key not in skip:
+            dst.set(key, value)
+
+
+def promote_tspan_to_text(
+    root: ET.Element,
+    element_id: str,
+    x: str,
+    y: str,
+) -> tuple[bool, Optional[str]]:
+    """Promote a moved direct-child <tspan> into an independent <text>.
+
+    Writing vertical movement into ``dy`` changes the baseline for following
+    tspans. Promotion preserves the edited line as its own object whose final
+    position lives in x/y, while adjacent lines remain anchored in the parent.
+    """
+    target, text_el = _find_with_parent(root, element_id)
+    if target is None or text_el is None:
+        return False, 'not-found'
+    if _local_name(target) != 'tspan' or _local_name(text_el) != 'text':
+        return False, 'not-tspan'
+
+    grandparent: Optional[ET.Element] = None
+    for candidate in root.iter():
+        if text_el in list(candidate):
+            grandparent = candidate
+            break
+    if grandparent is None:
+        return False, 'parent-not-found'
+
+    _adjust_following_tspan_dy(text_el, target)
+
+    new_text = ET.Element(f'{{{SVG_NS}}}text')
+    _copy_text_attrs(text_el, new_text, {'id', 'x', 'y', 'dx', 'dy'})
+    _copy_text_attrs(target, new_text, {'id', 'x', 'y', 'dx', 'dy', 'transform'})
+    new_text.set('id', element_id)
+    new_text.set('x', x)
+    new_text.set('y', y)
+
+    if len(list(target)) == 0:
+        new_text.text = ''.join(target.itertext())
+    else:
+        new_text.text = target.text
+        for child in list(target):
+            new_text.append(deepcopy(child))
+
+    target_index = list(text_el).index(target)
+    tail = target.tail
+    text_el.remove(target)
+    if tail:
+        if target_index == 0:
+            text_el.text = (text_el.text or '') + tail
+        else:
+            prev = list(text_el)[target_index - 1]
+            prev.tail = (prev.tail or '') + tail
+
+    parent_index = list(grandparent).index(text_el)
+    grandparent.insert(parent_index + 1, new_text)
+    if not (text_el.text or '').strip() and len(list(text_el)) == 0:
+        grandparent.remove(text_el)
+    return True, None
+
+
 def parse_annotations(root: ET.Element) -> list[dict]:
     """Extract all annotations from an SVG element tree."""
     annotations = []
@@ -145,7 +295,10 @@ def set_attributes(
         if not is_editable_attr(key):
             return False, f'attr-not-allowed:{key}'
     for key, value in attrs.items():
-        elem.set(key, str(value))
+        if value is None:
+            elem.attrib.pop(key, None)
+        else:
+            elem.set(key, str(value))
     return True, None
 
 

skills/ppt-master/scripts/svg_editor/server.py

@@ -19,6 +19,7 @@
 
 import argparse
 import atexit
+import html
 import json
 import logging
 import os
@@ -53,6 +54,7 @@
     assign_temp_ids,
     is_editable_attr,
     parse_annotations,
+    promote_tspan_to_text,
     set_annotation,
     set_attributes,
     set_text,
@@ -78,6 +80,11 @@
 _LIST_CACHE: dict = {}  # path -> (mtime, annotation_count_on_disk)
 
 
+def _xml_attr(value: object) -> str:
+    """Escape a value for safe insertion into generated preview SVG markup."""
+    return html.escape(str(value), quote=True)
+
+
 def _cache_get(cache: dict, lock: threading.Lock, path: str, mtime: float):
     with lock:
         entry = cache.get(path)
@@ -181,8 +188,17 @@ def _inline_icons(content: str) -> tuple[str, list[dict]]:
         replacement = generate_icon_group(attrs, elements, style, base_size)
         id_match = re.search(r'\bid="([^"]+)"', use_str)
         if id_match:
+            preview_attrs = [
+                f'id="{_xml_attr(id_match.group(1))}"',
+                f'data-icon="{_xml_attr(icon_name)}"',
+            ]
+            for key in ('x', 'y', 'width', 'height'):
+                if key in attrs:
+                    preview_attrs.append(f'data-use-{key}="{_xml_attr(attrs[key])}"')
+            if 'transform' in attrs:
+                preview_attrs.append('data-use-has-transform="1"')
             replacement = replacement.replace(
-                '<g ', f'<g id="{id_match.group(1)}" data-icon="{icon_name}" ', 1,
+                '<g ', f'<g {" ".join(preview_attrs)} ', 1,
             )
         new_content = new_content[:match.start()] + replacement + new_content[match.end():]
     return new_content, warnings
@@ -219,6 +235,10 @@ def _validate_edit_attrs(attrs: dict, existing_attrs: set[str]) -> Optional[str]
             return f'attribute not editable: {key}'
         if key not in existing_attrs and key != 'transform' and key not in _ADDABLE_BATCH_ATTRS:
             return f'attribute does not exist on element: {key}'
+        if value is None:
+            if key not in existing_attrs:
+                return f'attribute does not exist on element: {key}'
+            continue
         if not isinstance(value, str):
             return f'value must be a string: {key}'
         if len(value) > _MAX_ATTR_VALUE_LEN:
@@ -262,6 +282,18 @@ def _apply_edit_record(root: ET.Element, record: dict) -> tuple[bool, Optional[s
     element_id = record.get('element_id')
     if not isinstance(element_id, str):
         return False, 'invalid-record'
+    promote = record.get('promote_tspan')
+    if promote:
+        if not isinstance(promote, dict):
+            return False, 'invalid-promote'
+        ok, reason = promote_tspan_to_text(
+            root,
+            element_id,
+            str(promote.get('x') or ''),
+            str(promote.get('y') or ''),
+        )
+        if not ok:
+            return ok, reason
     if 'text' in record:
         ok, reason = set_text(root, element_id, str(record.get('text') or ''))
         if not ok:
@@ -290,7 +322,8 @@ def _edit_signature(record: dict) -> tuple:
     collapses to one undo step; 'change fill then font-size' stays two.
     """
     attr_keys = tuple(sorted((record.get('attrs') or {}).keys()))
-    return (record.get('element_id'), 'text' in record, attr_keys)
+    promote_keys = tuple(sorted((record.get('promote_tspan') or {}).keys()))
+    return (record.get('element_id'), 'text' in record, attr_keys, promote_keys)
 
 
 def _coalesce_into(prev: dict, cur: dict) -> None:
@@ -307,6 +340,8 @@ def _coalesce_into(prev: dict, cur: dict) -> None:
         merged = dict(prev.get('attrs') or {})
         merged.update(cur['attrs'])
         prev['attrs'] = merged
+    if cur.get('promote_tspan'):
+        prev['promote_tspan'] = cur['promote_tspan']
     old_by_field = {(c['kind'], c['key']): c['old'] for c in prev['changes']}
     prev['changes'] = [
         {
@@ -624,7 +659,8 @@ def post_edit(name: str):
 
         new_text = data.get('text')
         attrs = data.get('attrs')
-        if new_text is None and not attrs:
+        promote = data.get('promote_tspan')
+        if new_text is None and not attrs and not promote:
             return jsonify({'error': 'Nothing to edit (no text or attrs)'}), 400
 
         if new_text is not None:
@@ -633,6 +669,13 @@ def post_edit(name: str):
         if attrs is not None:
             if not isinstance(attrs, dict):
                 return jsonify({'error': 'attrs must be an object'}), 400
+        if promote is not None:
+            if not isinstance(promote, dict):
+                return jsonify({'error': 'promote_tspan must be an object'}), 400
+            for key in ('x', 'y'):
+                value = promote.get(key)
+                if not isinstance(value, str) or not re.fullmatch(r'-?\d+(?:\.\d+)?', value):
+                    return jsonify({'error': f'invalid promote_tspan.{key}'}), 400
 
         try:
             tree = ET.parse(str(svg_file))
@@ -677,6 +720,27 @@ def post_edit(name: str):
             for k, v in attrs.items():
                 changes.append({'kind': 'attr', 'key': k, 'old': old_attrs[k], 'new': v})
             staged['attrs'] = attrs
+        if promote:
+            tag = target.tag.split('}', 1)[1] if '}' in target.tag else target.tag
+            old_state = {
+                'tag': tag,
+                'x': target.get('x'),
+                'y': target.get('y'),
+                'dy': target.get('dy'),
+                'transform': target.get('transform'),
+            }
+            ok, reason = promote_tspan_to_text(root, element_id, promote['x'], promote['y'])
+            if not ok:
+                return jsonify({'error': f'Tspan promotion failed: {reason}'}), (
+                    404 if reason == 'not-found' else 400
+                )
+            changes.append({
+                'kind': 'structure',
+                'key': 'promote-tspan',
+                'old': old_state,
+                'new': {'tag': 'text', 'x': promote['x'], 'y': promote['y']},
+            })
+            staged['promote_tspan'] = promote
 
         staged['changes'] = changes
         pending = app.config['PENDING_EDITS'].setdefault(name, [])