KiCad PCB EDA Suite
Loading...
Searching...
No Matches
undo_redo.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) 2012 Jean-Pierre Charras, [email protected]
5 * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
6 * Copyright (C) 2016 CERN
7 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
8 * @author Maciej Suminski <[email protected]>
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version 2
13 * of the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, you may find one here:
22 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
23 * or you may search the http://www.gnu.org website for the version 2 license,
24 * or you may write to the Free Software Foundation, Inc.,
25 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
26 */
27
28#include <functional>
29using namespace std::placeholders;
30#include <macros.h>
31#include <pcb_edit_frame.h>
32#include <pcb_track.h>
33#include <pcb_group.h>
34#include <pcb_shape.h>
35#include <pcb_generator.h>
36#include <footprint.h>
37#include <lset.h>
38#include <pad.h>
39#include <origin_viewitem.h>
41#include <tool/tool_manager.h>
42#include <tool/actions.h>
43#include <tools/pcb_actions.h>
45#include <tools/pcb_control.h>
47#include <board_commit.h>
49#include <wx/msgdlg.h>
50#include <pcb_board_outline.h>
51
52/* Functions to undo and redo edit commands.
53 * commands to undo are stored in CurrentScreen->m_UndoList
54 * commands to redo are stored in CurrentScreen->m_RedoList
55 *
56 * m_UndoList and m_RedoList handle a std::vector of PICKED_ITEMS_LIST
57 * Each PICKED_ITEMS_LIST handle a std::vector of pickers (class ITEM_PICKER),
58 * that store the list of schematic items that are concerned by the command to undo or redo
59 * and is created for each command to undo (handle also a command to redo).
60 * each picker has a pointer pointing to an item to undo or redo (in fact: deleted, added or
61 * modified),
62 * and has a pointer to a copy of this item, when this item has been modified
63 * (the old values of parameters are therefore saved)
64 *
65 * there are 3 cases:
66 * - delete item(s) command
67 * - change item(s) command
68 * - add item(s) command
69 *
70 * Undo command
71 * - delete item(s) command:
72 * => deleted items are moved in undo list
73 *
74 * - change item(s) command
75 * => A copy of item(s) is made (a DrawPickedStruct list of wrappers)
76 * the .m_Link member of each wrapper points the modified item.
77 * the .m_Item member of each wrapper points the old copy of this item.
78 *
79 * - add item(s) command
80 * =>A list of item(s) is made. The .m_Item member of each wrapper points the new item.
81 *
82 * Redo command
83 * - delete item(s) old command:
84 * => deleted items are moved in EEDrawList list, and in
85 *
86 * - change item(s) command
87 * => the copy of item(s) is moved in Undo list
88 *
89 * - add item(s) command
90 * => The list of item(s) is used to create a deleted list in undo list(same as a delete
91 * command)
92 *
93 * Some block operations that change items can be undone without memorize items, just the
94 * coordinates of the transform:
95 * move list of items (undo/redo is made by moving with the opposite move vector)
96 * mirror (Y) and flip list of items (undo/redo is made by mirror or flip items)
97 * so they are handled specifically.
98 *
99 */
100
101
103 const PICKED_ITEMS_LIST& aItemsList,
104 UNDO_REDO aCommandType )
105{
106 int preExisting = (int) commandToUndo->GetCount();
107
108 for( unsigned ii = 0; ii < aItemsList.GetCount(); ii++ )
109 commandToUndo->PushItem( aItemsList.GetItemWrapper(ii) );
110
111 for( unsigned ii = preExisting; ii < commandToUndo->GetCount(); ii++ )
112 {
113 EDA_ITEM* item = commandToUndo->GetPickedItem( ii );
114 UNDO_REDO command = commandToUndo->GetPickedItemStatus( ii );
115
116 if( command == UNDO_REDO::UNSPECIFIED )
117 {
118 command = aCommandType;
119 commandToUndo->SetPickedItemStatus( command, ii );
120 }
121
122 wxASSERT( item );
123
124 switch( command )
125 {
129 // If we don't yet have a copy in the link, set one up
130 if( !commandToUndo->GetPickedItemLink( ii ) )
131 commandToUndo->SetPickedItemLink( BOARD_COMMIT::MakeImage( item ), ii );
132
133 break;
134
138 break;
139
140 default:
141 wxFAIL_MSG( wxString::Format( wxT( "Unrecognized undo command: %X" ), command ) );
142 break;
143 }
144 }
145
146 if( commandToUndo->GetCount() )
147 {
148 /* Save the copy in undo list */
149 PushCommandToUndoList( commandToUndo );
150
151 /* Clear redo list, because after a new command one cannot redo a command */
153 }
154 else
155 {
156 // Should not occur
157 wxASSERT( false );
158 delete commandToUndo;
159 }
160}
161
162
164{
165 PICKED_ITEMS_LIST* commandToUndo = new PICKED_ITEMS_LIST();
166 PICKED_ITEMS_LIST itemsList;
167
168 itemsList.PushItem( ITEM_PICKER( nullptr, aItem, aCommandType ) );
169 saveCopyInUndoList( commandToUndo, itemsList, aCommandType );
170}
171
172
174 UNDO_REDO aCommandType )
175{
176 PICKED_ITEMS_LIST* commandToUndo = new PICKED_ITEMS_LIST();
177 commandToUndo->SetDescription( aItemsList.GetDescription() );
178
179 saveCopyInUndoList( commandToUndo, aItemsList, aCommandType );
180}
181
182
184 UNDO_REDO aCommandType )
185{
186 PICKED_ITEMS_LIST* commandToUndo = PopCommandFromUndoList();
187
188 if( !commandToUndo )
189 {
190 commandToUndo = new PICKED_ITEMS_LIST();
191 commandToUndo->SetDescription( aItemsList.GetDescription() );
192 }
193
194 saveCopyInUndoList( commandToUndo, aItemsList, aCommandType );
195}
196
197
199{
200 if( UndoRedoBlocked() )
201 return;
202
203 if( GetUndoCommandCount() <= 0 )
204 return;
205
206 // Inform tools that undo command was issued
207 m_toolManager->ProcessEvent( { TC_MESSAGE, TA_UNDO_REDO_PRE, AS_GLOBAL } );
208
209 // Get the old list
211
212 // Undo the command
214
215 // Put the old list in RedoList
216 list->ReversePickersListOrder();
217 PushCommandToRedoList( list );
218
219 OnModify();
220
223
224 m_pcb->UpdateBoardOutline();
225 GetCanvas()->GetView()->Update( m_pcb->BoardOutline() );
226 GetCanvas()->Refresh();
227}
228
229
231{
232 if( UndoRedoBlocked() )
233 return;
234
235 if( GetRedoCommandCount() == 0 )
236 return;
237
238 // Inform tools that redo command was issued
240
241 // Get the old list
243
244 // Redo the command
246
247 // Put the old list in UndoList
248 list->ReversePickersListOrder();
249 PushCommandToUndoList( list );
250
251 OnModify();
252
255
256 m_pcb->UpdateBoardOutline();
257 GetCanvas()->GetView()->Update( m_pcb->BoardOutline() );
258 GetCanvas()->Refresh();
259}
260
261
263{
264 bool not_found = false;
265 bool reBuild_ratsnest = false;
266 bool deep_reBuild_ratsnest = false; // true later if pointers must be rebuilt
267 bool solder_mask_dirty = false;
268 bool current_show_ratsnest = GetPcbNewSettings()->m_Display.m_ShowGlobalRatsnest;
269 std::vector<BOX2I> dirty_rule_areas;
270
271 KIGFX::PCB_VIEW* view = GetCanvas()->GetView();
272 std::shared_ptr<CONNECTIVITY_DATA> connectivity = GetBoard()->GetConnectivity();
273
274 GetBoard()->IncrementTimeStamp(); // clear caches
275
276 // Enum to track the modification type of items. Used to enable bulk BOARD_LISTENER
277 // callbacks at the end of the undo / redo operation
278 enum ITEM_CHANGE_TYPE
279 {
280 ADDED,
281 DELETED,
282 CHANGED
283 };
284
285 std::unordered_map<EDA_ITEM*, ITEM_CHANGE_TYPE> item_changes;
286
287 auto clear_local_ratsnest_flags =
288 [&]( EDA_ITEM* item )
289 {
290 switch( item->Type() )
291 {
292 case PCB_TRACE_T:
293 case PCB_ARC_T:
294 case PCB_VIA_T:
295 static_cast<PCB_TRACK*>( item )->SetLocalRatsnestVisible( current_show_ratsnest );
296 break;
297
298 case PCB_ZONE_T:
299 static_cast<ZONE*>( item )->SetLocalRatsnestVisible( current_show_ratsnest );
300 break;
301
302 case PCB_FOOTPRINT_T:
303 for( PAD* pad : static_cast<FOOTPRINT*>( item )->Pads() )
304 pad->SetLocalRatsnestVisible( current_show_ratsnest );
305
306 break;
307
308 default:
309 break;
310 }
311 };
312
313 auto update_item_change_state =
314 [&]( EDA_ITEM* item, ITEM_CHANGE_TYPE change_type )
315 {
316 auto item_itr = item_changes.find( item );
317
318 if( item_itr == item_changes.end() )
319 {
320 // First time we've seen this item - tag the current change type
321 item_changes.insert( { item, change_type } );
322 return;
323 }
324
325 // Update the item state based on the current and next change type
326 switch( item_itr->second )
327 {
328 case ITEM_CHANGE_TYPE::ADDED:
329 {
330 if( change_type == ITEM_CHANGE_TYPE::DELETED )
331 {
332 // The item was previously added, now deleted - as far as bulk callbacks
333 // are concerned, the item has never existed
334 item_changes.erase( item_itr );
335 }
336 else if( change_type == ITEM_CHANGE_TYPE::ADDED )
337 {
338 // Error condition - added an already added item
339 wxASSERT_MSG( false, wxT( "UndoRedo: should not add already added item" ) );
340 }
341
342 // For all other cases, the item remains as ADDED as seen by the bulk callbacks
343 break;
344 }
345 case ITEM_CHANGE_TYPE::DELETED:
346 {
347 // This is an error condition - item has already been deleted so should not
348 // be operated on further
349 wxASSERT_MSG( false, wxT( "UndoRedo: should not alter already deleted item" ) );
350 break;
351 }
352 case ITEM_CHANGE_TYPE::CHANGED:
353 {
354 if( change_type == ITEM_CHANGE_TYPE::DELETED )
355 {
356 item_itr->second = ITEM_CHANGE_TYPE::DELETED;
357 }
358 else if( change_type == ITEM_CHANGE_TYPE::ADDED )
359 {
360 // This is an error condition - item has already been changed so should not
361 // be added
362 wxASSERT_MSG( false, wxT( "UndoRedo: should not add already changed item" ) );
363 }
364
365 // Otherwise, item remains CHANGED
366 break;
367 }
368 }
369 };
370
371 // Undo in the reverse order of list creation: (this can allow stacked changes
372 // like the same item can be changes and deleted in the same complex command
373
374 // Restore changes in reverse order
375 for( int ii = (int) aList->GetCount() - 1; ii >= 0 ; ii-- )
376 {
377 EDA_ITEM* eda_item = aList->GetPickedItem( (unsigned) ii );
378
379 /* Test for existence of item on board.
380 * It could be deleted, and no more on board:
381 * - if a call to SaveCopyInUndoList was forgotten in Pcbnew
382 * - in zones outlines, when a change in one zone merges this zone with an other
383 * This test avoids a Pcbnew crash
384 * Obviously, this test is not made for deleted items
385 */
386 UNDO_REDO status = aList->GetPickedItemStatus( ii );
387
388 if( status != UNDO_REDO::DELETED
389 && status != UNDO_REDO::DRILLORIGIN // origin markers never on board
390 && status != UNDO_REDO::GRIDORIGIN // origin markers never on board
391 && status != UNDO_REDO::PAGESETTINGS ) // nor are page settings proxy items
392 {
393 if( !GetBoard()->ResolveItem( eda_item->m_Uuid, true ) )
394 {
395 // Remove this non existent item
396 aList->RemovePicker( ii );
397 not_found = true;
398
399 if( aList->GetCount() == 0 )
400 break;
401
402 continue;
403 }
404 }
405
406 // see if we must rebuild ratsnets and pointers lists
407 switch( eda_item->Type() )
408 {
409 case PCB_FOOTPRINT_T:
410 deep_reBuild_ratsnest = true; // Pointers on pads can be invalid
412
413 case PCB_ZONE_T:
414 case PCB_TRACE_T:
415 case PCB_ARC_T:
416 case PCB_VIA_T:
417 case PCB_PAD_T:
418 reBuild_ratsnest = true;
419 break;
420
421 case PCB_NETINFO_T:
422 reBuild_ratsnest = true;
423 deep_reBuild_ratsnest = true;
424 break;
425
426 default:
427 break;
428 }
429
430 switch( eda_item->Type() )
431 {
432 case PCB_FOOTPRINT_T:
433 solder_mask_dirty = true;
434 break;
435
436 case PCB_VIA_T:
437 solder_mask_dirty = true;
438 break;
439
440 case PCB_ZONE_T:
441 case PCB_TRACE_T:
442 case PCB_ARC_T:
443 case PCB_PAD_T:
444 case PCB_SHAPE_T:
445 {
446 LSET layers = static_cast<BOARD_ITEM*>( eda_item )->GetLayerSet();
447
448 if( layers.test( F_Mask ) || layers.test( B_Mask ) )
449 solder_mask_dirty = true;
450
451 break;
452 }
453
454 default:
455 break;
456 }
457
458 switch( aList->GetPickedItemStatus( ii ) )
459 {
460 case UNDO_REDO::CHANGED: /* Exchange old and new data for each item */
461 if( eda_item->IsBOARD_ITEM() )
462 {
463 BOARD_ITEM* item = static_cast<BOARD_ITEM*>( eda_item );
464 BOARD_ITEM* image = static_cast<BOARD_ITEM*>( aList->GetPickedItemLink( ii ) );
465 BOARD_ITEM_CONTAINER* parent = GetBoard();
466
467 if( item->GetParentFootprint() )
468 {
469 // We need the current item and it's parent, which may be different from what
470 // was stored if we're multiple frames up the undo stack.
471 item = GetBoard()->ResolveItem( item->m_Uuid );
472 parent = item->GetParentFootprint();
473 }
474
475 view->Remove( item );
476 parent->Remove( item );
477
478 item->SwapItemData( image );
479
480 clear_local_ratsnest_flags( item );
481 item->ClearFlags( UR_TRANSIENT );
482 image->SetFlags( UR_TRANSIENT );
483
484 view->Add( item );
485 view->Hide( item, false );
486 parent->Add( item );
487
488 if( item->Type() == PCB_ZONE_T && static_cast<ZONE*>( item )->GetIsRuleArea() )
489 {
490 dirty_rule_areas.push_back( item->GetBoundingBox() );
491 dirty_rule_areas.push_back( image->GetBoundingBox() );
492 }
493
494 update_item_change_state( item, ITEM_CHANGE_TYPE::CHANGED );
495 }
496
497 break;
498
499 case UNDO_REDO::NEWITEM: /* new items are deleted */
500 if( eda_item->IsBOARD_ITEM() )
501 {
503 GetModel()->Remove( static_cast<BOARD_ITEM*>( eda_item ), REMOVE_MODE::BULK );
504 update_item_change_state( eda_item, ITEM_CHANGE_TYPE::DELETED );
505
506 if( eda_item->Type() != PCB_NETINFO_T )
507 view->Remove( eda_item );
508
509 eda_item->SetFlags( UR_TRANSIENT );
510
511 if( eda_item->Type() == PCB_ZONE_T && static_cast<ZONE*>( eda_item )->GetIsRuleArea() )
512 dirty_rule_areas.push_back( eda_item->GetBoundingBox() );
513 }
514
515 break;
516
517 case UNDO_REDO::DELETED: /* deleted items are put in List, as new items */
518 if( eda_item->IsBOARD_ITEM() )
519 {
521
522 clear_local_ratsnest_flags( eda_item );
523 eda_item->ClearFlags( UR_TRANSIENT );
524
525 GetModel()->Add( static_cast<BOARD_ITEM*>( eda_item ), ADD_MODE::BULK_APPEND );
526 update_item_change_state( eda_item, ITEM_CHANGE_TYPE::ADDED );
527
528 if( eda_item->Type() != PCB_NETINFO_T )
529 view->Add( eda_item );
530
531 if( eda_item->Type() == PCB_ZONE_T && static_cast<ZONE*>( eda_item )->GetIsRuleArea() )
532 dirty_rule_areas.push_back( eda_item->GetBoundingBox() );
533 }
534
535 break;
536
539 {
540 // Warning: DRILLORIGIN and GRIDORIGIN undo/redo command create EDA_ITEMs
541 // that cannot be casted to BOARD_ITEMs
542 EDA_ITEM* image = aList->GetPickedItemLink( ii );
543 VECTOR2D origin = image->GetPosition();
544 image->SetPosition( eda_item->GetPosition() );
545
546 if( aList->GetPickedItemStatus( ii ) == UNDO_REDO::DRILLORIGIN )
547 BOARD_EDITOR_CONTROL::DoSetDrillOrigin( view, this, eda_item, origin );
548 else
549 PCB_CONTROL::DoSetGridOrigin( view, this, eda_item, origin );
550
551 break;
552 }
553
555 if( eda_item->Type() == WS_PROXY_UNDO_ITEM_T || eda_item->Type() == WS_PROXY_UNDO_ITEM_PLUS_T )
556 {
557 // swap current settings with stored settings
558 DS_PROXY_UNDO_ITEM alt_item( this );
559 DS_PROXY_UNDO_ITEM* item = static_cast<DS_PROXY_UNDO_ITEM*>( eda_item );
560 item->Restore( this );
561 *item = std::move( alt_item );
562 }
563
564 break;
565
566 default:
567 wxFAIL_MSG( wxString::Format( wxT( "PutDataInPreviousState() error (unknown code %X)" ),
568 aList->GetPickedItemStatus( ii ) ) );
569 break;
570 }
571
572 if( eda_item->Type() == PCB_FOOTPRINT_T )
573 {
574 FOOTPRINT* fp = static_cast<FOOTPRINT*>( eda_item );
576 m_pcb->GetComponentClassManager().RebuildRequiredCaches( fp );
577 }
578 }
579
580 if( not_found )
581 wxMessageBox( _( "Incomplete undo/redo operation: some items not found" ) );
582
583 // We have now swapped all the group parent and group member pointers. But it is a
584 // risky proposition to bet on the pointers being invariant, so validate them all.
585 for( int ii = 0; ii < (int) aList->GetCount(); ++ii )
586 {
587 ITEM_PICKER& wrapper = aList->GetItemWrapper( ii );
588
589 if( wrapper.GetStatus() == UNDO_REDO::DELETED )
590 continue;
591
592 BOARD_ITEM* parentGroup = GetBoard()->ResolveItem( wrapper.GetGroupId(), true );
593 wrapper.GetItem()->SetParentGroup( dynamic_cast<PCB_GROUP*>( parentGroup ) );
594
595 if( EDA_GROUP* group = dynamic_cast<PCB_GROUP*>( wrapper.GetItem() ) )
596 {
597 // Items list may contain dodgy pointers, so don't use RemoveAll()
598 group->GetItems().clear();
599
600 for( const KIID& member : wrapper.GetGroupMembers() )
601 {
602 if( BOARD_ITEM* memberItem = GetBoard()->ResolveItem( member, true ) )
603 group->AddItem( memberItem );
604 }
605 }
606
607 // And prepare for a redo by updating group info based on current image
608 if( EDA_ITEM* item = wrapper.GetLink() )
609 wrapper.SetLink( item );
610 }
611
612 if( IsType( FRAME_PCB_EDITOR ) )
613 {
614 if( !dirty_rule_areas.empty() && ( GetPcbNewSettings()->m_Display.m_TrackClearance == SHOW_WITH_VIA_ALWAYS
615 || GetPcbNewSettings()->m_Display.m_PadClearance ) )
616 {
617 view->UpdateCollidingItems( dirty_rule_areas, { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T, PCB_PAD_T } );
618 }
619
620 if( reBuild_ratsnest || deep_reBuild_ratsnest )
621 {
622 // Connectivity may have changed; rebuild internal caches to remove stale items
624 Compile_Ratsnest( false );
625 }
626
627 if( solder_mask_dirty )
629 }
630
632
634 selTool->RebuildSelection();
635
637
638 // Invoke bulk BOARD_LISTENER callbacks
639 std::vector<BOARD_ITEM*> added_items, deleted_items, changed_items;
640
641 for( auto& [item, changeType] : item_changes )
642 {
643 switch( changeType )
644 {
645 case ITEM_CHANGE_TYPE::ADDED:
646 added_items.push_back( static_cast<BOARD_ITEM*>( item ) );
647 break;
648
649 case ITEM_CHANGE_TYPE::DELETED:
650 deleted_items.push_back( static_cast<BOARD_ITEM*>( item ) );
651 break;
652
653 case ITEM_CHANGE_TYPE::CHANGED:
654 changed_items.push_back( static_cast<BOARD_ITEM*>( item ) );
655 break;
656 }
657 }
658
660
661 if( added_items.size() > 0 || deleted_items.size() > 0 || changed_items.size() > 0 )
662 GetBoard()->OnItemsCompositeUpdate( added_items, deleted_items, changed_items );
663}
664
665
667{
668 if( aItemCount == 0 )
669 return;
670
671 UNDO_REDO_CONTAINER& list = ( whichList == UNDO_LIST ) ? m_undoList : m_redoList;
672
673 if( aItemCount < 0 )
674 {
675 list.ClearCommandList();
676 }
677 else
678 {
679 for( int ii = 0; ii < aItemCount; ii++ )
680 {
681 if( list.m_CommandsList.size() == 0 )
682 break;
683
684 PICKED_ITEMS_LIST* curr_cmd = list.m_CommandsList[0];
685 list.m_CommandsList.erase( list.m_CommandsList.begin() );
686 ClearListAndDeleteItems( curr_cmd );
687 delete curr_cmd; // Delete command
688 }
689 }
690}
691
692
694{
696 []( EDA_ITEM* item )
697 {
698 wxASSERT_MSG( item->HasFlag( UR_TRANSIENT ),
699 "Item on undo/redo list not owned by undo/redo!" );
700
701 delete item;
702 } );
703}
704
705
707{
711 delete undo;
712
713 m_pcb->UpdateBoardOutline();
714 GetCanvas()->GetView()->Update( m_pcb->BoardOutline() );
715 GetCanvas()->Refresh();
716}
static EDA_ITEM * MakeImage(EDA_ITEM *aItem)
static void DoSetDrillOrigin(KIGFX::VIEW *aView, PCB_BASE_FRAME *aFrame, EDA_ITEM *aItem, const VECTOR2D &aPoint)
Abstract interface for BOARD_ITEMs capable of storing other items inside.
virtual void Remove(BOARD_ITEM *aItem, REMOVE_MODE aMode=REMOVE_MODE::NORMAL)=0
Removes an item from the container.
virtual void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false)=0
Adds an item to the container.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition board_item.h:79
void SwapItemData(BOARD_ITEM *aImage)
Swap data between aItem and aImage.
FOOTPRINT * GetParentFootprint() const
void SanitizeNetcodes()
Definition board.cpp:2824
bool BuildConnectivity(PROGRESS_REPORTER *aReporter=nullptr)
Build or rebuild the board connectivity database for the board, especially the list of connected item...
Definition board.cpp:188
void OnItemsCompositeUpdate(std::vector< BOARD_ITEM * > &aAddedItems, std::vector< BOARD_ITEM * > &aRemovedItems, std::vector< BOARD_ITEM * > &aChangedItems)
Notify the board and its listeners that items on the board have been modified in a composite operatio...
Definition board.cpp:2871
void IncrementTimeStamp()
Definition board.cpp:256
COMPONENT_CLASS_MANAGER & GetComponentClassManager()
Gets the component class manager.
Definition board.h:1344
BOARD_ITEM * ResolveItem(const KIID &aID, bool aAllowNullptrReturn=false) const
Definition board.cpp:1613
std::shared_ptr< CONNECTIVITY_DATA > GetConnectivity() const
Return a list of missing connections between components/tracks.
Definition board.h:521
void InvalidateComponentClasses()
Invalidates any caches component classes and recomputes caches if required.
void Restore(EDA_DRAW_FRAME *aFrame, KIGFX::VIEW *aView=nullptr)
virtual void PushCommandToUndoList(PICKED_ITEMS_LIST *aItem)
Add a command to undo in the undo list.
virtual int GetRedoCommandCount() const
UNDO_REDO_CONTAINER m_undoList
UNDO_REDO_LIST
Specify whether we are interacting with the undo or redo stacks.
virtual PICKED_ITEMS_LIST * PopCommandFromRedoList()
Return the last command to undo and remove it from list, nothing is deleted.
UNDO_REDO_CONTAINER m_redoList
virtual PICKED_ITEMS_LIST * PopCommandFromUndoList()
Return the last command to undo and remove it from list, nothing is deleted.
virtual int GetUndoCommandCount() const
virtual void PushCommandToRedoList(PICKED_ITEMS_LIST *aItem)
Add a command to redo in the redo list.
bool IsType(FRAME_T aType) const
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=nullptr) override
A set of EDA_ITEMs (i.e., without duplicates).
Definition eda_group.h:46
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
virtual VECTOR2I GetPosition() const
Definition eda_item.h:272
virtual const BOX2I GetBoundingBox() const
Return the orthogonal bounding box of this object for display purposes.
Definition eda_item.cpp:110
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition eda_item.h:142
const KIID m_Uuid
Definition eda_item.h:516
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition eda_item.h:144
bool HasFlag(EDA_ITEM_FLAGS aFlag) const
Definition eda_item.h:146
static const TOOL_EVENT UndoRedoPreEvent
Definition actions.h:369
static const TOOL_EVENT SelectedItemsModified
Selected items were moved, this can be very high frequency on the canvas, use with care.
Definition actions.h:353
static const TOOL_EVENT UndoRedoPostEvent
Definition actions.h:370
void InvalidateComponentClassCache() const
Forces deferred (on next access) recalculation of the component class for this footprint.
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const override
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition pcb_view.cpp:91
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1) override
Add a VIEW_ITEM to the view.
Definition pcb_view.cpp:57
void UpdateCollidingItems(const std::vector< BOX2I > &aStaleAreas, std::initializer_list< KICAD_T > aTypes)
Sets the KIGFX::REPAINT on all items matching aTypes which intersect aStaleAreas.
Definition pcb_view.cpp:122
virtual void Remove(VIEW_ITEM *aItem) override
Remove a VIEW_ITEM from the view.
Definition pcb_view.cpp:74
bool IsBOARD_ITEM() const
Definition view_item.h:102
void Hide(VIEW_ITEM *aItem, bool aHide=true, bool aHideOverlay=false)
Temporarily hide the item in the view (e.g.
Definition view.cpp:1633
Definition kiid.h:49
LSET is a set of PCB_LAYER_IDs.
Definition lset.h:37
Definition pad.h:54
DISPLAY_OPTIONS m_Display
static TOOL_ACTION rehatchShapes
void ClearUndoORRedoList(UNDO_REDO_LIST whichList, int aItemCount=-1) override
Free the undo or redo list from List element.
void RestoreCopyFromUndoList(wxCommandEvent &aEvent)
Undo the last edit:
void saveCopyInUndoList(PICKED_ITEMS_LIST *commandToUndo, const PICKED_ITEMS_LIST &aItemsList, UNDO_REDO aCommandType)
void AppendCopyToUndoList(const PICKED_ITEMS_LIST &aItemsList, UNDO_REDO aCommandType) override
As SaveCopyInUndoList, but appends the changes to the last undo item on the stack.
void SaveCopyInUndoList(EDA_ITEM *aItemToCopy, UNDO_REDO aTypeCommand) override
Create a new entry in undo list of commands.
void ClearListAndDeleteItems(PICKED_ITEMS_LIST *aList)
void RollbackFromUndo()
Perform an undo of the last edit without logging a corresponding redo.
bool UndoRedoBlocked() const
Check if the undo and redo operations are currently blocked.
void PutDataInPreviousState(PICKED_ITEMS_LIST *aList)
Used in undo or redo command.
void RestoreCopyFromRedoList(wxCommandEvent &aEvent)
Redo the last edit:
PCBNEW_SETTINGS * GetPcbNewSettings() const
void OnModify() override
Must be called after a change in order to set the "modify" flag and update other data structures and ...
EDA_ITEM * ResolveItem(const KIID &aId, bool aAllowNullptrReturn=false) const override
Fetch an item by KIID.
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
BOARD * GetBoard() const
virtual BOARD_ITEM_CONTAINER * GetModel() const =0
void Compile_Ratsnest(bool aDisplayStatus)
Create the entire board ratsnest.
Definition ratsnest.cpp:35
static void DoSetGridOrigin(KIGFX::VIEW *aView, PCB_BASE_FRAME *aFrame, EDA_ITEM *originViewItem, const VECTOR2D &aPoint)
virtual KIGFX::PCB_VIEW * GetView() const override
Return a pointer to the #VIEW instance used in the panel.
A set of BOARD_ITEMs (i.e., without duplicates).
Definition pcb_group.h:53
The selection tool: currently supports:
void RebuildSelection()
Rebuild the selection from the EDA_ITEMs' selection flags.
A holder to handle information on schematic or board items.
bool SetPickedItemStatus(UNDO_REDO aStatus, unsigned aIdx)
Set the type of undo/redo operation for a given picked item.
void PushItem(const ITEM_PICKER &aItem)
Push aItem to the top of the list.
void SetDescription(const wxString &aDescription)
UNDO_REDO GetPickedItemStatus(unsigned int aIdx) const
EDA_ITEM * GetPickedItemLink(unsigned int aIdx) const
wxString GetDescription() const
bool RemovePicker(unsigned aIdx)
Remove one entry (one picker) from the list of picked items.
const ITEM_PICKER & GetItemWrapper(unsigned int aIdx) const
unsigned GetCount() const
bool SetPickedItemLink(EDA_ITEM *aLink, unsigned aIdx)
Set the link associated to a given picked item.
void ClearListAndDeleteItems(std::function< void(EDA_ITEM *)> aItemDeleter)
Delete the list of pickers AND the data pointed by #m_PickedItem or #m_PickedItemLink according to th...
EDA_ITEM * GetPickedItem(unsigned int aIdx) const
TOOL_MANAGER * m_toolManager
TOOL_MANAGER * GetToolManager() const
Return the MVC controller.
bool PostAction(const std::string &aActionName, T aParam)
Run the specified action after the current action (coroutine) ends.
A holder to handle a list of undo (or redo) commands.
Handle a list of polygons defining a copper zone.
Definition zone.h:74
bool GetIsRuleArea() const
Accessors to parameters used in Rule Area zones:
Definition zone.h:704
#define _(s)
#define UR_TRANSIENT
indicates the item is owned by the undo/redo stack
@ FRAME_PCB_EDITOR
Definition frame_type.h:42
@ B_Mask
Definition layer_ids.h:98
@ F_Mask
Definition layer_ids.h:97
This file contains miscellaneous commonly used macros and functions.
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
Definition macros.h:83
Class to handle a set of BOARD_ITEMs.
@ SHOW_WITH_VIA_ALWAYS
@ AS_GLOBAL
Global action (toolbar/main menu event, global shortcut)
Definition tool_action.h:49
@ TA_UNDO_REDO_PRE
This event is sent before undo/redo command is performed.
Definition tool_event.h:106
@ TA_UNDO_REDO_POST
This event is sent after undo/redo command is performed.
Definition tool_event.h:109
@ TC_MESSAGE
Definition tool_event.h:58
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
Definition typeinfo.h:88
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition typeinfo.h:97
@ PCB_ZONE_T
class ZONE, a copper pour area
Definition typeinfo.h:107
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
Definition typeinfo.h:86
@ WS_PROXY_UNDO_ITEM_T
Definition typeinfo.h:226
@ 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
@ WS_PROXY_UNDO_ITEM_PLUS_T
Definition typeinfo.h:227
@ PCB_NETINFO_T
class NETINFO_ITEM, a description of a net
Definition typeinfo.h:109
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition typeinfo.h:96
UNDO_REDO
Undo Redo considerations: Basically we have 3 cases New item Deleted item Modified item there is also...
VECTOR2< double > VECTOR2D
Definition vector2d.h:694