Mirrors
/
kicad
mirror of https://github.com/KiCad/kicad-source-mirror
3
0
Fork 0
Code Releases Activity
Browse Source

undo-redo rework

pull/1/head
charras 16 years ago
parent
f21d7bc675
commit
9d6daf5665
13 changed files with 340 additions and 498 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      common/CMakeLists.txt
  2. 2
      common/about_kicad.cpp
  3. 106
      common/base_screen.cpp
  4. 60
      eeschema/libedit_undo_redo.cpp
  5. 4
      eeschema/libframe.cpp
  6. 514
      eeschema/schematic_undo_redo.cpp
  7. 4
      eeschema/schframe.cpp
  8. 44
      include/base_struct.h
  9. 26
      include/class_base_screen.h
  10. 17
      include/class_sch_screen.h
  11. 3
      include/wxEeschemaStruct.h
  12. 53
      pcbnew/modedit_undo_redo.cpp
  13. 4
      pcbnew/moduleframe.cpp

1
common/CMakeLists.txt
View File

@ -14,6 +14,7 @@ set(COMMON_SRCS
block_commande.cpp
class_drawpickedstruct.cpp
class_marker_base.cpp
class_undoredo_container.cpp
common.cpp
common_plot_functions.cpp
common_plotHPGL_functions.cpp

2
common/about_kicad.cpp
View File

@ -8,7 +8,7 @@
#include "appl_wxstruct.h"
#define BUILD_VERSION "(20090712-unstable)"
#define BUILD_VERSION "(20090723-unstable)"
#ifdef HAVE_SVN_VERSION

106
common/base_screen.cpp
View File

@ -28,9 +28,7 @@ BASE_SCREEN* ActiveScreen = NULL;
BASE_SCREEN::BASE_SCREEN( KICAD_T aType ) : EDA_BaseStruct( aType )
{
EEDrawList = NULL; /* Schematic items list */
m_UndoList = NULL;
m_RedoList = NULL;
m_UndoRedoCountMax = 1;
m_UndoRedoCountMax = 1; /* undo/Redo command Max depth */
m_FirstRedraw = TRUE;
m_ScreenNumber = 1;
m_NumberOfScreen = 1; /* Hierarchy: Root: ScreenNumber = 1 */
@ -486,121 +484,57 @@ void BASE_SCREEN::ClearUndoRedoList()
/* free the undo and the redo lists
*/
{
EDA_BaseStruct* nextitem;
while( m_UndoList )
{
nextitem = m_UndoList->Next();
delete m_UndoList;
m_UndoList = nextitem;
}
while( m_RedoList )
{
nextitem = m_RedoList->Next();
delete m_RedoList;
m_RedoList = nextitem;
}
m_UndoList.ClearCommandList();
m_RedoList.ClearCommandList();
}
/***********************************************************/
void BASE_SCREEN::AddItemToUndoList( EDA_BaseStruct* newitem )
void BASE_SCREEN::PushCommandToUndoList( PICKED_ITEMS_LIST* aNewitem )
/************************************************************/
/* Put newitem in head of undo list
/* Put aNewitem in top of undo list
* Deletes olds items if > count max.
*/
{
int ii;
EDA_BaseStruct* item;
EDA_BaseStruct* nextitem;
if( newitem == NULL )
return;
newitem->SetNext( m_UndoList );
m_UndoList = newitem;
/* Free first items, if count max reached */
for( ii = 0, item = m_UndoList; ii < m_UndoRedoCountMax; ii++ )
m_UndoList.PushCommand(aNewitem);
while( m_UndoList.m_CommandsList.size() > 0 &&
m_UndoList.m_CommandsList.size() >= m_UndoRedoCountMax )
{
if( item->Next() == NULL )
return;
item = item->Next();
delete m_UndoList.m_CommandsList[0];
m_UndoList.m_CommandsList.erase( m_UndoList.m_CommandsList.begin() );
}
if( item == NULL )
return;
nextitem = item->Next();
item->SetNext( NULL ); // Set end of chain
// Delete the extra items
for( item = nextitem; item != NULL; item = nextitem )
{
nextitem = item->Next();
delete item;
}
}
/***********************************************************/
void BASE_SCREEN::AddItemToRedoList( EDA_BaseStruct* newitem )
void BASE_SCREEN::PushCommandToRedoList( PICKED_ITEMS_LIST* aNewitem )
/***********************************************************/
{
int ii;
EDA_BaseStruct* item, * nextitem;
if( newitem == NULL )
return;
newitem->SetNext( m_RedoList );
m_RedoList = newitem;
/* Free first items, if count max reached */
for( ii = 0, item = m_RedoList; ii < m_UndoRedoCountMax; ii++ )
m_RedoList.PushCommand(aNewitem);
while( m_RedoList.m_CommandsList.size() > 0 &&
m_RedoList.m_CommandsList.size() >= m_UndoRedoCountMax )
{
if( item->Next() == NULL )
break;
item = item->Next();
}
if( item == NULL )
return;
nextitem = item->Next();
item->SetNext( NULL ); // Set end of chain
// Delete the extra items
for( item = nextitem; item != NULL; item = nextitem )
{
nextitem = item->Next();
delete item;
delete m_RedoList.m_CommandsList[0];
m_RedoList.m_CommandsList.erase( m_RedoList.m_CommandsList.begin() );
}
}
/*****************************************************/
EDA_BaseStruct* BASE_SCREEN::GetItemFromUndoList()
PICKED_ITEMS_LIST* BASE_SCREEN::PopCommandFromUndoList( )
/*****************************************************/
{
EDA_BaseStruct* item = m_UndoList;
if( item )
m_UndoList = item->Next();
return item;
return m_UndoList.PopCommand( );
}
/******************************************************/
EDA_BaseStruct* BASE_SCREEN::GetItemFromRedoList()
PICKED_ITEMS_LIST* BASE_SCREEN::PopCommandFromRedoList( )
/******************************************************/
{
EDA_BaseStruct* item = m_RedoList;
if( item )
m_RedoList = item->Next();
return item;
return m_RedoList.PopCommand( );
}

60
eeschema/libedit_undo_redo.cpp
View File

@ -21,19 +21,29 @@ void WinEDA_LibeditFrame::SaveCopyInUndoList( EDA_BaseStruct* ItemToCopy,
{
EDA_BaseStruct* item;
EDA_LibComponentStruct* CopyItem;
PICKED_ITEMS_LIST* lastcmd;
CopyItem = CopyLibEntryStruct( this, (EDA_LibComponentStruct*) ItemToCopy );
GetScreen()->AddItemToUndoList( (EDA_BaseStruct*) CopyItem );
lastcmd = new PICKED_ITEMS_LIST();
ITEM_PICKER wrapper(CopyItem);
lastcmd->PushItem(wrapper);
GetScreen()->PushCommandToUndoList( lastcmd );
/* Clear current flags (which can be temporary set by a current edit command) */
for( item = CopyItem->m_Drawings; item != NULL; item = item->Next() )
item->m_Flags = 0;
/* Clear redo list, because after new save there is no redo to do */
while( GetScreen()->m_RedoList )
while( (lastcmd = GetScreen()->PopCommandFromRedoList( ) ) != NULL )
{
item = GetScreen()->m_RedoList->Next();
delete( GetScreen()->m_RedoList );
GetScreen()->m_RedoList = item;
while ( 1 )
{
wrapper = lastcmd->PopItem();
if ( wrapper.m_Item == NULL )
break; // All items are removed
delete wrapper.m_Item;
}
delete lastcmd;
}
}
@ -45,15 +55,21 @@ bool WinEDA_LibeditFrame::GetComponentFromRedoList()
/* Redo the last edition:
* - Place the current edited library component in undo list
* - Get old version of the current edited library component
* @return FALSE if nothing done, else TRUE
* @return FALSE if nothing done, else true
*/
{
if( GetScreen()->m_RedoList == NULL )
return FALSE;
if ( GetScreen()->GetRedoCommandCount() <= 0 )
return false;
PICKED_ITEMS_LIST* lastcmd = new PICKED_ITEMS_LIST();
ITEM_PICKER wrapper(CurrentLibEntry);
lastcmd->PushItem(wrapper);
GetScreen()->PushCommandToUndoList( lastcmd );
lastcmd = GetScreen()->PopCommandFromRedoList( );
GetScreen()->AddItemToUndoList( (EDA_BaseStruct*) CurrentLibEntry );
CurrentLibEntry =
(EDA_LibComponentStruct*) GetScreen()->GetItemFromRedoList();
wrapper = lastcmd->PopItem();
CurrentLibEntry = (EDA_LibComponentStruct*) wrapper.m_Item;
if( CurrentLibEntry )
CurrentLibEntry->SetNext( NULL );
CurrentDrawItem = NULL;
@ -61,7 +77,7 @@ bool WinEDA_LibeditFrame::GetComponentFromRedoList()
ReCreateHToolbar();
SetToolbars();
return TRUE;
return true;
}
@ -72,15 +88,21 @@ bool WinEDA_LibeditFrame::GetComponentFromUndoList()
/* Undo the last edition:
* - Place the current edited library component in Redo list
* - Get old version of the current edited library component
* @return FALSE if nothing done, else TRUE
* @return FALSE if nothing done, else true
*/
{
if( GetScreen()->m_UndoList == NULL )
return FALSE;
if ( GetScreen()->GetUndoCommandCount() <= 0 )
return false;
PICKED_ITEMS_LIST* lastcmd = new PICKED_ITEMS_LIST();
ITEM_PICKER wrapper(CurrentLibEntry);
lastcmd->PushItem(wrapper);
GetScreen()->PushCommandToRedoList( lastcmd );
lastcmd = GetScreen()->PopCommandFromUndoList( );
GetScreen()->AddItemToRedoList( (EDA_BaseStruct*) CurrentLibEntry );
CurrentLibEntry =
(EDA_LibComponentStruct*) GetScreen()->GetItemFromUndoList();
wrapper = lastcmd->PopItem();
CurrentLibEntry = (EDA_LibComponentStruct*) wrapper.m_Item;
if( CurrentLibEntry )
CurrentLibEntry->SetNext( NULL );
@ -89,5 +111,5 @@ bool WinEDA_LibeditFrame::GetComponentFromUndoList()
ReCreateHToolbar();
SetToolbars();
return TRUE;
return true;
}

4
eeschema/libframe.cpp
View File

@ -279,8 +279,8 @@ void WinEDA_LibeditFrame::SetToolbars()
if( GetScreen() )
{
m_HToolBar->EnableTool( ID_LIBEDIT_UNDO, GetScreen()->m_UndoList );
m_HToolBar->EnableTool( ID_LIBEDIT_REDO, GetScreen()->m_RedoList );
m_HToolBar->EnableTool( ID_LIBEDIT_UNDO, GetScreen()->GetUndoCommandCount() );
m_HToolBar->EnableTool( ID_LIBEDIT_REDO, GetScreen()->GetRedoCommandCount() );
}
}

514
eeschema/schematic_undo_redo.cpp
View File

@ -60,33 +60,33 @@
/************************************/
void SwapData( EDA_BaseStruct* Item )
void SwapData( EDA_BaseStruct* aItem, EDA_BaseStruct* aImage )
/************************************/
/* Used if undo / redo command:
* swap data between Item and its copy, pointed by its .m_Image member
*/
{
if( Item == NULL )
return;
EDA_BaseStruct* image = Item->m_Image;
if( image == NULL )
if( aItem == NULL || aImage == NULL )
{
wxMessageBox(wxT("SwapData error: NULL pointer"));
return;
}
switch( Item->Type() )
switch( aItem->Type() )
{
case DRAW_POLYLINE_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawPolylineStruct*) Item )
#define DEST ( (DrawPolylineStruct*) image )
#define SOURCE ( (DrawPolylineStruct*) aItem )
#define DEST ( (DrawPolylineStruct*) aImage )
break;
case DRAW_JUNCTION_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawJunctionStruct*) Item )
#define DEST ( (DrawJunctionStruct*) image )
#define SOURCE ( (DrawJunctionStruct*) aItem )
#define DEST ( (DrawJunctionStruct*) aImage )
EXCHG( SOURCE->m_Pos, DEST->m_Pos );
break;
@ -96,24 +96,24 @@ void SwapData( EDA_BaseStruct* Item )
case TYPE_SCH_TEXT:
#undef SOURCE
#undef DEST
#define SOURCE ( (SCH_TEXT*) Item )
#define DEST ( (SCH_TEXT*) image )
#define SOURCE ( (SCH_TEXT*) aItem )
#define DEST ( (SCH_TEXT*) aImage )
DEST->SwapData( SOURCE );
break;
case TYPE_SCH_COMPONENT:
#undef SOURCE
#undef DEST
#define SOURCE ( (SCH_COMPONENT*) Item )
#define DEST ( (SCH_COMPONENT*) image )
#define SOURCE ( (SCH_COMPONENT*) aItem )
#define DEST ( (SCH_COMPONENT*) aImage )
DEST->SwapData( SOURCE );
break;
case DRAW_SEGMENT_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (EDA_DrawLineStruct*) Item )
#define DEST ( (EDA_DrawLineStruct*) image )
#define SOURCE ( (EDA_DrawLineStruct*) aItem )
#define DEST ( (EDA_DrawLineStruct*) aImage )
EXCHG( SOURCE->m_Start, DEST->m_Start );
EXCHG( SOURCE->m_End, DEST->m_End );
break;
@ -121,8 +121,8 @@ void SwapData( EDA_BaseStruct* Item )
case DRAW_BUSENTRY_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawBusEntryStruct*) Item )
#define DEST ( (DrawBusEntryStruct*) image )
#define SOURCE ( (DrawBusEntryStruct*) aItem )
#define DEST ( (DrawBusEntryStruct*) aImage )
EXCHG( SOURCE->m_Pos, DEST->m_Pos );
EXCHG( SOURCE->m_Size, DEST->m_Size );
break;
@ -130,24 +130,24 @@ void SwapData( EDA_BaseStruct* Item )
case DRAW_SHEET_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawSheetStruct*) Item )
#define DEST ( (DrawSheetStruct*) image )
#define SOURCE ( (DrawSheetStruct*) aItem )
#define DEST ( (DrawSheetStruct*) aImage )
DEST->SwapData( SOURCE );
break;
case DRAW_MARKER_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (MARKER_SCH*) Item )
#define DEST ( (MARKER_SCH*) image )
#define SOURCE ( (MARKER_SCH*) aItem )
#define DEST ( (MARKER_SCH*) aImage )
EXCHG( SOURCE->m_Pos, DEST->m_Pos );
break;
case DRAW_HIERARCHICAL_PIN_SHEET_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (Hierarchical_PIN_Sheet_Struct*) Item )
#define DEST ( (Hierarchical_PIN_Sheet_Struct*) image )
#define SOURCE ( (Hierarchical_PIN_Sheet_Struct*) aItem )
#define DEST ( (Hierarchical_PIN_Sheet_Struct*) aImage )
EXCHG( SOURCE->m_Edge, DEST->m_Edge );
EXCHG( SOURCE->m_Shape, DEST->m_Shape );
break;
@ -155,19 +155,15 @@ void SwapData( EDA_BaseStruct* Item )
case DRAW_NOCONNECT_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawNoConnectStruct*) Item )
#define DEST ( (DrawNoConnectStruct*) image )
#define SOURCE ( (DrawNoConnectStruct*) aItem )
#define DEST ( (DrawNoConnectStruct*) aImage )
EXCHG( SOURCE->m_Pos, DEST->m_Pos );
break;
case DRAW_PART_TEXT_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawPolylineStruct*) Item )
#define DEST ( (DrawPolylineStruct*) image )
break;
// not directly used in schematic:
// not directly used in schematic:
default:
DisplayInfoMessage( NULL, wxT( "SwapData() error: unexpected type" ) );
break;
@ -176,8 +172,8 @@ void SwapData( EDA_BaseStruct* Item )
/***********************************************************************/
void WinEDA_SchematicFrame::SaveCopyInUndoList( SCH_ITEM * ItemToCopy,
int flag_type_command )
void WinEDA_SchematicFrame::SaveCopyInUndoList( SCH_ITEM* ItemToCopy,
int flag_type_command )
/***********************************************************************/
/* Create a copy of the current schematic draw list, and put it in the undo list.
@ -205,11 +201,11 @@ void WinEDA_SchematicFrame::SaveCopyInUndoList( SCH_ITEM * ItemToCopy,
* saved in Undo List (for Undo or Redo commands, saved wires will be exchanged with current wire list
*/
{
SCH_ITEM* CopyItem;
DrawPickedStruct* NewList = new DrawPickedStruct( NULL );
SCH_ITEM* CopyOfItem;
PICKED_ITEMS_LIST* commandToUndo = new PICKED_ITEMS_LIST();
NewList->m_Flags = flag_type_command;
commandToUndo->m_UndoRedoType = flag_type_command;
ITEM_PICKER itemWrapper( ItemToCopy, flag_type_command );
if( ItemToCopy )
{
@ -219,79 +215,107 @@ void WinEDA_SchematicFrame::SaveCopyInUndoList( SCH_ITEM * ItemToCopy,
break;
case IS_CHANGED: /* Create a copy of schematic */
CopyItem = DuplicateStruct( ItemToCopy );
NewList->SetSon( CopyItem );
if( ItemToCopy->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
{
DrawPickedStruct* PickedList = (DrawPickedStruct*) CopyItem;
DrawPickedStruct* PickedList = (DrawPickedStruct*) ItemToCopy;
while( PickedList )
{
CopyItem = (SCH_ITEM*) PickedList->m_PickedStruct;
CopyItem->m_Flags = flag_type_command;
PickedList->m_Image = CopyItem->m_Image;
CopyOfItem = DuplicateStruct( (SCH_ITEM*) PickedList->m_PickedStruct);
CopyOfItem->m_Flags = flag_type_command;
itemWrapper.m_Item = CopyOfItem;
itemWrapper.m_Link = (SCH_ITEM*) PickedList->m_PickedStruct;
commandToUndo->PushItem( itemWrapper );
PickedList = PickedList->Next();
}
}
}
else
{
CopyItem->m_Flags = flag_type_command;
CopyItem->m_Image = ItemToCopy;
CopyOfItem = DuplicateStruct(ItemToCopy);
itemWrapper.m_Item = CopyOfItem;
itemWrapper.m_Link = ItemToCopy;
commandToUndo->PushItem( itemWrapper );
}
break;
case IS_NEW:
if( ItemToCopy->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
{
NewList->SetSon( ItemToCopy );
DrawPickedStruct* PickedList = (DrawPickedStruct*) ItemToCopy;
while( PickedList )
{
CopyItem = (SCH_ITEM*) PickedList->m_PickedStruct;
PickedList->m_Image = CopyItem;
CopyOfItem = (SCH_ITEM*) PickedList->m_PickedStruct;
PickedList->m_PickedStruct = NULL;
PickedList->m_Flags = flag_type_command;
PickedList = PickedList->Next();
itemWrapper.m_Item = CopyOfItem;
commandToUndo->PushItem( itemWrapper );
}
}
else
{
commandToUndo->PushItem( itemWrapper );
}
break;
case IS_NEW | IS_CHANGED: // when more than one item, some are new, some are changed
if( ItemToCopy->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
{
DrawPickedStruct* PickedList = (DrawPickedStruct*) ItemToCopy;
while( PickedList )
{
CopyOfItem = (SCH_ITEM*) PickedList->m_PickedStruct;
PickedList->m_PickedStruct = NULL;
PickedList = PickedList->Next();
itemWrapper.m_Item = CopyOfItem;
itemWrapper.m_UndoRedoStatus = PickedList->m_Flags;
commandToUndo->PushItem( itemWrapper );
}
}
else
{
NewList->m_Image = ItemToCopy;
commandToUndo->PushItem( itemWrapper );
}
break;
case IS_NEW | IS_CHANGED:
case IS_WIRE_IMAGE:
NewList->SetSon( ItemToCopy );
commandToUndo->PushItem( itemWrapper );
break;
case IS_DELETED:
NewList->SetSon( ItemToCopy );
ItemToCopy->m_Flags = flag_type_command;
if( ItemToCopy->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
{
DrawPickedStruct* PickedList = (DrawPickedStruct*) ItemToCopy;
while( PickedList )
{
CopyItem = (SCH_ITEM*) PickedList->m_PickedStruct;
CopyItem->m_Flags = flag_type_command;
CopyOfItem = (SCH_ITEM*) PickedList->m_PickedStruct;
CopyOfItem->m_Flags = flag_type_command;
PickedList->m_Flags = flag_type_command;
PickedList = PickedList->Next();
itemWrapper.m_Item = CopyOfItem;
commandToUndo->PushItem( itemWrapper );
}
}
else
{
commandToUndo->PushItem( itemWrapper );
}
break;
default:
DisplayError( this, wxT( "SaveCopyInUndoList() error" ) );
{
wxString msg;
msg.Printf(wxT( "SaveCopyInUndoList() error (unknown code %X)" ), flag_type_command);
DisplayError( this, msg);
}
break;
}
}
/* Save the copy in undo list */
GetScreen()->AddItemToUndoList( NewList );
GetScreen()->PushCommandToUndoList( commandToUndo );
/* Clear redo list, because after new save there is no redo to do */
( (SCH_SCREEN*) GetScreen() )->ClearUndoORRedoList( GetScreen()->m_RedoList );
GetScreen()->m_RedoList = NULL;
GetScreen()->ClearUndoORRedoList( GetScreen()->m_RedoList );
}
@ -302,15 +326,17 @@ bool WinEDA_SchematicFrame::GetSchematicFromRedoList()
/* Redo the last edition:
* - Save the current schematic in undo list
* - Get the old version
* @return FALSE if nothing done, else true
* @return false if nothing done, else true
*/
{
if( GetScreen()->m_RedoList == NULL )
return FALSE;
if( GetScreen()->GetRedoCommandCount() == 0 )
return false;
/* Get the old wrapper and put it in UndoList */
DrawPickedStruct* List = (DrawPickedStruct*) GetScreen()->GetItemFromRedoList();
GetScreen()->AddItemToUndoList( List );
PICKED_ITEMS_LIST* List = GetScreen()->PopCommandFromRedoList();
GetScreen()->PushCommandToUndoList( List );
/* Redo the command: */
PutDataInPreviousState( List );
@ -325,148 +351,64 @@ bool WinEDA_SchematicFrame::GetSchematicFromRedoList()
/***************************************************************************/
void WinEDA_SchematicFrame::PutDataInPreviousState( DrawPickedStruct* List )
void WinEDA_SchematicFrame::PutDataInPreviousState( PICKED_ITEMS_LIST* aList )
/***************************************************************************/
/* Used in undo or redo command.
* Put data pointed by List in the previous state, i.e. the state memorised by List
*/
{
SCH_ITEM* FirstItem = (SCH_ITEM*) List->GetSon();
SCH_ITEM* item;
DrawPickedStruct* PickedList;
SCH_ITEM* item;
SCH_ITEM* alt_item;
switch( List->m_Flags )
for( unsigned ii = 0; ii < aList->GetCount(); ii++ )
{
case IS_CHANGED: /* Exchange old and new data for each item */
if( FirstItem == NULL )
ITEM_PICKER itemWrapper = aList->GetItemWrapper( ii );
item = (SCH_ITEM*) itemWrapper.m_Item;
SCH_ITEM * image = (SCH_ITEM*) itemWrapper.m_Link;
switch( itemWrapper.m_UndoRedoStatus )
{
DisplayError( this, wxT( "PutDataInPreviousState() error : Null item" ) );
case IS_CHANGED: /* Exchange old and new data for each item */
SwapData( item, image );
break;
}
if( FirstItem->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
{
DrawPickedStruct* PickedList = (DrawPickedStruct*) FirstItem;
while( PickedList )
{
SwapData( PickedList->m_PickedStruct );
PickedList = PickedList->Next();
}
}
else
{
SwapData( FirstItem );
}
break;
case IS_NEW: /* new items are deleted */
List->m_Flags = IS_DELETED;
if( FirstItem && FirstItem->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
{
PickedList = (DrawPickedStruct*) FirstItem;
while( PickedList )
{
item = (SCH_ITEM*) PickedList->m_Image;
( (SCH_SCREEN*) GetScreen() )->RemoveFromDrawList( item );
item->m_Flags = IS_DELETED;
PickedList->m_PickedStruct = item;
PickedList->m_Flags = IS_DELETED;
PickedList = PickedList->Next();
}
}
else
{
FirstItem = (SCH_ITEM*)List->m_Image;
( (SCH_SCREEN*) GetScreen() )->RemoveFromDrawList( FirstItem );
FirstItem->m_Flags = IS_DELETED;
List->SetSon( FirstItem );
}
break;
case IS_NEW: /* new items are deleted */
aList->m_UndoRedoType = IS_DELETED;
aList->SetItemStatus( IS_DELETED, ii );
GetScreen()->RemoveFromDrawList( item );
item->m_Flags = IS_DELETED;
break;
case IS_DELETED: /* deleted items are put in EEdrawList, as new items */
List->m_Flags = IS_NEW;
if( FirstItem->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
{
PickedList = (DrawPickedStruct*) FirstItem;
while( PickedList )
case IS_DELETED: /* deleted items are put in EEdrawList, as new items */
aList->m_UndoRedoType = IS_NEW;
aList->SetItemStatus( IS_NEW, ii );
item->SetNext( GetScreen()->EEDrawList );
GetScreen()->EEDrawList = item;
item->m_Flags = 0;
break;
case IS_WIRE_IMAGE:
/* Exchange the current wires and the old wires */
alt_item = GetScreen()->ExtractWires( false );
aList->SetItem( alt_item, ii );
while( item )
{
item = (SCH_ITEM*) PickedList->m_PickedStruct;
SCH_ITEM* nextitem = item->Next();
item->SetNext( GetScreen()->EEDrawList );
GetScreen()->EEDrawList = item;
item->m_Flags = 0;
PickedList->m_PickedStruct = NULL;
PickedList->m_Image = item;
PickedList->m_Flags = IS_NEW;
PickedList = PickedList->Next();
item = nextitem;
}
}
else
{
FirstItem->SetNext( GetScreen()->EEDrawList );
GetScreen()->EEDrawList = FirstItem;
FirstItem->m_Flags = 0;
List->m_Image = List->GetSon();
List->SetSon( NULL );
}
break;
break;
case IS_WIRE_IMAGE:
/* Exchange the current wires and the old wires */
List->SetSon( ( (SCH_SCREEN*) GetScreen() )->ExtractWires( FALSE ) );
while( FirstItem )
default:
{
SCH_ITEM* nextitem = FirstItem->Next();
FirstItem->SetNext( GetScreen()->EEDrawList );
GetScreen()->EEDrawList = FirstItem;
FirstItem->m_Flags = 0;
FirstItem = nextitem;
wxString msg;
msg.Printf(wxT( "PutDataInPreviousState() error (unknown code %X)" ), itemWrapper.m_UndoRedoStatus);
DisplayError( this, msg);
}
break;
case IS_NEW | IS_CHANGED:
case IS_DELETED | IS_CHANGED:
if( !FirstItem || FirstItem->Type() != DRAW_PICK_ITEM_STRUCT_TYPE )
{
DisplayError( this, wxT( "GetSchematicFromUndoList() error: Pickstruct expected" ) );
break;
}
PickedList = (DrawPickedStruct*) FirstItem;
while( PickedList )
{
switch( PickedList->m_Flags )
{
case IS_CHANGED:
SwapData( PickedList->m_PickedStruct );
break;
case IS_NEW:
item = (SCH_ITEM*) PickedList->m_Image;
( (SCH_SCREEN*) GetScreen() )->RemoveFromDrawList( item );
item->m_Flags = IS_DELETED;
PickedList->m_PickedStruct = item;
PickedList->m_Flags = IS_DELETED;
break;
case IS_DELETED:
item = (SCH_ITEM*) PickedList->m_PickedStruct;
item->SetNext( GetScreen()->EEDrawList );
GetScreen()->EEDrawList = item;
item->m_Flags = 0;
PickedList->m_PickedStruct = NULL;
PickedList->m_Image = item;
PickedList->m_Flags = IS_NEW;
break;
}
PickedList = PickedList->Next();
}
break;
default:
DisplayError( this, wxT( "GetSchematicFromUndoList() error: Unknown cmd" ) );
break;
}
}
@ -479,15 +421,15 @@ bool WinEDA_SchematicFrame::GetSchematicFromUndoList()
* Undo the last edition:
* - Save the current schematic in Redo list
* - Get an old version of the schematic
* @return FALSE if nothing done, else true
* @return false if nothing done, else true
*/
{
if( GetScreen()->m_UndoList == NULL )
return FALSE;
if( GetScreen()->GetUndoCommandCount() <= 0 )
return false;
/* Get the old wrapper and put it in RedoList (the real data list is the m_Son member) */
DrawPickedStruct* List = (DrawPickedStruct*) GetScreen()->GetItemFromUndoList();
GetScreen()->AddItemToRedoList( List );
/* Get the old wrapper and put it in RedoList */
PICKED_ITEMS_LIST* List = GetScreen()->PopCommandFromUndoList();
GetScreen()->PushCommandToRedoList( List );
/* Undo the command */
PutDataInPreviousState( List );
@ -502,118 +444,61 @@ bool WinEDA_SchematicFrame::GetSchematicFromUndoList()
/*********************************************************/
void SCH_SCREEN::ClearUndoORRedoList( EDA_BaseStruct* List )
void SCH_SCREEN::ClearUndoORRedoList( UNDO_REDO_CONTAINER& aList, int aItemCount )
/*********************************************************/
/* free the undo or redo list from List element
/** Function ClearUndoORRedoList
* free the undo or redo list from List element
* Wrappers are deleted.
* datas pointed by wrappers are deleted if not flagged IS_NEW
* because they are copy of used data or they are not in use (DELETED)
* @param aList = the UNDO_REDO_CONTAINER to clear
* @param aItemCount = the count of items to remove. < 0 for all items
* items are removed from the beginning of the list.
* So this function can be called to remove old commands
*/
{
EDA_BaseStruct* nextitem;
EDA_BaseStruct* FirstItem;
int CmdType;
if( List == NULL )
if( aItemCount == 0 )
return;
for( ; List != NULL; List = nextitem )
unsigned icnt = aList.m_CommandsList.size();
if( aItemCount > 0 )
icnt = aItemCount;
for( unsigned ii = 0; ii < icnt; ii++ )
{
nextitem = List->Next();
FirstItem = List->GetSon();
CmdType = List->m_Flags;
SAFE_DELETE( List );
if( FirstItem == NULL )
continue;
if ( aList.m_CommandsList.size() == 0 )
break;
PICKED_ITEMS_LIST* curr_cmd = aList.m_CommandsList[0];
aList.m_CommandsList.erase( aList.m_CommandsList.begin() );
CmdType = curr_cmd->m_UndoRedoType;
if( FirstItem->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
// Delete items is they are not flagged IS_NEW
while(1)
{
EDA_BaseStruct* item;
DrawPickedStruct* PickedList = (DrawPickedStruct*) FirstItem;
while( PickedList ) // delete wrapper list and copies
{
item = PickedList->m_PickedStruct;
if( item )
{
#if 0
if( item->Type() == DRAW_SHEET_STRUCT_TYPE )
{
printf(
"schematic undo_redo.cpp: undo_redo with a DRAW_SHEET_STRUCT_TYPE, checkme!!\n" );
DrawSheetStruct* sheet = (DrawSheetStruct*) item;
/* Delete sub hierarchy if the sheet must be deleted */
if( (sheet->m_Flags & IS_DELETED) != 0 )
DeleteSubHierarchy( sheet, FALSE );
else /* EEDrawList, UndoList and Redo list are shared, and are deleted
* only if sheet is deleted */
{
if( (item->m_Flags & IS_NEW) == 0 )
{
/*
* sheet->EEDrawList = NULL;
* sheet->m_UndoList = NULL;
* sheet->m_RedoList = NULL;
*/
}
}
}
#endif
if( (item->m_Flags & IS_NEW) == 0 )
{
SAFE_DELETE( item );
}
}
DrawPickedStruct* wrapper = PickedList;
PickedList = PickedList->Next();
SAFE_DELETE( wrapper );
}
}
else // This is a single item: deleted copy
{
if( CmdType == IS_WIRE_IMAGE )
ITEM_PICKER wrapper = curr_cmd->PopItem();
EDA_BaseStruct* item = wrapper.m_Item;
if( item == NULL ) // No more item in list.
break;
if( wrapper.m_UndoRedoStatus == IS_WIRE_IMAGE )
{
while( FirstItem )
while( item )
{
EDA_BaseStruct* nextitem = FirstItem->Next();
delete FirstItem;
FirstItem = nextitem;
EDA_BaseStruct* nextitem = item->Next();
delete item;
item = nextitem;
}
}
else
{
#if 0
if( FirstItem->Type() == DRAW_SHEET_STRUCT_TYPE )
{
DrawSheetStruct* sheet = (DrawSheetStruct*) FirstItem;
/* Delete hierarchy if the sheet must be deleted */
if( (sheet->m_Flags & IS_DELETED) == IS_DELETED )
DeleteSubHierarchy( sheet, FALSE );
else
{
if( (FirstItem->m_Flags & IS_NEW) == 0 )
{
printf(
"schematic undo_redo.cpp undo_redo with a DRAW_SHEET_STRUCT_TYPE, checkme!!\n" );
/*
* sheet->EEDrawList = NULL;
* sheet->m_UndoList = NULL;
* sheet->m_RedoList = NULL;
*/
}
}
}
#endif
if( (FirstItem->m_Flags & IS_NEW) == 0 )
if( (wrapper.m_UndoRedoStatus & IS_NEW) == 0 )
{
SAFE_DELETE( FirstItem );
delete item;
}
}
}
delete curr_cmd; // Delete command
}
}
@ -625,79 +510,36 @@ void SCH_SCREEN::ClearUndoRedoList()
/* free the undo and the redo lists
*/
{
ClearUndoORRedoList( m_UndoList ); m_UndoList = NULL;
ClearUndoORRedoList( m_RedoList ); m_RedoList = NULL;
ClearUndoORRedoList( m_UndoList );
ClearUndoORRedoList( m_RedoList );
}
/***********************************************************/
void SCH_SCREEN::AddItemToUndoList( EDA_BaseStruct* newitem )
void SCH_SCREEN::PushCommandToUndoList( PICKED_ITEMS_LIST* aItem )
/************************************************************/
/* Put newitem in head of undo list
* Deletes olds items if > count max.
*/
{
int ii;
EDA_BaseStruct* item, * nextitem;
if( newitem == NULL )
return;
if( m_UndoList )
m_UndoList->SetBack( newitem );
newitem->SetNext( m_UndoList );
newitem->SetBack( NULL );
m_UndoList = newitem;
/* Free oldest items, if count max reached */
for( ii = 0, item = m_UndoList; ii < m_UndoRedoCountMax; ii++ )
{
if( item->Next() == NULL )
return;
item = item->Next();
}
m_UndoList.PushCommand( aItem );
if( item == NULL )
return;
nextitem = item->Next();
item->SetNext( NULL ); // Set end of chain
// Delete the extra items
ClearUndoORRedoList( nextitem );
/* Delete the extra items, if count max reached */
int extraitems = GetUndoCommandCount() - m_UndoRedoCountMax;
if( extraitems > 0 ) // Delete the extra items
ClearUndoORRedoList( m_UndoList, extraitems );
}
/***********************************************************/
void SCH_SCREEN::AddItemToRedoList( EDA_BaseStruct* newitem )
void SCH_SCREEN::PushCommandToRedoList( PICKED_ITEMS_LIST* aItem )
/***********************************************************/
{
int ii;
EDA_BaseStruct* item, * nextitem;
if( newitem == NULL )
return;
newitem->SetBack( NULL );
newitem->SetNext( m_RedoList );
m_RedoList = newitem;
/* Free first items, if count max reached */
for( ii = 0, item = m_RedoList; ii < m_UndoRedoCountMax; ii++ )
{
if( item->Next() == NULL )
break;
item = item->Next();
}
if( item == NULL )
return;
nextitem = item->Next();
item->SetNext( NULL ); // Set end of chain
m_RedoList.PushCommand( aItem );
// Delete the extra items
ClearUndoORRedoList( nextitem );
/* Delete the extra items, if count max reached */
int extraitems = GetRedoCommandCount() - m_UndoRedoCountMax;
if( extraitems > 0 ) // Delete the extra items
ClearUndoORRedoList( m_RedoList, extraitems );
}

4
eeschema/schframe.cpp
View File

@ -431,13 +431,13 @@ void WinEDA_SchematicFrame::OnUpdatePaste( wxUpdateUIEvent& event )
void WinEDA_SchematicFrame::OnUpdateSchematicUndo( wxUpdateUIEvent& event )
{
if ( GetScreen() )
event.Enable( (GetScreen()->m_UndoList) ? true : false );
event.Enable( GetScreen()->GetUndoCommandCount() > 0 );
}
void WinEDA_SchematicFrame::OnUpdateSchematicRedo( wxUpdateUIEvent& event )
{
if ( GetScreen() )
event.Enable( (GetScreen()->m_RedoList) ? true : false );
event.Enable( GetScreen()->GetRedoCommandCount() > 0 );
}
void WinEDA_SchematicFrame::OnUpdateBusOrientation( wxUpdateUIEvent& event )

44
include/base_struct.h
View File

@ -220,26 +220,7 @@ class DHEAD;
* Class EDA_BaseStruct
* is a base class for most all the kicad significant classes, used in schematics and boards.
*/
class EDA_BaseStruct
{
private:
/**
* Run time identification, _keep private_ so it can never be changed after
* a constructor sets it. See comment near SetType() regarding virtual functions.
*/
KICAD_T m_StructType;
protected:
EDA_BaseStruct* Pnext; /* Linked list: Link (next struct) */
EDA_BaseStruct* Pback; /* Linked list: Link (previous struct) */
EDA_BaseStruct* m_Parent; /* Linked list: Link (parent struct) */
EDA_BaseStruct* m_Son; /* Linked list: Link (son struct) */
DHEAD* m_List; ///< which DLIST I am on.
public:
int m_Flags; // flags for editing and other misc. uses
// These define are used for the .m_Flags and .m_UndoRedoStatus member of the class EDA_BaseStruct
#define IS_CHANGED (1 << 0)
#define IS_LINKED (1 << 1)
#define IN_EDIT (1 << 2)
@ -259,12 +240,33 @@ public:
#define DO_NOT_DRAW (1 << 16) ///< Used to disable draw function
#define DRAW_ERASED (1 << 17) ///< draw in background color, used by classs TRACK in gerbview
class EDA_BaseStruct
{
private:
/**
* Run time identification, _keep private_ so it can never be changed after
* a constructor sets it. See comment near SetType() regarding virtual functions.
*/
KICAD_T m_StructType;
protected:
EDA_BaseStruct* Pnext; /* Linked list: Link (next struct) */
EDA_BaseStruct* Pback; /* Linked list: Link (previous struct) */
EDA_BaseStruct* m_Parent; /* Linked list: Link (parent struct) */
EDA_BaseStruct* m_Son; /* Linked list: Link (son struct) */
DHEAD* m_List; ///< which DLIST I am on.
EDA_BaseStruct* m_Image; /* Link to an image copy for undelete or abort command */
public:
int m_Flags; // flags for editing and other misc. uses
unsigned long m_TimeStamp; // Time stamp used for logical links
int m_Selected; /* Used by block commands, and selective editing */
// member used in undo/redo function
EDA_BaseStruct* m_Image; // Link to an image copy to save a copy of old parmeters values
private:
int m_Status;

26
include/class_base_screen.h
View File

@ -11,6 +11,7 @@
#define __CLASS_BASE_SCREEN_H__
#include "base_struct.h"
#include "class_undoredo_container.h"
// Forward declarations:
@ -116,11 +117,12 @@ public:
* Schematic */
bool m_FirstRedraw;
/* Gestion des editions */
SCH_ITEM* EEDrawList; /* Object list (main data) for schematic */
EDA_BaseStruct* m_UndoList; /* Object list for the undo command (old data) */
EDA_BaseStruct* m_RedoList; /* Object list for the redo command (old data) */
int m_UndoRedoCountMax; /* undo/Redo command Max depth */
// Undo/redo list of commands
UNDO_REDO_CONTAINER m_UndoList; /* Object list for the undo command (old data) */
UNDO_REDO_CONTAINER m_RedoList; /* Object list for the redo command (old data) */
unsigned m_UndoRedoCountMax; // undo/Redo command Max depth
/* block control */
DrawBlockStruct BlockLocate; /* Bock description for block commands */
@ -187,10 +189,18 @@ public:
/* general Undo/Redo command control */
virtual void ClearUndoRedoList();
virtual void AddItemToUndoList( EDA_BaseStruct* item );
virtual void AddItemToRedoList( EDA_BaseStruct* item );
virtual EDA_BaseStruct* GetItemFromUndoList();
virtual EDA_BaseStruct* GetItemFromRedoList();
virtual void PushCommandToUndoList( PICKED_ITEMS_LIST* aItem );
virtual void PushCommandToRedoList( PICKED_ITEMS_LIST* aItem );
virtual PICKED_ITEMS_LIST* PopCommandFromUndoList();
virtual PICKED_ITEMS_LIST* PopCommandFromRedoList();
int GetUndoCommandCount( )
{
return m_UndoList.m_CommandsList.size();
}
int GetRedoCommandCount( )
{
return m_RedoList.m_CommandsList.size();
}
/* Manipulation des flags */
void SetRefreshReq() { m_FlagRefreshReq = 1; }

17
include/class_sch_screen.h
View File

@ -51,15 +51,26 @@ public:
void RemoveFromDrawList( SCH_ITEM* DrawStruct ); /* remove DrawStruct from EEDrawList. */
bool CheckIfOnDrawList( SCH_ITEM* st );
void AddToDrawList( SCH_ITEM* DrawStruct );
void ClearUndoORRedoList( EDA_BaseStruct* List );
bool SchematicCleanUp( wxDC* DC = NULL );
SCH_ITEM* ExtractWires( bool CreateCopy );
/* full undo redo management : */
virtual void ClearUndoRedoList();
virtual void AddItemToUndoList( EDA_BaseStruct* item );
virtual void AddItemToRedoList( EDA_BaseStruct* item );
virtual void PushCommandToUndoList( PICKED_ITEMS_LIST* aItem );
virtual void PushCommandToRedoList( PICKED_ITEMS_LIST* aItem );
/** Function ClearUndoORRedoList
* free the undo or redo list from List element
* Wrappers are deleted.
* datas pointed by wrappers are deleted if not flagged IS_NEW
* because they are copy of used data or they are not in use (DELETED)
* @param aList = the UNDO_REDO_CONTAINER to clear
* @param aItemCount = the count of items to remove. < 0 for all items
* items are removed from the beginning of the list.
* So this function can be called to remove old commands
*/
void ClearUndoORRedoList( UNDO_REDO_CONTAINER& aList, int aItemCount = -1 );
/**
* Function Save

3
include/wxEeschemaStruct.h
View File

@ -33,6 +33,7 @@ class LibDrawField;
class SCH_CMP_FIELD;
class LibDrawPin;
class DrawJunctionStruct;
class PICKED_ITEMS_LIST;
/*******************************/
/* class WinEDA_SchematicFrame */
@ -371,7 +372,7 @@ public:
int flag_type_command = 0 );
private:
void PutDataInPreviousState( DrawPickedStruct* List );
void PutDataInPreviousState( PICKED_ITEMS_LIST* aList );
bool GetSchematicFromRedoList();
bool GetSchematicFromUndoList();

53
pcbnew/modedit_undo_redo.cpp
View File

@ -19,22 +19,32 @@ void WinEDA_ModuleEditFrame::SaveCopyInUndoList( EDA_BaseStruct* ItemToCopy,
{
EDA_BaseStruct* item;
MODULE* CopyItem;
PICKED_ITEMS_LIST* lastcmd;
CopyItem = new MODULE( GetBoard() );
CopyItem->Copy( (MODULE*) ItemToCopy );
CopyItem->SetParent( GetBoard() );
GetScreen()->AddItemToUndoList( (EDA_BaseStruct*) CopyItem );
lastcmd = new PICKED_ITEMS_LIST();
ITEM_PICKER wrapper(CopyItem);
lastcmd->PushItem(wrapper);
GetScreen()->PushCommandToUndoList( lastcmd );
/* Clear current flags (which can be temporary set by a current edit command) */
for( item = CopyItem->m_Drawings; item != NULL; item = item->Next() )
item->m_Flags = 0;
/* Clear redo list, because after new save there is no redo to do */
while( GetScreen()->m_RedoList )
while( (lastcmd = GetScreen()->PopCommandFromRedoList( ) ) != NULL )
{
item = GetScreen()->m_RedoList->Next();
delete GetScreen()->m_RedoList;
GetScreen()->m_RedoList = item;
while ( 1 )
{
wrapper = lastcmd->PopItem();
if ( wrapper.m_Item == NULL )
break; // All items are removed
delete wrapper.m_Item;
}
delete lastcmd;
}
}
@ -48,12 +58,19 @@ void WinEDA_ModuleEditFrame::GetComponentFromRedoList()
* - Get old version of the current edited library component
*/
{
if( GetScreen()->m_RedoList == NULL )
if ( GetScreen()->GetRedoCommandCount() <= 0 )
return;
GetScreen()->AddItemToUndoList( GetBoard()->m_Modules.PopFront() );
PICKED_ITEMS_LIST* lastcmd = new PICKED_ITEMS_LIST();
ITEM_PICKER wrapper( GetBoard()->m_Modules.PopFront() );
lastcmd->PushItem(wrapper);
GetScreen()->PushCommandToUndoList( lastcmd );
lastcmd = GetScreen()->PopCommandFromRedoList( );
wrapper = lastcmd->PopItem();
GetBoard()->Add( (MODULE*) GetScreen()->GetItemFromRedoList() );
GetBoard()->Add( (MODULE*) wrapper.m_Item );
SetCurItem( NULL );;
GetScreen()->SetModify();
@ -71,19 +88,21 @@ void WinEDA_ModuleEditFrame::GetComponentFromUndoList()
* - Get old version of the current edited library component
*/
{
if( GetScreen()->m_UndoList == NULL )
if ( GetScreen()->GetUndoCommandCount() <= 0 )
return;
GetScreen()->AddItemToRedoList( GetBoard()->m_Modules.PopFront() );
PICKED_ITEMS_LIST* lastcmd = new PICKED_ITEMS_LIST();
ITEM_PICKER wrapper(GetBoard()->m_Modules.PopFront());
lastcmd->PushItem(wrapper);
GetScreen()->PushCommandToRedoList( lastcmd );
lastcmd = GetScreen()->PopCommandFromUndoList( );
wrapper = lastcmd->PopItem();
MODULE* module = (MODULE*) GetScreen()->GetItemFromUndoList();
if( module )
GetBoard()->Add( module, ADD_APPEND );
if( wrapper.m_Item )
GetBoard()->Add( (MODULE*) wrapper.m_Item, ADD_APPEND );
/* Add() calls PushBack(), no need for this
if( GetBoard()->m_Modules )
GetBoard()->m_Modules->SetNext( NULL );
*/
GetScreen()->SetModify();
SetCurItem( NULL );;

4
pcbnew/moduleframe.cpp
View File

@ -298,8 +298,8 @@ void WinEDA_ModuleEditFrame::SetToolbars()
if( GetScreen() )
{
m_HToolBar->EnableTool( ID_MODEDIT_UNDO, GetScreen()->m_UndoList && active );
m_HToolBar->EnableTool( ID_MODEDIT_REDO, GetScreen()->m_RedoList && active );
m_HToolBar->EnableTool( ID_MODEDIT_UNDO, GetScreen()->GetUndoCommandCount( )>0 && active );
m_HToolBar->EnableTool( ID_MODEDIT_REDO, GetScreen()->GetRedoCommandCount( )>0 && active );
}
if( frame->GetBoard()->m_Modules )

Write Preview
Loading…
Cancel
Save