KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pcb_group.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) 2020 Joshua Redstone redstone at gmail.com
5 * Copyright (C) 1992-2023 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#include <bitmaps.h>
25#include <eda_draw_frame.h>
27#include <board.h>
28#include <board_item.h>
29#include <footprint.h>
30#include <pcb_generator.h>
31#include <pcb_group.h>
32#include <confirm.h>
33#include <widgets/msgpanel.h>
34#include <view/view.h>
35
36#include <wx/debug.h>
37
39 BOARD_ITEM( aParent, PCB_GROUP_T )
40{
41}
42
43
45 BOARD_ITEM( aParent, idtype, aLayer )
46{
47}
48
49
51{
52 switch ( aType )
53 {
54 case PCB_FOOTPRINT_T:
55 case PCB_PAD_T:
56 case PCB_SHAPE_T:
58 case PCB_FIELD_T:
59 case PCB_TEXT_T:
60 case PCB_TEXTBOX_T:
61 case PCB_TABLE_T:
62 case PCB_GROUP_T:
63 case PCB_GENERATOR_T:
64 case PCB_TRACE_T:
65 case PCB_VIA_T:
66 case PCB_ARC_T:
67 case PCB_DIMENSION_T:
73 case PCB_ZONE_T:
74 return true;
75 default:
76 return false;
77 }
78}
79
80
82{
83 wxCHECK_MSG( IsGroupableType( aItem->Type() ), false,
84 wxT( "Invalid item type added to group: " ) + aItem->GetTypeDesc() );
85
86 // Items can only be in one group at a time
87 if( aItem->GetParentGroup() )
88 aItem->GetParentGroup()->RemoveItem( aItem );
89
90 m_items.insert( aItem );
91 aItem->SetParentGroup( this );
92 return true;
93}
94
95
97{
98 // Only clear the item's group field if it was inside this group
99 if( m_items.erase( aItem ) == 1 )
100 {
101 aItem->SetParentGroup( nullptr );
102 return true;
103 }
104
105 return false;
106}
107
108
110{
111 for( BOARD_ITEM* item : m_items )
112 item->SetParentGroup( nullptr );
113
114 m_items.clear();
115}
116
117
118/*
119 * @return if not in the footprint editor and aItem is in a footprint, returns the
120 * footprint's parent group. Otherwise, returns the aItem's parent group.
121 */
122PCB_GROUP* getClosestGroup( BOARD_ITEM* aItem, bool isFootprintEditor )
123{
124 if( !isFootprintEditor && aItem->GetParent() && aItem->GetParent()->Type() == PCB_FOOTPRINT_T )
125 return aItem->GetParent()->GetParentGroup();
126 else
127 return aItem->GetParentGroup();
128}
129
130
132PCB_GROUP* getNestedGroup( BOARD_ITEM* aItem, PCB_GROUP* aScope, bool isFootprintEditor )
133{
134 PCB_GROUP* group = getClosestGroup( aItem, isFootprintEditor );
135
136 if( group == aScope )
137 return nullptr;
138
139 while( group && group->GetParentGroup() && group->GetParentGroup() != aScope )
140 {
141 if( group->GetParent()->Type() == PCB_FOOTPRINT_T && isFootprintEditor )
142 break;
143
144 group = group->GetParentGroup();
145 }
146
147 return group;
148}
149
150
151PCB_GROUP* PCB_GROUP::TopLevelGroup( BOARD_ITEM* aItem, PCB_GROUP* aScope, bool isFootprintEditor )
152{
153 return getNestedGroup( aItem, aScope, isFootprintEditor );
154}
155
156
157bool PCB_GROUP::WithinScope( BOARD_ITEM* aItem, PCB_GROUP* aScope, bool isFootprintEditor )
158{
159 PCB_GROUP* group = getClosestGroup( aItem, isFootprintEditor );
160
161 if( group && group == aScope )
162 return true;
163
164 PCB_GROUP* nested = getNestedGroup( aItem, aScope, isFootprintEditor );
165
166 return nested && nested->GetParentGroup() && nested->GetParentGroup() == aScope;
167}
168
169
171{
172 return GetBoundingBox().Centre();
173}
174
175
176void PCB_GROUP::SetPosition( const VECTOR2I& aNewpos )
177{
178 VECTOR2I delta = aNewpos - GetPosition();
179
180 Move( delta );
181}
182
183
184void PCB_GROUP::SetLocked( bool aLockState )
185{
186 BOARD_ITEM::SetLocked( aLockState );
187
189 [&]( BOARD_ITEM* child )
190 {
191 child->SetLocked( aLockState );
192 } );
193}
194
195
197{
198 // Use copy constructor to get the same uuid and other fields
199 PCB_GROUP* newGroup = new PCB_GROUP( *this );
200 return newGroup;
201}
202
203
205{
206 // Use copy constructor to get the same uuid and other fields
207 PCB_GROUP* newGroup = new PCB_GROUP( *this );
208 newGroup->m_items.clear();
209
210 for( BOARD_ITEM* member : m_items )
211 {
212 if( member->Type() == PCB_GROUP_T )
213 newGroup->AddItem( static_cast<PCB_GROUP*>( member )->DeepClone() );
214 else if( member->Type() == PCB_GENERATOR_T )
215 newGroup->AddItem( static_cast<PCB_GENERATOR*>( member )->DeepClone() );
216 else
217 newGroup->AddItem( static_cast<BOARD_ITEM*>( member->Clone() ) );
218 }
219
220 return newGroup;
221}
222
223
225{
226 PCB_GROUP* newGroup = static_cast<PCB_GROUP*>( Duplicate() );
227 newGroup->m_items.clear();
228
229 for( BOARD_ITEM* member : m_items )
230 {
231 if( member->Type() == PCB_GROUP_T )
232 newGroup->AddItem( static_cast<PCB_GROUP*>( member )->DeepDuplicate() );
233 else
234 newGroup->AddItem( static_cast<BOARD_ITEM*>( member->Duplicate() ) );
235 }
236
237 return newGroup;
238}
239
240
242{
243 assert( aImage->Type() == PCB_GROUP_T );
244
245 std::swap( *( (PCB_GROUP*) this ), *( (PCB_GROUP*) aImage ) );
246}
247
248
249bool PCB_GROUP::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
250{
251 // Groups are selected by promoting a selection of one of their children
252 return false;
253}
254
255
256bool PCB_GROUP::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
257{
258 // Groups are selected by promoting a selection of one of their children
259 return false;
260}
261
262
264{
265 BOX2I bbox;
266
267 for( BOARD_ITEM* item : m_items )
268 {
269 if( item->Type() == PCB_FOOTPRINT_T )
270 bbox.Merge( static_cast<FOOTPRINT*>( item )->GetBoundingBox( true ) );
271 else
272 bbox.Merge( item->GetBoundingBox() );
273 }
274
275 bbox.Inflate( pcbIUScale.mmToIU( 0.25 ) ); // Give a min size to the bbox
276
277 return bbox;
278}
279
280
281std::shared_ptr<SHAPE> PCB_GROUP::GetEffectiveShape( PCB_LAYER_ID aLayer, FLASHING aFlash ) const
282{
283 std::shared_ptr<SHAPE_COMPOUND> shape = std::make_shared<SHAPE_COMPOUND>();
284
285 for( BOARD_ITEM* item : m_items )
286 shape->AddShape( item->GetEffectiveShape( aLayer, aFlash )->Clone() );
287
288 return shape;
289}
290
291
292INSPECT_RESULT PCB_GROUP::Visit( INSPECTOR aInspector, void* aTestData,
293 const std::vector<KICAD_T>& aScanTypes )
294{
295 for( KICAD_T scanType : aScanTypes )
296 {
297 if( scanType == Type() )
298 {
299 if( INSPECT_RESULT::QUIT == aInspector( this, aTestData ) )
300 return INSPECT_RESULT::QUIT;
301 }
302 }
303
304 return INSPECT_RESULT::CONTINUE;
305}
306
307
309{
310 LSET aSet;
311
312 for( BOARD_ITEM* item : m_items )
313 aSet |= item->GetLayerSet();
314
315 return aSet;
316}
317
318
320{
321 // A group is on a layer if any item is on the layer
322 for( BOARD_ITEM* item : m_items )
323 {
324 if( item->IsOnLayer( aLayer ) )
325 return true;
326 }
327
328 return false;
329}
330
331
332std::vector<int> PCB_GROUP::ViewGetLayers() const
333{
334 return { LAYER_ANCHOR };
335}
336
337
338double PCB_GROUP::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const
339{
340 if( aView->IsLayerVisible( LAYER_ANCHOR ) )
341 return 0.0;
342
343 return std::numeric_limits<double>::max();
344}
345
346
347void PCB_GROUP::Move( const VECTOR2I& aMoveVector )
348{
349 for( BOARD_ITEM* member : m_items )
350 member->Move( aMoveVector );
351}
352
353
354void PCB_GROUP::Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle )
355{
356 for( BOARD_ITEM* item : m_items )
357 item->Rotate( aRotCentre, aAngle );
358}
359
360
361void PCB_GROUP::Flip( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
362{
363 for( BOARD_ITEM* item : m_items )
364 item->Flip( aCentre, aFlipDirection );
365}
366
367
368void PCB_GROUP::Mirror( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
369{
370 for( BOARD_ITEM* item : m_items )
371 item->Mirror( aCentre, aFlipDirection );
372}
373
374
375wxString PCB_GROUP::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
376{
377 if( m_name.empty() )
378 return wxString::Format( _( "Unnamed Group, %zu members" ), m_items.size() );
379 else
380 return wxString::Format( _( "Group '%s', %zu members" ), m_name, m_items.size() );
381}
382
383
385{
386 return BITMAPS::module;
387}
388
389
390void PCB_GROUP::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
391{
392 aList.emplace_back( _( "Group" ), m_name.empty() ? _( "<unnamed>" ) : m_name );
393 aList.emplace_back( _( "Members" ), wxString::Format( wxT( "%zu" ), m_items.size() ) );
394
395 if( aFrame->GetName() == PCB_EDIT_FRAME_NAME && IsLocked() )
396 aList.emplace_back( _( "Status" ), _( "Locked" ) );
397}
398
399
400void PCB_GROUP::RunOnChildren( const std::function<void( BOARD_ITEM* )>& aFunction ) const
401{
402 try
403 {
404 for( BOARD_ITEM* item : m_items )
405 aFunction( item );
406 }
407 catch( std::bad_function_call& )
408 {
409 wxFAIL_MSG( wxT( "Error calling function in PCB_GROUP::RunOnChildren" ) );
410 }
411}
412
413
414void PCB_GROUP::RunOnDescendants( const std::function<void( BOARD_ITEM* )>& aFunction,
415 int aDepth ) const
416{
417 // Avoid freezes with infinite recursion
418 if( aDepth > 20 )
419 return;
420
421 try
422 {
423 for( BOARD_ITEM* item : m_items )
424 {
425 aFunction( item );
426
427 if( item->Type() == PCB_GROUP_T || item->Type() == PCB_GENERATOR_T )
428 item->RunOnDescendants( aFunction, aDepth + 1 );
429 }
430 }
431 catch( std::bad_function_call& )
432 {
433 wxFAIL_MSG( wxT( "Error calling function in PCB_GROUP::RunOnDescendants" ) );
434 }
435}
436
437
438bool PCB_GROUP::operator==( const BOARD_ITEM& aBoardItem ) const
439{
440 if( aBoardItem.Type() != Type() )
441 return false;
442
443 const PCB_GROUP& other = static_cast<const PCB_GROUP&>( aBoardItem );
444
445 return *this == other;
446}
447
448
449bool PCB_GROUP::operator==( const PCB_GROUP& aOther ) const
450{
451 if( m_items.size() != aOther.m_items.size() )
452 return false;
453
454 // The items in groups are in unordered sets hashed by the pointer value, so we need to
455 // order them by UUID (EDA_ITEM_SET) to compare
456 EDA_ITEM_SET itemSet( m_items.begin(), m_items.end() );
457 EDA_ITEM_SET otherItemSet( aOther.m_items.begin(), aOther.m_items.end() );
458
459 for( auto it1 = itemSet.begin(), it2 = otherItemSet.begin(); it1 != itemSet.end(); ++it1, ++it2 )
460 {
461 // Compare UUID instead of the items themselves because we only care if the contents
462 // of the group has changed, not which elements in the group have changed
463 if( ( *it1 )->m_Uuid != ( *it2 )->m_Uuid )
464 return false;
465 }
466
467 return true;
468}
469
470
471double PCB_GROUP::Similarity( const BOARD_ITEM& aOther ) const
472{
473 if( aOther.Type() != Type() )
474 return 0.0;
475
476 const PCB_GROUP& other = static_cast<const PCB_GROUP&>( aOther );
477
478 double similarity = 0.0;
479
480 for( BOARD_ITEM* item : m_items )
481 {
482 for( BOARD_ITEM* otherItem : other.m_items )
483 {
484 similarity += item->Similarity( *otherItem );
485 }
486 }
487
488 return similarity / m_items.size();
489}
490
491
492static struct PCB_GROUP_DESC
493{
495 {
500
501 propMgr.Mask( TYPE_HASH( PCB_GROUP ), TYPE_HASH( BOARD_ITEM ), _HKI( "Position X" ) );
502 propMgr.Mask( TYPE_HASH( PCB_GROUP ), TYPE_HASH( BOARD_ITEM ), _HKI( "Position Y" ) );
503 propMgr.Mask( TYPE_HASH( PCB_GROUP ), TYPE_HASH( BOARD_ITEM ), _HKI( "Layer" ) );
504
505 const wxString groupTab = _HKI( "Group Properties" );
506
507 propMgr.AddProperty( new PROPERTY<PCB_GROUP, wxString>( _HKI( "Name" ),
509 groupTab );
510 }
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:108
BITMAPS
A list of all bitmap identifiers.
Definition: bitmaps_list.h:33
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:79
void SetParentGroup(PCB_GROUP *aGroup)
Definition: board_item.h:89
virtual void SetLocked(bool aLocked)
Definition: board_item.h:328
PCB_GROUP * GetParentGroup() const
Definition: board_item.h:90
virtual BOARD_ITEM * Duplicate() const
Create a copy of this BOARD_ITEM.
Definition: board_item.cpp:243
virtual bool IsLocked() const
Definition: board_item.cpp:75
BOARD_ITEM_CONTAINER * GetParent() const
Definition: board_item.h:215
constexpr BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
Definition: box2.h:558
constexpr Vec Centre() const
Definition: box2.h:97
constexpr BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition: box2.h:658
The base class for create windows for drawing purpose.
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:89
wxString GetTypeDesc() const
Return a translated description of the type for this EDA_ITEM for display in user facing messages.
Definition: eda_item.cpp:323
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:101
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:68
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition: view.h:419
LSET is a set of PCB_LAYER_IDs.
Definition: lset.h:36
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:52
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
Definition: pcb_group.cpp:263
std::unordered_set< BOARD_ITEM * > m_items
Definition: pcb_group.h:221
static bool WithinScope(BOARD_ITEM *aItem, PCB_GROUP *aScope, bool isFootprintEditor)
Definition: pcb_group.cpp:157
wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider, bool aFull) const override
Return a user-visible description string of this item.
Definition: pcb_group.cpp:375
PCB_GROUP * DeepClone() const
Definition: pcb_group.cpp:204
static PCB_GROUP * TopLevelGroup(BOARD_ITEM *aItem, PCB_GROUP *aScope, bool isFootprintEditor)
Definition: pcb_group.cpp:151
void RunOnDescendants(const std::function< void(BOARD_ITEM *)> &aFunction, int aDepth=0) const override
Invoke a function on all descendants.
Definition: pcb_group.cpp:414
static bool IsGroupableType(KICAD_T aType)
Check if the proposed type can be added to a group.
Definition: pcb_group.cpp:50
void Mirror(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Mirror this object relative to a given horizontal axis the layer is not changed.
Definition: pcb_group.cpp:368
void Rotate(const VECTOR2I &aRotCentre, const EDA_ANGLE &aAngle) override
Rotate this object.
Definition: pcb_group.cpp:354
double ViewGetLOD(int aLayer, KIGFX::VIEW *aView) const override
Definition: pcb_group.cpp:338
void RemoveAll()
Definition: pcb_group.cpp:109
bool operator==(const PCB_GROUP &aOther) const
Definition: pcb_group.cpp:449
bool IsOnLayer(PCB_LAYER_ID aLayer) const override
Test to see if this object is on the given layer.
Definition: pcb_group.cpp:319
PCB_GROUP * DeepDuplicate() const
Definition: pcb_group.cpp:224
LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition: pcb_group.cpp:308
void SetName(const wxString &aName)
Definition: pcb_group.h:67
void SetPosition(const VECTOR2I &aNewpos) override
Definition: pcb_group.cpp:176
void Move(const VECTOR2I &aMoveVector) override
Move this object.
Definition: pcb_group.cpp:347
double Similarity(const BOARD_ITEM &aOther) const override
Return a measure of how likely the other object is to represent the same object.
Definition: pcb_group.cpp:471
INSPECT_RESULT Visit(INSPECTOR aInspector, void *aTestData, const std::vector< KICAD_T > &aScanTypes) override
May be re-implemented for each derived class in order to handle all the types given by its member dat...
Definition: pcb_group.cpp:292
virtual bool RemoveItem(BOARD_ITEM *aItem)
Remove item from group.
Definition: pcb_group.cpp:96
std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=FLASHING::DEFAULT) const override
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
Definition: pcb_group.cpp:281
void GetMsgPanelInfo(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList) override
Populate aList of MSG_PANEL_ITEM objects with it's internal state for display purposes.
Definition: pcb_group.cpp:390
VECTOR2I GetPosition() const override
Definition: pcb_group.cpp:170
void Flip(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Flip this object, i.e.
Definition: pcb_group.cpp:361
virtual bool AddItem(BOARD_ITEM *aItem)
Add item to group.
Definition: pcb_group.cpp:81
void RunOnChildren(const std::function< void(BOARD_ITEM *)> &aFunction) const override
Invoke a function on all descendants.
Definition: pcb_group.cpp:400
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
Definition: pcb_group.cpp:249
wxString GetName() const
Definition: pcb_group.h:66
wxString m_name
Definition: pcb_group.h:222
EDA_ITEM * Clone() const override
Create a duplicate of this item with linked list members set to NULL.
Definition: pcb_group.cpp:196
PCB_GROUP(BOARD_ITEM *aParent)
Definition: pcb_group.cpp:38
BITMAPS GetMenuImage() const override
Return a pointer to an image to be used in menus.
Definition: pcb_group.cpp:384
void swapData(BOARD_ITEM *aImage) override
Definition: pcb_group.cpp:241
void SetLocked(bool aLocked) override
Definition: pcb_group.cpp:184
std::vector< int > ViewGetLayers() const override
Definition: pcb_group.cpp:332
Provide class metadata.Helper macro to map type hashes to names.
Definition: property_mgr.h:85
void InheritsAfter(TYPE_ID aDerived, TYPE_ID aBase)
Declare an inheritance relationship between types.
void Mask(TYPE_ID aDerived, TYPE_ID aBase, const wxString &aName)
Sets a base class property as masked in a derived class.
static PROPERTY_MANAGER & Instance()
Definition: property_mgr.h:87
PROPERTY_BASE & AddProperty(PROPERTY_BASE *aProperty, const wxString &aGroup=wxEmptyString)
Register a property.
void AddTypeCast(TYPE_CAST_BASE *aCast)
Register a type converter.
This file is part of the common library.
#define _HKI(x)
#define _(s)
#define PCB_EDIT_FRAME_NAME
INSPECT_RESULT
Definition: eda_item.h:43
std::set< EDA_ITEM *, CompareByUuid > EDA_ITEM_SET
Definition: eda_item.h:538
const INSPECTOR_FUNC & INSPECTOR
Definition: eda_item.h:82
FLASHING
Enum used during connectivity building to ensure we do not query connectivity while building the data...
Definition: layer_ids.h:147
@ LAYER_ANCHOR
anchor of items having an anchor point (texts, footprints)
Definition: layer_ids.h:202
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:60
FLIP_DIRECTION
Definition: mirror.h:27
Message panel definition file.
PCB_GROUP * getNestedGroup(BOARD_ITEM *aItem, PCB_GROUP *aScope, bool isFootprintEditor)
Returns the top level group inside the aScope group, or nullptr.
Definition: pcb_group.cpp:132
static struct PCB_GROUP_DESC _PCB_GROUP_DESC
PCB_GROUP * getClosestGroup(BOARD_ITEM *aItem, bool isFootprintEditor)
Definition: pcb_group.cpp:122
Class to handle a set of BOARD_ITEMs.
#define TYPE_HASH(x)
Definition: property.h:71
#define REGISTER_TYPE(x)
Definition: property_mgr.h:371
constexpr int mmToIU(double mm) const
Definition: base_units.h:88
constexpr int delta
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition: typeinfo.h:78
@ 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_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_DIMENSION_T
class PCB_DIMENSION_BASE: abstract dimension meta-type
Definition: typeinfo.h:100
@ PCB_TABLE_T
class PCB_TABLE, table of PCB_TABLECELLs
Definition: typeinfo.h:94
@ 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