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

change_log.txt

@@ -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

common/edaappl.cpp

@@ -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
 

eeschema/block.cpp

@@ -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;

eeschema/cleanup.cpp

@@ -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;
 }
 

eeschema/controle.cpp

@@ -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 )
+    if( strcmp( idcmd, "$PART:" ) != 0 )
+        return;
+
+    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 )
     {
-        WinEDA_SchematicFrame* frame = EDA_Appl->SchematicFrame;
+        frame->FindComponentAndItem( part_ref, true, 3, msg, false );
+    }
 
-        wxString msg = CONV_FROM_UTF8( text );
-        frame->FindSchematicItem( msg, 1, 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 */
-
 }

eeschema/delsheet.cpp

@@ -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;

eeschema/dialog_eeschema_config.cpp

@@ -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);
 }

eeschema/eeconfig.cpp

@@ -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;
 }

eeschema/eeschema.cpp

@@ -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;

eeschema/find.cpp

@@ -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;
@@ -258,7 +470,7 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindSchematicItem(
             switch( DrawList->Type() )
             {
             case DRAW_LIB_ITEM_STRUCT_TYPE:
-                EDA_SchComponentStruct* pSch;
+                EDA_SchComponentStruct * pSch;
                 pSch = (EDA_SchComponentStruct*) DrawList;
                 if( WildCompareString( WildText, pSch->m_Field[REFERENCE].m_Text, FALSE ) )
                 {
@@ -276,7 +488,7 @@ EDA_BaseStruct* WinEDA_SchematicFrame::FindSchematicItem(
             case DRAW_LABEL_STRUCT_TYPE:
             case DRAW_GLOBAL_LABEL_STRUCT_TYPE:
             case DRAW_TEXT_STRUCT_TYPE:
-                DrawTextStruct* pDraw;
+                DrawTextStruct * pDraw;
                 pDraw = (DrawTextStruct*) DrawList;
                 if( WildCompareString( WildText, pDraw->m_Text, 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 );

eeschema/getpart.cpp

@@ -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 );

eeschema/libframe.cpp

@@ -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;
 }
 

eeschema/locate.cpp

@@ -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;

eeschema/protos.h

@@ -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 */

eeschema/schedit.cpp

@@ -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;
 

eeschema/schframe.cpp

@@ -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 ;

eeschema/symbdraw.cpp

@@ -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 )
     {

eeschema/viewlib_frame.cpp

@@ -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;
 }
 
 /*****************************************************************/

include/appl_wxstruct.h

@@ -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;

include/wxstruct.h

@@ -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 );
 
@@ -1584,13 +1600,13 @@ public:
     const wxChar**    m_ItemList;
 
 private:
-    void (*m_MoveFct)(wxString & Text);
+    void (*m_MoveFct)( wxString & Text );
 
 public:
     WinEDAListBox( WinEDA_DrawFrame* parent, const wxString& title,
                    const wxChar** ItemList,
                    const wxString& RefText,
-                   void (* movefct)(wxString& Text) = NULL,
+                   void(* movefct)(wxString& Text) = NULL,
                    const wxColour& colour = wxNullColour,
                    wxPoint dialog_position = wxDefaultPosition );
     ~WinEDAListBox();

pcbnew/controle.cpp

@@ -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 )
+    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()

pcbnew/drc.cpp

@@ -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�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 )

pcbnew/edit.cpp

@@ -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 ) 
+    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 )
 /***************************************************************/

share/drawframe.cpp

@@ -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 )