KiCad PCB EDA Suite
Loading...
Searching...
No Matches
api_pcb_utils.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2023 Jon Evans <[email protected]>
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software: you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation, either version 3 of the License, or (at your
10 * option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <https://www.gnu.org/licenses/>.
19 */
20
21#include <algorithm>
22#include <ranges>
23
24#include <api/api_pcb_utils.h>
25#include <api/api_enums.h>
26#include <api/board/board.pb.h>
27#include <api/api_utils.h>
28#include <board.h>
29#include <embedded_files.h>
32#include <footprint.h>
33#include <lset.h>
34#include <pad.h>
35#include <pcb_group.h>
36#include <pcb_generator.h>
37#include <generators_mgr.h>
39#include <mmh3_hash.h>
40#include <pcb_barcode.h>
41#include <pcb_grid_item.h>
42#include <pcb_reference_image.h>
43#include <pcb_shape.h>
44#include <pcb_3d_body.h>
45#include <pcb_point.h>
46#include <pcb_track.h>
47#include <pcb_field.h>
48#include <pcb_text.h>
49#include <pcb_textbox.h>
50#include <pcb_drill_chart.h>
51#include <pcb_drill_map.h>
52#include <pcb_stackup_table.h>
53#include <pcb_table.h>
54#include <pcb_dimension.h>
55#include <zone.h>
56
57
58std::unique_ptr<BOARD_ITEM> CreateGeneratorForType( const wxString& aGeneratorType, BOARD_ITEM_CONTAINER* aContainer )
59{
60 PCB_GENERATOR* generator = GENERATORS_MGR::Instance().CreateFromType( aGeneratorType );
61
62 if( !generator )
63 return nullptr;
64
65 if( aContainer )
66 generator->SetParent( aContainer );
67
68 return std::unique_ptr<BOARD_ITEM>( generator );
69}
70
71
72std::unique_ptr<BOARD_ITEM> CreateItemForType( KICAD_T aType, BOARD_ITEM_CONTAINER* aContainer )
73{
74 switch( aType )
75 {
76 case PCB_TRACE_T: return std::make_unique<PCB_TRACK>( aContainer );
77 case PCB_ARC_T: return std::make_unique<PCB_ARC>( aContainer );
78 case PCB_VIA_T: return std::make_unique<PCB_VIA>( aContainer );
79 case PCB_TEXT_T: return std::make_unique<PCB_TEXT>( aContainer );
80 case PCB_TEXTBOX_T: return std::make_unique<PCB_TEXTBOX>( aContainer );
81 case PCB_TABLE_T: return std::make_unique<PCB_TABLE>( aContainer );
82 case PCB_DRILL_CHART_T: return std::make_unique<PCB_DRILL_CHART>( aContainer );
83 case PCB_DRILL_MAP_T: return std::make_unique<PCB_DRILL_MAP>( aContainer );
84 case PCB_STACKUP_TABLE_T: return std::make_unique<PCB_STACKUP_TABLE>( aContainer );
85 case PCB_TABLECELL_T:
86 {
87 PCB_TABLE* table = dynamic_cast<PCB_TABLE*>( aContainer );
88
89 if( !table )
90 return nullptr;
91
92 return std::make_unique<PCB_TABLECELL>( aContainer );
93 }
94 case PCB_SHAPE_T: return std::make_unique<PCB_SHAPE>( aContainer );
95 case PCB_POINT_T: return std::make_unique<PCB_POINT>( aContainer );
96 case PCB_BARCODE_T: return std::make_unique<PCB_BARCODE>( aContainer );
97 case PCB_ZONE_T: return std::make_unique<ZONE>( aContainer );
98 case PCB_GROUP_T: return std::make_unique<PCB_GROUP>( aContainer );
99 case PCB_GENERATOR_T: return nullptr; // must be created via CreateGeneratorForType
100 case PCB_CONSTRAINT_T: return std::make_unique<PCB_CONSTRAINT>( aContainer );
101 case PCB_REFERENCE_IMAGE_T: return std::make_unique<PCB_REFERENCE_IMAGE>( aContainer );
102 case PCB_GRID_ITEM_T: return std::make_unique<PCB_GRID_ITEM>( aContainer );
103
104 case PCB_PAD_T:
105 {
106 FOOTPRINT* footprint = dynamic_cast<FOOTPRINT*>( aContainer );
107
108 if( !footprint )
109 return nullptr;
110
111 return std::make_unique<PAD>( footprint );
112 }
113
114 case PCB_3D_BODY_T:
115 {
116 FOOTPRINT* footprint = dynamic_cast<FOOTPRINT*>( aContainer );
117
118 if( !footprint )
119 return nullptr;
120
121 return std::make_unique<PCB_3D_BODY>( footprint );
122 }
123
124 case PCB_FIELD_T:
125 {
126 FOOTPRINT* footprint = dynamic_cast<FOOTPRINT*>( aContainer );
127
128 if( !footprint )
129 return nullptr;
130
131 return std::make_unique<PCB_FIELD>( footprint, FIELD_T::USER );
132 }
133
134 case PCB_FOOTPRINT_T:
135 {
136 BOARD* board = dynamic_cast<BOARD*>( aContainer );
137
138 if( !board )
139 return nullptr;
140
141 return std::make_unique<FOOTPRINT>( board );
142 }
143
144 case PCB_DIM_ALIGNED_T: return std::make_unique<PCB_DIM_ALIGNED>( aContainer );
145 case PCB_DIM_ORTHOGONAL_T: return std::make_unique<PCB_DIM_ORTHOGONAL>( aContainer );
146 case PCB_DIM_RADIAL_T: return std::make_unique<PCB_DIM_RADIAL>( aContainer );
147 case PCB_DIM_LEADER_T: return std::make_unique<PCB_DIM_LEADER>( aContainer );
148 case PCB_DIM_CENTER_T: return std::make_unique<PCB_DIM_CENTER>( aContainer );
149
150 default:
151 return nullptr;
152 }
153}
154
156{
157
158void PackLayerSet( google::protobuf::RepeatedField<int>& aOutput, const LSET& aLayerSet )
159{
160 for( const PCB_LAYER_ID& layer : aLayerSet.Seq() )
161 aOutput.Add( ToProtoEnum<PCB_LAYER_ID, types::BoardLayer>( layer ) );
162}
163
164
165LSET UnpackLayerSet( const google::protobuf::RepeatedField<int>& aProtoLayerSet )
166{
167 LSET set;
168
169 for( int layer : aProtoLayerSet )
170 {
171 wxCHECK2( layer >= F_Cu && layer < PCB_LAYER_ID_COUNT, continue );
172 PCB_LAYER_ID boardLayer =
173 FromProtoEnum<PCB_LAYER_ID>( static_cast<types::BoardLayer>( layer ) );
174
175 if( boardLayer >= 0 && IsValidLayer( boardLayer ) )
176 set.set( boardLayer );
177 }
178
179 return set;
180}
181
182
183void PackBoardStackup( const BOARD& aBoard, BoardStackup& aOut )
184{
185 aBoard.GetStackupOrDefault().Serialize( aOut );
186
187 for( BoardStackupLayer& layer : *aOut.mutable_layers() )
188 {
189 if( layer.type() == BoardStackupLayerType::BSLT_DIELECTRIC )
190 continue;
191
192 PCB_LAYER_ID id = FromProtoEnum<PCB_LAYER_ID>( layer.layer() );
193
194 layer.set_user_name( aBoard.GetLayerName( id ) );
195 }
196}
197
198
199void PackTeardropSettings( types::PadTeardropSettings& aOutput, const TEARDROP_PARAMETERS& aParams )
200{
201 aOutput.set_mode( aParams.m_Enabled ? types::PadTeardropMode::PTM_ENABLED : types::PadTeardropMode::PTM_DISABLED );
202 aOutput.set_curved_edges( aParams.m_CurvedEdges );
203 aOutput.set_allow_multiple_track_segments( aParams.m_AllowUseTwoTracks );
204 aOutput.set_prefer_zone_connection( !aParams.m_TdOnPadsInZones );
205 aOutput.mutable_max_length()->set_value_nm( aParams.m_TdMaxLen );
206 aOutput.mutable_max_width()->set_value_nm( aParams.m_TdMaxWidth );
207 aOutput.set_best_length_ratio( aParams.m_BestLengthRatio );
208 aOutput.set_best_width_ratio( aParams.m_BestWidthRatio );
209 aOutput.set_max_track_width_ratio( aParams.m_WidthtoSizeFilterRatio );
210}
211
212
213void UnpackTeardropSettings( TEARDROP_PARAMETERS& aOutput, const types::PadTeardropSettings& aProto )
214{
215 aOutput.m_Enabled = ( aProto.mode() == types::PadTeardropMode::PTM_ENABLED );
216 aOutput.m_CurvedEdges = aProto.curved_edges();
217 aOutput.m_AllowUseTwoTracks = aProto.allow_multiple_track_segments();
218 aOutput.m_TdOnPadsInZones = !aProto.prefer_zone_connection();
219 aOutput.m_TdMaxLen = aProto.max_length().value_nm();
220 aOutput.m_TdMaxWidth = aProto.max_width().value_nm();
221 aOutput.m_BestLengthRatio = aProto.best_length_ratio();
222 aOutput.m_BestWidthRatio = aProto.best_width_ratio();
223 aOutput.m_WidthtoSizeFilterRatio = aProto.max_track_width_ratio();
224}
225
226
227void PackZoneLayerOverrides( google::protobuf::RepeatedPtrField<types::ZoneLayerOverrideEntry>* aOutput,
228 const std::map<PCB_LAYER_ID, ZONE_LAYER_OVERRIDE>& aInput )
229{
230 aOutput->Clear();
231
232 for( const auto& [layer, overrideVal] : aInput )
233 {
234 types::ZoneLayerOverride protoOverride = types::ZLO_NONE;
235
236 switch( overrideVal )
237 {
238 case ZLO_FORCE_FLASHED: protoOverride = types::ZLO_FORCE_FLASHED; break;
239 case ZLO_FORCE_NO_ZONE_CONNECTION: protoOverride = types::ZLO_FORCE_NO_ZONE_CONNECTION; break;
240 default: break;
241 }
242
243 if( protoOverride != types::ZLO_NONE )
244 {
245 types::ZoneLayerOverrideEntry* entry = aOutput->Add();
246 entry->set_layer( ToProtoEnum<PCB_LAYER_ID, types::BoardLayer>( layer ) );
247 entry->set_override( protoOverride );
248 }
249 }
250}
251
252
253void UnpackZoneLayerOverrides( std::map<PCB_LAYER_ID, ZONE_LAYER_OVERRIDE>& aOutput,
254 const google::protobuf::RepeatedPtrField<types::ZoneLayerOverrideEntry>& aInput )
255{
256 for( const types::ZoneLayerOverrideEntry& entry : aInput )
257 {
258 ZONE_LAYER_OVERRIDE overrideVal = ZLO_NONE;
259
260 switch( entry.override() )
261 {
262 case types::ZLO_FORCE_FLASHED: overrideVal = ZLO_FORCE_FLASHED; break;
263 case types::ZLO_FORCE_NO_ZONE_CONNECTION: overrideVal = ZLO_FORCE_NO_ZONE_CONNECTION; break;
264 default: break;
265 }
266
267 aOutput[FromProtoEnum<PCB_LAYER_ID>( entry.layer() )] = overrideVal;
268 }
269}
270
271
272void PackEmbeddedFiles( common::types::EmbeddedFiles& aOutput, const EMBEDDED_FILES& aFiles )
273{
274 for( const auto& [name, file] : aFiles.EmbeddedFileMap() )
275 {
276 if( file->compressedEncodedData.empty() )
277 continue;
278
279 common::types::EmbeddedFile* proto = aOutput.add_files();
280 proto->set_name( name.ToUTF8() );
281 proto->set_type(
283 proto->set_data( file->compressedEncodedData );
284 proto->set_data_hash( file->data_hash );
285 }
286}
287
288
289bool UnpackEmbeddedFiles( EMBEDDED_FILES& aOutput, const common::types::EmbeddedFiles& aProto )
290{
291 EMBEDDED_FILES files;
292
293 for( const common::types::EmbeddedFile& protoFile : aProto.files() )
294 {
295 auto file = std::make_shared<EMBEDDED_FILES::EMBEDDED_FILE>();
296 file->name = wxString::FromUTF8( protoFile.name() );
297 file->type = FromProtoEnum<EMBEDDED_FILES::EMBEDDED_FILE::FILE_TYPE>( protoFile.type() );
298 file->compressedEncodedData = protoFile.data();
299 file->data_hash = protoFile.data_hash();
300
301 if( EMBEDDED_FILES::DecompressAndDecode( *file, /* aAllowEmptyHash = */ true )
303 {
304 return false;
305 }
306
307 if( !file->Validate() )
308 return false;
309
310 files.AddFile( file );
311 }
312
313 bool embedFonts = aOutput.GetAreFontsEmbedded();
314 aOutput.ClearEmbeddedFiles();
315 aOutput = files;
316 aOutput.SetAreFontsEmbedded( embedFonts );
317
318 return true;
319}
320
321
322std::vector<BOARD_ITEM*> FindItemsFromSyncSelection(
323 const BOARD* aBoard,
324 const google::protobuf::RepeatedPtrField<kiapi::common::commands::SelectionSpec>& aItems )
325{
326 using kiapi::common::commands::SelectionSpec;
327
328 std::vector<std::pair<int, BOARD_ITEM*>> orderPairs;
329 wxCHECK( aBoard, {} );
330
331 // Unpacking rebuilds a KIID per path element, so do it once rather than per footprint
332 std::vector<KIID_PATH> sheetPaths( aItems.size() );
333
334 for( int index = 0; index < aItems.size(); ++index )
335 {
336 if( aItems[index].spec_case() == SelectionSpec::SpecCase::kSheetPath )
337 sheetPaths[index] = kiapi::common::UnpackSheetPath( aItems[index].sheet_path() );
338 }
339
340 for( FOOTPRINT* footprint : aBoard->Footprints() )
341 {
342 wxString fpRef = footprint->GetReference();
343
344 for( int index = 0; index < aItems.size(); ++index )
345 {
346 const SelectionSpec& spec = aItems[index];
347
348 switch( spec.spec_case() )
349 {
350 case SelectionSpec::SpecCase::kFootprint:
351 {
352 if( fpRef == wxString::FromUTF8( spec.footprint().reference() ) )
353 orderPairs.emplace_back( index, footprint );
354
355 break;
356 }
357
358 case SelectionSpec::SpecCase::kPad:
359 {
360 if( fpRef == wxString::FromUTF8( spec.pad().reference() ) )
361 {
362 wxString padNumber = wxString::FromUTF8( spec.pad().number() );
363
364 for( PAD* pad : footprint->Pads() )
365 {
366 if( padNumber == pad->GetNumber() )
367 orderPairs.emplace_back( index, pad );
368 }
369 }
370
371 break;
372 }
373
374 case SelectionSpec::SpecCase::kSheetPath:
375 {
376 if( footprint->IsWithinSchematicSheet( sheetPaths[index] ) )
377 orderPairs.emplace_back( index, footprint );
378
379 break;
380 }
381
382 default: break;
383 }
384 }
385 }
386
387 std::ranges::sort( orderPairs,
388 []( const std::pair<int, BOARD_ITEM*>& a, const std::pair<int, BOARD_ITEM*>& b ) -> bool
389 {
390 return a.first < b.first;
391 } );
392
393 std::vector<BOARD_ITEM*> items;
394 items.reserve( orderPairs.size() );
395
396 for( BOARD_ITEM* val : orderPairs | std::views::values )
397 items.push_back( val );
398
399 return items;
400}
401
402} // namespace kiapi::board
int index
const char * name
KICOMMON_API types::KiCadObjectType ToProtoEnum(KICAD_T aValue)
KICOMMON_API KICAD_T FromProtoEnum(types::KiCadObjectType aValue)
Definition api_enums.cpp:56
std::unique_ptr< BOARD_ITEM > CreateGeneratorForType(const wxString &aGeneratorType, BOARD_ITEM_CONTAINER *aContainer)
std::unique_ptr< BOARD_ITEM > CreateItemForType(KICAD_T aType, BOARD_ITEM_CONTAINER *aContainer)
ZONE_LAYER_OVERRIDE
Conditionally flashed vias and pads that interact with zones of different priority can be very squirr...
Definition board_item.h:75
@ ZLO_NONE
Definition board_item.h:76
@ ZLO_FORCE_NO_ZONE_CONNECTION
Definition board_item.h:78
@ ZLO_FORCE_FLASHED
Definition board_item.h:77
BASE_SET & set(size_t pos)
Definition base_set.h:126
Abstract interface for BOARD_ITEMs capable of storing other items inside.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition board_item.h:99
void Serialize(google::protobuf::Any &aContainer) const override
Serializes this object to the given Any message.
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:411
BOARD_STACKUP GetStackupOrDefault() const
Definition board.cpp:3506
const FOOTPRINTS & Footprints() const
Definition board.h:465
const wxString GetLayerName(PCB_LAYER_ID aLayer) const
Return the name of a aLayer.
Definition board.cpp:960
virtual void SetParent(EDA_ITEM *aParent)
Definition eda_item.cpp:153
static RETURN_CODE DecompressAndDecode(EMBEDDED_FILE &aFile, bool aAllowEmptyHash=false)
Takes data from the compressedEncodedData buffer and Base64 decodes it.
void ClearEmbeddedFiles(bool aDeleteFiles=true)
EMBEDDED_FILE * AddFile(const wxFileName &aName, bool aOverwrite)
Load a file from disk and adds it to the collection.
const std::map< wxString, std::shared_ptr< EMBEDDED_FILE > > & EmbeddedFileMap() const
Provide an iterable view of the file collection.
void SetAreFontsEmbedded(bool aEmbedFonts)
bool GetAreFontsEmbedded() const
PCB_GENERATOR * CreateFromType(const wxString &aTypeStr)
static GENERATORS_MGR & Instance()
LSET is a set of PCB_LAYER_IDs.
Definition lset.h:37
LSEQ Seq(const LSEQ &aSequence) const
Return an LSEQ from the union of this LSET and a desired sequence.
Definition lset.cpp:309
Definition pad.h:61
TEARDROP_PARAMETARS is a helper class to handle parameters needed to build teardrops for a board thes...
double m_BestWidthRatio
The height of a teardrop as ratio between height and size of pad/via.
int m_TdMaxLen
max allowed length for teardrops in IU. <= 0 to disable
bool m_AllowUseTwoTracks
True to create teardrops using 2 track segments if the first in too small.
int m_TdMaxWidth
max allowed height for teardrops in IU. <= 0 to disable
double m_BestLengthRatio
The length of a teardrop as ratio between length and size of pad/via.
double m_WidthtoSizeFilterRatio
The ratio (H/D) between the via/pad size and the track width max value to create a teardrop 1....
bool m_TdOnPadsInZones
A filter to exclude pads inside zone fills.
bool m_Enabled
Flag to enable teardrops.
bool m_CurvedEdges
True if the teardrop should be curved.
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:56
@ PCB_LAYER_ID_COUNT
Definition layer_ids.h:167
@ F_Cu
Definition layer_ids.h:60
bool IsValidLayer(int aLayerId)
Test whether a given integer is a valid layer index, i.e.
Definition layer_ids.h:722
void PackLayerSet(google::protobuf::RepeatedField< int > &aOutput, const LSET &aLayerSet)
void PackBoardStackup(const BOARD &aBoard, BoardStackup &aOut)
void PackEmbeddedFiles(common::types::EmbeddedFiles &aOutput, const EMBEDDED_FILES &aFiles)
void PackZoneLayerOverrides(google::protobuf::RepeatedPtrField< types::ZoneLayerOverrideEntry > *aOutput, const std::map< PCB_LAYER_ID, ZONE_LAYER_OVERRIDE > &aInput)
void UnpackTeardropSettings(TEARDROP_PARAMETERS &aOutput, const types::PadTeardropSettings &aProto)
bool UnpackEmbeddedFiles(EMBEDDED_FILES &aOutput, const common::types::EmbeddedFiles &aProto)
LSET UnpackLayerSet(const google::protobuf::RepeatedField< int > &aProtoLayerSet)
std::vector< BOARD_ITEM * > FindItemsFromSyncSelection(const BOARD *aBoard, const google::protobuf::RepeatedPtrField< kiapi::common::commands::SelectionSpec > &aItems)
Resolve a cross-probe selection request against a board.
void UnpackZoneLayerOverrides(std::map< PCB_LAYER_ID, ZONE_LAYER_OVERRIDE > &aOutput, const google::protobuf::RepeatedPtrField< types::ZoneLayerOverrideEntry > &aInput)
void PackTeardropSettings(types::PadTeardropSettings &aOutput, const TEARDROP_PARAMETERS &aParams)
KICOMMON_API KIID_PATH UnpackSheetPath(const types::SheetPath &aInput)
BARCODE class definition.
Class to handle a set of BOARD_ITEMs.
@ USER
The field ID hasn't been set yet; field is invalid.
const std::string table
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition typeinfo.h:70
@ PCB_CONSTRAINT_T
a geometric constraint between board items
Definition typeinfo.h:237
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
Definition typeinfo.h:80
@ PCB_DIM_ORTHOGONAL_T
class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
Definition typeinfo.h:98
@ PCB_DIM_LEADER_T
class PCB_DIM_LEADER, a leader dimension (graphic item)
Definition typeinfo.h:95
@ PCB_GENERATOR_T
class PCB_GENERATOR, generator on a layer
Definition typeinfo.h:83
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition typeinfo.h:89
@ PCB_DRILL_MAP_T
class PCB_DRILL_MAP, drill symbols drawn at the holes
Definition typeinfo.h:240
@ PCB_DIM_CENTER_T
class PCB_DIM_CENTER, a center point marking (graphic item)
Definition typeinfo.h:96
@ PCB_GROUP_T
class PCB_GROUP, a set of BOARD_ITEMs
Definition typeinfo.h:103
@ PCB_TEXTBOX_T
class PCB_TEXTBOX, wrapped text on a layer
Definition typeinfo.h:85
@ PCB_ZONE_T
class ZONE, a copper pour area
Definition typeinfo.h:100
@ PCB_TEXT_T
class PCB_TEXT, text on a layer
Definition typeinfo.h:84
@ PCB_3D_BODY_T
class PCB_3D_BODY, a 3D body (extruded or model) on a footprint
Definition typeinfo.h:241
@ PCB_REFERENCE_IMAGE_T
class PCB_REFERENCE_IMAGE, bitmap on a layer
Definition typeinfo.h:81
@ PCB_FIELD_T
class PCB_FIELD, text associated with a footprint property
Definition typeinfo.h:82
@ PCB_BARCODE_T
class PCB_BARCODE, a barcode (graphic item)
Definition typeinfo.h:93
@ PCB_TABLECELL_T
class PCB_TABLECELL, PCB_TEXTBOX for use in tables
Definition typeinfo.h:87
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
Definition typeinfo.h:78
@ PCB_GRID_ITEM_T
a subgrid placed on a board
Definition typeinfo.h:238
@ PCB_DIM_ALIGNED_T
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
Definition typeinfo.h:94
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition typeinfo.h:79
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
Definition typeinfo.h:90
@ PCB_TABLE_T
class PCB_TABLE, table of PCB_TABLECELLs
Definition typeinfo.h:86
@ PCB_STACKUP_TABLE_T
class PCB_STACKUP_TABLE, a live stackup table derived from PCB_TABLE
Definition typeinfo.h:242
@ PCB_POINT_T
class PCB_POINT, a 0-dimensional point
Definition typeinfo.h:105
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition typeinfo.h:88
@ PCB_DIM_RADIAL_T
class PCB_DIM_RADIAL, a radius or diameter dimension
Definition typeinfo.h:97
@ PCB_DRILL_CHART_T
class PCB_DRILL_CHART, a live drill chart derived from PCB_TABLE
Definition typeinfo.h:239