/* * This program source code file is part of KiCad, a free EDA CAD application. * * Copyright (C) 2016 CERN * Copyright (C) 2020-2023 KiCad Developers, see AUTHORS.txt for contributors. * @author Tomasz Wlostowski * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, you may find one here: * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html * or you may search the http://www.gnu.org website for the version 2 license, * or you may write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std::placeholders; BOARD_COMMIT::BOARD_COMMIT( TOOL_BASE* aTool ) : m_toolMgr( aTool->GetManager() ), m_isBoardEditor( false ) { if( PCB_TOOL_BASE* pcb_tool = dynamic_cast( aTool ) ) m_isBoardEditor = pcb_tool->IsBoardEditor(); } BOARD_COMMIT::BOARD_COMMIT( EDA_DRAW_FRAME* aFrame ) : m_toolMgr( aFrame->GetToolManager() ), m_isBoardEditor( aFrame->IsType( FRAME_PCB_EDITOR ) ) { } BOARD_COMMIT::BOARD_COMMIT( TOOL_MANAGER* aMgr ) : m_toolMgr( aMgr ), m_isBoardEditor( false ) { } BOARD* BOARD_COMMIT::GetBoard() const { return static_cast( m_toolMgr->GetModel() ); } COMMIT& BOARD_COMMIT::Stage( EDA_ITEM* aItem, CHANGE_TYPE aChangeType, BASE_SCREEN* aScreen ) { wxCHECK( aItem, *this ); if( aChangeType == CHT_MODIFY && aItem->Type() == PCB_GROUP_T ) { // Many operations on group (move, rotate, etc.) are applied directly to their // children, so it's the children that must be staged. static_cast( aItem )->RunOnChildren( [&]( BOARD_ITEM* child ) { COMMIT::Stage( child, aChangeType ); } ); } return COMMIT::Stage( aItem, aChangeType ); } COMMIT& BOARD_COMMIT::Stage( std::vector& container, CHANGE_TYPE aChangeType, BASE_SCREEN* aScreen ) { return COMMIT::Stage( container, aChangeType, aScreen ); } COMMIT& BOARD_COMMIT::Stage( const PICKED_ITEMS_LIST& aItems, UNDO_REDO aModFlag, BASE_SCREEN* aScreen ) { return COMMIT::Stage( aItems, aModFlag, aScreen ); } void BOARD_COMMIT::dirtyIntersectingZones( BOARD_ITEM* item, int aChangeType ) { wxCHECK( item, /* void */ ); ZONE_FILLER_TOOL* zoneFillerTool = m_toolMgr->GetTool(); if( item->Type() == PCB_ZONE_T ) zoneFillerTool->DirtyZone( static_cast( item ) ); if( item->Type() == PCB_GROUP_T ) { static_cast( item )->RunOnChildren( [&]( BOARD_ITEM* child ) { dirtyIntersectingZones( child, aChangeType ); } ); } else { BOARD* board = static_cast( m_toolMgr->GetModel() ); BOX2I bbox = item->GetBoundingBox(); LSET layers = item->GetLayerSet(); if( layers.test( Edge_Cuts ) || layers.test( Margin ) ) layers = LSET::PhysicalLayersMask(); else layers &= LSET::AllCuMask(); if( layers.any() ) { for( ZONE* zone : board->Zones() ) { if( zone->GetIsRuleArea() ) continue; if( ( zone->GetLayerSet() & layers ).any() && zone->GetBoundingBox().Intersects( bbox ) ) { zoneFillerTool->DirtyZone( zone ); } } } } } void BOARD_COMMIT::Push( const wxString& aMessage, int aCommitFlags ) { KIGFX::VIEW* view = m_toolMgr->GetView(); BOARD* board = static_cast( m_toolMgr->GetModel() ); PCB_BASE_FRAME* frame = dynamic_cast( m_toolMgr->GetToolHolder() ); PCB_SELECTION_TOOL* selTool = m_toolMgr->GetTool(); // Notification info PICKED_ITEMS_LIST undoList; bool itemsDeselected = false; bool selectedModified = false; // Dirty flags and lists bool solderMaskDirty = false; bool autofillZones = false; std::vector staleTeardropPadsAndVias; std::set staleTeardropTracks; if( Empty() ) return; undoList.SetDescription( aMessage ); TEARDROP_MANAGER teardropMgr( board, m_toolMgr ); std::shared_ptr connectivity = board->GetConnectivity(); // Note: frame == nullptr happens in QA tests std::vector bulkAddedItems; std::vector bulkRemovedItems; std::vector itemsChanged; if( m_isBoardEditor && !( aCommitFlags & ZONE_FILL_OP ) && ( frame && frame->GetPcbNewSettings()->m_AutoRefillZones ) ) { autofillZones = true; for( ZONE* zone : board->Zones() ) zone->CacheBoundingBox(); } for( COMMIT_LINE& ent : m_changes ) { BOARD_ITEM* boardItem = dynamic_cast( ent.m_item ); if( m_isBoardEditor && boardItem ) { if( boardItem->Type() == PCB_VIA_T || boardItem->Type() == PCB_FOOTPRINT_T || boardItem->IsOnLayer( F_Mask ) || boardItem->IsOnLayer( B_Mask ) ) { solderMaskDirty = true; } if( !( aCommitFlags & SKIP_TEARDROPS ) ) { if( boardItem->Type() == PCB_FOOTPRINT_T ) { for( PAD* pad : static_cast( boardItem )->Pads() ) staleTeardropPadsAndVias.push_back( pad ); } else if( boardItem->Type() == PCB_PAD_T || boardItem->Type() == PCB_VIA_T ) { staleTeardropPadsAndVias.push_back( boardItem ); } else if( boardItem->Type() == PCB_TRACE_T || boardItem->Type() == PCB_ARC_T ) { PCB_TRACK* track = static_cast( boardItem ); staleTeardropTracks.insert( track ); std::vector connectedPads; std::vector connectedVias; connectivity->GetConnectedPadsAndVias( track, &connectedPads, &connectedVias ); for( PAD* pad : connectedPads ) staleTeardropPadsAndVias.push_back( pad ); for( PCB_VIA* via : connectedVias ) staleTeardropPadsAndVias.push_back( via ); } } } if( boardItem && boardItem->IsSelected() ) selectedModified = true; } // Old teardrops must be removed before connectivity is rebuilt if( !staleTeardropPadsAndVias.empty() || !staleTeardropTracks.empty() ) teardropMgr.RemoveTeardrops( *this, &staleTeardropPadsAndVias, &staleTeardropTracks ); for( COMMIT_LINE& ent : m_changes ) { int changeType = ent.m_type & CHT_TYPE; int changeFlags = ent.m_type & CHT_FLAGS; BOARD_ITEM* boardItem = dynamic_cast( ent.m_item ); wxASSERT( ent.m_item ); wxCHECK2( boardItem, continue ); switch( changeType ) { case CHT_ADD: if( selTool && selTool->GetEnteredGroup() && !boardItem->GetParentGroup() && PCB_GROUP::IsGroupableType( boardItem->Type() ) ) { selTool->GetEnteredGroup()->AddItem( boardItem ); } if( !( aCommitFlags & SKIP_UNDO ) ) undoList.PushItem( ITEM_PICKER( nullptr, boardItem, UNDO_REDO::NEWITEM ) ); if( !( changeFlags & CHT_DONE ) ) { if( FOOTPRINT* parentFP = boardItem->GetParentFootprint() ) { parentFP->Add( boardItem ); } else { board->Add( boardItem, ADD_MODE::BULK_INSERT ); // handles connectivity bulkAddedItems.push_back( boardItem ); } } if( autofillZones && boardItem->Type() != PCB_MARKER_T ) dirtyIntersectingZones( boardItem, changeType ); if( view && boardItem->Type() != PCB_NETINFO_T ) view->Add( boardItem ); break; case CHT_REMOVE: { FOOTPRINT* parentFP = boardItem->GetParentFootprint(); PCB_GROUP* parentGroup = boardItem->GetParentGroup(); if( !( aCommitFlags & SKIP_UNDO ) ) undoList.PushItem( ITEM_PICKER( nullptr, boardItem, UNDO_REDO::DELETED ) ); if( boardItem->IsSelected() ) { if( selTool ) selTool->RemoveItemFromSel( boardItem, true /* quiet mode */ ); itemsDeselected = true; } if( parentGroup && !( parentGroup->GetFlags() & STRUCT_DELETED ) ) parentGroup->RemoveItem( boardItem ); if( parentFP && !( parentFP->GetFlags() & STRUCT_DELETED ) ) ent.m_parent = parentFP->m_Uuid; if( autofillZones ) dirtyIntersectingZones( boardItem, changeType ); switch( boardItem->Type() ) { case PCB_FIELD_T: case PCB_TEXT_T: case PCB_PAD_T: case PCB_SHAPE_T: // a shape (normally not on copper layers) case PCB_BITMAP_T: // a bitmap on a user layer case PCB_TEXTBOX_T: // a wrapped text on a layer case PCB_TRACE_T: // a track segment (segment on a copper layer) case PCB_ARC_T: // an arced track segment (segment on a copper layer) case PCB_VIA_T: // a via (like track segment on a copper layer) case PCB_DIM_ALIGNED_T: // a dimension (graphic item) case PCB_DIM_CENTER_T: case PCB_DIM_RADIAL_T: case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_LEADER_T: // a leader dimension case PCB_TARGET_T: // a target (graphic item) case PCB_MARKER_T: // a marker used to show something case PCB_ZONE_T: case PCB_FOOTPRINT_T: if( view ) view->Remove( boardItem ); if( !( changeFlags & CHT_DONE ) ) { if( parentFP ) { parentFP->Remove( boardItem ); } else { board->Remove( boardItem, REMOVE_MODE::BULK ); bulkRemovedItems.push_back( boardItem ); } } break; case PCB_GROUP_T: if( view ) view->Remove( boardItem ); if( !( changeFlags & CHT_DONE ) ) { if( parentFP ) { parentFP->Remove( boardItem ); } else { board->Remove( boardItem, REMOVE_MODE::BULK ); bulkRemovedItems.push_back( boardItem ); } } break; // Metadata items case PCB_NETINFO_T: board->Remove( boardItem, REMOVE_MODE::BULK ); bulkRemovedItems.push_back( boardItem ); break; default: // other types do not need to (or should not) be handled wxASSERT( false ); break; } break; } case CHT_MODIFY: { BOARD_ITEM* boardItemCopy = dynamic_cast( ent.m_copy ); if( !( aCommitFlags & SKIP_UNDO ) ) { ITEM_PICKER itemWrapper( nullptr, boardItem, UNDO_REDO::CHANGED ); wxASSERT( boardItemCopy ); itemWrapper.SetLink( boardItemCopy ); undoList.PushItem( itemWrapper ); } if( !( aCommitFlags & SKIP_CONNECTIVITY ) ) { if( boardItemCopy ) connectivity->MarkItemNetAsDirty( boardItemCopy ); connectivity->Update( boardItem ); } if( m_isBoardEditor && autofillZones ) { dirtyIntersectingZones( boardItemCopy, changeType ); // before dirtyIntersectingZones( boardItem, changeType ); // after } if( view ) view->Update( boardItem ); itemsChanged.push_back( boardItem ); // if no undo entry is needed, the copy would create a memory leak if( aCommitFlags & SKIP_UNDO ) delete ent.m_copy; break; } default: UNIMPLEMENTED_FOR( boardItem->GetClass() ); break; } boardItem->ClearEditFlags(); } if( bulkAddedItems.size() > 0 ) board->FinalizeBulkAdd( bulkAddedItems ); if( bulkRemovedItems.size() > 0 ) board->FinalizeBulkRemove( bulkRemovedItems ); if( itemsChanged.size() > 0 ) board->OnItemsChanged( itemsChanged ); if( m_isBoardEditor ) { size_t num_changes = m_changes.size(); if( aCommitFlags & SKIP_CONNECTIVITY ) { connectivity->ClearRatsnest(); connectivity->ClearLocalRatsnest(); } else { connectivity->RecalculateRatsnest( this ); board->UpdateRatsnestExclusions(); connectivity->ClearLocalRatsnest(); if( frame ) frame->GetCanvas()->RedrawRatsnest(); board->OnRatsnestChanged(); } if( solderMaskDirty ) { if( frame ) frame->HideSolderMask(); } if( !staleTeardropPadsAndVias.empty() || !staleTeardropTracks.empty() ) teardropMgr.UpdateTeardrops( *this, &staleTeardropPadsAndVias, &staleTeardropTracks ); // Log undo items for any connectivity or teardrop changes for( size_t i = num_changes; i < m_changes.size(); ++i ) { COMMIT_LINE& ent = m_changes[i]; BOARD_ITEM* boardItem = dynamic_cast( ent.m_item ); BOARD_ITEM* boardItemCopy = dynamic_cast( ent.m_copy ); wxCHECK2( boardItem, continue ); if( !( aCommitFlags & SKIP_UNDO ) ) { ITEM_PICKER itemWrapper( nullptr, boardItem, convert( ent.m_type & CHT_TYPE ) ); itemWrapper.SetLink( boardItemCopy ); undoList.PushItem( itemWrapper ); } else { delete ent.m_copy; } if( view ) { if( ( ent.m_type & CHT_TYPE ) == CHT_ADD ) view->Add( boardItem ); else if( ( ent.m_type & CHT_TYPE ) == CHT_REMOVE ) view->Remove( boardItem ); else view->Update( boardItem ); } } } if( frame ) { if( !( aCommitFlags & SKIP_UNDO ) ) { if( aCommitFlags & APPEND_UNDO ) frame->AppendCopyToUndoList( undoList, UNDO_REDO::UNSPECIFIED ); else frame->SaveCopyInUndoList( undoList, UNDO_REDO::UNSPECIFIED ); } } m_toolMgr->PostEvent( { TC_MESSAGE, TA_MODEL_CHANGE, AS_GLOBAL } ); if( itemsDeselected ) m_toolMgr->PostEvent( EVENTS::UnselectedEvent ); if( autofillZones ) m_toolMgr->PostAction( PCB_ACTIONS::zoneFillDirty ); if( selectedModified ) m_toolMgr->ProcessEvent( EVENTS::SelectedItemsModified ); if( frame ) { if( !( aCommitFlags & SKIP_SET_DIRTY ) ) frame->OnModify(); else frame->Update3DView( true, frame->GetPcbNewSettings()->m_Display.m_Live3DRefresh ); } clear(); } EDA_ITEM* BOARD_COMMIT::parentObject( EDA_ITEM* aItem ) const { if( BOARD_ITEM* boardItem = dynamic_cast( aItem ) ) { if( FOOTPRINT* parentFP = boardItem->GetParentFootprint() ) return parentFP; } return aItem; } EDA_ITEM* BOARD_COMMIT::makeImage( EDA_ITEM* aItem ) const { EDA_ITEM* clone = aItem->Clone(); if( BOARD_ITEM* board_item = dynamic_cast( clone ) ) board_item->SetParentGroup( nullptr ); return clone; } void BOARD_COMMIT::Revert() { PICKED_ITEMS_LIST undoList; KIGFX::VIEW* view = m_toolMgr->GetView(); BOARD* board = (BOARD*) m_toolMgr->GetModel(); std::shared_ptr connectivity = board->GetConnectivity(); board->IncrementTimeStamp(); // clear caches std::vector bulkAddedItems; std::vector bulkRemovedItems; std::vector itemsChanged; for( auto it = m_changes.rbegin(); it != m_changes.rend(); ++it ) { COMMIT_LINE& ent = *it; BOARD_ITEM* boardItem = dynamic_cast( ent.m_item ); int changeType = ent.m_type & CHT_TYPE; int changeFlags = ent.m_type & CHT_FLAGS; wxCHECK2( boardItem, continue ); switch( changeType ) { case CHT_ADD: if( !( changeFlags & CHT_DONE ) ) break; view->Remove( boardItem ); connectivity->Remove( boardItem ); if( FOOTPRINT* parentFP = boardItem->GetParentFootprint() ) { parentFP->Remove( boardItem ); } else { board->Remove( boardItem, REMOVE_MODE::BULK ); bulkRemovedItems.push_back( boardItem ); } break; case CHT_REMOVE: if( !( changeFlags & CHT_DONE ) ) break; view->Add( boardItem ); connectivity->Add( boardItem ); if( FOOTPRINT* parentFP = dynamic_cast( board->GetItem( ent.m_parent ) ) ) { parentFP->Add( boardItem, ADD_MODE::INSERT ); } else { board->Add( boardItem, ADD_MODE::INSERT ); bulkAddedItems.push_back( boardItem ); } break; case CHT_MODIFY: { view->Remove( boardItem ); connectivity->Remove( boardItem ); BOARD_ITEM* boardItemCopy = dynamic_cast( ent.m_copy ); wxASSERT( boardItemCopy ); boardItem->SwapItemData( boardItemCopy ); if( boardItem->Type() == PCB_GROUP_T ) { PCB_GROUP* group = static_cast( boardItem ); group->RunOnChildren( [&]( BOARD_ITEM* child ) { child->SetParentGroup( group ); } ); } view->Add( boardItem ); connectivity->Add( boardItem ); board->OnItemChanged( boardItem ); itemsChanged.push_back( boardItem ); delete ent.m_copy; break; } default: UNIMPLEMENTED_FOR( boardItem->GetClass() ); break; } boardItem->ClearEditFlags(); } if( bulkAddedItems.size() > 0 ) board->FinalizeBulkAdd( bulkAddedItems ); if( bulkRemovedItems.size() > 0 ) board->FinalizeBulkRemove( bulkRemovedItems ); if( itemsChanged.size() > 0 ) board->OnItemsChanged( itemsChanged ); if( m_isBoardEditor ) { connectivity->RecalculateRatsnest(); board->UpdateRatsnestExclusions(); board->OnRatsnestChanged(); } PCB_SELECTION_TOOL* selTool = m_toolMgr->GetTool(); selTool->RebuildSelection(); // Property panel needs to know about the reselect m_toolMgr->PostEvent( EVENTS::SelectedItemsModified ); clear(); }