KiCad PCB EDA Suite
Loading...
Searching...
No Matches
view_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) 2013 CERN
5 * Copyright (C) 2021 KiCad Developers, see AUTHORS.txt for contributors.
6 * @author Maciej Suminski <[email protected]>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, you may find one here:
20 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
21 * or you may search the http://www.gnu.org website for the version 2 license,
22 * or you may write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
24 *
25 */
26
34#include <set>
35#include <core/kicad_algo.h>
36#include <view/view_group.h>
37#include <view/view.h>
38#include <view/view_item.h>
39#include <gal/painter.h>
41#include <layer_ids.h>
42
43using namespace KIGFX;
44
46 VIEW_ITEM(),
47 m_layer( LAYER_SELECT_OVERLAY )
48{
49}
50
51
53{
54 // VIEW_ITEM destructor removes the object from its parent view
55}
56
57
59{
60 m_groupItems.push_back( aItem );
61}
62
63
65{
67}
68
69
71{
72 m_groupItems.clear();
73}
74
75
76unsigned int VIEW_GROUP::GetSize() const
77{
78 return m_groupItems.size();
79}
80
81
82VIEW_ITEM *VIEW_GROUP::GetItem( unsigned int idx ) const
83{
84 return m_groupItems[idx];
85}
86
87
89{
90 BOX2I bb;
91
92 if( !m_groupItems.size() )
93 {
94 bb.SetMaximum();
95 }
96 else
97 {
98 bb = m_groupItems[0]->ViewBBox();
99
100 for( VIEW_ITEM* item : m_groupItems )
101 bb.Merge( item->ViewBBox() );
102 }
103
104 return bb;
105}
106
107
108void VIEW_GROUP::ViewDraw( int aLayer, VIEW* aView ) const
109{
110 KIGFX::GAL* gal = aView->GetGAL();
111 PAINTER* painter = aView->GetPainter();
112 bool isSelection = m_layer == LAYER_SELECT_OVERLAY;
113
114 const std::vector<VIEW_ITEM*> drawList = updateDrawList();
115 constexpr double HIDE = std::numeric_limits<double>::max();
116
117 std::map<int, std::vector<VIEW_ITEM*>> layer_item_map;
118
119 // Build a list of layers used by the items in the group
120 for( VIEW_ITEM* item : drawList )
121 {
122 if( aView->IsHiddenOnOverlay( item ) )
123 continue;
124
125 int item_layers[VIEW::VIEW_MAX_LAYERS], item_layers_count;
126 item->ViewGetLayers( item_layers, item_layers_count );
127
128 for( int i = 0; i < item_layers_count; i++ )
129 {
130 wxCHECK2_MSG( item_layers[i] <= LAYER_ID_COUNT, continue, wxT( "Invalid item layer" ) );
131 layer_item_map[ item_layers[i] ].push_back( item );
132 }
133 }
134
135 int layers[VIEW::VIEW_MAX_LAYERS] = { 0 };
136 int layers_count = 0;
137
138 for( const std::pair<const int, std::vector<VIEW_ITEM*>>& entry : layer_item_map )
139 layers[ layers_count++ ] = entry.first;
140
141 if( layers_count == 0 )
142 return;
143
144 aView->SortLayers( layers, layers_count );
145
146 // Now draw the layers in sorted order
147
148 gal->PushDepth();
149
150 for( int i = 0; i < layers_count; i++ )
151 {
152 int layer = layers[i];
153
154 if( IsZoneFillLayer( layer ) )
155 layer = layer - LAYER_ZONE_START;
156
157 bool draw = aView->IsLayerVisible( layer );
158
159 if( isSelection )
160 {
161 switch( layer )
162 {
163 case LAYER_PADS_TH:
168 draw = true;
169 break;
170 default:
171 break;
172 }
173 }
174
175 if( draw )
176 {
177 gal->AdvanceDepth();
178
179 for( VIEW_ITEM* item : layer_item_map[ layers[i] ] )
180 {
181 // Ignore LOD scale for selected items, but don't ignore things explicitly
182 // hidden.
183 if( item->ViewGetLOD( layer, aView ) == HIDE )
184 continue;
185
186 if( !painter->Draw( item, layers[i] ) )
187 item->ViewDraw( layers[i], aView ); // Alternative drawing method
188 }
189 }
190 }
191
192 gal->PopDepth();
193}
194
195
196void VIEW_GROUP::ViewGetLayers( int aLayers[], int& aCount ) const
197{
198 // Everything is displayed on a single layer
199 aLayers[0] = m_layer;
200 aCount = 1;
201}
202
203
205{
206 for( unsigned int i = 0 ; i < GetSize(); i++ )
207 delete GetItem( i );
208
209 Clear();
210}
211
212
213const std::vector<VIEW_ITEM*> VIEW_GROUP::updateDrawList() const
214{
215 return m_groupItems;
216}
217
218
219/*void VIEW_GROUP::ItemsSetVisibility( bool aVisible )
220{
221 for(unsigned int i = 0 ; i < GetSize(); i++)
222 GetItem(i)->ViewSetVisible( aVisible );
223}
224
225
226void VIEW_GROUP::ItemsViewUpdate( VIEW_ITEM::VIEW_UPDATE_FLAGS aFlags )
227{
228 for(unsigned int i = 0 ; i < GetSize(); i++)
229 GetItem(i)->ViewUpdate( aFlags );
230}*/
void SetMaximum()
Definition: box2.h:70
BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition: box2.h:623
Abstract interface for drawing on a 2D-surface.
void AdvanceDepth()
Change the current depth to deeper, so it is possible to draw objects right beneath other.
void PushDepth()
Store current drawing depth on the depth stack.
void PopDepth()
Restore previously stored drawing depth for the depth stack.
Contains all the knowledge about how to draw graphical object onto any particular output device.
Definition: painter.h:59
virtual bool Draw(const VIEW_ITEM *aItem, int aLayer)=0
Takes an instance of VIEW_ITEM and passes it to a function that knows how to draw the item.
virtual void Clear()
Remove all the stored items from the group.
Definition: view_group.cpp:70
virtual unsigned int GetSize() const
Return the number of stored items.
Definition: view_group.cpp:76
virtual void ViewDraw(int aLayer, VIEW *aView) const override
Draw all the stored items in the group on the given layer.
Definition: view_group.cpp:108
virtual VIEW_ITEM * GetItem(unsigned int aIdx) const
Definition: view_group.cpp:82
void FreeItems()
Free all the items that were added to the group.
Definition: view_group.cpp:204
virtual void ViewGetLayers(int aLayers[], int &aCount) const override
Return all the layers used by the stored items.
Definition: view_group.cpp:196
std::vector< VIEW_ITEM * > m_groupItems
Definition: view_group.h:114
virtual void Remove(VIEW_ITEM *aItem)
Remove an item from the group.
Definition: view_group.cpp:64
VIEW_GROUP(VIEW *aView=nullptr)
Definition: view_group.cpp:45
virtual ~VIEW_GROUP()
Definition: view_group.cpp:52
virtual void Add(VIEW_ITEM *aItem)
Add an item to the group.
Definition: view_group.cpp:58
virtual const std::vector< VIEW_ITEM * > updateDrawList() const
Definition: view_group.cpp:213
virtual const BOX2I ViewBBox() const override
Return the bounding box for all stored items covering all its layers.
Definition: view_group.cpp:88
An abstract base class for deriving all objects that can be added to a VIEW.
Definition: view_item.h:84
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:68
void SortLayers(int aLayers[], int &aCount) const
Change the order of given layer ids, so after sorting the order corresponds to layers rendering order...
Definition: view.cpp:652
GAL * GetGAL() const
Return the #GAL this view is using to draw graphical primitives.
Definition: view.h:197
bool IsHiddenOnOverlay(const VIEW_ITEM *aItem) const
Definition: view.cpp:1609
static constexpr int VIEW_MAX_LAYERS
Rendering order modifier for layers that are marked as top layers.
Definition: view.h:729
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition: view.h:412
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:215
#define LAYER_ID_COUNT
Must update this if you add any enums after GerbView!
Definition: layer_ids.h:478
@ LAYER_PAD_PLATEDHOLES
to draw pad holes (plated)
Definition: layer_ids.h:218
@ LAYER_ZONE_START
Virtual layers for stacking zones and tracks on a given copper layer.
Definition: layer_ids.h:257
@ LAYER_PADS_SMD_BK
smd pads, back layer
Definition: layer_ids.h:207
@ LAYER_PADS_TH
multilayer pads, usually with holes
Definition: layer_ids.h:217
@ LAYER_PADS_SMD_FR
smd pads, front layer
Definition: layer_ids.h:206
@ LAYER_SELECT_OVERLAY
currently selected items overlay
Definition: layer_ids.h:223
@ LAYER_PAD_HOLEWALLS
Definition: layer_ids.h:237
bool IsZoneFillLayer(int aLayer)
Definition: layer_ids.h:1050
The Cairo implementation of the graphics abstraction layer.
Definition: color4d.cpp:247
void delete_matching(_Container &__c, _Value __value)
Covers for the horrifically named std::remove and std::remove_if (neither of which remove anything).
Definition: kicad_algo.h:165