Files
likang 7e01147566
CI / typecheck + test + build (push) Has been cancelled
Initial commit: import VibeMake PCB Studio
2026-11-03 11:20:08 +08:00

1514 lines
53 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.
/**
* PADSTACK (pcbnew/padstack.h / pcbnew/padstack.cpp).
*/
// ---------------------------------------------------------------------------
// PADSTACK (pcbnew/padstack.h / pcbnew/padstack.cpp)
//
// `Serialize`/`Deserialize` (protobuf) are
// not here. `std::unordered_map` has no defined order; `m_copperProps` is a
// `Map` in insertion order, which is what `ForEachUniqueLayer` walks in
// CUSTOM mode.
import {
IsBackLayer,
IsFrontLayer,
IsNonCopperLayer,
PCB_LAYER_ID,
} from '@ziroeda/common/layer_id.js';
import { LSET } from '@ziroeda/common/lset.js';
import {
ANGLE_0,
ANGLE_45,
ANGLE_90,
type EDA_ANGLE,
} from '@ziroeda/kimath/src/geometry/eda_angle.js';
import { KiROUND } from '@ziroeda/kimath/src/math/util.js';
import type { VECTOR2I } from '@ziroeda/kimath/src/math/vector2.js';
import type { BOARD } from './board.js';
import type { BOARD_ITEM } from './board_item.js';
import type { EDA_SHAPE } from '@ziroeda/common/eda_shape.js';
import type { PCB_SHAPE } from './pcb_shape.js';
import { ZONE_CONNECTION } from './zones.js';
import { ENUM_MAP } from '@ziroeda/common/properties/property.js';
/**
* `IMPLEMENT_ENUM_TO_WXANY( PAD_DRILL_POST_MACHINING_MODE )` and
* `( BACKDRILL_MODE )` (padstack.cpp:39): the two enum maps, filled the way
* `PAD_DESC` fills them ("Ensure ... enum choices are defined before
* properties use them"). The C++ relies on pad.cpp's static initialiser
* running before pcb_track.cpp's; a module here has no such order, so both
* `_DESC`s call this before registering a property on either enum.
*/
export function EnsurePadstackEnumChoices(): void {
const pmMap = ENUM_MAP.Instance<PAD_DRILL_POST_MACHINING_MODE>('PAD_DRILL_POST_MACHINING_MODE');
if (pmMap.Choices().GetCount() === 0) {
pmMap
.Undefined(PAD_DRILL_POST_MACHINING_MODE.UNKNOWN)
.Map(PAD_DRILL_POST_MACHINING_MODE.NOT_POST_MACHINED, 'Not post-machined')
.Map(PAD_DRILL_POST_MACHINING_MODE.COUNTERBORE, 'Counterbore')
.Map(PAD_DRILL_POST_MACHINING_MODE.COUNTERSINK, 'Countersink');
}
const bdMap = ENUM_MAP.Instance<BACKDRILL_MODE>('BACKDRILL_MODE');
if (bdMap.Choices().GetCount() === 0) {
bdMap
.Undefined(BACKDRILL_MODE.NO_BACKDRILL)
.Map(BACKDRILL_MODE.NO_BACKDRILL, 'No backdrill')
.Map(BACKDRILL_MODE.BACKDRILL_BOTTOM, 'Backdrill bottom')
.Map(BACKDRILL_MODE.BACKDRILL_TOP, 'Backdrill top')
.Map(BACKDRILL_MODE.BACKDRILL_BOTH, 'Backdrill both');
}
}
export enum PAD_SHAPE {
CIRCLE = 0,
RECTANGLE = 1, // do not use just RECT: it collides in a header on MSYS2
OVAL = 2,
TRAPEZOID = 3,
ROUNDRECT = 4,
// Rectangle with a chamfered corner ( and with rounded other corners).
CHAMFERED_RECT = 5,
CUSTOM = 6, // A shape defined by user, using a set of basic shapes
// (thick segments, circles, arcs, polygons).
}
export enum PAD_DRILL_SHAPE {
UNDEFINED = 0,
CIRCLE = 1,
OBLONG = 2,
}
export enum PAD_DRILL_POST_MACHINING_MODE {
UNKNOWN = 0,
NOT_POST_MACHINED = 1,
COUNTERBORE = 2,
COUNTERSINK = 3,
}
export enum BACKDRILL_MODE {
NO_BACKDRILL = 0,
BACKDRILL_BOTTOM = 1,
BACKDRILL_TOP = 2,
BACKDRILL_BOTH = 3,
}
/**
* The set of pad shapes, used with PAD::{Set,Get}Attribute()
*
* The double name is for convenience of Python devs
*/
export enum PAD_ATTRIB {
PTH = 0, ///< Plated through hole pad
SMD = 1, ///< Smd pad, appears on the solder paste layer (default)
CONN = 2, ///< Like smd, does not appear on the solder paste layer (default)
///< Note: also has a special attribute in Gerber X files
///< Used for edgecard connectors for instance
NPTH = 3, ///< like PAD_PTH, but not plated
///< mechanical use only, no connection allowed
}
/**
* The set of pad properties used in Gerber files (Draw files, and P&P files)
* to define some properties in fabrication or test files.
*/
export enum PAD_PROP {
NONE = 0, ///< no special fabrication property
BGA = 1, ///< Smd pad, used in BGA footprints
FIDUCIAL_GLBL = 2, ///< a fiducial (usually a smd) for the full board
FIDUCIAL_LOCAL = 3, ///< a fiducial (usually a smd) local to the parent footprint
TESTPOINT = 4, ///< a test point pad
HEATSINK = 5, ///< a pad used as heat sink, usually in SMD footprints
CASTELLATED = 6, ///< a pad with a castellated through hole
MECHANICAL = 7, ///< a pad used for mechanical support
PRESSFIT = 8, ///< a PTH with a hole diameter with tight tolerances for press fit pin
}
export enum UNCONNECTED_LAYER_MODE {
KEEP_ALL = 0,
START_END_ONLY = 1,
REMOVE_ALL = 2,
REMOVE_EXCEPT_START_AND_END = 3,
}
export enum CUSTOM_SHAPE_ZONE_MODE {
OUTLINE = 0,
CONVEXHULL = 1,
}
///! Padstack type, mostly for IPC-7351 naming and attributes
///! Note that TYPE::MOUNTING is probably not currently supported by KiCad
export enum PADSTACK_TYPE {
NORMAL = 0, ///< Padstack for a footprint pad
VIA = 1, ///< Padstack for a via
MOUNTING = 2, ///< A mounting hole (plated or unplated, not associated with a footprint)
}
///! Copper geometry mode: controls how many unique copper layer shapes this padstack has
export enum PADSTACK_MODE {
NORMAL = 0, ///< Shape is the same on all layers
FRONT_INNER_BACK = 1, ///< Up to three shapes can be defined (F_Cu, inner copper layers, B_Cu)
CUSTOM = 2, ///< Shapes can be defined on arbitrary layers
}
const vecEq = (a: VECTOR2I, b: VECTOR2I): boolean => a.x === b.x && a.y === b.y;
/** `#define TEST( a, b ) { if( a != b ) return a - b; }` as an expression: 0 when equal. */
const test = (a: number, b: number): number => a - b;
/** `TEST_OPT( a, b, v )`: presence first, then the values with `v` for a missing one. */
function testOpt(
a: number | boolean | undefined,
b: number | boolean | undefined,
v: number | boolean,
): number {
if ((a !== undefined) !== (b !== undefined))
return Number(a !== undefined) - Number(b !== undefined);
return Number(a ?? v) - Number(b ?? v);
}
///! The set of properties that define a pad's shape on a given layer
export class PADSTACK_SHAPE_PROPS {
shape: PAD_SHAPE; ///< Shape of the pad
anchor_shape: PAD_SHAPE; ///< Shape of the anchor when shape == PAD_SHAPE::CUSTOM
size: VECTOR2I; ///< Size of the shape, or of the anchor pad for custom shape pads
/*
* Most of the time the hole is the center of the shape (m_Offset = 0). But some designers
* use oblong/rect pads with a hole moved to one of the oblong/rect pad shape ends.
* In all cases the hole is at the pad position. This offset is from the hole to the center
* of the pad shape (ie: the copper area around the hole).
* ShapePos() returns the board shape position according to the offset and the pad rotation.
*/
offset: VECTOR2I; ///< Offset of the shape center from the pad center
round_rect_radius_ratio: number;
chamfered_rect_ratio: number; ///< Size of chamfer: ratio of smallest of X,Y size
chamfered_rect_positions: number; ///< @see RECT_CHAMFER_POSITIONS
trapezoid_delta_size: VECTOR2I;
constructor() {
this.shape = PAD_SHAPE.CIRCLE;
this.anchor_shape = PAD_SHAPE.RECTANGLE;
this.size = { x: 0, y: 0 };
this.offset = { x: 0, y: 0 };
this.round_rect_radius_ratio = 0.0;
this.chamfered_rect_ratio = 0.0;
this.chamfered_rect_positions = 0;
this.trapezoid_delta_size = { x: 0, y: 0 };
}
clone(): PADSTACK_SHAPE_PROPS {
const c = new PADSTACK_SHAPE_PROPS();
c.shape = this.shape;
c.anchor_shape = this.anchor_shape;
c.size = { x: this.size.x, y: this.size.y };
c.offset = { x: this.offset.x, y: this.offset.y };
c.round_rect_radius_ratio = this.round_rect_radius_ratio;
c.chamfered_rect_ratio = this.chamfered_rect_ratio;
c.chamfered_rect_positions = this.chamfered_rect_positions;
c.trapezoid_delta_size = { x: this.trapezoid_delta_size.x, y: this.trapezoid_delta_size.y };
return c;
}
equals(aOther: PADSTACK_SHAPE_PROPS): boolean {
return (
this.shape === aOther.shape &&
this.anchor_shape === aOther.anchor_shape &&
vecEq(this.size, aOther.size) &&
vecEq(this.offset, aOther.offset) &&
this.round_rect_radius_ratio === aOther.round_rect_radius_ratio &&
this.chamfered_rect_ratio === aOther.chamfered_rect_ratio &&
this.chamfered_rect_positions === aOther.chamfered_rect_positions &&
vecEq(this.trapezoid_delta_size, aOther.trapezoid_delta_size)
);
}
Compare(aOther: PADSTACK_SHAPE_PROPS): number {
let d: number;
d = test(this.shape, aOther.shape);
if (d !== 0) return d;
d = test(this.anchor_shape, aOther.anchor_shape);
if (d !== 0) return d;
d = test(this.size.x, aOther.size.x);
if (d !== 0) return d;
if (
this.shape !== PAD_SHAPE.CIRCLE &&
(this.shape !== PAD_SHAPE.CUSTOM || this.anchor_shape !== PAD_SHAPE.CIRCLE)
) {
d = test(this.size.y, aOther.size.y);
if (d !== 0) return d;
}
d = test(this.offset.x, aOther.offset.x);
if (d !== 0) return d;
d = test(this.offset.y, aOther.offset.y);
if (d !== 0) return d;
if (Math.abs(this.round_rect_radius_ratio - aOther.round_rect_radius_ratio) > 0.0001)
return this.round_rect_radius_ratio > aOther.round_rect_radius_ratio ? 1 : -1;
if (Math.abs(this.chamfered_rect_ratio - aOther.chamfered_rect_ratio) > 0.0001)
return this.chamfered_rect_ratio > aOther.chamfered_rect_ratio ? 1 : -1;
d = test(this.chamfered_rect_positions, aOther.chamfered_rect_positions);
if (d !== 0) return d;
return 0;
}
}
export class PADSTACK_COPPER_LAYER_PROPS {
shape = new PADSTACK_SHAPE_PROPS();
zone_connection: ZONE_CONNECTION | undefined;
thermal_spoke_width: number | undefined;
thermal_spoke_angle: EDA_ANGLE | undefined;
thermal_gap: number | undefined;
clearance: number | undefined;
/*
* How to build the custom shape in zone, to create the clearance area:
* CUSTOM_SHAPE_ZONE_MODE::OUTLINE = use pad shape
* CUSTOM_SHAPE_ZONE_MODE::CONVEXHULL = use the convex hull of the pad shape
*/
custom_shapes: PCB_SHAPE[] = [];
/** The value copy `std::unordered_map<PCB_LAYER_ID, COPPER_LAYER_PROPS>` makes. */
clone(): PADSTACK_COPPER_LAYER_PROPS {
const c = new PADSTACK_COPPER_LAYER_PROPS();
c.shape = this.shape.clone();
c.zone_connection = this.zone_connection;
c.thermal_spoke_width = this.thermal_spoke_width;
c.thermal_spoke_angle = this.thermal_spoke_angle;
c.thermal_gap = this.thermal_gap;
c.clearance = this.clearance;
c.custom_shapes = [...this.custom_shapes]; // shared_ptr copies share the shapes
return c;
}
/** The implicit `operator=`: `padStack.CopperLayer( F_Cu ) = props`. */
assign(aOther: PADSTACK_COPPER_LAYER_PROPS): this {
this.shape = aOther.shape.clone();
this.zone_connection = aOther.zone_connection;
this.thermal_spoke_width = aOther.thermal_spoke_width;
this.thermal_spoke_angle = aOther.thermal_spoke_angle;
this.thermal_gap = aOther.thermal_gap;
this.clearance = aOther.clearance;
this.custom_shapes = [...aOther.custom_shapes];
return this;
}
equals(aOther: PADSTACK_COPPER_LAYER_PROPS): boolean {
if (!this.shape.equals(aOther.shape)) return false;
if (this.zone_connection !== aOther.zone_connection) return false;
if (this.thermal_spoke_width !== aOther.thermal_spoke_width) return false;
if (!optAngleEq(this.thermal_spoke_angle, aOther.thermal_spoke_angle)) return false;
if (this.thermal_gap !== aOther.thermal_gap) return false;
if (this.clearance !== aOther.clearance) return false;
if (this.custom_shapes.length !== aOther.custom_shapes.length) return false;
// Deep compare of shapes?
// For now, just check pointers or size
return true;
}
Compare(aOther: PADSTACK_COPPER_LAYER_PROPS): number {
let diff: number;
diff = this.shape.Compare(aOther.shape);
if (diff !== 0) return diff;
diff = testOpt(this.zone_connection, aOther.zone_connection, ZONE_CONNECTION.NONE);
if (diff !== 0) return diff;
diff = testOpt(this.thermal_spoke_width, aOther.thermal_spoke_width, 0);
if (diff !== 0) return diff;
// TEST_OPT_ANGLE( thermal_spoke_angle, aOther.thermal_spoke_angle, ANGLE_0 )
if ((this.thermal_spoke_angle !== undefined) !== (aOther.thermal_spoke_angle !== undefined))
return (
Number(this.thermal_spoke_angle !== undefined) -
Number(aOther.thermal_spoke_angle !== undefined)
);
{
const a = (this.thermal_spoke_angle ?? ANGLE_0).AsDegrees();
const b = (aOther.thermal_spoke_angle ?? ANGLE_0).AsDegrees();
if (Math.abs(a - b) > 0.001) return a > b ? 1 : -1;
}
diff = testOpt(this.thermal_gap, aOther.thermal_gap, 0);
if (diff !== 0) return diff;
diff = testOpt(this.clearance, aOther.clearance, 0);
if (diff !== 0) return diff;
diff = this.custom_shapes.length - aOther.custom_shapes.length;
if (diff !== 0) return diff;
for (let ii = 0; ii < this.custom_shapes.length; ++ii) {
diff = this.custom_shapes[ii]!.Compare(aOther.custom_shapes[ii]! as unknown as EDA_SHAPE);
if (diff !== 0) return diff;
}
return 0;
}
Similarity(aOther: PADSTACK_COPPER_LAYER_PROPS): number {
let similarity = 1.0;
if (!this.shape.equals(aOther.shape)) similarity *= 0.5;
if (this.zone_connection !== aOther.zone_connection) similarity *= 0.9;
if (this.thermal_spoke_width !== aOther.thermal_spoke_width) similarity *= 0.9;
if (!optAngleEq(this.thermal_spoke_angle, aOther.thermal_spoke_angle)) similarity *= 0.9;
if (this.thermal_gap !== aOther.thermal_gap) similarity *= 0.9;
if (this.clearance !== aOther.clearance) similarity *= 0.9;
// `custom_shapes != aOther.custom_shapes`: the vectors of shared_ptr, so the same shapes.
if (
this.custom_shapes.length !== aOther.custom_shapes.length ||
this.custom_shapes.some((s, i) => s !== aOther.custom_shapes[i])
)
similarity *= 0.5;
return similarity;
}
}
function optAngleEq(a: EDA_ANGLE | undefined, b: EDA_ANGLE | undefined): boolean {
if (a === undefined || b === undefined) return a === b;
return a.equals(b);
}
///! The features of a padstack that can vary on outer layers.
///! All parameters are optional; leaving them un-set means "use parent/rule defaults"
export class PADSTACK_MASK_LAYER_PROPS {
solder_mask_margin: number | undefined;
solder_paste_margin: number | undefined;
solder_paste_margin_ratio: number | undefined;
has_solder_mask: boolean | undefined; ///< True if this outer layer has mask (is not tented)
has_solder_paste: boolean | undefined; ///< True if this outer layer has solder paste
has_covering: boolean | undefined; ///< True if the pad on this side should have covering
has_plugging: boolean | undefined; ///< True if the drill hole should be plugged on this side
clone(): PADSTACK_MASK_LAYER_PROPS {
const c = new PADSTACK_MASK_LAYER_PROPS();
c.solder_mask_margin = this.solder_mask_margin;
c.solder_paste_margin = this.solder_paste_margin;
c.solder_paste_margin_ratio = this.solder_paste_margin_ratio;
c.has_solder_mask = this.has_solder_mask;
c.has_solder_paste = this.has_solder_paste;
c.has_covering = this.has_covering;
c.has_plugging = this.has_plugging;
return c;
}
equals(aOther: PADSTACK_MASK_LAYER_PROPS): boolean {
return (
this.solder_mask_margin === aOther.solder_mask_margin &&
this.solder_paste_margin === aOther.solder_paste_margin &&
this.solder_paste_margin_ratio === aOther.solder_paste_margin_ratio &&
this.has_solder_mask === aOther.has_solder_mask &&
this.has_solder_paste === aOther.has_solder_paste &&
this.has_covering === aOther.has_covering &&
this.has_plugging === aOther.has_plugging
);
}
Compare(aOther: PADSTACK_MASK_LAYER_PROPS): number {
let d: number;
d = testOpt(this.solder_mask_margin, aOther.solder_mask_margin, 0);
if (d !== 0) return d;
d = testOpt(this.solder_paste_margin, aOther.solder_paste_margin, 0);
if (d !== 0) return d;
if (
(this.solder_paste_margin_ratio !== undefined) !==
(aOther.solder_paste_margin_ratio !== undefined)
)
return (
Number(this.solder_paste_margin_ratio !== undefined) -
Number(aOther.solder_paste_margin_ratio !== undefined)
);
if (
Math.abs(
(this.solder_paste_margin_ratio ?? 0.0) - (aOther.solder_paste_margin_ratio ?? 0.0),
) > 0.0001
)
return (this.solder_paste_margin_ratio ?? 0.0) > (aOther.solder_paste_margin_ratio ?? 0.0)
? 1
: -1;
d = testOpt(this.has_solder_mask, aOther.has_solder_mask, false);
if (d !== 0) return d;
d = testOpt(this.has_solder_paste, aOther.has_solder_paste, false);
if (d !== 0) return d;
d = testOpt(this.has_covering, aOther.has_covering, false);
if (d !== 0) return d;
d = testOpt(this.has_plugging, aOther.has_plugging, false);
if (d !== 0) return d;
return 0;
}
}
///! The properties of a padstack drill. Drill position is always the pad position (origin).
export class PADSTACK_DRILL_PROPS {
size: VECTOR2I = { x: 0, y: 0 }; ///< Drill diameter (x == y) or slot dimensions (x != y)
shape: PAD_DRILL_SHAPE = PAD_DRILL_SHAPE.UNDEFINED;
start: PCB_LAYER_ID = PCB_LAYER_ID.UNDEFINED_LAYER;
end: PCB_LAYER_ID = PCB_LAYER_ID.UNDEFINED_LAYER;
is_filled: boolean | undefined; ///< True if the drill hole should be filled completely
is_capped: boolean | undefined; ///< True if the drill hole should be capped
clone(): PADSTACK_DRILL_PROPS {
const c = new PADSTACK_DRILL_PROPS();
c.assign(this);
return c;
}
assign(aOther: PADSTACK_DRILL_PROPS): this {
this.size = { x: aOther.size.x, y: aOther.size.y };
this.shape = aOther.shape;
this.start = aOther.start;
this.end = aOther.end;
this.is_filled = aOther.is_filled;
this.is_capped = aOther.is_capped;
return this;
}
equals(aOther: PADSTACK_DRILL_PROPS): boolean {
return (
vecEq(this.size, aOther.size) &&
this.shape === aOther.shape &&
this.start === aOther.start &&
this.end === aOther.end &&
this.is_filled === aOther.is_filled &&
this.is_capped === aOther.is_capped
);
}
Compare(aOther: PADSTACK_DRILL_PROPS): number {
let d: number;
d = test(this.shape, aOther.shape);
if (d !== 0) return d;
d = test(this.size.x, aOther.size.x);
if (d !== 0) return d;
if (this.shape !== PAD_DRILL_SHAPE.CIRCLE) {
d = test(this.size.y, aOther.size.y);
if (d !== 0) return d;
}
d = test(this.start, aOther.start);
if (d !== 0) return d;
d = test(this.end, aOther.end);
if (d !== 0) return d;
d = testOpt(this.is_filled, aOther.is_filled, false);
if (d !== 0) return d;
d = testOpt(this.is_capped, aOther.is_capped, false);
if (d !== 0) return d;
return 0;
}
}
export class PADSTACK_POST_MACHINING_PROPS {
mode: PAD_DRILL_POST_MACHINING_MODE | undefined;
size = 0;
depth = 0;
angle = 0;
clone(): PADSTACK_POST_MACHINING_PROPS {
const c = new PADSTACK_POST_MACHINING_PROPS();
c.mode = this.mode;
c.size = this.size;
c.depth = this.depth;
c.angle = this.angle;
return c;
}
equals(aOther: PADSTACK_POST_MACHINING_PROPS): boolean {
return (
this.mode === aOther.mode &&
this.size === aOther.size &&
this.depth === aOther.depth &&
this.angle === aOther.angle
);
}
Compare(aOther: PADSTACK_POST_MACHINING_PROPS): number {
let d: number;
d = testOpt(this.mode, aOther.mode, PAD_DRILL_POST_MACHINING_MODE.UNKNOWN);
if (d !== 0) return d;
d = test(this.size, aOther.size);
if (d !== 0) return d;
d = test(this.depth, aOther.depth);
if (d !== 0) return d;
d = test(this.angle, aOther.angle);
if (d !== 0) return d;
return 0;
}
}
/**
* A padstack defines the characteristics of a single or multi-layer pad, in the IPC sense of the
* word. Pads are made up of a number of layers (a copper layer, a mask layer, etc) and each layer
* may have a different shape, size, and properties.
*/
export class PADSTACK {
static readonly TYPE = PADSTACK_TYPE;
static readonly MODE = PADSTACK_MODE;
///! Temporary layer identifier to identify code that is not padstack-aware
static readonly ALL_LAYERS: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu;
///! The layer identifier to use for "inner layers" on top/inner/bottom padstacks
static readonly INNER_LAYERS: PCB_LAYER_ID = PCB_LAYER_ID.In1_Cu;
///! The BOARD_ITEM this PADSTACK belongs to; will be used as the parent for owned shapes
private m_parent: BOARD_ITEM | null;
///! The copper layer variation mode this padstack is in
private m_mode: PADSTACK_MODE;
///! The board layers that this padstack is active on
private m_layerSet = new LSET();
///! An override for the IPC-7351 padstack name
private m_customName: string | null = null;
///! The rotation of the pad relative to an outer reference frame
private m_orientation: EDA_ANGLE;
///! The properties applied to copper layers if they aren't overridden
//COPPER_LAYER_PROPS m_defaultCopperProps;
private m_copperProps = new Map<PCB_LAYER_ID, PADSTACK_COPPER_LAYER_PROPS>();
///! The overrides applied to front outer technical layers
private m_frontMaskProps = new PADSTACK_MASK_LAYER_PROPS();
///! The overrides applied to back outer technical layers
private m_backMaskProps = new PADSTACK_MASK_LAYER_PROPS();
private m_unconnectedLayerMode: UNCONNECTED_LAYER_MODE;
private m_customShapeInZoneMode: CUSTOM_SHAPE_ZONE_MODE;
///! The primary drill parameters, which also define the start and end layers for through-hole
///! vias and pads (F_Cu to B_Cu for normal holes; a subset of layers for blind/buried vias)
private m_drill = new PADSTACK_DRILL_PROPS();
///! Secondary drill, used to define back-drilling starting from the bottom side
private m_secondaryDrill = new PADSTACK_DRILL_PROPS();
///! Tertiary drill, used to define back-drilling starting from the top side
private m_tertiaryDrill = new PADSTACK_DRILL_PROPS();
private m_frontPostMachining = new PADSTACK_POST_MACHINING_PROPS();
private m_backPostMachining = new PADSTACK_POST_MACHINING_PROPS();
constructor(aParent: BOARD_ITEM | null);
constructor(aOther: PADSTACK);
constructor(a: BOARD_ITEM | PADSTACK | null) {
if (a instanceof PADSTACK) {
// PADSTACK( const PADSTACK& aOther )
this.m_parent = a.m_parent;
this.m_mode = PADSTACK_MODE.NORMAL;
this.m_orientation = ANGLE_0;
this.m_unconnectedLayerMode = UNCONNECTED_LAYER_MODE.KEEP_ALL;
this.m_customShapeInZoneMode = CUSTOM_SHAPE_ZONE_MODE.OUTLINE;
this.assign(a);
this.ForEachUniqueLayer((aLayer) => {
for (const shape of this.CopperLayer(aLayer).custom_shapes) shape.SetParent(this.m_parent);
});
return;
}
this.m_parent = a;
this.m_mode = PADSTACK_MODE.NORMAL;
this.m_orientation = ANGLE_0;
this.m_unconnectedLayerMode = UNCONNECTED_LAYER_MODE.KEEP_ALL;
this.m_customShapeInZoneMode = CUSTOM_SHAPE_ZONE_MODE.OUTLINE;
const all = this.copperEntry(PADSTACK.ALL_LAYERS);
all.shape = new PADSTACK_SHAPE_PROPS();
all.zone_connection = ZONE_CONNECTION.INHERITED;
all.thermal_spoke_width = undefined;
all.thermal_spoke_angle = ANGLE_45;
all.thermal_gap = undefined;
this.m_drill.shape = PAD_DRILL_SHAPE.CIRCLE;
this.m_drill.start = PCB_LAYER_ID.F_Cu;
this.m_drill.end = PCB_LAYER_ID.B_Cu;
this.m_secondaryDrill.shape = PAD_DRILL_SHAPE.UNDEFINED;
this.m_secondaryDrill.start = PCB_LAYER_ID.UNDEFINED_LAYER;
this.m_secondaryDrill.end = PCB_LAYER_ID.UNDEFINED_LAYER;
this.m_tertiaryDrill.shape = PAD_DRILL_SHAPE.UNDEFINED;
this.m_tertiaryDrill.start = PCB_LAYER_ID.UNDEFINED_LAYER;
this.m_tertiaryDrill.end = PCB_LAYER_ID.UNDEFINED_LAYER;
}
/** `m_copperProps[aLayer]`: a `std::unordered_map` creates the entry on first access. */
private copperEntry(aLayer: PCB_LAYER_ID): PADSTACK_COPPER_LAYER_PROPS {
let entry = this.m_copperProps.get(aLayer);
if (!entry) {
entry = new PADSTACK_COPPER_LAYER_PROPS();
this.m_copperProps.set(aLayer, entry);
}
return entry;
}
/** `operator=( const PADSTACK& aOther )`. */
assign(aOther: PADSTACK): this {
// NOTE: m_parent is not copied from operator=, because this operator is commonly used to
// update the padstack properties, and such an update must not change the parent PAD to point to
// the parent of some different padstack.
this.m_mode = aOther.m_mode;
this.m_layerSet = new LSET(aOther.m_layerSet);
this.SetCustomName(aOther.CustomName());
this.m_orientation = aOther.m_orientation;
// `m_copperProps = aOther.m_copperProps` is safe for `*this = *this` (a pad pushed onto
// itself, `doPushPadProperties`); read the source map before replacing ours.
const otherCopperProps = aOther.m_copperProps;
this.m_copperProps = new Map();
for (const [layer, props] of otherCopperProps) this.m_copperProps.set(layer, props.clone());
this.m_frontMaskProps = aOther.m_frontMaskProps.clone();
this.m_backMaskProps = aOther.m_backMaskProps.clone();
this.m_unconnectedLayerMode = aOther.m_unconnectedLayerMode;
this.m_customShapeInZoneMode = aOther.m_customShapeInZoneMode;
this.m_drill = aOther.m_drill.clone();
this.m_secondaryDrill = aOther.m_secondaryDrill.clone();
this.m_tertiaryDrill = aOther.m_tertiaryDrill.clone();
this.m_frontPostMachining = aOther.m_frontPostMachining.clone();
this.m_backPostMachining = aOther.m_backPostMachining.clone();
// Data consistency enforcement logic that used to live in the pad properties dialog.
// While it might be tempting to put these in the individual property setters, there's no
// well-defined order in which they're called, and many of the consistency checks are
// between multiple properties.
this.ForEachUniqueLayer((aLayer) => {
const shape = this.Shape(aLayer);
// Make sure leftover primitives don't stick around
this.ClearPrimitives(aLayer);
// For custom pad shape, duplicate primitives of the pad to copy
if (shape === PAD_SHAPE.CUSTOM) this.ReplacePrimitives(aOther.Primitives(aLayer), aLayer);
// rounded rect pads with radius ratio = 0 are in fact rect pads.
// So set the right shape (and perhaps issues with a radius = 0)
if (shape === PAD_SHAPE.ROUNDRECT && this.RoundRectRadiusRatio(aLayer) === 0.0)
this.SetShape(PAD_SHAPE.RECTANGLE, aLayer);
});
return this;
}
equals(aOther: PADSTACK): boolean {
if (this.m_mode !== aOther.m_mode) return false;
if (!this.m_layerSet.equals(aOther.m_layerSet)) return false;
if (this.CustomName() !== aOther.CustomName()) return false;
if (!this.m_orientation.equals(aOther.m_orientation)) return false;
if (!this.m_frontMaskProps.equals(aOther.m_frontMaskProps)) return false;
if (!this.m_backMaskProps.equals(aOther.m_backMaskProps)) return false;
if (this.m_unconnectedLayerMode !== aOther.m_unconnectedLayerMode) return false;
if (this.m_customShapeInZoneMode !== aOther.m_customShapeInZoneMode) return false;
if (!this.m_drill.equals(aOther.m_drill)) return false;
if (!this.m_secondaryDrill.equals(aOther.m_secondaryDrill)) return false;
if (!this.m_tertiaryDrill.equals(aOther.m_tertiaryDrill)) return false;
if (!this.m_frontPostMachining.equals(aOther.m_frontPostMachining)) return false;
if (!this.m_backPostMachining.equals(aOther.m_backPostMachining)) return false;
let copperMatches = true;
this.ForEachUniqueLayer((aLayer) => {
if (!this.CopperLayer(aLayer).equals(aOther.CopperLayer(aLayer))) copperMatches = false;
});
return copperMatches;
}
// A backdrill's side is identified by its start layer (F_Cu = top, B_Cu = bottom), not by which
// drill slot it occupies. Reads scan both slots so a board written by KiCad 10.0 - which stored the
// top backdrill in the tertiary slot - is understood, and writes always stamp the start layer so a
// backdrill saved here is read back correctly by older KiCad. Presence is keyed on the drill size.
private findBackdrillDrill(aTop: boolean): PADSTACK_DRILL_PROPS | null {
const side = aTop ? PCB_LAYER_ID.F_Cu : PCB_LAYER_ID.B_Cu;
if (this.m_secondaryDrill.size.x > 0 && this.m_secondaryDrill.start === side)
return this.m_secondaryDrill;
if (this.m_tertiaryDrill.size.x > 0 && this.m_tertiaryDrill.start === side)
return this.m_tertiaryDrill;
return null;
}
/// Return the slot to write a backdrill side into, reusing the slot already holding that side
/// or otherwise the canonical slot (top -> secondary, bottom -> tertiary).
private backdrillWriteSlot(aTop: boolean): PADSTACK_DRILL_PROPS {
const existing = this.findBackdrillDrill(aTop);
if (existing) return existing;
const home = aTop ? this.m_secondaryDrill : this.m_tertiaryDrill;
const other = aTop ? this.m_tertiaryDrill : this.m_secondaryDrill;
const otherSide = aTop ? PCB_LAYER_ID.B_Cu : PCB_LAYER_ID.F_Cu;
// Displace to the other slot only when the canonical home is already taken by the opposite
// side, which happens when extending a backdrill on a board written by KiCad 10.0.
if (home.size.x > 0 && home.start === otherSide) return other;
return home;
}
/// Clear every slot whose start layer marks it as the given backdrill side, so a malformed
/// padstack with the side duplicated across both slots is fully cleared.
private clearBackdrillSide(aTop: boolean): void {
const side = aTop ? PCB_LAYER_ID.F_Cu : PCB_LAYER_ID.B_Cu;
if (this.m_secondaryDrill.start === side) this.m_secondaryDrill.size = { x: 0, y: 0 };
if (this.m_tertiaryDrill.start === side) this.m_tertiaryDrill.size = { x: 0, y: 0 };
}
GetBackdrillMode(): BACKDRILL_MODE {
const hasTop = this.findBackdrillDrill(true) !== null;
const hasBottom = this.findBackdrillDrill(false) !== null;
if (hasTop && hasBottom) return BACKDRILL_MODE.BACKDRILL_BOTH;
if (hasTop) return BACKDRILL_MODE.BACKDRILL_TOP;
if (hasBottom) return BACKDRILL_MODE.BACKDRILL_BOTTOM;
return BACKDRILL_MODE.NO_BACKDRILL;
}
SetBackdrillMode(aMode: BACKDRILL_MODE): void {
const apply = (aTop: boolean, aWant: boolean): void => {
if (aWant) {
const drill = this.backdrillWriteSlot(aTop);
drill.start = aTop ? PCB_LAYER_ID.F_Cu : PCB_LAYER_ID.B_Cu;
drill.shape = PAD_DRILL_SHAPE.CIRCLE;
if (drill.size.x <= 0)
// Backdrill slightly larger than main drill
drill.size = {
x: Math.trunc(this.m_drill.size.x * 1.1),
y: Math.trunc(this.m_drill.size.y * 1.1),
};
} else {
this.clearBackdrillSide(aTop);
}
};
apply(true, aMode === BACKDRILL_MODE.BACKDRILL_TOP || aMode === BACKDRILL_MODE.BACKDRILL_BOTH);
apply(
false,
aMode === BACKDRILL_MODE.BACKDRILL_BOTTOM || aMode === BACKDRILL_MODE.BACKDRILL_BOTH,
);
}
GetBackdrillSize(aTop: boolean): number | undefined {
const drill = this.findBackdrillDrill(aTop);
if (drill) return drill.size.x;
return undefined;
}
SetBackdrillSize(aTop: boolean, aSize: number | undefined): void {
if (aSize !== undefined) {
const target = this.backdrillWriteSlot(aTop);
target.size = { x: aSize, y: aSize };
target.shape = PAD_DRILL_SHAPE.CIRCLE;
target.start = aTop ? PCB_LAYER_ID.F_Cu : PCB_LAYER_ID.B_Cu;
} else {
this.clearBackdrillSide(aTop);
}
}
GetBackdrillEndLayer(aTop: boolean): PCB_LAYER_ID {
const drill = this.findBackdrillDrill(aTop);
if (drill) return drill.end;
return PCB_LAYER_ID.UNDEFINED_LAYER;
}
SetBackdrillEndLayer(aTop: boolean, aLayer: PCB_LAYER_ID): void {
// A backdrill with no must-cut layer does not exist (matching the via layer sanitizer), so
// clearing the must-cut clears the side rather than leaving a sizeful drill with no end.
if (aLayer === PCB_LAYER_ID.UNDEFINED_LAYER) {
this.clearBackdrillSide(aTop);
return;
}
const target = this.backdrillWriteSlot(aTop);
target.end = aLayer;
target.start = aTop ? PCB_LAYER_ID.F_Cu : PCB_LAYER_ID.B_Cu;
}
static Compare(aLeft: PADSTACK, aRight: PADSTACK): number {
let diff: number;
diff = test(aLeft.m_mode, aRight.m_mode);
if (diff !== 0) return diff;
if (!aLeft.m_layerSet.equals(aRight.m_layerSet))
return Number(lseqLess(aLeft.m_layerSet.Seq(), aRight.m_layerSet.Seq()));
diff = wxCmp(aLeft.CustomName(), aRight.CustomName());
if (diff !== 0) return diff;
diff = test(aLeft.m_orientation.AsTenthsOfADegree(), aRight.m_orientation.AsTenthsOfADegree());
if (diff !== 0) return diff;
diff = aLeft.m_frontMaskProps.Compare(aRight.m_frontMaskProps);
if (diff !== 0) return diff;
diff = aLeft.m_backMaskProps.Compare(aRight.m_backMaskProps);
if (diff !== 0) return diff;
diff = test(aLeft.m_unconnectedLayerMode, aRight.m_unconnectedLayerMode);
if (diff !== 0) return diff;
diff = test(aLeft.m_customShapeInZoneMode, aRight.m_customShapeInZoneMode);
if (diff !== 0) return diff;
diff = aLeft.m_drill.Compare(aRight.m_drill);
if (diff !== 0) return diff;
diff = aLeft.m_secondaryDrill.Compare(aRight.m_secondaryDrill);
if (diff !== 0) return diff;
diff = aLeft.m_tertiaryDrill.Compare(aRight.m_tertiaryDrill);
if (diff !== 0) return diff;
diff = aLeft.m_frontPostMachining.Compare(aRight.m_frontPostMachining);
if (diff !== 0) return diff;
diff = aLeft.m_backPostMachining.Compare(aRight.m_backPostMachining);
if (diff !== 0) return diff;
aLeft.ForEachUniqueLayer((aLayer) => {
if (diff !== 0)
// we want to return the first non-matching layer
return;
diff = aLeft.CopperLayer(aLayer).Compare(aRight.CopperLayer(aLayer));
});
if (diff !== 0) return diff;
return 0;
}
HasExplicitDefinitionForLayer(aLayer: PCB_LAYER_ID): boolean {
return this.m_copperProps.has(aLayer);
}
Similarity(aOther: PADSTACK): number {
let similarity = 1.0;
if (this.m_mode !== aOther.m_mode) similarity *= 0.9;
if (!this.m_layerSet.equals(aOther.m_layerSet)) similarity *= 0.9;
if (this.CustomName() !== aOther.CustomName()) similarity *= 0.9;
if (!this.m_orientation.equals(aOther.m_orientation)) similarity *= 0.9;
if (!this.m_frontMaskProps.equals(aOther.m_frontMaskProps)) similarity *= 0.9;
if (!this.m_backMaskProps.equals(aOther.m_backMaskProps)) similarity *= 0.9;
if (this.m_unconnectedLayerMode !== aOther.m_unconnectedLayerMode) similarity *= 0.9;
if (this.m_customShapeInZoneMode !== aOther.m_customShapeInZoneMode) similarity *= 0.9;
if (!this.m_drill.equals(aOther.m_drill)) similarity *= 0.9;
if (!this.m_secondaryDrill.equals(aOther.m_secondaryDrill)) similarity *= 0.9;
if (!this.m_tertiaryDrill.equals(aOther.m_tertiaryDrill)) similarity *= 0.9;
if (!this.m_frontPostMachining.equals(aOther.m_frontPostMachining)) similarity *= 0.9;
if (!this.m_backPostMachining.equals(aOther.m_backPostMachining)) similarity *= 0.9;
this.ForEachUniqueLayer((aLayer) => {
similarity *= this.CopperLayer(aLayer).Similarity(aOther.CopperLayer(aLayer));
});
return similarity;
}
LayerSet(): LSET {
return this.m_layerSet;
}
SetLayerSet(aSet: LSET): void {
this.m_layerSet = new LSET(aSet);
}
FlipLayers(aBoard: BOARD): void {
if (this.m_mode === PADSTACK_MODE.FRONT_INNER_BACK) {
const oldCopperProps = this.m_copperProps;
this.m_copperProps = new Map();
this.m_copperProps.set(
aBoard.FlipLayer(PCB_LAYER_ID.F_Cu),
oldCopperProps.get(PCB_LAYER_ID.F_Cu) ?? new PADSTACK_COPPER_LAYER_PROPS(),
);
this.m_copperProps.set(
PADSTACK.INNER_LAYERS,
oldCopperProps.get(PADSTACK.INNER_LAYERS) ?? new PADSTACK_COPPER_LAYER_PROPS(),
);
this.m_copperProps.set(
aBoard.FlipLayer(PCB_LAYER_ID.B_Cu),
oldCopperProps.get(PCB_LAYER_ID.B_Cu) ?? new PADSTACK_COPPER_LAYER_PROPS(),
);
} else if (this.m_mode === PADSTACK_MODE.CUSTOM) {
const oldCopperProps = this.m_copperProps;
this.m_copperProps = new Map();
for (const [layer, props] of oldCopperProps)
this.m_copperProps.set(aBoard.FlipLayer(layer), props);
}
[this.m_frontMaskProps, this.m_backMaskProps] = [this.m_backMaskProps, this.m_frontMaskProps];
this.m_drill.start = aBoard.FlipLayer(this.m_drill.start);
this.m_drill.end = aBoard.FlipLayer(this.m_drill.end);
this.m_secondaryDrill.start = aBoard.FlipLayer(this.m_secondaryDrill.start);
this.m_secondaryDrill.end = aBoard.FlipLayer(this.m_secondaryDrill.end);
this.m_tertiaryDrill.start = aBoard.FlipLayer(this.m_tertiaryDrill.start);
this.m_tertiaryDrill.end = aBoard.FlipLayer(this.m_tertiaryDrill.end);
[this.m_frontPostMachining, this.m_backPostMachining] = [
this.m_backPostMachining,
this.m_frontPostMachining,
];
}
StartLayer(): PCB_LAYER_ID {
return this.m_drill.start;
}
EndLayer(): PCB_LAYER_ID {
return this.m_drill.end;
}
Mode(): PADSTACK_MODE {
return this.m_mode;
}
SetMode(aMode: PADSTACK_MODE): void {
this.m_mode = aMode;
}
///! Returns the name of this padstack in IPC-7351 format
Name(): string {
return this.CustomName();
}
CustomName(): string {
if (this.m_customName !== null) return this.m_customName;
return '';
}
SetCustomName(aCustomName: string): void {
if (aCustomName === '') {
this.m_customName = null;
} else {
this.m_customName = aCustomName;
}
}
GetOrientation(): EDA_ANGLE {
return this.m_orientation;
}
SetOrientation(aAngle: EDA_ANGLE): void {
this.m_orientation = aAngle.Clone();
this.m_orientation.Normalize();
}
Drill(): PADSTACK_DRILL_PROPS {
return this.m_drill;
}
SecondaryDrill(): PADSTACK_DRILL_PROPS {
return this.m_secondaryDrill;
}
TertiaryDrill(): PADSTACK_DRILL_PROPS {
return this.m_tertiaryDrill;
}
FrontPostMachining(): PADSTACK_POST_MACHINING_PROPS {
return this.m_frontPostMachining;
}
BackPostMachining(): PADSTACK_POST_MACHINING_PROPS {
return this.m_backPostMachining;
}
UnconnectedLayerMode(): UNCONNECTED_LAYER_MODE {
return this.m_unconnectedLayerMode;
}
SetUnconnectedLayerMode(aMode: UNCONNECTED_LAYER_MODE): void {
this.m_unconnectedLayerMode = aMode;
}
/** The const `CopperLayer( aLayer )`: reads without creating, with the fallbacks. */
CopperLayer(aLayer: PCB_LAYER_ID): PADSTACK_COPPER_LAYER_PROPS {
return this.copperLayerFor(aLayer);
}
/** The non-const `CopperLayer( aLayer )`: `operator[]`, which creates the entry. */
CopperLayerMut(aLayer: PCB_LAYER_ID): PADSTACK_COPPER_LAYER_PROPS {
if (this.m_mode === PADSTACK_MODE.NORMAL) return this.copperEntry(PADSTACK.ALL_LAYERS);
if (this.m_mode === PADSTACK_MODE.FRONT_INNER_BACK) {
if (IsFrontLayer(aLayer)) return this.copperEntry(PCB_LAYER_ID.F_Cu);
else if (IsBackLayer(aLayer)) return this.copperEntry(PCB_LAYER_ID.B_Cu);
else return this.copperEntry(PADSTACK.INNER_LAYERS);
}
return this.copperEntry(aLayer);
}
private copperLayerFor(aLayer: PCB_LAYER_ID): PADSTACK_COPPER_LAYER_PROPS {
if (this.m_mode === PADSTACK_MODE.FRONT_INNER_BACK) {
if (IsFrontLayer(aLayer) && this.m_copperProps.has(PCB_LAYER_ID.F_Cu))
return this.m_copperProps.get(PCB_LAYER_ID.F_Cu)!;
else if (IsBackLayer(aLayer) && this.m_copperProps.has(PCB_LAYER_ID.B_Cu))
return this.m_copperProps.get(PCB_LAYER_ID.B_Cu)!;
else if (this.m_copperProps.has(PADSTACK.INNER_LAYERS))
return this.m_copperProps.get(PADSTACK.INNER_LAYERS)!;
} else if (this.m_mode === PADSTACK_MODE.CUSTOM) {
if (IsFrontLayer(aLayer) && this.m_copperProps.has(PCB_LAYER_ID.F_Cu))
return this.m_copperProps.get(PCB_LAYER_ID.F_Cu)!;
else if (IsBackLayer(aLayer) && this.m_copperProps.has(PCB_LAYER_ID.B_Cu))
return this.m_copperProps.get(PCB_LAYER_ID.B_Cu)!;
if (this.m_copperProps.has(aLayer)) return this.m_copperProps.get(aLayer)!;
// For CUSTOM mode, fall back to ALL_LAYERS if available (e.g. for layers not yet
// explicitly defined). If ALL_LAYERS is also absent (e.g. after a FlipLayers()
// that renamed the only entry from F_Cu to B_Cu), return whatever entry is first.
if (this.m_copperProps.has(PADSTACK.ALL_LAYERS))
return this.m_copperProps.get(PADSTACK.ALL_LAYERS)!;
console.assert(this.m_copperProps.size > 0);
return this.m_copperProps.values().next().value!;
}
const all = this.m_copperProps.get(PADSTACK.ALL_LAYERS);
if (!all) throw new RangeError('out_of_range'); // std::unordered_map::at
return all;
}
FrontOuterLayers(): PADSTACK_MASK_LAYER_PROPS {
return this.m_frontMaskProps;
}
BackOuterLayers(): PADSTACK_MASK_LAYER_PROPS {
return this.m_backMaskProps;
}
IsTented(aSide: PCB_LAYER_ID): boolean | undefined {
if (IsFrontLayer(aSide)) return this.FrontOuterLayers().has_solder_mask;
else if (IsBackLayer(aSide)) return this.BackOuterLayers().has_solder_mask;
else return undefined;
}
IsCovered(aSide: PCB_LAYER_ID): boolean | undefined {
if (IsFrontLayer(aSide)) return this.FrontOuterLayers().has_covering;
else if (IsBackLayer(aSide)) return this.BackOuterLayers().has_covering;
else return undefined;
}
IsPlugged(aSide: PCB_LAYER_ID): boolean | undefined {
if (IsFrontLayer(aSide)) return this.FrontOuterLayers().has_plugging;
else if (IsBackLayer(aSide)) return this.BackOuterLayers().has_plugging;
else return undefined;
}
IsCapped(): boolean | undefined {
return this.m_drill.is_capped;
}
IsFilled(): boolean | undefined {
return this.m_drill.is_filled;
}
CustomShapeInZoneMode(): CUSTOM_SHAPE_ZONE_MODE {
return this.m_customShapeInZoneMode;
}
SetCustomShapeInZoneMode(aM: CUSTOM_SHAPE_ZONE_MODE): void {
this.m_customShapeInZoneMode = aM;
}
/**
* Run the given callable for each active unique copper layer in this padstack, meaning F_Cu for
* MODE::NORMAL, and F_Cu, In1_Cu, and B_Cu for MODE::FRONT_INNER_BACK.
*/
ForEachUniqueLayer(aMethod: (aLayer: PCB_LAYER_ID) => void): void {
if (this.m_mode === PADSTACK_MODE.NORMAL) {
aMethod(PADSTACK.ALL_LAYERS);
} else if (this.m_mode === PADSTACK_MODE.FRONT_INNER_BACK) {
aMethod(PCB_LAYER_ID.F_Cu);
aMethod(PADSTACK.INNER_LAYERS);
aMethod(PCB_LAYER_ID.B_Cu);
} else {
for (const [layer] of this.m_copperProps) aMethod(layer);
}
}
UniqueLayers(): PCB_LAYER_ID[] {
const layers: PCB_LAYER_ID[] = [];
this.ForEachUniqueLayer((layer) => {
layers.push(layer);
});
return layers;
}
/**
* Determines which geometry layer should be used for the given input layer.
*/
EffectiveLayerFor(aLayer: PCB_LAYER_ID): PCB_LAYER_ID {
if (this.m_mode === PADSTACK_MODE.NORMAL) return PADSTACK.ALL_LAYERS;
if (this.m_mode === PADSTACK_MODE.FRONT_INNER_BACK || IsNonCopperLayer(aLayer)) {
let candidate: PCB_LAYER_ID;
if (IsFrontLayer(aLayer)) candidate = PCB_LAYER_ID.F_Cu;
else if (IsBackLayer(aLayer)) candidate = PCB_LAYER_ID.B_Cu;
else candidate = PADSTACK.INNER_LAYERS;
// FRONT_INNER_BACK always has all three sides.
// In CUSTOM mode only return the side if the pad actually defines it.
if (this.m_mode === PADSTACK_MODE.FRONT_INNER_BACK || this.m_copperProps.has(candidate))
return candidate;
}
if (this.m_copperProps.has(aLayer)) return aLayer;
// For CUSTOM mode, if ALL_LAYERS is present use it as the default; otherwise return the
// first available layer (e.g. after FlipLayers renamed ALL_LAYERS from F_Cu to B_Cu).
if (this.m_copperProps.has(PADSTACK.ALL_LAYERS)) return PADSTACK.ALL_LAYERS;
console.assert(this.m_copperProps.size > 0);
return this.m_copperProps.keys().next().value!;
}
/**
* Return the set of layers that must be considered if checking one padstack against another.
*/
RelevantShapeLayers(aOther: PADSTACK): LSET {
const layers = new LSET();
if (this.m_mode === PADSTACK_MODE.NORMAL && aOther.m_mode === PADSTACK_MODE.NORMAL) {
layers.set(PADSTACK.ALL_LAYERS);
} else {
this.ForEachUniqueLayer((layer) => {
layers.set(layer);
});
aOther.ForEachUniqueLayer((layer) => {
layers.set(layer);
});
}
return layers;
}
// The following section has convenience getters for the padstack properties on a given layer.
Shape(aLayer: PCB_LAYER_ID): PAD_SHAPE {
return this.CopperLayer(aLayer).shape.shape;
}
SetShape(aShape: PAD_SHAPE, aLayer: PCB_LAYER_ID): void {
this.CopperLayerMut(aLayer).shape.shape = aShape;
}
// Setter rather than direct access to enforce only positive sizes
SetSize(aSize: VECTOR2I, aLayer: PCB_LAYER_ID): void {
const size = { x: aSize.x, y: aSize.y };
if (size.x < 0) size.x = 0;
if (size.y < 0) size.y = 0;
this.CopperLayerMut(aLayer).shape.size = size;
}
Size(aLayer: PCB_LAYER_ID): VECTOR2I {
return this.CopperLayer(aLayer).shape.size;
}
DrillShape(): PAD_DRILL_SHAPE {
return this.m_drill.shape;
}
SetDrillShape(aShape: PAD_DRILL_SHAPE): void {
this.m_drill.shape = aShape;
}
/** `Offset( aLayer )`: the offset by reference — the object, which the caller may write to. */
Offset(aLayer: PCB_LAYER_ID): VECTOR2I {
return this.CopperLayerMut(aLayer).shape.offset;
}
/**
* `Offset( aLayer ) const`: read through the const `CopperLayer`, which never creates an
* entry. A const caller (PAD::GetOffset, ShapePos, IsOnCopperLayer) must use this one, or
* a FRONT_INNER_BACK stack gains a default inner entry the writer then prints.
*/
OffsetConst(aLayer: PCB_LAYER_ID): VECTOR2I {
return this.CopperLayer(aLayer).shape.offset;
}
SetOffset(aOffset: VECTOR2I, aLayer: PCB_LAYER_ID): void {
this.CopperLayerMut(aLayer).shape.offset = { x: aOffset.x, y: aOffset.y };
}
AnchorShape(aLayer: PCB_LAYER_ID): PAD_SHAPE {
return this.CopperLayer(aLayer).shape.anchor_shape;
}
SetAnchorShape(aShape: PAD_SHAPE, aLayer: PCB_LAYER_ID): void {
this.CopperLayerMut(aLayer).shape.anchor_shape = aShape;
}
TrapezoidDeltaSize(aLayer: PCB_LAYER_ID): VECTOR2I {
return this.CopperLayerMut(aLayer).shape.trapezoid_delta_size;
}
/** `TrapezoidDeltaSize( aLayer ) const`: see OffsetConst. */
TrapezoidDeltaSizeConst(aLayer: PCB_LAYER_ID): VECTOR2I {
return this.CopperLayer(aLayer).shape.trapezoid_delta_size;
}
SetTrapezoidDeltaSize(aDelta: VECTOR2I, aLayer: PCB_LAYER_ID): void {
this.CopperLayerMut(aLayer).shape.trapezoid_delta_size = { x: aDelta.x, y: aDelta.y };
}
RoundRectRadiusRatio(aLayer: PCB_LAYER_ID): number {
return this.CopperLayer(aLayer).shape.round_rect_radius_ratio;
}
SetRoundRectRadiusRatio(aRatio: number, aLayer: PCB_LAYER_ID): void {
this.CopperLayerMut(aLayer).shape.round_rect_radius_ratio = aRatio;
}
RoundRectRadius(aLayer: PCB_LAYER_ID): number {
const size = this.Size(aLayer);
return KiROUND(Math.min(size.x, size.y) * this.RoundRectRadiusRatio(aLayer));
}
SetRoundRectRadius(aRadius: number, aLayer: PCB_LAYER_ID): void {
const size = this.Size(aLayer);
const min_r = Math.min(size.x, size.y);
if (min_r > 0) this.SetRoundRectRadiusRatio(aRadius / min_r, aLayer);
}
ChamferRatio(aLayer: PCB_LAYER_ID): number {
return this.CopperLayer(aLayer).shape.chamfered_rect_ratio;
}
SetChamferRatio(aRatio: number, aLayer: PCB_LAYER_ID): void {
this.CopperLayerMut(aLayer).shape.chamfered_rect_ratio = aRatio;
}
ChamferPositions(aLayer: PCB_LAYER_ID): number {
return this.CopperLayer(aLayer).shape.chamfered_rect_positions;
}
SetChamferPositions(aPositions: number, aLayer: PCB_LAYER_ID): void {
this.CopperLayerMut(aLayer).shape.chamfered_rect_positions = aPositions;
}
Clearance(aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): number | undefined {
return this.CopperLayer(aLayer).clearance;
}
SetClearance(aClearance: number | undefined, aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): void {
this.CopperLayerMut(aLayer).clearance = aClearance;
}
SolderMaskMargin(aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): number | undefined {
if (IsFrontLayer(aLayer)) return this.FrontOuterLayers().solder_mask_margin;
else if (IsBackLayer(aLayer)) return this.BackOuterLayers().solder_mask_margin;
else return this.FrontOuterLayers().solder_mask_margin; // Should not happen
}
SetSolderMaskMargin(aMargin: number | undefined, aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): void {
if (IsFrontLayer(aLayer)) this.FrontOuterLayers().solder_mask_margin = aMargin;
else if (IsBackLayer(aLayer)) this.BackOuterLayers().solder_mask_margin = aMargin;
else this.FrontOuterLayers().solder_mask_margin = aMargin; // Should not happen
}
SolderPasteMargin(aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): number | undefined {
if (IsFrontLayer(aLayer)) return this.FrontOuterLayers().solder_paste_margin;
else if (IsBackLayer(aLayer)) return this.BackOuterLayers().solder_paste_margin;
else return this.FrontOuterLayers().solder_paste_margin; // Should not happen
}
SetSolderPasteMargin(
aMargin: number | undefined,
aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu,
): void {
if (IsFrontLayer(aLayer)) this.FrontOuterLayers().solder_paste_margin = aMargin;
else if (IsBackLayer(aLayer)) this.BackOuterLayers().solder_paste_margin = aMargin;
else this.FrontOuterLayers().solder_paste_margin = aMargin; // Should not happen
}
SolderPasteMarginRatio(aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): number | undefined {
if (IsFrontLayer(aLayer)) return this.FrontOuterLayers().solder_paste_margin_ratio;
else if (IsBackLayer(aLayer)) return this.BackOuterLayers().solder_paste_margin_ratio;
else return this.FrontOuterLayers().solder_paste_margin_ratio; // Should not happen
}
SetSolderPasteMarginRatio(
aRatio: number | undefined,
aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu,
): void {
if (IsFrontLayer(aLayer)) this.FrontOuterLayers().solder_paste_margin_ratio = aRatio;
else if (IsBackLayer(aLayer)) this.BackOuterLayers().solder_paste_margin_ratio = aRatio;
else this.FrontOuterLayers().solder_paste_margin_ratio = aRatio; // Should not happen
}
ZoneConnection(aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): ZONE_CONNECTION | undefined {
return this.CopperLayer(aLayer).zone_connection;
}
SetZoneConnection(
aConnection: ZONE_CONNECTION | undefined,
aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu,
): void {
this.CopperLayerMut(aLayer).zone_connection = aConnection;
}
ThermalSpokeWidth(aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): number | undefined {
return this.CopperLayer(aLayer).thermal_spoke_width;
}
SetThermalSpokeWidth(aWidth: number | undefined, aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): void {
this.CopperLayerMut(aLayer).thermal_spoke_width = aWidth;
}
ThermalGap(aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): number | undefined {
return this.CopperLayer(aLayer).thermal_gap;
}
SetThermalGap(aGap: number | undefined, aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): void {
this.CopperLayerMut(aLayer).thermal_gap = aGap;
}
DefaultThermalSpokeAngleForShape(aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): EDA_ANGLE {
if (
this.Shape(aLayer) === PAD_SHAPE.OVAL ||
this.Shape(aLayer) === PAD_SHAPE.RECTANGLE ||
this.Shape(aLayer) === PAD_SHAPE.ROUNDRECT ||
this.Shape(aLayer) === PAD_SHAPE.CHAMFERED_RECT
) {
return ANGLE_90;
}
return ANGLE_45;
}
ThermalSpokeAngle(aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu): EDA_ANGLE {
const angle = this.CopperLayer(aLayer).thermal_spoke_angle;
if (angle !== undefined) return angle;
return this.DefaultThermalSpokeAngleForShape(aLayer);
}
SetThermalSpokeAngle(
aAngle: EDA_ANGLE | undefined,
aLayer: PCB_LAYER_ID = PCB_LAYER_ID.F_Cu,
): void {
this.CopperLayerMut(aLayer).thermal_spoke_angle = aAngle;
}
Primitives(aLayer: PCB_LAYER_ID): PCB_SHAPE[] {
return this.CopperLayer(aLayer).custom_shapes;
}
AddPrimitive(aShape: PCB_SHAPE, aLayer: PCB_LAYER_ID): void {
this.CopperLayerMut(aLayer).custom_shapes.push(aShape);
}
AppendPrimitives(aList: readonly PCB_SHAPE[], aLayer: PCB_LAYER_ID): void {
const list = this.CopperLayerMut(aLayer).custom_shapes;
for (const item of aList) {
const new_shape = item.Clone();
new_shape.SetParent(this.m_parent);
list.push(new_shape);
}
}
ReplacePrimitives(aList: readonly PCB_SHAPE[], aLayer: PCB_LAYER_ID): void {
this.ClearPrimitives(aLayer);
this.AppendPrimitives(aList, aLayer);
}
ClearPrimitives(aLayer: PCB_LAYER_ID): void {
this.CopperLayerMut(aLayer).custom_shapes.length = 0;
}
}
/** `wxString::Cmp`. */
function wxCmp(a: string, b: string): number {
return a < b ? -1 : a > b ? 1 : 0;
}
/** `std::vector<PCB_LAYER_ID>::operator<`. */
function lseqLess(a: readonly PCB_LAYER_ID[], b: readonly PCB_LAYER_ID[]): boolean {
const n = Math.min(a.length, b.length);
for (let i = 0; i < n; ++i) if (a[i]! !== b[i]!) return a[i]! < b[i]!;
return a.length < b.length;
}