void PCB_EDIT_FRAME::Block_Flip()
{
#define INVERT( pos ) (pos) = center.y - ( (pos) - center.y )
wxPoint memo;
wxPoint center; // Position of the axis for inversion of all elements
OnModify();
PICKED_ITEMS_LIST* itemsList = &GetScreen()->m_BlockLocate.GetItems();
itemsList->m_Status = UR_FLIPPED;
memo = GetCrossHairPosition();
center = GetScreen()->m_BlockLocate.Centre();
for( unsigned ii = 0; ii < itemsList->GetCount(); ii++ )
{
BOARD_ITEM* item = (BOARD_ITEM*) itemsList->GetPickedItem( ii );
wxASSERT( item );
itemsList->SetPickedItemStatus( UR_FLIPPED, ii );
item->Flip( center );
switch( item->Type() )
{
case PCB_MODULE_T:
item->ClearFlags();
m_Pcb->m_Status_Pcb = 0;
break;
// Move and rotate the track segments
case PCB_TRACE_T: // a track segment (segment on a copper layer)
case PCB_VIA_T: // a via (like track segment on a copper layer)
m_Pcb->m_Status_Pcb = 0;
break;
case PCB_ZONE_AREA_T:
case PCB_LINE_T:
case PCB_TEXT_T:
case PCB_TARGET_T:
case PCB_DIMENSION_T:
break;
// This item is not put in undo list
case PCB_ZONE_T: // SEG_ZONE items are now deprecated
itemsList->RemovePicker( ii );
ii--;
break;
default:
wxMessageBox( wxT( "PCB_EDIT_FRAME::Block_Flip( ) error: unexpected type" ) );
break;
}
}
SaveCopyInUndoList( *itemsList, UR_FLIPPED, center );
Compile_Ratsnest( NULL, true );
m_canvas->Refresh( true );
}
void PCB_EDIT_FRAME::Block_Delete()
{
OnModify();
SetCurItem( NULL );
PICKED_ITEMS_LIST* itemsList = &GetScreen()->m_BlockLocate.GetItems();
itemsList->m_Status = UR_DELETED;
// unlink items and clear flags
for( unsigned ii = 0; ii < itemsList->GetCount(); ii++ )
{
BOARD_ITEM* item = (BOARD_ITEM*) itemsList->GetPickedItem( ii );
itemsList->SetPickedItemStatus( UR_DELETED, ii );
GetBoard()->GetConnectivity()->Remove( item );
switch( item->Type() )
{
case PCB_MODULE_T:
{
MODULE* module = (MODULE*) item;
module->ClearFlags();
module->UnLink();
m_Pcb->m_Status_Pcb = 0;
}
break;
case PCB_ZONE_AREA_T: // a zone area
m_Pcb->Remove( item );
break;
case PCB_LINE_T: // a segment not on copper layers
case PCB_TEXT_T: // a text on a layer
case PCB_TRACE_T: // a track segment (segment on a copper layer)
case PCB_VIA_T: // a via (like track segment on a copper layer)
case PCB_DIMENSION_T: // a dimension (graphic item)
case PCB_TARGET_T: // a target (graphic item)
item->UnLink();
break;
// These items are deleted, but not put in undo list
case PCB_MARKER_T: // a marker used to show something
case PCB_ZONE_T: // SEG_ZONE items are now deprecated
item->UnLink();
itemsList->RemovePicker( ii );
ii--;
item->DeleteStructure();
break;
default:
wxMessageBox( wxT( "PCB_EDIT_FRAME::Block_Delete( ) error: unexpected type" ) );
break;
}
}
SaveCopyInUndoList( *itemsList, UR_DELETED );
Compile_Ratsnest( NULL, true );
m_canvas->Refresh( true );
}
void PCB_EDIT_FRAME::Block_Rotate()
{
wxPoint oldpos;
wxPoint centre; // rotation cent-re for the rotation transform
int rotAngle = 900; // rotation angle in 0.1 deg.
oldpos = GetScreen()->GetCrossHairPosition();
centre = GetScreen()->m_BlockLocate.Centre();
OnModify();
PICKED_ITEMS_LIST* itemsList = &GetScreen()->m_BlockLocate.m_ItemsSelection;
itemsList->m_Status = UR_ROTATED;
for( unsigned ii = 0; ii < itemsList->GetCount(); ii++ )
{
BOARD_ITEM* item = (BOARD_ITEM*) itemsList->GetPickedItem( ii );
wxASSERT( item );
itemsList->SetPickedItemStatus( UR_ROTATED, ii );
item->Rotate( centre, rotAngle );
switch( item->Type() )
{
case PCB_MODULE_T:
( (MODULE*) item )->ClearFlags();
m_Pcb->m_Status_Pcb = 0;
break;
/* Move and rotate the track segments */
case PCB_TRACE_T: // a track segment (segment on a copper layer)
case PCB_VIA_T: // a via (like track segment on a copper layer)
m_Pcb->m_Status_Pcb = 0;
break;
case PCB_ZONE_AREA_T:
case PCB_LINE_T:
case PCB_TEXT_T:
case PCB_TARGET_T:
case PCB_DIMENSION_T:
break;
// This item is not put in undo list
case PCB_ZONE_T: // SEG_ZONE items are now deprecated
itemsList->RemovePicker( ii );
ii--;
break;
default:
wxMessageBox( wxT( "PCB_EDIT_FRAME::Block_Rotate( ) error: unexpected type" ) );
break;
}
}
SaveCopyInUndoList( *itemsList, UR_ROTATED, centre );
Compile_Ratsnest( NULL, true );
m_canvas->Refresh( true );
}
/* Clear the flag CH_NOROUTABLE which is set to 1 by Solve(),
* when a track was not routed.
* (If this flag is 1 the corresponding track it is not rerouted)
*/
void PCB_EDIT_FRAME::Reset_Noroutable( wxDC* DC )
{
if( ( GetBoard()->m_Status_Pcb & LISTE_RATSNEST_ITEM_OK )== 0 )
Compile_Ratsnest( DC, true );
for( unsigned ii = 0; ii < GetBoard()->GetRatsnestsCount(); ii++ )
{
GetBoard()->m_FullRatsnest[ii].m_Status &= ~CH_UNROUTABLE;
}
}
void PCB_EDIT_FRAME::Block_Move()
{
OnModify();
wxPoint MoveVector = GetScreen()->m_BlockLocate.GetMoveVector();
PICKED_ITEMS_LIST* itemsList = &GetScreen()->m_BlockLocate.GetItems();
itemsList->m_Status = UR_MOVED;
for( unsigned ii = 0; ii < itemsList->GetCount(); ii++ )
{
BOARD_ITEM* item = (BOARD_ITEM*) itemsList->GetPickedItem( ii );
itemsList->SetPickedItemStatus( UR_MOVED, ii );
item->Move( MoveVector );
GetBoard()->GetConnectivity()->Update( item );
item->ClearFlags( IS_MOVED );
switch( item->Type() )
{
case PCB_MODULE_T:
m_Pcb->m_Status_Pcb = 0;
item->ClearFlags();
break;
// Move track segments
case PCB_TRACE_T: // a track segment (segment on a copper layer)
case PCB_VIA_T: // a via (like a track segment on a copper layer)
m_Pcb->m_Status_Pcb = 0;
break;
case PCB_ZONE_AREA_T:
case PCB_LINE_T:
case PCB_TEXT_T:
case PCB_TARGET_T:
case PCB_DIMENSION_T:
break;
// This item is not put in undo list
case PCB_ZONE_T: // SEG_ZONE items are now deprecated
itemsList->RemovePicker( ii );
ii--;
break;
default:
wxMessageBox( wxT( "PCB_EDIT_FRAME::Block_Move( ) error: unexpected type" ) );
break;
}
}
SaveCopyInUndoList( *itemsList, UR_MOVED, MoveVector );
Compile_Ratsnest( NULL, true );
m_canvas->Refresh( true );
}
void PCB_EDIT_FRAME::UseGalCanvas( bool aEnable )
{
PCB_BASE_EDIT_FRAME::UseGalCanvas( aEnable );
if( aEnable && GetBoard() )
GetBoard()->GetRatsnest()->ProcessBoard();
else
Compile_Ratsnest( NULL, true );
enableGALSpecificMenus();
}
void WinEDA_BasePcbFrame::test_1_net_connexion(wxDC * DC, int net_code)
/*************************************************************************/
/*
Routine recherchant les connexions deja faites relatives a 1 net
*/
{
TRACK * pt_start_conn, * pt_end_conn;
int ii, nb_net_noconnect = 0;
LISTE_PAD * pt_pad;
wxString msg;
if(net_code == 0) return;
if ( (m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0 )
Compile_Ratsnest( DC, TRUE );
pt_pad = (LISTE_PAD*)m_Pcb->m_Pads;
for( ii = 0; ii < m_Pcb->m_NbPads; ii++ , pt_pad++)
{
int pad_net_code = (*pt_pad)->m_NetCode;
if(pad_net_code < net_code) continue;
if(pad_net_code > net_code) break;
(*pt_pad)->m_physical_connexion = 0 ;
}
/* Determination des limites du net */
if( m_Pcb->m_Track )
{
pt_end_conn = NULL;
pt_start_conn = m_Pcb->m_Track->GetStartNetCode(net_code);
if( pt_start_conn )
pt_end_conn = pt_start_conn->GetEndNetCode(net_code);
if( pt_start_conn && pt_end_conn ) // c.a.d. s'il y a des segments
{
calcule_connexite_1_net(pt_start_conn, pt_end_conn);
}
}
/* Test des chevelus */
nb_net_noconnect = Test_1_Net_Ratsnest(DC, net_code);
/* Affichage des resultats */
msg.Printf( wxT("links %d nc %d net:nc %d"),
m_Pcb->m_NbLinks, m_Pcb->GetNumNoconnect(),
nb_net_noconnect);
Affiche_Message(msg);
return;
}
void PCB_EDIT_FRAME::UseGalCanvas( bool aEnable )
{
if( aEnable )
{
BOARD* board = GetBoard();
if( board )
board->GetRatsnest()->ProcessBoard();
}
else
{
Compile_Ratsnest( NULL, true );
}
PCB_BASE_EDIT_FRAME::UseGalCanvas( aEnable );
enableGALSpecificMenus();
}
void PCB_EDIT_FRAME::OnOrientFootprints( wxCommandEvent& event )
/****************************************************************/
/**
* Function OnOrientFootprints
* install the dialog box for the comman Orient Footprints
*/
{
DIALOG_ORIENT_FOOTPRINTS dlg(this);
if( dlg.ShowModal() != wxID_OK )
return;
wxString text = dlg.GetFilter();
if( ReOrientModules( text, dlg.GetOrientation(), dlg.ApplyToLockedModules() ) )
{
m_canvas->Refresh();
Compile_Ratsnest( NULL, true );
}
}
void PCB_EDIT_FRAME::Block_Duplicate( bool aIncrement )
{
wxPoint MoveVector = GetScreen()->m_BlockLocate.GetMoveVector();
OnModify();
PICKED_ITEMS_LIST* itemsList = &GetScreen()->m_BlockLocate.GetItems();
PICKED_ITEMS_LIST newList;
newList.m_Status = UR_NEW;
ITEM_PICKER picker( NULL, UR_NEW );
BOARD_ITEM* newitem;
for( unsigned ii = 0; ii < itemsList->GetCount(); ii++ )
{
BOARD_ITEM* item = (BOARD_ITEM*) itemsList->GetPickedItem( ii );
newitem = (BOARD_ITEM*)item->Clone();
if( aIncrement )
newitem->IncrementItemReference();
if( item->Type() == PCB_MODULE_T )
m_Pcb->m_Status_Pcb = 0;
m_Pcb->Add( newitem );
if( newitem )
{
newitem->Move( MoveVector );
picker.SetItem ( newitem );
newList.PushItem( picker );
}
}
if( newList.GetCount() )
SaveCopyInUndoList( newList, UR_NEW );
Compile_Ratsnest( NULL, true );
m_canvas->Refresh( true );
}
void PCB_EDIT_FRAME::SwitchCanvas( wxCommandEvent& aEvent )
{
int id = aEvent.GetId();
switch( id )
{
case ID_MENU_CANVAS_DEFAULT:
Compile_Ratsnest( NULL, true );
UseGalCanvas( false );
break;
case ID_MENU_CANVAS_CAIRO:
GetGalCanvas()->SwitchBackend( EDA_DRAW_PANEL_GAL::GAL_TYPE_CAIRO );
UseGalCanvas( true );
break;
case ID_MENU_CANVAS_OPENGL:
GetGalCanvas()->SwitchBackend( EDA_DRAW_PANEL_GAL::GAL_TYPE_OPENGL );
UseGalCanvas( true );
break;
}
}
void WinEDA_PcbFrame::Ratsnest_On_Off(wxDC * DC)
/***********************************************/
/* Affiche ou efface le chevelu selon l'etat du bouton d'appel */
{
int ii;
CHEVELU * pt_chevelu;
if((m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0 )
{
if ( g_Show_Ratsnest ) Compile_Ratsnest( DC, TRUE );
return;
}
DrawGeneralRatsnest(DC, 0); /* effacement eventuel du chevelu affiche */
pt_chevelu = m_Pcb->m_Ratsnest;
if ( pt_chevelu == NULL ) return;
if(g_Show_Ratsnest)
{
for( ii = m_Pcb->GetNumRatsnests(); ii > 0 ; pt_chevelu++, ii--)
{
pt_chevelu->status |= CH_VISIBLE;
}
DrawGeneralRatsnest(DC, 0);
}
else
{
for( ii = m_Pcb->GetNumRatsnests(); ii > 0; pt_chevelu++, ii--)
{
pt_chevelu->status &= ~CH_VISIBLE;
}
}
}
/* Install the cleanup dialog frame to know what should be cleaned
*/
void PCB_EDIT_FRAME::Clean_Pcb()
{
DIALOG_CLEANING_OPTIONS dlg( this );
if( dlg.ShowModal() != wxID_OK )
return;
wxBusyCursor( dummy );
TRACKS_CLEANER cleaner( GetBoard() );
cleaner.SetdeleteUnconnectedTracksOpt( dlg.m_deleteUnconnectedSegm );
cleaner.SetMergeSegmentsOpt( dlg.m_mergeSegments );
cleaner.SetCleanViasOpt( dlg.m_cleanVias );
if( cleaner.CleanupBoard() )
{
// Clear undo and redo lists to avoid inconsistencies between lists
GetScreen()->ClearUndoRedoList();
SetCurItem( NULL );
Compile_Ratsnest( NULL, true );
OnModify();
}
m_canvas->Refresh( true );
}
/* Called on events (popup menus) relative to automove and autoplace footprints
*/
void PCB_EDIT_FRAME::OnPlaceOrRouteFootprints( wxCommandEvent& event )
{
int id = event.GetId();
if( m_mainToolBar == NULL )
return;
INSTALL_UNBUFFERED_DC( dc, m_canvas );
switch( id )
{
case ID_POPUP_PCB_AUTOROUTE_SELECT_LAYERS:
return;
case ID_POPUP_PCB_AUTOPLACE_FIXE_MODULE:
LockModule( (MODULE*) GetScreen()->GetCurItem(), true );
return;
case ID_POPUP_PCB_AUTOPLACE_FREE_MODULE:
LockModule( (MODULE*) GetScreen()->GetCurItem(), false );
return;
case ID_POPUP_PCB_AUTOPLACE_FREE_ALL_MODULES:
LockModule( NULL, false );
return;
case ID_POPUP_PCB_AUTOPLACE_FIXE_ALL_MODULES:
LockModule( NULL, true );
return;
case ID_POPUP_CANCEL_CURRENT_COMMAND:
if( m_canvas->IsMouseCaptured() )
{
m_canvas->CallEndMouseCapture( &dc );
}
break;
default: // Abort a current command (if any)
m_canvas->EndMouseCapture( ID_NO_TOOL_SELECTED, m_canvas->GetDefaultCursor() );
break;
}
// Erase ratsnest if needed
if( GetBoard()->IsElementVisible(RATSNEST_VISIBLE) )
DrawGeneralRatsnest( &dc );
GetBoard()->m_Status_Pcb |= DO_NOT_SHOW_GENERAL_RASTNEST;
switch( id )
{
case ID_POPUP_PCB_AUTOPLACE_CURRENT_MODULE:
AutoPlaceModule( (MODULE*) GetScreen()->GetCurItem(), PLACE_1_MODULE, &dc );
break;
case ID_POPUP_PCB_AUTOPLACE_ALL_MODULES:
AutoPlaceModule( NULL, PLACE_ALL, &dc );
break;
case ID_POPUP_PCB_AUTOPLACE_NEW_MODULES:
AutoPlaceModule( NULL, PLACE_OUT_OF_BOARD, &dc );
break;
case ID_POPUP_PCB_AUTOPLACE_NEXT_MODULE:
AutoPlaceModule( NULL, PLACE_INCREMENTAL, &dc );
break;
case ID_POPUP_PCB_SPREAD_ALL_MODULES:
if( !IsOK( this,
_("Not locked footprints inside the board will be moved. OK?") ) )
break;
// Fall through
case ID_POPUP_PCB_SPREAD_NEW_MODULES:
if( GetBoard()->m_Modules == NULL )
{
DisplayError( this, _( "No footprint found!" ) );
return;
}
else
{
MODULE* footprint = GetBoard()->m_Modules;
std::vector<MODULE*> footprintList;
for( ; footprint != NULL; footprint = footprint->Next() )
footprintList.push_back( footprint );
SpreadFootprints( &footprintList, id == ID_POPUP_PCB_SPREAD_NEW_MODULES, true );
}
break;
case ID_POPUP_PCB_AUTOROUTE_ALL_MODULES:
Autoroute( &dc, ROUTE_ALL );
break;
case ID_POPUP_PCB_AUTOROUTE_MODULE:
Autoroute( &dc, ROUTE_MODULE );
break;
case ID_POPUP_PCB_AUTOROUTE_PAD:
Autoroute( &dc, ROUTE_PAD );
break;
case ID_POPUP_PCB_AUTOROUTE_NET:
Autoroute( &dc, ROUTE_NET );
break;
case ID_POPUP_PCB_AUTOROUTE_RESET_UNROUTED:
Reset_Noroutable( &dc );
break;
default:
wxMessageBox( wxT( "OnPlaceOrRouteFootprints command error" ) );
break;
}
GetBoard()->m_Status_Pcb &= ~DO_NOT_SHOW_GENERAL_RASTNEST;
Compile_Ratsnest( &dc, true );
}
/**
* Function PutDataInPreviousState
* Used in undo or redo command.
* Put data pointed by List in the previous state, i.e. the state memorised by List
* @param aList = a PICKED_ITEMS_LIST pointer to the list of items to undo/redo
* @param aRedoCommand = a bool: true for redo, false for undo
* @param aRebuildRatsnet = a bool: true to rebuid ratsnet (normal use, and default), false
* to just retrieve las state (used in abort commands that do not need to rebuild ratsnest)
*/
void PCB_EDIT_FRAME::PutDataInPreviousState( PICKED_ITEMS_LIST* aList, bool aRedoCommand,
bool aRebuildRatsnet )
{
BOARD_ITEM* item;
bool not_found = false;
bool reBuild_ratsnest = false;
// Undo in the reverse order of list creation: (this can allow stacked changes
// like the same item can be changes and deleted in the same complex command
bool build_item_list = true; // if true the list of esiting items must be rebuilt
for( int ii = aList->GetCount()-1; ii >= 0 ; ii-- )
{
item = (BOARD_ITEM*) aList->GetPickedItem( ii );
wxASSERT( item );
/* Test for existence of item on board.
* It could be deleted, and no more on board:
* - if a call to SaveCopyInUndoList was forgotten in Pcbnew
* - in zones outlines, when a change in one zone merges this zone with an other
* This test avoids a Pcbnew crash
* Obviouly, this test is not made for deleted items
*/
UNDO_REDO_T status = aList->GetPickedItemStatus( ii );
if( status != UR_DELETED )
{
if( build_item_list )
// Build list of existing items, for integrity test
TestForExistingItem( GetBoard(), NULL );
build_item_list = false;
if( !TestForExistingItem( GetBoard(), item ) )
{
// Remove this non existant item
aList->RemovePicker( ii );
ii++; // the current item was removed, ii points now the next item
// decrement it because it will be incremented later
not_found = true;
continue;
}
}
item->ClearFlags();
// see if we must rebuild ratsnets and pointers lists
switch( item->Type() )
{
case PCB_MODULE_T:
case PCB_ZONE_AREA_T:
case PCB_TRACE_T:
case PCB_VIA_T:
reBuild_ratsnest = true;
break;
default:
break;
}
switch( aList->GetPickedItemStatus( ii ) )
{
case UR_CHANGED: /* Exchange old and new data for each item */
{
BOARD_ITEM* image = (BOARD_ITEM*) aList->GetPickedItemLink( ii );
SwapData( item, image );
}
break;
case UR_NEW: /* new items are deleted */
aList->SetPickedItemStatus( UR_DELETED, ii );
GetBoard()->Remove( item );
break;
case UR_DELETED: /* deleted items are put in List, as new items */
aList->SetPickedItemStatus( UR_NEW, ii );
GetBoard()->Add( item );
build_item_list = true;
break;
case UR_MOVED:
item->Move( aRedoCommand ? aList->m_TransformPoint : -aList->m_TransformPoint );
break;
case UR_ROTATED:
item->Rotate( aList->m_TransformPoint, aRedoCommand ? 900 : -900 );
break;
case UR_ROTATED_CLOCKWISE:
item->Rotate( aList->m_TransformPoint, aRedoCommand ? -900 : 900 );
break;
case UR_FLIPPED:
item->Flip( aList->m_TransformPoint );
break;
default:
{
wxString msg;
msg.Printf( wxT( "PutDataInPreviousState() error (unknown code %X)" ),
aList->GetPickedItemStatus( ii ) );
wxMessageBox( msg );
}
break;
}
}
if( not_found )
wxMessageBox( wxT( "Incomplete undo/redo operation: some items not found" ) );
// Rebuild pointers and rastnest that can be changed.
if( reBuild_ratsnest && aRebuildRatsnet )
Compile_Ratsnest( NULL, true );
}
bool PCB_EDIT_FRAME::OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl )
{
// This is for python:
if( aFileSet.size() != 1 )
{
UTF8 msg = StrPrintf( "Pcbnew:%s() takes only a single filename", __func__ );
DisplayError( this, msg );
return false;
}
wxString fullFileName( aFileSet[0] );
// We insist on caller sending us an absolute path, if it does not, we say it's a bug.
wxASSERT_MSG( wxFileName( fullFileName ).IsAbsolute(), wxT( "Path is not absolute!" ) );
std::unique_ptr<wxSingleInstanceChecker> lockFile = ::LockFile( fullFileName );
if( !lockFile )
{
wxString msg = wxString::Format( _( "PCB file \"%s\" is already open." ), fullFileName );
DisplayError( this, msg );
return false;
}
if( GetScreen()->IsModify() && !GetBoard()->IsEmpty() )
{
if( !HandleUnsavedChanges( this, _( "The current PCB has been modified. Save changes?" ),
[&]()->bool { return SavePcbFile( GetBoard()->GetFileName(), CREATE_BACKUP_FILE ); } ) )
{
return false;
}
}
// Release the lock file, until the new file is actually loaded
ReleaseFile();
wxFileName pro = fullFileName;
pro.SetExt( ProjectFileExtension );
bool is_new = !wxFileName::IsFileReadable( fullFileName );
// If its a non-existent schematic and caller thinks it exists
if( is_new && !( aCtl & KICTL_CREATE ) )
{
// notify user that fullFileName does not exist, ask if user wants to create it.
wxString ask = wxString::Format( _( "PCB \"%s\" does not exist. Do you wish to create it?" ),
fullFileName );
if( !IsOK( this, ask ) )
return false;
}
Clear_Pcb( false ); // pass false since we prompted above for a modified board
IO_MGR::PCB_FILE_T pluginType = plugin_type( fullFileName, aCtl );
bool converted = pluginType != IO_MGR::LEGACY && pluginType != IO_MGR::KICAD_SEXP;
if( !converted )
{
// PROJECT::SetProjectFullName() is an impactful function. It should only be
// called under carefully considered circumstances.
// The calling code should know not to ask me here to change projects unless
// it knows what consequences that will have on other KIFACEs running and using
// this same PROJECT. It can be very harmful if that calling code is stupid.
Prj().SetProjectFullName( pro.GetFullPath() );
// load project settings before BOARD
LoadProjectSettings();
}
if( is_new )
{
OnModify();
}
else
{
BOARD* loadedBoard = 0; // it will be set to non-NULL if loaded OK
PLUGIN::RELEASER pi( IO_MGR::PluginFind( pluginType ) );
// This will rename the file if there is an autosave and the user want to recover
CheckForAutoSaveFile( fullFileName );
try
{
PROPERTIES props;
char xbuf[30];
char ybuf[30];
// EAGLE_PLUGIN can use this info to center the BOARD, but it does not yet.
sprintf( xbuf, "%d", GetPageSizeIU().x );
sprintf( ybuf, "%d", GetPageSizeIU().y );
props["page_width"] = xbuf;
props["page_height"] = ybuf;
#if USE_INSTRUMENTATION
// measure the time to load a BOARD.
unsigned startTime = GetRunningMicroSecs();
#endif
loadedBoard = pi->Load( fullFileName, NULL, &props );
#if USE_INSTRUMENTATION
unsigned stopTime = GetRunningMicroSecs();
printf( "PLUGIN::Load(): %u usecs\n", stopTime - startTime );
#endif
}
catch( const IO_ERROR& ioe )
{
if( ioe.Problem() != wxT( "CANCEL" ) )
{
wxString msg = wxString::Format( _( "Error loading board file:\n%s" ), fullFileName );
DisplayErrorMessage( this, msg, ioe.What() );
}
return false;
}
// 6.0 TODO: some settings didn't make it into the board file in 5.1 so as not to
// change the file format. For 5.1 we must copy them across from the config-initialized
// board.
BOARD_DESIGN_SETTINGS& bds = loadedBoard->m_designSettings;
BOARD_DESIGN_SETTINGS& configBds = GetBoard()->GetDesignSettings();
bds.m_RequireCourtyards = configBds.m_RequireCourtyards;
bds.m_ProhibitOverlappingCourtyards = configBds.m_ProhibitOverlappingCourtyards;
bds.m_HoleToHoleMin = configBds.m_HoleToHoleMin;
bds.m_LineThickness[LAYER_CLASS_OTHERS] = configBds.m_LineThickness[LAYER_CLASS_OTHERS];
bds.m_TextSize[LAYER_CLASS_OTHERS] = configBds.m_TextSize[LAYER_CLASS_OTHERS];
bds.m_TextThickness[LAYER_CLASS_OTHERS] = configBds.m_TextThickness[LAYER_CLASS_OTHERS];
std::copy( configBds.m_TextItalic, configBds.m_TextItalic + 4, bds.m_TextItalic );
std::copy( configBds.m_TextUpright, configBds.m_TextUpright + 4, bds.m_TextUpright );
bds.m_DiffPairDimensionsList = configBds.m_DiffPairDimensionsList;
bds.m_CopperEdgeClearance = configBds.m_CopperEdgeClearance;
SetBoard( loadedBoard );
// we should not ask PLUGINs to do these items:
loadedBoard->BuildListOfNets();
loadedBoard->SynchronizeNetsAndNetClasses();
// If this is a legacy board then we set the copper edge clearance to 1/2 the edge-cut
// line width (which was a legacy kludge for implementing edge clearances).
if( bds.m_CopperEdgeClearance == Millimeter2iu( LEGACY_COPPEREDGECLEARANCE ) )
bds.SetCopperEdgeClearance( inferLegacyEdgeClearance( loadedBoard ) );
if( loadedBoard->IsModified() )
OnModify();
else
GetScreen()->ClrModify();
if( pluginType == IO_MGR::LEGACY &&
loadedBoard->GetFileFormatVersionAtLoad() < LEGACY_BOARD_FILE_VERSION )
{
DisplayInfoMessage( this,
_( "This file was created by an older version of Pcbnew.\n"
"It will be stored in the new file format when you save this file again." ) );
}
}
{
wxFileName fn = fullFileName;
if( converted )
fn.SetExt( PcbFileExtension );
wxString fname = fn.GetFullPath();
fname.Replace( WIN_STRING_DIR_SEP, UNIX_STRING_DIR_SEP );
GetBoard()->SetFileName( fname );
}
// Lock the file newly opened:
m_file_checker.reset( lockFile.release() );
if( !converted )
UpdateFileHistory( GetBoard()->GetFileName() );
// Rebuild the new pad list (for drc and ratsnet control ...)
GetBoard()->m_Status_Pcb = 0;
// Select netclass Default as current netclass (it always exists)
SetCurrentNetClass( NETCLASS::Default );
// Rebuild list of nets (full ratsnest rebuild)
Compile_Ratsnest( NULL, true );
GetBoard()->BuildConnectivity();
onBoardLoaded();
// Refresh the 3D view, if any
EDA_3D_VIEWER* draw3DFrame = Get3DViewerFrame();
if( draw3DFrame )
draw3DFrame->NewDisplay();
#if 0 && defined(DEBUG)
// Output the board object tree to stdout, but please run from command prompt:
GetBoard()->Show( 0, std::cout );
#endif
// from EDA_APPL which was first loaded BOARD only:
{
/* For an obscure reason the focus is lost after loading a board file
* when starting up the process.
* (seems due to the recreation of the layer manager after loading the file)
* Give focus to main window and Drawpanel
* must be done for these 2 windows (for an obscure reason ...)
* Linux specific
* This is more a workaround than a fix.
*/
SetFocus();
GetCanvas()->SetFocus();
}
return true;
}
void PCB_EDIT_FRAME::Show_1_Ratsnest( EDA_ITEM* item, wxDC* DC )
{
D_PAD* pt_pad = NULL;
MODULE* Module = NULL;
if( GetBoard()->IsElementVisible(RATSNEST_VISIBLE) )
return;
if( ( GetBoard()->m_Status_Pcb & LISTE_RATSNEST_ITEM_OK ) == 0 )
Compile_Ratsnest( DC, true );
if( item )
{
if( item->Type() == PCB_PAD_T )
{
pt_pad = (D_PAD*) item;
Module = pt_pad->GetParent();
}
if( pt_pad ) // Displaying the ratsnest of the corresponding net.
{
SetMsgPanel( pt_pad );
for( unsigned ii = 0; ii < GetBoard()->GetRatsnestsCount(); ii++ )
{
RATSNEST_ITEM* net = &GetBoard()->m_FullRatsnest[ii];
if( net->GetNet() == pt_pad->GetNetCode() )
{
if( ( net->m_Status & CH_VISIBLE ) != 0 )
continue;
net->m_Status |= CH_VISIBLE;
if( ( net->m_Status & CH_ACTIF ) == 0 )
continue;
net->Draw( m_canvas, DC, GR_XOR, wxPoint( 0, 0 ) );
}
}
}
else
{
if( item->Type() == PCB_MODULE_TEXT_T )
{
if( item->GetParent() && ( item->GetParent()->Type() == PCB_MODULE_T ) )
Module = static_cast<MODULE*>( item->GetParent() );
}
else if( item->Type() == PCB_MODULE_T )
{
Module = static_cast<MODULE*>( item );
}
if( Module )
{
SetMsgPanel( Module );
pt_pad = Module->Pads();
for( ; pt_pad != NULL; pt_pad = pt_pad->Next() )
{
for( unsigned ii = 0; ii < GetBoard()->GetRatsnestsCount(); ii++ )
{
RATSNEST_ITEM* net = &GetBoard()->m_FullRatsnest[ii];
if( ( net->m_PadStart == pt_pad ) || ( net->m_PadEnd == pt_pad ) )
{
if( net->m_Status & CH_VISIBLE )
continue;
net->m_Status |= CH_VISIBLE;
if( (net->m_Status & CH_ACTIF) == 0 )
continue;
net->Draw( m_canvas, DC, GR_XOR, wxPoint( 0, 0 ) );
}
}
}
pt_pad = NULL;
}
}
}
// Erase if no pad or module has been selected.
if( ( pt_pad == NULL ) && ( Module == NULL ) )
{
DrawGeneralRatsnest( DC );
for( unsigned ii = 0; ii < GetBoard()->GetRatsnestsCount(); ii++ )
GetBoard()->m_FullRatsnest[ii].m_Status &= ~CH_VISIBLE;
}
}
/* init board, route traces*/
void PCB_EDIT_FRAME::Autoroute( wxDC* DC, int mode )
{
int start, stop;
MODULE* Module = NULL;
D_PAD* Pad = NULL;
int autoroute_net_code = -1;
wxString msg;
if( GetBoard()->GetCopperLayerCount() > 1 )
{
g_Route_Layer_TOP = GetScreen()->m_Route_Layer_TOP;
g_Route_Layer_BOTTOM = GetScreen()->m_Route_Layer_BOTTOM;
}
else
{
g_Route_Layer_TOP = g_Route_Layer_BOTTOM = LAYER_N_BACK;
}
switch( mode )
{
case ROUTE_NET:
if( GetScreen()->GetCurItem() )
{
switch( GetScreen()->GetCurItem()->Type() )
{
case PCB_PAD_T:
Pad = (D_PAD*) GetScreen()->GetCurItem();
autoroute_net_code = Pad->GetNetCode();
break;
default:
break;
}
}
if( autoroute_net_code <= 0 )
{
wxMessageBox( _( "Net not selected" ) ); return;
}
break;
case ROUTE_MODULE:
Module = (MODULE*) GetScreen()->GetCurItem();
if( (Module == NULL) || (Module->Type() != PCB_MODULE_T) )
{
wxMessageBox( _( "Module not selected" ) );
return;
}
break;
case ROUTE_PAD:
Pad = (D_PAD*) GetScreen()->GetCurItem();
if( (Pad == NULL) || (Pad->Type() != PCB_PAD_T) )
{
wxMessageBox( _( "Pad not selected" ) );
return;
}
break;
}
if( (GetBoard()->m_Status_Pcb & LISTE_RATSNEST_ITEM_OK ) == 0 )
Compile_Ratsnest( DC, true );
/* Set the flag on the ratsnest to CH_ROUTE_REQ. */
for( unsigned ii = 0; ii < GetBoard()->GetRatsnestsCount(); ii++ )
{
RATSNEST_ITEM* ptmp = &GetBoard()->m_FullRatsnest[ii];
ptmp->m_Status &= ~CH_ROUTE_REQ;
switch( mode )
{
case ROUTE_ALL:
ptmp->m_Status |= CH_ROUTE_REQ;
break;
case ROUTE_NET:
if( autoroute_net_code == ptmp->GetNet() )
ptmp->m_Status |= CH_ROUTE_REQ;
break;
case ROUTE_MODULE:
{
D_PAD* pt_pad = (D_PAD*) Module->Pads();
for( ; pt_pad != NULL; pt_pad = pt_pad->Next() )
{
if( ptmp->m_PadStart == pt_pad )
ptmp->m_Status |= CH_ROUTE_REQ;
if( ptmp->m_PadEnd == pt_pad )
ptmp->m_Status |= CH_ROUTE_REQ;
}
break;
}
case ROUTE_PAD:
if( ( ptmp->m_PadStart == Pad ) || ( ptmp->m_PadEnd == Pad ) )
ptmp->m_Status |= CH_ROUTE_REQ;
break;
}
}
start = time( NULL );
/* Calculation of no fixed routing to 5 mils and more. */
RoutingMatrix.m_GridRouting = (int)GetScreen()->GetGridSize().x;
if( RoutingMatrix.m_GridRouting < (5*IU_PER_MILS) )
RoutingMatrix.m_GridRouting = 5*IU_PER_MILS;
/* Calculated ncol and nrow, matrix size for routing. */
RoutingMatrix.ComputeMatrixSize( GetBoard() );
m_messagePanel->EraseMsgBox();
/* Map the board */
RoutingMatrix.m_RoutingLayersCount = 1;
if( g_Route_Layer_TOP != g_Route_Layer_BOTTOM )
RoutingMatrix.m_RoutingLayersCount = 2;
if( RoutingMatrix.InitRoutingMatrix() < 0 )
{
wxMessageBox( _( "No memory for autorouting" ) );
RoutingMatrix.UnInitRoutingMatrix(); /* Free memory. */
return;
}
SetStatusText( _( "Place Cells" ) );
PlaceCells( GetBoard(), -1, FORCE_PADS );
/* Construction of the track list for router. */
RoutingMatrix.m_RouteCount = Build_Work( GetBoard() );
// DisplayRoutingMatrix( m_canvas, DC );
Solve( DC, RoutingMatrix.m_RoutingLayersCount );
/* Free memory. */
FreeQueue();
InitWork(); /* Free memory for the list of router connections. */
RoutingMatrix.UnInitRoutingMatrix();
stop = time( NULL ) - start;
msg.Printf( wxT( "time = %d second%s" ), stop, ( stop == 1 ) ? wxT( "" ) : wxT( "s" ) );
SetStatusText( msg );
}
void PCB_EDIT_FRAME::OnSelectTool( wxCommandEvent& aEvent )
{
int id = aEvent.GetId();
if( GetToolId() == id )
return;
INSTALL_UNBUFFERED_DC( dc, m_canvas );
// Stop the current command and deselect the current tool.
m_canvas->EndMouseCapture( ID_NO_TOOL_SELECTED, m_canvas->GetDefaultCursor() );
switch( id )
{
case ID_NO_TOOL_SELECTED:
SetToolID( id, m_canvas->GetDefaultCursor(), wxEmptyString );
break;
case ID_TRACK_BUTT:
if( g_Drc_On )
SetToolID( id, wxCURSOR_PENCIL, _( "Add tracks" ) );
else
SetToolID( id, wxCURSOR_QUESTION_ARROW, _( "Add tracks" ) );
if( (GetBoard()->m_Status_Pcb & LISTE_RATSNEST_ITEM_OK) == 0 )
{
Compile_Ratsnest( &dc, true );
}
break;
case ID_PCB_MODULE_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _( "Add module" ) );
break;
case ID_PCB_ZONES_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _( "Add zones" ) );
if( DisplayOpt.DisplayZonesMode != 0 )
DisplayInfoMessage( this, _( "Warning: zone display is OFF!!!" ) );
if( !GetBoard()->IsHighLightNetON() && (GetBoard()->GetHighLightNetCode() > 0 ) )
HighLight( &dc );
break;
case ID_PCB_KEEPOUT_AREA_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _( "Add keepout" ) );
break;
case ID_PCB_MIRE_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _( "Add layer alignment target" ) );
break;
case ID_PCB_PLACE_OFFSET_COORD_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _( "Adjust zero" ) );
break;
case ID_PCB_PLACE_GRID_COORD_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _( "Adjust grid origin" ) );
break;
case ID_PCB_ADD_LINE_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _( "Add graphic line" ) );
break;
case ID_PCB_ARC_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _( "Add graphic arc" ) );
break;
case ID_PCB_CIRCLE_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _( "Add graphic circle" ) );
break;
case ID_PCB_ADD_TEXT_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _( "Add text" ) );
break;
case ID_COMPONENT_BUTT:
SetToolID( id, wxCURSOR_HAND, _( "Add module" ) );
break;
case ID_PCB_DIMENSION_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _( "Add dimension" ) );
break;
case ID_PCB_DELETE_ITEM_BUTT:
SetToolID( id, wxCURSOR_BULLSEYE, _( "Delete item" ) );
break;
case ID_PCB_HIGHLIGHT_BUTT:
SetToolID( id, wxCURSOR_HAND, _( "Highlight net" ) );
break;
case ID_PCB_SHOW_1_RATSNEST_BUTT:
SetToolID( id, wxCURSOR_HAND, _( "Select rats nest" ) );
if( ( GetBoard()->m_Status_Pcb & LISTE_RATSNEST_ITEM_OK ) == 0 )
Compile_Ratsnest( &dc, true );
break;
}
}
/* Driver function: processing starts here */
void PCB_EDIT_FRAME::ExportToGenCAD( wxCommandEvent& aEvent )
{
wxFileName fn = GetBoard()->GetFileName();
FILE* file;
wxString ext = wxT( "cad" );
wxString wildcard = _( "GenCAD 1.4 board files (.cad)|*.cad" );
fn.SetExt( ext );
wxString pro_dir = wxPathOnly( Prj().GetProjectFullName() );
wxFileDialog dlg( this, _( "Save GenCAD Board File" ), pro_dir,
fn.GetFullName(), wildcard,
wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
if( dlg.ShowModal() == wxID_CANCEL )
return;
if( ( file = wxFopen( dlg.GetPath(), wxT( "wt" ) ) ) == NULL )
{
wxString msg;
msg.Printf( _( "Unable to create <%s>" ), GetChars( dlg.GetPath() ) );
DisplayError( this, msg ); return;
}
SetLocaleTo_C_standard(); // No pesky decimal separators in gencad
// Update some board data, to ensure a reliable gencad export
GetBoard()->ComputeBoundingBox();
// Save the auxiliary origin for the rest of the module
GencadOffsetX = GetAuxOrigin().x;
GencadOffsetY = GetAuxOrigin().y;
// No idea on *why* this should be needed... maybe to fix net names?
Compile_Ratsnest( NULL, true );
/* Temporary modification of footprints that are flipped (i.e. on bottom
* layer) to convert them to non flipped footprints.
* This is necessary to easily export shapes to GenCAD,
* that are given as normal orientation (non flipped, rotation = 0))
* these changes will be undone later
*/
BOARD* pcb = GetBoard();
MODULE* module;
for( module = pcb->m_Modules; module; module = module->Next() )
{
module->SetFlag( 0 );
if( module->GetLayer() == B_Cu )
{
module->Flip( module->GetPosition() );
module->SetFlag( 1 );
}
}
/* Gencad has some mandatory and some optional sections: some importer
* need the padstack section (which is optional) anyway. Also the
* order of the section *is* important */
CreateHeaderInfoData( file, this ); // Gencad header
CreateBoardSection( file, pcb ); // Board perimeter
CreatePadsShapesSection( file, pcb ); // Pads and padstacks
CreateArtworksSection( file ); // Empty but mandatory
/* Gencad splits a component info in shape, component and device.
* We don't do any sharing (it would be difficult since each module is
* customizable after placement) */
CreateShapesSection( file, pcb );
CreateComponentsSection( file, pcb );
CreateDevicesSection( file, pcb );
// In a similar way the netlist is split in net, track and route
CreateSignalsSection( file, pcb );
CreateTracksInfoData( file, pcb );
CreateRoutesSection( file, pcb );
fclose( file );
SetLocaleTo_Default(); // revert to the current locale
// Undo the footprints modifications (flipped footprints)
for( module = pcb->m_Modules; module; module = module->Next() )
{
if( module->GetFlag() )
{
module->Flip( module->GetPosition() );
module->SetFlag( 0 );
}
}
}
bool PCB_EDIT_FRAME::OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl )
{
// This is for python:
if( aFileSet.size() != 1 )
{
UTF8 msg = StrPrintf( "Pcbnew:%s() takes only a single filename", __func__ );
DisplayError( this, msg );
return false;
}
wxString fullFileName( aFileSet[0] );
// We insist on caller sending us an absolute path, if it does not, we say it's a bug.
wxASSERT_MSG( wxFileName( fullFileName ).IsAbsolute(),
wxT( "bug in single_top.cpp or project manager." ) );
if( !LockFile( fullFileName ) )
{
wxString msg = wxString::Format( _(
"PCB file '%s' is already open." ),
GetChars( fullFileName )
);
DisplayError( this, msg );
return false;
}
if( GetScreen()->IsModify() )
{
int response = YesNoCancelDialog( this, _(
"The current board has been modified. Do you wish to save the changes?" ),
wxEmptyString,
_( "Save and Load" ),
_( "Load Without Saving" )
);
if( response == wxID_CANCEL )
return false;
else if( response == wxID_YES )
SavePcbFile( GetBoard()->GetFileName(), CREATE_BACKUP_FILE );
else
{
// response == wxID_NO, fall thru
}
}
wxFileName pro = fullFileName;
pro.SetExt( ProjectFileExtension );
bool is_new = !wxFileName::IsFileReadable( fullFileName );
// If its a non-existent schematic and caller thinks it exists
if( is_new && !( aCtl & KICTL_CREATE ) )
{
// notify user that fullFileName does not exist, ask if user wants to create it.
wxString ask = wxString::Format( _(
"Board '%s' does not exist. Do you wish to create it?" ),
GetChars( fullFileName )
);
if( !IsOK( this, ask ) )
return false;
}
Clear_Pcb( false ); // pass false since we prompted above for a modified board
IO_MGR::PCB_FILE_T pluginType = plugin_type( fullFileName, aCtl );
bool converted = pluginType != IO_MGR::LEGACY && pluginType != IO_MGR::KICAD;
if( !converted )
{
// PROJECT::SetProjectFullName() is an impactful function. It should only be
// called under carefully considered circumstances.
// The calling code should know not to ask me here to change projects unless
// it knows what consequences that will have on other KIFACEs running and using
// this same PROJECT. It can be very harmful if that calling code is stupid.
Prj().SetProjectFullName( pro.GetFullPath() );
// load project settings before BOARD
LoadProjectSettings();
}
if( is_new )
{
OnModify();
}
else
{
BOARD* loadedBoard = 0; // it will be set to non-NULL if loaded OK
PLUGIN::RELEASER pi( IO_MGR::PluginFind( pluginType ) );
try
{
PROPERTIES props;
char xbuf[30];
char ybuf[30];
// EAGLE_PLUGIN can use this info to center the BOARD, but it does not yet.
sprintf( xbuf, "%d", GetPageSizeIU().x );
sprintf( ybuf, "%d", GetPageSizeIU().y );
props["page_width"] = xbuf;
props["page_height"] = ybuf;
#if USE_INSTRUMENTATION
// measure the time to load a BOARD.
unsigned startTime = GetRunningMicroSecs();
#endif
loadedBoard = pi->Load( fullFileName, NULL, &props );
#if USE_INSTRUMENTATION
unsigned stopTime = GetRunningMicroSecs();
printf( "PLUGIN::Load(): %u usecs\n", stopTime - startTime );
#endif
}
catch( const IO_ERROR& ioe )
{
wxString msg = wxString::Format( _(
"Error loading board.\n%s" ),
GetChars( ioe.errorText )
);
DisplayError( this, msg );
return false;
}
SetBoard( loadedBoard );
// we should not ask PLUGINs to do these items:
loadedBoard->BuildListOfNets();
loadedBoard->SynchronizeNetsAndNetClasses();
SetStatusText( wxEmptyString );
BestZoom();
// update the layer names in the listbox
ReCreateLayerBox( false );
GetScreen()->ClrModify();
{
wxFileName fn = fullFileName;
CheckForAutoSaveFile( fullFileName, fn.GetExt() );
}
if( pluginType == IO_MGR::LEGACY &&
loadedBoard->GetFileFormatVersionAtLoad() < LEGACY_BOARD_FILE_VERSION )
{
DisplayInfoMessage( this,
_( "This file was created by an older version of Pcbnew.\n"
"It will be stored in the new file format when you save this file again." ) );
}
}
{
wxFileName fn = fullFileName;
if( converted )
fn.SetExt( PcbFileExtension );
wxString fname = fn.GetFullPath();
fname.Replace( WIN_STRING_DIR_SEP, UNIX_STRING_DIR_SEP );
GetBoard()->SetFileName( fname );
}
UpdateTitle();
if( !converted )
UpdateFileHistory( GetBoard()->GetFileName() );
// Rebuild the new pad list (for drc and ratsnet control ...)
GetBoard()->m_Status_Pcb = 0;
// Update info shown by the horizontal toolbars
SetCurrentNetClass( NETCLASS::Default );
ReFillLayerWidget();
ReCreateLayerBox();
// upate the layer widget to match board visibility states, both layers and render columns.
syncLayerVisibilities();
syncLayerWidgetLayer();
syncRenderStates();
// Update the tracks / vias available sizes list:
ReCreateAuxiliaryToolbar();
// Update the RATSNEST items, which were not loaded at the time
// BOARD::SetVisibleElements() was called from within any PLUGIN.
// See case RATSNEST_VISIBLE: in BOARD::SetElementVisibility()
GetBoard()->SetVisibleElements( GetBoard()->GetVisibleElements() );
// Display the loaded board:
Zoom_Automatique( false );
// Compile ratsnest and displays net info
{
wxBusyCursor dummy; // Displays an Hourglass while building connectivity
Compile_Ratsnest( NULL, true );
GetBoard()->GetRatsnest()->ProcessBoard();
}
SetMsgPanel( GetBoard() );
// Refresh the 3D view, if any
if( m_Draw3DFrame )
m_Draw3DFrame->NewDisplay();
#if 0 && defined(DEBUG)
// Output the board object tree to stdout, but please run from command prompt:
GetBoard()->Show( 0, std::cout );
#endif
// from EDA_APPL which was first loaded BOARD only:
{
/* For an obscure reason the focus is lost after loading a board file
* when starting up the process.
* (seems due to the recreation of the layer manager after loading the file)
* Give focus to main window and Drawpanel
* must be done for these 2 windows (for an obscure reason ...)
* Linux specific
* This is more a workaround than a fix.
*/
SetFocus();
GetCanvas()->SetFocus();
}
return true;
}
void PCB_EDIT_FRAME::Block_Rotate()
{
wxPoint centre; // rotation cent-re for the rotation transform
int rotAngle = m_rotationAngle; // rotation angle in 0.1 deg.
centre = GetScreen()->m_BlockLocate.Centre();
OnModify();
PICKED_ITEMS_LIST* itemsList = &GetScreen()->m_BlockLocate.GetItems();
itemsList->m_Status = UR_CHANGED;
for( unsigned ii = 0; ii < itemsList->GetCount(); ii++ )
{
BOARD_ITEM* item = (BOARD_ITEM*) itemsList->GetPickedItem( ii );
wxASSERT( item );
itemsList->SetPickedItemStatus( UR_CHANGED, ii );
switch( item->Type() )
{
case PCB_MODULE_T:
( (MODULE*) item )->ClearFlags();
m_Pcb->m_Status_Pcb = 0;
break;
// Move and rotate the track segments
case PCB_TRACE_T: // a track segment (segment on a copper layer)
case PCB_VIA_T: // a via (like track segment on a copper layer)
m_Pcb->m_Status_Pcb = 0;
break;
case PCB_ZONE_AREA_T:
case PCB_LINE_T:
case PCB_TEXT_T:
case PCB_TARGET_T:
case PCB_DIMENSION_T:
break;
// This item is not put in undo list
case PCB_ZONE_T: // SEG_ZONE items are now deprecated
itemsList->RemovePicker( ii );
ii--;
break;
default:
wxMessageBox( wxT( "PCB_EDIT_FRAME::Block_Rotate( ) error: unexpected type" ) );
break;
}
}
// Save all the block items in there current state before applying the rotation.
SaveCopyInUndoList( *itemsList, UR_CHANGED, centre );
// Now perform the rotation.
for( unsigned ii = 0; ii < itemsList->GetCount(); ii++ )
{
BOARD_ITEM* item = (BOARD_ITEM*) itemsList->GetPickedItem( ii );
wxASSERT( item );
item->Rotate( centre, rotAngle );
GetBoard()->GetConnectivity()->Update( item );
}
Compile_Ratsnest( NULL, true );
m_canvas->Refresh( true );
}
void WinEDA_PcbFrame::Show_1_Ratsnest(EDA_BaseStruct * item, wxDC * DC)
/**********************************************************************/
/* Affiche le ratsnest relatif
au net du pad pointe par la souris
ou au module localise par la souris
Efface le chevelu affiche si aucun module ou pad n'est selectionne
*/
{
int ii;
CHEVELU * pt_chevelu;
D_PAD * pt_pad = NULL;
MODULE * Module = NULL;
if (g_Show_Ratsnest) return; // Deja Affich�
if((m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0 )
{
Compile_Ratsnest( DC, TRUE );
}
if ( item && (item->m_StructType == TYPEPAD) )
{
pt_pad = (D_PAD*)item;
Module = (MODULE *) pt_pad->m_Parent;
}
if ( pt_pad ) /* Affichage du chevelu du net correspondant */
{
pt_pad->Display_Infos(this);
pt_chevelu = (CHEVELU*) m_Pcb->m_Ratsnest;
for( ii = m_Pcb->GetNumRatsnests(); ii > 0; pt_chevelu++, ii--)
{
if( pt_chevelu->m_NetCode == pt_pad->m_NetCode)
{
if( (pt_chevelu->status & CH_VISIBLE) != 0 ) continue;
pt_chevelu->status |= CH_VISIBLE;
if( (pt_chevelu->status & CH_ACTIF) == 0 ) continue;
GRSetDrawMode(DC, GR_XOR);
GRLine( &DrawPanel->m_ClipBox, DC, pt_chevelu->pad_start->m_Pos.x,
pt_chevelu->pad_start->m_Pos.y,
pt_chevelu->pad_end->m_Pos.x,
pt_chevelu->pad_end->m_Pos.y,
g_DesignSettings.m_RatsnestColor);
}
}
}
else
{
if ( item && (item->m_StructType == TYPEMODULE) )
{
Module = (MODULE*)item;
}
if( Module)
{
Module->Display_Infos(this);
pt_pad = Module->m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*)pt_pad->Pnext)
{
pt_chevelu = (CHEVELU*) m_Pcb->m_Ratsnest;
for( ii = m_Pcb->GetNumRatsnests(); ii > 0; pt_chevelu++, ii--)
{
if( (pt_chevelu->pad_start == pt_pad) ||
(pt_chevelu->pad_end == pt_pad) )
{
if( pt_chevelu->status & CH_VISIBLE ) continue;
pt_chevelu->status |= CH_VISIBLE;
if( (pt_chevelu->status & CH_ACTIF) == 0 ) continue;
GRSetDrawMode(DC, GR_XOR);
GRLine(&DrawPanel->m_ClipBox, DC, pt_chevelu->pad_start->m_Pos.x,
pt_chevelu->pad_start->m_Pos.y,
pt_chevelu->pad_end->m_Pos.x,
pt_chevelu->pad_end->m_Pos.y,
g_DesignSettings.m_RatsnestColor);
}
}
}
pt_pad = NULL;
}
}
/* Effacement complet des selections
si aucun pad ou module n'a ete localise */
if( (pt_pad == NULL) && (Module == NULL) )
{
MsgPanel->EraseMsgBox();
DrawGeneralRatsnest(DC);
pt_chevelu = (CHEVELU*) m_Pcb->m_Ratsnest;
for( ii = m_Pcb->GetNumRatsnests();(ii > 0) && pt_chevelu; pt_chevelu++, ii--)
pt_chevelu->status &= ~CH_VISIBLE;
}
}
/* Must be called on a click on the left toolbar (options toolbar
* Update variables according to tools states
*/
void PCB_EDIT_FRAME::OnSelectOptionToolbar( wxCommandEvent& event )
{
int id = event.GetId();
bool state = event.IsChecked();
switch( id )
{
case ID_TB_OPTIONS_DRC_OFF:
g_Drc_On = !state;
if( GetToolId() == ID_TRACK_BUTT )
{
if( g_Drc_On )
m_canvas->SetCursor( wxCURSOR_PENCIL );
else
m_canvas->SetCursor( wxCURSOR_QUESTION_ARROW );
}
break;
case ID_TB_OPTIONS_SHOW_RATSNEST:
SetElementVisibility( RATSNEST_VISIBLE, state );
if( state && (GetBoard()->m_Status_Pcb & LISTE_RATSNEST_ITEM_OK) == 0 )
Compile_Ratsnest( NULL, true );
m_canvas->Refresh();
break;
case ID_TB_OPTIONS_SHOW_MODULE_RATSNEST:
g_Show_Module_Ratsnest = state; // TODO: use the visibility list
break;
case ID_TB_OPTIONS_AUTO_DEL_TRACK:
g_AutoDeleteOldTrack = state;
break;
case ID_TB_OPTIONS_SHOW_ZONES:
DisplayOpt.DisplayZonesMode = 0;
m_canvas->Refresh();
break;
case ID_TB_OPTIONS_SHOW_ZONES_DISABLE:
DisplayOpt.DisplayZonesMode = 1;
m_canvas->Refresh();
break;
case ID_TB_OPTIONS_SHOW_ZONES_OUTLINES_ONLY:
DisplayOpt.DisplayZonesMode = 2;
m_canvas->Refresh();
break;
case ID_TB_OPTIONS_SHOW_VIAS_SKETCH:
m_DisplayViaFill = DisplayOpt.DisplayViaFill = !state;
m_canvas->Refresh();
break;
case ID_TB_OPTIONS_SHOW_TRACKS_SKETCH:
m_DisplayPcbTrackFill = DisplayOpt.DisplayPcbTrackFill = !state;
m_canvas->Refresh();
break;
case ID_TB_OPTIONS_SHOW_HIGH_CONTRAST_MODE:
{
DisplayOpt.ContrastModeDisplay = state;
m_canvas->Refresh();
break;
}
case ID_TB_OPTIONS_SHOW_EXTRA_VERTICAL_TOOLBAR_MICROWAVE:
m_show_microwave_tools = state;
m_auimgr.GetPane( wxT( "m_microWaveToolBar" ) ).Show( m_show_microwave_tools );
m_auimgr.Update();
GetMenuBar()->SetLabel( ID_MENU_PCB_SHOW_HIDE_MUWAVE_TOOLBAR,
m_show_microwave_tools ?
_( "Hide Microwave Toolbar" ): _( "Show Microwave Toolbar" ));
break;
case ID_TB_OPTIONS_SHOW_MANAGE_LAYERS_VERTICAL_TOOLBAR:
// show auxiliary Vertical layers and visibility manager toolbar
m_show_layer_manager_tools = state;
m_auimgr.GetPane( wxT( "m_LayersManagerToolBar" ) ).Show( m_show_layer_manager_tools );
m_auimgr.Update();
GetMenuBar()->SetLabel( ID_MENU_PCB_SHOW_HIDE_LAYERS_MANAGER_DIALOG,
m_show_layer_manager_tools ?
_( "Hide &Layers Manager" ) : _( "Show &Layers Manager" ) );
break;
default:
DisplayError( this,
wxT( "PCB_EDIT_FRAME::OnSelectOptionToolbar error \n (event not handled!)" ) );
break;
}
}
void PCB_EDIT_FRAME::ReadPcbNetlist( const wxString& aNetlistFileName,
const wxString& aCmpFileName,
REPORTER* aReporter,
bool aChangeFootprints,
bool aDeleteUnconnectedTracks,
bool aDeleteExtraFootprints,
bool aSelectByTimeStamp,
bool aDeleteSinglePadNets,
bool aIsDryRun )
{
wxString msg;
NETLIST netlist;
KIGFX::VIEW* view = GetGalCanvas()->GetView();
BOARD* board = GetBoard();
netlist.SetIsDryRun( aIsDryRun );
netlist.SetFindByTimeStamp( aSelectByTimeStamp );
netlist.SetDeleteExtraFootprints( aDeleteExtraFootprints );
netlist.SetReplaceFootprints( aChangeFootprints );
try
{
std::auto_ptr<NETLIST_READER> netlistReader( NETLIST_READER::GetNetlistReader(
&netlist, aNetlistFileName, aCmpFileName ) );
if( !netlistReader.get() )
{
msg.Printf( _( "Cannot open netlist file \"%s\"." ), GetChars( aNetlistFileName ) );
wxMessageBox( msg, _( "Netlist Load Error." ), wxOK | wxICON_ERROR, this );
return;
}
SetLastNetListRead( aNetlistFileName );
netlistReader->LoadNetlist();
loadFootprints( netlist, aReporter );
}
catch( const IO_ERROR& ioe )
{
msg.Printf( _( "Error loading netlist.\n%s" ), ioe.errorText.GetData() );
wxMessageBox( msg, _( "Netlist Load Error" ), wxOK | wxICON_ERROR );
return;
}
// Clear undo and redo lists to avoid inconsistencies between lists
if( !netlist.IsDryRun() )
GetScreen()->ClearUndoRedoList();
if( !netlist.IsDryRun() )
{
// Remove old modules
for( MODULE* module = board->m_Modules; module; module = module->Next() )
{
module->RunOnChildren( boost::bind( &KIGFX::VIEW::Remove, view, _1 ) );
view->Remove( module );
}
}
// Clear selection, just in case a selected item has to be removed
m_toolManager->RunAction( COMMON_ACTIONS::selectionClear, true );
netlist.SortByReference();
board->ReplaceNetlist( netlist, aDeleteSinglePadNets, aReporter );
// If it was a dry run, nothing has changed so we're done.
if( netlist.IsDryRun() )
return;
OnModify();
SetCurItem( NULL );
// Reload modules
for( MODULE* module = board->m_Modules; module; module = module->Next() )
{
module->RunOnChildren( boost::bind( &KIGFX::VIEW::Add, view, _1 ) );
view->Add( module );
module->ViewUpdate();
}
if( aDeleteUnconnectedTracks && board->m_Track )
{
// Remove erroneous tracks. This should probably pushed down to the #BOARD object.
RemoveMisConnectedTracks();
}
// Rebuild the board connectivity:
if( IsGalCanvasActive() )
board->GetRatsnest()->ProcessBoard();
Compile_Ratsnest( NULL, true );
SetMsgPanel( board );
m_canvas->Refresh();
}
void PCB_BASE_FRAME::TestNetConnection( wxDC* aDC, int aNetCode )
{
wxString msg;
if( aNetCode <= 0 ) // -1 = not existing net, 0 = dummy net
return;
if( (m_Pcb->m_Status_Pcb & LISTE_RATSNEST_ITEM_OK) == 0 )
Compile_Ratsnest( aDC, true );
// Clear the cluster identifier (subnet) of pads for this net
for( unsigned i = 0; i < m_Pcb->GetPadCount(); ++i )
{
D_PAD* pad = m_Pcb->GetPad(i);
int pad_net_code = pad->GetNetCode();
if( pad_net_code < aNetCode )
continue;
if( pad_net_code > aNetCode )
break;
pad->SetSubNet( 0 );
}
m_Pcb->Test_Connections_To_Copper_Areas( aNetCode );
// Search for the first and the last segment relative to the given net code
if( m_Pcb->m_Track )
{
CONNECTIONS connections( m_Pcb );
TRACK* firstTrack;
TRACK* lastTrack = NULL;
firstTrack = m_Pcb->m_Track.GetFirst()->GetStartNetCode( aNetCode );
if( firstTrack )
lastTrack = firstTrack->GetEndNetCode( aNetCode );
if( firstTrack && lastTrack ) // i.e. if there are segments
{
connections.Build_CurrNet_SubNets_Connections( firstTrack, lastTrack, firstTrack->GetNetCode() );
}
}
Merge_SubNets_Connected_By_CopperAreas( m_Pcb, aNetCode );
// rebuild the active ratsnest for this net
DrawGeneralRatsnest( aDC, aNetCode );
TestForActiveLinksInRatsnest( aNetCode );
DrawGeneralRatsnest( aDC, aNetCode );
// Display results
int net_notconnected_count = 0;
NETINFO_ITEM* net = m_Pcb->FindNet( aNetCode );
if( net ) // Should not occur, but ...
{
for( unsigned ii = net->m_RatsnestStartIdx; ii < net->m_RatsnestEndIdx; ii++ )
{
if( m_Pcb->m_FullRatsnest[ii].IsActive() )
net_notconnected_count++;
}
msg.Printf( wxT( "links %d nc %d net:nc %d" ),
m_Pcb->GetRatsnestsCount(), m_Pcb->GetUnconnectedNetCount(),
net_notconnected_count );
}
else
msg.Printf( wxT( "net not found: netcode %d" ),aNetCode );
SetStatusText( msg );
return;
}
void PCB_EDIT_FRAME::ReadPcbNetlist( const wxString& aNetlistFileName,
const wxString& aCmpFileName,
REPORTER* aReporter,
bool aChangeFootprints,
bool aDeleteUnconnectedTracks,
bool aDeleteExtraFootprints,
bool aSelectByTimeStamp,
bool aDeleteSinglePadNets,
bool aIsDryRun )
{
wxString msg;
NETLIST netlist;
NETLIST_READER* netlistReader;
netlist.SetIsDryRun( aIsDryRun );
netlist.SetFindByTimeStamp( aSelectByTimeStamp );
netlist.SetDeleteExtraFootprints( aDeleteExtraFootprints );
netlist.SetReplaceFootprints( aChangeFootprints );
try
{
netlistReader = NETLIST_READER::GetNetlistReader( &netlist, aNetlistFileName,
aCmpFileName );
if( netlistReader == NULL )
{
msg.Printf( _( "Cannot open netlist file \"%s\"." ), GetChars( aNetlistFileName ) );
wxMessageBox( msg, _( "Netlist Load Error." ), wxOK | wxICON_ERROR, this );
return;
}
std::auto_ptr< NETLIST_READER > nlr( netlistReader );
SetLastNetListRead( aNetlistFileName );
netlistReader->LoadNetlist();
loadFootprints( netlist, aReporter );
}
catch( const IO_ERROR& ioe )
{
msg.Printf( _( "Error loading netlist.\n%s" ), ioe.errorText.GetData() );
wxMessageBox( msg, _( "Netlist Load Error" ), wxOK | wxICON_ERROR );
return;
}
// Clear undo and redo lists to avoid inconsistencies between lists
if( !netlist.IsDryRun() )
GetScreen()->ClearUndoRedoList();
netlist.SortByReference();
GetBoard()->ReplaceNetlist( netlist, aDeleteSinglePadNets, aReporter );
// If it was a dry run, nothing has changed so we're done.
if( netlist.IsDryRun() )
return;
OnModify();
SetCurItem( NULL );
if( aDeleteUnconnectedTracks && GetBoard()->m_Track )
{
// Remove erroneous tracks. This should probably pushed down to the #BOARD object.
RemoveMisConnectedTracks();
}
// Rebuild the board connectivity:
Compile_Ratsnest( NULL, true );
SetMsgPanel( GetBoard() );
m_canvas->Refresh();
}
void WinEDA_PcbFrame::Process_Special_Functions(wxCommandEvent& event)
/*********************************************************************/
/* Traite les selections d'outils et les commandes appelees du menu POPUP
*/
{
int id = event.GetId();
wxPoint pos;
wxClientDC dc(DrawPanel);
int itmp;
DrawPanel->PrepareGraphicContext(&dc);
wxGetMousePosition(&pos.x, &pos.y);
pos.y += 20;
switch ( id ) // Arret eventuel de la commande de déplacement en cours
{
case wxID_CUT:
case wxID_COPY:
case ID_AUX_TOOLBAR_PCB_TRACK_WIDTH:
case ID_AUX_TOOLBAR_PCB_VIA_SIZE:
case ID_ON_GRID_SELECT:
case ID_ON_ZOOM_SELECT:
case ID_PCB_USER_GRID_SETUP:
case ID_TOOLBARH_PCB_SELECT_LAYER:
case ID_POPUP_PCB_ROTATE_TEXTEPCB:
case ID_POPUP_PCB_EDIT_TEXTEPCB:
case ID_POPUP_PCB_EDIT_MIRE:
case ID_POPUP_PCB_ROTATE_TEXTMODULE:
case ID_POPUP_PCB_ROTATE_MODULE_CLOCKWISE:
case ID_POPUP_PCB_ROTATE_MODULE_COUNTERCLOCKWISE:
case ID_POPUP_PCB_CHANGE_SIDE_MODULE:
case ID_POPUP_PCB_EDIT_MODULE:
case ID_POPUP_PCB_EDIT_TEXTMODULE:
case ID_POPUP_PCB_STOP_CURRENT_DRAWING:
case ID_POPUP_PCB_END_TRACK:
case ID_POPUP_PCB_PLACE_VIA:
case ID_POPUP_PCB_IMPORT_PAD_SETTINGS:
case ID_POPUP_PCB_EXPORT_PAD_SETTINGS:
case ID_POPUP_PCB_GLOBAL_IMPORT_PAD_SETTINGS:
case ID_POPUP_PCB_STOP_CURRENT_EDGE_ZONE:
case ID_POPUP_PCB_DELETE_EDGE_ZONE:
case ID_POPUP_PCB_DELETE_ZONE_LIMIT:
case ID_POPUP_PCB_EDIT_ZONE:
case ID_POPUP_PCB_DELETE_ZONE:
case ID_POPUP_PCB_DELETE_TRACKSEG:
case ID_POPUP_PCB_DELETE_TRACK:
case ID_POPUP_PCB_DELETE_TRACKNET:
case ID_POPUP_PCB_FILL_ZONE:
case ID_POPUP_PCB_SELECT_NET_ZONE:
case ID_POPUP_PCB_SELECT_LAYER:
case ID_POPUP_PCB_SELECT_CU_LAYER:
case ID_POPUP_PCB_SELECT_LAYER_PAIR:
case ID_POPUP_PCB_SELECT_NO_CU_LAYER:
case ID_POPUP_PCB_SELECT_WIDTH:
case ID_POPUP_PCB_SELECT_WIDTH1:
case ID_POPUP_PCB_SELECT_WIDTH2:
case ID_POPUP_PCB_SELECT_WIDTH3:
case ID_POPUP_PCB_SELECT_WIDTH4:
case ID_POPUP_PCB_SELECT_WIDTH5:
case ID_POPUP_PCB_SELECT_WIDTH6:
case ID_POPUP_PCB_SELECT_WIDTH7:
case ID_POPUP_PCB_SELECT_WIDTH8:
case ID_POPUP_PCB_SELECT_VIASIZE:
case ID_POPUP_PCB_SELECT_VIASIZE1:
case ID_POPUP_PCB_SELECT_VIASIZE2:
case ID_POPUP_PCB_SELECT_VIASIZE3:
case ID_POPUP_PCB_SELECT_VIASIZE4:
case ID_POPUP_PCB_SELECT_VIASIZE5:
case ID_POPUP_PCB_SELECT_VIASIZE6:
case ID_POPUP_PCB_SELECT_VIASIZE7:
case ID_POPUP_PCB_SELECT_VIASIZE8:
case ID_POPUP_PCB_MOVE_TRACK_NODE:
case ID_POPUP_PCB_PLACE_MOVED_TRACK_NODE:
case ID_POPUP_PCB_BREAK_TRACK:
case ID_POPUP_PCB_EDIT_NET:
case ID_POPUP_PCB_EDIT_TRACK:
case ID_POPUP_PCB_EDIT_TRACKSEG:
case ID_POPUP_PCB_LOCK_ON_TRACKSEG:
case ID_POPUP_PCB_LOCK_OFF_TRACKSEG:
case ID_POPUP_PCB_LOCK_ON_TRACK:
case ID_POPUP_PCB_LOCK_OFF_TRACK:
case ID_POPUP_PCB_LOCK_ON_NET:
case ID_POPUP_PCB_LOCK_OFF_NET:
case ID_POPUP_DELETE_BLOCK:
case ID_POPUP_PLACE_BLOCK:
case ID_POPUP_ZOOM_BLOCK:
case ID_POPUP_INVERT_BLOCK:
case ID_POPUP_ROTATE_BLOCK:
case ID_POPUP_COPY_BLOCK:
case ID_POPUP_PCB_VIA_EDITING:
case ID_POPUP_PCB_VIA_HOLE_TO_DEFAULT:
case ID_POPUP_PCB_VIA_HOLE_TO_VALUE:
case ID_POPUP_PCB_VIA_HOLE_ENTER_VALUE:
case ID_POPUP_PCB_VIA_HOLE_EXPORT:
case ID_POPUP_PCB_VIA_HOLE_RESET_TO_DEFAULT:
case ID_POPUP_PCB_VIA_HOLE_EXPORT_TO_OTHERS:
break;
case ID_POPUP_CANCEL_CURRENT_COMMAND:
if( GetScreen()->ManageCurseur &&
GetScreen()->ForceCloseManageCurseur )
{
GetScreen()->ForceCloseManageCurseur(this, &dc);
}
/* ne devrait pas etre execute, sauf bug */
if (m_CurrentScreen->BlockLocate.m_Command != BLOCK_IDLE)
{
m_CurrentScreen->BlockLocate.m_Command = BLOCK_IDLE;
m_CurrentScreen->BlockLocate.m_State = STATE_NO_BLOCK;
m_CurrentScreen->BlockLocate.m_BlockDrawStruct = NULL;
}
if (m_ID_current_state == 0 )
SetToolID(0, wxCURSOR_ARROW,wxEmptyString);
else SetCursor(DrawPanel->m_PanelCursor = DrawPanel->m_PanelDefaultCursor);
break;
default: // Arret de la commande de déplacement en cours
if( GetScreen()->ManageCurseur &&
GetScreen()->ForceCloseManageCurseur )
{
GetScreen()->ForceCloseManageCurseur(this, &dc);
}
SetToolID(0, wxCURSOR_ARROW,wxEmptyString);
break;
}
switch ( id ) // Traitement des commandes
{
case ID_EXIT :
Close(TRUE);
break;
case ID_OPEN_MODULE_EDITOR:
if (m_Parent->m_ModuleEditFrame == NULL )
{
m_Parent->m_ModuleEditFrame = new WinEDA_ModuleEditFrame(this,
m_Parent,_("Module Editor"),
wxPoint(-1, -1), wxSize(600,400) );
m_Parent->m_ModuleEditFrame->Show(TRUE);
m_Parent->m_ModuleEditFrame->Zoom_Automatique(TRUE);
}
else m_Parent->m_ModuleEditFrame->Iconize(FALSE);
break;
case ID_NEW_PROJECT:
case ID_LOAD_PROJECT:
Files_io(event);
break;
case ID_PCB_GLOBAL_DELETE:
InstallPcbGlobalDeleteFrame(pos);
break;
case ID_POPUP_PLACE_BLOCK:
GetScreen()->BlockLocate.m_Command = BLOCK_MOVE;
DrawPanel->m_AutoPAN_Request = FALSE;
HandleBlockPlace(&dc);
break;
case ID_POPUP_COPY_BLOCK:
GetScreen()->BlockLocate.m_Command = BLOCK_COPY;
m_CurrentScreen->BlockLocate.SetMessageBlock(this);
DrawPanel->m_AutoPAN_Request = FALSE;
HandleBlockPlace(&dc);
break;
case ID_POPUP_ZOOM_BLOCK:
GetScreen()->BlockLocate.m_Command = BLOCK_ZOOM;
m_CurrentScreen->BlockLocate.SetMessageBlock(this);
m_CurrentScreen->BlockLocate.SetMessageBlock(this);
HandleBlockEnd(&dc);
break;
case ID_POPUP_DELETE_BLOCK:
GetScreen()->BlockLocate.m_Command = BLOCK_DELETE;
m_CurrentScreen->BlockLocate.SetMessageBlock(this);
HandleBlockEnd(&dc);
break;
case ID_POPUP_ROTATE_BLOCK:
GetScreen()->BlockLocate.m_Command = BLOCK_ROTATE;
m_CurrentScreen->BlockLocate.SetMessageBlock(this);
HandleBlockEnd(&dc);
break;
case ID_POPUP_INVERT_BLOCK:
GetScreen()->BlockLocate.m_Command = BLOCK_INVERT;
m_CurrentScreen->BlockLocate.SetMessageBlock(this);
HandleBlockEnd(&dc);
break;
case ID_UNDO_BUTT:
UnDeleteItem(&dc);
break;
case ID_DRC_CONTROL:
Install_Test_DRC_Frame(&dc);
break;
case ID_GET_NETLIST:
InstallNetlistFrame(&dc, wxPoint(-1,-1));
break;
case ID_GET_TOOLS:
// InstallToolsFrame(this, wxPoint(-1,-1) );
break;
case ID_FIND_ITEMS:
InstallFindFrame(pos, &dc);
break;
case ID_TRACK_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _("Add Tracks"));
DisplayTrackSettings();
if ( (m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0)
{
Compile_Ratsnest( &dc, TRUE );
}
break;
case ID_PCB_ZONES_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _("Add Zones"));
if ( ! DisplayOpt.DisplayZones )
DisplayInfo(this, _("Warning: Display Zone is OFF!!!") );
DelLimitesZone(&dc, TRUE);
if( ! g_HightLigt_Status && (g_HightLigth_NetCode > 0 ) )
Hight_Light(&dc);
break;
case ID_PCB_MIRE_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _("Add Mire"));
break;
case ID_PCB_PLACE_OFFSET_COORD_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _("Adjust Zero"));
break;
case ID_LINE_COMMENT_BUTT:
case ID_PCB_ARC_BUTT:
case ID_PCB_CIRCLE_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _("Add Graphic"));
break;
case ID_TEXT_COMMENT_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _("Add Text"));
break;
case ID_COMPONENT_BUTT:
SetToolID( id, wxCURSOR_HAND, _("Add Modules"));
break;
case ID_PCB_COTATION_BUTT:
SetToolID( id, wxCURSOR_PENCIL, _("Add Cotation"));
break;
case ID_NO_SELECT_BUTT:
SetToolID( 0, wxCURSOR_ARROW, wxEmptyString);
break;
case ID_PCB_HIGHLIGHT_BUTT:
SetToolID( id, wxCURSOR_HAND, _("Net Highlight"));
break;
case ID_PCB_SHOW_1_RATSNEST_BUTT:
SetToolID( id, wxCURSOR_HAND, _("Local Ratsnest"));
if ( (m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0)
Compile_Ratsnest( &dc, TRUE );
break;
case ID_POPUP_CLOSE_CURRENT_TOOL:
SetToolID( 0, wxCURSOR_ARROW, wxEmptyString);
break;
case ID_POPUP_CANCEL_CURRENT_COMMAND:
break;
case ID_POPUP_END_LINE:
DrawPanel->MouseToCursorSchema();
// EndSegment(&dc);
break;
case ID_POPUP_PCB_EDIT_TRACK:
if ( CURRENT_ITEM == NULL) break;
Edit_Track_Width(&dc, (TRACK *) CURRENT_ITEM);
DrawPanel->MouseToCursorSchema();
GetScreen()->SetModify();
break;
case ID_POPUP_PCB_EDIT_TRACKSEG:
if ( CURRENT_ITEM == NULL) break;
Edit_TrackSegm_Width(&dc, (TRACK *) CURRENT_ITEM);
DrawPanel->MouseToCursorSchema();
GetScreen()->SetModify();
break;
case ID_POPUP_PCB_EDIT_NET:
if ( CURRENT_ITEM == NULL) break;
Edit_Net_Width(&dc, ((TRACK *) CURRENT_ITEM)->m_NetCode);
DrawPanel->MouseToCursorSchema();
GetScreen()->SetModify();
break;
case ID_POPUP_PCB_EDIT_ALL_VIAS_AND_TRACK_SIZE:
case ID_POPUP_PCB_EDIT_ALL_VIAS_SIZE:
case ID_POPUP_PCB_EDIT_ALL_TRACK_SIZE:
if ( CURRENT_ITEM == NULL) break;
{
bool resize_vias = TRUE, resize_track = TRUE;
if( id == ID_POPUP_PCB_EDIT_ALL_VIAS_SIZE) resize_track = FALSE;
if( id == ID_POPUP_PCB_EDIT_ALL_TRACK_SIZE) resize_vias = FALSE;
if ( Resize_Pistes_Vias(&dc, resize_track, resize_vias)) GetScreen()->SetModify();
}
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_END_TRACK:
DrawPanel->MouseToCursorSchema();
End_Route( (TRACK *) CURRENT_ITEM, &dc);
break;
case ID_POPUP_PCB_PLACE_MOVED_TRACK_NODE:
DrawPanel->MouseToCursorSchema();
if ( CURRENT_ITEM->m_Flags & IS_DRAGGED )
{
PlaceDraggedTrackSegment((TRACK *) CURRENT_ITEM, &dc);
}
break;
case ID_POPUP_PCB_PLACE_VIA:
DrawPanel->MouseToCursorSchema();
if ( CURRENT_ITEM->m_Flags & IS_DRAGGED )
{
PlaceDraggedTrackSegment((TRACK *) CURRENT_ITEM, &dc);
}
else
{
Other_Layer_Route( (TRACK *) CURRENT_ITEM, &dc);
if ( DisplayOpt.ContrastModeDisplay )
GetScreen()->SetRefreshReq();
}
break;
case ID_POPUP_PCB_DELETE_TRACKSEG:
DrawPanel->MouseToCursorSchema();
GetScreen()->m_CurrentItem = Delete_Segment(&dc, (TRACK*)CURRENT_ITEM);
GetScreen()->SetModify();
break;
case ID_POPUP_PCB_DELETE_TRACK:
DrawPanel->MouseToCursorSchema();
Delete_Track(&dc, (TRACK*)CURRENT_ITEM);
GetScreen()->m_CurrentItem = NULL;
GetScreen()->SetModify();
break;
case ID_POPUP_PCB_DELETE_TRACKNET:
DrawPanel->MouseToCursorSchema();
Delete_net(&dc, (TRACK*)CURRENT_ITEM);
GetScreen()->m_CurrentItem = NULL;
GetScreen()->SetModify();
break;
case ID_POPUP_PCB_LOCK_ON_TRACKSEG:
Attribut_Segment((TRACK*)CURRENT_ITEM, &dc, TRUE);
break;
case ID_POPUP_PCB_LOCK_OFF_TRACKSEG:
Attribut_Segment((TRACK*)CURRENT_ITEM, &dc, FALSE);
break;
case ID_POPUP_PCB_LOCK_ON_TRACK:
Attribut_Track((TRACK*)CURRENT_ITEM, &dc, TRUE);
break;
case ID_POPUP_PCB_LOCK_OFF_TRACK:
Attribut_Track((TRACK*)CURRENT_ITEM, &dc, FALSE);
break;
case ID_POPUP_PCB_LOCK_ON_NET:
Attribut_net(&dc, ((TRACK*)CURRENT_ITEM)->m_NetCode, TRUE);
break;
case ID_POPUP_PCB_LOCK_OFF_NET:
Attribut_net(&dc, ((TRACK*)CURRENT_ITEM)->m_NetCode, FALSE);
break;
case ID_POPUP_PCB_SETFLAGS_TRACK_MNU:
break;
case ID_POPUP_PCB_DELETE_ZONE:
DrawPanel->MouseToCursorSchema();
if ( CURRENT_ITEM == NULL) break;
Delete_Zone(&dc, (SEGZONE*)CURRENT_ITEM);
GetScreen()->m_CurrentItem = NULL;
break;
case ID_POPUP_PCB_EDIT_ZONE:
DrawPanel->MouseToCursorSchema();
if ( CURRENT_ITEM == NULL) break;
Edit_Zone_Width(&dc, (SEGZONE*)CURRENT_ITEM);
break;
case ID_POPUP_PCB_DELETE_ZONE_LIMIT:
DrawPanel->MouseToCursorSchema();
DelLimitesZone(&dc, TRUE);
break;
case ID_PCB_DELETE_ITEM_BUTT:
SetToolID( id, wxCURSOR_BULLSEYE, _("Delete item"));
break;
case ID_POPUP_PCB_MOVE_TEXTEPCB_REQUEST:
Process_Move_Item(this, CURRENT_ITEM, &dc);
DrawPanel->m_AutoPAN_Request = TRUE;
break;
case ID_POPUP_PCB_DRAG_MODULE_REQUEST:
g_Drag_Pistes_On = TRUE;
case ID_POPUP_PCB_MOVE_MODULE_REQUEST:
// If the current Item is a pad, text module ...: Get the parent
if ( CURRENT_ITEM->m_StructType != TYPEMODULE )
CURRENT_ITEM = (MODULE *) CURRENT_ITEM->m_Parent;
if ( !CURRENT_ITEM || CURRENT_ITEM->m_StructType != TYPEMODULE )
{
g_Drag_Pistes_On = FALSE;
break;
}
DrawPanel->MouseToCursorSchema();
StartMove_Module( (MODULE*)CURRENT_ITEM, &dc);
break;
case ID_POPUP_PCB_DELETE_MODULE:
DrawPanel->MouseToCursorSchema();
// If the current Item is a pad, text module ...: Get the parent
if ( CURRENT_ITEM->m_StructType != TYPEMODULE )
CURRENT_ITEM = (MODULE *) CURRENT_ITEM->m_Parent;
if ( !CURRENT_ITEM || CURRENT_ITEM->m_StructType != TYPEMODULE )
break;
if ( Delete_Module((MODULE*) CURRENT_ITEM, &dc) )
{
GetScreen()->m_CurrentItem = NULL;
}
break;
case ID_POPUP_PCB_ROTATE_MODULE_COUNTERCLOCKWISE:
DrawPanel->MouseToCursorSchema();
// If the current Item is a pad, text module ...: Get the parent
if ( CURRENT_ITEM->m_StructType != TYPEMODULE )
CURRENT_ITEM = (MODULE *) CURRENT_ITEM->m_Parent;
if ( !CURRENT_ITEM || CURRENT_ITEM->m_StructType != TYPEMODULE )
break;
Rotate_Module(&dc, (MODULE*)CURRENT_ITEM, -900, TRUE);
break;
case ID_POPUP_PCB_ROTATE_MODULE_CLOCKWISE:
DrawPanel->MouseToCursorSchema();
// If the current Item is a pad, text module ...: Get the parent
if ( CURRENT_ITEM->m_StructType != TYPEMODULE )
CURRENT_ITEM = (MODULE *) CURRENT_ITEM->m_Parent;
if ( !CURRENT_ITEM || CURRENT_ITEM->m_StructType != TYPEMODULE )
break;
Rotate_Module(&dc, (MODULE*)CURRENT_ITEM, 900, TRUE);
break;
case ID_POPUP_PCB_CHANGE_SIDE_MODULE:
DrawPanel->MouseToCursorSchema();
// If the current Item is a pad, text module ...: Get the parent
if ( CURRENT_ITEM->m_StructType != TYPEMODULE )
CURRENT_ITEM = (MODULE *) CURRENT_ITEM->m_Parent;
if ( !CURRENT_ITEM || CURRENT_ITEM->m_StructType != TYPEMODULE )
break;
Change_Side_Module((MODULE *) CURRENT_ITEM, &dc);
break;
case ID_POPUP_PCB_EDIT_MODULE:
// If the current Item is a pad, text module ...: Get the parent
if ( CURRENT_ITEM->m_StructType != TYPEMODULE )
CURRENT_ITEM = (MODULE *) CURRENT_ITEM->m_Parent;
if ( !CURRENT_ITEM || CURRENT_ITEM->m_StructType != TYPEMODULE )
break;
InstallModuleOptionsFrame((MODULE *)CURRENT_ITEM,
&dc, pos);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_DRAG_PAD_REQUEST:
g_Drag_Pistes_On = TRUE;
case ID_POPUP_PCB_MOVE_PAD_REQUEST:
DrawPanel->MouseToCursorSchema();
StartMovePad((D_PAD *)CURRENT_ITEM, &dc);
break;
case ID_POPUP_PCB_EDIT_PAD:
InstallPadOptionsFrame((D_PAD *)CURRENT_ITEM,
&dc, pos);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_IMPORT_PAD_SETTINGS:
DrawPanel->MouseToCursorSchema();
Import_Pad_Settings((D_PAD *)CURRENT_ITEM, &dc);
break;
case ID_POPUP_PCB_GLOBAL_IMPORT_PAD_SETTINGS:
DrawPanel->MouseToCursorSchema();
Global_Import_Pad_Settings((D_PAD *)CURRENT_ITEM, &dc);
break;
case ID_POPUP_PCB_EXPORT_PAD_SETTINGS:
DrawPanel->MouseToCursorSchema();
Export_Pad_Settings((D_PAD *)CURRENT_ITEM);
break;
case ID_POPUP_PCB_DELETE_PAD:
DeletePad((D_PAD *)CURRENT_ITEM, &dc);
GetScreen()->m_CurrentItem = NULL;
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_EDIT_TEXTMODULE:
InstallTextModOptionsFrame((TEXTE_MODULE *)CURRENT_ITEM,
&dc, pos);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_MOVE_TEXTMODULE_REQUEST:
DrawPanel->MouseToCursorSchema();
StartMoveTexteModule( (TEXTE_MODULE *) CURRENT_ITEM,
&dc);
break;
case ID_POPUP_PCB_ROTATE_TEXTMODULE:
RotateTextModule((TEXTE_MODULE *)CURRENT_ITEM,
&dc);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_DELETE_TEXTMODULE:
DeleteTextModule((TEXTE_MODULE *)CURRENT_ITEM,
&dc);
GetScreen()->m_CurrentItem = NULL;
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_SELECT_LAYER:
itmp = SelectLayer(GetScreen()->m_Active_Layer, -1, -1);
if ( itmp >= 0 ) GetScreen()->m_Active_Layer = itmp;
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_SELECT_NO_CU_LAYER:
itmp = SelectLayer(GetScreen()->m_Active_Layer, CMP_N+1, -1);
if ( itmp >= 0 ) GetScreen()->m_Active_Layer = itmp;
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_SELECT_CU_LAYER:
itmp = SelectLayer(GetScreen()->m_Active_Layer, -1, CMP_N);
if ( itmp >= 0 ) GetScreen()->m_Active_Layer = itmp;
break;
case ID_POPUP_PCB_SELECT_LAYER_PAIR:
SelectLayerPair();
DrawPanel->MouseToCursorSchema();
break;
case ID_TOOLBARH_PCB_SELECT_LAYER:
itmp = m_SelLayerBox->GetChoice();
GetScreen()->m_Active_Layer = (int)((size_t) m_SelLayerBox->GetClientData(itmp));
if ( DisplayOpt.ContrastModeDisplay ) DrawPanel->Refresh(TRUE);
break;
case ID_POPUP_PCB_EDIT_TEXTEPCB:
InstallTextPCBOptionsFrame((TEXTE_PCB *)CURRENT_ITEM,
&dc, pos);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_ROTATE_TEXTEPCB:
Rotate_Texte_Pcb((TEXTE_PCB *)CURRENT_ITEM, &dc);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_DELETE_TEXTEPCB:
Delete_Texte_Pcb((TEXTE_PCB *)CURRENT_ITEM, &dc);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_MOVE_MIRE_REQUEST:
StartMove_Mire((MIREPCB *)CURRENT_ITEM, &dc);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_EDIT_MIRE:
InstallMireOptionsFrame((MIREPCB *)CURRENT_ITEM, &dc, pos);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_DELETE_MIRE:
DrawPanel->MouseToCursorSchema();
Delete_Mire((MIREPCB *)CURRENT_ITEM, &dc);
GetScreen()->m_CurrentItem = NULL;
break;
case ID_POPUP_PCB_DELETE_COTATION:
DrawPanel->MouseToCursorSchema();
Delete_Cotation((COTATION*)CURRENT_ITEM, &dc);
GetScreen()->m_CurrentItem = NULL;
break;
case ID_POPUP_PCB_EDIT_COTATION:
Install_Edit_Cotation((COTATION*)CURRENT_ITEM, &dc, pos);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_DELETE_DRAWING:
Delete_Segment_Edge((DRAWSEGMENT *)CURRENT_ITEM, &dc);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_DELETE_DRAWING_LAYER:
Delete_Drawings_All_Layer((DRAWSEGMENT *)CURRENT_ITEM, &dc);
GetScreen()->m_CurrentItem = NULL;
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_EDIT_DRAWING:
Drawing_SetNewWidth((DRAWSEGMENT *)CURRENT_ITEM, &dc);
DrawPanel->MouseToCursorSchema();
break;
case ID_POPUP_PCB_MOVE_DRAWING_REQUEST:
DrawPanel->MouseToCursorSchema();
Start_Move_DrawItem((DRAWSEGMENT *)CURRENT_ITEM, &dc);
break;
case ID_POPUP_PCB_STOP_CURRENT_DRAWING:
DrawPanel->MouseToCursorSchema();
if ( CURRENT_ITEM && (CURRENT_ITEM->m_Flags & IS_NEW) )
{
End_Edge( (DRAWSEGMENT *)CURRENT_ITEM, &dc);
GetScreen()->m_CurrentItem = NULL;
}
break;
case ID_POPUP_PCB_STOP_CURRENT_EDGE_ZONE:
DrawPanel->MouseToCursorSchema();
if ( CURRENT_ITEM && (CURRENT_ITEM->m_Flags & IS_NEW) )
{
End_Zone(&dc);
GetScreen()->m_CurrentItem = NULL;
}
break;
case ID_POPUP_PCB_DELETE_EDGE_ZONE:
DrawPanel->MouseToCursorSchema();
if ( CURRENT_ITEM && (CURRENT_ITEM->m_Flags & IS_NEW) )
{
GetScreen()->m_CurrentItem = Del_SegmEdgeZone(&dc,
(EDGE_ZONE *) CURRENT_ITEM);
}
break;
case ID_POPUP_PCB_FILL_ZONE:
DrawPanel->MouseToCursorSchema();
Fill_Zone(&dc);
break;
case ID_POPUP_PCB_SELECT_NET_ZONE:
DrawPanel->MouseToCursorSchema();
CaptureNetName(&dc);
break;
case ID_POPUP_PCB_SELECT_WIDTH:
break;
case ID_AUX_TOOLBAR_PCB_TRACK_WIDTH:
{
int ii = m_SelTrackWidthBox->GetChoice();
g_DesignSettings.m_CurrentTrackWidth = g_DesignSettings.m_TrackWidhtHistory[ii];
DisplayTrackSettings();
m_SelTrackWidthBox_Changed = FALSE;
m_SelViaSizeBox_Changed = FALSE;
}
break;
case ID_POPUP_PCB_SELECT_WIDTH1:
case ID_POPUP_PCB_SELECT_WIDTH2:
case ID_POPUP_PCB_SELECT_WIDTH3:
case ID_POPUP_PCB_SELECT_WIDTH4:
case ID_POPUP_PCB_SELECT_WIDTH5:
case ID_POPUP_PCB_SELECT_WIDTH6:
case ID_POPUP_PCB_SELECT_WIDTH7:
case ID_POPUP_PCB_SELECT_WIDTH8:
DrawPanel->MouseToCursorSchema();
{
int ii = id - ID_POPUP_PCB_SELECT_WIDTH1;
g_DesignSettings.m_CurrentTrackWidth = g_DesignSettings.m_TrackWidhtHistory[ii];
DisplayTrackSettings();
}
break;
case ID_POPUP_PCB_SELECT_VIASIZE:
break;
case ID_AUX_TOOLBAR_PCB_VIA_SIZE:
{
int ii = m_SelViaSizeBox->GetChoice();
g_DesignSettings.m_CurrentViaSize = g_DesignSettings.m_ViaSizeHistory[ii];
DisplayTrackSettings();
m_SelTrackWidthBox_Changed = FALSE;
m_SelViaSizeBox_Changed = FALSE;
}
break;
case ID_POPUP_PCB_SELECT_VIASIZE1:
case ID_POPUP_PCB_SELECT_VIASIZE2:
case ID_POPUP_PCB_SELECT_VIASIZE3:
case ID_POPUP_PCB_SELECT_VIASIZE4:
case ID_POPUP_PCB_SELECT_VIASIZE5:
case ID_POPUP_PCB_SELECT_VIASIZE6:
case ID_POPUP_PCB_SELECT_VIASIZE7:
case ID_POPUP_PCB_SELECT_VIASIZE8:
case ID_POPUP_PCB_VIA_EDITING:
case ID_POPUP_PCB_VIA_HOLE_TO_DEFAULT:
case ID_POPUP_PCB_VIA_HOLE_TO_VALUE:
case ID_POPUP_PCB_VIA_HOLE_ENTER_VALUE:
case ID_POPUP_PCB_VIA_HOLE_EXPORT:
case ID_POPUP_PCB_VIA_HOLE_RESET_TO_DEFAULT:
case ID_POPUP_PCB_VIA_HOLE_EXPORT_TO_OTHERS:
Via_Edit_Control(&dc, id, (SEGVIA *) GetScreen()->m_CurrentItem);
break;
case ID_POPUP_PCB_MOVE_TRACK_NODE:
DrawPanel->MouseToCursorSchema();
Start_MoveOneTrackSegment((TRACK *) GetScreen()->m_CurrentItem,
&dc, TRUE);
break;
case ID_POPUP_PCB_BREAK_TRACK:
DrawPanel->MouseToCursorSchema();
{
TRACK * track = (TRACK *) GetScreen()->m_CurrentItem;
wxPoint pos = GetScreen()->m_Curseur;
track->Draw(DrawPanel, &dc, GR_XOR);
TRACK * newtrack = CreateLockPoint(&pos.x, &pos.y, track, NULL);
track->Draw(DrawPanel, &dc, GR_XOR);
newtrack->Draw(DrawPanel, &dc, GR_XOR);
}
break;
case ID_MENU_PCB_CLEAN:
Clean_Pcb(&dc);
break;
case ID_MENU_PCB_SWAP_LAYERS:
Swap_Layers(event);
break;
case ID_POPUP_PCB_AUTOROUTE_GET_AUTOROUTER:
GlobalRoute(&dc);
break;
case ID_POPUP_PCB_AUTOROUTE_GET_AUTOROUTER_DATA:
ReadAutoroutedTracks(&dc);
break;
case ID_PCB_USER_GRID_SETUP:
InstallGridFrame(pos);
break;
case ID_POPUP_PCB_DISPLAY_FOOTPRINT_DOC:
{
wxString msg = FindKicadHelpPath();
msg += EDA_Appl->m_EDA_CommonConfig->Read(wxT("module_doc_file"),
wxT("pcbnew/footprints.pdf"));
GetAssociatedDocument(this, wxEmptyString, msg);
}
break;
case ID_MENU_ARCHIVE_NEW_MODULES:
Archive_Modules(wxEmptyString, TRUE);
break;
case ID_MENU_ARCHIVE_ALL_MODULES:
Archive_Modules(wxEmptyString, FALSE);
break;
default:
{
DisplayError(this, wxT("WinEDA_PcbFrame::Process_Special_Functions() id error"));
break;
}
}
SetToolbars();
}
void PCB_EDIT_FRAME::AutoPlaceModule( MODULE* Module, int place_mode, wxDC* DC )
{
MODULE* currModule = NULL;
wxPoint PosOK;
wxPoint memopos;
int error;
LAYER_ID lay_tmp_TOP, lay_tmp_BOTTOM;
// Undo: init list
PICKED_ITEMS_LIST newList;
newList.m_Status = UR_CHANGED;
ITEM_PICKER picker( NULL, UR_CHANGED );
if( GetBoard()->m_Modules == NULL )
return;
m_canvas->SetAbortRequest( false );
switch( place_mode )
{
case PLACE_1_MODULE:
currModule = Module;
if( currModule == NULL )
return;
currModule->SetIsPlaced( false );
currModule->SetNeedsPlaced( false );
break;
case PLACE_OUT_OF_BOARD:
break;
case PLACE_ALL:
if( !IsOK( this, _( "Footprints NOT LOCKED will be moved" ) ) )
return;
break;
case PLACE_INCREMENTAL:
if( !IsOK( this, _( "Footprints NOT PLACED will be moved" ) ) )
return;
break;
}
memopos = CurrPosition;
lay_tmp_BOTTOM = g_Route_Layer_BOTTOM;
lay_tmp_TOP = g_Route_Layer_TOP;
RoutingMatrix.m_GridRouting = (int) GetScreen()->GetGridSize().x;
// Ensure Board.m_GridRouting has a reasonable value:
if( RoutingMatrix.m_GridRouting < Millimeter2iu( 0.25 ) )
RoutingMatrix.m_GridRouting = Millimeter2iu( 0.25 );
// Compute module parameters used in auto place
if( genPlacementRoutingMatrix( GetBoard(), m_messagePanel ) == 0 )
return;
int moduleCount = 0;
Module = GetBoard()->m_Modules;
for( ; Module != NULL; Module = Module->Next() )
{
Module->SetNeedsPlaced( false );
switch( place_mode )
{
case PLACE_1_MODULE:
if( currModule == Module )
{
// Module will be placed, add to undo.
picker.SetItem( currModule );
newList.PushItem( picker );
Module->SetNeedsPlaced( true );
}
break;
case PLACE_OUT_OF_BOARD:
Module->SetIsPlaced( false );
if( Module->IsLocked() )
break;
if( !RoutingMatrix.m_BrdBox.Contains( Module->GetPosition() ) )
{
// Module will be placed, add to undo.
picker.SetItem( Module );
newList.PushItem( picker );
Module->SetNeedsPlaced( true );
}
break;
case PLACE_ALL:
Module->SetIsPlaced( false );
if( Module->IsLocked() )
break;
// Module will be placed, add to undo.
picker.SetItem( Module );
newList.PushItem( picker );
Module->SetNeedsPlaced( true );
break;
case PLACE_INCREMENTAL:
if( Module->IsLocked() )
{
Module->SetIsPlaced( false );
break;
}
if( !Module->NeedsPlaced() )
{
// Module will be placed, add to undo.
picker.SetItem( Module );
newList.PushItem( picker );
Module->SetNeedsPlaced( true );
}
break;
}
if( Module->NeedsPlaced() ) // Erase from screen
{
moduleCount++;
Module->Draw( m_canvas, DC, GR_XOR );
}
else
{
genModuleOnRoutingMatrix( Module );
}
}
// Undo command: prepare list
if( newList.GetCount() )
SaveCopyInUndoList( newList, UR_CHANGED );
int cnt = 0;
wxString msg;
while( ( Module = PickModule( this, DC ) ) != NULL )
{
// Display some info about activity, module placement can take a while:
msg.Printf( _( "Place footprint %d of %d" ), cnt, moduleCount );
SetStatusText( msg );
double initialOrient = Module->GetOrientation();
// Display fill area of interest, barriers, penalties.
drawPlacementRoutingMatrix( GetBoard(), DC );
error = getOptimalModulePlacement( this, Module, DC );
double bestScore = MinCout;
double bestRotation = 0.0;
int rotAllowed;
PosOK = CurrPosition;
if( error == ESC )
goto end_of_tst;
// Try orientations 90, 180, 270 degrees from initial orientation
rotAllowed = Module->GetPlacementCost180();
if( rotAllowed != 0 )
{
Rotate_Module( DC, Module, 1800.0, true );
error = getOptimalModulePlacement( this, Module, DC );
MinCout *= OrientPenality[rotAllowed];
if( bestScore > MinCout ) // This orientation is better.
{
PosOK = CurrPosition;
bestScore = MinCout;
bestRotation = 1800.0;
}
else
{
Rotate_Module( DC, Module, initialOrient, false );
}
if( error == ESC )
goto end_of_tst;
}
// Determine if the best orientation of a module is 90.
rotAllowed = Module->GetPlacementCost90();
if( rotAllowed != 0 )
{
Rotate_Module( DC, Module, 900.0, true );
error = getOptimalModulePlacement( this, Module, DC );
MinCout *= OrientPenality[rotAllowed];
if( bestScore > MinCout ) // This orientation is better.
{
PosOK = CurrPosition;
bestScore = MinCout;
bestRotation = 900.0;
}
else
{
Rotate_Module( DC, Module, initialOrient, false );
}
if( error == ESC )
goto end_of_tst;
}
// Determine if the best orientation of a module is -90.
if( rotAllowed != 0 )
{
Rotate_Module( DC, Module, 2700.0, true );
error = getOptimalModulePlacement( this, Module, DC );
MinCout *= OrientPenality[rotAllowed];
if( bestScore > MinCout ) // This orientation is better.
{
PosOK = CurrPosition;
bestScore = MinCout;
bestRotation = 2700.0;
}
else
{
Rotate_Module( DC, Module, initialOrient, false );
}
if( error == ESC )
goto end_of_tst;
}
end_of_tst:
if( error == ESC )
break;
// Place module.
CurrPosition = GetCrossHairPosition();
SetCrossHairPosition( PosOK );
PlaceModule( Module, DC );
bestRotation += initialOrient;
if( bestRotation != Module->GetOrientation() )
Rotate_Module( DC, Module, bestRotation, false );
SetCrossHairPosition( CurrPosition );
Module->CalculateBoundingBox();
genModuleOnRoutingMatrix( Module );
Module->SetIsPlaced( true );
Module->SetNeedsPlaced( false );
}
CurrPosition = memopos;
RoutingMatrix.UnInitRoutingMatrix();
g_Route_Layer_TOP = lay_tmp_TOP;
g_Route_Layer_BOTTOM = lay_tmp_BOTTOM;
Module = GetBoard()->m_Modules;
for( ; Module != NULL; Module = Module->Next() )
{
Module->CalculateBoundingBox();
}
GetBoard()->m_Status_Pcb = 0;
Compile_Ratsnest( DC, true );
m_canvas->ReDraw( DC, true );
}
void PCB_EDIT_FRAME::PutDataInPreviousState( PICKED_ITEMS_LIST* aList, bool aRedoCommand,
bool aRebuildRatsnet )
{
BOARD_ITEM* item;
bool not_found = false;
bool reBuild_ratsnest = false;
KIGFX::VIEW* view = GetGalCanvas()->GetView();
RN_DATA* ratsnest = GetBoard()->GetRatsnest();
// Undo in the reverse order of list creation: (this can allow stacked changes
// like the same item can be changes and deleted in the same complex command
bool build_item_list = true; // if true the list of existing items must be rebuilt
for( int ii = aList->GetCount() - 1; ii >= 0 ; ii-- )
{
item = (BOARD_ITEM*) aList->GetPickedItem( ii );
wxASSERT( item );
/* Test for existence of item on board.
* It could be deleted, and no more on board:
* - if a call to SaveCopyInUndoList was forgotten in Pcbnew
* - in zones outlines, when a change in one zone merges this zone with an other
* This test avoids a Pcbnew crash
* Obviously, this test is not made for deleted items
*/
UNDO_REDO_T status = aList->GetPickedItemStatus( ii );
if( status != UR_DELETED )
{
if( build_item_list )
// Build list of existing items, for integrity test
TestForExistingItem( GetBoard(), NULL );
build_item_list = false;
if( !TestForExistingItem( GetBoard(), item ) )
{
// Remove this non existent item
aList->RemovePicker( ii );
ii++; // the current item was removed, ii points now the next item
// decrement it because it will be incremented later
not_found = true;
continue;
}
}
item->ClearFlags();
// see if we must rebuild ratsnets and pointers lists
switch( item->Type() )
{
case PCB_MODULE_T:
case PCB_ZONE_AREA_T:
case PCB_TRACE_T:
case PCB_VIA_T:
reBuild_ratsnest = true;
break;
default:
break;
}
switch( aList->GetPickedItemStatus( ii ) )
{
case UR_CHANGED: /* Exchange old and new data for each item */
{
BOARD_ITEM* image = (BOARD_ITEM*) aList->GetPickedItemLink( ii );
// Remove all pads/drawings/texts, as they become invalid
// for the VIEW after SwapData() called for modules
if( item->Type() == PCB_MODULE_T )
{
MODULE* oldModule = static_cast<MODULE*>( item );
oldModule->RunOnChildren( boost::bind( &KIGFX::VIEW::Remove, view, _1 ) );
}
ratsnest->Remove( item );
item->SwapData( image );
// Update all pads/drawings/texts, as they become invalid
// for the VIEW after SwapData() called for modules
if( item->Type() == PCB_MODULE_T )
{
MODULE* newModule = static_cast<MODULE*>( item );
newModule->RunOnChildren( boost::bind( &KIGFX::VIEW::Add, view, _1 ) );
}
ratsnest->Add( item );
item->ClearFlags( SELECTED );
item->ViewUpdate( KIGFX::VIEW_ITEM::LAYERS );
}
break;
case UR_NEW: /* new items are deleted */
aList->SetPickedItemStatus( UR_DELETED, ii );
GetBoard()->Remove( item );
if( item->Type() == PCB_MODULE_T )
{
MODULE* module = static_cast<MODULE*>( item );
module->RunOnChildren( boost::bind( &KIGFX::VIEW::Remove, view, _1 ) );
}
view->Remove( item );
item->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
break;
case UR_DELETED: /* deleted items are put in List, as new items */
aList->SetPickedItemStatus( UR_NEW, ii );
GetBoard()->Add( item );
if( item->Type() == PCB_MODULE_T )
{
MODULE* module = static_cast<MODULE*>( item );
module->RunOnChildren( boost::bind( &KIGFX::VIEW::Add, view, _1) );
}
view->Add( item );
item->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
build_item_list = true;
break;
case UR_MOVED:
item->Move( aRedoCommand ? aList->m_TransformPoint : -aList->m_TransformPoint );
item->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
ratsnest->Update( item );
break;
case UR_ROTATED:
item->Rotate( aList->m_TransformPoint,
aRedoCommand ? m_rotationAngle : -m_rotationAngle );
item->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
ratsnest->Update( item );
break;
case UR_ROTATED_CLOCKWISE:
item->Rotate( aList->m_TransformPoint,
aRedoCommand ? -m_rotationAngle : m_rotationAngle );
item->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
ratsnest->Update( item );
break;
case UR_FLIPPED:
item->Flip( aList->m_TransformPoint );
item->ViewUpdate( KIGFX::VIEW_ITEM::LAYERS );
ratsnest->Update( item );
break;
default:
{
wxString msg;
msg.Printf( wxT( "PutDataInPreviousState() error (unknown code %X)" ),
aList->GetPickedItemStatus( ii ) );
wxMessageBox( msg );
}
break;
}
}
if( not_found )
wxMessageBox( wxT( "Incomplete undo/redo operation: some items not found" ) );
// Rebuild pointers and ratsnest that can be changed.
if( reBuild_ratsnest && aRebuildRatsnet )
{
if( IsGalCanvasActive() )
ratsnest->Recalculate();
else
Compile_Ratsnest( NULL, true );
}
}