Function box_symbol_svg

SLiCAP/schematic/subcircuit.py:145–222

Return a standalone SVG holding a default block symbol for ``defn``. ``placement`` is the **visual** clockwise-from-top-left pin order (default: the ``.subckt`` node order). It only moves where each named pin is drawn — ``data-nodes`` stays in the fixed ``.subckt`` order, since a SLiCA

(defn: SubcktDef, placement: list | None = None,
                   extra_w: float = 0.0, extra_h: float = 0.0)

def box_symbol_svg(defn: SubcktDef, placement: list | None = None,
                   extra_w: float = 0.0, extra_h: float = 0.0) -> str:
    """Return a standalone SVG holding a default block symbol for ``defn``.

    ``placement`` is the **visual** clockwise-from-top-left pin order (default:
    the ``.subckt`` node order).  It only moves where each named pin is drawn —
    ``data-nodes`` stays in the fixed ``.subckt`` order, since a SLiCAP ``X``
    instance lists its nodes positionally against the ``.subckt`` header.  So
    reordering pins never changes the netlist, only the look.

    ``extra_w`` / ``extra_h`` grow (or, when negative, shrink) each half-dimension
    relative to the auto-fit minimum — the Place dialog's width/height +/- buttons.
    Shrinking is allowed down to an absolute floor; below the auto-fit size names
    may overlap, which is then the user's call.  The box stays on the grid.
    """
    ports     = list(defn.ports)                       # data-nodes / netlist order
    placement = list(placement) if placement else list(ports)
    n_top, n_right, n_bottom, n_left = _side_counts(len(placement))

    hw_min, hh_min = _min_half(placement)
    half_w = max(_FLOOR, hw_min + extra_w)
    half_h = max(_FLOOR, hh_min + extra_h)

    # Clockwise slots (top L→R, right T→B, bottom R→L, left B→T): each is
    # (edge_x, edge_y, node_x, node_y).  placement[i] occupies slot i.
    slots: list[tuple[float, float, float, float]] = []
    for x in _spread(n_top, half_w):
        slots.append((x, -half_h, x, -half_h - _STUB))
    for y in _spread(n_right, half_h):
        slots.append((half_w, y, half_w + _STUB, y))
    for x in reversed(_spread(n_bottom, half_w)):
        slots.append((x, half_h, x, half_h + _STUB))
    for y in reversed(_spread(n_left, half_h)):
        slots.append((-half_w, y, -half_w - _STUB, y))
    pos = {placement[i]: slots[i] for i in range(len(placement))}

    def _f(v: float) -> str:                       # tidy number formatting
        return f"{v:g}"

    # The box + pin stubs + node markers only.  The block name (model label) and
    # the pin names are drawn by ComponentItem so they stay upright under any
    # rotation/flip — never baked into the (rotating) symbol art.
    lines = [
        f'<rect x="{_f(-half_w)}" y="{_f(-half_h)}" '
        f'width="{_f(2 * half_w)}" height="{_f(2 * half_h)}" '
        f'fill="none" stroke="black" stroke-width="1"/>',
        "",
        "<!-- Pins -->",
    ]
    for port in ports:
        ex, ey, nx, ny = pos[port]
        lines.append(
            f'<line x1="{_f(ex)}" y1="{_f(ey)}" x2="{_f(nx)}" y2="{_f(ny)}" '
            f'stroke="black" stroke-width="1"/>'
        )
    lines.append("")
    for port in ports:
        _ex, _ey, nx, ny = pos[port]