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

676 lines
21 KiB
C++
Raw Blame History

/********************************************/
/* library editor: undo and redo functions */
/********************************************/
#include "fctsys.h"
#include "gr_basic.h"
#include "common.h"
#include "program.h"
#include "libcmp.h"
#include "general.h"
#include "id.h"
#include "protos.h"
/* Functions to undo and redo edit commands.
* commmands to undo are in CurrentScreen->m_UndoList
* commmands to redo are in CurrentScreen->m_RedoList
*
* m_UndoList and m_RedoList are a linked list of DrawPickedStruct.
* each DrawPickedStruct has its .m_Son member pointing to an item to undo or redo,
* or to a list of DrawPickedStruct which points (.m_PickedStruct membre)
* the items to undo or redo
*
* there are 3 cases:
* - delete item(s) command
* - change item(s) command
* - add item(s) command
*
* Undo command
* - delete item(s) command:
* deleted items are moved in undo list
*
* - change item(s) command
* A copy of item(s) is made (a DrawPickedStruct list of wrappers)
* the .m_Image member of each wrapper points the modified item.
*
* - add item(s) command
* A list of item(s) is made
* the .m_Image member of each wrapper points the new item.
*
* Redo command
* - delete item(s) old command:
* deleted items are moved in EEDrawList list
*
* - change item(s) command
* the copy of item(s) is moved in Undo list
*
* - add item(s) command
* The list of item(s) is used to create a deleted list in undo list
* (same as a delete command)
*
* A problem is the hierarchical sheet handling.
* the data associated (subhierarchy, uno/redo list) is deleted only
* when the sheet is really deleted (i.e. when deleted from undo or redo list)
* and not when it is a copy.
*/
/************************************/
void SwapData( EDA_BaseStruct* Item )
/************************************/
/* 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 )
return;
switch( Item->Type() )
{
case DRAW_POLYLINE_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawPolylineStruct*) Item )
#define DEST ( (DrawPolylineStruct*) image )
break;
case DRAW_JUNCTION_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawJunctionStruct*) Item )
#define DEST ( (DrawJunctionStruct*) image )
EXCHG( SOURCE->m_Pos, DEST->m_Pos );
break;
case DRAW_LABEL_STRUCT_TYPE:
case DRAW_GLOBAL_LABEL_STRUCT_TYPE:
case DRAW_TEXT_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawTextStruct*) Item )
#define DEST ( (DrawTextStruct*) image )
DEST->SwapData( SOURCE );
break;
case DRAW_LIB_ITEM_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (EDA_SchComponentStruct*) Item )
#define DEST ( (EDA_SchComponentStruct*) image )
DEST->SwapData( SOURCE );
break;
case DRAW_SEGMENT_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (EDA_DrawLineStruct*) Item )
#define DEST ( (EDA_DrawLineStruct*) image )
EXCHG( SOURCE->m_Start, DEST->m_Start );
EXCHG( SOURCE->m_End, DEST->m_End );
break;
case DRAW_BUSENTRY_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawBusEntryStruct*) Item )
#define DEST ( (DrawBusEntryStruct*) image )
EXCHG( SOURCE->m_Pos, DEST->m_Pos );
EXCHG( SOURCE->m_Size, DEST->m_Size );
break;
case DRAW_SHEET_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawSheetStruct*) Item )
#define DEST ( (DrawSheetStruct*) image )
DEST->SwapData( SOURCE );
break;
case DRAW_MARKER_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawMarkerStruct*) Item )
#define DEST ( (DrawMarkerStruct*) image )
EXCHG( SOURCE->m_Pos, DEST->m_Pos );
break;
case DRAW_SHEETLABEL_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawSheetLabelStruct*) Item )
#define DEST ( (DrawSheetLabelStruct*) image )
EXCHG( SOURCE->m_Edge, DEST->m_Edge );
EXCHG( SOURCE->m_Shape, DEST->m_Shape );
break;
case DRAW_NOCONNECT_STRUCT_TYPE:
#undef SOURCE
#undef DEST
#define SOURCE ( (DrawNoConnectStruct*) Item )
#define DEST ( (DrawNoConnectStruct*) image )
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:
default:
DisplayInfo( NULL, wxT( "SwapData() error: unexpected type" ) );
break;
}
}
/***********************************************************************/
void WinEDA_SchematicFrame::SaveCopyInUndoList( EDA_BaseStruct* ItemToCopy,
int flag_type_command )
/***********************************************************************/
/* Create a copy of the current schematic draw list, and put it in the undo list.
* A DrawPickedStruct wrapper is created to handle the draw list.
* the .m_Son of this wrapper points the list of items
*
* flag_type_command =
* 0 (unspecified)
* IS_CHANGED
* IS_NEW
* IS_DELETED
* IS_WIRE_IMAGE
*
* for 0: only a wrapper is created. The used must init the .Flags member of the
* wrapper, and add the item list to the wrapper
* If it is a delete command, items are put on list with the .Flags member set to IS_DELETED.
* When it will be really deleted, the EEDrawList and the subhierarchy will be deleted.
* If it is only a copy, the EEDrawList and the subhierarchy must NOT be deleted.
*
* Note:
* Edit wires and busses is a bit complex.
* because when a new wire is added, modifications in wire list
* (wire concatenation) there are modified items, deleted items and new items
* so flag_type_command is IS_WIRE_IMAGE: the struct ItemToCopy is a list of wires
* saved in Undo List (for Undo or Redo commands, saved wires will be exchanged with current wire list
*/
{
EDA_BaseStruct* CopyItem;
DrawPickedStruct* NewList = new DrawPickedStruct( NULL );
NewList->m_Flags = flag_type_command;
if( ItemToCopy )
{
switch( flag_type_command )
{
case 0:
break;
case IS_CHANGED: /* Create a copy of schematic */
NewList->m_Son = CopyItem = DuplicateStruct( ItemToCopy );
if( ItemToCopy->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
{
DrawPickedStruct* PickedList = (DrawPickedStruct*) CopyItem;
while( PickedList )
{
CopyItem = PickedList->m_PickedStruct;
CopyItem->m_Flags = flag_type_command;
PickedList->m_Image = CopyItem->m_Image;
PickedList = (DrawPickedStruct*) PickedList->Pnext;
}
}
else
{
CopyItem->m_Flags = flag_type_command;
CopyItem->m_Image = ItemToCopy;
}
break;
case IS_NEW:
if( ItemToCopy->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
{
NewList->m_Son = ItemToCopy;
DrawPickedStruct* PickedList = (DrawPickedStruct*) ItemToCopy;
while( PickedList )
{
CopyItem = PickedList->m_PickedStruct;
PickedList->m_Image = CopyItem;
PickedList->m_PickedStruct = NULL;
PickedList->m_Flags = flag_type_command;
PickedList = (DrawPickedStruct*) PickedList->Pnext;
}
}
else
{
NewList->m_Image = ItemToCopy;
}
break;
case IS_NEW | IS_CHANGED:
case IS_WIRE_IMAGE:
NewList->m_Son = ItemToCopy;
break;
case IS_DELETED:
NewList->m_Son = ItemToCopy;
ItemToCopy->m_Flags = flag_type_command;
if( ItemToCopy->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
{
DrawPickedStruct* PickedList = (DrawPickedStruct*) ItemToCopy;
while( PickedList )
{
CopyItem = PickedList->m_PickedStruct;
CopyItem->m_Flags = flag_type_command;
PickedList->m_Flags = flag_type_command;
PickedList = (DrawPickedStruct*) PickedList->Pnext;
}
}
break;
default:
DisplayError( this, wxT( "SaveCopyInUndoList() error" ) );
break;
}
}
/* Save the copy in undo list */
GetScreen()->AddItemToUndoList( NewList );
/* Clear redo list, because after new save there is no redo to do */
GetScreen()->ClearUndoORRedoList( GetScreen()->m_RedoList );
GetScreen()->m_RedoList = NULL;
}
/**********************************************************/
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
*/
{
if( GetScreen()->m_RedoList == NULL )
return FALSE;
/* Get the old wrapper and put it in UndoList */
DrawPickedStruct* List = (DrawPickedStruct*) GetScreen()->GetItemFromRedoList();
GetScreen()->AddItemToUndoList( List );
/* Redo the command: */
PutDataInPreviousState( List );
CurrentDrawItem = NULL;
GetScreen()->SetModify();
ReCreateHToolbar();
SetToolbars();
return TRUE;
}
/***************************************************************************/
void WinEDA_SchematicFrame::PutDataInPreviousState( DrawPickedStruct* List )
/***************************************************************************/
/* Used in undo or redo command.
* Put data pointed by List in the previous state, i.e. the state memorised by List
*/
{
EDA_BaseStruct* FirstItem = List->m_Son;
EDA_BaseStruct* item;
DrawPickedStruct* PickedList;
switch( List->m_Flags )
{
case IS_CHANGED: /* Exchange old and new data for each item */
if( FirstItem == NULL )
{
DisplayError( this, wxT( "PutDataInPreviousState() error : Null item" ) );
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 = PickedList->m_Image;
GetScreen()->RemoveFromDrawList( item );
item->m_Flags = IS_DELETED;
PickedList->m_PickedStruct = item;
PickedList->m_Flags = IS_DELETED;
PickedList = PickedList->Next();
}
}
else
{
FirstItem = List->m_Image;
GetScreen()->RemoveFromDrawList( FirstItem );
FirstItem->m_Flags = IS_DELETED;
List->m_Son = FirstItem;
}
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 )
{
item = PickedList->m_PickedStruct;
item->Pnext = 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();
}
}
else
{
FirstItem->Pnext = GetScreen()->EEDrawList;
GetScreen()->EEDrawList = FirstItem;
FirstItem->m_Flags = 0;
List->m_Image = List->m_Son;
List->m_Son = NULL;
}
break;
case IS_WIRE_IMAGE:
/* Exchange the current wires and the oild wires */
List->m_Son = GetScreen()->ExtractWires( FALSE );
while( FirstItem )
{
EDA_BaseStruct* nextitem = FirstItem->Pnext;
FirstItem->Pnext = GetScreen()->EEDrawList;
GetScreen()->EEDrawList = FirstItem;
FirstItem->m_Flags = 0;
FirstItem = nextitem;
}
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 = PickedList->m_Image;
GetScreen()->RemoveFromDrawList( item );
item->m_Flags = IS_DELETED;
PickedList->m_PickedStruct = item;
PickedList->m_Flags = IS_DELETED;
break;
case IS_DELETED:
item = PickedList->m_PickedStruct;
item->Pnext = 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;
}
}
/**********************************************************/
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
*/
{
if( GetScreen()->m_UndoList == NULL )
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 );
/* Undo the command */
PutDataInPreviousState( List );
CurrentDrawItem = NULL;
GetScreen()->SetModify();
ReCreateHToolbar();
SetToolbars();
return TRUE;
}
/*********************************************************/
void SCH_SCREEN::ClearUndoORRedoList( EDA_BaseStruct* List )
/*********************************************************/
/* 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)
*/
{
EDA_BaseStruct* nextitem;
EDA_BaseStruct* FirstItem;
int CmdType;
if( List == NULL )
return;
for( ; List != NULL; List = nextitem )
{
nextitem = List->Pnext;
FirstItem = List->m_Son;
CmdType = List->m_Flags;
delete List;
if( FirstItem == NULL )
continue;
if( FirstItem->Type() == DRAW_PICK_ITEM_STRUCT_TYPE )
{
EDA_BaseStruct* item;
DrawPickedStruct* PickedList = (DrawPickedStruct*) FirstItem;
while( PickedList ) // delete wrapper list and copies
{
item = PickedList->m_PickedStruct;
if( item )
{
if( item->Type() == DRAW_SHEET_STRUCT_TYPE )
{
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;
}
}
}
if( (item->m_Flags & IS_NEW) == 0 )
delete item;
}
DrawPickedStruct* wrapper = PickedList;
PickedList = PickedList->Next();
delete wrapper;
}
}
else // This is a single item: deleted copy
{
if( CmdType == IS_WIRE_IMAGE )
{
while( FirstItem )
{
EDA_BaseStruct* nextitem = FirstItem->Pnext;
delete FirstItem;
FirstItem = nextitem;
}
}
else
{
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 )
{
sheet->EEDrawList = NULL;
sheet->m_UndoList = NULL;
sheet->m_RedoList = NULL;
}
}
}
if( (FirstItem->m_Flags & IS_NEW) == 0 )
delete FirstItem;
}
}
}
}
/*****************************************/
void SCH_SCREEN::ClearUndoRedoList()
/*****************************************/
/* free the undo and the redo lists
*/
{
ClearUndoORRedoList( m_UndoList ); m_UndoList = NULL;
ClearUndoORRedoList( m_RedoList ); m_RedoList = NULL;
}
/***********************************************************/
void SCH_SCREEN::AddItemToUndoList( EDA_BaseStruct* newitem )
/************************************************************/
/* 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->Pback = newitem;
newitem->Pnext = m_UndoList;
newitem->Pback = NULL;
m_UndoList = newitem;
/* Free oldest items, if count max reached */
for( ii = 0, item = m_UndoList; ii < m_UndoRedoCountMax; ii++ )
{
if( item->Pnext == NULL )
return;
item = item->Pnext;
}
if( item == NULL )
return;
nextitem = item->Pnext;
item->Pnext = NULL; // Set end of chain
// Delete the extra items
ClearUndoORRedoList( nextitem );
}
/***********************************************************/
void SCH_SCREEN::AddItemToRedoList( EDA_BaseStruct* newitem )
/***********************************************************/
{
int ii;
EDA_BaseStruct* item, * nextitem;
if( newitem == NULL )
return;
newitem->Pback = NULL;
newitem->Pnext = m_RedoList;
m_RedoList = newitem;
/* Free first items, if count max reached */
for( ii = 0, item = m_RedoList; ii < m_UndoRedoCountMax; ii++ )
{
if( item->Pnext == NULL )
break;
item = item->Pnext;
}
if( item == NULL )
return;
nextitem = item->Pnext;
item->Pnext = NULL; // Set end of chain
// Delete the extra items
ClearUndoORRedoList( nextitem );
}
Reference in New Issue View Git Blame Copy Permalink