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