1193 lines
42 KiB
TypeScript
1193 lines
42 KiB
TypeScript
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
// Copyright (C) 2026 ZiroEDA and contributors.
|
|
// Portions derived from KiCad, copyright The KiCad Developers. See NOTICE.md.
|
|
/**
|
|
* SVG_PLOTTER, the SVG 1.1 plot back-end, transcribed from
|
|
* common/plotters/SVG_plotter.cpp. It derives from PSLIKE_PLOTTER
|
|
* (PS_plotter.ts) and so from PLOTTER (plotter.ts), which carry SetColor, the
|
|
* device transform, the dash lengths, the pen wrappers, the three-point Arc and
|
|
* Text's glyph stroking, as upstream's base classes do.
|
|
*
|
|
* The plotter is an append-only text emitter with a *lazy graphics context*.
|
|
* Pen colour, brush colour and alpha, fill mode, pen width and dash style live
|
|
* in members; touching any of them only raises `m_graphics_changed`, and the
|
|
* next drawing primitive flushes it by writing `</g>\n<g style="…">`. Nothing
|
|
* is buffered or reordered, so a port has to make the same calls in the same
|
|
* order or the group balance — and hence the whole document — differs.
|
|
*
|
|
* Three things dominate byte-level fidelity.
|
|
*
|
|
* 1. Precision is per call site. Most numbers use fmt's `{:.{}f}` with
|
|
* `m_precision` (4), but *five* places use a bare `{:f}`, which is a
|
|
* hard-coded six decimals: `<rect>`'s x/y/width/height/rx, `<image>`'s x/y,
|
|
* the `translate()` of mirrored hidden text, `Text`'s `rotate()` angle, and
|
|
* the DOT/DASHDOT/DASHDOTDOT dasharrays — DASH alone uses m_precision. (The
|
|
* port spec lists only four; `rotate()` is the fifth, SVG_plotter.cpp:904.)
|
|
* A single shared formatter would quietly normalise all of them.
|
|
* 2. `fixed()` below rounds ties to even on the exact binary value, because
|
|
* that is what fmt and printf do. `Number.toFixed` rounds ties away from
|
|
* zero and drops the sign of negative zero, so it is not a drop-in.
|
|
* 3. Separators differ by element and are copied literally: PenTo writes
|
|
* `M{x} {y}` / `L{x} {y}`, PlotPoly writes `M {x},{y}`, BezierCurve writes
|
|
* `M{x},{y} C…`, Arc writes spaces. So is the stray whitespace — `<circle …
|
|
* /> \n`, `Z" /> \n`, `</g> \n</svg>\n`, the space before `</title>` and
|
|
* `</desc>`.
|
|
*
|
|
* Faithfully reproduced oddities, none of which is to be "fixed": Circle
|
|
* flushes the style *before* the thin-circle branch switches to FILLED_SHAPE,
|
|
* so the enlarged circle comes out stroked and hollow and the fill state leaks
|
|
* to the next primitive; PlotPoly hands setSVGPlotStyle the raw `aWidth`, so a
|
|
* caller passing a sentinel gets `stroke:none`; PlotPoly asks for a non-group
|
|
* style, which does *not* clear the dirty flag, so the next primitive re-emits
|
|
* one; a hatch fill still emits `fill:#RRGGBB` and is only overridden by the
|
|
* `fill:none` appended after it in CSS source order; `Arc` with a non-positive
|
|
* radius passes the *width* where Circle expects a *diameter*; `flg_sweep` is
|
|
* hard-coded to 0; emitSetRGBColor truncates `255*channel` rather than
|
|
* rounding; StartLayer/EndLayer have no caller anywhere in KiCad and do not
|
|
* escape the layer name; and KiCad's base64 encoder emits no `=` padding, so
|
|
* the `<image>` data URI is unpadded.
|
|
*
|
|
* Deliberate gaps, each modelled as an injected dependency rather than
|
|
* approximated: the font (PLOTTER's `PLOTTER_FONT`, standing in for
|
|
* KIFONT::FONT; SVG needs its `GRTextWidth` too) and the raster image
|
|
* (`SvgImage`, standing in for wxImage). `@{…}` expression evaluation is skipped, as is the
|
|
* outline-font polygon callback; both are noted where they would have run.
|
|
*/
|
|
|
|
import type { Vec2 } from '@ziroeda/kimath/src/math/vector2.js';
|
|
import { type EDA_ANGLE, ANGLE_180 } from '@ziroeda/kimath/src/geometry/eda_angle.js';
|
|
import { RotatePointD } from '@ziroeda/kimath/src/trigo.js';
|
|
import { GR_TEXT_H_ALIGN_T, GR_TEXT_V_ALIGN_T } from '../eda_text.js';
|
|
import type { Color4d } from '../gal/color4d.js';
|
|
import type { PlotterRenderSettings } from '../render_settings.js';
|
|
import {
|
|
DO_NOT_SET_LINE_WIDTH,
|
|
FILL_T,
|
|
LINE_STYLE,
|
|
PLOT_FORMAT,
|
|
PLOT_TEXT_MODE,
|
|
type PLOTTER_FONT,
|
|
type PLOTTER_TEXT_ATTRIBUTES,
|
|
type PEN_PLUME,
|
|
toVector2I,
|
|
USE_DEFAULT_LINE_WIDTH,
|
|
} from './plotter.js';
|
|
import { PSLIKE_PLOTTER } from './PS_plotter.js';
|
|
|
|
/**
|
|
* `wxImage`, reduced to what PlotImage uses. `SaveFilePng` is
|
|
* `SaveFile(stream, wxBITMAP_TYPE_PNG)`; the greyscale conversion is a separate
|
|
* call because upstream re-encodes a *converted* image, so the two paths do not
|
|
* share bytes.
|
|
*/
|
|
export interface SvgImage {
|
|
GetWidth(): number;
|
|
GetHeight(): number;
|
|
SaveFilePng(): Uint8Array;
|
|
ConvertToGreyscale(): SvgImage;
|
|
}
|
|
|
|
// ===========================================================================
|
|
// Number formatting
|
|
// ===========================================================================
|
|
|
|
import { fixed } from './fmt.js';
|
|
|
|
/** fmt's bare `{:f}`: a hard-coded six decimals, whatever m_precision says. */
|
|
export const DEFAULT_FMT_PRECISION = 6;
|
|
|
|
/** fmt's `{:06X}`: uppercase hex, zero-padded to at least six digits. */
|
|
export function hex6(aValue: number): string {
|
|
return (aValue >>> 0).toString(16).toUpperCase().padStart(6, '0');
|
|
}
|
|
|
|
// ===========================================================================
|
|
// Free functions
|
|
// ===========================================================================
|
|
|
|
/**
|
|
* `XmlEsc` (SVG_plotter.cpp:109). Carriage return is escaped in *both* modes,
|
|
* which is why it sits above the isAttribute switch; the apostrophe is escaped
|
|
* in neither. Every call from the SVG plotter leaves isAttribute false, so the
|
|
* quote/tab/newline arm is unreachable from here — it is ported because the
|
|
* function is the unit, not the call site.
|
|
*/
|
|
export function XmlEsc(aStr: string, aIsAttribute = false): string {
|
|
let escaped = '';
|
|
|
|
for (const c of aStr) {
|
|
switch (c) {
|
|
case '<':
|
|
escaped += '<';
|
|
break;
|
|
case '>':
|
|
escaped += '>';
|
|
break;
|
|
case '&':
|
|
escaped += '&';
|
|
break;
|
|
case '\r':
|
|
escaped += '
';
|
|
break;
|
|
default:
|
|
if (aIsAttribute) {
|
|
switch (c) {
|
|
case '"':
|
|
escaped += '"';
|
|
break;
|
|
case '\t':
|
|
escaped += '	';
|
|
break;
|
|
case '\n':
|
|
escaped += '
';
|
|
break;
|
|
default:
|
|
escaped += c;
|
|
}
|
|
} else {
|
|
escaped += c;
|
|
}
|
|
}
|
|
}
|
|
|
|
return escaped;
|
|
}
|
|
|
|
const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
|
|
|
/**
|
|
* `base64::encode` (libs/core/base64.cpp). KiCad's encoder emits **no `=`
|
|
* padding** — encode_length works out to 2 or 3 characters for a 1- or 2-byte
|
|
* tail — so the `<image>` data URI in a KiCad SVG is unpadded base64. `btoa`
|
|
* pads, so it cannot be used here.
|
|
*/
|
|
export function base64Encode(aInput: Uint8Array): string {
|
|
const end = Math.trunc(aInput.length / 3) * 3;
|
|
let out = '';
|
|
|
|
for (let i = 0; i < end; i += 3) {
|
|
const value = (aInput[i]! << 16) | (aInput[i + 1]! << 8) | aInput[i + 2]!;
|
|
|
|
out += BASE64_ALPHABET[(value >> 18) & 0x3f];
|
|
out += BASE64_ALPHABET[(value >> 12) & 0x3f];
|
|
out += BASE64_ALPHABET[(value >> 6) & 0x3f];
|
|
out += BASE64_ALPHABET[value & 0x3f];
|
|
}
|
|
|
|
const remainder = aInput.length - end;
|
|
|
|
if (remainder) {
|
|
let value = aInput[end]!;
|
|
|
|
if (remainder === 2) {
|
|
value = (value << 10) | (aInput[end + 1]! << 2);
|
|
out += BASE64_ALPHABET[(value >> 12) & 0x3f];
|
|
} else {
|
|
value <<= 4;
|
|
}
|
|
|
|
out += BASE64_ALPHABET[(value >> 6) & 0x3f];
|
|
out += BASE64_ALPHABET[value & 0x3f];
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* `GetISO8601CurrentDateTime` (string_utils.cpp:815), i.e.
|
|
* `wxDateTime::Now().FormatISOCombined('T')` — *local* time, second precision,
|
|
* no zone suffix.
|
|
*/
|
|
export function GetISO8601CurrentDateTime(aNow: Date = new Date()): string {
|
|
const pad = (aValue: number, aWidth = 2): string => String(aValue).padStart(aWidth, '0');
|
|
|
|
return (
|
|
`${pad(aNow.getFullYear(), 4)}-${pad(aNow.getMonth() + 1)}-${pad(aNow.getDate())}` +
|
|
`T${pad(aNow.getHours())}:${pad(aNow.getMinutes())}:${pad(aNow.getSeconds())}`
|
|
);
|
|
}
|
|
|
|
/** `wxFileName( … ).GetFullName()`: the last path component, separator agnostic. */
|
|
function fullName(aPath: string): string {
|
|
const cut = Math.max(aPath.lastIndexOf('/'), aPath.lastIndexOf('\\'));
|
|
return cut < 0 ? aPath : aPath.slice(cut + 1);
|
|
}
|
|
|
|
/**
|
|
* `SVG_PLOTTER` (include/plotters/plotters_pslike.h,
|
|
* common/plotters/SVG_plotter.cpp).
|
|
*
|
|
* Drive it exactly as upstream does: OpenFile / SetCreator / SetPageSettings /
|
|
* SetColorMode / SetViewport, then StartPlot, then geometry, then EndPlot, and
|
|
* read the document back with `text()`. Write it to disk as UTF-8 — every
|
|
* string that reaches the file goes through upstream's TO_UTF8.
|
|
*/
|
|
export class SVG_PLOTTER extends PSLIKE_PLOTTER {
|
|
// ---- SVG_PLOTTER state ---------------------------------------------------
|
|
private m_fillMode: FILL_T = FILL_T.NO_FILL;
|
|
private m_pen_rgb_color = 0;
|
|
private m_brush_rgb_color = 0;
|
|
private m_brush_alpha = 1.0;
|
|
private m_graphics_changed = true;
|
|
private m_dashed: LINE_STYLE = LINE_STYLE.SOLID;
|
|
private m_precision = 4;
|
|
|
|
/** The emitted document. UTF-8 on the way to disk, a JS string in memory. */
|
|
private out = '';
|
|
|
|
constructor(aRenderSettings: PlotterRenderSettings | null = null) {
|
|
super();
|
|
this.m_renderSettings = aRenderSettings;
|
|
|
|
// SVG_PLOTTER's constructor body, in order. PSLIKE_PLOTTER's m_textMode
|
|
// is set here and never read again.
|
|
this.m_graphics_changed = true;
|
|
this.SetTextMode(PLOT_TEXT_MODE.STROKE);
|
|
this.m_fillMode = FILL_T.NO_FILL;
|
|
this.m_pen_rgb_color = 0;
|
|
this.m_brush_rgb_color = 0;
|
|
this.m_brush_alpha = 1.0;
|
|
this.m_dashed = LINE_STYLE.SOLID;
|
|
this.m_precision = 4;
|
|
}
|
|
|
|
static GetDefaultFileExtension(): string {
|
|
return 'svg';
|
|
}
|
|
|
|
override GetPlotterType(): PLOT_FORMAT {
|
|
return PLOT_FORMAT.SVG;
|
|
}
|
|
|
|
// =========================================================================
|
|
// Output buffer
|
|
// =========================================================================
|
|
|
|
private emit(aText: string): void {
|
|
this.out += aText;
|
|
}
|
|
|
|
/** The plotted document. */
|
|
text(): string {
|
|
return this.out;
|
|
}
|
|
|
|
/** The document as the bytes that should be written to disk. */
|
|
bytes(): Uint8Array {
|
|
return new TextEncoder().encode(this.out);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Setup
|
|
// =========================================================================
|
|
|
|
/**
|
|
* `SetViewport`. SVG is the one back-end that reverses the Y axis, and the
|
|
* paper size is computed here with *two* truncations: the mils are a VECTOR2D
|
|
* assigned into a VECTOR2I member, and each `int *= double` truncates again.
|
|
* That is why an A4 page comes out as 297.0022 mm wide in every file rather
|
|
* than 297.
|
|
*
|
|
* `iusPerMM` is derived from aIusPerDecimil alone, so for pcbnew's 2540 the
|
|
* device unit is exactly one millimetre.
|
|
*/
|
|
SetViewport(aOffset: Vec2, aIusPerDecimil: number, aScale: number, aMirror: boolean): void {
|
|
this.m_plotMirror = aMirror;
|
|
this.m_yaxisReversed = true; // unlike other plotters, SVG has Y axis reversed
|
|
this.m_plotOffset = aOffset;
|
|
this.m_plotScale = aScale;
|
|
this.m_IUsPerDecimil = aIusPerDecimil;
|
|
|
|
// Compute the paper size in IUs. for historical reasons the page size is in mils
|
|
// Two truncations, and only the first is observable. `PAGE_INFO::SetWidthMM`
|
|
// stores mils as `mm * 1000 / 25.4`, so the mils really can be fractional
|
|
// and dropping this one changes the emitted page size — a test pins it.
|
|
// The second is upstream's `int *= double`: by then the value is integral
|
|
// and every caller passes an integer `aIusPerDecimil` (pcbnew 2540,
|
|
// eeschema 100, gerbview 1000), so it can never fire. Mutation testing
|
|
// confirms it. Kept as upstream's arithmetic, not on the strength of a test.
|
|
const paperSize = toVector2I(this.PageSettings().GetSizeMils());
|
|
this.m_paperSize = {
|
|
x: Math.trunc(paperSize.x * (10.0 * aIusPerDecimil)),
|
|
y: Math.trunc(paperSize.y * (10.0 * aIusPerDecimil)),
|
|
};
|
|
|
|
const iusPerMM = (this.m_IUsPerDecimil / 2.54) * 1000;
|
|
this.m_iuPerDeviceUnit = 1 / iusPerMM;
|
|
|
|
this.SetSvgCoordinatesFormat(4);
|
|
}
|
|
|
|
/** `SetSvgCoordinatesFormat`. SVG units are always mm; only the digits move. */
|
|
override SetSvgCoordinatesFormat(aPrecision: number): void {
|
|
this.m_precision = aPrecision;
|
|
}
|
|
|
|
GetPrecision(): number {
|
|
return this.m_precision;
|
|
}
|
|
|
|
// =========================================================================
|
|
// Coordinates
|
|
// =========================================================================
|
|
|
|
// =========================================================================
|
|
// Graphics context
|
|
// =========================================================================
|
|
|
|
/** `setFillMode`. Only a *change* dirties the context. */
|
|
private setFillMode(aFill: FILL_T): void {
|
|
if (this.m_fillMode !== aFill) {
|
|
this.m_graphics_changed = true;
|
|
this.m_fillMode = aFill;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* `setSVGPlotStyle`. With aIsGroup (the default) this closes the open group
|
|
* and opens a new one, and only then is the context clean again; PlotPoly
|
|
* passes false, writes the style straight onto its own `<path>` element, and
|
|
* so leaves the context dirty for whatever comes next.
|
|
*
|
|
* The dash geometry is recomputed from *this call's* width, not from the
|
|
* width SetDash was given — SetDash discards its width argument entirely.
|
|
*/
|
|
private setSVGPlotStyle(aLineWidth: number, aIsGroup = true, aExtraStyle = ''): void {
|
|
if (aIsGroup) this.emit('</g>\n<g ');
|
|
|
|
this.emit('style="');
|
|
|
|
if (this.m_fillMode === FILL_T.NO_FILL) {
|
|
this.emit('fill:none; ');
|
|
} else {
|
|
// output the background fill color
|
|
this.emit(`fill:#${hex6(this.m_brush_rgb_color)}; `);
|
|
|
|
switch (this.m_fillMode) {
|
|
case FILL_T.FILLED_SHAPE:
|
|
case FILL_T.FILLED_WITH_BG_BODYCOLOR:
|
|
case FILL_T.FILLED_WITH_COLOR:
|
|
this.emit(`fill-opacity:${fixed(this.m_brush_alpha, this.m_precision)}; `);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
const pen_w = this.userToDeviceSize(aLineWidth);
|
|
|
|
if (pen_w <= 0) {
|
|
this.emit('stroke:none;');
|
|
} else {
|
|
// Inkscape mishandles stroke widths below 100 nm when degrouping, hence
|
|
// the four-digit cap on the mantissa.
|
|
this.emit(
|
|
`\nstroke:#${hex6(this.m_pen_rgb_color)}; ` +
|
|
`stroke-width:${fixed(pen_w, this.m_precision)}; stroke-opacity:1; \n`,
|
|
);
|
|
this.emit('stroke-linecap:round; stroke-linejoin:round;');
|
|
|
|
const p = this.m_precision;
|
|
const d = DEFAULT_FMT_PRECISION;
|
|
|
|
switch (this.m_dashed) {
|
|
case LINE_STYLE.DASH:
|
|
this.emit(
|
|
`stroke-dasharray:${fixed(this.GetDashMarkLenIU(aLineWidth), p)},` +
|
|
`${fixed(this.GetDashGapLenIU(aLineWidth), p)};`,
|
|
);
|
|
break;
|
|
|
|
// DOT and below use a bare {:f}, i.e. six decimals, not m_precision.
|
|
case LINE_STYLE.DOT:
|
|
this.emit(
|
|
`stroke-dasharray:${fixed(this.GetDotMarkLenIU(aLineWidth), d)},` +
|
|
`${fixed(this.GetDashGapLenIU(aLineWidth), d)};`,
|
|
);
|
|
break;
|
|
|
|
case LINE_STYLE.DASHDOT:
|
|
this.emit(
|
|
`stroke-dasharray:${fixed(this.GetDashMarkLenIU(aLineWidth), d)},` +
|
|
`${fixed(this.GetDashGapLenIU(aLineWidth), d)},` +
|
|
`${fixed(this.GetDotMarkLenIU(aLineWidth), d)},` +
|
|
`${fixed(this.GetDashGapLenIU(aLineWidth), d)};`,
|
|
);
|
|
break;
|
|
|
|
case LINE_STYLE.DASHDOTDOT:
|
|
this.emit(
|
|
`stroke-dasharray:${fixed(this.GetDashMarkLenIU(aLineWidth), d)},` +
|
|
`${fixed(this.GetDashGapLenIU(aLineWidth), d)},` +
|
|
`${fixed(this.GetDotMarkLenIU(aLineWidth), d)},` +
|
|
`${fixed(this.GetDashGapLenIU(aLineWidth), d)},` +
|
|
`${fixed(this.GetDotMarkLenIU(aLineWidth), d)},` +
|
|
`${fixed(this.GetDashGapLenIU(aLineWidth), d)};`,
|
|
);
|
|
break;
|
|
|
|
case LINE_STYLE.DEFAULT:
|
|
case LINE_STYLE.SOLID:
|
|
default:
|
|
// do nothing
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (aExtraStyle.length) this.emit(aExtraStyle);
|
|
|
|
this.emit('"');
|
|
|
|
if (aIsGroup) {
|
|
this.emit('>');
|
|
this.m_graphics_changed = false;
|
|
}
|
|
|
|
this.emit('\n');
|
|
}
|
|
|
|
/**
|
|
* `SetCurrentLineWidth`. DO_NOT_SET_LINE_WIDTH is an early *return*: the pen
|
|
* keeps its old value and the context is not dirtied. Width 0 is legal and
|
|
* means "filled shape with no outline", which setSVGPlotStyle renders as
|
|
* `stroke:none`.
|
|
*
|
|
* Any *other* negative width only trips a `wxASSERT_MSG`, which is compiled
|
|
* out of a release build and merely logs in a debug one — execution continues
|
|
* and the negative value is stored. Text relies on that: it hands
|
|
* SetCurrentLineWidth the raw stroke width before PLOTTER::Text takes the
|
|
* magnitude, so a caller with a negative stroke width transiently sets a
|
|
* negative pen and gets one `stroke:none` style out of it. Throwing here
|
|
* would turn a logged warning into a failed plot.
|
|
*/
|
|
SetCurrentLineWidth(aWidth: number, _aData?: unknown): void {
|
|
let width = aWidth;
|
|
|
|
if (width === DO_NOT_SET_LINE_WIDTH) return;
|
|
else if (width === USE_DEFAULT_LINE_WIDTH) width = this.renderSettings().GetDefaultPenWidth();
|
|
|
|
if (width !== this.m_currentPenWidth) {
|
|
this.m_graphics_changed = true;
|
|
this.m_currentPenWidth = width;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* `emitSetRGBColor`. The channels are *truncated*, not rounded, so r = 0.5
|
|
* gives 0x7F. Pen and brush always carry the same triple; only the brush
|
|
* carries the alpha.
|
|
*/
|
|
protected override emitSetRGBColor(r: number, g: number, b: number, a: number): void {
|
|
const red = Math.trunc(255.0 * r);
|
|
const green = Math.trunc(255.0 * g);
|
|
const blue = Math.trunc(255.0 * b);
|
|
const rgb_color = ((red << 16) | (green << 8) | blue) >>> 0;
|
|
|
|
if (this.m_pen_rgb_color !== rgb_color || this.m_brush_alpha !== a) {
|
|
this.m_graphics_changed = true;
|
|
this.m_pen_rgb_color = rgb_color;
|
|
|
|
// Currently, use the same color for brush and pen.
|
|
this.m_brush_rgb_color = rgb_color;
|
|
this.m_brush_alpha = a;
|
|
}
|
|
}
|
|
|
|
/** `SetDash`. The width argument is ignored; only a *change* dirties. */
|
|
SetDash(_aLineWidth: number, aLineStyle: LINE_STYLE): void {
|
|
if (this.m_dashed !== aLineStyle) {
|
|
this.m_graphics_changed = true;
|
|
this.m_dashed = aLineStyle;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* `StartBlock` / `EndBlock`. Deliberately empty: `<g>` is already spoken for
|
|
* by the lazy graphics context, which leaves its last group open, so a block
|
|
* cannot nest inside it.
|
|
*/
|
|
override StartBlock(_aData?: unknown): void {
|
|
// Intentionally empty, as upstream is.
|
|
}
|
|
|
|
override EndBlock(_aData?: unknown): void {
|
|
// Intentionally empty, as upstream is.
|
|
}
|
|
|
|
/**
|
|
* `StartLayer`. Flushes any pending context first so the layer group is a
|
|
* sibling of the style group rather than a child of a half-written one. The
|
|
* layer name is *not* escaped, so a name containing `&` or `"` produces
|
|
* invalid XML — upstream's behaviour, and it has no callers in the KiCad tree
|
|
* to have noticed.
|
|
*/
|
|
StartLayer(aLayerName: string): void {
|
|
if (this.m_graphics_changed) this.setSVGPlotStyle(this.GetCurrentLineWidth());
|
|
|
|
this.emit(`<g id="${aLayerName}" inkscape:label="${aLayerName}" inkscape:groupmode="layer">\n`);
|
|
}
|
|
|
|
/** `EndLayer`: closes the context group and the layer group, then dirties. */
|
|
EndLayer(): void {
|
|
this.emit('</g>\n');
|
|
this.emit('</g>\n');
|
|
this.m_graphics_changed = true; // Force new graphics context on next draw
|
|
}
|
|
|
|
// =========================================================================
|
|
// File skeleton
|
|
// =========================================================================
|
|
|
|
/**
|
|
* `StartPlot`. The header opens a `<g>` that nothing ever closes on purpose:
|
|
* m_graphics_changed is left true, so the first primitive emits `</g><g …>`
|
|
* and the balance works out to the single `</g>` EndPlot writes.
|
|
*
|
|
* `origin` is upstream's zero-initialised VECTOR2D with a "TODO set to actual
|
|
* value" beside it, so the viewBox always starts at 0 0.
|
|
*/
|
|
StartPlot(_aPageNumber = '', aNow: Date = new Date()): boolean {
|
|
const header =
|
|
'<?xml version="1.0" standalone="no"?>\n' +
|
|
' <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" \n' +
|
|
' "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> \n' +
|
|
'<svg\n' +
|
|
' xmlns:svg="http://www.w3.org/2000/svg"\n' +
|
|
' xmlns="http://www.w3.org/2000/svg"\n' +
|
|
' xmlns:xlink="http://www.w3.org/1999/xlink"\n' +
|
|
' xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"\n' +
|
|
' version="1.1"\n';
|
|
|
|
this.emit(header);
|
|
|
|
const p = this.m_precision;
|
|
const origin = { x: 0, y: 0 };
|
|
|
|
this.emit(
|
|
` width="${fixed(((this.m_paperSize.x / this.m_IUsPerDecimil) * 2.54) / 1000, p)}mm"` +
|
|
` height="${fixed(((this.m_paperSize.y / this.m_IUsPerDecimil) * 2.54) / 1000, p)}mm"` +
|
|
` viewBox="${fixed(origin.x, p)} ${fixed(origin.y, p)}` +
|
|
` ${fixed(this.m_paperSize.x * this.m_iuPerDeviceUnit, p)}` +
|
|
` ${fixed(this.m_paperSize.y * this.m_iuPerDeviceUnit, p)}">\n`,
|
|
);
|
|
|
|
const date = GetISO8601CurrentDateTime(aNow);
|
|
|
|
this.emit(
|
|
`<title>SVG Image created as ${XmlEsc(fullName(this.m_filename))} date ${date} </title>\n`,
|
|
);
|
|
|
|
this.emit(` <desc>Image generated by ${XmlEsc(this.m_creator)} </desc>\n`);
|
|
|
|
// output the pen and brush color (RVB values in hex) and opacity
|
|
const opacity = 1.0; // 0.0 (transparent) to 1.0 (solid)
|
|
|
|
this.emit(
|
|
`<g style="fill:#${hex6(this.m_brush_rgb_color)}; ` +
|
|
`fill-opacity:${fixed(this.m_brush_alpha, p)};` +
|
|
`stroke:#${hex6(this.m_pen_rgb_color)}; stroke-opacity:${fixed(opacity, p)};\n`,
|
|
);
|
|
|
|
this.emit('stroke-linecap:round; stroke-linejoin:round;"\n');
|
|
this.emit(' transform="translate(0 0) scale(1 1)">\n');
|
|
|
|
return true;
|
|
}
|
|
|
|
/** `EndPlot`. Mind the space between `</g>` and the newline. */
|
|
EndPlot(): boolean {
|
|
this.emit('</g> \n</svg>\n');
|
|
return true;
|
|
}
|
|
|
|
// =========================================================================
|
|
// Entities
|
|
// =========================================================================
|
|
|
|
/**
|
|
* `Rect`. Normalised twice — once in user space, once in device space —
|
|
* because the transform can flip the sign of an extent and Inkscape refuses a
|
|
* negative or zero width. For SVG it is the *horizontal mirror* that does the
|
|
* flipping, not Y: the reversed axis cancels the paper flip, so an unmirrored
|
|
* plot never needs the second pass and only a mirrored one shows it working.
|
|
*
|
|
* The zero test is an exact float compare on the *device* size, and a
|
|
* degenerate rectangle degrades to a `<line>` at m_precision while the real
|
|
* `<rect>` uses six decimals throughout.
|
|
*/
|
|
Rect(p1: Vec2, p2: Vec2, fill: FILL_T, width: number, aCornerRadius = 0): void {
|
|
const rect = normalizedBox(p1, { x: p2.x - p1.x, y: p2.y - p1.y });
|
|
|
|
const org_dev = this.userToDeviceCoordinates(rect.pos);
|
|
const end_dev = this.userToDeviceCoordinates({
|
|
x: rect.pos.x + rect.size.x,
|
|
y: rect.pos.y + rect.size.y,
|
|
});
|
|
const size_dev = { x: end_dev.x - org_dev.x, y: end_dev.y - org_dev.y };
|
|
|
|
const rect_dev = normalizedBox(org_dev, size_dev);
|
|
|
|
this.setFillMode(fill);
|
|
this.SetCurrentLineWidth(width);
|
|
|
|
if (this.m_graphics_changed) this.setSVGPlotStyle(this.GetCurrentLineWidth());
|
|
|
|
const p = this.m_precision;
|
|
const d = DEFAULT_FMT_PRECISION;
|
|
|
|
if (rect_dev.size.x === 0.0 || rect_dev.size.y === 0.0) {
|
|
// Rectangles with a zero side are not drawn by Inkscape, so draw a line.
|
|
this.emit(
|
|
`<line x1="${fixed(rect_dev.pos.x, p)}" y1="${fixed(rect_dev.pos.y, p)}"` +
|
|
` x2="${fixed(rect_dev.pos.x + rect_dev.size.x, p)}"` +
|
|
` y2="${fixed(rect_dev.pos.y + rect_dev.size.y, p)}" />\n`,
|
|
);
|
|
} else {
|
|
this.emit(
|
|
`<rect x="${fixed(rect_dev.pos.x, d)}" y="${fixed(rect_dev.pos.y, d)}"` +
|
|
` width="${fixed(rect_dev.size.x, d)}" height="${fixed(rect_dev.size.y, d)}"` +
|
|
` rx="${fixed(this.userToDeviceSize(aCornerRadius), d)}" />\n`,
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* `Circle`. The thin-circle branch is subtle and its subtlety is the point:
|
|
* the style is flushed *before* the branch runs, so switching to FILLED_SHAPE
|
|
* and a zero pen there changes nothing about the element being written — it
|
|
* still comes out stroked and unfilled, just with the radius grown to
|
|
* `d/2 + w/2`. Both state changes leak to the next primitive, which is where
|
|
* they finally take effect.
|
|
*/
|
|
Circle(pos: Vec2, diametre: number, fill: FILL_T, width: number): void {
|
|
const pos_dev = this.userToDeviceCoordinates(pos);
|
|
let radius = this.userToDeviceSize(diametre / 2.0);
|
|
|
|
this.setFillMode(fill);
|
|
this.SetCurrentLineWidth(width);
|
|
|
|
if (this.m_graphics_changed) this.setSVGPlotStyle(this.GetCurrentLineWidth());
|
|
|
|
// If diameter is less than width, switch to filled mode
|
|
if (fill === FILL_T.NO_FILL && diametre < this.GetCurrentLineWidth()) {
|
|
this.setFillMode(FILL_T.FILLED_SHAPE);
|
|
const w = this.GetCurrentLineWidth();
|
|
this.SetCurrentLineWidth(0);
|
|
|
|
radius = this.userToDeviceSize(diametre / 2.0 + w / 2.0);
|
|
}
|
|
|
|
const p = this.m_precision;
|
|
|
|
this.emit(
|
|
`<circle cx="${fixed(pos_dev.x, p)}" cy="${fixed(pos_dev.y, p)}" r="${fixed(radius, p)}" /> \n`,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* `Arc`. A non-positive radius is turned into a *filled circle whose diameter
|
|
* is the line width* — `Circle( aCenter, aWidth, … )` really does pass the
|
|
* width into the diameter slot.
|
|
*
|
|
* The horizontal-mirror branch swaps the angles and then reflects each about
|
|
* 180 degrees; the vertical branch negates both without swapping, which can
|
|
* leave endAngle behind startAngle. The theta normalisation below is what
|
|
* rescues that, and it is also what decides flg_arc. flg_sweep is a constant
|
|
* zero, so a clockwise arc is expressed purely through the angle ordering.
|
|
*
|
|
* A filled arc emits *two* paths: the pie wedge with a zero pen, then the
|
|
* stroked arc with no fill.
|
|
*/
|
|
override Arc(
|
|
aCenter: Vec2,
|
|
aStartAngle: EDA_ANGLE,
|
|
aAngle: EDA_ANGLE,
|
|
aRadius: number,
|
|
aFill: FILL_T,
|
|
aWidth: number,
|
|
): void {
|
|
if (aRadius <= 0) {
|
|
this.Circle(toVector2I(aCenter), aWidth, FILL_T.FILLED_SHAPE, 0);
|
|
return;
|
|
}
|
|
|
|
let startAngle = aStartAngle.negate();
|
|
let endAngle = startAngle.sub(aAngle);
|
|
|
|
if (endAngle.lt(startAngle)) [startAngle, endAngle] = [endAngle, startAngle];
|
|
|
|
const centre_device = this.userToDeviceCoordinates(toVector2I(aCenter));
|
|
const radius_device = this.userToDeviceSize(aRadius);
|
|
|
|
if (this.m_plotMirror) {
|
|
if (this.m_mirrorIsHorizontal) {
|
|
[startAngle, endAngle] = [endAngle, startAngle];
|
|
startAngle = ANGLE_180.sub(startAngle);
|
|
endAngle = ANGLE_180.sub(endAngle);
|
|
} else {
|
|
startAngle = startAngle.negate();
|
|
endAngle = endAngle.negate();
|
|
}
|
|
}
|
|
|
|
let start = { x: radius_device, y: 0 };
|
|
start = RotatePointD(start, startAngle);
|
|
let end = { x: radius_device, y: 0 };
|
|
end = RotatePointD(end, endAngle);
|
|
start = { x: start.x + centre_device.x, y: start.y + centre_device.y };
|
|
end = { x: end.x + centre_device.x, y: end.y + centre_device.y };
|
|
|
|
let theta1 = startAngle.AsRadians();
|
|
|
|
if (theta1 < 0) theta1 = theta1 + Math.PI * 2;
|
|
|
|
let theta2 = endAngle.AsRadians();
|
|
|
|
if (theta2 < 0) theta2 = theta2 + Math.PI * 2;
|
|
|
|
if (theta2 < theta1) theta2 = theta2 + Math.PI * 2;
|
|
|
|
let flg_arc = 0; // flag for large or small arc. 0 means less than 180 degrees
|
|
|
|
if (Math.abs(theta2 - theta1) > Math.PI) flg_arc = 1;
|
|
|
|
const flg_sweep = 0; // flag for sweep always 0
|
|
const p = this.m_precision;
|
|
|
|
if (aFill !== FILL_T.NO_FILL) {
|
|
// Filled arcs (in Eeschema) consist of the pie wedge and a stroke only on
|
|
// the arc, so they need two elements.
|
|
this.setFillMode(aFill);
|
|
this.SetCurrentLineWidth(0);
|
|
|
|
if (this.m_graphics_changed) this.setSVGPlotStyle(this.GetCurrentLineWidth());
|
|
|
|
this.emit(
|
|
`<path d="M${fixed(start.x, p)} ${fixed(start.y, p)}` +
|
|
` A${fixed(radius_device, p)} ${fixed(radius_device, p)} 0.0 ${flg_arc} ${flg_sweep}` +
|
|
` ${fixed(end.x, p)} ${fixed(end.y, p)}` +
|
|
` L ${fixed(centre_device.x, p)} ${fixed(centre_device.y, p)} Z" />\n`,
|
|
);
|
|
}
|
|
|
|
this.setFillMode(FILL_T.NO_FILL);
|
|
this.SetCurrentLineWidth(aWidth);
|
|
|
|
if (this.m_graphics_changed) this.setSVGPlotStyle(this.GetCurrentLineWidth());
|
|
|
|
this.emit(
|
|
`<path d="M${fixed(start.x, p)} ${fixed(start.y, p)}` +
|
|
` A${fixed(radius_device, p)} ${fixed(radius_device, p)} 0.0 ${flg_arc} ${flg_sweep}` +
|
|
` ${fixed(end.x, p)} ${fixed(end.y, p)}" />\n`,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* `BezierCurve`. Upstream keeps the flattening fallback behind an `#if 1`, so
|
|
* aTolerance is dead and a real cubic goes out; the `C` command takes three
|
|
* points because the current point is the start.
|
|
*/
|
|
override BezierCurve(
|
|
aStart: Vec2,
|
|
aControl1: Vec2,
|
|
aControl2: Vec2,
|
|
aEnd: Vec2,
|
|
_aTolerance: number,
|
|
aLineThickness: number,
|
|
): void {
|
|
this.setFillMode(FILL_T.NO_FILL);
|
|
this.SetCurrentLineWidth(aLineThickness);
|
|
|
|
if (this.m_graphics_changed) this.setSVGPlotStyle(this.GetCurrentLineWidth());
|
|
|
|
const start = this.userToDeviceCoordinates(aStart);
|
|
const ctrl1 = this.userToDeviceCoordinates(aControl1);
|
|
const ctrl2 = this.userToDeviceCoordinates(aControl2);
|
|
const end = this.userToDeviceCoordinates(aEnd);
|
|
const p = this.m_precision;
|
|
|
|
this.emit(
|
|
`<path d="M${fixed(start.x, p)},${fixed(start.y, p)}` +
|
|
` C${fixed(ctrl1.x, p)},${fixed(ctrl1.y, p)}` +
|
|
` ${fixed(ctrl2.x, p)},${fixed(ctrl2.y, p)}` +
|
|
` ${fixed(end.x, p)},${fixed(end.y, p)}" />\n`,
|
|
);
|
|
}
|
|
|
|
/**
|
|
* `PlotPoly( const std::vector<VECTOR2I>& )`. Three things here look wrong and
|
|
* are not: the style is emitted with the *raw* aWidth, so a caller passing a
|
|
* sentinel gets `stroke:none` even though the pen was set correctly; it asks
|
|
* for a non-group style, which leaves the context dirty so the next primitive
|
|
* still opens a group; and the vertex loop stops one short of the end, the
|
|
* last point being either replaced by `Z` (on an exact integer match with the
|
|
* first) or written after the loop.
|
|
*
|
|
* A hatch fill still calls setFillMode, so the style opens with
|
|
* `fill:#RRGGBB` and is only countermanded by the `fill:none` appended after
|
|
* it — CSS source order is doing the work.
|
|
*/
|
|
PlotPoly(aCornerList: readonly Vec2[], aFill: FILL_T, aWidth: number, _aData?: unknown): void {
|
|
if (aCornerList.length <= 1) return;
|
|
|
|
this.setFillMode(aFill);
|
|
this.SetCurrentLineWidth(aWidth);
|
|
this.emit('<path ');
|
|
|
|
switch (aFill) {
|
|
case FILL_T.NO_FILL:
|
|
case FILL_T.HATCH:
|
|
case FILL_T.REVERSE_HATCH:
|
|
case FILL_T.CROSS_HATCH:
|
|
this.setSVGPlotStyle(aWidth, false, 'fill:none');
|
|
break;
|
|
|
|
case FILL_T.FILLED_WITH_BG_BODYCOLOR:
|
|
case FILL_T.FILLED_SHAPE:
|
|
case FILL_T.FILLED_WITH_COLOR:
|
|
this.setSVGPlotStyle(aWidth, false, 'fill-rule:evenodd;');
|
|
break;
|
|
}
|
|
|
|
const p = this.m_precision;
|
|
let pos = this.userToDeviceCoordinates(aCornerList[0]!);
|
|
this.emit(`d="M ${fixed(pos.x, p)},${fixed(pos.y, p)}\n`);
|
|
|
|
for (let ii = 1; ii < aCornerList.length - 1; ii++) {
|
|
pos = this.userToDeviceCoordinates(aCornerList[ii]!);
|
|
this.emit(`${fixed(pos.x, p)},${fixed(pos.y, p)}\n`);
|
|
}
|
|
|
|
const first = aCornerList[0]!;
|
|
const last = aCornerList[aCornerList.length - 1]!;
|
|
|
|
// If the corner list ends where it begins, then close the poly
|
|
if (first.x === last.x && first.y === last.y) {
|
|
this.emit('Z" /> \n');
|
|
} else {
|
|
pos = this.userToDeviceCoordinates(last);
|
|
this.emit(`${fixed(pos.x, p)},${fixed(pos.y, p)}\n" /> \n`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* `PlotImage`. The start corner is computed in *doubles* and then truncated
|
|
* into a VECTOR2I, which is not the same as the base class's integer halving
|
|
* — see plotterPlotImage below, which the degenerate branch falls back to.
|
|
*
|
|
* The x/y of the `<image>` use six decimals while its width/height use
|
|
* m_precision, and the base64 payload is broken with a newline after every
|
|
* 64th character (i.e. after index 63, 127, …). The element is left without a
|
|
* trailing newline, exactly as upstream leaves it.
|
|
*/
|
|
override PlotImage(aImage: SvgImage, aPos: Vec2, aScaleFactor: number): void {
|
|
const pix_size = { x: aImage.GetWidth(), y: aImage.GetHeight() };
|
|
|
|
// Requested size (in IUs)
|
|
const drawsize = {
|
|
x: aScaleFactor * pix_size.x,
|
|
y: aScaleFactor * pix_size.y,
|
|
};
|
|
|
|
// calculate the bitmap start position
|
|
const start = toVector2I({
|
|
x: aPos.x - drawsize.x / 2,
|
|
y: aPos.y - drawsize.y / 2,
|
|
});
|
|
|
|
if (drawsize.x === 0.0 || drawsize.y === 0.0) {
|
|
// Rectangles with a zero side are not drawn by Inkscape, so draw a line.
|
|
this.plotterPlotImage(aImage, aPos, aScaleFactor);
|
|
} else {
|
|
const png = this.m_colorMode
|
|
? aImage.SaveFilePng()
|
|
: aImage.ConvertToGreyscale().SaveFilePng();
|
|
|
|
const encoded = base64Encode(png);
|
|
|
|
const pos = this.userToDeviceCoordinates(start);
|
|
const d = DEFAULT_FMT_PRECISION;
|
|
|
|
this.emit(
|
|
`<image x="${fixed(pos.x, d)}" y="${fixed(pos.y, d)}" xlink:href="data:image/png;base64,`,
|
|
);
|
|
|
|
for (let i = 0; i < encoded.length; i++) {
|
|
this.emit(encoded[i]!);
|
|
|
|
if (i % 64 === 63) this.emit('\n');
|
|
}
|
|
|
|
const p = this.m_precision;
|
|
|
|
this.emit(
|
|
`"\npreserveAspectRatio="none"` +
|
|
` width="${fixed(this.userToDeviceSize(drawsize.x), p)}"` +
|
|
` height="${fixed(this.userToDeviceSize(drawsize.y), p)}" />`,
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* `PLOTTER::PlotImage`, the degenerate fallback: an outline rectangle at the
|
|
* default pen width. Its halving is *integer* division on an already
|
|
* truncated size, so it can land one IU away from the override's corner.
|
|
*/
|
|
private plotterPlotImage(aImage: SvgImage, aPos: Vec2, aScaleFactor: number): void {
|
|
const size = toVector2I({
|
|
x: aImage.GetWidth() * aScaleFactor,
|
|
y: aImage.GetHeight() * aScaleFactor,
|
|
});
|
|
|
|
const start = {
|
|
x: aPos.x - Math.trunc(size.x / 2),
|
|
y: aPos.y - Math.trunc(size.y / 2),
|
|
};
|
|
const end = { x: start.x + size.x, y: start.y + size.y };
|
|
|
|
this.Rect(start, end, FILL_T.NO_FILL, USE_DEFAULT_LINE_WIDTH, 0);
|
|
}
|
|
|
|
// =========================================================================
|
|
// Pen
|
|
// =========================================================================
|
|
|
|
/**
|
|
* `PenTo`. There is no mid-path moveto: once a path is open a 'U' plume emits
|
|
* an `L`, exactly like a 'D' would, so two disjoint polylines need an explicit
|
|
* PenFinish between them. 'Z' closes the element and parks the pen at
|
|
* (-1,-1), which is what makes the *next* 'U' open a fresh path.
|
|
*
|
|
* Opening a path forces NO_FILL first — an open contour must not be filled —
|
|
* and that fill change is what dirties the context, so the style group is
|
|
* emitted before the `<path>` rather than after.
|
|
*/
|
|
PenTo(pos: Vec2, plume: PEN_PLUME): void {
|
|
const p = this.m_precision;
|
|
|
|
if (plume === 'Z') {
|
|
if (this.m_penState !== 'Z') {
|
|
this.emit('" />\n');
|
|
this.m_penState = 'Z';
|
|
this.m_penLastpos = { x: -1, y: -1 };
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (this.m_penState === 'Z') {
|
|
// here plume = 'D' or 'U'
|
|
const pos_dev = this.userToDeviceCoordinates(pos);
|
|
|
|
// Ensure we do not use a fill mode when moving the pen: in SVG mode we
|
|
// are plotting only basic lines, not a filled area.
|
|
if (this.m_fillMode !== FILL_T.NO_FILL) this.setFillMode(FILL_T.NO_FILL);
|
|
|
|
if (this.m_graphics_changed) this.setSVGPlotStyle(this.GetCurrentLineWidth());
|
|
|
|
this.emit(`<path d="M${fixed(pos_dev.x, p)} ${fixed(pos_dev.y, p)}\n`);
|
|
} else if (
|
|
this.m_penState !== plume ||
|
|
pos.x !== this.m_penLastpos.x ||
|
|
pos.y !== this.m_penLastpos.y
|
|
) {
|
|
if (this.m_graphics_changed) this.setSVGPlotStyle(this.GetCurrentLineWidth());
|
|
|
|
const pos_dev = this.userToDeviceCoordinates(pos);
|
|
|
|
this.emit(`L${fixed(pos_dev.x, p)} ${fixed(pos_dev.y, p)}\n`);
|
|
}
|
|
|
|
this.m_penState = plume;
|
|
this.m_penLastpos = { x: pos.x, y: pos.y };
|
|
}
|
|
|
|
// =========================================================================
|
|
// Text
|
|
// =========================================================================
|
|
|
|
/**
|
|
* `Text`. The string goes out *twice*: once as a fully transparent `<text>`
|
|
* so that viewers can search and select it, and once as stroked geometry
|
|
* inside `<g class="stroked-text">` with a `<desc>` for screen readers.
|
|
* m_textMode is never consulted.
|
|
*
|
|
* Two asymmetries are load bearing. The `rotate()` transform pivots on the
|
|
* *original* position while the `<text>` element's x/y are the
|
|
* vertically-justified one, and the rotation angle is negated unless the plot
|
|
* is mirrored. The mirror test is an XOR — `m_plotMirror !== (aSize.x < 0)` —
|
|
* because a negative width is how a mirrored string is encoded, so a mirrored
|
|
* string on a mirrored plot is upright again.
|
|
*
|
|
* `text_size.y` is computed from `aSize.x`, not aSize.y: four thirds of the
|
|
* *width*, as integer arithmetic, converting Hershey height to em size.
|
|
*/
|
|
override Text(
|
|
aPos: Vec2,
|
|
aColor: Color4d,
|
|
aText: string,
|
|
aOrient: EDA_ANGLE,
|
|
aSize: Vec2,
|
|
aH_justify: GR_TEXT_H_ALIGN_T,
|
|
aV_justify: GR_TEXT_V_ALIGN_T,
|
|
aWidth: number,
|
|
aItalic: boolean,
|
|
aBold: boolean,
|
|
aMultilineAllowed: boolean,
|
|
aFont: PLOTTER_FONT | null,
|
|
aFontMetrics?: unknown,
|
|
_aData?: unknown,
|
|
): void {
|
|
this.setFillMode(FILL_T.NO_FILL);
|
|
this.SetColor(aColor);
|
|
this.SetCurrentLineWidth(aWidth);
|
|
|
|
if (this.m_graphics_changed) this.setSVGPlotStyle(this.GetCurrentLineWidth());
|
|
|
|
const text_pos = { x: aPos.x, y: aPos.y };
|
|
let hjust = 'start';
|
|
|
|
switch (aH_justify) {
|
|
case GR_TEXT_H_ALIGN_T.GR_TEXT_H_ALIGN_CENTER:
|
|
hjust = 'middle';
|
|
break;
|
|
case GR_TEXT_H_ALIGN_T.GR_TEXT_H_ALIGN_RIGHT:
|
|
hjust = 'end';
|
|
break;
|
|
case GR_TEXT_H_ALIGN_T.GR_TEXT_H_ALIGN_LEFT:
|
|
hjust = 'start';
|
|
break;
|
|
}
|
|
|
|
switch (aV_justify) {
|
|
case GR_TEXT_V_ALIGN_T.GR_TEXT_V_ALIGN_CENTER:
|
|
text_pos.y += Math.trunc(aSize.y / 2);
|
|
break;
|
|
case GR_TEXT_V_ALIGN_T.GR_TEXT_V_ALIGN_TOP:
|
|
text_pos.y += aSize.y;
|
|
break;
|
|
case GR_TEXT_V_ALIGN_T.GR_TEXT_V_ALIGN_BOTTOM:
|
|
break;
|
|
}
|
|
|
|
if (!aFont?.GRTextWidth)
|
|
throw new Error('SVG Text needs a font (KIFONT::FONT::GetFont is not wired)');
|
|
|
|
// aSize.x or aSize.y is < 0 for mirrored texts; the size is the magnitude.
|
|
const text_size = {
|
|
x: Math.abs(aFont.GRTextWidth(aText, aSize, this.GetCurrentLineWidth(), aBold, aItalic)),
|
|
// Hershey font height to em size conversion, on the WIDTH.
|
|
y: Math.abs(Math.trunc((aSize.x * 4) / 3)),
|
|
};
|
|
|
|
const anchor_pos_dev = this.userToDeviceCoordinates(aPos);
|
|
const text_pos_dev = this.userToDeviceCoordinates(text_pos);
|
|
const sz_dev = this.userToDeviceSizeV(text_size);
|
|
const p = this.m_precision;
|
|
const d = DEFAULT_FMT_PRECISION;
|
|
|
|
// Output the text as a hidden string (opacity = 0), so that WYSIWYG search
|
|
// can highlight roughly the right area and later processes can edit it.
|
|
if (!aOrient.IsZero()) {
|
|
this.emit(
|
|
`<g transform="rotate(` +
|
|
`${fixed(this.m_plotMirror ? aOrient.AsDegrees() : -aOrient.AsDegrees(), d)}` +
|
|
` ${fixed(anchor_pos_dev.x, p)} ${fixed(anchor_pos_dev.y, p)})">\n`,
|
|
);
|
|
}
|
|
|
|
this.emit(`<text x="${fixed(text_pos_dev.x, p)}" y="${fixed(text_pos_dev.y, p)}"\n`);
|
|
|
|
// If the text is mirrored, we should also mirror the hidden text to match
|
|
if (this.m_plotMirror !== aSize.x < 0)
|
|
this.emit(`transform="scale(-1 1) translate(${fixed(-2 * text_pos_dev.x, d)} 0)"\n`);
|
|
|
|
this.emit(
|
|
`textLength="${fixed(sz_dev.x, p)}" font-size="${fixed(sz_dev.y, p)}" lengthAdjust="spacingAndGlyphs"\n` +
|
|
`text-anchor="${hjust}" opacity="0" stroke-opacity="0">${XmlEsc(aText)}</text>\n`,
|
|
);
|
|
|
|
if (!aOrient.IsZero()) this.emit('</g>\n');
|
|
|
|
// Output the text again as graphics with a <desc> tag (for non-WYSIWYG
|
|
// search and for screen readers).
|
|
this.emit(`<g class="stroked-text"><desc>${XmlEsc(aText)}</desc>\n`);
|
|
|
|
super.Text(
|
|
aPos,
|
|
aColor,
|
|
aText,
|
|
aOrient,
|
|
aSize,
|
|
aH_justify,
|
|
aV_justify,
|
|
this.GetCurrentLineWidth(),
|
|
aItalic,
|
|
aBold,
|
|
aMultilineAllowed,
|
|
aFont,
|
|
aFontMetrics,
|
|
);
|
|
|
|
this.emit('</g>');
|
|
}
|
|
|
|
/**
|
|
* `PlotText`. A mirrored run is handed to Text as a *negative width*, which is
|
|
* the encoding Text's XOR mirror test then reads back out.
|
|
*/
|
|
override PlotText(
|
|
aPos: Vec2,
|
|
aColor: Color4d,
|
|
aText: string,
|
|
aAttributes: PLOTTER_TEXT_ATTRIBUTES,
|
|
aFont: PLOTTER_FONT | null,
|
|
aFontMetrics?: unknown,
|
|
aData?: unknown,
|
|
): void {
|
|
const size = { x: aAttributes.m_Size.x, y: aAttributes.m_Size.y };
|
|
|
|
if (aAttributes.m_Mirrored) size.x = -size.x;
|
|
|
|
this.Text(
|
|
aPos,
|
|
aColor,
|
|
aText,
|
|
aAttributes.m_Angle,
|
|
size,
|
|
aAttributes.m_Halign,
|
|
aAttributes.m_Valign,
|
|
aAttributes.m_StrokeWidth,
|
|
aAttributes.m_Italic,
|
|
aAttributes.m_Bold,
|
|
aAttributes.m_Multiline,
|
|
aFont,
|
|
aFontMetrics,
|
|
aData,
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* `BOX2::Normalize` folded into the constructor, which already calls it — so
|
|
* `BOX2I rect( p1, size ); rect.Normalize();` normalises once, not twice. The
|
|
* origin moves by the *negated* size, which is why a box built from a
|
|
* bottom-right corner and a negative extent still ends up anchored top-left.
|
|
*/
|
|
function normalizedBox(aPos: Vec2, aSize: Vec2): { pos: Vec2; size: Vec2 } {
|
|
const pos = { x: aPos.x, y: aPos.y };
|
|
const size = { x: aSize.x, y: aSize.y };
|
|
|
|
if (size.y < 0) {
|
|
size.y = -size.y;
|
|
pos.y = pos.y - size.y;
|
|
}
|
|
|
|
if (size.x < 0) {
|
|
size.x = -size.x;
|
|
pos.x = pos.x - size.x;
|
|
}
|
|
|
|
return { pos, size };
|
|
}
|