KiCad PCB EDA Suite
Loading...
Searching...
No Matches
collectors.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) 2007-2008 SoftPLC Corporation, Dick Hollenbeck <[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
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU 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, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25#include <collectors.h>
26#include <board_item.h> // class BOARD_ITEM
27
28#include <footprint.h>
29#include <netinfo.h>
30#include <pad.h>
31#include <pcb_track.h>
32#include <pcb_marker.h>
33#include <pcb_dimension.h>
34#include <zone.h>
35#include <pcb_shape.h>
36#include <pcb_group.h>
37#include <macros.h>
38#include <math/util.h> // for KiROUND
39
40
41const std::vector<KICAD_T> GENERAL_COLLECTOR::AllBoardItems = {
42 PCB_MARKER_T, // in m_markers
43 PCB_TEXT_T, // in m_drawings
44 PCB_REFERENCE_IMAGE_T, // in m_drawings
45 PCB_TEXTBOX_T, // in m_drawings
46 PCB_TABLE_T, // in m_drawings
47 PCB_TABLECELL_T, // in tables
48 PCB_SHAPE_T, // in m_drawings
49 PCB_DIM_ALIGNED_T, // in m_drawings
50 PCB_DIM_CENTER_T, // in m_drawings
51 PCB_DIM_RADIAL_T, // in m_drawings
52 PCB_DIM_ORTHOGONAL_T, // in m_drawings
53 PCB_DIM_LEADER_T, // in m_drawings
54 PCB_TARGET_T, // in m_drawings
55 PCB_VIA_T, // in m_tracks
56 PCB_TRACE_T, // in m_tracks
57 PCB_ARC_T, // in m_tracks
58 PCB_PAD_T, // in footprints
59 PCB_FIELD_T, // in footprints
60 PCB_FOOTPRINT_T, // in m_footprints
61 PCB_GROUP_T, // in m_groups
62 PCB_ZONE_T, // in m_zones
63 PCB_POINT_T, // in m_points
64 PCB_GENERATOR_T // in m_generators
65};
66
67
68const std::vector<KICAD_T> GENERAL_COLLECTOR::BoardLevelItems = {
89};
90
91
92const std::vector<KICAD_T> GENERAL_COLLECTOR::Footprints = {
94};
95
96
97const std::vector<KICAD_T> GENERAL_COLLECTOR::PadsOrTracks = {
102};
103
104
105const std::vector<KICAD_T> GENERAL_COLLECTOR::FootprintItems = {
118 PCB_PAD_T,
123};
124
125
126const std::vector<KICAD_T> GENERAL_COLLECTOR::Tracks = {
128 PCB_ARC_T,
130};
131
132
133const std::vector<KICAD_T> GENERAL_COLLECTOR::Dimensions = {
139};
140
141
142const std::vector<KICAD_T> GENERAL_COLLECTOR::DraggableItems = {
144 PCB_VIA_T,
147};
148
149
151{
152 BOARD_ITEM* boardItem = nullptr;
153 FOOTPRINT* footprint = nullptr;
154 PCB_GROUP* group = nullptr;
155 PAD* pad = nullptr;
156 bool pad_through = false;
157 PCB_VIA* via = nullptr;
158 PCB_MARKER* marker = nullptr;
159 ZONE* zone = nullptr;
160 PCB_FIELD* field = nullptr;
161 PCB_TEXT* text = nullptr;
162 PCB_DIMENSION_BASE* dimension = nullptr;
163 PCB_SHAPE* shape = nullptr;
164
165 switch( aTestItem->Type() )
166 {
167 case PCB_PAD_T:
168 // there are pad specific visibility controls.
169 // Criteria to select a pad is:
170 // for smd pads: the footprint parent must be visible, and pads on the corresponding
171 // board side must be visible
172 // if pad is a thru hole, then it can be visible when its parent footprint is not.
173 // for through pads: pads on Front or Back board sides must be visible
174 pad = static_cast<PAD*>( aTestItem );
175 boardItem = pad;
176
177 if( ( pad->GetAttribute() != PAD_ATTRIB::SMD ) &&
178 ( pad->GetAttribute() != PAD_ATTRIB::CONN ) ) // a hole is present, so multiple layers
179 {
180 // proceed to the common tests below, but without the parent footprint test,
181 // by leaving footprint==NULL, but having pad != null
182 pad_through = true;
183 }
184
185 break;
186
187 case PCB_VIA_T: // vias are on many layers, so layer test is specific
188 via = static_cast<PCB_VIA*>( aTestItem );
189 boardItem = via;
190 break;
191
192 case PCB_TRACE_T:
193 case PCB_ARC_T:
194 if( m_Guide->IgnoreTracks() )
196
197 boardItem = static_cast<PCB_TRACK*>( aTestItem );
198 break;
199
200 case PCB_ZONE_T:
201 zone = static_cast<ZONE*>( aTestItem );
202
203 if( m_Guide->IgnoreNoNets() && zone->GetNetCode() == NETINFO_LIST::UNCONNECTED )
205
206 boardItem = zone;
207 break;
208
209 case PCB_SHAPE_T:
210 shape = static_cast<PCB_SHAPE*>( aTestItem );
211
212 if( m_Guide->IgnoreNoNets() && shape->GetNetCode() == NETINFO_LIST::UNCONNECTED )
214
215 boardItem = shape;
216 break;
217
218 case PCB_TEXTBOX_T:
219 case PCB_TABLE_T:
220 case PCB_TABLECELL_T:
221 if( m_Guide->IgnoreNoNets() )
223
224 boardItem = static_cast<BOARD_ITEM*>( aTestItem );
225 break;
226
228 case PCB_DIM_CENTER_T:
229 case PCB_DIM_RADIAL_T:
231 case PCB_DIM_LEADER_T:
232 if( m_Guide->IgnoreNoNets() )
234
235 dimension = static_cast<PCB_DIMENSION_BASE*>( aTestItem );
236 boardItem = dimension;
237 break;
238
239 case PCB_TARGET_T:
240 if( m_Guide->IgnoreNoNets() )
242
243 boardItem = static_cast<BOARD_ITEM*>( aTestItem );
244 break;
245
246 case PCB_POINT_T:
247 boardItem = static_cast<BOARD_ITEM*>( aTestItem );
248 break;
249
250 case PCB_FIELD_T:
251 if( m_Guide->IgnoreNoNets() )
253
254 field = static_cast<PCB_FIELD*>( aTestItem );
255
256 if( !field->IsVisible() )
258
259 if( field->IsReference() && m_Guide->IgnoreFPReferences() )
261
262 if( field->IsValue() && m_Guide->IgnoreFPValues() )
264
266
267 case PCB_TEXT_T:
268 if( m_Guide->IgnoreNoNets() )
270
271 text = static_cast<PCB_TEXT*>( aTestItem );
272 boardItem = text;
273
274 if( text->GetParentFootprint() )
275 {
276 PCB_LAYER_ID layer = text->GetLayer();
277
278 if( m_Guide->IgnoreFPTextOnBack() && IsBackLayer( layer ) )
280
281 if( m_Guide->IgnoreFPTextOnFront() && IsFrontLayer( layer ) )
283 }
284
285 break;
286
287 case PCB_FOOTPRINT_T:
288 footprint = static_cast<FOOTPRINT*>( aTestItem );
289 boardItem = footprint;
290 break;
291
292 case PCB_GROUP_T:
293 group = static_cast<PCB_GROUP*>( aTestItem );
294 boardItem = group;
295 break;
296
297 case PCB_MARKER_T:
298 marker = static_cast<PCB_MARKER*>( aTestItem );
299 boardItem = marker;
300 break;
301
302 default:
303 if( aTestItem->IsBOARD_ITEM() )
304 boardItem = static_cast<BOARD_ITEM*>( aTestItem );
305
306 break;
307 }
308
309 if( boardItem && !footprint )
310 footprint = boardItem->GetParentFootprint();
311
312 // common tests:
313
314 if( footprint )
315 {
316 if( m_Guide->IgnoreFootprintsOnBack() && footprint->GetSide() == B_Cu )
318
319 if( m_Guide->IgnoreFootprintsOnFront() && footprint->GetSide() == F_Cu )
321 }
322
323 // Pads are not sensitive to the layer visibility controls; they all have their own separate
324 // visibility controls.
325 if( pad )
326 {
327 if( m_Guide->IgnorePads() )
329
330 if( ! pad_through )
331 {
332 if( m_Guide->IgnorePadsOnFront() && pad->IsOnLayer(F_Cu ) )
334
335 if( m_Guide->IgnorePadsOnBack() && pad->IsOnLayer(B_Cu ) )
337 }
338 }
339
340 if( marker )
341 {
342 // Markers are not sensitive to the layer
343 if( marker->HitTest( m_refPos ) )
344 Append( aTestItem );
345
347 }
348
349 if( group )
350 {
351 // Groups are not sensitive to the layer ... ?
352 if( group->HitTest( m_refPos ) )
353 Append( aTestItem );
354
356 }
357
358 if( via )
359 {
360 auto type = via->GetViaType();
361
362 if( ( m_Guide->IgnoreThroughVias() && type == VIATYPE::THROUGH )
363 || ( m_Guide->IgnoreBlindBuriedVias() && type == VIATYPE::BLIND_BURIED )
364 || ( m_Guide->IgnoreMicroVias() && type == VIATYPE::MICROVIA ) )
365 {
367 }
368 }
369
370 if( boardItem
371 && ( boardItem->IsOnLayer( m_Guide->GetPreferredLayer() ) )
372 && ( !boardItem->IsLocked() || !m_Guide->IgnoreLockedItems() ) )
373 {
374 // Footprints and their subcomponents: reference, value and pads are not sensitive to the
375 // layer visibility controls; they all have their own separate visibility controls.
376 // For vias, GetLayer() has no meaning, but IsOnLayer() works fine.
377 // User text and fields in a footprint *are* sensitive to layer visibility but they were
378 // already handled.
379
380 int accuracy = m_Guide->Accuracy();
381
382 if( zone )
383 {
384 if( zone->HitTestForCorner( m_refPos, accuracy * 2 ) || zone->HitTestForEdge( m_refPos, accuracy ) )
385 {
386 Append( aTestItem );
388 }
389 else if( !m_Guide->IgnoreZoneFills() )
390 {
391 for( PCB_LAYER_ID layer : zone->GetLayerSet() )
392 {
393 if( m_Guide->IsLayerVisible( layer ) && zone->HitTestFilledArea( layer, m_refPos ) )
394 {
395 Append( aTestItem );
397 }
398 }
399 }
400 }
401 else if( aTestItem == footprint )
402 {
403 if( footprint->HitTest( m_refPos, accuracy ) && footprint->HitTestAccurate( m_refPos, accuracy ) )
404 {
405 Append( aTestItem );
407 }
408 }
409 else if( pad || via )
410 {
411 if( aTestItem->HitTest( m_refPos, accuracy ) )
412 {
413 Append( aTestItem );
415 }
416 }
417 else
418 {
419 PCB_LAYER_ID layer = boardItem->GetLayer();
420
421 if( m_Guide->IsLayerVisible( layer ) )
422 {
423 if( dimension )
424 {
425 // Dimensions feel particularly hard to select, probably due to their noisy
426 // shape making it feel like they should have a larger boundary.
427 accuracy = KiROUND( accuracy * 1.5 );
428 }
429
430 if( aTestItem->HitTest( m_refPos, accuracy ) )
431 {
432 Append( aTestItem );
434 }
435 }
436 }
437 }
438
439 if( m_Guide->IncludeSecondary()
440 && ( !boardItem || !boardItem->IsLocked() || !m_Guide->IgnoreLockedItems() ) )
441 {
442 // For now, "secondary" means "tolerate any visible layer". It has no effect on other
443 // criteria, since there is a separate "ignore" control for those in the COLLECTORS_GUIDE
444
445 // Footprints and their subcomponents: reference, value and pads are not sensitive to the
446 // layer visibility controls; they all have their own separate visibility controls.
447 // For vias, GetLayer() has no meaning, but IsOnLayer() works fine.
448 // User text and fields in a footprint *are* sensitive to layer visibility but they were
449 // already handled.
450
451 int accuracy = m_Guide->Accuracy();
452
453 if( zone )
454 {
455 if( zone->HitTestForCorner( m_refPos, accuracy * 2 ) || zone->HitTestForEdge( m_refPos, accuracy ) )
456 {
457 Append2nd( aTestItem );
459 }
460 else if( !m_Guide->IgnoreZoneFills() )
461 {
462 for( PCB_LAYER_ID layer : zone->GetLayerSet() )
463 {
464 if( m_Guide->IsLayerVisible( layer ) && zone->HitTestFilledArea( layer, m_refPos ) )
465 {
466 Append2nd( aTestItem );
468 }
469 }
470 }
471 }
472 else if( aTestItem->Type() == PCB_FOOTPRINT_T )
473 {
474 // Already tested above, but Coverity can't figure that out
475 wxCHECK( footprint, INSPECT_RESULT::CONTINUE );
476
477 if( footprint->HitTest( m_refPos, accuracy ) && footprint->HitTestAccurate( m_refPos, accuracy ) )
478 {
479 Append2nd( aTestItem );
481 }
482 }
483 else if( pad || via )
484 {
485 if( aTestItem->HitTest( m_refPos, accuracy ) )
486 {
487 Append2nd( aTestItem );
489 }
490 }
491 else if( boardItem && m_Guide->IsLayerVisible( boardItem->GetLayer() ) )
492 {
493 if( dimension )
494 {
495 // Dimensions feel particularly hard to select, probably due to their noisy shape
496 // making it feel like they should have a larger boundary.
497 accuracy = KiROUND( accuracy * 1.5 );
498 }
499
500 if( aTestItem->HitTest( m_refPos, accuracy ) )
501 {
502 Append2nd( aTestItem );
504 }
505 }
506 }
507
508 return INSPECT_RESULT::CONTINUE; // always when collecting
509}
510
511
512void GENERAL_COLLECTOR::Collect( BOARD_ITEM* aItem, const std::vector<KICAD_T>& aScanTypes,
513 const VECTOR2I& aRefPos, const COLLECTORS_GUIDE& aGuide )
514{
515 Empty(); // empty the collection, primary criteria list
516 Empty2nd(); // empty the collection, secondary criteria list
517
518 // remember guide, pass it to Inspect()
519 SetGuide( &aGuide );
520
521 SetScanTypes( aScanTypes );
522
523 // remember where the snapshot was taken from and pass refPos to
524 // the Inspect() function.
525 SetRefPos( aRefPos );
526
527 wxCHECK_RET( aItem, "" );
528 aItem->Visit( m_inspector, nullptr, m_scanTypes );
529
530 // append 2nd list onto end of the first list
531 for( EDA_ITEM* item : m_List2nd )
532 Append( item );
533
534 Empty2nd();
535}
536
537
539{
540 // The Visit() function only visits the testItem if its type was in the the scanList,
541 // so therefore we can collect anything given to us here.
542 Append( testItem );
543
544 return INSPECT_RESULT::CONTINUE; // always when collecting
545}
546
547
548void PCB_TYPE_COLLECTOR::Collect( BOARD_ITEM* aBoard, const std::vector<KICAD_T>& aTypes )
549{
550 Empty();
551 aBoard->Visit( m_inspector, nullptr, aTypes );
552}
553
554
556{
557 BOARD_ITEM* item = (BOARD_ITEM*) testItem;
558
559 if( item->IsOnLayer( m_layer_id ) )
560 Append( testItem );
561
563}
564
565
566void PCB_LAYER_COLLECTOR::Collect( BOARD_ITEM* aBoard, const std::vector<KICAD_T>& aTypes )
567{
568 Empty();
569 aBoard->Visit( m_inspector, nullptr, aTypes );
570}
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition box2.h:990
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition board_item.h:79
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
Definition board_item.h:232
bool IsLocked() const override
virtual bool IsOnLayer(PCB_LAYER_ID aLayer) const
Test to see if this object is on the given layer.
Definition board_item.h:314
FOOTPRINT * GetParentFootprint() const
An abstract base class whose derivatives may be passed to a GENERAL_COLLECTOR telling it what should ...
Definition collectors.h:54
INSPECTOR_FUNC m_inspector
Definition collector.h:246
void Empty()
Clear the list.
Definition collector.h:91
VECTOR2I m_refPos
Definition collector.h:248
void SetScanTypes(const std::vector< KICAD_T > &aTypes)
Record the list of KICAD_T types to consider for collection by the Inspect() function.
Definition collector.h:213
void SetRefPos(const VECTOR2I &aRefPos)
Definition collector.h:215
std::vector< KICAD_T > m_scanTypes
Definition collector.h:245
void Append(EDA_ITEM *item)
Add an item to the end of the list.
Definition collector.h:101
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
virtual INSPECT_RESULT Visit(INSPECTOR inspector, void *testData, const std::vector< KICAD_T > &aScanTypes)
May be re-implemented for each derived class in order to handle all the types given by its member dat...
Definition eda_item.cpp:127
virtual bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const
Test if aPosition is inside or on the boundary of this item.
Definition eda_item.h:233
virtual bool IsVisible() const
Definition eda_text.h:186
PCB_LAYER_ID GetSide() const
Use instead of IsFlipped() when you also need to account for unsided footprints (those purely on user...
bool HitTestAccurate(const VECTOR2I &aPosition, int aAccuracy=0) const
Test if a point is inside the bounding polygon of the footprint.
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
static const std::vector< KICAD_T > BoardLevelItems
A scan list for all primary board items, omitting items which are subordinate to a FOOTPRINT,...
Definition collectors.h:68
void SetGuide(const COLLECTORS_GUIDE *aGuide)
Record which COLLECTORS_GUIDE to use.
Definition collectors.h:291
static const std::vector< KICAD_T > PadsOrTracks
A scan list for PADs, TRACKs, or VIAs.
Definition collectors.h:97
void Append2nd(EDA_ITEM *item)
Definition collectors.h:281
INSPECT_RESULT Inspect(EDA_ITEM *aTestItem, void *aTestData) override
The examining function within the INSPECTOR which is passed to the Iterate function.
std::vector< EDA_ITEM * > m_List2nd
A place to hold collected objects which don't match precisely the search criteria,...
Definition collectors.h:215
static const std::vector< KICAD_T > Footprints
A scan list for only FOOTPRINTs.
Definition collectors.h:92
static const std::vector< KICAD_T > AllBoardItems
A scan list for all editable board items.
Definition collectors.h:41
static const std::vector< KICAD_T > Tracks
A scan list for only TRACKs and ARCs.
Definition collectors.h:126
void Collect(BOARD_ITEM *aItem, const std::vector< KICAD_T > &aScanList, const VECTOR2I &aRefPos, const COLLECTORS_GUIDE &aGuide)
Scan a BOARD_ITEM using this class's Inspector method, which does the collection.
static const std::vector< KICAD_T > Dimensions
A scan list for dimensions.
Definition collectors.h:133
static const std::vector< KICAD_T > FootprintItems
A scan list for primary footprint items.
Definition collectors.h:105
const COLLECTORS_GUIDE * m_Guide
Determine which items are to be collected by Inspect().
Definition collectors.h:220
static const std::vector< KICAD_T > DraggableItems
A scan list for items that can be dragged.
Definition collectors.h:142
bool IsBOARD_ITEM() const
Definition view_item.h:102
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
Definition netinfo.h:365
Definition pad.h:54
Abstract dimension API.
bool IsReference() const
Definition pcb_field.h:68
bool IsValue() const
Definition pcb_field.h:69
A set of BOARD_ITEMs (i.e., without duplicates).
Definition pcb_group.h:53
void Collect(BOARD_ITEM *aBoard, const std::vector< KICAD_T > &aTypes)
Test a BOARD_ITEM using this class's Inspector method, which does the collection.
INSPECT_RESULT Inspect(EDA_ITEM *testItem, void *testData) override
The examining function within the INSPECTOR which is passed to the iterate function.
PCB_LAYER_ID m_layer_id
Definition collectors.h:575
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
Definition pcb_marker.h:72
void Collect(BOARD_ITEM *aBoard, const std::vector< KICAD_T > &aTypes)
Collect BOARD_ITEM objects using this class's Inspector method, which does the collection.
INSPECT_RESULT Inspect(EDA_ITEM *testItem, void *testData) override
The examining function within the INSPECTOR which is passed to the Iterate function.
Handle a list of polygons defining a copper zone.
Definition zone.h:74
bool HitTestForCorner(const VECTOR2I &refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX *aCornerHit=nullptr) const
Test if the given VECTOR2I is near a corner.
Definition zone.cpp:713
bool HitTestForEdge(const VECTOR2I &refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX *aCornerHit=nullptr) const
Test if the given VECTOR2I is near a segment defined by 2 corners.
Definition zone.cpp:720
bool HitTestFilledArea(PCB_LAYER_ID aLayer, const VECTOR2I &aRefPos, int aAccuracy=0) const
Test if the given VECTOR2I is within the bounds of a filled area of this zone.
Definition zone.cpp:820
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition zone.h:136
INSPECT_RESULT
Definition eda_item.h:44
bool IsFrontLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a front layer.
Definition layer_ids.h:776
bool IsBackLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a back layer.
Definition layer_ids.h:799
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:60
@ B_Cu
Definition layer_ids.h:65
@ F_Cu
Definition layer_ids.h:64
This file contains miscellaneous commonly used macros and functions.
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
Definition macros.h:83
@ SMD
Smd pad, appears on the solder paste layer (default)
Definition padstack.h:83
@ CONN
Like smd, does not appear on the solder paste layer (default) Note: also has a special attribute in G...
Definition padstack.h:84
Class to handle a set of BOARD_ITEMs.
@ THROUGH
Definition pcb_track.h:67
@ BLIND_BURIED
Definition pcb_track.h:68
@ MICROVIA
Definition pcb_track.h:69
const int accuracy
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
Definition typeinfo.h:88
@ PCB_DIM_ORTHOGONAL_T
class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
Definition typeinfo.h:105
@ PCB_DIM_LEADER_T
class PCB_DIM_LEADER, a leader dimension (graphic item)
Definition typeinfo.h:102
@ PCB_GENERATOR_T
class PCB_GENERATOR, generator on a layer
Definition typeinfo.h:91
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition typeinfo.h:97
@ PCB_DIM_CENTER_T
class PCB_DIM_CENTER, a center point marking (graphic item)
Definition typeinfo.h:103
@ PCB_GROUP_T
class PCB_GROUP, a set of BOARD_ITEMs
Definition typeinfo.h:110
@ PCB_TEXTBOX_T
class PCB_TEXTBOX, wrapped text on a layer
Definition typeinfo.h:93
@ PCB_ZONE_T
class ZONE, a copper pour area
Definition typeinfo.h:107
@ PCB_TEXT_T
class PCB_TEXT, text on a layer
Definition typeinfo.h:92
@ PCB_REFERENCE_IMAGE_T
class PCB_REFERENCE_IMAGE, bitmap on a layer
Definition typeinfo.h:89
@ PCB_FIELD_T
class PCB_FIELD, text associated with a footprint property
Definition typeinfo.h:90
@ PCB_MARKER_T
class PCB_MARKER, a marker used to show something
Definition typeinfo.h:99
@ PCB_TARGET_T
class PCB_TARGET, a target (graphic item)
Definition typeinfo.h:106
@ PCB_TABLECELL_T
class PCB_TABLECELL, PCB_TEXTBOX for use in tables
Definition typeinfo.h:95
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
Definition typeinfo.h:86
@ PCB_DIM_ALIGNED_T
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
Definition typeinfo.h:101
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition typeinfo.h:87
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
Definition typeinfo.h:98
@ PCB_TABLE_T
class PCB_TABLE, table of PCB_TABLECELLs
Definition typeinfo.h:94
@ PCB_POINT_T
class PCB_POINT, a 0-dimensional point
Definition typeinfo.h:112
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition typeinfo.h:96
@ PCB_DIM_RADIAL_T
class PCB_DIM_RADIAL, a radius or diameter dimension
Definition typeinfo.h:104
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:695