haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/eeschema/sch_commit.cpp

566 lines
16 KiB
C++
Raw Normal View History

Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
Fix assertion when pasting schematic sheets. Pasted sheets do not have assigned SCH_SCREEN objects until after they are loaded. Do not recalculate connectivity unless the SCH_COMMIT object actually has connectable schematic object changes. Fixes https://gitlab.com/kicad/code/kicad/-/issues/16579
2024-01-15 17:15:30 +00:00
* Copyright (C) 2023-2024 KiCad Developers, see AUTHORS.txt for contributors.
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
*
* 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 <macros.h>
#include <tool/tool_manager.h>
#include <tools/ee_tool_base.h>
#include <lib_item.h>
#include <lib_symbol.h>
#include <sch_screen.h>
#include <schematic.h>
#include <view/view.h>
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
#include <sch_commit.h>
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
#include <functional>
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
SCH_COMMIT::SCH_COMMIT( TOOL_MANAGER* aToolMgr ) :
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
m_toolMgr( aToolMgr ),
m_isLibEditor( false )
{
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
SCH_BASE_FRAME* frame = static_cast<SCH_BASE_FRAME*>( m_toolMgr->GetToolHolder() );
m_isLibEditor = frame && frame->IsType( FRAME_SCH_SYMBOL_EDITOR );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
SCH_COMMIT::SCH_COMMIT( EE_TOOL_BASE<SCH_BASE_FRAME>* aTool )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
m_toolMgr = aTool->GetManager();
m_isLibEditor = aTool->IsSymbolEditor();
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
SCH_COMMIT::SCH_COMMIT( EDA_DRAW_FRAME* aFrame )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
m_toolMgr = aFrame->GetToolManager();
m_isLibEditor = aFrame->IsType( FRAME_SCH_SYMBOL_EDITOR );
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
SCH_COMMIT::~SCH_COMMIT()
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
COMMIT& SCH_COMMIT::Stage( EDA_ITEM *aItem, CHANGE_TYPE aChangeType, BASE_SCREEN *aScreen )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
wxCHECK( aItem, *this );
Make sure all items managed by their parent get correct handling in SCH_COMMIT. Fixes https://gitlab.com/kicad/code/kicad/-/issues/15129
2023-07-08 19:36:00 +00:00
// If aItem belongs a symbol, sheet or label, the full parent will be saved because undo/redo
// does not handle "sub items" modifications.
Don't promote to sheet parent when the item itself is a sheet. Fixes https://gitlab.com/kicad/code/kicad/-/issues/15167
2023-07-11 13:51:33 +00:00
if( aItem->Type() != SCH_SHEET_T
&& aItem->GetParent() && aItem->GetParent()->IsType( { SCH_SYMBOL_T, LIB_SYMBOL_T,
SCH_SHEET_T,
SCH_LABEL_LOCATE_ANY_T } ) )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
aItem = aItem->GetParent();
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
aChangeType = CHT_MODIFY;
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
}
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
// IS_SELECTED flag should not be set on undo items which were added for
// a drag operation.
if( aItem->IsSelected() && aItem->HasFlag( SELECTED_BY_DRAG ) )
{
aItem->ClearSelected();
COMMIT::Stage( aItem, aChangeType, aScreen );
aItem->SetSelected();
}
else
{
COMMIT::Stage( aItem, aChangeType, aScreen );
}
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
return *this;
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
COMMIT& SCH_COMMIT::Stage( std::vector<EDA_ITEM*> &container, CHANGE_TYPE aChangeType,
BASE_SCREEN *aScreen )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
for( EDA_ITEM* item : container )
Stage( item, aChangeType, aScreen );
return *this;
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
COMMIT& SCH_COMMIT::Stage( const PICKED_ITEMS_LIST &aItems, UNDO_REDO aModFlag,
BASE_SCREEN *aScreen )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
return COMMIT::Stage( aItems, aModFlag, aScreen );
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
void SCH_COMMIT::pushLibEdit( const wxString& aMessage, int aCommitFlags )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
KIGFX::VIEW* view = m_toolMgr->GetView();
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
SYMBOL_EDIT_FRAME* frame = static_cast<SYMBOL_EDIT_FRAME*>( m_toolMgr->GetToolHolder() );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
if( Empty() )
return;
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
// Symbol editor just saves copies of the whole symbol, so grab the first and discard the rest
LIB_SYMBOL* symbol = dynamic_cast<LIB_SYMBOL*>( m_changes.front().m_item );
LIB_SYMBOL* copy = dynamic_cast<LIB_SYMBOL*>( m_changes.front().m_copy );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( symbol )
{
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
if( view )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
view->Update( symbol );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
symbol->RunOnChildren(
[&]( LIB_ITEM* aChild )
{
view->Update( aChild );
});
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
}
Stop confusing Covertiy.
2023-06-10 10:16:55 +00:00
if( !( aCommitFlags & SKIP_UNDO ) )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( frame && copy )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
Keep selected flags on undo/redo items. Also fixes a memory leak in Symbol Editor undo/redo. Also moves a few more things to SCH_COMMIT. Also fixes a couple of LIB_ITEM::Clone() methods that were failing to return the same uuid.
2023-12-22 17:30:14 +00:00
frame->PushSymbolToUndoList( aMessage, copy );
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
copy = nullptr; // we've transferred ownership to the undo stack
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
}
}
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( copy )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
// if no undo entry was needed, the copy would create a memory leak
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
delete copy;
copy = nullptr;
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
}
}
m_toolMgr->PostEvent( { TC_MESSAGE, TA_MODEL_CHANGE, AS_GLOBAL } );
More undo cleanup. The symbol editor has few enough items that it will still be performant if we always send a selected-item-modifed event. (As it turns out we were doing that anyway as the check for child-modified flags didn't also check for selected.)
2023-07-15 21:23:36 +00:00
m_toolMgr->ProcessEvent( EVENTS::SelectedItemsModified );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Stop confusing Covertiy.
2023-06-10 10:16:55 +00:00
if( !( aCommitFlags & SKIP_SET_DIRTY ) )
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
{
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( frame )
frame->OnModify();
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
}
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
for( size_t ii = 1; ii < m_changes.size(); ++ii )
delete m_changes[ii].m_copy;
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
clear();
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
void SCH_COMMIT::pushSchEdit( const wxString& aMessage, int aCommitFlags )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
// Objects potentially interested in changes:
PICKED_ITEMS_LIST undoList;
KIGFX::VIEW* view = m_toolMgr->GetView();
SCH_EDIT_FRAME* frame = static_cast<SCH_EDIT_FRAME*>( m_toolMgr->GetToolHolder() );
EE_SELECTION_TOOL* selTool = m_toolMgr->GetTool<EE_SELECTION_TOOL>();
bool itemsDeselected = false;
bool selectedModified = false;
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
bool dirtyConnectivity = false;
Incremental schematic connectivity fixes.
2024-01-21 16:53:05 +00:00
SCH_CLEANUP_FLAGS connectivityCleanUp = NO_CLEANUP;
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
if( Empty() )
return;
Add action info to Undo/Redo menus. Note that this only works where a BOARD_COMMIT or SCHEMATIC_COMMIT is used. (BOARD_COMMIT is used almost universally in PCBNew, but SCHEMATIC_COMMIT has very little adoption in EEschema so far.)
2023-06-07 13:35:25 +00:00
undoList.SetDescription( aMessage );
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
SCHEMATIC* schematic = nullptr;
std::vector<SCH_ITEM*> bulkAddedItems;
std::vector<SCH_ITEM*> bulkRemovedItems;
std::vector<SCH_ITEM*> itemsChanged;
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
for( COMMIT_LINE& ent : m_changes )
{
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
int changeType = ent.m_type & CHT_TYPE;
int changeFlags = ent.m_type & CHT_FLAGS;
SCH_ITEM* schItem = dynamic_cast<SCH_ITEM*>( ent.m_item );
SCH_SCREEN* screen = dynamic_cast<SCH_SCREEN*>( ent.m_screen );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
wxCHECK2( schItem && screen, continue );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
if( !schematic )
schematic = schItem->Schematic();
if( schItem->IsSelected() )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
selectedModified = true;
Fix assertion when pasting schematic sheets. Pasted sheets do not have assigned SCH_SCREEN objects until after they are loaded. Do not recalculate connectivity unless the SCH_COMMIT object actually has connectable schematic object changes. Fixes https://gitlab.com/kicad/code/kicad/-/issues/16579
2024-01-15 17:15:30 +00:00
if( !( aCommitFlags & SKIP_CONNECTIVITY ) && schItem->IsConnectable() )
Incremental schematic connectivity fixes.
2024-01-21 16:53:05 +00:00
{
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
dirtyConnectivity = true;
Incremental schematic connectivity fixes.
2024-01-21 16:53:05 +00:00
// Do a local clean up if there are any connectable objects in the commit.
if( connectivityCleanUp == NO_CLEANUP )
connectivityCleanUp = LOCAL_CLEANUP;
// Do a full rebauild of the connectivity if there is a sheet in the commit.
if( schItem->Type() == SCH_SHEET_T )
connectivityCleanUp = GLOBAL_CLEANUP;
}
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
switch( changeType )
{
case CHT_ADD:
{
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
if( !( aCommitFlags & SKIP_UNDO ) )
undoList.PushItem( ITEM_PICKER( screen, schItem, UNDO_REDO::NEWITEM ) );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
if( !( changeFlags & CHT_DONE ) )
{
Fine-tune SCH_COMMIT handling of child objects. While a SCH_SHEET does indeed have a SCH_SHEET parent, it's not one of the children that gets added as a CHT_MODIFY of its parent. Also fixes a bug where the newly drawn sheet gets removed from the preview before running the dialog. Fixes https://gitlab.com/kicad/code/kicad/-/issues/14976
2023-06-18 15:36:28 +00:00
if( !screen->CheckIfOnDrawList( schItem ) ) // don't want a loop!
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
screen->Append( schItem );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
if( view )
view->Add( schItem );
}
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Move item updating and view refresh to SCH_COMMIT::Push(). Fixes https://gitlab.com/kicad/code/kicad/-/issues/15132
2023-07-07 14:34:43 +00:00
if( frame )
frame->UpdateItem( schItem, true, true );
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
bulkAddedItems.push_back( schItem );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
break;
}
case CHT_REMOVE:
{
if( !( aCommitFlags & SKIP_UNDO ) )
undoList.PushItem( ITEM_PICKER( screen, schItem, UNDO_REDO::DELETED ) );
if( schItem->IsSelected() )
{
if( selTool )
selTool->RemoveItemFromSel( schItem, true /* quiet mode */ );
itemsDeselected = true;
}
if( schItem->Type() == SCH_FIELD_T )
{
static_cast<SCH_FIELD*>( schItem )->SetVisible( false );
break;
}
if( !( changeFlags & CHT_DONE ) )
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
{
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
screen->Remove( schItem );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
if( view )
view->Remove( schItem );
}
Move item updating and view refresh to SCH_COMMIT::Push(). Fixes https://gitlab.com/kicad/code/kicad/-/issues/15132
2023-07-07 14:34:43 +00:00
if( frame )
frame->UpdateItem( schItem, true, true );
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
bulkRemovedItems.push_back( schItem );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
break;
}
case CHT_MODIFY:
{
if( !( aCommitFlags & SKIP_UNDO ) )
{
ITEM_PICKER itemWrapper( screen, schItem, UNDO_REDO::CHANGED );
wxASSERT( ent.m_copy );
itemWrapper.SetLink( ent.m_copy );
undoList.PushItem( itemWrapper );
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
ent.m_copy = nullptr; // We've transferred ownership to the undo list
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
}
Move item updating and view refresh to SCH_COMMIT::Push(). Fixes https://gitlab.com/kicad/code/kicad/-/issues/15132
2023-07-07 14:34:43 +00:00
if( frame )
frame->UpdateItem( schItem, false, true );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
itemsChanged.push_back( schItem );
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
if( ent.m_copy )
{
// if no undo entry is needed, the copy would create a memory leak
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
delete ent.m_copy;
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
ent.m_copy = nullptr;
}
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
break;
}
default:
wxASSERT( false );
break;
}
Clear IS_MOVING (as well as IS_NEW) in SCH_COMMIT::Push(). Fixes https://gitlab.com/kicad/code/kicad/-/issues/15051
2023-06-24 16:06:57 +00:00
SCH_COMMIT: when clearing all item flags, do not clear all item flags. If a item is selected, its SELECTED, STARTPOINT and ENDPOINT flags cannot be cleared, and must be still selected after changes to allow more move, rotate... commands. Fix to previous commit 741c6f2d
2023-10-05 14:46:04 +00:00
// Clear all flags but SELECTED and others used to move and rotate commands,
// after edition (selected items must keep their selection flag).
const int selected_mask = ( SELECTED | STARTPOINT | ENDPOINT );
SCH_COMMIT: when clearing all item flags, do not clear SELECTED item flags. If a item is selected, its SELECTED flag cannot be cleared without managing selections stored in tools, and must be still selected after changes. Fixes #15671 https://gitlab.com/kicad/code/kicad/-/issues/15671
2023-09-24 09:07:04 +00:00
schItem->ClearFlags( EDA_ITEM_ALL_FLAGS - selected_mask );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
}
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
if( schematic )
{
if( bulkAddedItems.size() > 0 )
schematic->OnItemsAdded( bulkAddedItems );
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
if( bulkRemovedItems.size() > 0 )
schematic->OnItemsRemoved( bulkRemovedItems );
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
if( itemsChanged.size() > 0 )
schematic->OnItemsChanged( itemsChanged );
}
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
if( !( aCommitFlags & SKIP_UNDO ) )
Upgrade some dialogs to SCHEMATIC_COMMIT.
2023-06-07 22:45:06 +00:00
{
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
if( frame )
Update TestDanglingEnds to O(n) speed The elements don't care which they connect to, so don't search for points on the page, just collect them all and then test them all Adjusts f3dd5b73
2023-08-30 21:21:58 +00:00
{
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
frame->SaveCopyInUndoList( undoList, UNDO_REDO::UNSPECIFIED, false, dirtyConnectivity );
Fix assertion when pasting schematic sheets. Pasted sheets do not have assigned SCH_SCREEN objects until after they are loaded. Do not recalculate connectivity unless the SCH_COMMIT object actually has connectable schematic object changes. Fixes https://gitlab.com/kicad/code/kicad/-/issues/16579
2024-01-15 17:15:30 +00:00
if( dirtyConnectivity )
Incremental schematic connectivity fixes.
2024-01-21 16:53:05 +00:00
frame->RecalculateConnections( this, connectivityCleanUp );
Update TestDanglingEnds to O(n) speed The elements don't care which they connect to, so don't search for points on the page, just collect them all and then test them all Adjusts f3dd5b73
2023-08-30 21:21:58 +00:00
}
Upgrade some dialogs to SCHEMATIC_COMMIT.
2023-06-07 22:45:06 +00:00
}
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
m_toolMgr->PostEvent( { TC_MESSAGE, TA_MODEL_CHANGE, AS_GLOBAL } );
if( itemsDeselected )
m_toolMgr->PostEvent( EVENTS::UnselectedEvent );
if( selectedModified )
m_toolMgr->ProcessEvent( EVENTS::SelectedItemsModified );
Move item updating and view refresh to SCH_COMMIT::Push(). Fixes https://gitlab.com/kicad/code/kicad/-/issues/15132
2023-07-07 14:34:43 +00:00
if( frame && frame->GetCanvas() )
frame->GetCanvas()->Refresh();
Allow SCH_COMMIT to operate without a frame. We'll want this at some point (presumably) for plugins.
2023-06-10 17:35:59 +00:00
if( !( aCommitFlags & SKIP_SET_DIRTY ) )
{
if( frame )
frame->OnModify();
}
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
clear();
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
void SCH_COMMIT::Push( const wxString& aMessage, int aCommitFlags )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
if( m_isLibEditor )
pushLibEdit( aMessage, aCommitFlags );
else
pushSchEdit( aMessage, aCommitFlags );
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
EDA_ITEM* SCH_COMMIT::parentObject( EDA_ITEM* aItem ) const
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
Eradicate a bunch of calls to dyn_cast.
2023-06-24 17:19:44 +00:00
EDA_ITEM* parent = aItem->GetParent();
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Eradicate a bunch of calls to dyn_cast.
2023-06-24 17:19:44 +00:00
if( parent && parent->Type() == SCH_SYMBOL_T )
return parent;
if( parent && parent->Type() == LIB_SYMBOL_T )
return parent;
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
if( m_isLibEditor )
return static_cast<SYMBOL_EDIT_FRAME*>( m_toolMgr->GetToolHolder() )->GetCurSymbol();
return aItem;
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
EDA_ITEM* SCH_COMMIT::makeImage( EDA_ITEM* aItem ) const
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
if( m_isLibEditor )
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
{
SYMBOL_EDIT_FRAME* frame = static_cast<SYMBOL_EDIT_FRAME*>( m_toolMgr->GetToolHolder() );
Keep selected flags on undo/redo items. Also fixes a memory leak in Symbol Editor undo/redo. Also moves a few more things to SCH_COMMIT. Also fixes a couple of LIB_ITEM::Clone() methods that were failing to return the same uuid.
2023-12-22 17:30:14 +00:00
LIB_SYMBOL* symbol = frame->GetCurSymbol();
std::vector<KIID> selected;
for( const LIB_ITEM& item : symbol->GetDrawItems() )
{
if( item.IsSelected() )
selected.push_back( item.m_Uuid );
}
symbol = new LIB_SYMBOL( *symbol );
for( LIB_ITEM& item : symbol->GetDrawItems() )
{
if( alg::contains( selected, item.m_Uuid ) )
item.SetSelected();
}
return symbol;
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
}
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
return aItem->Clone();
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
void SCH_COMMIT::revertLibEdit()
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( Empty() )
return;
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
// Symbol editor just saves copies of the whole symbol, so grab the first and discard the rest
SYMBOL_EDIT_FRAME* frame = dynamic_cast<SYMBOL_EDIT_FRAME*>( m_toolMgr->GetToolHolder() );
LIB_SYMBOL* copy = dynamic_cast<LIB_SYMBOL*>( m_changes.front().m_copy );
Support synchronous move in symbol editor. Also removes duplicate-during-move. It's not really compatibile with a passed-in SCH_COMMIT, and it was never clear it was worth the code. Fixes https://gitlab.com/kicad/code/kicad/-/issues/14274
2023-07-01 21:35:39 +00:00
EE_SELECTION_TOOL* selTool = m_toolMgr->GetTool<EE_SELECTION_TOOL>();
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( frame && copy )
{
frame->SetCurSymbol( copy, false );
m_toolMgr->ResetTools( TOOL_BASE::MODEL_RELOAD );
}
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
for( size_t ii = 1; ii < m_changes.size(); ++ii )
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
delete m_changes[ii].m_copy;
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Support synchronous move in symbol editor. Also removes duplicate-during-move. It's not really compatibile with a passed-in SCH_COMMIT, and it was never clear it was worth the code. Fixes https://gitlab.com/kicad/code/kicad/-/issues/14274
2023-07-01 21:35:39 +00:00
if( selTool )
selTool->RebuildSelection();
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
clear();
}
Upgrade some symbol editor stuff to SCHEMATIC_COMMIT. Also renames SCHEMATIC_COMMIT to SCH_COMMIT since it's not schematic-specifc.
2023-06-09 21:41:33 +00:00
void SCH_COMMIT::Revert()
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
KIGFX::VIEW* view = m_toolMgr->GetView();
SCH_EDIT_FRAME* frame = dynamic_cast<SCH_EDIT_FRAME*>( m_toolMgr->GetToolHolder() );
EE_SELECTION_TOOL* selTool = m_toolMgr->GetTool<EE_SELECTION_TOOL>();
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
if( m_changes.empty() )
return;
if( m_isLibEditor )
{
revertLibEdit();
return;
}
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
SCHEMATIC* schematic = nullptr;
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
std::vector<SCH_ITEM*> bulkAddedItems;
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
std::vector<SCH_ITEM*> bulkRemovedItems;
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
std::vector<SCH_ITEM*> itemsChanged;
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
for( COMMIT_LINE& ent : m_changes )
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
{
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
int changeType = ent.m_type & CHT_TYPE;
int changeFlags = ent.m_type & CHT_FLAGS;
SCH_ITEM* item = dynamic_cast<SCH_ITEM*>( ent.m_item );
SCH_ITEM* copy = dynamic_cast<SCH_ITEM*>( ent.m_copy );
SCH_SCREEN* screen = dynamic_cast<SCH_SCREEN*>( ent.m_screen );
wxCHECK2( item && screen, continue );
if( !schematic )
schematic = item->Schematic();
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
switch( changeType )
{
case CHT_ADD:
if( !( changeFlags & CHT_DONE ) )
break;
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( view )
view->Remove( item );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
screen->Remove( item );
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
bulkRemovedItems.push_back( item );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
break;
case CHT_REMOVE:
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
item->SetConnectivityDirty();
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
if( !( changeFlags & CHT_DONE ) )
break;
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( view )
view->Add( item );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
screen->Append( item );
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
bulkAddedItems.push_back( item );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
break;
case CHT_MODIFY:
{
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( view )
view->Remove( item );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
item->SwapData( copy );
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
item->SetConnectivityDirty();
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
// Special cases for items which have instance data
if( item->GetParent() && item->GetParent()->Type() == SCH_SYMBOL_T
&& item->Type() == SCH_FIELD_T )
{
SCH_FIELD* field = static_cast<SCH_FIELD*>( item );
SCH_SYMBOL* symbol = static_cast<SCH_SYMBOL*>( item->GetParent() );
if( field->GetId() == REFERENCE_FIELD )
{
Don't store address of temp object. Fixes https://gitlab.com/kicad/code/kicad/-/issues/15517
2023-08-27 18:02:12 +00:00
SCH_SHEET_PATH sheet = schematic->GetSheets().FindSheetForScreen( screen );
symbol->SetRef( &sheet, field->GetText() );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
}
}
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( view )
view->Add( item );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
Move TestDanglingEnds() to SCH_COMMIT. Also fixes a bug where Convert Symbol wasn't undoable. Also cleans up some SetModified() call no longer needed with SCH_COMMIT. Also fixes bug where revert of a modification didn't update the screen's RTree. Fixes https://gitlab.com/kicad/code/kicad/-/issues/15030
2023-06-23 18:59:18 +00:00
screen->Update( item );
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
delete copy;
break;
}
default:
wxASSERT( false );
break;
}
}
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( schematic )
{
if( bulkAddedItems.size() > 0 )
schematic->OnItemsAdded( bulkAddedItems );
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( bulkRemovedItems.size() > 0 )
schematic->OnItemsRemoved( bulkRemovedItems );
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( itemsChanged.size() > 0 )
schematic->OnItemsChanged( itemsChanged );
}
Add SCHEMATIC_LISTENER equivalent to BOARD_LISTENER
2023-05-11 02:53:10 +00:00
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( selTool )
selTool->RebuildSelection();
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
if( frame )
Move TestDanglingEnds() to SCH_COMMIT. Also fixes a bug where Convert Symbol wasn't undoable. Also cleans up some SetModified() call no longer needed with SCH_COMMIT. Also fixes bug where revert of a modification didn't update the screen's RTree. Fixes https://gitlab.com/kicad/code/kicad/-/issues/15030
2023-06-23 18:59:18 +00:00
{
More changes for SCH_COMMIT independence from frames. Also fixes some bugs in Symbol Editor SCH_COMMIT::Revert().
2023-06-10 18:02:49 +00:00
frame->RecalculateConnections( nullptr, NO_CLEANUP );
Move TestDanglingEnds() to SCH_COMMIT. Also fixes a bug where Convert Symbol wasn't undoable. Also cleans up some SetModified() call no longer needed with SCH_COMMIT. Also fixes bug where revert of a modification didn't update the screen's RTree. Fixes https://gitlab.com/kicad/code/kicad/-/issues/15030
2023-06-23 18:59:18 +00:00
}
Upgrade many editing actions to SCHEMATIC_COMMIT.
2023-06-09 16:24:49 +00:00
Add COMMIT structure to Schematic and Symbol editors Provides a single-point access for modifying the schematic and symbol elements that allows chaining updates and reverting partial changes. Standardizes the undo hierarchy between pcb and schematic editors As this is another layer on the existing undo/redo structure, the initial commit does not replace all undo/redo calls currently existing. These will be handled in a series of follow-on commits
2023-04-29 00:02:42 +00:00
clear();
}