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, see <https://www.gnu.org/licenses/>.
19 */
20
21#include <collectors.h>
22#include <board_item.h> // class BOARD_ITEM
23
24#include <footprint.h>
25#include <netinfo.h>
26#include <pad.h>
27#include <pcb_track.h>
28#include <pcb_marker.h>
29#include <pcb_grid_item.h>
30#include <pcb_dimension.h>
31#include <zone.h>
32#include <pcb_shape.h>
33#include <pcb_group.h>
34#include <macros.h>
35#include <math/util.h> // for KiROUND
36
37
38const std::vector<KICAD_T> GENERAL_COLLECTOR::AllBoardItems = {
39 PCB_MARKER_T, // in m_markers
40 PCB_TEXT_T, // in m_drawings
41 PCB_REFERENCE_IMAGE_T, // in m_drawings
42 PCB_TEXTBOX_T, // in m_drawings
43 PCB_TABLE_T, // in m_drawings
44 PCB_DRILL_CHART_T, // in m_drawings
45 PCB_STACKUP_TABLE_T, // in m_drawings
46 PCB_DRILL_MAP_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 PCB_BARCODE_T, // in m_drawings
66 PCB_GRID_ITEM_T, // in m_drawings
67};
68
69
70const std::vector<KICAD_T> GENERAL_COLLECTOR::BoardLevelItems = {
96};
97
98
99const std::vector<KICAD_T> GENERAL_COLLECTOR::Footprints = {
101};
102
103
104const std::vector<KICAD_T> GENERAL_COLLECTOR::PadsOrTracks = {
105 PCB_PAD_T,
106 PCB_VIA_T,
109};
110
111
112const std::vector<KICAD_T> GENERAL_COLLECTOR::FootprintItems = {
125 PCB_PAD_T,
131};
132
133
134const std::vector<KICAD_T> GENERAL_COLLECTOR::Tracks = {
136 PCB_ARC_T,
138};
139
140
141const std::vector<KICAD_T> GENERAL_COLLECTOR::Dimensions = {
147};
148
149
150const std::vector<KICAD_T> GENERAL_COLLECTOR::DraggableItems = {
152 PCB_VIA_T,
155};
156
157
159{
160 BOARD_ITEM* boardItem = nullptr;
161 FOOTPRINT* footprint = nullptr;
162 PCB_GROUP* group = nullptr;
163 PAD* pad = nullptr;
164 bool pad_through = false;
165 PCB_VIA* via = nullptr;
166 PCB_MARKER* marker = nullptr;
167 PCB_GRID_ITEM* gridItem = nullptr;
168 ZONE* zone = nullptr;
169 PCB_FIELD* field = nullptr;
170 PCB_TEXT* text = nullptr;
171 PCB_DIMENSION_BASE* dimension = nullptr;
172 PCB_SHAPE* shape = nullptr;
173
174 switch( aTestItem->Type() )
175 {
176 case PCB_PAD_T:
177 // there are pad specific visibility controls.
178 // Criteria to select a pad is:
179 // for smd pads: the footprint parent must be visible, and pads on the corresponding
180 // board side must be visible
181 // if pad is a thru hole, then it can be visible when its parent footprint is not.
182 // for through pads: pads on Front or Back board sides must be visible
183 pad = static_cast<PAD*>( aTestItem );
184 boardItem = pad;
185
186 if( ( pad->GetAttribute() != PAD_ATTRIB::SMD ) &&
187 ( pad->GetAttribute() != PAD_ATTRIB::CONN ) &&
188 ( pad->GetAttribute() != PAD_ATTRIB::NON_COMPONENT ) ) // a hole is present, so multiple layers
189 {
190 // proceed to the common tests below, but without the parent footprint test,
191 // by leaving footprint==NULL, but having pad != null
192 pad_through = true;
193 }
194
195 break;
196
197 case PCB_VIA_T: // vias are on many layers, so layer test is specific
198 via = static_cast<PCB_VIA*>( aTestItem );
199 boardItem = via;
200 break;
201
202 case PCB_TRACE_T:
203 case PCB_ARC_T:
204 if( m_Guide->IgnoreTracks() )
206
207 boardItem = static_cast<PCB_TRACK*>( aTestItem );
208 break;
209
210 case PCB_ZONE_T:
211 zone = static_cast<ZONE*>( aTestItem );
212
213 if( m_Guide->IgnoreNoNets() && zone->GetNetCode() == NETINFO_LIST::UNCONNECTED )
215
216 boardItem = zone;
217 break;
218
219 case PCB_SHAPE_T:
220 shape = static_cast<PCB_SHAPE*>( aTestItem );
221
222 if( m_Guide->IgnoreNoNets() && shape->GetNetCode() == NETINFO_LIST::UNCONNECTED )
224
225 boardItem = shape;
226 break;
227
228 case PCB_TEXTBOX_T:
229 case PCB_TABLE_T:
232 case PCB_DRILL_MAP_T:
233 case PCB_TABLECELL_T:
234 if( m_Guide->IgnoreNoNets() )
236
237 boardItem = static_cast<BOARD_ITEM*>( aTestItem );
238 break;
239
241 case PCB_DIM_CENTER_T:
242 case PCB_DIM_RADIAL_T:
244 case PCB_DIM_LEADER_T:
245 if( m_Guide->IgnoreNoNets() )
247
248 dimension = static_cast<PCB_DIMENSION_BASE*>( aTestItem );
249 boardItem = dimension;
250 break;
251
252 case PCB_TARGET_T:
253 if( m_Guide->IgnoreNoNets() )
255
256 boardItem = static_cast<BOARD_ITEM*>( aTestItem );
257 break;
258
259 case PCB_POINT_T:
260 boardItem = static_cast<BOARD_ITEM*>( aTestItem );
261 break;
262
263 case PCB_GRID_ITEM_T:
264 gridItem = static_cast<PCB_GRID_ITEM*>( aTestItem );
265 boardItem = gridItem;
266 break;
267
268 case PCB_FIELD_T:
269 if( m_Guide->IgnoreNoNets() )
271
272 field = static_cast<PCB_FIELD*>( aTestItem );
273
274 if( !field->IsVisible() )
276
277 if( field->IsReference() && m_Guide->IgnoreFPReferences() )
279
280 if( field->IsValue() && m_Guide->IgnoreFPValues() )
282
284
285 case PCB_TEXT_T:
286 if( m_Guide->IgnoreNoNets() )
288
289 text = static_cast<PCB_TEXT*>( aTestItem );
290 boardItem = text;
291
292 if( text->GetParentFootprint() )
293 {
294 PCB_LAYER_ID layer = text->GetLayer();
295
296 if( m_Guide->IgnoreFPTextOnBack() && IsBackLayer( layer ) )
298
299 if( m_Guide->IgnoreFPTextOnFront() && IsFrontLayer( layer ) )
301 }
302
303 break;
304
305 case PCB_BARCODE_T:
306 if( m_Guide->IgnoreNoNets() )
308
309 boardItem = static_cast<BOARD_ITEM*>( aTestItem );
310 break;
311
312 case PCB_FOOTPRINT_T:
313 footprint = static_cast<FOOTPRINT*>( aTestItem );
314 boardItem = footprint;
315 break;
316
317 case PCB_GROUP_T:
318 group = static_cast<PCB_GROUP*>( aTestItem );
319 boardItem = group;
320 break;
321
322 case PCB_MARKER_T:
323 marker = static_cast<PCB_MARKER*>( aTestItem );
324 boardItem = marker;
325 break;
326
327 default:
328 if( aTestItem->IsBOARD_ITEM() )
329 boardItem = static_cast<BOARD_ITEM*>( aTestItem );
330
331 break;
332 }
333
334 if( boardItem && !footprint )
335 footprint = boardItem->GetParentFootprint();
336
337 // common tests:
338
339 if( footprint )
340 {
341 if( m_Guide->IgnoreFootprintsOnBack() && footprint->GetSide() == B_Cu )
343
344 if( m_Guide->IgnoreFootprintsOnFront() && footprint->GetSide() == F_Cu )
346 }
347
348 // Pads are not sensitive to the layer visibility controls; they all have their own separate
349 // visibility controls.
350 if( pad )
351 {
352 if( m_Guide->IgnorePads() )
354
355 if( ! pad_through )
356 {
357 if( m_Guide->IgnorePadsOnFront() && pad->IsOnLayer(F_Cu ) )
359
360 if( m_Guide->IgnorePadsOnBack() && pad->IsOnLayer(B_Cu ) )
362 }
363 }
364
365 if( marker )
366 {
367 // Markers are not sensitive to the layer
368 if( marker->HitTest( m_refPos ) )
369 Append( aTestItem );
370
372 }
373
374 if( group )
375 {
376 // Groups are not sensitive to the layer ... ?
377 if( group->HitTest( m_refPos ) )
378 Append( aTestItem );
379
381 }
382
383 if( gridItem )
384 {
385 // Grid items live on every layer; their visibility is controlled by the LAYER_GRID_ITEMS
386 // element, not by the per-copper-layer visibility set.
387 if( gridItem->HitTest( m_refPos, m_Guide->Accuracy() ) )
388 Append( aTestItem );
389
391 }
392
393 if( via )
394 {
395 auto type = via->GetViaType();
396
397 if( ( m_Guide->IgnoreThroughVias() && type == VIATYPE::THROUGH )
398 || ( m_Guide->IgnoreBlindBuriedVias() && ( type == VIATYPE::BLIND || type == VIATYPE::BURIED ) )
399 || ( m_Guide->IgnoreMicroVias() && type == VIATYPE::MICROVIA ) )
400 {
402 }
403 }
404
405 if( boardItem
406 && ( boardItem->IsOnLayer( m_Guide->GetPreferredLayer() ) )
407 && ( !boardItem->IsLocked() || !m_Guide->IgnoreLockedItems() ) )
408 {
409 // Footprints and their subcomponents: reference, value and pads are not sensitive to the
410 // layer visibility controls; they all have their own separate visibility controls.
411 // For vias, GetLayer() has no meaning, but IsOnLayer() works fine.
412 // User text and fields in a footprint *are* sensitive to layer visibility but they were
413 // already handled.
414
415 int accuracy = m_Guide->Accuracy();
416
417 if( zone )
418 {
419 if( zone->HitTestForCorner( m_refPos, accuracy * 2 ) || zone->HitTestForEdge( m_refPos, accuracy ) )
420 {
421 Append( zone );
423 }
424 else if( !m_Guide->IgnoreZoneFills() )
425 {
426 for( PCB_LAYER_ID layer : zone->GetLayerSet() )
427 {
428 if( m_Guide->IsLayerVisible( layer ) && zone->HitTestFilledArea( layer, m_refPos ) )
429 {
430 Append( zone );
432 }
433 }
434 }
435 }
436 else if( aTestItem == footprint )
437 {
438 if( footprint->HitTest( m_refPos, accuracy ) && footprint->HitTestAccurate( m_refPos, accuracy ) )
439 {
440 Append( footprint );
442 }
443 }
444 else if( pad || via )
445 {
446 if( boardItem->HitTest( m_refPos, accuracy ) )
447 {
448 Append( boardItem );
450 }
451 }
452 else
453 {
454 PCB_LAYER_ID layer = boardItem->GetLayer();
455
456 if( m_Guide->IsLayerVisible( layer ) )
457 {
458 if( dimension )
459 {
460 // Dimensions feel particularly hard to select, probably due to their noisy
461 // shape making it feel like they should have a larger boundary.
462 accuracy = KiROUND( accuracy * 1.5 );
463 }
464
465 if( boardItem->HitTest( m_refPos, accuracy ) )
466 {
467 Append( boardItem );
469 }
470 }
471 }
472 }
473
474 if( m_Guide->IncludeSecondary()
475 && ( !boardItem || !boardItem->IsLocked() || !m_Guide->IgnoreLockedItems() ) )
476 {
477 // For now, "secondary" means "tolerate any visible layer". It has no effect on other
478 // criteria, since there is a separate "ignore" control for those in the COLLECTORS_GUIDE
479
480 // Footprints and their subcomponents: reference, value and pads are not sensitive to the
481 // layer visibility controls; they all have their own separate visibility controls.
482 // For vias, GetLayer() has no meaning, but IsOnLayer() works fine.
483 // User text and fields in a footprint *are* sensitive to layer visibility but they were
484 // already handled.
485
486 int accuracy = m_Guide->Accuracy();
487
488 if( zone )
489 {
490 if( zone->HitTestForCorner( m_refPos, accuracy * 2 ) || zone->HitTestForEdge( m_refPos, accuracy ) )
491 {
492 Append2nd( zone );
494 }
495 else if( !m_Guide->IgnoreZoneFills() )
496 {
497 for( PCB_LAYER_ID layer : zone->GetLayerSet() )
498 {
499 if( m_Guide->IsLayerVisible( layer ) && zone->HitTestFilledArea( layer, m_refPos ) )
500 {
501 Append2nd( zone );
503 }
504 }
505 }
506 }
507 else if( aTestItem->Type() == PCB_FOOTPRINT_T )
508 {
509 // Already tested above, but Coverity can't figure that out
510 wxCHECK( footprint, INSPECT_RESULT::CONTINUE );
511
512 if( footprint->HitTest( m_refPos, accuracy ) && footprint->HitTestAccurate( m_refPos, accuracy ) )
513 {
514 Append2nd( footprint );
516 }
517 }
518 else if( pad || via )
519 {
520 if( boardItem->HitTest( m_refPos, accuracy ) )
521 {
522 Append2nd( boardItem );
524 }
525 }
526 else if( boardItem && m_Guide->IsLayerVisible( boardItem->GetLayer() ) )
527 {
528 if( dimension )
529 {
530 // Dimensions feel particularly hard to select, probably due to their noisy shape
531 // making it feel like they should have a larger boundary.
532 accuracy = KiROUND( accuracy * 1.5 );
533 }
534
535 if( boardItem->HitTest( m_refPos, accuracy ) )
536 {
537 Append2nd( boardItem );
539 }
540 }
541 }
542
543 return INSPECT_RESULT::CONTINUE; // always when collecting
544}
545
546
547void GENERAL_COLLECTOR::Collect( BOARD_ITEM* aItem, const std::vector<KICAD_T>& aScanTypes,
548 const VECTOR2I& aRefPos, const COLLECTORS_GUIDE& aGuide )
549{
550 Empty(); // empty the collection, primary criteria list
551 Empty2nd(); // empty the collection, secondary criteria list
552
553 // remember guide, pass it to Inspect()
554 SetGuide( &aGuide );
555
556 SetScanTypes( aScanTypes );
557
558 // remember where the snapshot was taken from and pass refPos to
559 // the Inspect() function.
560 SetRefPos( aRefPos );
561
562 wxCHECK_RET( aItem, "" );
563 aItem->Visit( m_inspector, nullptr, m_scanTypes );
564
565 // append 2nd list onto end of the first list
566 for( EDA_ITEM* item : m_List2nd )
567 Append( item );
568
569 Empty2nd();
570}
571
572
574{
575 // The Visit() function only visits the testItem if its type was in the the scanList,
576 // so therefore we can collect anything given to us here.
577 Append( testItem );
578
579 return INSPECT_RESULT::CONTINUE; // always when collecting
580}
581
582
583void PCB_TYPE_COLLECTOR::Collect( BOARD_ITEM* aBoard, const std::vector<KICAD_T>& aTypes )
584{
585 Empty();
586 aBoard->Visit( m_inspector, nullptr, aTypes );
587}
588
589
591{
592 BOARD_ITEM* item = (BOARD_ITEM*) testItem;
593
594 if( item->IsOnLayer( m_layer_id ) )
595 Append( testItem );
596
598}
599
600
601void PCB_LAYER_COLLECTOR::Collect( BOARD_ITEM* aBoard, const std::vector<KICAD_T>& aTypes )
602{
603 Empty();
604 aBoard->Visit( m_inspector, nullptr, aTypes );
605}
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition box2.h:985
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition board_item.h:99
bool IsLocked() const override
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
virtual bool IsOnLayer(PCB_LAYER_ID aLayer) const
Test to see if this object is on the given layer.
Definition board_item.h:432
FOOTPRINT * GetParentFootprint() const
An abstract base class whose derivatives may be passed to a GENERAL_COLLECTOR telling it what should ...
Definition collectors.h:50
INSPECTOR_FUNC m_inspector
Definition collector.h:244
void Empty()
Clear the list.
Definition collector.h:87
VECTOR2I m_refPos
Definition collector.h:246
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:209
void SetRefPos(const VECTOR2I &aRefPos)
Definition collector.h:213
std::vector< KICAD_T > m_scanTypes
Definition collector.h:243
void Append(EDA_ITEM *item)
Add an item to the end of the list.
Definition collector.h:97
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 aInspector, void *aTestData, 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:297
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:309
virtual bool IsVisible() const
Definition eda_text.h:226
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:70
void SetGuide(const COLLECTORS_GUIDE *aGuide)
Record which COLLECTORS_GUIDE to use.
Definition collectors.h:287
static const std::vector< KICAD_T > PadsOrTracks
A scan list for PADs, TRACKs, or VIAs.
Definition collectors.h:104
void Append2nd(EDA_ITEM *item)
Definition collectors.h:277
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:211
static const std::vector< KICAD_T > Footprints
A scan list for only FOOTPRINTs.
Definition collectors.h:99
static const std::vector< KICAD_T > AllBoardItems
A scan list for all editable board items.
Definition collectors.h:38
static const std::vector< KICAD_T > Tracks
A scan list for only TRACKs and ARCs.
Definition collectors.h:134
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:141
static const std::vector< KICAD_T > FootprintItems
A scan list for primary footprint items.
Definition collectors.h:112
const COLLECTORS_GUIDE * m_Guide
Determine which items are to be collected by Inspect().
Definition collectors.h:216
static const std::vector< KICAD_T > DraggableItems
A scan list for items that can be dragged.
Definition collectors.h:150
bool IsBOARD_ITEM() const
Definition view_item.h:98
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
Definition netinfo.h:281
Definition pad.h:61
Abstract dimension API.
bool IsReference() const
Definition pcb_field.h:76
bool IsValue() const
Definition pcb_field.h:77
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
A set of BOARD_ITEMs (i.e., without duplicates).
Definition pcb_group.h:51
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:572
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:78
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:70
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:987
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:998
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:1105
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition zone.h:133
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:847
bool IsBackLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a back layer.
Definition layer_ids.h:870
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:56
@ B_Cu
Definition layer_ids.h:61
@ F_Cu
Definition layer_ids.h:60
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:79
@ NON_COMPONENT
Pad with no hole that does not connect to a physical component, but rather provides a connection poin...
Definition padstack.h:106
@ SMD
Smd pad, appears on the solder paste layer (default)
Definition padstack.h:100
@ CONN
Like smd, does not appear on the solder paste layer (default) Note: also has a special attribute in G...
Definition padstack.h:101
Class to handle a set of BOARD_ITEMs.
const int accuracy
@ 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_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_MARKER_T
class PCB_MARKER, a marker used to show something
Definition typeinfo.h:91
@ PCB_BARCODE_T
class PCB_BARCODE, a barcode (graphic item)
Definition typeinfo.h:93
@ PCB_TARGET_T
class PCB_TARGET, a target (graphic item)
Definition typeinfo.h:99
@ 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
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:708