KiCad PCB EDA Suite
board_commit.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) 2016 CERN
5  * @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
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 <board.h>
26 #include <footprint.h>
27 #include <pcb_edit_frame.h>
28 #include <pcb_group.h>
29 #include <tool/tool_manager.h>
31 #include <view/view.h>
32 #include <board_commit.h>
33 #include <tools/pcb_tool_base.h>
34 #include <tools/pcb_actions.h>
36 
37 #include <functional>
38 using namespace std::placeholders;
39 
40 
42  m_resolveNetConflicts( false )
43 {
44  m_toolMgr = aTool->GetManager();
46 }
47 
48 
50  m_resolveNetConflicts( false )
51 {
52  m_toolMgr = aFrame->GetToolManager();
54 }
55 
56 
58 {
59 }
60 
61 
63 {
64  // if aItem belongs a footprint, the full footprint will be saved
65  // because undo/redo does not handle "sub items" modifications
66  if( aItem && aItem->Type() != PCB_FOOTPRINT_T && aChangeType == CHT_MODIFY )
67  {
68  EDA_ITEM* item = aItem->GetParent();
69 
70  if( item && item->Type() == PCB_FOOTPRINT_T ) // means aItem belongs a footprint
71  aItem = item;
72  }
73 
74  return COMMIT::Stage( aItem, aChangeType );
75 }
76 
77 
78 COMMIT& BOARD_COMMIT::Stage( std::vector<EDA_ITEM*>& container, CHANGE_TYPE aChangeType )
79 {
80  return COMMIT::Stage( container, aChangeType );
81 }
82 
83 
85 {
86  return COMMIT::Stage( aItems, aModFlag );
87 }
88 
89 
90 void BOARD_COMMIT::Push( const wxString& aMessage, bool aCreateUndoEntry, bool aSetDirtyBit )
91 {
92  // Objects potentially interested in changes:
93  PICKED_ITEMS_LIST undoList;
94  KIGFX::VIEW* view = m_toolMgr->GetView();
95  BOARD* board = (BOARD*) m_toolMgr->GetModel();
97  auto connectivity = board->GetConnectivity();
98  std::set<EDA_ITEM*> savedModules;
100  bool itemsDeselected = false;
101 
102  std::vector<BOARD_ITEM*> bulkAddedItems;
103  std::vector<BOARD_ITEM*> bulkRemovedItems;
104  std::vector<BOARD_ITEM*> itemsChanged;
105 
106  if( Empty() )
107  return;
108 
109  for( COMMIT_LINE& ent : m_changes )
110  {
111  int changeType = ent.m_type & CHT_TYPE;
112  int changeFlags = ent.m_type & CHT_FLAGS;
113  BOARD_ITEM* boardItem = static_cast<BOARD_ITEM*>( ent.m_item );
114 
115  // Module items need to be saved in the undo buffer before modification
116  if( m_isFootprintEditor )
117  {
118  // Be sure that we are storing a footprint
119  if( ent.m_item->Type() != PCB_FOOTPRINT_T )
120  ent.m_item = ent.m_item->GetParent();
121 
122  // We have not saved the footprint yet, so let's create an entry
123  if( savedModules.count( ent.m_item ) == 0 )
124  {
125  if( !ent.m_copy )
126  {
127  wxASSERT( changeType != CHT_MODIFY ); // too late to make a copy..
128  ent.m_copy = ent.m_item->Clone();
129  }
130 
131  wxASSERT( ent.m_item->Type() == PCB_FOOTPRINT_T );
132  wxASSERT( ent.m_copy->Type() == PCB_FOOTPRINT_T );
133 
134  if( aCreateUndoEntry )
135  {
136  ITEM_PICKER itemWrapper( nullptr, ent.m_item, UNDO_REDO::CHANGED );
137  itemWrapper.SetLink( ent.m_copy );
138  undoList.PushItem( itemWrapper );
139  frame->SaveCopyInUndoList( undoList, UNDO_REDO::CHANGED );
140  }
141 
142  savedModules.insert( ent.m_item );
143  static_cast<FOOTPRINT*>( ent.m_item )->SetLastEditTime();
144  }
145  }
146 
147  switch( changeType )
148  {
149  case CHT_ADD:
150  {
151  if( m_isFootprintEditor )
152  {
153  // footprints inside footprints are not supported yet
154  wxASSERT( boardItem->Type() != PCB_FOOTPRINT_T );
155 
156  boardItem->SetParent( board->Footprints().front() );
157 
158  if( !( changeFlags & CHT_DONE ) )
159  board->Footprints().front()->Add( boardItem );
160  }
161  else if( boardItem->Type() == PCB_PAD_T ||
162  boardItem->Type() == PCB_FP_TEXT_T ||
163  boardItem->Type() == PCB_FP_SHAPE_T ||
164  boardItem->Type() == PCB_FP_ZONE_T )
165  {
166  wxASSERT( boardItem->GetParent() &&
167  boardItem->GetParent()->Type() == PCB_FOOTPRINT_T );
168  }
169  else
170  {
171  if( aCreateUndoEntry )
172  undoList.PushItem( ITEM_PICKER( nullptr, boardItem, UNDO_REDO::NEWITEM ) );
173 
174  if( !( changeFlags & CHT_DONE ) )
175  {
176  board->Add( boardItem, ADD_MODE::BULK_INSERT ); // handles connectivity
177  bulkAddedItems.push_back( boardItem );
178  }
179  }
180 
181  if( boardItem->Type() != PCB_NETINFO_T )
182  view->Add( boardItem );
183 
184  break;
185  }
186 
187  case CHT_REMOVE:
188  {
189  PCB_GROUP* parentGroup = boardItem->GetParentGroup();
190 
191  if( !m_isFootprintEditor && aCreateUndoEntry )
192  undoList.PushItem( ITEM_PICKER( nullptr, boardItem, UNDO_REDO::DELETED ) );
193 
194  if( boardItem->IsSelected() )
195  {
196  selTool->RemoveItemFromSel( boardItem, true /* quiet mode */ );
197  itemsDeselected = true;
198  }
199 
200  switch( boardItem->Type() )
201  {
202  // Footprint items
203  case PCB_PAD_T:
204  case PCB_FP_SHAPE_T:
205  case PCB_FP_TEXT_T:
206  case PCB_FP_ZONE_T:
207  // This level can only handle footprint children in the footprint editor as
208  // only in that case has the entire footprint (and all its children) already
209  // been saved for undo.
210  wxASSERT( m_isFootprintEditor );
211 
212  if( boardItem->Type() == PCB_FP_TEXT_T )
213  {
214  FP_TEXT* text = static_cast<FP_TEXT*>( boardItem );
215 
216  // don't allow deletion of Reference or Value
217  if( text->GetType() != FP_TEXT::TEXT_is_DIVERS )
218  break;
219  }
220 
221  if( parentGroup && !( parentGroup->GetFlags() & STRUCT_DELETED ) )
222  parentGroup->RemoveItem( boardItem );
223 
224  view->Remove( boardItem );
225 
226  if( !( changeFlags & CHT_DONE ) )
227  {
228  FOOTPRINT* footprint = static_cast<FOOTPRINT*>( boardItem->GetParent() );
229  wxASSERT( footprint && footprint->Type() == PCB_FOOTPRINT_T );
230  footprint->Delete( boardItem );
231  }
232 
233  break;
234 
235  // Board items
236  case PCB_SHAPE_T: // a shape (normally not on copper layers)
237  case PCB_TEXT_T: // a text on a layer
238  case PCB_TRACE_T: // a track segment (segment on a copper layer)
239  case PCB_ARC_T: // an arced track segment (segment on a copper layer)
240  case PCB_VIA_T: // a via (like track segment on a copper layer)
241  case PCB_DIM_ALIGNED_T: // a dimension (graphic item)
242  case PCB_DIM_CENTER_T:
244  case PCB_DIM_LEADER_T: // a leader dimension
245  case PCB_TARGET_T: // a target (graphic item)
246  case PCB_MARKER_T: // a marker used to show something
247  case PCB_ZONE_T:
248  view->Remove( boardItem );
249 
250  if( !( changeFlags & CHT_DONE ) )
251  {
252  board->Remove( boardItem, REMOVE_MODE::BULK );
253  bulkRemovedItems.push_back( boardItem );
254  }
255 
256  break;
257 
258  case PCB_FOOTPRINT_T:
259  {
260  // No support for nested footprints (yet)
261  wxASSERT( !m_isFootprintEditor );
262 
263  FOOTPRINT* footprint = static_cast<FOOTPRINT*>( boardItem );
264  view->Remove( footprint );
265  footprint->ClearFlags();
266 
267  if( !( changeFlags & CHT_DONE ) )
268  {
269  board->Remove( footprint, REMOVE_MODE::BULK ); // handles connectivity
270  bulkRemovedItems.push_back( footprint );
271  }
272  }
273  break;
274 
275  case PCB_GROUP_T:
276  view->Remove( boardItem );
277 
278  if( !( changeFlags & CHT_DONE ) )
279  {
280  if( m_isFootprintEditor )
281  board->GetFirstFootprint()->Remove( boardItem );
282  else
283  {
284  board->Remove( boardItem, REMOVE_MODE::BULK );
285  bulkRemovedItems.push_back( boardItem );
286  }
287  }
288  break;
289 
290  // Metadata items
291  case PCB_NETINFO_T:
292  board->Remove( boardItem, REMOVE_MODE::BULK );
293  bulkRemovedItems.push_back( boardItem );
294  break;
295 
296  default: // other types do not need to (or should not) be handled
297  wxASSERT( false );
298  break;
299  }
300 
301  break;
302  }
303 
304  case CHT_MODIFY:
305  {
306  if( !m_isFootprintEditor && aCreateUndoEntry )
307  {
308  ITEM_PICKER itemWrapper( nullptr, boardItem, UNDO_REDO::CHANGED );
309  wxASSERT( ent.m_copy );
310  itemWrapper.SetLink( ent.m_copy );
311  undoList.PushItem( itemWrapper );
312  }
313 
314  if( ent.m_copy )
315  connectivity->MarkItemNetAsDirty( static_cast<BOARD_ITEM*>( ent.m_copy ) );
316 
317  connectivity->Update( boardItem );
318  view->Update( boardItem );
319 
320  if( m_isFootprintEditor )
321  {
322  static_cast<FOOTPRINT*>( boardItem )->RunOnChildren(
323  [&]( BOARD_ITEM* aChild )
324  {
325  view->Update( aChild );
326  });
327  }
328 
329  itemsChanged.push_back( boardItem );
330 
331  // if no undo entry is needed, the copy would create a memory leak
332  if( !aCreateUndoEntry )
333  delete ent.m_copy;
334 
335  break;
336  }
337 
338  default:
339  wxASSERT( false );
340  break;
341  }
342  }
343 
344  if( bulkAddedItems.size() > 0 )
345  board->FinalizeBulkAdd( bulkAddedItems );
346 
347  if( bulkRemovedItems.size() > 0 )
348  board->FinalizeBulkRemove( bulkRemovedItems );
349 
350  if( itemsChanged.size() > 0 )
351  board->OnItemsChanged( itemsChanged );
352 
353  if( !m_isFootprintEditor )
354  {
355  size_t num_changes = m_changes.size();
356 
358  connectivity->PropagateNets( this, PROPAGATE_MODE::RESOLVE_CONFLICTS );
359 
360  connectivity->RecalculateRatsnest( this );
361  connectivity->ClearDynamicRatsnest();
362  frame->GetCanvas()->RedrawRatsnest();
363 
364  if( m_changes.size() > num_changes )
365  {
366  for( size_t i = num_changes; i < m_changes.size(); ++i )
367  {
368  COMMIT_LINE& ent = m_changes[i];
369 
370  // This should only be modifications from the connectivity algo
371  wxASSERT( ( ent.m_type & CHT_TYPE ) == CHT_MODIFY );
372 
373  auto boardItem = static_cast<BOARD_ITEM*>( ent.m_item );
374 
375  if( aCreateUndoEntry )
376  {
377  ITEM_PICKER itemWrapper( nullptr, boardItem, UNDO_REDO::CHANGED );
378  wxASSERT( ent.m_copy );
379  itemWrapper.SetLink( ent.m_copy );
380  undoList.PushItem( itemWrapper );
381  }
382  else
383  {
384  delete ent.m_copy;
385  }
386 
387  view->Update( boardItem );
388  }
389  }
390  }
391 
392  if( !m_isFootprintEditor && aCreateUndoEntry )
393  frame->SaveCopyInUndoList( undoList, UNDO_REDO::UNSPECIFIED );
394 
396 
397  if( itemsDeselected )
399 
400  if( aSetDirtyBit )
401  frame->OnModify();
402  else
403  frame->Update3DView( true, frame->GetDisplayOptions().m_Live3DRefresh );
404 
405  clear();
406 }
407 
408 
410 {
411  switch( aItem->Type() )
412  {
413  case PCB_PAD_T:
414  case PCB_FP_SHAPE_T:
415  case PCB_FP_TEXT_T:
416  case PCB_FP_ZONE_T:
417  return aItem->GetParent();
418 
419  case PCB_ZONE_T:
420  wxASSERT( !dynamic_cast<FOOTPRINT*>( aItem->GetParent() ) );
421  return aItem;
422 
423  default:
424  break;
425  }
426 
427  return aItem;
428 }
429 
430 
432 {
433  PICKED_ITEMS_LIST undoList;
434  KIGFX::VIEW* view = m_toolMgr->GetView();
435  BOARD* board = (BOARD*) m_toolMgr->GetModel();
436  auto connectivity = board->GetConnectivity();
437 
438  std::vector<BOARD_ITEM*> bulkAddedItems;
439  std::vector<BOARD_ITEM*> bulkRemovedItems;
440  std::vector<BOARD_ITEM*> itemsChanged;
441 
442  for( auto it = m_changes.rbegin(); it != m_changes.rend(); ++it )
443  {
444  COMMIT_LINE& ent = *it;
445  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( ent.m_item );
446  BOARD_ITEM* copy = static_cast<BOARD_ITEM*>( ent.m_copy );
447  int changeType = ent.m_type & CHT_TYPE;
448  int changeFlags = ent.m_type & CHT_FLAGS;
449 
450  switch( changeType )
451  {
452  case CHT_ADD:
453  if( !( changeFlags & CHT_DONE ) )
454  break;
455 
456  view->Remove( item );
457  connectivity->Remove( item );
458  board->Remove( item, REMOVE_MODE::BULK );
459  bulkRemovedItems.push_back( item );
460  break;
461 
462  case CHT_REMOVE:
463  if( !( changeFlags & CHT_DONE ) )
464  break;
465 
466  view->Add( item );
467  connectivity->Add( item );
468  board->Add( item, ADD_MODE::INSERT );
469  bulkAddedItems.push_back( item );
470  break;
471 
472  case CHT_MODIFY:
473  {
474  view->Remove( item );
475  connectivity->Remove( item );
476 
477  item->SwapData( copy );
478 
479  view->Add( item );
480  connectivity->Add( item );
481  board->OnItemChanged( item );
482  itemsChanged.push_back( item );
483 
484  delete copy;
485  break;
486  }
487 
488  default:
489  wxASSERT( false );
490  break;
491  }
492  }
493 
494  if( bulkAddedItems.size() > 0 )
495  board->FinalizeBulkAdd( bulkAddedItems );
496 
497  if( bulkRemovedItems.size() > 0 )
498  board->FinalizeBulkRemove( bulkRemovedItems );
499 
500  if( itemsChanged.size() > 0 )
501  board->OnItemsChanged( itemsChanged );
502 
503  if ( !m_isFootprintEditor )
504  connectivity->RecalculateRatsnest();
505 
507  selTool->RebuildSelection();
508 
509  clear();
510 }
511 
PCB_GROUP * GetParentGroup() const
Definition: board_item.h:91
KIGFX::VIEW * GetView() const
Definition: tool_manager.h:283
virtual COMMIT & Stage(EDA_ITEM *aItem, CHANGE_TYPE aChangeType)
Definition: commit.cpp:49
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
Definition: typeinfo.h:100
class PCB_DIM_LEADER, a leader dimension (graphic item)
Definition: typeinfo.h:101
void clear()
Definition: commit.h:157
class FP_TEXT, text in a footprint
Definition: typeinfo.h:92
bool IsSelected() const
Definition: eda_item.h:123
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:200
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:80
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:108
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:50
class PCB_DIM_CENTER, a center point marking (graphic item)
Definition: typeinfo.h:102
Flag to indicate the change is already applied, just notify observers (not compatible with CHT_MODIFY...
Definition: commit.h:43
virtual void Revert() override
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
CHANGE_TYPE m_type
Modification type.
Definition: commit.h:153
Definition: commit.h:40
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:351
void Remove(BOARD_ITEM *aItem, REMOVE_MODE aMode=REMOVE_MODE::NORMAL) override
Removes an item from the container.
Definition: footprint.cpp:525
bool m_isFootprintEditor
Definition: board_commit.h:69
class PCB_TEXT, text on a layer
Definition: typeinfo.h:91
class PCB_ARC, an arc track segment on a copper layer
Definition: typeinfo.h:97
Represent a set of changes (additions, deletions or modifications) of a data model (e....
Definition: commit.h:71
void PushItem(const ITEM_PICKER &aItem)
Push aItem to the top of the list.
class FP_SHAPE, a footprint edge
Definition: typeinfo.h:93
class PAD, a pad in a footprint
Definition: typeinfo.h:89
EDA_ITEM * m_item
Main item that is added/deleted/modified.
Definition: commit.h:151
TOOL_MANAGER * m_toolMgr
Definition: board_commit.h:68
BOARD_COMMIT(EDA_DRAW_FRAME *aFrame)
The base class for create windows for drawing purpose.
virtual ~BOARD_COMMIT()
const PCB_DISPLAY_OPTIONS & GetDisplayOptions() const
Display options control the way tracks, vias, outlines and other things are shown (for instance solid...
void SetLink(EDA_ITEM *aItem)
UNDO_REDO
Undo Redo considerations: Basically we have 3 cases New item Deleted item Modified item there is also...
EDA_ITEM * GetModel() const
Definition: tool_manager.h:290
Clusters with conflicting drivers are not updated (default)
virtual EDA_ITEM * parentObject(EDA_ITEM *aItem) const override
void RedrawRatsnest()
Return the bounding box of the view that should be used if model is not valid.
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:116
class PCB_TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
void FinalizeBulkRemove(std::vector< BOARD_ITEM * > &aRemovedItems)
Must be used if Remove() is used using a BULK_x REMOVE_MODE to generate a change event for listeners.
Definition: board.cpp:702
TOOL_MANAGER * GetManager() const
Return the instance of TOOL_MANAGER that takes care of the tool.
Definition: tool_base.h:143
void RebuildSelection()
Rebuild the selection from the EDA_ITEMs' selection flags.
virtual void SwapData(BOARD_ITEM *aImage)
Swap data between aItem and aImage.
Definition: board_item.cpp:138
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT) override
Adds an item to the container.
Definition: board.cpp:606
bool m_resolveNetConflicts
Definition: board_commit.h:70
FOOTPRINT * GetFirstFootprint() const
Get the first footprint on the board or nullptr.
Definition: board.h:317
TOOL_TYPE m_type
Unique identifier for the tool, assigned by a TOOL_MANAGER instance.
Definition: tool_base.h:206
FOOTPRINTS & Footprints()
Definition: board.h:233
std::shared_ptr< CONNECTIVITY_DATA > GetConnectivity() const
Return a list of missing connections between components/tracks.
Definition: board.h:344
void OnItemsChanged(std::vector< BOARD_ITEM * > &aItems)
Notify the board and its listeners that an item on the board has been modified in some way.
Definition: board.cpp:2014
EDA_ITEM * GetParent() const
Definition: eda_item.h:115
#define STRUCT_DELETED
flag indication structures to be erased
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition: eda_item.h:154
bool RemoveItem(BOARD_ITEM *aItem)
Remove item from group.
Definition: pcb_group.cpp:50
class ZONE, a copper pour area
Definition: typeinfo.h:105
A holder to handle information on schematic or board items.
bool Empty() const
Returns status of an item.
Definition: commit.h:140
class PCB_TARGET, a target (graphic item)
Definition: typeinfo.h:104
EDA_ITEM_FLAGS GetFlags() const
Definition: eda_item.h:155
class FOOTPRINT, a footprint
Definition: typeinfo.h:88
void FinalizeBulkAdd(std::vector< BOARD_ITEM * > &aNewItems)
Must be used if Add() is used using a BULK_x ADD_MODE to generate a change event for listeners.
Definition: board.cpp:696
TOOLS_HOLDER * GetToolHolder() const
Definition: tool_manager.h:294
CHANGE_TYPE
Types of changes.
Definition: commit.h:39
virtual void OnModify()
Must be called after a change in order to set the "modify" flag of the current screen and update the ...
class PCB_MARKER, a marker used to show something
Definition: typeinfo.h:98
bool IsType(FRAME_T aType) const
Global action (toolbar/main menu event, global shortcut)
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:190
bool m_Live3DRefresh
If true, 3D viewer will redraw on every modification operation.
virtual void Update3DView(bool aMarkDirty, bool aRefresh, const wxString *aTitle=nullptr)
Update the 3D view, if the viewer is opened by this frame.
class NETINFO_ITEM, a description of a net
Definition: typeinfo.h:107
std::vector< COMMIT_LINE > m_changes
Definition: commit.h:179
class ZONE, managed by a footprint
Definition: typeinfo.h:94
The selection tool: currently supports:
void OnItemChanged(BOARD_ITEM *aItem)
Notify the board and its listeners that an item on the board has been modified in some way.
Definition: board.cpp:2008
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:100
void Remove(BOARD_ITEM *aBoardItem, REMOVE_MODE aMode=REMOVE_MODE::NORMAL) override
Removes an item from the container.
Definition: board.cpp:708
bool IsFootprintEditor() const
virtual void Push(const wxString &aMessage=wxT("A commit"), bool aCreateUndoEntry=true, bool aSetDirtyBit=true) override
Revert the commit by restoring the modified items state.
virtual void SaveCopyInUndoList(EDA_ITEM *aItemToCopy, UNDO_REDO aTypeCommand)=0
Create a new entry in undo list of commands.
virtual void Delete(BOARD_ITEM *aItem)
Removes an item from the container and deletes it.
class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
Definition: typeinfo.h:103
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Add a VIEW_ITEM to the view.
Definition: view.cpp:321
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
Definition: tools_holder.h:54
EDA_ITEM * m_copy
Optional copy of the item.
Definition: commit.h:152
void RemoveItemFromSel(BOARD_ITEM *aItem, bool aQuietMode=false)
Multiple item unselection event handler.
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:67
BOARD_ITEM_CONTAINER * GetParent() const
Definition: board_item.h:166
void PostEvent(const TOOL_EVENT &aEvent)
Put an event to the event queue to be processed at the end of event processing cycle.
class PCB_SHAPE, a segment not on copper layers
Definition: typeinfo.h:90
Base PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer.
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition: view.cpp:1503
COMMIT & Stage(EDA_ITEM *aItem, CHANGE_TYPE aChangeType) override
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113