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

enhancements in pcbnew to eeschema cross-probing. removed change in drc.cpp

This commit is contained in:
CHARRAS 2007-10-01 15:37:42 +00:00
parent 6245ac5286
commit 06c9f9c855
24 changed files with 757 additions and 368 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
change_log.txt
View File

@ -4,6 +4,19 @@ Started 2007-June-11
Please add newer entries at the top, list the date and your name with Please add newer entries at the top, list the date and your name with
email address. email address.
2007-Oct-01 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================
+ pcbnew/eeschema
Cross-probing pcbnew to eeschema:
A left click on a pad in pcbnew moves the eeschema cursor on the corresponding component pin
A left click on a footprint ref or value in pcbnew moves the eeschema cursor on the corresponding component ref or value
A left ckick on a footprint moves the eeschema cursor on the corresponding component anchor
+ pcbnew
removed drc.cpp change line 584, and translate comments in english.
nothing broken:
-> a pad with its netcode = 0 means the pad ** must be left unconnected ** (not attached to * a net).
-> a track with its netcode = 0 means the track is not attached to a net (cannot be connected to any pad).
2007-Sep-30 UPDATE Dick Hollenbeck <dick@softplc.com> 2007-Sep-30 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================ ================================================================================
@ -22,6 +35,7 @@ email address.
* beautification, house keeping. * beautification, house keeping.
2007-Sep-29 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr> 2007-Sep-29 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================ ================================================================================
+ pcbnew + pcbnew

6
common/edaappl.cpp
View File

@ -62,9 +62,9 @@ WinEDA_App::WinEDA_App()
m_MainFrame = NULL; m_MainFrame = NULL;
m_PcbFrame = NULL; m_PcbFrame = NULL;
m_ModuleEditFrame = NULL; // Edition des modules m_ModuleEditFrame = NULL; // Edition des modules
SchematicFrame = NULL; // Edition des Schemas m_SchematicFrame = NULL; // Edition des Schemas
LibeditFrame = NULL; // Edition des composants m_LibeditFrame = NULL; // Edition des composants
ViewlibFrame = NULL; // Visualisation des composants m_ViewlibFrame = NULL; // Visualisation des composants
m_CvpcbFrame = NULL; m_CvpcbFrame = NULL;
m_GerberFrame = NULL; // ecran de visualisation GERBER m_GerberFrame = NULL; // ecran de visualisation GERBER

6
eeschema/block.cpp
View File

@ -681,7 +681,7 @@ void MirrorOneStruct( EDA_BaseStruct* DrawStruct, wxPoint& Center )
MirrorYPoint( px, Center ); MirrorYPoint( px, Center );
px.x -= dx; px.x -= dx;
EDA_Appl->SchematicFrame->PutOnGrid( &px ); EDA_Appl->m_SchematicFrame->PutOnGrid( &px );
DrawText->m_Pos.x = px.x; DrawText->m_Pos.x = px.x;
break; break;
@ -696,14 +696,14 @@ void MirrorOneStruct( EDA_BaseStruct* DrawStruct, wxPoint& Center )
px = DrawText->m_Pos; px = DrawText->m_Pos;
MirrorYPoint( px, Center ); MirrorYPoint( px, Center );
EDA_Appl->SchematicFrame->PutOnGrid( &px ); EDA_Appl->m_SchematicFrame->PutOnGrid( &px );
DrawText->m_Pos.x = px.x; DrawText->m_Pos.x = px.x;
break; break;
case DRAW_LIB_ITEM_STRUCT_TYPE: case DRAW_LIB_ITEM_STRUCT_TYPE:
DrawLibItem = (EDA_SchComponentStruct*) DrawStruct; DrawLibItem = (EDA_SchComponentStruct*) DrawStruct;
dx = DrawLibItem->m_Pos.x; dx = DrawLibItem->m_Pos.x;
EDA_Appl->SchematicFrame->CmpRotationMiroir( DrawLibItem, EDA_Appl->m_SchematicFrame->CmpRotationMiroir( DrawLibItem,
NULL, CMP_MIROIR_Y ); NULL, CMP_MIROIR_Y );
MirrorYPoint( DrawLibItem->m_Pos, Center ); MirrorYPoint( DrawLibItem->m_Pos, Center );
dx -= DrawLibItem->m_Pos.x; dx -= DrawLibItem->m_Pos.x;

2
eeschema/cleanup.cpp
View File

@ -63,7 +63,7 @@ bool SCH_SCREEN::SchematicCleanUp( wxDC* DC )
} }
} }
EDA_Appl->SchematicFrame->TestDanglingEnds( EEDrawList, DC ); EDA_Appl->m_SchematicFrame->TestDanglingEnds( EEDrawList, DC );
return Modify; return Modify;
} }

59
eeschema/controle.cpp
View File

@ -22,33 +22,71 @@
/* variables externes */ /* variables externes */
/***************************************************************/
/**********************************/
void RemoteCommand( const char* cmdline ) void RemoteCommand( const char* cmdline )
/**********************************/ /***************************************************************/
/* Read a remote command sent from pcbnew, so when user selects a module /** Read a remote command sent by pcbnew (via a socket connection) , so when user selects a module
* or pin in pcbnew, eeschema shows that same component or pin. * or pin in pcbnew, eeschema shows that same component or pin.
* The cursor is put on the item
* @param cmdline = received command from pcbnew
* commands are:
* $PART: "reference" put cursor on component
* $PART: "reference" $REF: "ref" put cursor on reference component
* $PART: "reference" $VAL: "value" put cursor on value component
* $PART: "reference" $PAD: "pin name" put cursor on the component pin
*/ */
{ {
char line[1024]; char line[1024];
char* idcmd; char* idcmd;
char* text; char* text;
WinEDA_SchematicFrame* frame = EDA_Appl->m_SchematicFrame;
wxString part_ref, msg;
strncpy( line, cmdline, sizeof(line) - 1 ); strncpy( line, cmdline, sizeof(line) - 1 );
idcmd = strtok( line, " \n\r" ); idcmd = strtok( line, " \n\r" );
text = strtok( NULL, " \n\r" ); text = strtok( NULL, "\"\n\r" );
if( (idcmd == NULL) || (text == NULL) ) if( (idcmd == NULL) || (text == NULL) )
return; return;
if( strcmp( idcmd, "$PART:" ) == 0 ) if( strcmp( idcmd, "$PART:" ) != 0 )
{ return;
WinEDA_SchematicFrame* frame = EDA_Appl->SchematicFrame;
wxString msg = CONV_FROM_UTF8( text ); part_ref = CONV_FROM_UTF8( text );
frame->FindSchematicItem( msg, 1, false );
/* look for a complement */
idcmd = strtok( NULL, " \n\r" );
if( idcmd == NULL ) // component only
{
frame->FindComponentAndItem( part_ref, true, 0, wxEmptyString, false );
return;
} }
text = strtok( NULL, "\"\n\r" );
if( text == NULL )
return;
msg = CONV_FROM_UTF8( text );
if( strcmp( idcmd, "$REF:" ) == 0 )
{
frame->FindComponentAndItem( part_ref, true, 2, msg, false );
}
else if( strcmp( idcmd, "$VAL:" ) == 0 )
{
frame->FindComponentAndItem( part_ref, true, 3, msg, false );
}
else if( strcmp( idcmd, "$PAD:" ) == 0 )
{
frame->FindComponentAndItem( part_ref, true, 1, msg, false );
}
else
frame->FindComponentAndItem( part_ref, true, 0, wxEmptyString, false );
} }
@ -396,5 +434,4 @@ void WinEDA_DrawFrame::GeneralControle( wxDC* DC, wxPoint MousePositionInPixels
} }
Affiche_Status_Box(); /* Affichage des coord curseur */ Affiche_Status_Box(); /* Affichage des coord curseur */
} }

2
eeschema/delsheet.cpp
View File

@ -24,7 +24,7 @@ void DeleteSubHierarchy(DrawSheetStruct * FirstSheet, bool confirm_deletion)
{ {
EDA_BaseStruct *DrawStruct; EDA_BaseStruct *DrawStruct;
EDA_BaseStruct *EEDrawList; EDA_BaseStruct *EEDrawList;
WinEDA_SchematicFrame * frame = EDA_Appl->SchematicFrame; WinEDA_SchematicFrame * frame = EDA_Appl->m_SchematicFrame;
wxString msg; wxString msg;
if( FirstSheet == NULL ) return; if( FirstSheet == NULL ) return;

4
eeschema/dialog_eeschema_config.cpp
View File

@ -295,8 +295,8 @@ void KiConfigEeschemaFrame::OnCloseWindow(wxCloseEvent & event)
if ( m_LibListChanged ) if ( m_LibListChanged )
{ {
LoadLibraries(m_Parent); LoadLibraries(m_Parent);
if ( m_Parent->m_Parent->ViewlibFrame ) if ( m_Parent->m_Parent->m_ViewlibFrame )
m_Parent->m_Parent->ViewlibFrame->ReCreateListLib(); m_Parent->m_Parent->m_ViewlibFrame->ReCreateListLib();
} }
EndModal(0); EndModal(0);
} }

8
eeschema/eeconfig.cpp
View File

@ -159,13 +159,13 @@ wxArrayString liblist_tmp = g_LibName_List;
g_LibName_List.Add( wxT("device") ); g_LibName_List.Add( wxT("device") );
} }
if ( EDA_Appl->SchematicFrame ) if ( EDA_Appl->m_SchematicFrame )
{ {
EDA_Appl->SchematicFrame->SetDrawBgColor(g_DrawBgColor); EDA_Appl->m_SchematicFrame->SetDrawBgColor(g_DrawBgColor);
EDA_Appl->SchematicFrame->m_Draw_Grid = g_ShowGrid; EDA_Appl->m_SchematicFrame->m_Draw_Grid = g_ShowGrid;
} }
LoadLibraries(EDA_Appl->SchematicFrame); LoadLibraries(EDA_Appl->m_SchematicFrame);
return IsRead; return IsRead;
} }

22
eeschema/eeschema.cpp
View File

@ -66,41 +66,41 @@ bool WinEDA_App::OnInit()
/* init EESCHEMA */ /* init EESCHEMA */
GetSettings(); // read current setup GetSettings(); // read current setup
SeedLayers(); SeedLayers();
Read_Hotkey_Config( SchematicFrame, false ); /* Must be called before creating the main frame Read_Hotkey_Config( m_SchematicFrame, false ); /* Must be called before creating the main frame
* in order to display the real hotkeys in menus * in order to display the real hotkeys in menus
* or tool tips */ * or tool tips */
// Create main frame (schematic frame) : // Create main frame (schematic frame) :
SchematicFrame = new WinEDA_SchematicFrame( NULL, this, m_SchematicFrame = new WinEDA_SchematicFrame( NULL, this,
wxT( "EESchema" ), wxT( "EESchema" ),
wxPoint( 0, 0 ), wxSize( 600, 400 ) ); wxPoint( 0, 0 ), wxSize( 600, 400 ) );
SetTopWindow( SchematicFrame ); SetTopWindow( m_SchematicFrame );
SchematicFrame->Show( TRUE ); m_SchematicFrame->Show( TRUE );
if( CreateServer( SchematicFrame, KICAD_SCH_PORT_SERVICE_NUMBER ) ) if( CreateServer( m_SchematicFrame, KICAD_SCH_PORT_SERVICE_NUMBER ) )
{ {
// RemoteCommand is in controle.cpp and is called when PCBNEW // RemoteCommand is in controle.cpp and is called when PCBNEW
// sends EESCHEMA a command // sends EESCHEMA a command
SetupServerFunction( RemoteCommand ); SetupServerFunction( RemoteCommand );
} }
SchematicFrame->Zoom_Automatique( TRUE ); m_SchematicFrame->Zoom_Automatique( TRUE );
/* Load file specified in the command line. */ /* Load file specified in the command line. */
if( !FFileName.IsEmpty() ) if( !FFileName.IsEmpty() )
{ {
ChangeFileNameExt( FFileName, g_SchExtBuffer ); ChangeFileNameExt( FFileName, g_SchExtBuffer );
wxSetWorkingDirectory( wxPathOnly( FFileName ) ); wxSetWorkingDirectory( wxPathOnly( FFileName ) );
if( SchematicFrame->DrawPanel ) if( m_SchematicFrame->DrawPanel )
if( SchematicFrame->LoadOneEEProject( FFileName, FALSE ) <= 0 ) if( m_SchematicFrame->LoadOneEEProject( FFileName, FALSE ) <= 0 )
SchematicFrame->DrawPanel->Refresh( TRUE ); // File not found or error m_SchematicFrame->DrawPanel->Refresh( TRUE ); // File not found or error
} }
else else
{ {
Read_Config( wxEmptyString, TRUE ); // Read config file ici si pas de fichier a charger Read_Config( wxEmptyString, TRUE ); // Read config file ici si pas de fichier a charger
if( SchematicFrame->DrawPanel ) if( m_SchematicFrame->DrawPanel )
SchematicFrame->DrawPanel->Refresh( TRUE ); m_SchematicFrame->DrawPanel->Refresh( TRUE );
} }
return TRUE; return TRUE;

242
eeschema/find.cpp
View File

@ -56,6 +56,213 @@ void WinEDA_FindFrame::FindMarker( wxCommandEvent& event )
} }
/************************************************************************/
EDA_BaseStruct* WinEDA_SchematicFrame::FindComponentAndItem(
const wxString& component_reference, bool Find_in_hierarchy,
int SearchType,
const wxString& text_to_find,
bool mouseWarp )
/************************************************************************/
/**
* Function FindComponentAndItem
* finds a Component in the schematic, and an item in this component.
* @param pattern The text to search for, either in value, reference or elsewhere.
* @param Find_in_hierarchy: false => Search is made in current sheet
* true => the whole hierarchy
* @param SearchType: 0 => find component
* 1 => find pin
* 2 => find ref
* 3 => find value
* >= 4 => unused (same as 0)
* @param mouseWarp If true, then move the mouse cursor to the item.
*/
{
SCH_SCREEN* Screen, * ScreenWithComponentFound = NULL;
EDA_BaseStruct* DrawList = NULL;
EDA_SchComponentStruct* Component = NULL;
wxSize DrawAreaSize = DrawPanel->GetClientSize();
wxPoint pos, curpos;
bool DoCenterAndRedraw = FALSE;
bool NotFound = true;
wxString msg;
LibDrawPin* pin;
EDA_ScreenList ScreenList( NULL );
Screen = ScreenList.GetFirst();
if( !Find_in_hierarchy )
Screen = (SCH_SCREEN*) m_CurrentScreen;
for( ; Screen != NULL; Screen = ScreenList.GetNext() )
{
DrawList = Screen->EEDrawList;
for( ; (DrawList != NULL) && (NotFound == true); DrawList = DrawList->Pnext )
{
if( DrawList->Type() == DRAW_LIB_ITEM_STRUCT_TYPE )
{
EDA_SchComponentStruct* pSch;
pSch = (EDA_SchComponentStruct*) DrawList;
if( component_reference.CmpNoCase( pSch->m_Field[REFERENCE].m_Text ) == 0 )
{
Component = pSch;
ScreenWithComponentFound = Screen;
switch( SearchType )
{
default:
case 0: // Find component only
NotFound = FALSE;
pos = pSch->m_Pos;
break;
case 1: // find a pin
pos = pSch->m_Pos; // temporary: will be changed if the pin is found
pin = LocatePinByNumber( text_to_find, pSch );
if( pin == NULL )
break;
NotFound = FALSE;
pos += pin->m_Pos;
break;
case 2: // find reference
NotFound = FALSE;
pos = pSch->m_Field[REFERENCE].m_Pos;
break;
case 3: // find value
pos = pSch->m_Pos;
if( text_to_find.CmpNoCase( pSch->m_Field[VALUE].m_Text ) != 0 )
break;
NotFound = FALSE;
pos = pSch->m_Field[VALUE].m_Pos;
break;
}
}
}
}
if( (Find_in_hierarchy == FALSE) || (NotFound == FALSE) )
break;
}
if( Component )
{
Screen = ScreenWithComponentFound;
if( Screen != GetScreen() )
{
Screen->SetZoom( GetScreen()->GetZoom() );
m_CurrentScreen = ActiveScreen = Screen;
DoCenterAndRedraw = TRUE;
}
wxPoint delta;
pos -= Component->m_Pos;
delta.x = Component->m_Transform[0][0] * pos.x + Component->m_Transform[0][1] * pos.y;
delta.y = Component->m_Transform[1][0] * pos.x + Component->m_Transform[1][1] * pos.y;
pos = delta + Component->m_Pos;
wxPoint old_cursor_position = Screen->m_Curseur;
Screen->m_Curseur = pos;
curpos = DrawPanel->CursorScreenPosition();
DrawPanel->GetViewStart(
&m_CurrentScreen->m_StartVisu.x,
&m_CurrentScreen->m_StartVisu.y );
// calcul des coord curseur avec origine = screen
curpos.x -= m_CurrentScreen->m_StartVisu.x;
curpos.y -= m_CurrentScreen->m_StartVisu.y;
/* Il y a peut-etre necessite de recadrer le dessin: */
#define MARGIN 30
if( (curpos.x <= MARGIN) || (curpos.x >= DrawAreaSize.x - MARGIN)
|| (curpos.y <= MARGIN) || (curpos.y >= DrawAreaSize.y - MARGIN) )
{
DoCenterAndRedraw = true;;
}
#undef MARGIN
if ( DoCenterAndRedraw )
Recadre_Trace( mouseWarp );
else
{
wxClientDC dc( DrawPanel );
DrawPanel->PrepareGraphicContext( &dc );
EXCHG( old_cursor_position, Screen->m_Curseur );
DrawPanel->CursorOff( &dc );
if( mouseWarp )
GRMouseWarp( DrawPanel, curpos );
EXCHG( old_cursor_position, Screen->m_Curseur );
DrawPanel->CursorOn( &dc );
}
}
/* Print diaq */
wxString msg_item;
msg = component_reference;
switch( SearchType )
{
default:
case 0:
break; // Find component only
case 1: // find a pin
msg_item = _( "Pin " ) + text_to_find;
break;
case 2: // find reference
msg_item = _( "Ref " ) + text_to_find;
break;
case 3: // find value
msg_item = _( "Value " ) + text_to_find;
break;
case 4: // find field. todo
msg_item = _( "Field " ) + text_to_find;
break;
}
if( Component )
{
if( !NotFound )
{
if( !msg_item.IsEmpty() )
msg += wxT( " " ) + msg_item;
msg += _( " Found" );
}
else
{
msg += _( " Found" );
if( !msg_item.IsEmpty() )
{
msg += wxT( " but " ) + msg_item + _( " not found" );
}
}
}
else
{
if( !msg_item.IsEmpty() )
msg += wxT( " " ) + msg_item;
msg += _( " not found" );
}
Affiche_Message( msg );
return DrawList;
}
/*****************************************************************/ /*****************************************************************/
EDA_BaseStruct* WinEDA_SchematicFrame::FindMarker( int SearchType ) EDA_BaseStruct* WinEDA_SchematicFrame::FindMarker( int SearchType )
/*****************************************************************/ /*****************************************************************/
@ -71,9 +278,9 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindMarker( int SearchType )
int StartCount; int StartCount;
bool NotFound; bool NotFound;
wxPoint firstpos, pos; wxPoint firstpos, pos;
wxSize size = DrawPanel->GetClientSize(); wxSize DrawAreaSize = DrawPanel->GetClientSize();
wxPoint curpos, old_cursor_position; wxPoint curpos, old_cursor_position;
bool force_recadre = FALSE; bool DoCenterAndRedraw = FALSE;
wxString msg, WildText; wxString msg, WildText;
g_LastSearchIsMarker = TRUE; g_LastSearchIsMarker = TRUE;
@ -131,7 +338,7 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindMarker( int SearchType )
{ {
Screen->SetZoom( GetScreen()->GetZoom() ); Screen->SetZoom( GetScreen()->GetZoom() );
m_CurrentScreen = ActiveScreen = Screen; m_CurrentScreen = ActiveScreen = Screen;
force_recadre = TRUE; DoCenterAndRedraw = TRUE;
} }
old_cursor_position = Screen->m_Curseur; old_cursor_position = Screen->m_Curseur;
@ -145,11 +352,16 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindMarker( int SearchType )
curpos.y -= m_CurrentScreen->m_StartVisu.y; curpos.y -= m_CurrentScreen->m_StartVisu.y;
// reposition the window if the chosen marker is off screen. // reposition the window if the chosen marker is off screen.
if( (curpos.x <= 0) || (curpos.x >= size.x - 1) #define MARGIN 30
|| (curpos.y <= 0) || (curpos.y >= size.y) || force_recadre ) if( (curpos.x <= MARGIN) || (curpos.x >= DrawAreaSize.x - MARGIN)
|| (curpos.y <= MARGIN) || (curpos.y >= DrawAreaSize.y - MARGIN) )
{ {
Recadre_Trace( TRUE ); DoCenterAndRedraw = true;;
} }
#undef MARGIN
if( DoCenterAndRedraw )
Recadre_Trace( TRUE );
else else
{ {
wxClientDC dc( DrawPanel ); wxClientDC dc( DrawPanel );
@ -218,9 +430,9 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindSchematicItem(
bool NotFound; bool NotFound;
wxPoint firstpos, pos, old_cursor_position; wxPoint firstpos, pos, old_cursor_position;
static int Find_in_hierarchy; static int Find_in_hierarchy;
wxSize size = DrawPanel->GetClientSize(); wxSize DrawAreaSize = DrawPanel->GetClientSize();
wxPoint curpos; wxPoint curpos;
bool force_recadre = FALSE; bool DoCenterAndRedraw = FALSE;
wxString msg, WildText; wxString msg, WildText;
g_LastSearchIsMarker = FALSE; g_LastSearchIsMarker = FALSE;
@ -337,10 +549,10 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindSchematicItem(
{ {
Screen->SetZoom( GetScreen()->GetZoom() ); Screen->SetZoom( GetScreen()->GetZoom() );
m_CurrentScreen = ActiveScreen = Screen; m_CurrentScreen = ActiveScreen = Screen;
force_recadre = TRUE; DoCenterAndRedraw = TRUE;
} }
/* If the struct found is a DRAW_LIB_ITEM_STRUCT_TYPE type, /* the struct is a DRAW_LIB_ITEM_STRUCT_TYPE type,
* coordinates must be computed according to its orientation matrix * coordinates must be computed according to its orientation matrix
*/ */
if( Struct->Type() == DRAW_LIB_ITEM_STRUCT_TYPE ) if( Struct->Type() == DRAW_LIB_ITEM_STRUCT_TYPE )
@ -371,11 +583,15 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindSchematicItem(
curpos.y -= m_CurrentScreen->m_StartVisu.y; curpos.y -= m_CurrentScreen->m_StartVisu.y;
/* Il y a peut-etre necessite de recadrer le dessin: */ /* Il y a peut-etre necessite de recadrer le dessin: */
if( (curpos.x <= 0) || (curpos.x >= size.x - 1) #define MARGIN 30
|| (curpos.y <= 0) || (curpos.y >= size.y) || force_recadre ) if( (curpos.x <= MARGIN) || (curpos.x >= DrawAreaSize.x - MARGIN)
|| (curpos.y <= MARGIN) || (curpos.y >= DrawAreaSize.y - MARGIN) )
{ {
Recadre_Trace( mouseWarp ); DoCenterAndRedraw = true;
} }
if ( DoCenterAndRedraw )
Recadre_Trace( mouseWarp );
else else
{ {
wxClientDC dc( DrawPanel ); wxClientDC dc( DrawPanel );

6
eeschema/getpart.cpp
View File

@ -31,14 +31,14 @@ wxString SelectFromLibBrowser( WinEDA_DrawFrame* parent )
WinEDA_ViewlibFrame* Viewer; WinEDA_ViewlibFrame* Viewer;
wxSemaphore semaphore( 0, 1 ); wxSemaphore semaphore( 0, 1 );
Viewer = parent->m_Parent->ViewlibFrame; Viewer = parent->m_Parent->m_ViewlibFrame;
/* Close the current Lib browser, if open, and open a new one, in "modal" mode */ /* Close the current Lib browser, if open, and open a new one, in "modal" mode */
if( Viewer ) if( Viewer )
Viewer->Destroy(); Viewer->Destroy();
Viewer = parent->m_Parent->ViewlibFrame = new Viewer = parent->m_Parent->m_ViewlibFrame = new
WinEDA_ViewlibFrame( WinEDA_ViewlibFrame(
parent->m_Parent->SchematicFrame, parent->m_Parent->m_SchematicFrame,
parent->m_Parent, parent->m_Parent,
NULL, NULL,
&semaphore ); &semaphore );

2
eeschema/libframe.cpp
View File

@ -88,7 +88,7 @@ WinEDA_LibeditFrame::WinEDA_LibeditFrame( wxWindow* father,
WinEDA_LibeditFrame::~WinEDA_LibeditFrame() WinEDA_LibeditFrame::~WinEDA_LibeditFrame()
/**********************************************/ /**********************************************/
{ {
m_Parent->LibeditFrame = NULL; m_Parent->m_LibeditFrame = NULL;
m_CurrentScreen = ScreenSch; m_CurrentScreen = ScreenSch;
} }

57
eeschema/locate.cpp
View File

@ -1036,6 +1036,57 @@ int distance( int dx, int dy, int spot_cX, int spot_cY, int seuil )
return 0; return 0;
} }
/*******************************************************************/
LibDrawPin* LocatePinByNumber( const wxString & ePin_Number,
EDA_SchComponentStruct* eComponent )
/*******************************************************************/
/** Find a PIN in a component
* @param pin_number = pin number (string)
* @param pin_number = pin number (string)
* @return a pointer on the pin, or NULL if not found
*/
{
LibEDA_BaseStruct* DrawItem;
EDA_LibComponentStruct* Entry;
LibDrawPin* Pin;
int Unit, Convert;
Entry = FindLibPart(eComponent->m_ChipName.GetData(), wxEmptyString, FIND_ROOT );
if( Entry == NULL )
return NULL;
if( Entry->Type != ROOT )
{
DisplayError( NULL, wxT( "LocatePinByNumber() error: Entry is ALIAS" ) );
return NULL;
}
Unit = eComponent->m_Multi;
Convert = eComponent->m_Convert;
DrawItem = Entry->m_Drawings;
for( ; DrawItem != NULL; DrawItem = DrawItem->Next() )
{
if( DrawItem->Type() == COMPONENT_PIN_DRAW_TYPE ) /* Pin Trouvee */
{
Pin = (LibDrawPin*) DrawItem;
if( Unit && DrawItem->m_Unit && (DrawItem->m_Unit != Unit) )
continue;
if( Convert && DrawItem->m_Convert && (DrawItem->m_Convert != Convert) )
continue;
wxString pNumber;
Pin->ReturnPinStringNum( pNumber );
if ( ePin_Number == pNumber )
return Pin;
}
}
return NULL;
}
/*******************************************************************/ /*******************************************************************/
LibEDA_BaseStruct* LocatePin( const wxPoint& RefPos, LibEDA_BaseStruct* LocatePin( const wxPoint& RefPos,
@ -1047,12 +1098,6 @@ LibEDA_BaseStruct* LocatePin( const wxPoint& RefPos,
* retourne un pointeur sur la pin, ou NULL si pas trouve * retourne un pointeur sur la pin, ou NULL si pas trouve
* Si Unit = 0, le numero d'unite n'est pas teste * Si Unit = 0, le numero d'unite n'est pas teste
* Si convert = 0, le numero convert n'est pas teste * Si convert = 0, le numero convert n'est pas teste
*
* m_Transform = matrice de transformation.
* Si NULL: matrice de transformation " normale" [1 , 0 , 0 , -1]
* (la matrice de transformation " normale" etant [1 , 0 , 0 , -1]
* la coord dy doit etre inversee).
* PartX, PartY: coordonnees de positionnement du composant
*/ */
{ {
LibEDA_BaseStruct* DrawItem; LibEDA_BaseStruct* DrawItem;

2
eeschema/protos.h
View File

@ -118,6 +118,8 @@ bool DrawStructInBox(int x1, int y1, int x2, int y2,
/*************/ /*************/
/* LOCATE.CPP */ /* LOCATE.CPP */
/*************/ /*************/
LibDrawPin* LocatePinByNumber( const wxString & ePin_Number,
EDA_SchComponentStruct* eComponent );
EDA_SchComponentStruct * LocateSmallestComponent( SCH_SCREEN * Screen ); EDA_SchComponentStruct * LocateSmallestComponent( SCH_SCREEN * Screen );
/* Recherche du plus petit (en surface) composant pointe par la souris */ /* Recherche du plus petit (en surface) composant pointe par la souris */

20
eeschema/schedit.cpp
View File

@ -182,19 +182,19 @@ void WinEDA_SchematicFrame::Process_Special_Functions( wxCommandEvent& event )
break; break;
case ID_TO_LIBRARY: case ID_TO_LIBRARY:
if( m_Parent->LibeditFrame ) if( m_Parent->m_LibeditFrame )
{ {
m_Parent->LibeditFrame->Show( TRUE ); m_Parent->m_LibeditFrame->Show( TRUE );
} }
else else
{ {
m_Parent->LibeditFrame = new m_Parent->m_LibeditFrame = new
WinEDA_LibeditFrame( m_Parent->SchematicFrame, WinEDA_LibeditFrame( m_Parent->m_SchematicFrame,
m_Parent, m_Parent,
wxT( "Library Editor" ), wxT( "Library Editor" ),
wxPoint( -1, -1 ), wxSize( 600, 400 ) ); wxPoint( -1, -1 ), wxSize( 600, 400 ) );
ActiveScreen = ScreenLib; ActiveScreen = ScreenLib;
m_Parent->LibeditFrame->AdjustScrollBars(); m_Parent->m_LibeditFrame->AdjustScrollBars();
} }
break; break;
@ -229,15 +229,15 @@ void WinEDA_SchematicFrame::Process_Special_Functions( wxCommandEvent& event )
} }
case ID_TO_LIBVIEW: case ID_TO_LIBVIEW:
if( m_Parent->ViewlibFrame ) if( m_Parent->m_ViewlibFrame )
{ {
m_Parent->ViewlibFrame->Show( TRUE ); m_Parent->m_ViewlibFrame->Show( TRUE );
} }
else else
{ {
m_Parent->ViewlibFrame = new m_Parent->m_ViewlibFrame = new
WinEDA_ViewlibFrame( m_Parent->SchematicFrame, m_Parent ); WinEDA_ViewlibFrame( m_Parent->m_SchematicFrame, m_Parent );
m_Parent->ViewlibFrame->AdjustScrollBars(); m_Parent->m_ViewlibFrame->AdjustScrollBars();
} }
break; break;

6
eeschema/schframe.cpp
View File

@ -154,7 +154,7 @@ WinEDA_SchematicFrame:: WinEDA_SchematicFrame(wxWindow * father, WinEDA_App *par
WinEDA_SchematicFrame::~WinEDA_SchematicFrame() WinEDA_SchematicFrame::~WinEDA_SchematicFrame()
{ {
m_Parent->SchematicFrame = NULL; m_Parent->m_SchematicFrame = NULL;
m_CurrentScreen = ScreenSch; m_CurrentScreen = ScreenSch;
} }
@ -164,9 +164,9 @@ void WinEDA_SchematicFrame::OnCloseWindow(wxCloseEvent & Event)
{ {
SCH_SCREEN * screen; SCH_SCREEN * screen;
if ( m_Parent->LibeditFrame ) // Can close component editor ? if ( m_Parent->m_LibeditFrame ) // Can close component editor ?
{ {
if ( ! m_Parent->LibeditFrame->Close() ) return; if ( ! m_Parent->m_LibeditFrame->Close() ) return;
} }
screen = ScreenSch ; screen = ScreenSch ;

2
eeschema/symbdraw.cpp
View File

@ -793,7 +793,7 @@ static void ComputeArc( LibDrawArc* DrawItem, wxPoint ArcCentre )
wxString msg; wxString msg;
angle = DrawItem->t2 - DrawItem->t1; angle = DrawItem->t2 - DrawItem->t1;
msg.Printf( _( "Arc %.1f deg" ), (float) angle / 10 ); msg.Printf( _( "Arc %.1f deg" ), (float) angle / 10 );
EDA_Appl->LibeditFrame->PrintMsg( msg ); EDA_Appl->m_LibeditFrame->PrintMsg( msg );
while( (DrawItem->t2 - DrawItem->t1) >= 1800 ) while( (DrawItem->t2 - DrawItem->t1) >= 1800 )
{ {

2
eeschema/viewlib_frame.cpp
View File

@ -109,7 +109,7 @@ WinEDA_ViewlibFrame::WinEDA_ViewlibFrame(wxWindow * father, WinEDA_App *parent,
WinEDA_ViewlibFrame::~WinEDA_ViewlibFrame() WinEDA_ViewlibFrame::~WinEDA_ViewlibFrame()
{ {
delete m_CurrentScreen; delete m_CurrentScreen;
m_Parent->ViewlibFrame = NULL; m_Parent->m_ViewlibFrame = NULL;
} }
/*****************************************************************/ /*****************************************************************/

6
include/appl_wxstruct.h
View File

@ -30,9 +30,9 @@ public:
WinEDA_PcbFrame* m_PcbFrame; WinEDA_PcbFrame* m_PcbFrame;
WinEDA_ModuleEditFrame* m_ModuleEditFrame; WinEDA_ModuleEditFrame* m_ModuleEditFrame;
WinEDA_GerberFrame* m_GerberFrame; WinEDA_GerberFrame* m_GerberFrame;
WinEDA_SchematicFrame* SchematicFrame; // Edition des Schemas WinEDA_SchematicFrame* m_SchematicFrame; // Edition des Schemas
WinEDA_LibeditFrame* LibeditFrame; // Edition des composants WinEDA_LibeditFrame* m_LibeditFrame; // Edition des composants
WinEDA_ViewlibFrame* ViewlibFrame; // Visualisation des composants WinEDA_ViewlibFrame* m_ViewlibFrame; // Visualisation des composants
WinEDA_CvpcbFrame* m_CvpcbFrame; WinEDA_CvpcbFrame* m_CvpcbFrame;
wxPoint m_HelpPos; wxPoint m_HelpPos;

34
include/wxstruct.h
View File

@ -177,8 +177,12 @@ public:
void PrintMsg( const wxString& text ); void PrintMsg( const wxString& text );
void GetSettings(); void GetSettings();
void SaveSettings(); void SaveSettings();
int WriteHotkeyConfigFile(const wxString & Filename, struct Ki_HotkeyInfoSectionDescriptor * DescList, bool verbose); int WriteHotkeyConfigFile( const wxString& Filename,
int ReadHotkeyConfigFile(const wxString & Filename, struct Ki_HotkeyInfoSectionDescriptor * DescList, bool verbose); struct Ki_HotkeyInfoSectionDescriptor* DescList,
bool verbose );
int ReadHotkeyConfigFile( const wxString& Filename,
struct Ki_HotkeyInfoSectionDescriptor* DescList,
bool verbose );
void SetLanguage( wxCommandEvent& event ); void SetLanguage( wxCommandEvent& event );
void ProcessFontPreferences( int id ); void ProcessFontPreferences( int id );
@ -244,6 +248,7 @@ public:
void AddFontSelectionMenu( wxMenu* main_menu ); void AddFontSelectionMenu( wxMenu* main_menu );
void ProcessFontPreferences( wxCommandEvent& event ); void ProcessFontPreferences( wxCommandEvent& event );
void Affiche_Message( const wxString& message ); void Affiche_Message( const wxString& message );
void EraseMsgBox(); void EraseMsgBox();
void Process_PageSettings( wxCommandEvent& event ); void Process_PageSettings( wxCommandEvent& event );
@ -379,6 +384,7 @@ private:
public: public:
// Read/write fonctions: // Read/write fonctions:
EDA_BaseStruct* ReadDrawSegmentDescr( FILE* File, int* LineNum ); EDA_BaseStruct* ReadDrawSegmentDescr( FILE* File, int* LineNum );
int ReadListeSegmentDescr( wxDC* DC, FILE* File, int ReadListeSegmentDescr( wxDC* DC, FILE* File,
@ -550,7 +556,6 @@ public:
/*****************************************************/ /*****************************************************/
class WinEDA_PcbFrame : public WinEDA_BasePcbFrame class WinEDA_PcbFrame : public WinEDA_BasePcbFrame
{ {
public: public:
WinEDAChoiceBox* m_SelLayerBox; WinEDAChoiceBox* m_SelLayerBox;
WinEDAChoiceBox* m_SelTrackWidthBox; WinEDAChoiceBox* m_SelTrackWidthBox;
@ -824,7 +829,6 @@ public:
EDA_BaseStruct* Locate( int typeloc ); EDA_BaseStruct* Locate( int typeloc );
void SetToolbars(); void SetToolbars();
void Process_Settings( wxCommandEvent& event ); void Process_Settings( wxCommandEvent& event );
void Process_Config( wxCommandEvent& event ); void Process_Config( wxCommandEvent& event );
@ -989,7 +993,6 @@ enum fl_rot_cmp {
CMP_ORIENT_270, // orientation -90, pas de miroir CMP_ORIENT_270, // orientation -90, pas de miroir
CMP_MIROIR_X = 0x100, // miroir selon axe X CMP_MIROIR_X = 0x100, // miroir selon axe X
CMP_MIROIR_Y = 0x200 // miroir selon axe Y CMP_MIROIR_Y = 0x200 // miroir selon axe Y
}; };
class WinEDA_SchematicFrame : public WinEDA_DrawFrame class WinEDA_SchematicFrame : public WinEDA_DrawFrame
@ -1018,7 +1021,9 @@ public:
void ReCreateOptToolbar(); void ReCreateOptToolbar();
void ReCreateMenuBar(); void ReCreateMenuBar();
void SetToolbars(); void SetToolbars();
void OnHotKey( wxDC* DC, int hotkey, EDA_BaseStruct* DrawStruct ); void OnHotKey( wxDC* DC,
int hotkey,
EDA_BaseStruct* DrawStruct );
SCH_SCREEN* GetScreen() { return (SCH_SCREEN*) m_CurrentScreen; } SCH_SCREEN* GetScreen() { return (SCH_SCREEN*) m_CurrentScreen; }
@ -1031,9 +1036,16 @@ public:
void ToolOnRightClick( wxCommandEvent& event ); void ToolOnRightClick( wxCommandEvent& event );
int BestZoom(); // Retourne le meilleur zoom int BestZoom(); // Retourne le meilleur zoom
EDA_BaseStruct* SchematicGeneralLocateAndDisplay( bool IncludePin = TRUE ); EDA_BaseStruct* SchematicGeneralLocateAndDisplay(
EDA_BaseStruct* SchematicGeneralLocateAndDisplay( const wxPoint& refpoint, bool IncludePin = TRUE );
EDA_BaseStruct* SchematicGeneralLocateAndDisplay(
const wxPoint& refpoint,
bool IncludePin ); bool IncludePin );
EDA_BaseStruct* WinEDA_SchematicFrame:: FindComponentAndItem(
const wxString& component_reference, bool Find_in_hierarchy,
int SearchType,
const wxString& text_to_find,
bool mouseWarp );
/* netlist generation */ /* netlist generation */
void* BuildNetListBase(); void* BuildNetListBase();
@ -1053,6 +1065,7 @@ public:
bool LoadOneSheet( SCH_SCREEN* screen, const wxString& FullFileName ); bool LoadOneSheet( SCH_SCREEN* screen, const wxString& FullFileName );
// General search: // General search:
/** /**
* Function FindSchematicItem * Function FindSchematicItem
* finds a string in the schematic. * finds a string in the schematic.
@ -1062,7 +1075,9 @@ public:
* 2 => or for the next item * 2 => or for the next item
* @param mouseWarp If true, then move the mouse cursor to the item. * @param mouseWarp If true, then move the mouse cursor to the item.
*/ */
EDA_BaseStruct* FindSchematicItem( const wxString& pattern, int SearchType, bool mouseWarp=true ); EDA_BaseStruct* FindSchematicItem( const wxString& pattern,
int SearchType,
bool mouseWarp = true );
EDA_BaseStruct* FindMarker( int SearchType ); EDA_BaseStruct* FindMarker( int SearchType );
@ -1209,6 +1224,7 @@ public:
int BestZoom(); // Retourne le meilleur zoom int BestZoom(); // Retourne le meilleur zoom
void SetToolbars(); void SetToolbars();
void OnLeftDClick( wxDC* DC, const wxPoint& MousePos ); void OnLeftDClick( wxDC* DC, const wxPoint& MousePos );
SCH_SCREEN* GetScreen() { return (SCH_SCREEN*) m_CurrentScreen; } SCH_SCREEN* GetScreen() { return (SCH_SCREEN*) m_CurrentScreen; }
void OnHotKey( wxDC* DC, int hotkey, EDA_BaseStruct* DrawStruct ); void OnHotKey( wxDC* DC, int hotkey, EDA_BaseStruct* DrawStruct );

35
pcbnew/controle.cpp
View File

@ -17,23 +17,26 @@
#include "bitmaps.h" #include "bitmaps.h"
/****************************************/ /*******************************************/
void RemoteCommand( const char* cmdline ) void RemoteCommand( const char* cmdline )
/****************************************/ /*******************************************/
/* Read a remote command send by eeschema via a socket, /** Read a remote command send by eeschema via a socket,
* port KICAD_PCB_PORT_SERVICE_NUMBER (currently 4242) * port KICAD_PCB_PORT_SERVICE_NUMBER (currently 4242)
* @param cmdline = received command from eeschema
* Commands are
* $PART: "reference" put cursor on component
* $PIN: "pin name" $PART: "reference" put cursor on the footprint pin
*/ */
{ {
char line[1024]; char line[1024];
wxString msg; wxString msg;
char* idcmd; char* idcmd;
char* text; char* text;
WinEDA_PcbFrame* frame = EDA_Appl->m_PcbFrame;
MODULE* module = 0; MODULE* module = 0;
WinEDA_PcbFrame* frame = EDA_Appl->m_PcbFrame;
strncpy( line, cmdline, sizeof(line) - 1 ); strncpy( line, cmdline, sizeof(line) - 1 );
msg = CONV_FROM_UTF8( line );
idcmd = strtok( line, " \n\r" ); idcmd = strtok( line, " \n\r" );
text = strtok( NULL, " \n\r" ); text = strtok( NULL, " \n\r" );
@ -104,6 +107,7 @@ void RemoteCommand( const char* cmdline )
msg.Printf( _( "Pin %s (module %s) not found" ), pinName.GetData(), modName.GetData() ); msg.Printf( _( "Pin %s (module %s) not found" ), pinName.GetData(), modName.GetData() );
else else
msg.Printf( _( "Locate Pin %s (module %s)" ), pinName.GetData(), modName.GetData() ); msg.Printf( _( "Locate Pin %s (module %s)" ), pinName.GetData(), modName.GetData() );
frame->Affiche_Message( msg ); frame->Affiche_Message( msg );
} }
@ -212,9 +216,11 @@ BOARD_ITEM* WinEDA_BasePcbFrame::PcbGeneralLocateAndDisplay( int aHotKeyCode )
m_Collector->Collect( m_Pcb, scanList, GetScreen()->RefPos( true ), guide ); m_Collector->Collect( m_Pcb, scanList, GetScreen()->RefPos( true ), guide );
#if 0 #if 0
// debugging: print out the collected items, showing their priority order too. // debugging: print out the collected items, showing their priority order too.
for( int i = 0; i<m_Collector->GetCount(); ++i ) for( int i = 0; i<m_Collector->GetCount(); ++i )
(*m_Collector)[i]->Show( 0, std::cout ); (*m_Collector)[i]->Show( 0, std::cout );
#endif #endif
/* Remove redundancies: most of time, zones are found twice, /* Remove redundancies: most of time, zones are found twice,
@ -243,22 +249,21 @@ BOARD_ITEM* WinEDA_BasePcbFrame::PcbGeneralLocateAndDisplay( int aHotKeyCode )
item = (*m_Collector)[0]; item = (*m_Collector)[0];
SetCurItem( item ); SetCurItem( item );
} }
// If the count is 2, and first item is a pad or moduletext, and the 2nd item is its parent module: // If the count is 2, and first item is a pad or moduletext, and the 2nd item is its parent module:
else if( m_Collector->GetCount() == 2 else if( m_Collector->GetCount() == 2
&& ( (*m_Collector)[0]->Type() == TYPEPAD || (*m_Collector)[0]->Type() == TYPETEXTEMODULE ) && ( (*m_Collector)[0]->Type() == TYPEPAD || (*m_Collector)[0]->Type() ==
&& (*m_Collector)[1]->Type() == TYPEMODULE && (*m_Collector)[0]->GetParent()== (*m_Collector)[1] ) TYPETEXTEMODULE )
&& (*m_Collector)[1]->Type() == TYPEMODULE && (*m_Collector)[0]->GetParent()==
(*m_Collector)[1] )
{ {
item = (*m_Collector)[0]; item = (*m_Collector)[0];
SetCurItem( item ); SetCurItem( item );
} }
// if all are modules, find the smallest one amoung the primary choices // if all are modules, find the smallest one amoung the primary choices
else if( ( item = AllAreModulesAndReturnSmallestIfSo( m_Collector ) ) != NULL ) else if( ( item = AllAreModulesAndReturnSmallestIfSo( m_Collector ) ) != NULL )
{ {
SetCurItem( item ); SetCurItem( item );
} }
else // we can't figure out which item user wants, do popup menu so user can choose else // we can't figure out which item user wants, do popup menu so user can choose
{ {
wxMenu itemMenu; wxMenu itemMenu;
@ -281,11 +286,11 @@ BOARD_ITEM* WinEDA_BasePcbFrame::PcbGeneralLocateAndDisplay( int aHotKeyCode )
} }
/* @todo: rather than assignment to TRUE, these should be increment and decrement operators throughout _everywhere_. /* @todo: rather than assignment to TRUE, these should be increment and decrement operators throughout _everywhere_.
That way we can handle nesting. * That way we can handle nesting.
But I tried that and found there cases where the assignment to TRUE (converted to a m_IgnoreMouseEvents++ ) * But I tried that and found there cases where the assignment to TRUE (converted to a m_IgnoreMouseEvents++ )
was not balanced with the -- (now m_IgnoreMouseEvents=FALSE), so I had to revert. * was not balanced with the -- (now m_IgnoreMouseEvents=FALSE), so I had to revert.
Somebody should track down these and make them balanced. * Somebody should track down these and make them balanced.
DrawPanel->m_IgnoreMouseEvents = TRUE; * DrawPanel->m_IgnoreMouseEvents = TRUE;
*/ */
// this menu's handler is void WinEDA_BasePcbFrame::ProcessItemSelection() // this menu's handler is void WinEDA_BasePcbFrame::ProcessItemSelection()

153
pcbnew/drc.cpp
View File

@ -53,7 +53,7 @@ static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC,
/*******************************************/ /*******************************************/
/* Frame d'option et execution DRC general */ /* function relatives to the DRC control */
/*******************************************/ /*******************************************/
#include "dialog_drc.cpp" #include "dialog_drc.cpp"
@ -206,10 +206,7 @@ void WinEDA_DrcFrame::DelDRCMarkers( wxCommandEvent& event )
void WinEDA_PcbFrame::Install_Test_DRC_Frame( wxDC* DC ) void WinEDA_PcbFrame::Install_Test_DRC_Frame( wxDC* DC )
/******************************************************/ /******************************************************/
/* Test des isolements : teste les isolements des pistes et place un /* install a dialog box to handle the general DRC control
* marqueur sur les divers segments en defaut
* Principe:
* Appelle la routine drc() pour chaque segment de piste existant
*/ */
{ {
AbortDrc = FALSE; AbortDrc = FALSE;
@ -223,10 +220,9 @@ void WinEDA_PcbFrame::Install_Test_DRC_Frame( wxDC* DC )
int WinEDA_PcbFrame::Test_DRC( wxDC* DC, bool TestPad2Pad, bool TestZone ) int WinEDA_PcbFrame::Test_DRC( wxDC* DC, bool TestPad2Pad, bool TestZone )
/************************************************************************/ /************************************************************************/
/* Test des isolements : teste les isolements des pistes et place un /* Test DRC :
* marqueur sur les divers segments en defaut * Run a drc control for each pad and track segment
* Principe: * Put a marker on pad or track end which have a drc problem
* Appelle la routine drc() pour chaque segment de piste existant
*/ */
{ {
int ii, jj, old_net; int ii, jj, old_net;
@ -253,10 +249,10 @@ int WinEDA_PcbFrame::Test_DRC( wxDC* DC, bool TestPad2Pad, bool TestZone )
m_CurrentScreen->SetRefreshReq(); m_CurrentScreen->SetRefreshReq();
/* Effacement des anciens marqueurs */ /* Delete previous markers */
Erase_Marqueurs(); Erase_Marqueurs();
if( TestPad2Pad ) /* Test DRC des pads entre eux */ if( TestPad2Pad ) /* First test: Test DRC between pads (no track)*/
{ {
Line.Printf( wxT( "%d" ), m_Pcb->m_NbPads ); Line.Printf( wxT( "%d" ), m_Pcb->m_NbPads );
Affiche_1_Parametre( this, PRINT_NB_PAD_POS, wxT( "NbPad" ), Line, RED ); Affiche_1_Parametre( this, PRINT_NB_PAD_POS, wxT( "NbPad" ), Line, RED );
@ -373,7 +369,7 @@ int WinEDA_PcbFrame::Test_DRC( wxDC* DC, bool TestPad2Pad, bool TestZone )
} }
} }
/* Test zone segments segments */ /* Test zone segments */
if( TestZone ) if( TestZone )
{ {
m_Pcb->m_NbSegmZone = 0; m_Pcb->m_NbSegmZone = 0;
@ -494,15 +490,12 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
TRACK* pt_segment, TRACK* StartBuffer, int show_err ) TRACK* pt_segment, TRACK* StartBuffer, int show_err )
/***********************************************************************/ /***********************************************************************/
/* /**
* Teste le segment en cours de trace: * Test the current segment:
* pt_segment = pointeur sur segment a controler * @param pt_segment = current segment to test
* StartBuffer = adresse de la zone des pistes a controler * @param StartBuffer = track buffer to test (usually m_Pcb->m_Track)
* (typiquement m_Pcb->m_Track) * @param show_err (flag) si 0 pas d'affichage d'erreur sur ecran
* show_err (flag) si 0 pas d'affichage d'erreur sur ecran * @return : BAD_DRC (1) if DRC error or OK_DRC (0) if OK
* retourne :
* BAD_DRC (1) si Violation DRC
* OK_DRC (0) si OK
*/ */
{ {
int ii; int ii;
@ -526,31 +519,34 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
net_code_ref = pt_segment->m_NetCode; net_code_ref = pt_segment->m_NetCode;
segm_angle = 0; segm_angle = 0;
/* for a non horizontal or vertical segment Compute the segment angle
in 0,1 degrees and its lenght */
if( dx || dy ) if( dx || dy )
{ {
/* calcul de l'angle d'inclinaison en 0,1 degre */ /* Compute the segment angle in 0,1 degrees */
segm_angle = ArcTangente( dy, dx ); segm_angle = ArcTangente( dy, dx );
/* Calcul de la longueur du segment en segm_long : dx = longueur */ /* Compute the segment lenght: we build an equivalent rotated segment,
RotatePoint( &dx, &dy, segm_angle ); /* segm_long = longueur, yf = 0 */ this segment is horizontal, therefore dx = lenght */
RotatePoint( &dx, &dy, segm_angle ); /* dx = lenght, dy = 0 */
} }
/* Ici le segment a ete tourne de segm_angle, et est horizontal, dx > 0 */
segm_long = dx; segm_long = dx;
/******************************************/ /******************************************/
/* Phase 1 : test DRC track to pads :*/ /* Phase 1 : test DRC track to pads :*/
/******************************************/ /******************************************/
/* calcul de la distance min aux pads : */ /* Compute the min distance to pads : */
w_dist = (unsigned) (pt_segment->m_Width >> 1 ); w_dist = (unsigned) (pt_segment->m_Width >> 1 );
for( ii = 0; ii < frame->m_Pcb->m_NbPads; ii++ ) for( ii = 0; ii < frame->m_Pcb->m_NbPads; ii++ )
{ {
D_PAD* pt_pad = frame->m_Pcb->m_Pads[ii]; D_PAD* pt_pad = frame->m_Pcb->m_Pads[ii];
/* Pas de probleme si les pads sont en surface autre que la couche, /* No problem if pads are on an other layer,
* sauf si le trou de percage gene (cas des pastilles perc<EFBFBD>s simple * But if a drill hole exists (a pad on a single layer can have a hole!)
* face sur CI double face */ * we must test the hole
*/
if( (pt_pad->m_Masque_Layer & MaskLayer ) == 0 ) if( (pt_pad->m_Masque_Layer & MaskLayer ) == 0 )
{ {
/* We must test the pad hole. In order to use the function "TestClearanceSegmToPad", /* We must test the pad hole. In order to use the function "TestClearanceSegmToPad",
@ -579,9 +575,10 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
continue; continue;
} }
/* Le pad doit faire partie d'un net mais pas de probleme /* The pad must be in a net (i.e pt_pad->m_NetCode != 0 )
* si le pad est du meme net */ * but no problem if the pad netcode is the current netcode (same net) */
if( /*pt_pad->m_NetCode &&*/ net_code_ref == pt_pad->m_NetCode ) if( pt_pad->m_NetCode && // the pad must be connected
net_code_ref == pt_pad->m_NetCode ) // the pad net is the same as current net -> Ok
continue; continue;
/* Test DRC pour les pads */ /* Test DRC pour les pads */
@ -591,7 +588,7 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
if( TestClearanceSegmToPad( pt_pad, w_dist, g_DesignSettings.m_TrackClearence ) == OK_DRC ) if( TestClearanceSegmToPad( pt_pad, w_dist, g_DesignSettings.m_TrackClearence ) == OK_DRC )
continue; continue;
/* extremite sur pad ou defaut d'isolation trouve */ /* Drc error found! */
else else
{ {
ErrorsDRC_Count++; ErrorsDRC_Count++;
@ -603,20 +600,20 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
} }
/**********************************************/ /**********************************************/
/* Phase 2 : test DRC avec les autres pistes :*/ /* Phase 2: test DRC with other track segments */
/**********************************************/ /**********************************************/
/* Ici le segment de reference est sur l'axe X */ /* At this point the reference segment is the X axis */
/* Comparaison du segment de reference aux autres segments de piste */ /* Test the reference segment with other track segments */
pttrack = StartBuffer; pttrack = StartBuffer;
for( ; pttrack != NULL; pttrack = (TRACK*) pttrack->Pnext ) for( ; pttrack != NULL; pttrack = (TRACK*) pttrack->Pnext )
{ {
//pas de probleme si le segment a tester est du meme net: //No problem if segments have the meme net code:
if( net_code_ref == pttrack->m_NetCode ) if( net_code_ref == pttrack->m_NetCode )
continue; continue;
//pas de probleme si le segment a tester est sur une autre couche : // No problem if segment are on different layers :
if( ( MaskLayer & pttrack->ReturnMaskLayer() ) == 0 ) if( ( MaskLayer & pttrack->ReturnMaskLayer() ) == 0 )
continue; continue;
@ -626,7 +623,7 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
w_dist += pttrack->m_Width >> 1; w_dist += pttrack->m_Width >> 1;
w_dist += g_DesignSettings.m_TrackClearence; w_dist += g_DesignSettings.m_TrackClearence;
/* si le segment de reference est une via, le traitement est ici */ /* If the reference segment is a via, we test it here */
if( pt_segment->Type() == TYPEVIA ) if( pt_segment->Type() == TYPEVIA )
{ {
int orgx, orgy; // origine du repere d'axe X = segment a comparer int orgx, orgy; // origine du repere d'axe X = segment a comparer
@ -650,12 +647,12 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
return BAD_DRC; return BAD_DRC;
} }
} }
else /* Tst distance de via a segment */ else /* Tst drc via / segment */
{ {
/* calcul de l'angle */ /* Compute l'angle */
angle = ArcTangente( dy, dx ); angle = ArcTangente( dy, dx );
/* Calcul des coord dans le nouveau repere */ /* Compute new coordinates ( the segment become horizontal) */
RotatePoint( &dx, &dy, angle ); RotatePoint( &dx, &dy, angle );
RotatePoint( &x0, &y0, angle ); RotatePoint( &x0, &y0, angle );
@ -675,8 +672,10 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
continue; continue;
} }
/* calcule x0,y0, xf,yf = coord de debut et fin du segment de piste /* We compute x0,y0, xf,yf = starting and ending point coordinates for the segment to test
* a tester, dans le repere axe X = segment de reference */ * in the new axis : the new X axis is the reference segment
* We must translate and rotate the segment to test
*/
x0 = pttrack->m_Start.x - org_X; x0 = pttrack->m_Start.x - org_X;
y0 = pttrack->m_Start.y - org_Y; y0 = pttrack->m_Start.y - org_Y;
@ -697,20 +696,20 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
} }
/* /* We have changed axis:
* le segment de reference est Horizontal, par suite des modifs d'axe. * the reference segment is Horizontal.
* 3 cas : segment a comparer parallele, perp ou incline * 3 cases : the segment to test can be parallel, perpendicular or have an other direction
*/ */
if( y0 == yf ) // segments paralleles if( y0 == yf ) // parallel segments
{ {
if( abs( y0 ) >= w_dist ) if( abs( y0 ) >= w_dist )
continue; continue;
if( x0 > xf ) if( x0 > xf )
EXCHG( x0, xf ); /* pour que x0 <= xf */ EXCHG( x0, xf ); /* pour que x0 <= xf */
if( x0 > (-w_dist) && x0 < (segm_long + w_dist) ) /* Risque de defaut */ if( x0 > (-w_dist) && x0 < (segm_long + w_dist) ) /* possible error drc */
{ {
/* test fin tenant compte des formes arrondies des extremites */ /* Fine test : we consider the rounded shape of the ends */
if( x0 >= 0 && x0 <= segm_long ) if( x0 >= 0 && x0 <= segm_long )
{ {
ErrorsDRC_Count++; ErrorsDRC_Count++;
@ -738,7 +737,7 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
} }
if( xf > (-w_dist) && xf < (segm_long + w_dist) ) if( xf > (-w_dist) && xf < (segm_long + w_dist) )
{ {
/* test fin tenant compte des formes arrondies des extremites */ /* Fine test : we consider the rounded shape of the ends */
if( xf >= 0 && xf <= segm_long ) if( xf >= 0 && xf <= segm_long )
{ {
ErrorsDRC_Count++; ErrorsDRC_Count++;
@ -773,12 +772,12 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
return BAD_DRC; return BAD_DRC;
} }
} }
else if( x0 == xf ) // segments perpendiculaires else if( x0 == xf ) // perpendicular segments
{ {
if( ( x0 <= (-w_dist) ) || ( x0 >= (segm_long + w_dist) ) ) if( ( x0 <= (-w_dist) ) || ( x0 >= (segm_long + w_dist) ) )
continue; continue;
/* test si les segments se croisent */ /* Test is segments are crossing */
if( y0 > yf ) if( y0 > yf )
EXCHG( y0, yf ); EXCHG( y0, yf );
if( (y0 < 0) && (yf > 0) ) if( (y0 < 0) && (yf > 0) )
@ -789,8 +788,7 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
return BAD_DRC; return BAD_DRC;
} }
/* ici l'erreur est due a une extremite pres d'une extremite du segm /* At this point the drc error is due to an end near a reference segm end */
* de reference */
if( TestMarginToCircle( x0, y0, w_dist, segm_long ) == BAD_DRC ) if( TestMarginToCircle( x0, y0, w_dist, segm_long ) == BAD_DRC )
{ {
ErrorsDRC_Count++; ErrorsDRC_Count++;
@ -810,17 +808,17 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
{ {
int bflag = OK_DRC; int bflag = OK_DRC;
/* calcul de la "surface de securite du segment de reference */ /* calcul de la "surface de securite du segment de reference */
/* premiere passe : la piste est assimilee a un rectangle */ /* First rought 'and fast) test : the track segment is like a rectangle */
xcliplo = ycliplo = -w_dist; xcliplo = ycliplo = -w_dist;
xcliphi = segm_long + w_dist; ycliphi = w_dist; xcliphi = segm_long + w_dist; ycliphi = w_dist;
bflag = Tst_Ligne( x0, y0, xf, yf ); bflag = Tst_Ligne( x0, y0, xf, yf );
if( bflag == BAD_DRC ) if( bflag == BAD_DRC ) /* A fine test is needed because a serment is not exactly a rectangle
it has rounded ends */
{ {
/* 2eme passe : la piste a des extremites arrondies. /* 2eme passe : the track has rounded ends.
* Si le defaut de drc est du a une extremite : le calcul * we must a fine test for each rounded end and the rectangular zone */
* est affine pour tenir compte de cet arrondi */
xcliplo = 0; xcliphi = segm_long; xcliplo = 0; xcliphi = segm_long;
bflag = Tst_Ligne( x0, y0, xf, yf ); bflag = Tst_Ligne( x0, y0, xf, yf );
@ -837,9 +835,9 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
9 ); 9 );
return BAD_DRC; return BAD_DRC;
} }
else // L'erreur est due a une extremite du segment de reference: else // The drc error is due to the starting or the ending point of the reference segment
{ {
// il faut tester les extremites de ce segment // Test the starting and the ending point
int angle, rx0, ry0, rxf, ryf; int angle, rx0, ry0, rxf, ryf;
x0 = pttrack->m_Start.x; x0 = pttrack->m_Start.x;
y0 = pttrack->m_Start.y; y0 = pttrack->m_Start.y;
@ -850,14 +848,14 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
dx = xf - x0; dx = xf - x0;
dy = yf - y0; dy = yf - y0;
/* calcul de l'angle d'inclinaison en 0,1 degre */ /* Compute the segment orientation (angle) en 0,1 degre */
angle = ArcTangente( dy, dx ); angle = ArcTangente( dy, dx );
/* Calcul de la longueur du segment: dx = longueur */ /* Compute the segment lenght: dx = longueur */
RotatePoint( &dx, &dy, angle ); RotatePoint( &dx, &dy, angle );
/* calcul des coord du segment de reference ds le repere /* Comute the reference segment coordinates relatives to a
* d'axe X = segment courant en tst */ * X axis = current tested segment */
rx0 = pt_segment->m_Start.x - x0; rx0 = pt_segment->m_Start.x - x0;
ry0 = pt_segment->m_Start.y - y0; ry0 = pt_segment->m_Start.y - y0;
rxf = pt_segment->m_End.x - x0; rxf = pt_segment->m_End.x - x0;
@ -908,9 +906,14 @@ static bool Test_Pad_to_Pads_Drc( WinEDA_BasePcbFrame* frame,
bool show_err ) bool show_err )
/*****************************************************************************/ /*****************************************************************************/
/* Teste l'isolation de pad_ref avec les autres pads. /** Test the drc between pad_ref and other pads.
* end_buffer = upper limit of the pad list. * the pad list must be sorted by x coordinate
* max_size = size of the biggest pad (used to stop the test when the X distance is > max_size) * @param frame = current active frame
* @param DC = current DC
* @param pad_ref = pad to test
* @param end_buffer = upper limit of the pad list.
* @param max_size = size of the biggest pad (used to stop the test when the X distance is > max_size)
* @param show_err if true, display a marker and amessage.
*/ */
{ {
int MaskLayer; int MaskLayer;
@ -931,24 +934,24 @@ static bool Test_Pad_to_Pads_Drc( WinEDA_BasePcbFrame* frame,
if( pad->m_Pos.x > x_limite ) if( pad->m_Pos.x > x_limite )
break; break;
/* Pas de probleme si les pads ne sont pas sur les memes couches cuivre*/ /* No probleme if pads are on different copper layers */
if( (pad->m_Masque_Layer & MaskLayer ) == 0 ) if( (pad->m_Masque_Layer & MaskLayer ) == 0 )
continue; continue;
/* Le pad doit faire partie d'un net, /* The pad must be in a net (i.e pt_pad->m_NetCode != 0 ),
* mais pas de probleme si les pads sont du meme net */ * But noe probleme if pads have the same netcode (same net)*/
if( pad->m_NetCode && (pad_ref->m_NetCode == pad->m_NetCode) ) if( pad->m_NetCode && (pad_ref->m_NetCode == pad->m_NetCode) )
continue; continue;
/* pas de pb si les pads sont du meme module et /* No proble if pads are from the same footprint
* de la meme reference ( pads multiples ) */ * and have the same pad number ( equivalent pads ) */
if( (pad->m_Parent == pad_ref->m_Parent) && (pad->m_NumPadName == pad_ref->m_NumPadName) ) if( (pad->m_Parent == pad_ref->m_Parent) && (pad->m_NumPadName == pad_ref->m_NumPadName) )
continue; continue;
if( Pad_to_Pad_Isol( pad_ref, pad, g_DesignSettings.m_TrackClearence ) == OK_DRC ) if( Pad_to_Pad_Isol( pad_ref, pad, g_DesignSettings.m_TrackClearence ) == OK_DRC )
continue; continue;
else /* defaut d'isolation trouve */ else /* here we have a drc error! */
{ {
ErrorsDRC_Count++; ErrorsDRC_Count++;
if( show_err ) if( show_err )

64
pcbnew/edit.cpp
View File

@ -15,36 +15,78 @@
#include "eda_dde.h" #include "eda_dde.h"
static void Process_Move_Item( WinEDA_PcbFrame* frame, static void Process_Move_Item( WinEDA_PcbFrame* frame,
EDA_BaseStruct* DrawStruct, wxDC* DC ); EDA_BaseStruct* DrawStruct, wxDC* DC );
// see wxstruct.h // see wxstruct.h
/**************************************************************************/
void WinEDA_PcbFrame::SendMessageToEESCHEMA( BOARD_ITEM* objectToSync ) void WinEDA_PcbFrame::SendMessageToEESCHEMA( BOARD_ITEM* objectToSync )
/**************************************************************************/
/** Send a remote command to eeschema via a socket,
* @param objectToSync = item to be located on schematic (module, pin or text)
* Commands are
* $PART: "reference" put cursor on component anchor
* $PART: "reference" $PAD: "pad number" put cursor on the component pin
* $PART: "reference" $REF: "reference" put cursor on the component ref
* $PART: "reference" $VAL: "value" put cursor on the component value
*/
{ {
char cmd[1024]; char cmd[1024];
const char* text_key;
MODULE* module = NULL; MODULE* module = NULL;
D_PAD* pad;
TEXTE_MODULE* text_mod;
wxString msg;
if( objectToSync == NULL ) if( objectToSync == NULL )
return; return;
if( objectToSync->Type() == TYPEMODULE ) switch( objectToSync->Type() )
{
case TYPEMODULE:
module = (MODULE*) objectToSync; module = (MODULE*) objectToSync;
else if( objectToSync->Type() == TYPEPAD ) sprintf( cmd, "$PART: \"%s\"",
module = (MODULE*) objectToSync->GetParent(); CONV_TO_UTF8( module->m_Reference->m_Text ) );
else if( objectToSync->Type() == TYPETEXTEMODULE ) break;
module = (MODULE*) objectToSync->GetParent();
case TYPEPAD:
module = (MODULE*) objectToSync->m_Parent;
pad = (D_PAD*) objectToSync;
msg = pad->ReturnStringPadName();
sprintf( cmd, "$PART: \"%s\" $PAD: \"%s\"",
CONV_TO_UTF8( module->m_Reference->m_Text ),
CONV_TO_UTF8( msg ) );
break;
case TYPETEXTEMODULE:
#define REFERENCE 0
#define VALUE 1
module = (MODULE*) objectToSync->m_Parent;
text_mod = (TEXTE_MODULE*) objectToSync;
if( text_mod->m_Type == REFERENCE )
text_key = "$REF:";
else if( text_mod->m_Type == VALUE )
text_key = "$VAL:";
else
break;
sprintf( cmd, "$PART: \"%s\" %s \"%s\"",
CONV_TO_UTF8( module->m_Reference->m_Text ),
text_key,
CONV_TO_UTF8( text_mod->m_Text ) );
break;
default:
break;
}
// ask only for the reference for now, maybe pins later.
if( module ) if( module )
{ {
sprintf( cmd, "$PART: %s", CONV_TO_UTF8(module->m_Reference->m_Text) );
SendCommand( MSG_TO_SCH, cmd ); SendCommand( MSG_TO_SCH, cmd );
} }
} }
/*********************************************************************/ /*********************************************************************/
void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event ) void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
/*********************************************************************/ /*********************************************************************/
@ -262,6 +304,7 @@ void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
break; break;
case ID_GET_TOOLS: case ID_GET_TOOLS:
// InstalloolsFrame(this, wxPoint(-1,-1) ); // InstalloolsFrame(this, wxPoint(-1,-1) );
break; break;
@ -336,6 +379,7 @@ void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
case ID_POPUP_END_LINE: case ID_POPUP_END_LINE:
DrawPanel->MouseToCursorSchema(); DrawPanel->MouseToCursorSchema();
// EndSegment(&dc); // EndSegment(&dc);
break; break;
@ -564,6 +608,7 @@ void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
break; break;
case ID_POPUP_PCB_EDIT_MODULE: case ID_POPUP_PCB_EDIT_MODULE:
// If the current Item is a pad, text module ...: Get the parent // If the current Item is a pad, text module ...: Get the parent
if( GetCurItem()->Type() != TYPEMODULE ) if( GetCurItem()->Type() != TYPEMODULE )
SetCurItem( GetCurItem()->GetParent() ); SetCurItem( GetCurItem()->GetParent() );
@ -931,6 +976,7 @@ static void Process_Move_Item( WinEDA_PcbFrame* frame,
} }
} }
/***************************************************************/ /***************************************************************/
void WinEDA_PcbFrame::RemoveStruct( EDA_BaseStruct* Item, wxDC* DC ) void WinEDA_PcbFrame::RemoveStruct( EDA_BaseStruct* Item, wxDC* DC )
/***************************************************************/ /***************************************************************/

27
share/drawframe.cpp
View File

@ -56,7 +56,7 @@ WinEDA_DrawFrame::WinEDA_DrawFrame( wxWindow* father, int idtype,
DrawPanel = NULL; DrawPanel = NULL;
MsgPanel = NULL; MsgPanel = NULL;
m_CurrentScreen = NULL; m_CurrentScreen = NULL;
m_MenuBar = NULL; // menu du haut d'ecran m_MenuBar = NULL; // main meun frame
m_ID_current_state = 0; m_ID_current_state = 0;
m_HTOOL_current_state = 0; m_HTOOL_current_state = 0;
m_Draw_Axis = FALSE; // TRUE pour avoir les axes dessines m_Draw_Axis = FALSE; // TRUE pour avoir les axes dessines
@ -66,8 +66,8 @@ WinEDA_DrawFrame::WinEDA_DrawFrame( wxWindow* father, int idtype,
m_Draw_Auxiliary_Axis = FALSE; // TRUE pour avoir les axes auxiliares dessines m_Draw_Auxiliary_Axis = FALSE; // TRUE pour avoir les axes auxiliares dessines
m_UnitType = INTERNAL_UNIT_TYPE; // Internal unit = inch m_UnitType = INTERNAL_UNIT_TYPE; // Internal unit = inch
// nombre d'unites internes pour 1 pouce // Internal units per inch
// = 1000 pour schema, = 10000 pour PCB // = 1000 for schema, = 10000 for PCB
m_InternalUnits = EESCHEMA_INTERNAL_UNIT; m_InternalUnits = EESCHEMA_INTERNAL_UNIT;
if( (m_Ident == PCB_FRAME) || (m_Ident == GERBER_FRAME) if( (m_Ident == PCB_FRAME) || (m_Ident == GERBER_FRAME)
|| (m_Ident == CVPCB_DISPLAY_FRAME) || (m_Ident == CVPCB_DISPLAY_FRAME)
@ -111,7 +111,7 @@ WinEDA_DrawFrame::WinEDA_DrawFrame( wxWindow* father, int idtype,
WinEDA_DrawFrame::~WinEDA_DrawFrame() WinEDA_DrawFrame::~WinEDA_DrawFrame()
/****************************************/ /****************************************/
{ {
if( DrawPanel ) // for WinEDA3D_DrawFrame DrawPanel == NULL ! if( DrawPanel ) // Required: in WinEDA3D_DrawFrame, DrawPanel == NULL !
m_Parent->m_EDA_Config->Write( wxT( "AutoPAN" ), DrawPanel->m_AutoPAN_Enable ); m_Parent->m_EDA_Config->Write( wxT( "AutoPAN" ), DrawPanel->m_AutoPAN_Enable );
} }
@ -177,7 +177,7 @@ void WinEDA_DrawFrame::Affiche_Message( const wxString& message )
/**************************************************************/ /**************************************************************/
/* /*
* Affiche un message en bas de l'ecran * Dispaly the meesage on yhe bottomon the frame
*/ */
{ {
SetStatusText( message ); SetStatusText( message );
@ -216,40 +216,45 @@ void WinEDA_DrawFrame::OnMenuOpen( wxMenuEvent& event )
/*******************************************************/ /*******************************************************/
void WinEDA_DrawFrame::ReCreateAuxiliaryToolbar() // fonction virtuelle void WinEDA_DrawFrame::ReCreateAuxiliaryToolbar()
/*******************************************************/ /*******************************************************/
// Virtual function
{ {
} }
/********************************************/ /********************************************/
void WinEDA_DrawFrame::ReCreateMenuBar() // fonction virtuelle void WinEDA_DrawFrame::ReCreateMenuBar()
/********************************************/ /********************************************/
// Virtual function
{ {
} }
/****************************************************/ /****************************************************/
void WinEDA_DrawFrame::OnHotKey( wxDC* DC, int hotkey, void WinEDA_DrawFrame::OnHotKey( wxDC* DC, int hotkey,
EDA_BaseStruct* DrawStruct ) // fonction virtuelle EDA_BaseStruct* DrawStruct )
/****************************************************/ /****************************************************/
// Virtual function
{ {
} }
/**************************************************************/ /**************************************************************/
void WinEDA_DrawFrame::ToolOnRightClick( wxCommandEvent& event ) // fonction virtuelle void WinEDA_DrawFrame::ToolOnRightClick( wxCommandEvent& event )
/**************************************************************/ /**************************************************************/
// Virtual function
{ {
} }
/********************************************************/ /********************************************************/
void WinEDA_DrawFrame::OnSelectGrid( wxCommandEvent& event ) // fonction virtuelle void WinEDA_DrawFrame::OnSelectGrid( wxCommandEvent& event )
/********************************************************/ /********************************************************/
// Virtual function
{ {
if( m_SelGridBox == NULL ) if( m_SelGridBox == NULL )
return; //Ne devrait pas se produire! return; // Should not occurs
int id = m_SelGridBox->GetChoice(); int id = m_SelGridBox->GetChoice();
if( id < 0 ) if( id < 0 )