// 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. /** * DXF_PLOTTER, the AutoCAD R2004 (AC1018) plot back-end, transcribed from * common/plotters/DXF_plotter.cpp. It derives from PLOTTER (plotter.ts), which * carries the device transform, the pen wrappers, ThickOval and the stroked * text fallback, as upstream's base class does. * * A DXF file is read by mechanical CAD, so the byte-level syntax *is* the * interface: a stray space in a group code or a reordered subclass marker is * not a cosmetic difference, it is a file that will not open. Three * consequences shape this port. * * 1. Output is bytes, not a string. Layer names go out UTF-8 (upstream's * TO_UTF8) but TEXT glyphs are written a byte at a time with putc(), i.e. * Latin-1. The same file therefore carries two encodings and a * string-then-encode implementation would silently diverge on accented * text. Hence `out: number[]`, `emit()` for markup and `putLatin1()` for * glyphs. * 2. Group-code padding is copied verbatim per call site. The same code is * " 50" in the tables and " 50" inside $HEADER; nothing here computes * padding. * 3. Where upstream truncates with C++ integer division, or lets a VECTOR2D * decay to a VECTOR2I, this uses Math.trunc explicitly. Those half-IU * losses are observable in the emitted coordinates. * * Faithfully reproduced oddities, each of which looks like a bug and is not to * be "fixed": "VIOLETFIFTEEN" appears twice in the ACAD colour-name table (so * two LAYER records share a name, and the name->ACI lookup must be a * first-match scan); getDXFLineType returns "DIVIDE" for dash-dot-dot, a * linetype the LTYPE table never declares; Rect ignores its fill argument; * Circle with a fill that is neither NO_FILL nor FILLED_SHAPE emits nothing at * all; PenTo('Z') returns before updating the pen position; and arc angles are * written unnormalised, negative zero included. * * One ambiguity settled by measurement: upstream calls nextHandle() twice * inside a single fmt::print argument list for each BLOCK/ENDBLK pair, and C++ * leaves that evaluation order unspecified. The installed kicad-cli (GCC) * evaluates right to left, so ENDBLK gets the lower handle; this port * allocates in that order (qa/data/pcbnew/plot/fmt_oracle pins it). */ import type { Vec2 } from '@ziroeda/kimath/src/math/vector2.js'; import { ANGLE_90, EDA_ANGLE } from '@ziroeda/kimath/src/geometry/eda_angle.js'; import { RotatePoint } from '@ziroeda/kimath/src/trigo.js'; import { KiROUND } from '@ziroeda/kimath/src/math/util.js'; import { ERROR_LOC } from '@ziroeda/kimath/src/convert_basic_shapes_to_polygon.js'; import { SHAPE_POLY_SET, TransformRoundChamferedRectToPolygon, } from '@ziroeda/kimath/src/geometry/shape_poly_set.js'; import { GR_TEXT_H_ALIGN_T, GR_TEXT_V_ALIGN_T } from '../eda_text.js'; import { COLOR4D_BLACK, COLOR4D_WHITE, type Color4d } from '../gal/color4d.js'; import type { PlotterRenderSettings } from '../render_settings.js'; import { DO_NOT_SET_LINE_WIDTH, DXF_LAYER_OUTPUT_MODE, DXF_OUTLINE_MODE, DXF_UNITS, FILL_T, LINE_STYLE, PLOT_FORMAT, PLOT_TEXT_MODE, PLOTTER, type PLOTTER_FONT, type PLOTTER_TEXT_ATTRIBUTES, type PEN_PLUME, } from './plotter.js'; /** * Oblique angle for DXF native text. Upstream's comment: "I don't remember if * 15 degrees is the ISO value... it looks nice anyway". */ const DXF_OBLIQUE_ANGLE = 15; /** * `#define DXF_LINE_WIDTH DO_NOT_SET_LINE_WIDTH` — DXF carries no line widths, * so every internal call passes -2. That is why PlotPoly's `aWidth <= 0` branch * is the only one any caller inside this class ever reaches. */ const DXF_LINE_WIDTH = DO_NOT_SET_LINE_WIDTH; /** COLOR4D, components in 0..1. Equality below includes alpha, as upstream's does. */ const colorEquals = (a: Color4d, b: Color4d): boolean => a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a; /** * `RENDER_SETTINGS` plus the one accessor only DXF reaches for: the layer * colour GetCurrentLayerName names a layer after, by PCB_LAYER_ID. */ export interface DxfRenderSettings extends PlotterRenderSettings { GetLayerColor(aLayer: number): Color4d; } /** * The slice of `PLOT_PARAMS` the Thick and Flash primitives consult * (plotter.h). An absent params object means FILLED, because upstream's * `cfg && cfg->GetDXFPlotMode() == SKETCH` short-circuits on the null pointer. */ export interface DxfPlotParams { GetDXFPlotMode(): DXF_OUTLINE_MODE; } /** One `m_layersToExport` entry: the board layer and the DXF layer name for it. */ export type DxfLayerExport = readonly [layer: number, name: string]; interface DxfLayout { name: string; blockName: string; blockRecordHandle: string; layoutHandle: string; isPaperSpace: boolean; } /** * `formatCoord` (DXF_plotter.cpp): sixteen fixed decimals with trailing zeros * popped. The loop stops at the '.', so whole numbers keep a bare trailing dot * — "0.", "100." — and that dot is part of the expected output, not a typo. * * Two divergences between fmt and toFixed have to be papered over by hand: * JS drops the sign of negative zero, and it spells the non-finite values * differently. Coordinates never reach either case (the Y transform is written * as `0 - v`, which yields +0), but group 41 on TEXT does — see plotOneLineOfText. */ export function formatCoord(aValue: number): string { if (Number.isNaN(aValue)) return 'nan'; if (!Number.isFinite(aValue)) return aValue > 0 ? 'inf' : '-inf'; let buf = Object.is(aValue, -0) ? `-${(0).toFixed(16)}` : aValue.toFixed(16); while (buf.length > 0 && buf[buf.length - 1] === '0') buf = buf.slice(0, -1); return buf; } /** * fmt's `{:.8f}`, used for the two ARC angles and the TEXT rotation. Unlike * formatCoord this keeps its trailing zeros, and unlike formatCoord it really * does see negative zero: `Arc` negates a zero start angle, and upstream prints * that as "-0.00000000". */ function formatAngle(aValue: number): string { if (Number.isNaN(aValue)) return 'nan'; if (!Number.isFinite(aValue)) return aValue > 0 ? 'inf' : '-inf'; return Object.is(aValue, -0) ? `-${(0).toFixed(8)}` : aValue.toFixed(8); } /** * `getDXFLineType` (DXF_plotter.cpp). DASHDOTDOT maps to "DIVIDE", which * StartPlot never declares in the LTYPE table; the LINE entity then names an * undeclared linetype. That is upstream behaviour and stays. */ export function getDXFLineType(aType: LINE_STYLE): string { switch (aType) { case LINE_STYLE.DEFAULT: case LINE_STYLE.SOLID: return 'CONTINUOUS'; case LINE_STYLE.DASH: return 'DASHED'; case LINE_STYLE.DOT: return 'DOTTED'; case LINE_STYLE.DASHDOT: return 'DASHDOT'; case LINE_STYLE.DASHDOTDOT: return 'DIVIDE'; default: return 'CONTINUOUS'; } } /** * The ACAD legacy palette, transcribed from DXF_plotter.cpp lines 62..313. * * "VIOLETFIFTEEN" appears at index 192 (ACI 194) and again at index 224, where * the DXF_COLOR_T enum calls the entry VIOLETTHIRTYONE (ACI 229). Both records * are emitted, giving the file two LAYER entries with the same name, and the * name->ACI lookup in StartPlot is a first-match scan, so that name always * resolves to 194. A Map keyed by name would keep 229 instead and be wrong. */ const acad_dxf_color_names: readonly (readonly [name: string, aci: number])[] = [ ['BLACK', 250], ['RED', 14], ['YELLOW', 52], ['GREEN', 94], ['CYAN', 134], ['BLUE', 174], ['MAGENTA', 214], ['WHITE', 250], ['BROWN', 54], ['ORANGE', 32], ['LIGHTRED', 12], ['LIGHTYELLOW', 51], ['LIGHTGREEN', 92], ['LIGHTCYAN', 132], ['LIGHTBLUE', 172], ['LIGHTMAGENTA', 212], ['LIGHTORANGE', 30], ['LIGHTGRAY', 9], ['DARKRED', 16], ['DARKYELLOW', 41], ['DARKGREEN', 96], ['DARKCYAN', 136], ['DARKBLUE', 176], ['DARKMAGENTA', 216], ['DARKBROWN', 56], ['DARKORANGE', 34], ['DARKGRAY', 8], ['PURERED', 1], ['PUREYELLOW', 2], ['PUREGREEN', 3], ['PURECYAN', 4], ['PUREBLUE', 5], ['PUREMAGENTA', 6], ['PUREORANGE', 40], ['PUREGRAY', 57], ['REDONE', 11], ['REDTWO', 13], ['REDTHREE', 15], ['REDFOUR', 17], ['REDFIVE', 18], ['REDSIX', 19], ['ORANGEONE', 20], ['ORANGETWO', 21], ['ORANGETHREE', 22], ['ORANGEFOUR', 23], ['ORANGEFIVE', 24], ['REDSEVEN', 25], ['REDEIGHT', 26], ['ORANGESIX', 27], ['REDNINE', 28], ['ORANGESEVEN', 29], ['ORANGEEIGHT', 31], ['ORANGENINE', 33], ['ORANGETEN', 35], ['ORANGEELEVEN', 36], ['ORANGETWELVE', 37], ['ORANGETHIRTEEN', 38], ['ORANGEFOURTEEN', 39], ['YELLOWONE', 42], ['YELLOWTWO', 43], ['YELLOWTHREE', 44], ['YELLOWFOUR', 45], ['YELLOWFIVE', 46], ['YELLOWSIX', 47], ['YELLOWSEVEN', 48], ['YELLOWEIGHT', 49], ['YELLOWNINE', 53], ['YELLOWTEN', 55], ['YELLOWELEVEN', 58], ['YELLOWTWELVE', 59], ['YELLOWTHIRTEEN', 60], ['YELLOWFOURTEEN', 61], ['GREENONE', 62], ['GREENTWO', 63], ['GREENTHREE', 64], ['GREENFOUR', 65], ['GREENFIVE', 66], ['GREENSIX', 67], ['GREENSEVEN', 68], ['GREENEIGHT', 69], ['GREENNINE', 70], ['GREENTEN', 71], ['GREENELEVEN', 72], ['GREENTWELVE', 73], ['GREENTHIRTEEN', 74], ['GREENFOURTEEN', 75], ['GREENFIFTEEN', 76], ['GREENSIXTEEN', 77], ['GREENSEVENTEEN', 78], ['GREENEIGHTEEN', 79], ['GREENNINETEEN', 80], ['GREENTWENTY', 81], ['GREENTWENTYONE', 82], ['GREENTWENTYTWO', 83], ['GREENTWENTYTHREE', 84], ['GREENTWENTYFOUR', 85], ['GREENTWENTYFIVE', 86], ['GREENTWENTYSIX', 87], ['GREENTWENTYSEVEN', 88], ['GREENTWENTYEIGHT', 89], ['GREENTWENTYNINE', 90], ['GREENTHIRTY', 91], ['GREENTHIRTYONE', 93], ['GREENTHIRTYTWO', 95], ['GREENTHIRTYTHREE', 97], ['GREENTHIRTYFOUR', 98], ['GREENTHIRTYFIVE', 99], ['GREENTHIRTYSIX', 100], ['GREENTHIRTYSEVEN', 101], ['GREENTHIRTYEIGHT', 102], ['GREENTHIRTYNINE', 103], ['GREENFORTY', 104], ['GREENFORTYONE', 105], ['GREENFORTYTWO', 106], ['GREENFORTYTHREE', 107], ['GREENFORTYFOUR', 108], ['GREENFORTYFIVE', 109], ['GREENFORTYSIX', 110], ['GREENFORTYSEVEN', 111], ['GREENFORTYEIGHT', 112], ['GREENFORTYNINE', 113], ['GREENFIFTY', 114], ['GREENFIFTYONE', 115], ['GREENFIFTYTWO', 116], ['GREENFIFTYTHREE', 117], ['GREENFIFTYFOUR', 118], ['GREENFIFTYFIVE', 119], ['GREENFIFTYSIX', 120], ['GREENFIFTYSEVEN', 121], ['GREENFIFTYEIGHT', 122], ['GREENFIFTYNINE', 123], ['GREENSIXTY', 124], ['GREENSIXTYONE', 125], ['GREENSIXTYTWO', 126], ['GREENSIXTYTHREE', 127], ['GREENSIXTYFOUR', 128], ['GREENSIXTYFIVE', 129], ['CYANONE', 131], ['CYANTWO', 133], ['CYANTHREE', 135], ['CYANFOUR', 137], ['CYANFIVE', 138], ['CYANSIX', 139], ['CYANSEVEN', 140], ['BLUEONE', 141], ['BLUETWO', 142], ['BLUETHREE', 143], ['BLUEFOUR', 144], ['BLUEFIVE', 145], ['BLUESIX', 146], ['BLUESEVEN', 147], ['BLUEEIGHT', 148], ['BLUENINE', 149], ['BLUETEN', 150], ['BLUEELEVEN', 151], ['BLUETWELVE', 152], ['BLUETHIRTEEN', 153], ['BLUEFOURTEEN', 154], ['BLUEFIFTEEN', 155], ['BLUESIXTEEN', 156], ['BLUESEVENTEEN', 157], ['BLUEEIGHTEEN', 158], ['BLUENINETEEN', 159], ['BLUETWENTY', 160], ['BLUETWENTYONE', 161], ['BLUETWENTYTWO', 162], ['BLUETWENTYTHREE', 163], ['BLUETWENTYFOUR', 164], ['BLUETWENTYFIVE', 165], ['BLUETWENTYSIX', 166], ['BLUETWENTYSEVEN', 167], ['BLUETWENTYEIGHT', 168], ['BLUETWENTYNINE', 169], ['BLUETHIRTY', 170], ['BLUETHIRTYONE', 171], ['BLUETHIRTYTWO', 177], ['BLUETHIRTYETHREE', 178], ['BLUETHIRTYFOUR', 179], ['VIOLETONE', 180], ['VIOLETTWO', 181], ['VIOLETTHREE', 182], ['VIOLETFOUR', 183], ['VIOLETFIVE', 184], ['VIOLETSIX', 185], ['VIOLETSEVEN', 186], ['VIOLETEIGHT', 187], ['VIOLETNINE', 188], ['VIOLETTEN', 189], ['VIOLETELEVEN', 190], ['VIOLETTWELVE', 191], ['VIOLETTHIRTEEN', 192], ['VIOLETFOURTEEN', 193], ['VIOLETFIFTEEN', 194], ['VIOLETSIXTEEN', 195], ['VIOLETSEVENTEEN', 196], ['VIOLETEIGHTEEN', 197], ['VIOLETNINETEEN', 198], ['VIOLETTWENTY', 199], ['VIOLETTWENTYONE', 200], ['VIOLETTWENTYTWO', 201], ['VIOLETTWENTYTHREE', 202], ['VIOLETTWENTYFOUR', 203], ['VIOLETTWENTYFIVE', 204], ['VIOLETTWENTYSIX', 205], ['VIOLETTWENTYSEVEN', 206], ['VIOLETTWENTYEIGHT', 207], ['VIOLETTWENTYNINE', 208], ['VIOLETTHIRTY', 209], ['MAGENTAONE', 210], ['MAGENTATWO', 211], ['MAGENTATHREE', 213], ['MAGENTAFOUR', 215], ['MAGENTAFIVE', 217], ['MAGENTASIX', 218], ['MAGENTASEVEN', 219], ['MAGENTAEIGHT', 220], ['MAGENTANINE', 221], ['MAGENTATEN', 222], ['MAGENTAELEVEN', 223], ['MAGENTATWELVE', 224], ['MAGENTATHIRTEEN', 225], ['MAGENTAFOURTEEN', 226], ['REDTEN', 227], ['REDELEVEN', 228], ['VIOLETFIFTEEN', 229], ['REDTWELVE', 230], ['REDTHIRTEEN', 231], ['REDFOURTEEN', 232], ['REDFIFTEEN', 233], ['REDSIXTEEN', 234], ['REDSEVENTEEN', 235], ['REDEIGHTEEN', 236], ['REDNINETEEN', 237], ['REDTWENTY', 238], ['REDTWENTYONE', 239], ['REDTWENTYTWO', 240], ['REDTWENTYTHREE', 241], ['REDTWENTYFOUR', 242], ['REDTWENTYFIVE', 243], ['REDTWENTYSIX', 244], ['REDTWENTYSEVEN', 245], ['REDTWENTYEIGHT', 246], ['REDTWENTYNINE', 247], ['REDTHIRTY', 248], ['REDTHIRTYONE', 249], ['GRAYONE', 251], ['GRAYTWO', 252], ['GRAYTHREE', 253], ['GRAYFOUR', 254], ]; /** * The RGB values for those 249 entries, DXF_plotter.cpp lines 323..573. * Upstream stores them BLUE, GREEN, RED in that field order; the tuples keep it * so a transcription slip shows up as a swapped channel rather than silently * shifting every nearest-colour lookup. The struct's fourth member (the * DXF_COLOR_T name) is dead: FindNearestLegacyColor works off the array index. */ const acad_dxf_color_values: readonly (readonly [b: number, g: number, r: number])[] = [ [0, 0, 0], [0, 0, 127], [0, 165, 165], [0, 127, 0], [127, 127, 0], [127, 0, 0], [127, 0, 127], [255, 255, 255], [0, 127, 127], [0, 82, 165], [0, 0, 165], [127, 255, 255], [0, 165, 0], [165, 165, 0], [165, 0, 0], [165, 0, 165], [0, 127, 255], [192, 192, 192], [0, 0, 76], [127, 223, 255], [0, 76, 0], [76, 76, 0], [76, 0, 0], [76, 0, 76], [0, 76, 76], [0, 63, 127], [128, 128, 128], [0, 0, 255], [0, 255, 255], [0, 255, 0], [255, 255, 0], [255, 0, 0], [255, 0, 255], [0, 191, 255], [38, 76, 76], [127, 127, 255], [82, 82, 165], [63, 63, 127], [38, 38, 76], [0, 0, 38], [19, 19, 38], [0, 63, 255], [127, 159, 255], [0, 41, 165], [82, 103, 165], [0, 31, 127], [63, 79, 127], [0, 19, 76], [38, 47, 76], [0, 9, 38], [19, 23, 38], [127, 191, 255], [82, 124, 165], [63, 95, 127], [0, 38, 76], [38, 57, 76], [0, 19, 38], [19, 28, 38], [0, 124, 165], [82, 145, 165], [0, 95, 127], [63, 111, 127], [0, 57, 76], [38, 66, 76], [0, 28, 38], [19, 33, 38], [82, 165, 165], [63, 127, 127], [0, 38, 38], [19, 38, 38], [0, 255, 191], [127, 255, 223], [0, 165, 124], [82, 165, 145], [0, 127, 95], [63, 127, 111], [0, 76, 57], [38, 76, 66], [0, 38, 28], [19, 38, 33], [0, 255, 127], [127, 255, 191], [0, 165, 82], [82, 165, 124], [0, 127, 63], [63, 127, 95], [0, 76, 38], [38, 76, 57], [0, 38, 19], [19, 38, 28], [0, 255, 63], [127, 255, 159], [0, 165, 41], [82, 165, 103], [0, 127, 31], [63, 127, 79], [0, 76, 19], [38, 76, 47], [0, 38, 9], [19, 38, 23], [0, 255, 0], [127, 255, 127], [82, 165, 82], [63, 127, 63], [38, 76, 38], [0, 38, 0], [19, 38, 19], [63, 255, 0], [159, 255, 127], [41, 165, 0], [103, 165, 82], [31, 127, 0], [79, 127, 63], [19, 76, 0], [47, 76, 38], [9, 38, 0], [23, 88, 19], [127, 255, 0], [191, 255, 127], [82, 165, 0], [95, 127, 63], [63, 127, 0], [95, 127, 63], [38, 76, 0], [57, 76, 38], [19, 38, 0], [28, 88, 19], [191, 255, 0], [223, 255, 127], [124, 165, 0], [145, 165, 82], [95, 127, 0], [111, 127, 63], [57, 76, 0], [66, 76, 38], [28, 38, 0], [88, 88, 19], [255, 255, 127], [165, 165, 82], [127, 127, 63], [76, 76, 38], [38, 38, 0], [88, 88, 19], [255, 191, 0], [255, 223, 127], [165, 124, 0], [165, 145, 82], [127, 95, 0], [127, 111, 63], [76, 57, 0], [126, 66, 38], [38, 28, 0], [88, 88, 19], [255, 127, 0], [255, 191, 127], [165, 82, 0], [165, 124, 82], [127, 63, 0], [127, 95, 63], [76, 38, 0], [126, 57, 38], [38, 19, 0], [88, 28, 19], [255, 63, 0], [255, 159, 127], [165, 41, 0], [165, 103, 82], [127, 31, 0], [127, 79, 63], [76, 19, 0], [126, 47, 38], [38, 9, 0], [88, 23, 19], [255, 0, 0], [255, 127, 127], [126, 38, 38], [38, 0, 0], [88, 19, 19], [255, 0, 63], [255, 127, 159], [165, 0, 41], [165, 82, 103], [127, 0, 31], [127, 63, 79], [76, 0, 19], [126, 38, 47], [38, 0, 9], [88, 19, 23], [255, 0, 127], [255, 127, 191], [165, 0, 82], [165, 82, 124], [127, 0, 63], [127, 63, 95], [76, 0, 38], [126, 38, 57], [38, 0, 19], [88, 19, 28], [255, 0, 191], [255, 127, 223], [165, 0, 124], [165, 82, 145], [127, 0, 95], [127, 63, 111], [76, 0, 57], [76, 38, 66], [38, 0, 28], [88, 19, 88], [255, 0, 255], [255, 127, 255], [165, 82, 165], [127, 63, 127], [76, 38, 76], [38, 0, 38], [88, 19, 88], [191, 0, 255], [223, 127, 255], [124, 0, 165], [145, 82, 165], [95, 0, 127], [111, 63, 127], [57, 0, 76], [66, 38, 76], [28, 0, 38], [88, 19, 88], [127, 0, 255], [191, 127, 255], [82, 0, 165], [124, 82, 165], [63, 0, 127], [95, 63, 127], [38, 0, 76], [57, 38, 76], [19, 0, 38], [28, 19, 88], [63, 0, 255], [159, 127, 255], [41, 0, 165], [103, 82, 165], [31, 0, 127], [79, 63, 127], [19, 0, 76], [47, 38, 76], [9, 0, 38], [23, 19, 88], [101, 101, 101], [102, 102, 102], [153, 153, 153], [204, 204, 204], ]; /** * `FindNearestLegacyColor` (DXF_plotter.cpp): a linear scan over all 249 * entries by squared RGB distance. The comparison is strictly `<`, so ties go * to the lowest index — pure black resolves to BLACK (0) and never to WHITE * (7), even though the two share ACI 250. Returns a table *index*, not an ACI. */ export function FindNearestLegacyColor(aR: number, aG: number, aB: number): number { let nearestColorValueIndex = 0; let nearestDistance = Number.MAX_SAFE_INTEGER; for (let trying = 0; trying < acad_dxf_color_values.length; trying++) { const [blue, green, red] = acad_dxf_color_values[trying]!; const distance = (aR - red) * (aR - red) + (aG - green) * (aG - green) + (aB - blue) * (aB - blue); if (distance < nearestDistance) { nearestDistance = distance; nearestColorValueIndex = trying; } } return nearestColorValueIndex; } /** The ACAD colour name at a table index, for callers that resolved one. */ export function acadColorName(aIndex: number): string { return acad_dxf_color_names[aIndex]![0]; } /** * `arcPts` (DXF_plotter.cpp), the free function that flattens an arc at a fixed * five-degree step. The start angle is negated, then each sample is taken at * the *re*-negated angle, so the first point sits at the original start angle * unless the CCW swap fired. The loop bound is strictly `<`, which is why the * penultimate sample never lands on the end point. * * Its only upstream caller is the SHAPE_LINE_CHAIN PlotPoly overload, which * is deliberately NOT ported: the installed kicad-cli writes a rounded * rectangle's corners at the chain's own points, not at arcPts' five-degree * steps (qa/data/pcbnew/plot/fmt_oracle dxfsingle pins it), so the inherited * PLOTTER::PlotPolyLineChain is what matches. */ export function arcPts( aCenter: Vec2, aStartAngle: EDA_ANGLE, aAngle: EDA_ANGLE, aRadius: number, ): Vec2[] { const pts: Vec2[] = []; let startAngle = aStartAngle.negate(); let endAngle = startAngle.sub(aAngle); const delta = new EDA_ANGLE(5); if (startAngle.gt(endAngle)) [startAngle, endAngle] = [endAngle, startAngle]; pts.push({ x: KiROUND(aCenter.x + aRadius * startAngle.negate().Cos()), y: KiROUND(aCenter.y + aRadius * startAngle.negate().Sin()), }); for (let ii = startAngle.add(delta); ii.lt(endAngle); ii = ii.add(delta)) { pts.push({ x: KiROUND(aCenter.x + aRadius * ii.negate().Cos()), y: KiROUND(aCenter.y + aRadius * ii.negate().Sin()), }); } pts.push({ x: KiROUND(aCenter.x + aRadius * endAngle.negate().Cos()), y: KiROUND(aCenter.y + aRadius * endAngle.negate().Sin()), }); return pts; } /** One LTYPE table row (StartPlot's local `LtypePattern`). */ interface LtypePattern { name: string; description: string; elementCount: number; patternLength: number; dashes: string; } /** * ByBlock and ByLayer are looked up by name and AutoCAD aborts when either is * absent. Group 49 is the per-element dash (positive) or gap (negative) length * and each 49 must be followed by a 74 in R2000+. DOTTED's first dash is the * literal "0.0", which is not what String(0) would produce, so the pattern * strings are copied through verbatim rather than formatted. */ const LTYPES: readonly LtypePattern[] = [ { name: 'ByBlock', description: '', elementCount: 0, patternLength: 0.0, dashes: '' }, { name: 'ByLayer', description: '', elementCount: 0, patternLength: 0.0, dashes: '' }, { name: 'CONTINUOUS', description: 'Solid line', elementCount: 0, patternLength: 0.0, dashes: '', }, { name: 'DASHDOT', description: 'Dash Dot ____ _ ____ _', elementCount: 4, patternLength: 2.0, dashes: ' 49\n1.25\n 74\n0\n 49\n-0.25\n 74\n0\n' + ' 49\n0.25\n 74\n0\n 49\n-0.25\n 74\n0\n', }, { name: 'DASHED', description: 'Dashed __ __ __ __ __', elementCount: 2, patternLength: 0.75, dashes: ' 49\n0.5\n 74\n0\n 49\n-0.25\n 74\n0\n', }, { name: 'DOTTED', description: 'Dotted . . . .', elementCount: 2, patternLength: 0.2, dashes: ' 49\n0.0\n 74\n0\n 49\n-0.2\n 74\n0\n', }, ]; /** STYLE table names; the oblique angle is chosen by `i < 2`, not by the name. */ const STYLE_NAMES = ['KICAD', 'KICADB', 'KICADI', 'KICADBI'] as const; const PAPER_NAME = 'A3'; const PAPER_WIDTH_MM = 420.0; const PAPER_HEIGHT_MM = 297.0; const PLOT_FLAG_MODELTYPE = 1024; const TEXT_ENCODER = new TextEncoder(); /** * `DXF_PLOTTER` (include/plotters/plotter_dxf.h, common/plotters/DXF_plotter.cpp). * * Stateful by nature — handle counter, pen position, current colour and * linetype, layout bookkeeping — so it stays a class. Drive it exactly as * upstream does: SetUnits / SetViewport / SetColorMode / SetLayersToExport, * then StartPlot, then geometry with SetLayer between layers, then EndPlot. */ export class DXF_PLOTTER extends PLOTTER { // ---- DXF_PLOTTER state --------------------------------------------------- private m_plotUnits: DXF_UNITS = DXF_UNITS.INCH; private m_unitScalingFactor = 0.0001; private m_measurementDirective = 0; private m_insUnits = 1; private m_textAsLines = true; private m_currentColor: Color4d = COLOR4D_BLACK; private m_currentLineType: LINE_STYLE = LINE_STYLE.SOLID; private m_handle = 0; private m_modelSpaceHandle = ''; private m_plotStyleNormalHandle = ''; private m_plotStyleNameDictHandle = ''; private m_namedObjectDictHandle = ''; private m_layoutDictHandle = ''; private m_dxfLayouts: DxfLayout[] = []; /** The emitted file. Bytes, because layer names are UTF-8 and glyphs Latin-1. */ private out: number[] = []; /** DXF reads the layer colour too, which PLOTTER's slice does not carry. */ protected declare m_renderSettings: DxfRenderSettings | null; constructor(aRenderSettings: DxfRenderSettings | null = null) { super(); this.m_renderSettings = aRenderSettings; // DXF_PLOTTER's constructor body, in order. this.m_textAsLines = true; this.m_currentColor = COLOR4D_BLACK; this.m_currentLineType = LINE_STYLE.SOLID; this.SetUnits(DXF_UNITS.INCH); } override GetPlotterType(): PLOT_FORMAT { return PLOT_FORMAT.DXF; } static GetDefaultFileExtension(): string { return 'dxf'; } /** `m_renderSettings->`, with the DXF-only accessor. */ protected override renderSettings(): DxfRenderSettings { if (!this.m_renderSettings) throw new Error('plotter has no render settings'); return this.m_renderSettings; } // ========================================================================= // Output buffer // ========================================================================= /** Fixed markup and layer names: `TO_UTF8`. */ private emit(aText: string): void { for (const byte of TEXT_ENCODER.encode(aText)) this.out.push(byte); } /** A single raw byte, upstream's `putc( ch, m_outputFile )`, i.e. Latin-1. */ private putLatin1(aCode: number): void { this.out.push(aCode & 0xff); } /** The plotted file. This, not `text()`, is what should be written to disk. */ bytes(): Uint8Array { return Uint8Array.from(this.out); } /** The file decoded as Latin-1, so tests can read whole entities as prose. */ text(): string { let s = ''; for (const byte of this.out) s += String.fromCharCode(byte); return s; } // ========================================================================= // Units, viewport, pen and colour state // ========================================================================= /** `SetUnits`. INCH is also the default arm of upstream's switch. */ SetUnits(aUnit: DXF_UNITS): void { this.m_plotUnits = aUnit; switch (aUnit) { case DXF_UNITS.MM: this.m_unitScalingFactor = 0.00254; this.m_measurementDirective = 1; this.m_insUnits = 4; break; // INCH shares upstream's default arm. default: this.m_unitScalingFactor = 0.0001; this.m_measurementDirective = 0; this.m_insUnits = 1; } } GetUnits(): DXF_UNITS { return this.m_plotUnits; } /** * `SetViewport`. DXF paper is virtual, so the paper size is forced to zero, * and `aMirror` is deliberately dropped — DXF never mirrors. pcbnew always * passes aIusPerDecimil = 2540 (plot_board_layers.cpp), which makes the * device unit an inch or a millimetre depending on SetUnits. */ SetViewport(aOffset: Vec2, aIusPerDecimil: number, aScale: number, _aMirror: boolean): void { this.m_plotOffset = aOffset; this.m_plotScale = aScale; this.m_paperSize = { x: 0, y: 0 }; this.m_IUsPerDecimil = aIusPerDecimil; this.m_iuPerDeviceUnit = 1.0 / aIusPerDecimil; this.m_iuPerDeviceUnit *= this.m_unitScalingFactor; // aMirror is dropped on the floor: DXF never mirrors. this.m_currentColor = COLOR4D_BLACK; } /** DXF carries no line widths, so the width is discarded and the pen is 0. */ SetCurrentLineWidth(_width: number, _aData?: unknown): void { this.m_currentPenWidth = 0; } /** * `SetColor`. In mono mode everything but exact black and exact white * collapses to black; the comparison includes alpha, as COLOR4D's does. */ SetColor(aColor: Color4d): void { if ( this.m_colorMode || colorEquals(aColor, COLOR4D_BLACK) || colorEquals(aColor, COLOR4D_WHITE) ) this.m_currentColor = aColor; else this.m_currentColor = COLOR4D_BLACK; } /** * `SetTextMode`. The constructor leaves m_textAsLines true, so the native * TEXT entity path is reached only when the caller explicitly asks for it. */ override SetTextMode(aMode: PLOT_TEXT_MODE): void { if (aMode !== PLOT_TEXT_MODE.DEFAULT) this.m_textAsLines = aMode !== PLOT_TEXT_MODE.NATIVE; } /** `SetDash`. The width argument is ignored; DXF dashes are a linetype name. */ SetDash(_aLineWidth: number, aLineStyle: LINE_STYLE): void { this.m_currentLineType = aLineStyle; } // ========================================================================= // Layer naming // ========================================================================= /** * `GetCurrentLayerName`. Note the two asymmetries upstream builds in * deliberately: with an empty export list, Layer_Name reads the colour that * SetColor last stored while Layer_Color_Name reads the render settings, and * Current_Layer_Color_Name ignores the layer id it was handed in favour of * the current layer. `int( c * 255 )` truncates towards zero, so 0.5 is 127. */ GetCurrentLayerName(aMode: DXF_LAYER_OUTPUT_MODE, aLayerId?: number): string { const actualLayerId = aLayerId !== undefined ? aLayerId : this.m_layer; switch (aMode) { case DXF_LAYER_OUTPUT_MODE.Layer_Name: case DXF_LAYER_OUTPUT_MODE.Current_Layer_Name: { if (this.m_layersToExport.length === 0) { const layerColor = aMode === DXF_LAYER_OUTPUT_MODE.Current_Layer_Name ? this.m_currentColor : this.renderSettings().GetLayerColor(actualLayerId); const color = FindNearestLegacyColor( Math.trunc(layerColor.r * 255), Math.trunc(layerColor.g * 255), Math.trunc(layerColor.b * 255), ); return acad_dxf_color_names[color]![0]; } const it = this.m_layersToExport.find((element) => element[0] === actualLayerId); return it !== undefined ? it[1] : 'BLACK'; } case DXF_LAYER_OUTPUT_MODE.Layer_Color_Name: case DXF_LAYER_OUTPUT_MODE.Current_Layer_Color_Name: { const layerColor = aMode === DXF_LAYER_OUTPUT_MODE.Current_Layer_Color_Name ? this.renderSettings().GetLayerColor(this.GetLayer()) : this.renderSettings().GetLayerColor(actualLayerId); const color = FindNearestLegacyColor( Math.trunc(layerColor.r * 255), Math.trunc(layerColor.g * 255), Math.trunc(layerColor.b * 255), ); return acad_dxf_color_names[color]![0]; } default: return 'Unknown Mode'; } } // ========================================================================= // Handles // ========================================================================= /** `nextHandle`: uppercase unpadded hex, pre-incremented, so the first is "1". */ private nextHandle(): string { return (++this.m_handle).toString(16).toUpperCase(); } /** * `emitEntityHandle`. Returns the handle so POLYLINE can own its VERTEX * records and their SEQEND. SEQEND is the one caller that passes no subclass. */ private emitEntityHandle( aEntityType: string, aSubclass: string | null, aLayerName: string, aOwner = '', ): string { const handle = this.nextHandle(); const owner = aOwner === '' ? this.m_modelSpaceHandle : aOwner; this.emit( ` 0\n${aEntityType}\n` + ` 5\n${handle}\n` + `330\n${owner}\n` + `100\nAcDbEntity\n` + ` 8\n${aLayerName}\n`, ); if (aSubclass) this.emit(`100\n${aSubclass}\n`); return handle; } /** `emitSymbolTableHeader`; the returned handle is the 330 owner of its records. */ private emitSymbolTableHeader(aTableName: string, aCount: number): string { const handle = this.nextHandle(); this.emit( ` 0\n` + `TABLE\n` + ` 2\n${aTableName}\n` + ` 5\n${handle}\n` + `330\n0\n` + `100\nAcDbSymbolTable\n` + ` 70\n${aCount}\n`, ); return handle; } // ========================================================================= // File skeleton // ========================================================================= /** * `StartPlot`. Everything before the ENTITIES section, in one go, because the * handle numbering is positional: every record's handle is decided by where * its allocation sits in this method, and the OBJECTS section written by * EndPlot cites handles minted here. * * Tagged AC1018 (R2004) because the LAYER records emit group 420, the 24-bit * true colour AutoCAD only accepts from R2004 on; that in turn obliges the * full table and blocks skeleton below. */ StartPlot(_aPageNumber = ''): boolean { // Reset so one instance can plot several files, as upstream's does. this.m_handle = 0; this.m_modelSpaceHandle = ''; // Codes 50 and 70 carry TWO leading spaces here and one everywhere else. this.emit( ` 0\n` + `SECTION\n` + ` 2\n` + `HEADER\n` + ` 9\n` + `$ACADVER\n` + ` 1\n` + `AC1018\n` + ` 9\n` + `$HANDSEED\n` + ` 5\n` + `FFFFFFFF\n` + ` 9\n` + `$ANGBASE\n` + ` 50\n` + `0.0\n` + ` 9\n` + `$ANGDIR\n` + ` 70\n` + `1\n` + ` 9\n` + `$MEASUREMENT\n` + ` 70\n` + `${this.m_measurementDirective}\n` + ` 9\n` + `$INSUNITS\n` + ` 70\n` + `${this.m_insUnits}\n` + ` 0\n` + `ENDSEC\n`, ); this.emit(` 0\n` + `SECTION\n` + ` 2\n` + `TABLES\n`); // AutoCAD refuses to load R2000+ files lacking an ACAD APPID entry. const appidTableHandle = this.emitSymbolTableHeader('APPID', 1); this.emit( ` 0\n` + `APPID\n` + ` 5\n${this.nextHandle()}\n` + `330\n${appidTableHandle}\n` + `100\nAcDbSymbolTableRecord\n` + `100\nAcDbRegAppTableRecord\n` + ` 2\nACAD\n` + ` 70\n0\n` + ` 0\n` + `ENDTAB\n`, ); const ltypeTableHandle = this.emitSymbolTableHeader('LTYPE', LTYPES.length); for (const lt of LTYPES) { this.emit( ` 0\n` + `LTYPE\n` + ` 5\n${this.nextHandle()}\n` + `330\n${ltypeTableHandle}\n` + `100\nAcDbSymbolTableRecord\n` + `100\nAcDbLinetypeTableRecord\n` + ` 2\n${lt.name}\n` + ` 70\n0\n` + ` 3\n${lt.description}\n` + ` 72\n65\n` + ` 73\n${lt.elementCount}\n` + ` 40\n${String(lt.patternLength)}\n` + `${lt.dashes}`, ); } this.emit(` 0\n` + `ENDTAB\n`); // STYLE table - one entry per bold/italic combination. The oblique angle is // selected by `i < 2`, not by whether the style is the italic one; the // ordering makes that come out right, and the form is kept as upstream's. const styleTableHandle = this.emitSymbolTableHeader('STYLE', 4); for (let i = 0; i < 4; i++) { this.emit( ` 0\n` + `STYLE\n` + ` 5\n${this.nextHandle()}\n` + `330\n${styleTableHandle}\n` + `100\nAcDbSymbolTableRecord\n` + `100\nAcDbTextStyleTableRecord\n` + ` 2\n${STYLE_NAMES[i]}\n` + ` 70\n0\n` + ` 40\n0\n` + ` 41\n1\n` + ` 42\n1\n` + ` 50\n${String(i < 2 ? 0 : DXF_OBLIQUE_ANGLE)}\n` + ` 71\n0\n` + // The standard ISO font: with it, DXF text in acad matches perfectly. ` 3\nisocp.shx\n`, ); } this.emit(` 0\n` + `ENDTAB\n`); let numLayers = this.m_layersToExport.length === 0 ? acad_dxf_color_names.length : this.m_layersToExport.length; // If printing in monochrome, only output the black layer. The table header // count below is still numLayers + 1, so a mono colour-layered plot declares // two layers and writes one; that is upstream's arithmetic. if (!this.GetColorMode() && this.m_layersToExport.length === 0) numLayers = 1; // Every LAYER record needs a 390 hard-pointer to a PlotStyleName object; one // shared ACDBPLACEHOLDER named "Normal" serves them all, so its handle and // its owning dictionary's are minted here, before the records that cite them. // The +1 on the count is the mandatory layer "0" emitted next. const layerTableHandle = this.emitSymbolTableHeader('LAYER', numLayers + 1); this.m_plotStyleNormalHandle = this.nextHandle(); this.m_plotStyleNameDictHandle = this.nextHandle(); this.emit( ` 0\n` + `LAYER\n` + ` 5\n${this.nextHandle()}\n` + `330\n${layerTableHandle}\n` + `100\nAcDbSymbolTableRecord\n` + `100\nAcDbLayerTableRecord\n` + ` 2\n0\n` + ` 70\n0\n` + ` 62\n7\n` + ` 6\nCONTINUOUS\n` + `390\n${this.m_plotStyleNormalHandle}\n`, ); let layerName = ''; let colorNumber = 0; // Declared outside the loop and never reset, exactly as upstream. Harmless // only because the branch that sets it runs on every iteration or on none. let hasActualColor = false; let actualColor: Color4d = COLOR4D_BLACK; for (let i = 0; i < numLayers; i++) { if (this.m_layersToExport.length !== 0) { layerName = this.GetCurrentLayerName( DXF_LAYER_OUTPUT_MODE.Layer_Name, this.m_layersToExport[i]![0], ); const colorName = this.GetCurrentLayerName( DXF_LAYER_OUTPUT_MODE.Layer_Color_Name, this.m_layersToExport[i]![0], ); // First match, so a colour resolving to the duplicated "VIOLETFIFTEEN" // always takes ACI 194 and never the 229 of the second record. const it = acad_dxf_color_names.find((layer) => layer[0] === colorName); colorNumber = it !== undefined ? it[1] : 7; // Default to white/black actualColor = this.renderSettings().GetLayerColor(this.m_layersToExport[i]![0]); hasActualColor = true; } else { layerName = acad_dxf_color_names[i]![0]; colorNumber = acad_dxf_color_names[i]![1]; } this.emit( ` 0\n` + `LAYER\n` + ` 5\n${this.nextHandle()}\n` + `330\n${layerTableHandle}\n` + `100\nAcDbSymbolTableRecord\n` + `100\nAcDbLayerTableRecord\n` + ` 2\n${layerName}\n` + ` 70\n0\n` + ` 62\n${colorNumber}\n`, ); if (hasActualColor) { // The legacy 62 index alone would lose the user's layer colour. const r = Math.trunc(actualColor.r * 255); const g = Math.trunc(actualColor.g * 255); const b = Math.trunc(actualColor.b * 255); const trueColorValue = (r << 16) | (g << 8) | b; this.emit(`420\n${trueColorValue}\n`); } this.emit(` 6\nCONTINUOUS\n390\n${this.m_plotStyleNormalHandle}\n`); } this.emit(` 0\n` + `ENDTAB\n`); // AutoCAD's R2000+ reader walks a fixed list of expected symbol tables and // aborts when one is absent; empty headers satisfy it. for (const tableName of ['VPORT', 'VIEW', 'UCS']) { this.emitSymbolTableHeader(tableName, 0); this.emit(` 0\nENDTAB\n`); } // DIMSTYLE is the only symbol table whose record handle uses group 105 // instead of 5, and whose header carries an extra subclass marker. const dimstyleTableHandle = this.emitSymbolTableHeader('DIMSTYLE', 1); this.emit( `100\nAcDbDimStyleTable\n` + ` 71\n0\n` + ` 0\n` + `DIMSTYLE\n` + `105\n${this.nextHandle()}\n` + `330\n${dimstyleTableHandle}\n` + `100\nAcDbSymbolTableRecord\n` + `100\nAcDbDimStyleTableRecord\n` + ` 2\nStandard\n` + ` 70\n0\n` + ` 0\n` + `ENDTAB\n`, ); // R2004 mandates three layout blocks; each BLOCK_RECORD carries a 340 // hard-pointer to its LAYOUT, so the LAYOUT handles are pre-allocated here // for EndPlot to use when it writes OBJECTS. const blockRecordTableHandle = this.emitSymbolTableHeader('BLOCK_RECORD', 3); this.m_modelSpaceHandle = this.nextHandle(); const paperSpaceBR = this.nextHandle(); const paperSpace0BR = this.nextHandle(); this.m_dxfLayouts = []; this.m_dxfLayouts.push({ name: 'Model', blockName: '*Model_Space', blockRecordHandle: this.m_modelSpaceHandle, layoutHandle: this.nextHandle(), isPaperSpace: false, }); this.m_dxfLayouts.push({ name: 'Layout1', blockName: '*Paper_Space', blockRecordHandle: paperSpaceBR, layoutHandle: this.nextHandle(), isPaperSpace: true, }); this.m_dxfLayouts.push({ name: 'Layout2', blockName: '*Paper_Space0', blockRecordHandle: paperSpace0BR, layoutHandle: this.nextHandle(), isPaperSpace: true, }); this.m_namedObjectDictHandle = this.nextHandle(); this.m_layoutDictHandle = this.nextHandle(); for (const l of this.m_dxfLayouts) { this.emit( ` 0\n` + `BLOCK_RECORD\n` + ` 5\n${l.blockRecordHandle}\n` + `330\n${blockRecordTableHandle}\n` + `100\nAcDbSymbolTableRecord\n` + `100\nAcDbBlockTableRecord\n` + ` 2\n${l.blockName}\n` + `340\n${l.layoutHandle}\n` + ` 70\n0\n` + `280\n1\n` + `281\n0\n`, ); } this.emit(` 0\n` + `ENDTAB\n` + ` 0\n` + `ENDSEC\n`); this.emit(` 0\n` + `SECTION\n` + ` 2\n` + `BLOCKS\n`); for (const l of this.m_dxfLayouts) { // The BLOCK and ENDBLK handles are two nextHandle() calls in one C++ // argument list, evaluated right to left by GCC (see the file docblock). const endblkHandle = this.nextHandle(); const blockHandle = this.nextHandle(); const ps = l.isPaperSpace ? ` 67\n1\n` : ''; this.emit( ` 0\n` + `BLOCK\n` + ` 5\n${blockHandle}\n` + `330\n${l.blockRecordHandle}\n` + `100\nAcDbEntity\n` + `${ps}` + ` 8\n0\n` + `100\nAcDbBlockBegin\n` + ` 2\n${l.blockName}\n` + ` 70\n0\n` + ` 10\n0.0\n 20\n0.0\n 30\n0.0\n` + ` 3\n${l.blockName}\n` + ` 1\n\n` + ` 0\n` + `ENDBLK\n` + ` 5\n${endblkHandle}\n` + `330\n${l.blockRecordHandle}\n` + `100\nAcDbEntity\n` + `${ps}` + ` 8\n0\n` + `100\nAcDbBlockEnd\n`, ); } this.emit(` 0\n` + `ENDSEC\n`); this.emit(` 0\n` + `SECTION\n` + ` 2\n` + `ENTITIES\n`); return true; } /** * `writeObjectsSection`. The LAYOUT field set and its ordering are what the * ODA File Converter writes for R2004 and the reader is order-sensitive: * group 2 must be present, ModelType (1024) must be off for the paperspace * layouts, and 147 must follow 76/77/78. The +/-1e+20 extents are the * AcDbLayout "uninitialised" sentinel and are literal text — String(1e20) * would spell them out in full and break the sentinel. */ private writeObjectsSection(): void { const acadGroupDictHandle = this.nextHandle(); this.emit( ` 0\n` + `SECTION\n` + ` 2\n` + `OBJECTS\n` + ` 0\n` + `DICTIONARY\n` + ` 5\n${this.m_namedObjectDictHandle}\n` + `330\n0\n` + `100\nAcDbDictionary\n` + `281\n1\n` + ` 3\nACAD_GROUP\n` + `350\n${acadGroupDictHandle}\n` + ` 3\nACAD_LAYOUT\n` + `350\n${this.m_layoutDictHandle}\n` + ` 3\nACAD_PLOTSTYLENAME\n` + `350\n${this.m_plotStyleNameDictHandle}\n`, ); // ACAD_GROUP - empty, but the named-object root requires it. this.emit( ` 0\n` + `DICTIONARY\n` + ` 5\n${acadGroupDictHandle}\n` + `330\n${this.m_namedObjectDictHandle}\n` + `100\nAcDbDictionary\n` + `281\n1\n`, ); // A dictionary with a default entry; every LAYER's 390 resolves through here. this.emit( ` 0\n` + `ACDBDICTIONARYWDFLT\n` + ` 5\n${this.m_plotStyleNameDictHandle}\n` + `330\n${this.m_namedObjectDictHandle}\n` + `100\nAcDbDictionary\n` + `281\n1\n` + ` 3\nNormal\n` + `350\n${this.m_plotStyleNormalHandle}\n` + `100\nAcDbDictionaryWithDefault\n` + `340\n${this.m_plotStyleNormalHandle}\n`, ); // No payload; it just gives the "Normal" plot style a resolvable handle. this.emit( ` 0\n` + `ACDBPLACEHOLDER\n` + ` 5\n${this.m_plotStyleNormalHandle}\n` + `330\n${this.m_plotStyleNameDictHandle}\n`, ); this.emit( ` 0\n` + `DICTIONARY\n` + ` 5\n${this.m_layoutDictHandle}\n` + `330\n${this.m_namedObjectDictHandle}\n` + `100\nAcDbDictionary\n` + `281\n1\n`, ); for (const l of this.m_dxfLayouts) this.emit(` 3\n${l.name}\n` + `350\n${l.layoutHandle}\n`); for (let i = 0; i < this.m_dxfLayouts.length; ++i) { const l = this.m_dxfLayouts[i]!; const plotLayoutFlag = l.isPaperSpace ? 0 : PLOT_FLAG_MODELTYPE; this.emit( ` 0\n` + `LAYOUT\n` + ` 5\n${l.layoutHandle}\n` + `330\n${this.m_layoutDictHandle}\n` + `100\nAcDbPlotSettings\n` + ` 1\n\n` + ` 2\nnone_device\n` + ` 4\n${PAPER_NAME}\n` + ` 6\n\n` + ` 40\n0.0\n 41\n0.0\n 42\n0.0\n 43\n0.0\n` + ` 44\n${PAPER_WIDTH_MM.toFixed(1)}\n 45\n${PAPER_HEIGHT_MM.toFixed(1)}\n 46\n0.0\n 47\n0.0\n` + ` 48\n0.0\n 49\n0.0\n` + `140\n0.0\n141\n0.0\n142\n1.0\n143\n1.0\n` + ` 70\n${plotLayoutFlag}\n` + ` 72\n1\n 73\n0\n 74\n5\n` + ` 7\n\n` + ` 75\n16\n` + ` 76\n0\n 77\n2\n 78\n300\n` + `147\n1.0\n` + `148\n0.0\n149\n0.0\n` + `100\nAcDbLayout\n` + ` 1\n${l.name}\n` + ` 70\n1\n` + ` 71\n${i}\n` + ` 10\n0.0\n 20\n0.0\n` + ` 11\n${PAPER_WIDTH_MM.toFixed(1)}\n 21\n${PAPER_HEIGHT_MM.toFixed(1)}\n` + ` 12\n0.0\n 22\n0.0\n 32\n0.0\n` + ` 14\n1e+20\n 24\n1e+20\n 34\n1e+20\n` + ` 15\n-1e+20\n 25\n-1e+20\n 35\n-1e+20\n` + `146\n0.0\n` + ` 13\n0.0\n 23\n0.0\n 33\n0.0\n` + ` 16\n1.0\n 26\n0.0\n 36\n0.0\n` + ` 17\n0.0\n 27\n1.0\n 37\n0.0\n` + ` 76\n0\n` + `330\n${l.blockRecordHandle}\n`, ); } this.emit(` 0\n` + `ENDSEC\n`); } /** `EndPlot`: close ENTITIES, write OBJECTS, then EOF. The file ends "EOF\n". */ EndPlot(): boolean { this.emit(` 0\n` + `ENDSEC\n`); this.writeObjectsSection(); this.emit(` 0\n` + `EOF\n`); return true; } // ========================================================================= // Pen // ========================================================================= /** * `PenTo`. Two behaviours matter to callers: 'Z' returns *before* recording * the position, so the pen still sits at the last drawn point after a * FinishTo and a bare LineTo would draw from there; and a move to the * position the pen already holds emits nothing at all, which is what makes * the duplicated vertices in upstream's chain walks harmless. * * Hand-rolled rather than routed through emitEntityHandle because group 6, * the linetype, has to sit between group 8 and the AcDbLine marker. */ PenTo(pos: Vec2, plume: PEN_PLUME): void { if (plume === 'Z') return; const pos_dev = this.userToDeviceCoordinates(pos); const pen_lastpos_dev = this.userToDeviceCoordinates(this.m_penLastpos); if ((this.m_penLastpos.x !== pos.x || this.m_penLastpos.y !== pos.y) && plume === 'D') { const layer = this.GetCurrentLayerName(DXF_LAYER_OUTPUT_MODE.Current_Layer_Name); const lname = getDXFLineType(this.m_currentLineType); this.emit( ` 0\nLINE\n` + ` 5\n${this.nextHandle()}\n` + `330\n${this.m_modelSpaceHandle}\n` + `100\nAcDbEntity\n` + ` 8\n${layer}\n` + ` 6\n${lname}\n` + `100\nAcDbLine\n` + ` 10\n${formatCoord(pen_lastpos_dev.x)}\n 20\n${formatCoord(pen_lastpos_dev.y)}\n 30\n0\n` + ` 11\n${formatCoord(pos_dev.x)}\n 21\n${formatCoord(pos_dev.y)}\n 31\n0\n`, ); } this.m_penLastpos = pos; } // ========================================================================= // Entities // ========================================================================= /** * `Rect`. The fill argument is ignored outright — a filled rectangle comes * out as an outline — and the walk goes down the left edge first. A * degenerate rectangle becomes a POINT. */ Rect(p1: Vec2, p2: Vec2, _fill: FILL_T, _width: number, aCornerRadius = 0): void { if (aCornerRadius > 0) { // Needs SHAPE_RECT with a corner radius and the thick PlotPoly path. throw new Error('DXF Rect with a corner radius is not ported (needs SHAPE_RECT::SetRadius)'); } if (p1.x !== p2.x || p1.y !== p2.y) { this.MoveTo(p1); this.LineTo({ x: p1.x, y: p2.y }); this.LineTo({ x: p2.x, y: p2.y }); this.LineTo({ x: p2.x, y: p1.y }); this.FinishTo({ x: p1.x, y: p1.y }); } else { // Draw as a point const cLayerName = this.GetCurrentLayerName(DXF_LAYER_OUTPUT_MODE.Current_Layer_Name); const point_dev = this.userToDeviceCoordinates(p1); this.emitEntityHandle('POINT', 'AcDbPoint', cLayerName); // Group 30 is the bare literal "0", not formatCoord(0)'s "0.". this.emit(` 10\n${formatCoord(point_dev.x)}\n 20\n${formatCoord(point_dev.y)}\n 30\n0\n`); } } /** * `Circle`. `diameter / 2` is C++ integer division, so an odd diameter loses * half an IU before it is ever scaled. NO_FILL gives a CIRCLE; FILLED_SHAPE * gives the two-vertex bulged POLYLINE trick below; any *other* fill value * falls off the end of the if/else-if and emits nothing whatsoever. */ Circle(centre: Vec2, diameter: number, fill: FILL_T, _width: number): void { const radius = this.userToDeviceSize(Math.trunc(diameter / 2)); const centre_dev = this.userToDeviceCoordinates(centre); const layer = this.GetCurrentLayerName(DXF_LAYER_OUTPUT_MODE.Current_Layer_Name); if (radius > 0) { if (fill === FILL_T.NO_FILL) { this.emitEntityHandle('CIRCLE', 'AcDbCircle', layer); this.emit( ` 10\n${formatCoord(centre_dev.x)}\n 20\n${formatCoord(centre_dev.y)}\n 30\n0\n` + ` 40\n${formatCoord(radius)}\n`, ); } else if (fill === FILL_T.FILLED_SHAPE) { const r = radius * 0.5; // The fill is a closed two-vertex polyline whose *width* is the full // radius (groups 40/41) and whose vertices sit at half the radius either // side of the centre with bulge 1.0, i.e. two semicircles. 10/20/30 is // the elevation dummy point AutoCAD rejects the entity without. Owner of // the VERTEX records and the SEQEND is the POLYLINE, not *Model_Space. const polyHandle = this.emitEntityHandle('POLYLINE', 'AcDb2dPolyline', layer); const rStr = formatCoord(radius); this.emit(` 66\n1\n 10\n0\n 20\n0\n 30\n0\n 70\n1\n 40\n${rStr}\n 41\n${rStr}\n`); for (const offset of [-r, r]) { this.emitEntityHandle('VERTEX', 'AcDbVertex', layer, polyHandle); this.emit( `100\nAcDb2dVertex\n` + ` 10\n${formatCoord(centre_dev.x + offset)}\n 20\n${formatCoord(centre_dev.y)}\n 30\n0\n 42\n1.0\n`, ); } this.emitEntityHandle('SEQEND', null, layer, polyHandle); } } else { // Draw as a point this.emitEntityHandle('POINT', 'AcDbPoint', layer); this.emit(` 10\n${formatCoord(centre_dev.x)}\n 20\n${formatCoord(centre_dev.y)}\n 30\n0\n`); } } /** * `PlotPoly( const std::vector& )`. Every caller inside this class * passes width -2, so the stroked branch is the only one they reach; the * polygon is closed only when a fill was asked for. */ PlotPoly(aCornerList: readonly Vec2[], aFill: FILL_T, aWidth: number, _aData?: unknown): void { if (aCornerList.length <= 1) return; const last = aCornerList.length - 1; // Plot outlines with lines (thickness = 0) to define the polygon if (aWidth <= 0 || aFill === FILL_T.NO_FILL) { this.MoveTo(aCornerList[0]!); for (let ii = 1; ii < aCornerList.length; ii++) this.LineTo(aCornerList[ii]!); // Close polygon if 'fill' requested if (aFill !== FILL_T.NO_FILL) { if ( aCornerList[last]!.x !== aCornerList[0]!.x || aCornerList[last]!.y !== aCornerList[0]!.y ) this.LineTo(aCornerList[0]!); } this.PenFinish(); return; } // The thick-outline-plus-fill branch unions a TransformOvalToPolygon per // segment (excluding the closing one) with the raw polygon; kimath has no // TransformOvalToPolygon yet, so it is deliberately unreachable rather than // approximated. throw new Error( 'DXF PlotPoly with a thick filled outline is not ported (needs TransformOvalToPolygon)', ); } /** * `Arc`. The start angle is negated and the sweep subtracted from it, then * the pair is swapped if it came out clockwise, because DXF arcs are CCW. * Both angles go out in degrees *unnormalised*, so negative values — and the * negative zero that a zero start angle produces — appear verbatim. * * `aCenter` is a VECTOR2D upstream and userToDeviceCoordinates takes a * VECTOR2I, so C++ truncates it towards zero on the way in; Math.trunc here * reproduces that. */ override Arc( aCenter: Vec2, aStartAngle: EDA_ANGLE, aAngle: EDA_ANGLE, aRadius: number, _aFill: FILL_T, _aWidth: number, ): void { if (aRadius <= 0) return; let startAngle = aStartAngle.negate(); let endAngle = startAngle.sub(aAngle); if (endAngle.lt(startAngle)) [startAngle, endAngle] = [endAngle, startAngle]; const centre_device = this.userToDeviceCoordinates({ x: Math.trunc(aCenter.x), y: Math.trunc(aCenter.y), }); const radius_device = this.userToDeviceSize(aRadius); // Two subclass markers, AcDbCircle then AcDbArc; reversing them trips // AutoCAD's validator. const layer = this.GetCurrentLayerName(DXF_LAYER_OUTPUT_MODE.Current_Layer_Name); this.emitEntityHandle('ARC', 'AcDbCircle', layer); this.emit( ` 10\n${formatCoord(centre_device.x)}\n 20\n${formatCoord(centre_device.y)}\n 30\n0\n` + ` 40\n${formatCoord(radius_device)}\n` + `100\nAcDbArc\n` + ` 50\n${formatAngle(startAngle.AsDegrees())}\n 51\n${formatAngle(endAngle.AsDegrees())}\n`, ); } // ========================================================================= // Thick primitives // ========================================================================= /** * `ThickSegment`. In FILLED mode a zero-length segment emits nothing at all: * the base class would draw a filled circle there, but DXF overrides the * whole method and PenTo drops the equal-position move. */ override ThickSegment(aStart: Vec2, aEnd: Vec2, _aWidth: number, aData?: DxfPlotParams): void { if (aData && aData.GetDXFPlotMode() === DXF_OUTLINE_MODE.SKETCH) { throw new Error( 'DXF ThickSegment in SKETCH mode is not ported (needs TransformOvalToPolygon)', ); } else { this.MoveTo(aStart); this.FinishTo(aEnd); } } /** `ThickArc`. `aWidth / 2` is integer division, hence the Math.trunc. */ override ThickArc( centre: Vec2, aStartAngle: EDA_ANGLE, aAngle: EDA_ANGLE, aRadius: number, aWidth: number, aData?: DxfPlotParams, ): void { if (aData && aData.GetDXFPlotMode() === DXF_OUTLINE_MODE.SKETCH) { const half = Math.trunc(aWidth / 2); this.Arc(centre, aStartAngle, aAngle, aRadius - half, FILL_T.NO_FILL, DXF_LINE_WIDTH); this.Arc(centre, aStartAngle, aAngle, aRadius + half, FILL_T.NO_FILL, DXF_LINE_WIDTH); } else { this.Arc(centre, aStartAngle, aAngle, aRadius, FILL_T.NO_FILL, DXF_LINE_WIDTH); } } /** * `ThickRect`. The inner rectangle is produced by mutating the *already * offset* corners by the full width, so for an odd width the two rectangles * are not concentric: width 5 gives an outer edge at p1 - 2 and an inner one * at p1 + 3. Computing p1 + width/2 instead would diverge. */ override ThickRect(p1: Vec2, p2: Vec2, width: number, aData?: DxfPlotParams): void { if (aData && aData.GetDXFPlotMode() === DXF_OUTLINE_MODE.SKETCH) { const half = Math.trunc(width / 2); const offsetp1 = { x: p1.x - half, y: p1.y - half }; const offsetp2 = { x: p2.x + half, y: p2.y + half }; this.Rect(offsetp1, offsetp2, FILL_T.NO_FILL, DXF_LINE_WIDTH, 0); offsetp1.x += width; offsetp1.y += width; offsetp2.x -= width; offsetp2.y -= width; this.Rect(offsetp1, offsetp2, FILL_T.NO_FILL, DXF_LINE_WIDTH, 0); } else { this.Rect(p1, p2, FILL_T.NO_FILL, DXF_LINE_WIDTH, 0); } } /** `ThickCircle`. */ override ThickCircle(pos: Vec2, diametre: number, width: number, aData?: DxfPlotParams): void { if (aData && aData.GetDXFPlotMode() === DXF_OUTLINE_MODE.SKETCH) { this.Circle(pos, diametre - width, FILL_T.NO_FILL, DXF_LINE_WIDTH); this.Circle(pos, diametre + width, FILL_T.NO_FILL, DXF_LINE_WIDTH); } else { this.Circle(pos, diametre, FILL_T.NO_FILL, DXF_LINE_WIDTH); } } /** `FilledCircle`, the only internal caller that reaches the POLYLINE fill. */ override FilledCircle(pos: Vec2, diametre: number, aData?: DxfPlotParams): void { if (aData && aData.GetDXFPlotMode() === DXF_OUTLINE_MODE.SKETCH) this.Circle(pos, diametre, FILL_T.NO_FILL, DXF_LINE_WIDTH); else this.Circle(pos, diametre, FILL_T.FILLED_SHAPE, 0); } // ========================================================================= // Pad flashes - DXF draws every pad in sketch mode // ========================================================================= /** `FlashPadCircle`. */ FlashPadCircle(pos: Vec2, diametre: number, _aData?: unknown): void { this.Circle(pos, diametre, FILL_T.NO_FILL, DXF_LINE_WIDTH); } /** `FlashPadOval`: normalise to a vertical tablet, then hand to ThickOval. */ FlashPadOval(aPos: Vec2, aSize: Vec2, aOrient: EDA_ANGLE, aData?: unknown): void { const size = { x: aSize.x, y: aSize.y }; let orient = aOrient; /* The chip is reduced to an oval tablet with size.y > size.x * (Oval vertical orientation 0) */ if (size.x > size.y) { [size.x, size.y] = [size.y, size.x]; orient = orient.add(ANGLE_90); } this.ThickOval(aPos, size, orient, DXF_LINE_WIDTH, aData); } /** * `FlashPadRect`. Half sizes are integer divisions clamped at zero, and a * pad that is zero-wide or zero-high degenerates to a single stroke. */ FlashPadRect(aPos: Vec2, aPadSize: Vec2, aOrient: EDA_ANGLE, _aData?: unknown): void { const size = { x: Math.trunc(aPadSize.x / 2), y: Math.trunc(aPadSize.y / 2) }; if (size.x < 0) size.x = 0; if (size.y < 0) size.y = 0; // If a dimension is zero, the trace is reduced to 1 line if (size.x === 0) { const start = RotatePoint({ x: aPos.x, y: aPos.y - size.y }, aPos, aOrient); const end = RotatePoint({ x: aPos.x, y: aPos.y + size.y }, aPos, aOrient); this.MoveTo(start); this.FinishTo(end); return; } if (size.y === 0) { const start = RotatePoint({ x: aPos.x - size.x, y: aPos.y }, aPos, aOrient); const end = RotatePoint({ x: aPos.x + size.x, y: aPos.y }, aPos, aOrient); this.MoveTo(start); this.FinishTo(end); return; } const start = RotatePoint({ x: aPos.x - size.x, y: aPos.y - size.y }, aPos, aOrient); this.MoveTo(start); this.LineTo(RotatePoint({ x: aPos.x - size.x, y: aPos.y + size.y }, aPos, aOrient)); this.LineTo(RotatePoint({ x: aPos.x + size.x, y: aPos.y + size.y }, aPos, aOrient)); this.LineTo(RotatePoint({ x: aPos.x + size.x, y: aPos.y - size.y }, aPos, aOrient)); this.FinishTo(start); } /** `FlashPadRoundRect`: the outline walked as lines. */ FlashPadRoundRect( aPadPos: Vec2, aSize: Vec2, aCornerRadius: number, aOrient: EDA_ANGLE, _aData?: unknown, ): void { const outline = new SHAPE_POLY_SET(); TransformRoundChamferedRectToPolygon( outline, aPadPos, aSize, aOrient, aCornerRadius, 0.0, 0, 0, this.GetPlotterArcHighDef(), ERROR_LOC.ERROR_INSIDE, ); // TransformRoundRectToPolygon creates only one convex polygon const poly = outline.Outline(0); this.MoveTo({ x: poly.CPoint(0).x, y: poly.CPoint(0).y }); for (let ii = 1; ii < poly.PointCount(); ++ii) this.LineTo({ x: poly.CPoint(ii).x, y: poly.CPoint(ii).y }); this.FinishTo({ x: poly.CPoint(0).x, y: poly.CPoint(0).y }); } /** * `FlashPadCustom`. Position, size and orientation are all ignored: the * polygons arrive already placed. Holes are not plotted: upstream walks * Outline(cnt) for every outline index. */ FlashPadCustom( _aPadPos: Vec2, _aSize: Vec2, _aOrient: EDA_ANGLE, aPolygons: SHAPE_POLY_SET, _aData?: unknown, ): void { for (let cnt = 0; cnt < aPolygons.OutlineCount(); ++cnt) { const poly = aPolygons.Outline(cnt); this.MoveTo({ x: poly.CPoint(0).x, y: poly.CPoint(0).y }); for (let ii = 1; ii < poly.PointCount(); ++ii) this.LineTo({ x: poly.CPoint(ii).x, y: poly.CPoint(ii).y }); this.FinishTo({ x: poly.CPoint(0).x, y: poly.CPoint(0).y }); } } /** `FlashPadTrapez`. The corners rotate about the ORIGIN, then translate. */ FlashPadTrapez( aPadPos: Vec2, aCorners: readonly Vec2[], aPadOrient: EDA_ANGLE, _aData?: unknown, ): void { const coord: Vec2[] = []; for (let ii = 0; ii < 4; ii++) { const rotated = RotatePoint(aCorners[ii]!, aPadOrient); coord.push({ x: rotated.x + aPadPos.x, y: rotated.y + aPadPos.y }); } // Plot edge: this.MoveTo(coord[0]!); this.LineTo(coord[1]!); this.LineTo(coord[2]!); this.LineTo(coord[3]!); this.FinishTo(coord[0]!); } /** `FlashRegularPolygon`: upstream is a wxASSERT(0) and does nothing. */ FlashRegularPolygon( _aShapePos: Vec2, _aRadius: number, _aCornerCount: number, _aOrient: EDA_ANGLE, _aData?: unknown, ): void { // Do nothing } // ========================================================================= // Text // ========================================================================= /** * `Text`. The same guard as PlotText; the native path builds its own * TEXT_ATTRIBUTES and, as upstream does, never sets `m_Size` on it, so the * TEXT entity it writes has the default-constructed (0,0) 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 { let multilineAllowed = aMultilineAllowed; // Fix me: see how to use DXF text mode for multiline texts if (multilineAllowed && !aText.includes('\n')) multilineAllowed = false; // the text has only one line. const processSuperSub = aText.includes('^{') || aText.includes('_{'); if (this.m_textAsLines || containsNonAsciiChars(aText) || multilineAllowed || processSuperSub) { // output text as graphics. // Perhaps multiline texts could be handled as DXF text entity // but I do not want spend time about this (JPC) super.Text( aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, aWidth, aItalic, aBold, multilineAllowed, aFont, aFontMetrics, aData, ); } else { const attrs: PLOTTER_TEXT_ATTRIBUTES = { m_Size: { x: 0, y: 0 }, m_Halign: aH_justify, m_Valign: aV_justify, m_StrokeWidth: aWidth, m_Angle: aOrient, m_Italic: aItalic, m_Bold: aBold, m_Mirrored: aSize.x < 0, m_Multiline: false, }; this.plotOneLineOfText(aPos, aColor, aText, attrs); } } /** * `PlotText`, the entry point pcbnew uses for every string it plots. * * The guard below is why a plain plot never contains a TEXT entity: the * constructor leaves m_textAsLines true, so unless the caller has asked for * PLOT_TEXT_MODE::NATIVE the text is stroked into LINE entities instead. */ override PlotText( aPos: Vec2, aColor: Color4d, aText: string, aAttributes: PLOTTER_TEXT_ATTRIBUTES, aFont: PLOTTER_FONT | null = null, aFontMetrics?: unknown, aData?: unknown, ): void { const attrs: PLOTTER_TEXT_ATTRIBUTES = { ...aAttributes }; // Fix me: see how to use DXF text mode for multiline texts if (attrs.m_Multiline && !aText.includes('\n')) attrs.m_Multiline = false; const processSuperSub = aText.includes('^{') || aText.includes('_{'); if ( this.m_textAsLines || containsNonAsciiChars(aText) || attrs.m_Multiline || processSuperSub ) { // output text as graphics. // Perhaps multiline texts could be handled as DXF text entity // but I do not want spend time about that (JPC) super.PlotText(aPos, aColor, aText, aAttributes, aFont, aFontMetrics, aData); } else { this.plotOneLineOfText(aPos, aColor, aText, attrs); } } /** * `plotOneLineOfText`. Emit text as a TEXT entity: this loses formatting and * shape but is far more useful as a CAD object. * * SetColor runs before the layer name is resolved, and that order is load * bearing: with an empty export list the layer name is derived from the * colour this call just stored. * * Group 73 must follow a *second* AcDbText marker, and the vertical alignment * codes are TOP 3 / CENTER 2 / BOTTOM 1 — neither zero-based nor in the same * direction as the horizontal 0/1/2. */ private plotOneLineOfText( aPos: Vec2, aColor: Color4d, aText: string, aAttributes: PLOTTER_TEXT_ATTRIBUTES, ): void { const origin_dev = this.userToDeviceCoordinates(aPos); this.SetColor(aColor); const cLayerName = this.GetCurrentLayerName(DXF_LAYER_OUTPUT_MODE.Current_Layer_Name); const size_dev = this.userToDeviceSizeV(aAttributes.m_Size); let h_code = 0; let v_code = 0; switch (aAttributes.m_Halign) { case GR_TEXT_H_ALIGN_T.GR_TEXT_H_ALIGN_LEFT: h_code = 0; break; case GR_TEXT_H_ALIGN_T.GR_TEXT_H_ALIGN_CENTER: h_code = 1; break; case GR_TEXT_H_ALIGN_T.GR_TEXT_H_ALIGN_RIGHT: h_code = 2; break; } switch (aAttributes.m_Valign) { case GR_TEXT_V_ALIGN_T.GR_TEXT_V_ALIGN_TOP: v_code = 3; break; case GR_TEXT_V_ALIGN_T.GR_TEXT_V_ALIGN_CENTER: v_code = 2; break; case GR_TEXT_V_ALIGN_T.GR_TEXT_V_ALIGN_BOTTOM: v_code = 1; break; } let textStyle = 'KICAD'; if (aAttributes.m_Bold) { if (aAttributes.m_Italic) textStyle = 'KICADBI'; else textStyle = 'KICADB'; } else if (aAttributes.m_Italic) { textStyle = 'KICADI'; } this.emitEntityHandle('TEXT', 'AcDbText', cLayerName); this.emit( ` 10\n${formatCoord(origin_dev.x)}\n 20\n${formatCoord(origin_dev.y)}\n 30\n0\n` + ` 40\n${formatCoord(size_dev.y)}\n`, ); this.emit(` 1\n`); escapeDxfText( aText, (byte) => this.putLatin1(byte), (s) => this.emit(s), ); this.emit(`\n`); this.emit( ` 50\n${formatAngle(aAttributes.m_Angle.AsDegrees())}\n` + ` 41\n${formatCoord(Math.abs(size_dev.x / size_dev.y))}\n` + ` 51\n${formatAngle(aAttributes.m_Italic ? DXF_OBLIQUE_ANGLE : 0)}\n` + ` 7\n${textStyle}\n` + ` 71\n${aAttributes.m_Mirrored ? 2 : 0}\n` + ` 72\n${h_code}\n` + ` 11\n${formatCoord(origin_dev.x)}\n 21\n${formatCoord(origin_dev.y)}\n 31\n0\n` + `100\nAcDbText\n` + ` 73\n${v_code}\n`, ); } } /** * `containsNonAsciiChars`. Despite the name the cut is at 255, not 127, so * Latin-1 counts as ASCII here and only genuinely wide characters push the * caller onto the stroked path. */ export function containsNonAsciiChars(aString: string): boolean { for (let i = 0; i < aString.length; i++) { if (aString.charCodeAt(i) > 255) return true; } return false; } /** * The group-1 string escaper inside plotOneLineOfText, split out so it can be * tested on its own. * * Encoding: DXF's is unspecified enough that upstream settles on Latin-1 and * writes each character as one raw byte; anything above 255 becomes '?'. That * is why this takes a byte sink rather than returning a string. * * Overbars: only the '~{' pair and the '}' that closes it are consumed. A '{' * that is not part of '~{', and a '}' that closes something else, are written * out as themselves. * * Records longer than 255 bytes should be split across group-3 chunks. Upstream * says so in a comment and then does not do it, so neither does this. */ export function escapeDxfText( aText: string, put: (aByte: number) => void, emit: (aText: string) => void, ): void { let braceNesting = 0; let overbarDepth = -1; for (let i = 0; i < aText.length; i++) { const ch = aText.charCodeAt(i); if (ch > 255) { // I can't encode this... put('?'.charCodeAt(0)); } else { if (aText[i] === '~' && i + 1 < aText.length && aText[i + 1] === '{') { emit('%%o'); overbarDepth = braceNesting; // Skip the '{' i++; continue; } else if (aText[i] === '{') { braceNesting++; } else if (aText[i] === '}') { if (braceNesting > 0) braceNesting--; if (braceNesting === overbarDepth) { emit('%%O'); overbarDepth = -1; continue; } } put(ch); } } }