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