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 <[email protected]>
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_group.h>
28 #include <tool/tool_manager.h>
30 #include <view/view.h>
31 #include <board_commit.h>
32 #include <tools/pcb_tool_base.h>
33 #include <tools/pcb_actions.h>
35 
36 #include <functional>
37 using namespace std::placeholders;
38 
39 
41  m_toolMgr( aToolMgr ),
42  m_isFootprintEditor( false ),
43  m_resolveNetConflicts( false )
44 {
45 }
46 
47 
49  m_resolveNetConflicts( false )
50 {
51  m_toolMgr = aTool->GetManager();
53 }
54 
55 
57  m_resolveNetConflicts( false )
58 {
59  m_toolMgr = aFrame->GetToolManager();
61 }
62 
63 
65 {
66 }
67 
68 
70 {
71  // if aItem belongs a footprint, the full footprint will be saved
72  // because undo/redo does not handle "sub items" modifications
73  if( aItem && aItem->Type() != PCB_FOOTPRINT_T && aChangeType == CHT_MODIFY )
74  {
75  EDA_ITEM* item = aItem->GetParent();
76 
77  if( item && item->Type() == PCB_FOOTPRINT_T ) // means aItem belongs a footprint
78  aItem = item;
79  }
80 
81  return COMMIT::Stage( aItem, aChangeType );
82 }
83 
84 
85 COMMIT& BOARD_COMMIT::Stage( std::vector<EDA_ITEM*>& container, CHANGE_TYPE aChangeType )
86 {
87  return COMMIT::Stage( container, aChangeType );
88 }
89 
90 
92 {
93  return COMMIT::Stage( aItems, aModFlag );
94 }
95 
96 
97 void BOARD_COMMIT::Push( const wxString& aMessage, bool aCreateUndoEntry, bool aSetDirtyBit )
98 {
99  // Objects potentially interested in changes:
100  PICKED_ITEMS_LIST undoList;
101  KIGFX::VIEW* view = m_toolMgr->GetView();
102  BOARD* board = (BOARD*) m_toolMgr->GetModel();
103  PCB_BASE_FRAME* frame = dynamic_cast<PCB_BASE_FRAME*>( m_toolMgr->GetToolHolder() );
104  auto connectivity = board->GetConnectivity();
105  std::set<EDA_ITEM*> savedModules;
107  bool itemsDeselected = false;
108 
109  std::vector<BOARD_ITEM*> bulkAddedItems;
110  std::vector<BOARD_ITEM*> bulkRemovedItems;
111  std::vector<BOARD_ITEM*> itemsChanged;
112 
113  if( Empty() )
114  return;
115 
116  for( COMMIT_LINE& ent : m_changes )
117  {
118  int changeType = ent.m_type & CHT_TYPE;
119  int changeFlags = ent.m_type & CHT_FLAGS;
120  BOARD_ITEM* boardItem = static_cast<BOARD_ITEM*>( ent.m_item );
121 
122  wxASSERT( ent.m_item );
123 
124  // Module items need to be saved in the undo buffer before modification
125  if( m_isFootprintEditor )
126  {
127  // Be sure that we are storing a footprint
128  if( ent.m_item->Type() != PCB_FOOTPRINT_T )
129  {
130  ent.m_item = ent.m_item->GetParent();
131  wxASSERT( ent.m_item );
132  }
133 
134  // We have not saved the footprint yet, so let's create an entry
135  if( savedModules.count( ent.m_item ) == 0 )
136  {
137  if( !ent.m_copy )
138  {
139  wxASSERT( changeType != CHT_MODIFY ); // too late to make a copy..
140  ent.m_copy = ent.m_item->Clone();
141  }
142 
143  wxASSERT( ent.m_item->Type() == PCB_FOOTPRINT_T );
144  wxASSERT( ent.m_copy->Type() == PCB_FOOTPRINT_T );
145 
146  if( aCreateUndoEntry && frame )
147  {
148  ITEM_PICKER itemWrapper( nullptr, ent.m_item, UNDO_REDO::CHANGED );
149  itemWrapper.SetLink( ent.m_copy );
150  undoList.PushItem( itemWrapper );
151  frame->SaveCopyInUndoList( undoList, UNDO_REDO::CHANGED );
152  }
153 
154  savedModules.insert( ent.m_item );
155  static_cast<FOOTPRINT*>( ent.m_item )->SetLastEditTime();
156  }
157  }
158 
159  switch( changeType )
160  {
161  case CHT_ADD:
162  {
163  if( m_isFootprintEditor )
164  {
165  // footprints inside footprints are not supported yet
166  wxASSERT( boardItem->Type() != PCB_FOOTPRINT_T );
167 
168  boardItem->SetParent( board->Footprints().front() );
169 
170  if( !( changeFlags & CHT_DONE ) )
171  board->Footprints().front()->Add( boardItem );
172  }
173  else if( boardItem->Type() == PCB_PAD_T ||
174  boardItem->Type() == PCB_FP_TEXT_T ||
175  boardItem->Type() == PCB_FP_SHAPE_T ||
176  boardItem->Type() == PCB_FP_ZONE_T )
177  {
178  wxASSERT( boardItem->GetParent() &&
179  boardItem->GetParent()->Type() == PCB_FOOTPRINT_T );
180  }
181  else
182  {
183  if( aCreateUndoEntry )
184  undoList.PushItem( ITEM_PICKER( nullptr, boardItem, UNDO_REDO::NEWITEM ) );
185 
186  if( !( changeFlags & CHT_DONE ) )
187  {
188  board->Add( boardItem, ADD_MODE::BULK_INSERT ); // handles connectivity
189  bulkAddedItems.push_back( boardItem );
190  }
191  }
192 
193  if( view && boardItem->Type() != PCB_NETINFO_T )
194  view->Add( boardItem );
195 
196  break;
197  }
198 
199  case CHT_REMOVE:
200  {
201  PCB_GROUP* parentGroup = boardItem->GetParentGroup();
202 
203  if( !m_isFootprintEditor && aCreateUndoEntry )
204  undoList.PushItem( ITEM_PICKER( nullptr, boardItem, UNDO_REDO::DELETED ) );
205 
206  if( boardItem->IsSelected() )
207  {
208  selTool->RemoveItemFromSel( boardItem, true /* quiet mode */ );
209  itemsDeselected = true;
210  }
211 
212  switch( boardItem->Type() )
213  {
214  // Footprint items
215  case PCB_PAD_T:
216  case PCB_FP_SHAPE_T:
217  case PCB_FP_TEXT_T:
218  case PCB_FP_ZONE_T:
219  // This level can only handle footprint children in the footprint editor as
220  // only in that case has the entire footprint (and all its children) already
221  // been saved for undo.
222  wxASSERT( m_isFootprintEditor );
223 
224  if( boardItem->Type() == PCB_FP_TEXT_T )
225  {
226  FP_TEXT* text = static_cast<FP_TEXT*>( boardItem );
227 
228  // don't allow deletion of Reference or Value
229  if( text->GetType() != FP_TEXT::TEXT_is_DIVERS )
230  break;
231  }
232 
233  if( parentGroup && !( parentGroup->GetFlags() & STRUCT_DELETED ) )
234  parentGroup->RemoveItem( boardItem );
235 
236  if( view )
237  view->Remove( boardItem );
238 
239  if( !( changeFlags & CHT_DONE ) )
240  {
241  FOOTPRINT* footprint = static_cast<FOOTPRINT*>( boardItem->GetParent() );
242  wxASSERT( footprint && footprint->Type() == PCB_FOOTPRINT_T );
243  footprint->Delete( boardItem );
244  }
245 
246  break;
247 
248  // Board items
249  case PCB_SHAPE_T: // a shape (normally not on copper layers)
250  case PCB_TEXT_T: // a text on a layer
251  case PCB_TRACE_T: // a track segment (segment on a copper layer)
252  case PCB_ARC_T: // an arced track segment (segment on a copper layer)
253  case PCB_VIA_T: // a via (like track segment on a copper layer)
254  case PCB_DIM_ALIGNED_T: // a dimension (graphic item)
255  case PCB_DIM_CENTER_T:
257  case PCB_DIM_LEADER_T: // a leader dimension
258  case PCB_TARGET_T: // a target (graphic item)
259  case PCB_MARKER_T: // a marker used to show something
260  case PCB_ZONE_T:
261  if( view )
262  view->Remove( boardItem );
263 
264  if( !( changeFlags & CHT_DONE ) )
265  {
266  board->Remove( boardItem, REMOVE_MODE::BULK );
267  bulkRemovedItems.push_back( boardItem );
268  }
269 
270  break;
271 
272  case PCB_FOOTPRINT_T:
273  {
274  // No support for nested footprints (yet)
275  wxASSERT( !m_isFootprintEditor );
276 
277  FOOTPRINT* footprint = static_cast<FOOTPRINT*>( boardItem );
278 
279  if( view )
280  view->Remove( footprint );
281 
282  footprint->ClearFlags();
283 
284  if( !( changeFlags & CHT_DONE ) )
285  {
286  board->Remove( footprint, REMOVE_MODE::BULK ); // handles connectivity
287  bulkRemovedItems.push_back( footprint );
288  }
289  }
290  break;
291 
292  case PCB_GROUP_T:
293  if( view )
294  view->Remove( boardItem );
295 
296  if( !( changeFlags & CHT_DONE ) )
297  {
298  if( m_isFootprintEditor )
299  board->GetFirstFootprint()->Remove( boardItem );
300  else
301  {
302  board->Remove( boardItem, REMOVE_MODE::BULK );
303  bulkRemovedItems.push_back( boardItem );
304  }
305  }
306  break;
307 
308  // Metadata items
309  case PCB_NETINFO_T:
310  board->Remove( boardItem, REMOVE_MODE::BULK );
311  bulkRemovedItems.push_back( boardItem );
312  break;
313 
314  default: // other types do not need to (or should not) be handled
315  wxASSERT( false );
316  break;
317  }
318 
319  break;
320  }
321 
322  case CHT_MODIFY:
323  {
324  if( !m_isFootprintEditor && aCreateUndoEntry )
325  {
326  ITEM_PICKER itemWrapper( nullptr, boardItem, UNDO_REDO::CHANGED );
327  wxASSERT( ent.m_copy );
328  itemWrapper.SetLink( ent.m_copy );
329  undoList.PushItem( itemWrapper );
330  }
331 
332  if( ent.m_copy )
333  connectivity->MarkItemNetAsDirty( static_cast<BOARD_ITEM*>( ent.m_copy ) );
334 
335  connectivity->Update( boardItem );
336 
337  if( view )
338  {
339  view->Update( boardItem );
340 
341  if( m_isFootprintEditor )
342  {
343  static_cast<FOOTPRINT*>( boardItem )->RunOnChildren(
344  [&]( BOARD_ITEM* aChild )
345  {
346  view->Update( aChild );
347  });
348  }
349  }
350 
351  itemsChanged.push_back( boardItem );
352 
353  // if no undo entry is needed, the copy would create a memory leak
354  if( !aCreateUndoEntry )
355  delete ent.m_copy;
356 
357  break;
358  }
359 
360  default:
361  wxASSERT( false );
362  break;
363  }
364  }
365 
366  if( bulkAddedItems.size() > 0 )
367  board->FinalizeBulkAdd( bulkAddedItems );
368 
369  if( bulkRemovedItems.size() > 0 )
370  board->FinalizeBulkRemove( bulkRemovedItems );
371 
372  if( itemsChanged.size() > 0 )
373  board->OnItemsChanged( itemsChanged );
374 
375  if( !m_isFootprintEditor )
376  {
377  size_t num_changes = m_changes.size();
378 
380  connectivity->PropagateNets( this, PROPAGATE_MODE::RESOLVE_CONFLICTS );
381 
382  connectivity->RecalculateRatsnest( this );
383  connectivity->ClearDynamicRatsnest();
384 
385  if( frame )
386  frame->GetCanvas()->RedrawRatsnest();
387 
388  if( m_changes.size() > num_changes )
389  {
390  for( size_t i = num_changes; i < m_changes.size(); ++i )
391  {
392  COMMIT_LINE& ent = m_changes[i];
393 
394  // This should only be modifications from the connectivity algo
395  wxASSERT( ( ent.m_type & CHT_TYPE ) == CHT_MODIFY );
396 
397  BOARD_ITEM* boardItem = static_cast<BOARD_ITEM*>( ent.m_item );
398 
399  if( aCreateUndoEntry )
400  {
401  ITEM_PICKER itemWrapper( nullptr, boardItem, UNDO_REDO::CHANGED );
402  wxASSERT( ent.m_copy );
403  itemWrapper.SetLink( ent.m_copy );
404  undoList.PushItem( itemWrapper );
405  }
406  else
407  {
408  delete ent.m_copy;
409  }
410 
411  if( view )
412  view->Update( boardItem );
413  }
414  }
415  }
416 
417  if( !m_isFootprintEditor && aCreateUndoEntry && frame )
418  frame->SaveCopyInUndoList( undoList, UNDO_REDO::UNSPECIFIED );
419 
421 
422  if( itemsDeselected )
424 
425  if( frame )
426  {
427  if( aSetDirtyBit )
428  frame->OnModify();
429  else
430  frame->Update3DView( true, frame->GetDisplayOptions().m_Live3DRefresh );
431  }
432 
433  clear();
434 }
435 
436 
438 {
439  switch( aItem->Type() )
440  {
441  case PCB_PAD_T:
442  case PCB_FP_SHAPE_T:
443  case PCB_FP_TEXT_T:
444  case PCB_FP_ZONE_T:
445  return aItem->GetParent();
446 
447  case PCB_ZONE_T:
448  wxASSERT( !dynamic_cast<FOOTPRINT*>( aItem->GetParent() ) );
449  return aItem;
450 
451  default:
452  break;
453  }
454 
455  return aItem;
456 }
457 
458 
460 {
461  PICKED_ITEMS_LIST undoList;
462  KIGFX::VIEW* view = m_toolMgr->GetView();
463  BOARD* board = (BOARD*) m_toolMgr->GetModel();
464  auto connectivity = board->GetConnectivity();
465 
466  std::vector<BOARD_ITEM*> bulkAddedItems;
467  std::vector<BOARD_ITEM*> bulkRemovedItems;
468  std::vector<BOARD_ITEM*> itemsChanged;
469 
470  for( auto it = m_changes.rbegin(); it != m_changes.rend(); ++it )
471  {
472  COMMIT_LINE& ent = *it;
473  BOARD_ITEM* item = static_cast<BOARD_ITEM*>( ent.m_item );
474  BOARD_ITEM* copy = static_cast<BOARD_ITEM*>( ent.m_copy );
475  int changeType = ent.m_type & CHT_TYPE;
476  int changeFlags = ent.m_type & CHT_FLAGS;
477 
478  switch( changeType )
479  {
480  case CHT_ADD:
481  if( !( changeFlags & CHT_DONE ) )
482  break;
483 
484  view->Remove( item );
485  connectivity->Remove( item );
486  board->Remove( item, REMOVE_MODE::BULK );
487  bulkRemovedItems.push_back( item );
488  break;
489 
490  case CHT_REMOVE:
491  if( !( changeFlags & CHT_DONE ) )
492  break;
493 
494  view->Add( item );
495  connectivity->Add( item );
496  board->Add( item, ADD_MODE::INSERT );
497  bulkAddedItems.push_back( item );
498  break;
499 
500  case CHT_MODIFY:
501  {
502  view->Remove( item );
503  connectivity->Remove( item );
504 
505  item->SwapData( copy );
506 
507  view->Add( item );
508  connectivity->Add( item );
509  board->OnItemChanged( item );
510  itemsChanged.push_back( item );
511 
512  delete copy;
513  break;
514  }
515 
516  default:
517  wxASSERT( false );
518  break;
519  }
520  }
521 
522  if( bulkAddedItems.size() > 0 )
523  board->FinalizeBulkAdd( bulkAddedItems );
524 
525  if( bulkRemovedItems.size() > 0 )
526  board->FinalizeBulkRemove( bulkRemovedItems );
527 
528  if( itemsChanged.size() > 0 )
529  board->OnItemsChanged( itemsChanged );
530 
531  if ( !m_isFootprintEditor )
532  connectivity->RecalculateRatsnest();
533 
535  selTool->RebuildSelection();
536 
537  clear();
538 }
539 
PCB_GROUP * GetParentGroup() const
Definition: board_item.h:60
KIGFX::VIEW * GetView() const
Definition: tool_manager.h:283
virtual COMMIT & Stage(EDA_ITEM *aItem, CHANGE_TYPE aChangeType)
Definition: commit.cpp:48
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:122
static const TOOL_EVENT UnselectedEvent
Definition: actions.h:201
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:49
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:350
void Remove(BOARD_ITEM *aItem, REMOVE_MODE aMode=REMOVE_MODE::NORMAL) override
Removes an item from the container.
Definition: footprint.cpp:566
bool m_isFootprintEditor
Definition: board_commit.h:70
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:69
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:115
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:704
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.
Master controller class:
Definition: tool_manager.h:54
virtual void SwapData(BOARD_ITEM *aImage)
Swap data between aItem and aImage.
Definition: board_item.cpp:139
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT) override
Adds an item to the container.
Definition: board.cpp:608
bool m_resolveNetConflicts
Definition: board_commit.h:71
FOOTPRINT * GetFirstFootprint() const
Get the first footprint on the board or nullptr.
Definition: board.h:318
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:234
std::shared_ptr< CONNECTIVITY_DATA > GetConnectivity() const
Return a list of missing connections between components/tracks.
Definition: board.h:345
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:1985
EDA_ITEM * GetParent() const
Definition: eda_item.h:114
#define STRUCT_DELETED
flag indication structures to be erased
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition: eda_item.h:153
bool RemoveItem(BOARD_ITEM *aItem)
Remove item from group.
Definition: pcb_group.cpp:51
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:154
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:698
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:191
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:1979
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:99
void Remove(BOARD_ITEM *aBoardItem, REMOVE_MODE aMode=REMOVE_MODE::NORMAL) override
Removes an item from the container.
Definition: board.cpp:710
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
BOARD_COMMIT(TOOL_MANAGER *aToolMgr)
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:320
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:68
BOARD_ITEM_CONTAINER * GetParent() const
Definition: board_item.h:135
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:1570
COMMIT & Stage(EDA_ITEM *aItem, CHANGE_TYPE aChangeType) override
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:112