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
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>
================================================================================
@ -22,6 +35,7 @@ email address.
* beautification, house keeping.
2007-Sep-29 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================
+ pcbnew

6
common/edaappl.cpp
View File

@ -62,9 +62,9 @@ WinEDA_App::WinEDA_App()
m_MainFrame = NULL;
m_PcbFrame = NULL;
m_ModuleEditFrame = NULL; // Edition des modules
SchematicFrame = NULL; // Edition des Schemas
LibeditFrame = NULL; // Edition des composants
ViewlibFrame = NULL; // Visualisation des composants
m_SchematicFrame = NULL; // Edition des Schemas
m_LibeditFrame = NULL; // Edition des composants
m_ViewlibFrame = NULL; // Visualisation des composants
m_CvpcbFrame = NULL;
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 );
px.x -= dx;
EDA_Appl->SchematicFrame->PutOnGrid( &px );
EDA_Appl->m_SchematicFrame->PutOnGrid( &px );
DrawText->m_Pos.x = px.x;
break;
@ -696,14 +696,14 @@ void MirrorOneStruct( EDA_BaseStruct* DrawStruct, wxPoint& Center )
px = DrawText->m_Pos;
MirrorYPoint( px, Center );
EDA_Appl->SchematicFrame->PutOnGrid( &px );
EDA_Appl->m_SchematicFrame->PutOnGrid( &px );
DrawText->m_Pos.x = px.x;
break;
case DRAW_LIB_ITEM_STRUCT_TYPE:
DrawLibItem = (EDA_SchComponentStruct*) DrawStruct;
dx = DrawLibItem->m_Pos.x;
EDA_Appl->SchematicFrame->CmpRotationMiroir( DrawLibItem,
EDA_Appl->m_SchematicFrame->CmpRotationMiroir( DrawLibItem,
NULL, CMP_MIROIR_Y );
MirrorYPoint( DrawLibItem->m_Pos, Center );
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;
}

59
eeschema/controle.cpp
View File

@ -22,33 +22,71 @@
/* variables externes */
/**********************************/
/***************************************************************/
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.
* 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* idcmd;
char* text;
WinEDA_SchematicFrame* frame = EDA_Appl->m_SchematicFrame;
wxString part_ref, msg;
strncpy( line, cmdline, sizeof(line) - 1 );
idcmd = strtok( line, " \n\r" );
text = strtok( NULL, " \n\r" );
text = strtok( NULL, "\"\n\r" );
if( (idcmd == NULL) || (text == NULL) )
return;
if( strcmp( idcmd, "$PART:" ) == 0 )
{
WinEDA_SchematicFrame* frame = EDA_Appl->SchematicFrame;
if( strcmp( idcmd, "$PART:" ) != 0 )
return;
wxString msg = CONV_FROM_UTF8( text );
frame->FindSchematicItem( msg, 1, false );
part_ref = CONV_FROM_UTF8( text );
/* 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 */
}

2
eeschema/delsheet.cpp
View File

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

4
eeschema/dialog_eeschema_config.cpp
View File

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

8
eeschema/eeconfig.cpp
View File

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

22
eeschema/eeschema.cpp
View File

@ -66,41 +66,41 @@ bool WinEDA_App::OnInit()
/* init EESCHEMA */
GetSettings(); // read current setup
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
* or tool tips */
// Create main frame (schematic frame) :
SchematicFrame = new WinEDA_SchematicFrame( NULL, this,
m_SchematicFrame = new WinEDA_SchematicFrame( NULL, this,
wxT( "EESchema" ),
wxPoint( 0, 0 ), wxSize( 600, 400 ) );
SetTopWindow( SchematicFrame );
SchematicFrame->Show( TRUE );
SetTopWindow( m_SchematicFrame );
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
// sends EESCHEMA a command
SetupServerFunction( RemoteCommand );
}
SchematicFrame->Zoom_Automatique( TRUE );
m_SchematicFrame->Zoom_Automatique( TRUE );
/* Load file specified in the command line. */
if( !FFileName.IsEmpty() )
{
ChangeFileNameExt( FFileName, g_SchExtBuffer );
wxSetWorkingDirectory( wxPathOnly( FFileName ) );
if( SchematicFrame->DrawPanel )
if( SchematicFrame->LoadOneEEProject( FFileName, FALSE ) <= 0 )
SchematicFrame->DrawPanel->Refresh( TRUE ); // File not found or error
if( m_SchematicFrame->DrawPanel )
if( m_SchematicFrame->LoadOneEEProject( FFileName, FALSE ) <= 0 )
m_SchematicFrame->DrawPanel->Refresh( TRUE ); // File not found or error
}
else
{
Read_Config( wxEmptyString, TRUE ); // Read config file ici si pas de fichier a charger
if( SchematicFrame->DrawPanel )
SchematicFrame->DrawPanel->Refresh( TRUE );
if( m_SchematicFrame->DrawPanel )
m_SchematicFrame->DrawPanel->Refresh( 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 )
/*****************************************************************/
@ -71,9 +278,9 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindMarker( int SearchType )
int StartCount;
bool NotFound;
wxPoint firstpos, pos;
wxSize size = DrawPanel->GetClientSize();
wxSize DrawAreaSize = DrawPanel->GetClientSize();
wxPoint curpos, old_cursor_position;
bool force_recadre = FALSE;
bool DoCenterAndRedraw = FALSE;
wxString msg, WildText;
g_LastSearchIsMarker = TRUE;
@ -131,7 +338,7 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindMarker( int SearchType )
{
Screen->SetZoom( GetScreen()->GetZoom() );
m_CurrentScreen = ActiveScreen = Screen;
force_recadre = TRUE;
DoCenterAndRedraw = TRUE;
}
old_cursor_position = Screen->m_Curseur;
@ -145,11 +352,16 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindMarker( int SearchType )
curpos.y -= m_CurrentScreen->m_StartVisu.y;
// reposition the window if the chosen marker is off screen.
if( (curpos.x <= 0) || (curpos.x >= size.x - 1)
|| (curpos.y <= 0) || (curpos.y >= size.y) || force_recadre )
#define MARGIN 30
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
{
wxClientDC dc( DrawPanel );
@ -218,9 +430,9 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindSchematicItem(
bool NotFound;
wxPoint firstpos, pos, old_cursor_position;
static int Find_in_hierarchy;
wxSize size = DrawPanel->GetClientSize();
wxSize DrawAreaSize = DrawPanel->GetClientSize();
wxPoint curpos;
bool force_recadre = FALSE;
bool DoCenterAndRedraw = FALSE;
wxString msg, WildText;
g_LastSearchIsMarker = FALSE;
@ -337,10 +549,10 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindSchematicItem(
{
Screen->SetZoom( GetScreen()->GetZoom() );
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
*/
if( Struct->Type() == DRAW_LIB_ITEM_STRUCT_TYPE )
@ -371,11 +583,15 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindSchematicItem(
curpos.y -= m_CurrentScreen->m_StartVisu.y;
/* Il y a peut-etre necessite de recadrer le dessin: */
if( (curpos.x <= 0) || (curpos.x >= size.x - 1)
|| (curpos.y <= 0) || (curpos.y >= size.y) || force_recadre )
#define MARGIN 30
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
{
wxClientDC dc( DrawPanel );

6
eeschema/getpart.cpp
View File

@ -31,14 +31,14 @@ wxString SelectFromLibBrowser( WinEDA_DrawFrame* parent )
WinEDA_ViewlibFrame* Viewer;
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 */
if( Viewer )
Viewer->Destroy();
Viewer = parent->m_Parent->ViewlibFrame = new
Viewer = parent->m_Parent->m_ViewlibFrame = new
WinEDA_ViewlibFrame(
parent->m_Parent->SchematicFrame,
parent->m_Parent->m_SchematicFrame,
parent->m_Parent,
NULL,
&semaphore );

2
eeschema/libframe.cpp
View File

@ -88,7 +88,7 @@ WinEDA_LibeditFrame::WinEDA_LibeditFrame( wxWindow* father,
WinEDA_LibeditFrame::~WinEDA_LibeditFrame()
/**********************************************/
{
m_Parent->LibeditFrame = NULL;
m_Parent->m_LibeditFrame = NULL;
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;
}
/*******************************************************************/
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,
@ -1047,12 +1098,6 @@ LibEDA_BaseStruct* LocatePin( const wxPoint& RefPos,
* retourne un pointeur sur la pin, ou NULL si pas trouve
* Si Unit = 0, le numero d'unite 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;

2
eeschema/protos.h
View File

@ -118,6 +118,8 @@ bool DrawStructInBox(int x1, int y1, int x2, int y2,
/*************/
/* LOCATE.CPP */
/*************/
LibDrawPin* LocatePinByNumber( const wxString & ePin_Number,
EDA_SchComponentStruct* eComponent );
EDA_SchComponentStruct * LocateSmallestComponent( SCH_SCREEN * Screen );
/* 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;
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
{
m_Parent->LibeditFrame = new
WinEDA_LibeditFrame( m_Parent->SchematicFrame,
m_Parent->m_LibeditFrame = new
WinEDA_LibeditFrame( m_Parent->m_SchematicFrame,
m_Parent,
wxT( "Library Editor" ),
wxPoint( -1, -1 ), wxSize( 600, 400 ) );
ActiveScreen = ScreenLib;
m_Parent->LibeditFrame->AdjustScrollBars();
m_Parent->m_LibeditFrame->AdjustScrollBars();
}
break;
@ -229,15 +229,15 @@ void WinEDA_SchematicFrame::Process_Special_Functions( wxCommandEvent& event )
}
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
{
m_Parent->ViewlibFrame = new
WinEDA_ViewlibFrame( m_Parent->SchematicFrame, m_Parent );
m_Parent->ViewlibFrame->AdjustScrollBars();
m_Parent->m_ViewlibFrame = new
WinEDA_ViewlibFrame( m_Parent->m_SchematicFrame, m_Parent );
m_Parent->m_ViewlibFrame->AdjustScrollBars();
}
break;

6
eeschema/schframe.cpp
View File

@ -154,7 +154,7 @@ WinEDA_SchematicFrame:: WinEDA_SchematicFrame(wxWindow * father, WinEDA_App *par
WinEDA_SchematicFrame::~WinEDA_SchematicFrame()
{
m_Parent->SchematicFrame = NULL;
m_Parent->m_SchematicFrame = NULL;
m_CurrentScreen = ScreenSch;
}
@ -164,9 +164,9 @@ void WinEDA_SchematicFrame::OnCloseWindow(wxCloseEvent & Event)
{
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 ;

2
eeschema/symbdraw.cpp
View File

@ -793,7 +793,7 @@ static void ComputeArc( LibDrawArc* DrawItem, wxPoint ArcCentre )
wxString msg;
angle = DrawItem->t2 - DrawItem->t1;
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 )
{

2
eeschema/viewlib_frame.cpp
View File

@ -109,7 +109,7 @@ WinEDA_ViewlibFrame::WinEDA_ViewlibFrame(wxWindow * father, WinEDA_App *parent,
WinEDA_ViewlibFrame::~WinEDA_ViewlibFrame()
{
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_ModuleEditFrame* m_ModuleEditFrame;
WinEDA_GerberFrame* m_GerberFrame;
WinEDA_SchematicFrame* SchematicFrame; // Edition des Schemas
WinEDA_LibeditFrame* LibeditFrame; // Edition des composants
WinEDA_ViewlibFrame* ViewlibFrame; // Visualisation des composants
WinEDA_SchematicFrame* m_SchematicFrame; // Edition des Schemas
WinEDA_LibeditFrame* m_LibeditFrame; // Edition des composants
WinEDA_ViewlibFrame* m_ViewlibFrame; // Visualisation des composants
WinEDA_CvpcbFrame* m_CvpcbFrame;
wxPoint m_HelpPos;

34
include/wxstruct.h
View File

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

35
pcbnew/controle.cpp
View File

@ -17,23 +17,26 @@
#include "bitmaps.h"
/****************************************/
/*******************************************/
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)
* @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];
wxString msg;
char* idcmd;
char* text;
WinEDA_PcbFrame* frame = EDA_Appl->m_PcbFrame;
MODULE* module = 0;
WinEDA_PcbFrame* frame = EDA_Appl->m_PcbFrame;
strncpy( line, cmdline, sizeof(line) - 1 );
msg = CONV_FROM_UTF8( line );
idcmd = strtok( line, " \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() );
else
msg.Printf( _( "Locate Pin %s (module %s)" ), pinName.GetData(), modName.GetData() );
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 );
#if 0
// debugging: print out the collected items, showing their priority order too.
for( int i = 0; i<m_Collector->GetCount(); ++i )
(*m_Collector)[i]->Show( 0, std::cout );
#endif
/* Remove redundancies: most of time, zones are found twice,
@ -243,22 +249,21 @@ BOARD_ITEM* WinEDA_BasePcbFrame::PcbGeneralLocateAndDisplay( int aHotKeyCode )
item = (*m_Collector)[0];
SetCurItem( item );
}
// 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
&& ( (*m_Collector)[0]->Type() == TYPEPAD || (*m_Collector)[0]->Type() == TYPETEXTEMODULE )
&& (*m_Collector)[1]->Type() == TYPEMODULE && (*m_Collector)[0]->GetParent()== (*m_Collector)[1] )
&& ( (*m_Collector)[0]->Type() == TYPEPAD || (*m_Collector)[0]->Type() ==
TYPETEXTEMODULE )
&& (*m_Collector)[1]->Type() == TYPEMODULE && (*m_Collector)[0]->GetParent()==
(*m_Collector)[1] )
{
item = (*m_Collector)[0];
SetCurItem( item );
}
// if all are modules, find the smallest one amoung the primary choices
else if( ( item = AllAreModulesAndReturnSmallestIfSo( m_Collector ) ) != NULL )
{
SetCurItem( item );
}
else // we can't figure out which item user wants, do popup menu so user can choose
{
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_.
That way we can handle nesting.
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.
Somebody should track down these and make them balanced.
DrawPanel->m_IgnoreMouseEvents = TRUE;
* That way we can handle nesting.
* 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.
* Somebody should track down these and make them balanced.
* DrawPanel->m_IgnoreMouseEvents = TRUE;
*/
// 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"
@ -206,10 +206,7 @@ void WinEDA_DrcFrame::DelDRCMarkers( wxCommandEvent& event )
void WinEDA_PcbFrame::Install_Test_DRC_Frame( wxDC* DC )
/******************************************************/
/* Test des isolements : teste les isolements des pistes et place un
* marqueur sur les divers segments en defaut
* Principe:
* Appelle la routine drc() pour chaque segment de piste existant
/* install a dialog box to handle the general DRC control
*/
{
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 )
/************************************************************************/
/* Test des isolements : teste les isolements des pistes et place un
* marqueur sur les divers segments en defaut
* Principe:
* Appelle la routine drc() pour chaque segment de piste existant
/* Test DRC :
* Run a drc control for each pad and track segment
* Put a marker on pad or track end which have a drc problem
*/
{
int ii, jj, old_net;
@ -253,10 +249,10 @@ int WinEDA_PcbFrame::Test_DRC( wxDC* DC, bool TestPad2Pad, bool TestZone )
m_CurrentScreen->SetRefreshReq();
/* Effacement des anciens marqueurs */
/* Delete previous markers */
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 );
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 )
{
m_Pcb->m_NbSegmZone = 0;
@ -494,15 +490,12 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
TRACK* pt_segment, TRACK* StartBuffer, int show_err )
/***********************************************************************/
/*
* Teste le segment en cours de trace:
* pt_segment = pointeur sur segment a controler
* StartBuffer = adresse de la zone des pistes a controler
* (typiquement m_Pcb->m_Track)
* show_err (flag) si 0 pas d'affichage d'erreur sur ecran
* retourne :
* BAD_DRC (1) si Violation DRC
* OK_DRC (0) si OK
/**
* Test the current segment:
* @param pt_segment = current segment to test
* @param StartBuffer = track buffer to test (usually m_Pcb->m_Track)
* @param 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
*/
{
int ii;
@ -526,31 +519,34 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
net_code_ref = pt_segment->m_NetCode;
segm_angle = 0;
/* for a non horizontal or vertical segment Compute the segment angle
in 0,1 degrees and its lenght */
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 );
/* Calcul de la longueur du segment en segm_long : dx = longueur */
RotatePoint( &dx, &dy, segm_angle ); /* segm_long = longueur, yf = 0 */
/* Compute the segment lenght: we build an equivalent rotated segment,
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;
/******************************************/
/* 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 );
for( ii = 0; ii < frame->m_Pcb->m_NbPads; ii++ )
{
D_PAD* pt_pad = frame->m_Pcb->m_Pads[ii];
/* Pas de probleme si les pads sont en surface autre que la couche,
* sauf si le trou de percage gene (cas des pastilles perc<EFBFBD>s simple
* face sur CI double face */
/* No problem if pads are on an other layer,
* But if a drill hole exists (a pad on a single layer can have a hole!)
* we must test the hole
*/
if( (pt_pad->m_Masque_Layer & MaskLayer ) == 0 )
{
/* 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;
}
/* Le pad doit faire partie d'un net mais pas de probleme
* si le pad est du meme net */
if( /*pt_pad->m_NetCode &&*/ net_code_ref == pt_pad->m_NetCode )
/* The pad must be in a net (i.e pt_pad->m_NetCode != 0 )
* but no problem if the pad netcode is the current netcode (same net) */
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;
/* 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 )
continue;
/* extremite sur pad ou defaut d'isolation trouve */
/* Drc error found! */
else
{
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;
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 )
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 )
continue;
@ -626,7 +623,7 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
w_dist += pttrack->m_Width >> 1;
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 )
{
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;
}
}
else /* Tst distance de via a segment */
else /* Tst drc via / segment */
{
/* calcul de l'angle */
/* Compute l'angle */
angle = ArcTangente( dy, dx );
/* Calcul des coord dans le nouveau repere */
/* Compute new coordinates ( the segment become horizontal) */
RotatePoint( &dx, &dy, angle );
RotatePoint( &x0, &y0, angle );
@ -675,8 +672,10 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
continue;
}
/* calcule x0,y0, xf,yf = coord de debut et fin du segment de piste
* a tester, dans le repere axe X = segment de reference */
/* We compute x0,y0, xf,yf = starting and ending point coordinates for the segment to test
* 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;
y0 = pttrack->m_Start.y - org_Y;
@ -697,20 +696,20 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
}
/*
* le segment de reference est Horizontal, par suite des modifs d'axe.
* 3 cas : segment a comparer parallele, perp ou incline
/* We have changed axis:
* the reference segment is Horizontal.
* 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 )
continue;
if( 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 )
{
ErrorsDRC_Count++;
@ -738,7 +737,7 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
}
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 )
{
ErrorsDRC_Count++;
@ -773,12 +772,12 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
return BAD_DRC;
}
}
else if( x0 == xf ) // segments perpendiculaires
else if( x0 == xf ) // perpendicular segments
{
if( ( x0 <= (-w_dist) ) || ( x0 >= (segm_long + w_dist) ) )
continue;
/* test si les segments se croisent */
/* Test is segments are crossing */
if( y0 > yf )
EXCHG( y0, yf );
if( (y0 < 0) && (yf > 0) )
@ -789,8 +788,7 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
return BAD_DRC;
}
/* ici l'erreur est due a une extremite pres d'une extremite du segm
* de reference */
/* At this point the drc error is due to an end near a reference segm end */
if( TestMarginToCircle( x0, y0, w_dist, segm_long ) == BAD_DRC )
{
ErrorsDRC_Count++;
@ -810,17 +808,17 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
{
int bflag = OK_DRC;
/* 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;
xcliphi = segm_long + w_dist; ycliphi = w_dist;
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.
* Si le defaut de drc est du a une extremite : le calcul
* est affine pour tenir compte de cet arrondi */
/* 2eme passe : the track has rounded ends.
* we must a fine test for each rounded end and the rectangular zone */
xcliplo = 0; xcliphi = segm_long;
bflag = Tst_Ligne( x0, y0, xf, yf );
@ -837,9 +835,9 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
9 );
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;
x0 = pttrack->m_Start.x;
y0 = pttrack->m_Start.y;
@ -850,14 +848,14 @@ int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
dx = xf - x0;
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 );
/* Calcul de la longueur du segment: dx = longueur */
/* Compute the segment lenght: dx = longueur */
RotatePoint( &dx, &dy, angle );
/* calcul des coord du segment de reference ds le repere
* d'axe X = segment courant en tst */
/* Comute the reference segment coordinates relatives to a
* X axis = current tested segment */
rx0 = pt_segment->m_Start.x - x0;
ry0 = pt_segment->m_Start.y - y0;
rxf = pt_segment->m_End.x - x0;
@ -908,9 +906,14 @@ static bool Test_Pad_to_Pads_Drc( WinEDA_BasePcbFrame* frame,
bool show_err )
/*****************************************************************************/
/* Teste l'isolation de pad_ref avec les autres pads.
* end_buffer = upper limit of the pad list.
* max_size = size of the biggest pad (used to stop the test when the X distance is > max_size)
/** Test the drc between pad_ref and other pads.
* the pad list must be sorted by x coordinate
* @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;
@ -931,24 +934,24 @@ static bool Test_Pad_to_Pads_Drc( WinEDA_BasePcbFrame* frame,
if( pad->m_Pos.x > x_limite )
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 )
continue;
/* Le pad doit faire partie d'un net,
* mais pas de probleme si les pads sont du meme net */
/* The pad must be in a net (i.e pt_pad->m_NetCode != 0 ),
* But noe probleme if pads have the same netcode (same net)*/
if( pad->m_NetCode && (pad_ref->m_NetCode == pad->m_NetCode) )
continue;
/* pas de pb si les pads sont du meme module et
* de la meme reference ( pads multiples ) */
/* No proble if pads are from the same footprint
* and have the same pad number ( equivalent pads ) */
if( (pad->m_Parent == pad_ref->m_Parent) && (pad->m_NumPadName == pad_ref->m_NumPadName) )
continue;
if( Pad_to_Pad_Isol( pad_ref, pad, g_DesignSettings.m_TrackClearence ) == OK_DRC )
continue;
else /* defaut d'isolation trouve */
else /* here we have a drc error! */
{
ErrorsDRC_Count++;
if( show_err )

64
pcbnew/edit.cpp
View File

@ -15,36 +15,78 @@
#include "eda_dde.h"
static void Process_Move_Item( WinEDA_PcbFrame* frame,
EDA_BaseStruct* DrawStruct, wxDC* DC );
// see wxstruct.h
/**************************************************************************/
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];
const char* text_key;
MODULE* module = NULL;
D_PAD* pad;
TEXTE_MODULE* text_mod;
wxString msg;
if( objectToSync == NULL )
return;
if( objectToSync->Type() == TYPEMODULE )
switch( objectToSync->Type() )
{
case TYPEMODULE:
module = (MODULE*) objectToSync;
else if( objectToSync->Type() == TYPEPAD )
module = (MODULE*) objectToSync->GetParent();
else if( objectToSync->Type() == TYPETEXTEMODULE )
module = (MODULE*) objectToSync->GetParent();
sprintf( cmd, "$PART: \"%s\"",
CONV_TO_UTF8( module->m_Reference->m_Text ) );
break;
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 )
{
sprintf( cmd, "$PART: %s", CONV_TO_UTF8(module->m_Reference->m_Text) );
SendCommand( MSG_TO_SCH, cmd );
}
}
/*********************************************************************/
void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
/*********************************************************************/
@ -262,6 +304,7 @@ void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
break;
case ID_GET_TOOLS:
// InstalloolsFrame(this, wxPoint(-1,-1) );
break;
@ -336,6 +379,7 @@ void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
case ID_POPUP_END_LINE:
DrawPanel->MouseToCursorSchema();
// EndSegment(&dc);
break;
@ -564,6 +608,7 @@ void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
break;
case ID_POPUP_PCB_EDIT_MODULE:
// If the current Item is a pad, text module ...: Get the parent
if( GetCurItem()->Type() != TYPEMODULE )
SetCurItem( GetCurItem()->GetParent() );
@ -931,6 +976,7 @@ static void Process_Move_Item( WinEDA_PcbFrame* frame,
}
}
/***************************************************************/
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;
MsgPanel = NULL;
m_CurrentScreen = NULL;
m_MenuBar = NULL; // menu du haut d'ecran
m_MenuBar = NULL; // main meun frame
m_ID_current_state = 0;
m_HTOOL_current_state = 0;
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_UnitType = INTERNAL_UNIT_TYPE; // Internal unit = inch
// nombre d'unites internes pour 1 pouce
// = 1000 pour schema, = 10000 pour PCB
// Internal units per inch
// = 1000 for schema, = 10000 for PCB
m_InternalUnits = EESCHEMA_INTERNAL_UNIT;
if( (m_Ident == PCB_FRAME) || (m_Ident == GERBER_FRAME)
|| (m_Ident == CVPCB_DISPLAY_FRAME)
@ -111,7 +111,7 @@ WinEDA_DrawFrame::WinEDA_DrawFrame( wxWindow* father, int idtype,
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 );
}
@ -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 );
@ -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,
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 )
return; //Ne devrait pas se produire!
return; // Should not occurs
int id = m_SelGridBox->GetChoice();
if( id < 0 )