codefig 0.17.0__py3-none-any.whl

codefig/render_svg.py

@@ -0,0 +1,512 @@
+"""SVG drawing helpers and document assembly."""
+
+from __future__ import annotations
+
+import math
+from typing import List, Optional, Tuple
+
+from .fills import resolve_paint
+from .styles import DEFAULT_THEME, Theme, current_theme
+from .textutil import (
+    cjk_font_family_css,
+    contains_cjk,
+    expand_subscripts,
+    has_math_markup,
+    latin_font_family_css,
+    needs_script_split,
+    sym_font_family_css,
+    math_lines,
+    script_runs,
+    xml_escape,
+    has_rich_markup,
+    parse_rich,
+    run_width,
+    run_widths,
+)
+
+
+def _opacity_attrs(opacity: float) -> str:
+    if opacity >= 0.999:
+        return ""
+    return f' opacity="{opacity:.3f}"'
+
+
+def _dash_attr(dasharray: Optional[str]) -> str:
+    if not dasharray:
+        return ""
+    return f' stroke-dasharray="{dasharray}"'
+
+
+def draw_rect(
+    buf: List[str],
+    x: float,
+    y: float,
+    w: float,
+    h: float,
+    *,
+    fill: str = "#fff",
+    stroke: str = "#111",
+    stroke_width: float = 2.0,
+    radius: float = 0.0,
+    opacity: float = 1.0,
+    dasharray: Optional[str] = None,
+) -> None:
+    r_attr = f' rx="{radius}" ry="{radius}"' if radius else ""
+    fill = resolve_paint(buf, fill)
+    buf.append(
+        f'<rect x="{x:.2f}" y="{y:.2f}" width="{w:.2f}" height="{h:.2f}"'
+        f' fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"'
+        f"{r_attr}{_dash_attr(dasharray)}{_opacity_attrs(opacity)} />"
+    )
+
+
+def draw_line(
+    buf: List[str],
+    x1: float,
+    y1: float,
+    x2: float,
+    y2: float,
+    *,
+    stroke: str = "#111",
+    stroke_width: float = 2.0,
+    opacity: float = 1.0,
+    dasharray: Optional[str] = None,
+    marker_end: bool = False,
+    marker_start: bool = False,
+) -> None:
+    me = ' marker-end="url(#arrowhead)"' if marker_end else ""
+    ms = ' marker-start="url(#arrowhead-start)"' if marker_start else ""
+    buf.append(
+        f'<line x1="{x1:.2f}" y1="{y1:.2f}" x2="{x2:.2f}" y2="{y2:.2f}"'
+        f' stroke="{stroke}" stroke-width="{stroke_width}"'
+        f"{_dash_attr(dasharray)}{_opacity_attrs(opacity)}{me}{ms} />"
+    )
+
+
+
+def draw_circle(
+    buf: List[str],
+    cx: float,
+    cy: float,
+    r: float,
+    *,
+    fill: str = "#888",
+    stroke: str = "none",
+    stroke_width: float = 0.0,
+    opacity: float = 1.0,
+    dasharray: Optional[str] = None,
+) -> None:
+    fill = resolve_paint(buf, fill)
+    buf.append(
+        f'<circle cx="{cx:.2f}" cy="{cy:.2f}" r="{r:.2f}"'
+        f' fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"'
+        f"{_dash_attr(dasharray)}{_opacity_attrs(opacity)} />"
+    )
+
+
+def draw_ellipse(
+    buf: List[str],
+    cx: float,
+    cy: float,
+    rx: float,
+    ry: float,
+    *,
+    fill: str = "none",
+    stroke: str = "#111",
+    stroke_width: float = 2.0,
+    opacity: float = 1.0,
+    dasharray: Optional[str] = None,
+) -> None:
+    fill = resolve_paint(buf, fill)
+    buf.append(
+        f'<ellipse cx="{cx:.2f}" cy="{cy:.2f}" rx="{rx:.2f}" ry="{ry:.2f}"'
+        f' fill="{fill}" stroke="{stroke}" stroke-width="{stroke_width}"'
+        f"{_dash_attr(dasharray)}{_opacity_attrs(opacity)} />"
+    )
+
+
+def draw_path(
+    buf: List[str],
+    d: str,
+    *,
+    fill: str = "none",
+    stroke: str = "#111",
+    stroke_width: float = 2.0,
+    opacity: float = 1.0,
+    dasharray: Optional[str] = None,
+    marker_end: bool = False,
+    marker_start: bool = False,
+    fill_rule: Optional[str] = None,
+) -> None:
+    me = ' marker-end="url(#arrowhead)"' if marker_end else ""
+    ms = ' marker-start="url(#arrowhead-start)"' if marker_start else ""
+    fr = f' fill-rule="{fill_rule}"' if fill_rule else ""
+    fill = resolve_paint(buf, fill)
+    buf.append(
+        f'<path d="{d}" fill="{fill}"{fr} stroke="{stroke}"'
+        f' stroke-width="{stroke_width}" stroke-linejoin="round" stroke-linecap="round"'
+        f"{_dash_attr(dasharray)}{_opacity_attrs(opacity)}{me}{ms} />"
+    )
+
+
+def draw_arrowhead(
+    buf: List[str],
+    x: float,
+    y: float,
+    angle: float,
+    *,
+    size: float = 8.0,
+    color: str = "#111",
+    opacity: float = 1.0,
+    shape: str = "triangle",
+    length: Optional[float] = None,
+    width: Optional[float] = None,
+    hollow: bool = False,
+    fill: str = "#ffffff",
+    stroke_width: float = 1.2,
+) -> None:
+    """Draw an oriented arrowhead whose tip is at (x, y).
+
+    ``angle`` (radians) is the travel direction. Shapes: triangle, stealth, vee,
+    open (= hollow triangle), circle, diamond, bar, square, none.
+    """
+    if shape == "open":
+        shape, hollow = "triangle", True
+    L = float(length if length is not None else size)
+    W = float(width if width is not None else 0.9 * size)
+    if shape == "none" or L <= 0:
+        return
+    c, s = math.cos(angle), math.sin(angle)
+
+    def P(back: float, side: float) -> str:  # local frame → page
+        return f"{x - c * back - s * side:.2f},{y - s * back + c * side:.2f}"
+
+    op = _opacity_attrs(opacity)
+    floor = current_theme().edge_min_stroke
+    sw = max(floor, stroke_width)
+    if hollow:
+        paint = f'fill="{fill}" stroke="{color}" stroke-width="{sw:.2f}" stroke-linejoin="miter"'
+        inset = sw / 2  # keep the outline's outer edge on the tip
+    else:
+        paint = 'fill="' + color + '" stroke="none"'
+        inset = 0.0
+    hw = W / 2
+    if shape == "circle":
+        r = L / 2 - inset
+        cx, cy = x - c * L / 2, y - s * L / 2
+        buf.append(f'<circle cx="{cx:.2f}" cy="{cy:.2f}" r="{r:.2f}" {paint}{op} />')
+        return
+    if shape == "bar":
+        buf.append(
+            f'<path d="M {P(sw / 2, -hw)} L {P(sw / 2, hw)}" fill="none" stroke="{color}" '
+            f'stroke-width="{max(sw, floor * 1.75):.2f}" stroke-linecap="butt"{op} />'
+        )
+        return
+    if shape == "vee":
+        buf.append(
+            f'<path d="M {P(L, -hw)} L {P(0, 0)} L {P(L, hw)}" fill="none" stroke="{color}" '
+            f'stroke-width="{max(sw, floor * 1.6):.2f}" stroke-linejoin="miter" stroke-linecap="round"{op} />'
+        )
+        return
+    if shape == "diamond":
+        pts = [P(inset, 0), P(L / 2, -hw), P(L - inset, 0), P(L / 2, hw)]
+    elif shape == "square":
+        pts = [P(inset, -hw + inset), P(L - inset, -hw + inset), P(L - inset, hw - inset),
+               P(inset, hw - inset)]
+    elif shape == "stealth":
+        pts = [P(inset, 0), P(L, -hw), P(L * 0.62, 0), P(L, hw)]
+    else:  # triangle
+        pts = [P(inset * 2, 0), P(L, -hw + inset), P(L, hw - inset)]
+    buf.append(f'<polygon points="{" ".join(pts)}" {paint}{op} />')
+
+
+def draw_head(buf: List[str], x: float, y: float, angle: float, head, *, color: str,
+              opacity: float = 1.0, stroke_width: float = 1.2) -> None:
+    """Draw a :class:`~codefig.styles.ResolvedHead`."""
+    if head is None or not head.visible:
+        return
+    draw_arrowhead(buf, x, y, angle, size=head.length, length=head.length, width=head.width,
+                   shape=head.shape, hollow=head.hollow, fill=head.fill, color=color,
+                   opacity=opacity, stroke_width=stroke_width)
+
+
+def draw_mark(buf: List[str], kind: str, cx: float, cy: float, size: float, *,
+              color: str = "#111", stroke_width: Optional[float] = None) -> None:
+    """Vector cell marks (font independent): check | cross | dot | circle | dash."""
+    s = size / 2
+    th = current_theme()
+    sw = stroke_width if stroke_width is not None else (
+        max(1.2, size * 0.16) if th.unit == 1.0 else th.edge_width)
+    if kind == "check":
+        d = f"M {cx - s * 0.8:.2f},{cy + s * 0.05:.2f} L {cx - s * 0.2:.2f},{cy + s * 0.65:.2f} L {cx + s * 0.85:.2f},{cy - s * 0.65:.2f}"
+    elif kind == "cross":
+        d = (f"M {cx - s * 0.6:.2f},{cy - s * 0.6:.2f} L {cx + s * 0.6:.2f},{cy + s * 0.6:.2f} "
+             f"M {cx + s * 0.6:.2f},{cy - s * 0.6:.2f} L {cx - s * 0.6:.2f},{cy + s * 0.6:.2f}")
+    elif kind == "dash":
+        d = f"M {cx - s * 0.6:.2f},{cy:.2f} L {cx + s * 0.6:.2f},{cy:.2f}"
+    elif kind == "dot":
+        buf.append(f'<circle cx="{cx:.2f}" cy="{cy:.2f}" r="{s * 0.38:.2f}" fill="{color}" />')
+        return
+    elif kind == "circle":
+        buf.append(f'<circle cx="{cx:.2f}" cy="{cy:.2f}" r="{s * 0.55:.2f}" fill="none" '
+                   f'stroke="{color}" stroke-width="{sw:.2f}" />')
+        return
+    else:
+        raise ValueError(f"unknown mark {kind!r}; use check|cross|dot|circle|dash")
+    buf.append(f'<path d="{d}" fill="none" stroke="{color}" stroke-width="{sw:.2f}" '
+               f'stroke-linecap="round" stroke-linejoin="round" />')
+
+
+def angle_of(x1: float, y1: float, x2: float, y2: float) -> float:
+    return math.atan2(y2 - y1, x2 - x1)
+
+
+def _script_inner(text: str, *, mono: bool, force_family: Optional[str] = None) -> str:
+    """Wrap mixed Latin/CJK runs in per-script font-family tspans."""
+    if force_family is not None or not needs_script_split(text):
+        return xml_escape(text)
+    latin = latin_font_family_css(mono)
+    cjk = cjk_font_family_css()
+    sym = sym_font_family_css()
+    parts = []
+    for script, run in script_runs(text):
+        fam = cjk if script == "cjk" else sym if script == "sym" else latin
+        parts.append(f'<tspan font-family="{fam}">{xml_escape(run)}</tspan>')
+    return "".join(parts)
+
+
+# v0.13.0: scripts are positioned with explicit dy / y offsets instead of
+# ``baseline-shift`` (cairosvg — PNG / PDF export — and several viewers ignore it, so
+# P_1 rendered as "P1").  Offsets are fractions of the *base* font size.
+SUB_SHIFT = 0.24
+SUPER_SHIFT = 0.38
+
+
+def script_offset(kind: str, font_size: float) -> float:
+    """Vertical offset (SVG y grows down) of a ``sub`` / ``super`` run for body text
+    of ``font_size``; 0 for ordinary runs."""
+    if kind == "sub":
+        return SUB_SHIFT * font_size
+    if kind == "super":
+        return -SUPER_SHIFT * font_size
+    return 0.0
+
+
+def _tspan_math(segs, font_size: float, *, mono: bool = False, start: float = 0.0) -> Tuple[str, float]:
+    """Emit tspan markup for one line of math segments (with script runs).
+
+    Every segment is its own tspan with a relative ``dy`` so the pen returns to the
+    baseline after a script. Returns ``(markup, offset at the end of the line)``."""
+    from .textutil import _plain_line_width
+
+    parts = []
+    sub_fs = current_theme().script_size(font_size)
+    cur = start
+    segs = [(k, b) for k, b in segs if b]
+    pend_dx = 0.0  # pen correction after a stacked sub/super pair
+    i = 0
+    while i < len(segs):
+        kind, body = segs[i]
+        inner = _script_inner(body, mono=mono)
+        off = script_offset(kind, font_size)
+        dy = off - cur
+        cur = off
+        attrs = ""
+        if abs(pend_dx) > 1e-6:
+            attrs += f' dx="{pend_dx:.2f}"'
+            pend_dx = 0.0
+        if abs(dy) > 1e-6:
+            attrs += f' dy="{dy:.2f}"'
+        if kind in ("sub", "super"):
+            attrs += f' font-size="{sub_fs:.2f}"'
+        parts.append(f'<tspan{attrs}>{inner}</tspan>')
+        nxt = segs[i + 1] if i + 1 < len(segs) else None
+        if nxt is not None and {kind, nxt[0]} == {"sub", "super"}:
+            # stack the pair: back up over the first script, then skip past the wider
+            w1 = _plain_line_width(body, sub_fs, mono, False)
+            w2 = _plain_line_width(nxt[1], sub_fs, mono, False)
+            off2 = script_offset(nxt[0], font_size)
+            parts.append(f'<tspan dx="{-w1:.2f}" dy="{off2 - cur:.2f}" font-size="{sub_fs:.2f}">'
+                         f'{_script_inner(nxt[1], mono=mono)}</tspan>')
+            cur = off2
+            pend_dx = max(0.0, w1 - w2)
+            i += 2
+            continue
+        i += 1
+    return "".join(parts), cur
+
+
+def draw_text(
+    buf: List[str],
+    text: str,
+    x: float,
+    y: float,
+    *,
+    font_size: Optional[float] = None,
+    fill: Optional[str] = None,
+    weight: str = "normal",
+    mono: bool = False,
+    family: Optional[str] = None,
+    anchor: str = "start",
+    opacity: float = 1.0,
+    italic: bool = False,
+) -> None:
+    th = current_theme()
+    font_size = th.snap(th.font_size if font_size is None else font_size)
+    if fill is None:
+        fill = th.text_color
+    if has_rich_markup(text):
+        _draw_rich_text(buf, text, x, y, font_size=font_size, fill=fill, weight=weight,
+                        mono=mono, family=family, anchor=anchor, opacity=opacity, italic=italic)
+        return
+    if italic:
+        sub: List[str] = []
+        draw_text(sub, text, x, y, font_size=font_size, fill=fill, weight=weight, mono=mono,
+                  family=family, anchor=anchor, opacity=opacity)
+        buf.append("".join(sub).replace("<text ", '<text font-style="italic" ', 1))
+        return
+    # Default outer family: Latin stack; CJK runs get their own tspan family.
+    if family is None:
+        if mono:
+            fam = th.mono_family
+        else:
+            fam = latin_font_family_css(False)
+    else:
+        fam = family
+    op = _opacity_attrs(opacity)
+    use_math = has_math_markup(text)
+    force = family  # if caller forced a family, don't split scripts
+
+    def line_inner(raw: str) -> str:
+        if force is not None:
+            return xml_escape(raw)
+        return _script_inner(raw, mono=mono)
+
+    if use_math:
+        lines = math_lines(text)
+        buf.append(
+            f'<text x="{x:.2f}" y="{y:.2f}" font-size="{font_size}" '
+            f'font-family="{fam}" font-weight="{weight}" fill="{fill}" '
+            f'text-anchor="{anchor}"{op}>'
+        )
+        if len(lines) == 1:
+            buf.append(_tspan_math(lines[0], font_size, mono=mono)[0])
+        else:
+            for i, segs in enumerate(lines):
+                inner, _ = _tspan_math(segs, font_size, mono=mono)
+                buf.append(f'<tspan x="{x:.2f}" y="{y + i * font_size * 1.25:.2f}">{inner}</tspan>')
+        buf.append("</text>")
+        return
+
+    plain = expand_subscripts(text)
+    lines = plain.split("\n")
+    buf.append(
+        f'<text x="{x:.2f}" y="{y:.2f}" font-size="{font_size}" '
+        f'font-family="{fam}" font-weight="{weight}" fill="{fill}" '
+        f'text-anchor="{anchor}"{op}>'
+    )
+    if len(lines) == 1:
+        buf.append(line_inner(lines[0]))
+    else:
+        for i, line in enumerate(lines):
+            dy = 0 if i == 0 else font_size * 1.25
+            buf.append(
+                f'<tspan x="{x:.2f}" dy="{dy:.2f}">{line_inner(line)}</tspan>'
+            )
+    buf.append("</text>")
+
+
+def _draw_rich_text(buf: List[str], text: str, x: float, y: float, *, font_size: float,
+                    fill: str, weight: str, mono: bool, family: Optional[str], anchor: str,
+                    opacity: float, italic: bool) -> None:
+    """Inline-span text: one <text> per line, a <tspan> per styled run; highlight
+    backgrounds are rects measured with the same per-run font metrics."""
+    base_bold = str(weight) in ("bold", "600", "700", "800", "900")
+    th = current_theme()
+    fam = family or (th.mono_family if mono else latin_font_family_css(False))
+    mono_fam = th.mono_family
+    op = _opacity_attrs(opacity)
+    lh = font_size * 1.25
+    sub_fs = th.script_size(font_size)
+    for li, runs in enumerate(parse_rich(text)):
+        ly = y + li * lh
+        widths = run_widths(runs, font_size, mono=mono, bold=base_bold, italic=italic)
+        total = sum(widths)
+        x0 = x - (total / 2 if anchor == "middle" else total if anchor == "end" else 0.0)
+        # highlight backgrounds + underlines (behind / under the glyphs)
+        cx = x0
+        for r, w in zip(runs, widths):
+            if r.bg:
+                buf.append(f'<rect x="{cx - 1:.2f}" y="{ly - font_size * 0.86:.2f}" '
+                           f'width="{w + 2:.2f}" height="{font_size * 1.12:.2f}" rx="1.5" '
+                           f'fill="{r.bg}" stroke="none"{op} />')
+            cx += w
+        parts = []
+        cx = x0
+        for r, w in zip(runs, widths):
+            attrs = [f'x="{cx:.2f}"', f'y="{ly + script_offset(r.kind, font_size):.2f}"']
+            if r.bold and not base_bold:
+                attrs.append('font-weight="bold"')
+            if r.italic and not italic:
+                attrs.append('font-style="italic"')
+            if r.color:
+                attrs.append(f'fill="{r.color}"')
+            if r.mono and not mono:
+                attrs.append(f'font-family="{mono_fam}"')
+            if r.kind in ("sub", "super"):
+                attrs.append(f'font-size="{sub_fs:.2f}"')
+            inner = _script_inner(r.text, mono=mono or r.mono,
+                                  force_family=mono_fam if (r.mono or family) else None)
+            parts.append(f'<tspan {" ".join(attrs)}>{inner}</tspan>')
+            if r.underline:
+                buf.append(f'<line x1="{cx:.2f}" y1="{ly + font_size * 0.15:.2f}" '
+                           f'x2="{cx + w:.2f}" y2="{ly + font_size * 0.15:.2f}" '
+                           f'stroke="{r.color or fill}" stroke-width="{max(0.8, font_size / 14):.2f}"{op} />')
+            cx += w
+        if not parts:
+            continue
+        fs_attr = ' font-style="italic"' if italic else ""
+        buf.append(
+            f'<text x="{x0:.2f}" y="{ly:.2f}" font-size="{font_size}" font-family="{fam}" '
+            f'font-weight="{weight}" fill="{fill}" text-anchor="start"{fs_attr}{op} '
+            f'xml:space="preserve">' + "".join(parts) + "</text>"
+        )
+
+
+def svg_header(width: float, height: float, theme: Theme, *, units: str = "",
+               title: Optional[str] = None) -> List[str]:
+    """SVG prologue. ``units="pt"`` writes ``width="…pt"`` (physical size; the
+    viewBox stays in the same numbers, so 1 user unit = 1 pt)."""
+    # Keep legacy markers for any remaining marker-end=True callers.
+    hs = theme.edge_head_size
+    hw = hs
+    hh = hs * 0.8
+    if units:
+        size = (f'width="{width:.2f}{units}" height="{height:.2f}{units}" '
+                f'viewBox="0 0 {width:.2f} {height:.2f}"')
+    else:
+        size = (f'width="{width:.0f}" height="{height:.0f}" '
+                f'viewBox="0 0 {width:.0f} {height:.0f}"')
+    head = [
+        f'<?xml version="1.0" encoding="UTF-8"?>',
+        f'<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" {size}>',
+    ]
+    if title:
+        head.append(f"<title>{xml_escape(title)}</title>")
+    return head + [
+        "<defs>",
+        f'<marker id="arrowhead" markerWidth="{hw:.1f}" markerHeight="{hh:.1f}" '
+        f'refX="{hw * 0.9:.1f}" refY="{hh / 2:.1f}" orient="auto" markerUnits="userSpaceOnUse">',
+        f'<polygon points="0 0, {hw:.1f} {hh / 2:.1f}, 0 {hh:.1f}" fill="{theme.edge_color}" />',
+        "</marker>",
+        f'<marker id="arrowhead-start" markerWidth="{hw:.1f}" markerHeight="{hh:.1f}" '
+        f'refX="{hw * 0.1:.1f}" refY="{hh / 2:.1f}" orient="auto" markerUnits="userSpaceOnUse">',
+        f'<polygon points="{hw:.1f} 0, 0 {hh / 2:.1f}, {hw:.1f} {hh:.1f}" fill="{theme.edge_color}" />',
+        "</marker>",
+        "</defs>",
+        f'<rect width="100%" height="100%" fill="#ffffff" />',
+    ]
+
+
+def svg_footer() -> List[str]:
+    return ["</svg>"]