haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

More about undo/redo in pcbnew

This commit is contained in:
charras 2009-08-06 15:42:09 +00:00
parent 5699ee3b91
commit c718765268
12 changed files with 262 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
common/class_undoredo_container.cpp
View File

@ -292,12 +292,12 @@ bool PICKED_ITEMS_LIST::SetPickedItemStatus( UndoRedoOpType aStatus, unsigned aI
}
/** function RemovePickedItem
/** function RemovePicker
* remùove one entry (one picker) from the list of picked items
* @param aIdx = index of the picker in the picked list
* @return true if ok, or false if did not exist
*/
bool PICKED_ITEMS_LIST::RemovePickedItem( unsigned aIdx )
bool PICKED_ITEMS_LIST::RemovePicker( unsigned aIdx )
{
if( aIdx >= m_ItemsList.size() )
return false;
@ -308,17 +308,11 @@ bool PICKED_ITEMS_LIST::RemovePickedItem( unsigned aIdx )
/** Function CopyList
* copy all data from aSource
* Items picked are not copied. just pointer on them are copied
* Picked items are not copied. just pointers on them are copied
*/
void PICKED_ITEMS_LIST::CopyList( const PICKED_ITEMS_LIST& aSource )
{
ITEM_PICKER picker;
for( unsigned ii = 0; ii < aSource.GetCount(); ii++ )
{
picker = aSource.m_ItemsList[ii];
PushItem( picker );
}
m_ItemsList = aSource.m_ItemsList; // Vector's copy
}

35
eeschema/schematic_undo_redo.cpp
View File

@ -274,37 +274,38 @@ void WinEDA_SchematicFrame::SaveCopyInUndoList( PICKED_ITEMS_LIST& aItemsList,
SCH_ITEM* CopyOfItem;
PICKED_ITEMS_LIST* commandToUndo = new PICKED_ITEMS_LIST();
commandToUndo->m_TransformPoint = aTransformPoint;
// Copy picker list:
commandToUndo->CopyList( aItemsList );
ITEM_PICKER itemWrapper;
for( unsigned ii = 0; ii < aItemsList.GetCount(); ii++ )
// Verify list, and creates data if needed
for( unsigned ii = 0; ii < commandToUndo->GetCount(); ii++ )
{
SCH_ITEM* item = (SCH_ITEM*) aItemsList.GetPickedItem( ii );
if( item == NULL )
continue;
UndoRedoOpType command = aItemsList.GetPickedItemStatus( ii );
SCH_ITEM* item = (SCH_ITEM*) commandToUndo->GetPickedItem( ii );
wxASSERT( item );
UndoRedoOpType command = commandToUndo->GetPickedItemStatus( ii );
if( command == UR_UNSPECIFIED )
{
command = aTypeCommand;
commandToUndo->SetPickedItemStatus(command, ii );
}
itemWrapper.m_PickedItem = item;
itemWrapper.m_PickedItemType = item->Type();
itemWrapper.m_UndoRedoStatus = command;
itemWrapper.m_Link = aItemsList.GetPickedItemLink( ii );
switch( command )
{
case UR_CHANGED: /* Create a copy of item */
if( itemWrapper.m_Link == NULL )
itemWrapper.m_Link = DuplicateStruct( item );
if ( itemWrapper.m_Link )
commandToUndo->PushItem( itemWrapper );
/* If needed, create a copy of item, and put in undo list
* in the picker, as link
* If this link is not null, the copy is already done
*/
if( commandToUndo->GetPickedItemLink(ii) == NULL )
commandToUndo->SetPickedItemLink( DuplicateStruct( item ), ii );
wxASSERT( commandToUndo->GetPickedItemLink(ii) );
break;
case UR_MOVED:
case UR_MIRRORED_Y:
case UR_NEW:
case UR_DELETED:
commandToUndo->PushItem( itemWrapper );
break;
default:
@ -325,7 +326,7 @@ void WinEDA_SchematicFrame::SaveCopyInUndoList( PICKED_ITEMS_LIST& aItemsList,
/* Clear redo list, because after new save there is no redo to do */
GetScreen()->ClearUndoORRedoList( GetScreen()->m_RedoList );
}
else
else // Should not occur
delete commandToUndo;
}

6
include/class_undoredo_container.h
View File

@ -196,12 +196,12 @@ public:
*/
bool SetPickedItemStatus( UndoRedoOpType aStatus, unsigned aIdx );
/** function RemovePickedItem
* remùove one entry (one picker) from the list of picked items
/** function RemovePicker
* remove one entry (one picker) from the list of picked items
* @param aIdx = index of the picker in the picked list
* @return true if ok, or false if did not exist
*/
bool RemovePickedItem( unsigned aIdx );
bool RemovePicker( unsigned aIdx );
/** Function CopyList
* copy all data from aSource

3
include/wxBasePcbFrame.h
View File

@ -121,9 +121,6 @@ public:
int ReadSetup( FILE* File, int* LineNum );
int ReadGeneralDescrPcb( FILE* File, int* LineNum );
// PCB handling
bool Clear_Pcb( bool query );
/**
* Function PcbGeneralLocateAndDisplay

20
include/wxPcbStruct.h
View File

@ -254,6 +254,13 @@ public:
int SavePcbFormatAscii( FILE* File );
bool WriteGeneralDescrPcb( FILE* File );
// BOARD handling
/** function Clear_Pcb()
* delete all and reinitialize the current board
* @param aQuery = true to prompt user for confirmation, false to initialize silently
*/
bool Clear_Pcb( bool aQuery );
/**
* Function RecreateBOMFileFromBoard
* Recreates a .cmp file from the current loaded board
@ -348,12 +355,6 @@ public:
// loading modules: see WinEDA_BasePcbFrame
// Board handling
void Erase_Zones( bool query );
void Erase_Segments_Pcb( bool is_edges, bool query );
void Erase_Pistes( wxDC* DC, int masque_type, bool query );
void Erase_Modules( bool query );
void Erase_Textes_Pcb( bool query );
void Erase_Marqueurs();
void RemoveStruct( BOARD_ITEM* Item, wxDC* DC );
void Via_Edit_Control( wxDC* DC, int command_type, SEGVIA* via );
@ -655,6 +656,13 @@ public:
virtual void OnSelectGrid( wxCommandEvent& event );
void LoadModuleFromBoard( wxCommandEvent& event );
// BOARD handling
/** function Clear_Pcb()
* delete all and reinitialize the current board
* @param aQuery = true to prompt user for confirmation, false to initialize silently
*/
bool Clear_Pcb( bool aQuery );
/* handlers for block commands */
int ReturnBlockCommand( int key );
virtual void HandleBlockPlace( wxDC* DC );

59
pcbnew/block.cpp
View File

@ -417,7 +417,6 @@ int WinEDA_PcbFrame::HandleBlockEnd( wxDC* DC )
*/
void WinEDA_PcbFrame::Block_SelectItems()
{
BOARD_ITEM* PtStruct;
int masque_layer;
GetScreen()->m_BlockLocate.Normalize();
@ -428,7 +427,6 @@ void WinEDA_PcbFrame::Block_SelectItems()
/* Effacement des modules */
if( Block_Include_Modules )
{
;
for( MODULE* module = m_Pcb->m_Modules; module != NULL; module = module->Next() )
{
if( module->HitTest( GetScreen()->m_BlockLocate ) )
@ -463,7 +461,7 @@ void WinEDA_PcbFrame::Block_SelectItems()
if( !Block_Include_Edges_Items )
masque_layer &= ~EDGE_LAYER;
for( PtStruct = m_Pcb->m_Drawings; PtStruct != NULL; PtStruct = PtStruct->Next() )
for( BOARD_ITEM* PtStruct = m_Pcb->m_Drawings; PtStruct != NULL; PtStruct = PtStruct->Next() )
{
bool select_me = false;
switch( PtStruct->Type() )
@ -512,19 +510,25 @@ void WinEDA_PcbFrame::Block_SelectItems()
}
}
/* Effacement des Zones */
/* Zone selection */
if( Block_Include_Zones )
{
#if 0
/* This section can creates problems if selected:
* m_Pcb->m_Zone can have a *lot* of items (100 000 is easily possible)
* so it is not selected (and TODO: will be removed, one day)
*/
for( SEGZONE* pt_segm = m_Pcb->m_Zone; pt_segm != NULL; pt_segm = pt_segm->Next() )
{
{ /* Segments used in Zone filling selection */
if( pt_segm->HitTest( GetScreen()->m_BlockLocate ) )
{
picker.m_PickedItem = PtStruct;
picker.m_PickedItemType = PtStruct->Type();
picker.m_PickedItem = pt_segm;
picker.m_PickedItemType = pt_segm->Type();
itemsList->PushItem( picker );
}
}
#endif
for( int ii = 0; ii < m_Pcb->GetAreaCount(); ii++ )
{
if( m_Pcb->GetArea( ii )->HitTest( GetScreen()->m_BlockLocate ) )
@ -536,7 +540,7 @@ void WinEDA_PcbFrame::Block_SelectItems()
}
}
}
}
}
/**************************************************************************/
@ -630,13 +634,20 @@ void WinEDA_PcbFrame::Block_Delete()
case TYPE_TEXTE: // a text on a layer
case TYPE_TRACK: // a track segment (segment on a copper layer)
case TYPE_VIA: // a via (like atrack segment on a copper layer)
case TYPE_ZONE: // a segment used to fill a zome area (segment on a copper layer)
case TYPE_MARKER_PCB: // a marker used to show something
case TYPE_COTATION: // a dimension (graphic item)
case TYPE_MIRE: // a target (graphic item)
item->UnLink();
break;
// These items are deleted, but not put in undo list
case TYPE_MARKER_PCB: // a marker used to show something
case TYPE_ZONE: // a segment used to fill a zome area (segment on a copper layer)
item->UnLink();
itemsList->RemovePicker( ii );
ii--;
item->DeleteStructure();
break;
default:
wxMessageBox( wxT( "WinEDA_PcbFrame::Block_Delete( ) error: unexpected type" ) );
break;
@ -696,7 +707,6 @@ void WinEDA_PcbFrame::Block_Rotate()
m_Pcb->m_Status_Pcb = 0;
break;
case TYPE_ZONE: // a segment used to fill a zone area (segment on a copper layer)
case TYPE_ZONE_CONTAINER:
case TYPE_DRAWSEGMENT:
case TYPE_TEXTE:
@ -704,6 +714,11 @@ void WinEDA_PcbFrame::Block_Rotate()
case TYPE_COTATION:
break;
// This item is not put in undo list
case TYPE_ZONE: // a segment used to fill a zome area (segment on a copper layer)
itemsList->RemovePicker( ii );
ii--;
break;
default:
wxMessageBox( wxT( "WinEDA_PcbFrame::Block_Rotate( ) error: unexpected type" ) );
@ -763,7 +778,6 @@ void WinEDA_PcbFrame::Block_Flip()
m_Pcb->m_Status_Pcb = 0;
break;
case TYPE_ZONE: // a segment used to fill a zone area (segment on a copper layer)
case TYPE_ZONE_CONTAINER:
case TYPE_DRAWSEGMENT:
case TYPE_TEXTE:
@ -771,6 +785,12 @@ void WinEDA_PcbFrame::Block_Flip()
case TYPE_COTATION:
break;
// This item is not put in undo list
case TYPE_ZONE: // a segment used to fill a zome area (segment on a copper layer)
itemsList->RemovePicker( ii );
ii--;
break;
default:
wxMessageBox( wxT( "WinEDA_PcbFrame::Block_Flip( ) error: unexpected type" ) );
@ -825,7 +845,6 @@ void WinEDA_PcbFrame::Block_Move()
m_Pcb->m_Status_Pcb = 0;
break;
case TYPE_ZONE: // a segment used to fill a zome area (segment on a copper layer)
case TYPE_ZONE_CONTAINER:
case TYPE_DRAWSEGMENT:
case TYPE_TEXTE:
@ -833,6 +852,12 @@ void WinEDA_PcbFrame::Block_Move()
case TYPE_COTATION:
break;
// This item is not put in undo list
case TYPE_ZONE: // a segment used to fill a zome area (segment on a copper layer)
itemsList->RemovePicker( ii );
ii--;
break;
default:
wxMessageBox( wxT( "WinEDA_PcbFrame::Block_Move( ) error: unexpected type" ) );
break;
@ -905,10 +930,8 @@ void WinEDA_PcbFrame::Block_Duplicate()
case TYPE_ZONE: // a segment used to fill a zome area (segment on a copper layer)
{
SEGZONE* track = (SEGZONE*) item;
SEGZONE* new_track = (SEGZONE*) track->Copy();
newitem = new_track;
m_Pcb->m_Track.PushFront( new_track );
// SEG_ZONE items are not copied or put in undo list
// they must be recreated by zone filling
}
break;

57
pcbnew/board_undo_redo.cpp
View File

@ -126,11 +126,14 @@ void SwapData( BOARD_ITEM* aItem, BOARD_ITEM* aImage )
}
// Swap layers:
if( aItem->Type() != TYPE_MODULE ) // Modules have a global swap function
{
int layer, layerimg;
layer = aItem->GetLayer();
layerimg = aImage->GetLayer();
aItem->SetLayer( layerimg );
aImage->SetLayer( layer );
}
switch( aItem->Type() )
{
@ -211,7 +214,7 @@ BOARD_ITEM* DuplicateStruct( BOARD_ITEM* aItem )
{
if( aItem == NULL )
{
wxMessageBox( wxT( "DuplicateStruct error: NULL struct" ) );
wxMessageBox( wxT( "DuplicateStruct() error: NULL aItem" ) );
return NULL;
}
@ -380,28 +383,31 @@ void WinEDA_PcbFrame::SaveCopyInUndoList( PICKED_ITEMS_LIST& aItemsList,
PICKED_ITEMS_LIST* commandToUndo = new PICKED_ITEMS_LIST();
commandToUndo->m_TransformPoint = aTransformPoint;
// Copy picker list:
commandToUndo->CopyList( aItemsList );
ITEM_PICKER itemWrapper;
for( unsigned ii = 0; ii < aItemsList.GetCount(); ii++ )
// Verify list, and creates data if needed
for( unsigned ii = 0; ii < commandToUndo->GetCount(); ii++ )
{
BOARD_ITEM* item = (BOARD_ITEM*) aItemsList.GetPickedItem( ii );
UndoRedoOpType command = aItemsList.GetPickedItemStatus( ii );
BOARD_ITEM* item = (BOARD_ITEM*) commandToUndo->GetPickedItem( ii );
UndoRedoOpType command = commandToUndo->GetPickedItemStatus( ii );
if( command == UR_UNSPECIFIED )
{
command = aTypeCommand;
commandToUndo->SetPickedItemStatus(command, ii );
}
wxASSERT( item );
itemWrapper.m_PickedItem = item;
itemWrapper.m_PickedItemType = item->Type();
itemWrapper.m_UndoRedoStatus = command;
itemWrapper.m_Link = aItemsList.GetPickedItemLink( ii );
switch( command )
{
case UR_CHANGED: /* If needed, create a copy of item, and put in undo list */
if( itemWrapper.m_Link == NULL ) // When not null, the copy is already done
itemWrapper.m_Link = DuplicateStruct( item );
if( itemWrapper.m_Link )
commandToUndo->PushItem( itemWrapper );
case UR_CHANGED:
/* If needed, create a copy of item, and put in undo list
* in the picker, as link
* If this link is not null, the copy is already done
*/
if( commandToUndo->GetPickedItemLink(ii) == NULL )
commandToUndo->SetPickedItemLink( DuplicateStruct( item ), ii );
wxASSERT( commandToUndo->GetPickedItemLink(ii) );
break;
case UR_MOVED:
@ -410,7 +416,6 @@ void WinEDA_PcbFrame::SaveCopyInUndoList( PICKED_ITEMS_LIST& aItemsList,
case UR_FLIPPED:
case UR_NEW:
case UR_DELETED:
commandToUndo->PushItem( itemWrapper );
break;
default:
@ -428,10 +433,10 @@ void WinEDA_PcbFrame::SaveCopyInUndoList( PICKED_ITEMS_LIST& aItemsList,
/* Save the copy in undo list */
GetScreen()->PushCommandToUndoList( commandToUndo );
/* Clear redo list, because after new save there is no redo to do */
/* Clear redo list, because after a new command one cannot redo a command */
GetScreen()->ClearUndoORRedoList( GetScreen()->m_RedoList );
}
else
else // Should not occur
delete commandToUndo;
}
@ -452,21 +457,23 @@ void WinEDA_PcbFrame::PutDataInPreviousState( PICKED_ITEMS_LIST* aList, bool aRe
{
item = (BOARD_ITEM*) aList->GetPickedItem( ii );
wxASSERT( item );
#if 1
if( aList->GetPickedItemStatus( ii ) != UR_DELETED )
{
if( !TestForExistingItem( GetBoard(), item ) )
{
// Remove this non existant item
aList->RemovePickedItem( ii );
aList->RemovePicker( ii );
ii--; // the current item was removed, ii points now the next item
// whe must decrement it because it will be incremented
not_found = true;
continue;
}
}
#endif
item->m_Flags = 0;
// see if one must rebuild ratsnets and pointers lists
// see if we must rebuild ratsnets and pointers lists
switch( item->Type() )
{
case TYPE_MODULE:
@ -528,9 +535,9 @@ void WinEDA_PcbFrame::PutDataInPreviousState( PICKED_ITEMS_LIST* aList, bool aRe
}
if( not_found )
wxMessageBox( wxT( "Incomplete undo/redo command: item not found" ) );
wxMessageBox( wxT( "Incomplete undo/redo operation: some items not found" ) );
// Rebuild pointers and rastnest
// Rebuild pointers and rastnest that can be changed.
if( reBuild_ratsnest )
Compile_Ratsnest( NULL, true );
}
@ -542,8 +549,8 @@ void WinEDA_PcbFrame::GetBoardFromUndoList( wxCommandEvent& event )
/** Function GetBoardFromUndoList
* Undo the last edition:
* - Save the current board in Redo list
* - Get an old version of the board from Undo list
* - Save the current board state in Redo list
* - Get an old version of the board state from Undo list
* @return none
*/
{
@ -612,7 +619,7 @@ void PCB_SCREEN::ClearUndoORRedoList( UNDO_REDO_CONTAINER& aList, int aItemCount
unsigned icnt = aList.m_CommandsList.size();
if( aItemCount > 0 )
icnt = aItemCount;
bool displ_error = true;
for( unsigned ii = 0; ii < icnt; ii++ )
{
if( aList.m_CommandsList.size() == 0 )

8
pcbnew/dialog_edit_module.cpp
View File

@ -533,6 +533,14 @@ void WinEDA_ModulePropertiesFrame::OnOkClick( wxCommandEvent& event )
bool change_layer = FALSE;
wxPoint modpos;
if( m_CurrentModule->m_Flags == 0 ) // this is a simple edition, we must create an undo entry
{
if( m_Parent->m_Ident == PCB_FRAME )
m_Parent->SaveCopyInUndoList( m_CurrentModule, UR_CHANGED );
else
m_Parent->SaveCopyInUndoList( m_CurrentModule, UR_MODEDIT );
}
if( m_DC )
{
m_Parent->DrawPanel->CursorOff( m_DC );

41
pcbnew/editedge.cpp
View File

@ -20,8 +20,8 @@ static void Montre_Position_NewSegment( WinEDA_DrawPanel* panel, wxDC* DC, bool
static void Move_Segment( WinEDA_DrawPanel* panel, wxDC* DC, bool erase );
/* Variables locales : */
static wxPoint cursor_pos; // position originelle du curseur souris (fct deplacement)
static wxPoint cursor_pos0; // position courante du curseur souris
static wxPoint s_InitialPosition; // position originelle du curseur souris (fct deplacement)
static wxPoint s_LastPosition; // position courante du curseur souris
/****************************************************************************/
void WinEDA_PcbFrame::Start_Move_DrawItem( DRAWSEGMENT* drawitem, wxDC* DC )
@ -34,7 +34,7 @@ void WinEDA_PcbFrame::Start_Move_DrawItem( DRAWSEGMENT* drawitem, wxDC* DC )
return;
drawitem->Draw( DrawPanel, DC, GR_XOR );
drawitem->m_Flags |= IS_MOVED;
cursor_pos = cursor_pos0 = GetScreen()->m_Curseur;
s_InitialPosition = s_LastPosition = GetScreen()->m_Curseur;
drawitem->DisplayInfo( this );
DrawPanel->ManageCurseur = Move_Segment;
DrawPanel->ForceCloseManageCurseur = Exit_EditEdge;
@ -54,6 +54,7 @@ void WinEDA_PcbFrame::Place_DrawItem( DRAWSEGMENT* drawitem, wxDC* DC )
if( drawitem == NULL )
return;
SaveCopyInUndoList(drawitem, UR_MOVED, s_LastPosition - s_InitialPosition);
drawitem->Draw( DrawPanel, DC, GR_OR );
DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL;
@ -82,13 +83,10 @@ static void Move_Segment( WinEDA_DrawPanel* panel, wxDC* DC, bool erase )
Segment->Draw( panel, DC, GR_XOR );
wxPoint delta;
delta.x = panel->GetScreen()->m_Curseur.x - cursor_pos.x;
delta.y = panel->GetScreen()->m_Curseur.y - cursor_pos.y;
Segment->m_Start.x += delta.x;
Segment->m_Start.y += delta.y;
Segment->m_End.x += delta.x;
Segment->m_End.y += delta.y;
cursor_pos = panel->GetScreen()->m_Curseur;
delta = panel->GetScreen()->m_Curseur - s_LastPosition;
Segment->m_Start += delta;
Segment->m_End += delta;
s_LastPosition = panel->GetScreen()->m_Curseur;
Segment->Draw( panel, DC, GR_XOR );
DisplayOpt.DisplayDrawItems = t_fill;
@ -151,10 +149,12 @@ void WinEDA_PcbFrame::Delete_Drawings_All_Layer( DRAWSEGMENT* Segment, wxDC* DC
if( !IsOK( this, msg ) )
return;
PICKED_ITEMS_LIST pickList;
ITEM_PICKER picker(NULL, UR_DELETED);
BOARD_ITEM* PtNext;
for( BOARD_ITEM* item = GetBoard()->m_Drawings; item; item = PtNext )
{
GetScreen()->SetModify();
PtNext = item->Next();
switch( item->Type() )
@ -165,7 +165,9 @@ void WinEDA_PcbFrame::Delete_Drawings_All_Layer( DRAWSEGMENT* Segment, wxDC* DC
if( item->GetLayer() == layer )
{
item->Draw( DrawPanel, DC, GR_XOR );
item->DeleteStructure();
item->UnLink();
picker.m_PickedItem = item;
pickList.PushItem(picker);
}
break;
@ -174,6 +176,12 @@ void WinEDA_PcbFrame::Delete_Drawings_All_Layer( DRAWSEGMENT* Segment, wxDC* DC
break;
}
}
if( pickList.GetCount() )
{
GetScreen()->SetModify();
SaveCopyInUndoList(Segment, UR_DELETED);
}
}
@ -195,7 +203,7 @@ static void Exit_EditEdge( WinEDA_DrawPanel* Panel, wxDC* DC )
else
{
wxPoint pos = Panel->GetScreen()->m_Curseur;
Panel->GetScreen()->m_Curseur = cursor_pos0;
Panel->GetScreen()->m_Curseur = s_InitialPosition;
Panel->ManageCurseur( Panel, DC, TRUE );
Panel->GetScreen()->m_Curseur = pos;
Segment->m_Flags = 0;
@ -247,6 +255,7 @@ DRAWSEGMENT* WinEDA_PcbFrame::Begin_DrawSegment( DRAWSEGMENT* Segment,
{
if( Segment->m_Shape == S_SEGMENT )
{
SaveCopyInUndoList(Segment, UR_NEW );
GetBoard()->Add( Segment );
GetScreen()->SetModify();
@ -287,17 +296,15 @@ void WinEDA_PcbFrame::End_Edge( DRAWSEGMENT* Segment, wxDC* DC )
Segment->Draw( DrawPanel, DC, GR_OR );
/* Effacement si Longueur nulle */
if( (Segment->m_Start.x == Segment->m_End.x)
&& (Segment->m_Start.y == Segment->m_End.y) )
if( Segment->m_Start == Segment->m_End)
Segment ->DeleteStructure();
else
{
Segment->m_Flags = 0;
GetBoard()->Add( Segment );
GetScreen()->SetModify();
SaveCopyInUndoList(Segment, UR_NEW );
}
DrawPanel->ManageCurseur = NULL;

289
pcbnew/initpcb.cpp
View File

@ -33,108 +33,133 @@ void WinEDA_PcbFrame::InstallPcbGlobalDeleteFrame( const wxPoint& pos )
void WinEDA_PcbGlobalDeleteFrame::AcceptPcbDelete( wxCommandEvent& event )
/***********************************************************************/
{
int track_mask;
bool redraw = false;
bool gen_rastnest = false;
wxClientDC dc( m_Parent->DrawPanel );
m_Parent->DrawPanel->PrepareGraphicContext( &dc );
m_Parent->SetCurItem( NULL );
if( m_DelAlls->GetValue() )
{
m_Parent->Clear_Pcb( TRUE );
redraw = TRUE;
m_Parent->Clear_Pcb( true );
}
else
{
if( !IsOK( this, _( "Ok to delete selected items ?" ) ) )
return;
BOARD * pcb = m_Parent->GetBoard();
PICKED_ITEMS_LIST pickersList;
ITEM_PICKER itemPicker( NULL, UR_DELETED );
BOARD_ITEM* item, * nextitem;
if( m_DelZones->GetValue() )
{
m_Parent->Erase_Zones( TRUE );
gen_rastnest = true;
redraw = TRUE;
/* Segments used in Zone filling selection */
// for many reasons saving these items can create problems so they are not saved
// (because they are numerous and can be deleted in zones operation)
pcb->m_Zone.DeleteAll();
while( pcb->GetAreaCount() )
{
item = pcb->GetArea( 0 );
itemPicker.m_PickedItem = item;
pickersList.PushItem( itemPicker );
pcb->Remove( item );
}
}
if( m_DelTexts->GetValue() )
{
m_Parent->Erase_Textes_Pcb( TRUE );
redraw = TRUE;
}
int masque_layer = 0;
if( m_DelDrawings->GetValue() )
masque_layer = (~EDGE_LAYER) & 0x1FFF0000;
if( m_DelEdges->GetValue() )
{
m_Parent->Erase_Segments_Pcb( TRUE, TRUE );
redraw = TRUE;
}
masque_layer |= EDGE_LAYER;
if( m_DelDrawings->GetValue() )
for( item = pcb->m_Drawings; item != NULL; item = nextitem )
{
m_Parent->Erase_Segments_Pcb( FALSE, TRUE );
redraw = TRUE;
nextitem = item->Next();
bool removeme = (g_TabOneLayerMask[ item->GetLayer()] & masque_layer) != 0;
if( ( item->Type() == TYPE_TEXTE ) && m_DelTexts->GetValue() )
removeme = true;
if( removeme )
{
itemPicker.m_PickedItem = item;
pickersList.PushItem( itemPicker );
item->UnLink();
}
}
if( m_DelModules->GetValue() )
{
m_Parent->Erase_Modules( TRUE );
gen_rastnest = true;
redraw = TRUE;
for( item = pcb->m_Modules; item; item = nextitem )
{
nextitem = item->Next();
itemPicker.m_PickedItem = item;
pickersList.PushItem( itemPicker );
item->UnLink();
}
}
if( m_DelTracks->GetValue() )
{
track_mask = 0;
int track_mask_filter = 0;
if( !m_TrackFilterLocked->GetValue() )
track_mask |= SEGM_FIXE;
track_mask_filter |= SEGM_FIXE;
if( !m_TrackFilterAR->GetValue() )
track_mask |= SEGM_AR;
m_Parent->Erase_Pistes( &dc, track_mask, TRUE );
redraw = TRUE;
track_mask_filter |= SEGM_AR;
for( item = pcb->m_Track; item != NULL; item = nextitem )
{
nextitem = item->Next();
if( (item->GetState( SEGM_FIXE | SEGM_AR ) & track_mask_filter) != 0 )
continue;
itemPicker.m_PickedItem = item;
pickersList.PushItem( itemPicker );
item->UnLink();
gen_rastnest = true;
}
}
if( pickersList.GetCount() )
m_Parent->SaveCopyInUndoList( pickersList, UR_DELETED );
if( m_DelMarkers->GetValue() )
{
m_Parent->Erase_Marqueurs();
redraw = TRUE;
pcb->DeleteMARKERs();
if( gen_rastnest )
m_Parent->Compile_Ratsnest( NULL, true );
}
if ( gen_rastnest )
m_Parent->Compile_Ratsnest( &dc, true );
}
if( redraw )
{
m_Parent->DrawPanel->Refresh();
}
EndModal( 1 );
}
/*********************************************************/
bool WinEDA_BasePcbFrame::Clear_Pcb( bool query )
/*********************************************************/
/* Realise les init des pointeurs et variables
* Si query == FALSE, il n'y aura pas de confirmation
/** function WinEDA_PcbFrame::Clear_Pcb()
* delete all and reinitialize the current board
* @param aQuery = true to prompt user for confirmation, false to initialize silently
*/
bool WinEDA_PcbFrame::Clear_Pcb( bool aQuery )
{
if( GetBoard() == NULL )
return FALSE;
if( query && GetScreen()->IsModify() )
if( aQuery )
{
if( GetBoard()->m_Drawings || GetBoard()->m_Modules
|| GetBoard()->m_Track || GetBoard()->m_Zone )
{
if( !IsOK( this, _( "Current Board will be lost ?" ) ) )
if( !IsOK( this,
_( "Current Board will be lost and this operation and cannot be undone. Continue ?" ) ) )
return FALSE;
}
}
// Clear undo and redo lists because we want a full deletion
GetScreen()->ClearUndoRedoList();
// delete the old BOARD and create a new BOARD so that the default
// layer names are put into the BOARD.
SetBoard( new BOARD( NULL, this ) );
@ -146,7 +171,7 @@ bool WinEDA_BasePcbFrame::Clear_Pcb( bool query )
/* Init parametres de gestion */
wxRealPoint gridsize = GetScreen()->GetGrid();
((PCB_SCREEN*)GetScreen())->Init();
GetScreen()->Init();
GetScreen()->SetGrid( gridsize );
g_HightLigt_Status = 0;
@ -161,157 +186,51 @@ bool WinEDA_BasePcbFrame::Clear_Pcb( bool query )
g_DesignSettings.m_TrackWidthHistory[0] = g_DesignSettings.m_CurrentTrackWidth;
g_DesignSettings.m_TrackClearenceHistory[0] = g_DesignSettings.m_TrackClearence;
g_DesignSettings.m_ViaSizeHistory[0] = g_DesignSettings.m_CurrentViaSize;
/* NO, this is a global setting, and changing it here changes a loaded board's layer count when loading a module in the module editor since
the module editor calls this when loading an existing module.
g_DesignSettings.m_CopperLayerCount = 2; // Default copper layers count set to 2: double layer board
*/
Zoom_Automatique( TRUE );
Zoom_Automatique( true );
return TRUE;
return true;
}
/************************************************************/
void WinEDA_PcbFrame::Erase_Zones( bool query )
/************************************************************/
{
if( query && !IsOK( this, _( "Delete Zones ?" ) ) )
return;
GetBoard()->m_Zone.DeleteAll();
GetBoard()->DeleteZONEOutlines();
GetScreen()->SetModify();
}
/*****************************************************************************/
void WinEDA_PcbFrame::Erase_Segments_Pcb( bool is_edges, bool query )
/*****************************************************************************/
{
BOARD_ITEM* PtStruct;
BOARD_ITEM* PtNext;
int masque_layer = (~EDGE_LAYER) & 0x1FFF0000;
if( is_edges )
{
masque_layer = EDGE_LAYER;
if( query && !IsOK( this, _( "Delete Board edges ?" ) ) )
return;
}
else
{
if( query && !IsOK( this, _( "Delete draw items?" ) ) )
return;
}
PtStruct = GetBoard()->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtNext )
{
PtNext = PtStruct->Next();
switch( PtStruct->Type() )
{
case TYPE_DRAWSEGMENT:
case TYPE_TEXTE:
case TYPE_COTATION:
case TYPE_MIRE:
if( g_TabOneLayerMask[ PtStruct->GetLayer()] & masque_layer )
GetBoard()->Delete( PtStruct );
break;
default:
DisplayError( this, wxT( "Unknown/unexpected Draw Type" ) );
break;
}
}
GetScreen()->SetModify();
}
/**************************************************************************/
void WinEDA_PcbFrame::Erase_Pistes( wxDC * DC, int masque_type, bool query )
/**************************************************************************/
/* Efface les segments de piste, selon les autorisations affichees
* masque_type = masque des options de selection:
* SEGM_FIXE, SEGM_AR
* Si un des bits est a 1, il n'y a pas effacement du segment de meme bit a 1
/** function WinEDA_ModuleEditFrame::Clear_Pcb()
* delete all and reinitialize the current board
* @param aQuery = true to prompt user for confirmation, false to initialize silently
*/
bool WinEDA_ModuleEditFrame::Clear_Pcb( bool aQuery )
{
TRACK* pt_segm;
TRACK* PtNext;
if( GetBoard() == NULL )
return FALSE;
if( query && !IsOK( this, _( "Delete Tracks?" ) ) )
return;
/* Marquage des pistes a effacer */
for( pt_segm = GetBoard()->m_Track; pt_segm != NULL; pt_segm = (TRACK*) PtNext )
if( aQuery && GetScreen()->IsModify() )
{
PtNext = pt_segm->Next();
if( pt_segm->GetState( SEGM_FIXE | SEGM_AR ) & masque_type )
continue;
pt_segm->DeleteStructure();
if( GetBoard()->m_Modules )
{
if( !IsOK( this,
_( "Current Footprint will be lost and this operation and cannot be undone. Continue ?" ) ) )
return FALSE;
}
}
GetScreen()->SetModify();
Compile_Ratsnest( DC, TRUE );
}
/**************************************************************/
void WinEDA_PcbFrame::Erase_Modules( bool query )
/**************************************************************/
{
if( query && !IsOK( this, _( "Delete Modules?" ) ) )
return;
// Clear undo and redo lists
GetScreen()->ClearUndoRedoList();
// Delete the current footprint
GetBoard()->m_Modules.DeleteAll();
GetBoard()->m_Status_Pcb = 0;
m_Pcb->m_NetInfo->DeleteData();
m_Pcb->m_FullRatsnest.clear(); // empty the pad list pointers
m_Pcb->m_LocalRatsnest.clear(); // empty the pad list pointers
GetBoard()->m_NbNodes = 0;
GetBoard()->m_NbNoconnect = 0;
/* init pointeurs et variables */
GetScreen()->m_FileName.Empty();
GetScreen()->SetModify();
SetCurItem( NULL );
/* Init parametres de gestion */
wxRealPoint gridsize = GetScreen()->GetGrid();
GetScreen()->Init();
GetScreen()->SetGrid( gridsize );
Zoom_Automatique( true );
return true;
}
/************************************************************/
void WinEDA_PcbFrame::Erase_Textes_Pcb( bool query )
/************************************************************/
{
BOARD_ITEM* PtStruct, * PtNext;
if( query && !IsOK( this, _( "Delete Pcb Texts" ) ) )
return;
PtStruct = GetBoard()->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtNext )
{
PtNext = PtStruct->Next();
if( PtStruct->Type() == TYPE_TEXTE )
{
PtStruct->DeleteStructure();
}
}
GetScreen()->SetModify();
}
/*******************************************/
void WinEDA_PcbFrame::Erase_Marqueurs()
/*******************************************/
{
GetBoard()->DeleteMARKERs();
GetScreen()->SetModify(); // @todo : why mark this if MARKERs are not saved in the *.brd file?
}

4
pcbnew/modedit.cpp
View File

@ -364,8 +364,8 @@ void WinEDA_ModuleEditFrame::Process_Special_Functions( wxCommandEvent& event )
if( GetBoard()->m_Modules )
GetBoard()->m_Modules->m_Flags = 0;
//if either m_Reference or m_Value are gone, reinstate them -
//otherwise it becomes hard to see what you are working with in the layout!
// if either m_Reference or m_Value are gone, reinstall them -
// otherwise you cannot see what you are doing on board
if( GetBoard() && GetBoard()->m_Modules )
{
TEXTE_MODULE* ref = GetBoard()->m_Modules->m_Reference;

2
pcbnew/modules.cpp
View File

@ -122,7 +122,7 @@ void WinEDA_PcbFrame::StartMove_Module( MODULE* module, wxDC* DC )
if( g_Show_Ratsnest )
DrawGeneralRatsnest( DC );
if( g_DragSegmentList ) /* Anormal ! */
if( g_DragSegmentList ) /* Should not occur ! */
{
EraseDragListe();
}