see 2007-Oct-12 change_log.txt

change_log.txt

@@ -19,6 +19,40 @@ email address.
     with genliste.cpp.notused
 
 
+    
+2007-Oct-12 UPDATE   Dick Hollenbeck <dick@softplc.com>
+================================================================================
++ all
+  * m_NetCode is now private or protected throughout.
+    added SetNet() and GetNet() to all classes which have this member name.
+    ditto for m_Sous_NetCode, for which there is now SetSubNet() and GetSubNet().
++ pcbnew
+    added more disambiguating text to the PcbGeneralLocateAndDisplay() popup
+    menu for tracks. We need all the info we can get there I found after using
+    the software for many hours.
+  
+  
+  Jean-Pierre:    
+    
+  I never thought I would find a greater problem in using Kicad than having to
+  lay down all the ground and power tracks, rather that just linking vias into
+  pre-established zones or "tagged layers".  
+  
+  But I have, hundreds of my tracks and vias are showing
+  unconnected under my BGA, (where say the track or via is NetCode==0) and it
+  should not be, because the damn track ties the BGA pad to a nearby via.
+  How can the software be made to think these three items are on the same net,
+  without re-entering all the damn tracks?
+
+  This issue has been coming up for months on the user list, it must be dealt with now.
+  There is always the same lame answer, "make sure your tracks go to the center of the pads".
+  Nonsense, the software picked the track end points, not me, and grid was on when it did it.  
+  There are bugs here.
+  
+  Does Recalcule_all_net_connexion() work, and why is not called from anywhere?
+
+  
+    
 2007-Oct-11 UPDATE   Dick Hollenbeck <dick@softplc.com>
 ================================================================================
 + pcbnew

common/common.cpp

@@ -427,7 +427,7 @@ int GetTimeStamp()
 
 
 /*************************************************/
-void valeur_param( int valeur, wxString& buf_texte )
+const wxString& valeur_param( int valeur, wxString& buf_texte )
 /*************************************************/
 
 /* Retourne pour affichage la valeur d'un parametre, selon type d'unites choisies
@@ -444,4 +444,6 @@ void valeur_param( int valeur, wxString& buf_texte )
     {
         buf_texte.Printf( wxT( "%2.4f \"" ), valeur * 0.0001 );
     }
+    
+    return buf_texte;
 }

eeschema/erc.cpp

@@ -343,7 +343,7 @@ void WinEDA_ErcFrame::TestErc( wxCommandEvent& event )
     for( ; NetItemRef < Lim; NetItemRef++ )
     {
         /* Tst changement de net */
-        if( OldItem->m_NetCode != NetItemRef->m_NetCode )
+        if( OldItem->GetNet() != NetItemRef->GetNet() )
         {
             MinConn = NOC; 
             NetNbItems = 0; 
@@ -581,7 +581,7 @@ static void Diagnose( WinEDA_DrawPanel* panel, wxDC* DC,
         {
             Marker->m_Comment.Printf(
                 _( "Warning Pin %s not driven (Net %d)" ),
-                MsgPinElectricType[ii], NetItemRef->m_NetCode );
+                MsgPinElectricType[ii], NetItemRef->GetNet() );
             if( screen == panel->GetScreen() )
                 RedrawOneStruct( panel, DC, Marker, GR_COPY );
             return;
@@ -612,7 +612,7 @@ static void Diagnose( WinEDA_DrawPanel* panel, wxDC* DC,
                                       "%s: Pin %s connected to Pin %s (net %d)" ),
                                   DiagLevel.GetData(),
                                   MsgPinElectricType[ii],
-                                  MsgPinElectricType[jj], NetItemRef->m_NetCode );
+                                  MsgPinElectricType[jj], NetItemRef->GetNet() );
 
         if( screen == panel->GetScreen() )
             RedrawOneStruct( panel, DC, Marker, GR_COPY );
@@ -653,7 +653,7 @@ static void TestOthersItems( WinEDA_DrawPanel* panel, wxDC* DC,
 
         /* Est - on toujours dans le meme net ? */
         if( (NetItemTst >= Lim)                                     // fin de liste (donc fin de net)
-           || (NetItemRef->m_NetCode != NetItemTst->m_NetCode) )    // fin de net
+           || (NetItemRef->GetNet() != NetItemTst->GetNet()) )    // fin de net
         {                                                           /* Fin de netcode trouve: Tst connexion minimum */
             if( (*MinConnexion < NET_NC )
                && (local_minconn < NET_NC ) )                       /* pin non connecte ou non pilotee */
@@ -796,7 +796,7 @@ void TestLabel( WinEDA_DrawPanel* panel, wxDC* DC,
 
         /* Est - on toujours dans le meme net ? */
         if( ( NetItemTst ==  Lim )
-           || ( NetItemRef->m_NetCode != NetItemTst->m_NetCode ) )
+           || ( NetItemRef->GetNet() != NetItemTst->GetNet() ) )
         {           
             /* Fin de netcode trouve */
             if( erc )

eeschema/netform.cpp

@@ -192,7 +192,7 @@ static wxString ReturnPinNetName( ObjetNetListStruct* Pin,
  *  "netname_sheetnumber" for the usual nets
  */
 {
-    int      netcode = Pin->m_NetCode;
+    int      netcode = Pin->GetNet();
     wxString NetName;
 
     if( (netcode == 0 ) || ( Pin->m_FlagOfConnection != CONNECT ) )
@@ -204,7 +204,7 @@ static wxString ReturnPinNetName( ObjetNetListStruct* Pin,
         int jj;
         for( jj = 0; jj < g_NbrObjNet; jj++ )
         {
-            if( g_TabObjNet[jj].m_NetCode != netcode )
+            if( g_TabObjNet[jj].GetNet() != netcode )
                 continue;
             if( ( g_TabObjNet[jj].m_Type != NET_GLOBLABEL)
                && ( g_TabObjNet[jj].m_Type != NET_LABEL)
@@ -481,7 +481,7 @@ static void WriteNetListPspice( WinEDA_SchematicFrame* frame, FILE* f,
                     if( NetName == wxT( "0" ) || NetName == wxT( "GND" ) )
                         fprintf( f, " 0" );
                     else
-                        fprintf( f, " %d", Pin->m_NetCode );
+                        fprintf( f, " %d", Pin->GetNet() );
                 }
             }
 
@@ -834,13 +834,13 @@ static void WriteGENERICListOfNets( FILE* f, ObjetNetListStruct* ObjNet )
 
     for( ii = 0; ii < g_NbrObjNet; ii++ )
     {
-        if( (NetCode = ObjNet[ii].m_NetCode) != LastNetCode )   // New net found, write net id;
+        if( (NetCode = ObjNet[ii].GetNet()) != LastNetCode )   // New net found, write net id;
         {
             SameNetcodeCount = 0;                               // Items count for this net
             NetName.Empty();
             for( jj = 0; jj < g_NbrObjNet; jj++ )               // Find a label (if exists) for this net
             {
-                if( ObjNet[jj].m_NetCode != NetCode )
+                if( ObjNet[jj].GetNet() != NetCode )
                     continue;
                 if( ( ObjNet[jj].m_Type != NET_GLOBLABEL)
                    && ( ObjNet[jj].m_Type != NET_LABEL)
@@ -1010,12 +1010,12 @@ static void WriteListOfNetsCADSTAR( FILE* f, ObjetNetListStruct* ObjNet )
     for( ii = 0; ii < g_NbrObjNet; ii++ )
     {
         // Get the NetName of the current net :
-        if( (NetCode = ObjNet[ii].m_NetCode) != LastNetCode )
+        if( (NetCode = ObjNet[ii].GetNet()) != LastNetCode )
         {
             NetName.Empty();
             for( jj = 0; jj < g_NbrObjNet; jj++ )
             {
-                if( ObjNet[jj].m_NetCode != NetCode )
+                if( ObjNet[jj].GetNet() != NetCode )
                     continue;
                 if( ( ObjNet[jj].m_Type != NET_GLOBLABEL)
                    && ( ObjNet[jj].m_Type != NET_LABEL)
@@ -1089,7 +1089,7 @@ static void WriteListOfNetsCADSTAR( FILE* f, ObjetNetListStruct* ObjNet )
         //	pour ne pas generer plusieurs fois la connexion
         for( jj = ii + 1; jj < g_NbrObjNet; jj++ )
         {
-            if( ObjNet[jj].m_NetCode != NetCode )
+            if( ObjNet[jj].GetNet() != NetCode )
                 break;
             if( ObjNet[jj].m_Type != NET_PIN )
                 continue;

eeschema/netlist.cpp

@@ -66,7 +66,7 @@ void ObjetNetListStruct::Show( std::ostream& out, int ndx )
 {
     out << "<netItem ndx=\"" << ndx << '"' << 
             " type=\"" << ShowType(m_Type) << '"' <<
-            " netCode=\"" << m_NetCode << '"' <<
+            " netCode=\"" << GetNet() << '"' <<
             " sheet=\"" << m_SheetNumber << '"' <<
             ">\n";
 
@@ -226,14 +226,14 @@ void* WinEDA_SchematicFrame::BuildNetListBase()
         case NET_PINLABEL:
         case NET_SHEETLABEL:
         case NET_NOCONNECT:
-            if( g_TabObjNet[i].m_NetCode != 0 )
+            if( g_TabObjNet[i].GetNet() != 0 )
                 break;                                      /* Deja connecte */
 
         case NET_SEGMENT:
             /* Controle des connexions type point a point ( Sans BUS ) */
-            if( g_TabObjNet[i].m_NetCode == 0 )
+            if( g_TabObjNet[i].GetNet() == 0 )
             {
-                g_TabObjNet[i].m_NetCode = LastNetCode;
+                g_TabObjNet[i].SetNet( LastNetCode );
                 LastNetCode++;
             }
             PointToPointConnect( g_TabObjNet + i, 0, istart );
@@ -241,9 +241,9 @@ void* WinEDA_SchematicFrame::BuildNetListBase()
 
         case NET_JONCTION:
             /* Controle des jonction , hors BUS */
-            if( g_TabObjNet[i].m_NetCode == 0 )
+            if( g_TabObjNet[i].GetNet() == 0 )
             {
-                g_TabObjNet[i].m_NetCode = LastNetCode;
+                g_TabObjNet[i].SetNet( LastNetCode );
                 LastNetCode++;
             }
             SegmentToPointConnect( g_TabObjNet + i, 0, istart );
@@ -260,9 +260,9 @@ void* WinEDA_SchematicFrame::BuildNetListBase()
         case NET_LABEL:
         case NET_GLOBLABEL:
             /* Controle des connexions type jonction ( Sans BUS ) */
-            if( g_TabObjNet[i].m_NetCode == 0 )
+            if( g_TabObjNet[i].GetNet() == 0 )
             {
-                g_TabObjNet[i].m_NetCode = LastNetCode;
+                g_TabObjNet[i].SetNet( LastNetCode );
                 LastNetCode++;
             }
             SegmentToPointConnect( g_TabObjNet + i, 0, istart );
@@ -285,7 +285,7 @@ void* WinEDA_SchematicFrame::BuildNetListBase()
         case NET_BUSLABELMEMBER:
         case NET_GLOBBUSLABELMEMBER:
             /* Controle des connexions semblables a des sur BUS */
-            if( g_TabObjNet[i].m_NetCode == 0 )
+            if( g_TabObjNet[i].GetNet() == 0 )
             {
                 g_TabObjNet[i].m_BusNetCode = LastBusNetCode;
                 LastBusNetCode++;
@@ -368,12 +368,12 @@ void* WinEDA_SchematicFrame::BuildNetListBase()
     LastNetCode = NetCode = 0;
     for( i = 0; i < g_NbrObjNet; i++ )
     {
-        if( g_TabObjNet[i].m_NetCode != LastNetCode )
+        if( g_TabObjNet[i].GetNet() != LastNetCode )
         {
             NetCode++; 
-            LastNetCode = g_TabObjNet[i].m_NetCode;
+            LastNetCode = g_TabObjNet[i].GetNet();
         }
-        g_TabObjNet[i].m_NetCode = NetCode;
+        g_TabObjNet[i].SetNet( NetCode );
     }
 
     Affiche_1_Parametre( this, -1, wxEmptyString, _( "Done" ), GREEN );
@@ -393,7 +393,7 @@ static void SheetLabelConnection( ObjetNetListStruct* SheetLabel )
     int i;
     ObjetNetListStruct* ObjetNet;
 
-    if( SheetLabel->m_NetCode == 0 )
+    if( SheetLabel->GetNet() == 0 )
         return;
 
     /* Calcul du numero de sous feuille correspondante au sheetlabel */
@@ -409,17 +409,17 @@ static void SheetLabelConnection( ObjetNetListStruct* SheetLabel )
            && (ObjetNet[i].m_Type != NET_GLOBBUSLABELMEMBER ) )
             continue;
             
-        if( ObjetNet[i].m_NetCode == SheetLabel->m_NetCode )
+        if( ObjetNet[i].GetNet() == SheetLabel->GetNet() )
             continue;
         
         if( ObjetNet[i].m_Label->CmpNoCase( *SheetLabel->m_Label ) != 0 )
             continue;
 
         /* Propagation du Netcode a tous les Objets de meme NetCode */
-        if( ObjetNet[i].m_NetCode )
-            PropageNetCode( ObjetNet[i].m_NetCode, SheetLabel->m_NetCode, 0 );
+        if( ObjetNet[i].GetNet() )
+            PropageNetCode( ObjetNet[i].GetNet(), SheetLabel->GetNet(), 0 );
         else
-            ObjetNet[i].m_NetCode = SheetLabel->m_NetCode;
+            ObjetNet[i].SetNet( SheetLabel->GetNet() );
     }
 }
 
@@ -714,9 +714,9 @@ static void ConnectBusLabels( ObjetNetListStruct* Label, int NbItems )
            || (Label->m_Type == NET_BUSLABELMEMBER)
            || (Label->m_Type == NET_GLOBBUSLABELMEMBER) )
         {
-            if( Label->m_NetCode == 0 )
+            if( Label->GetNet() == 0 )
             {
-                Label->m_NetCode = LastNetCode; 
+                Label->SetNet( LastNetCode ); 
                 LastNetCode++;
             }
             
@@ -732,10 +732,10 @@ static void ConnectBusLabels( ObjetNetListStruct* Label, int NbItems )
                     if( LabelInTst->m_Member != Label->m_Member )
                         continue;
                     
-                    if( LabelInTst->m_NetCode == 0 )
-                        LabelInTst->m_NetCode = Label->m_NetCode;
+                    if( LabelInTst->GetNet() == 0 )
+                        LabelInTst->SetNet( Label->GetNet() );
                     else
-                        PropageNetCode( LabelInTst->m_NetCode, Label->m_NetCode, 0 );
+                        PropageNetCode( LabelInTst->GetNet(), Label->GetNet(), 0 );
                 }
             }
         }
@@ -886,9 +886,9 @@ static void PropageNetCode( int OldNetCode, int NewNetCode, int IsBus )
     {
         for( jj = 0; jj < g_NbrObjNet; jj++, Objet++ )
         {
-            if( Objet->m_NetCode == OldNetCode )
+            if( Objet->GetNet() == OldNetCode )
             {
-                Objet->m_NetCode = NewNetCode;
+                Objet->SetNet( NewNetCode );
             }
         }
     }
@@ -933,7 +933,7 @@ static void PointToPointConnect( ObjetNetListStruct* Ref, int IsBus, int start )
 
     if( IsBus == 0 )    /* Objets autres que BUS et BUSLABELS */
     {
-        netCode = Ref->m_NetCode;
+        netCode = Ref->GetNet();
         for( i = start; i < g_NbrObjNet; i++ )
         {
             if( netTable[i].m_SheetNumber > Ref->m_SheetNumber )
@@ -954,10 +954,10 @@ static void PointToPointConnect( ObjetNetListStruct* Ref, int IsBus, int start )
                  || Ref->m_End   == netTable[i].m_Start
                  || Ref->m_End   == netTable[i].m_End )
                 {
-                    if( netTable[i].m_NetCode == 0 )
-                        netTable[i].m_NetCode = netCode;
+                    if( netTable[i].GetNet() == 0 )
+                        netTable[i].SetNet( netCode );
                     else
-                        PropageNetCode( netTable[i].m_NetCode, netCode, 0 );
+                        PropageNetCode( netTable[i].GetNet(), netCode, 0 );
                 }
                 break;
 
@@ -1052,11 +1052,11 @@ static void SegmentToPointConnect( ObjetNetListStruct* Jonction,
             /* Propagation du Netcode a tous les Objets de meme NetCode */
             if( IsBus == 0 )
             {
-                if( Segment[i].m_NetCode )
-                    PropageNetCode( Segment[i].m_NetCode,
-                                    Jonction->m_NetCode, IsBus );
+                if( Segment[i].GetNet() )
+                    PropageNetCode( Segment[i].GetNet(),
+                                    Jonction->GetNet(), IsBus );
                 else
-                    Segment[i].m_NetCode = Jonction->m_NetCode;
+                    Segment[i].SetNet( Jonction->GetNet() );
             }
             else
             {
@@ -1076,14 +1076,14 @@ static void SegmentToPointConnect( ObjetNetListStruct* Jonction,
  *******************************************************************/
 static void LabelConnection( ObjetNetListStruct* LabelRef )
 {
-    if( LabelRef->m_NetCode == 0 )
+    if( LabelRef->GetNet() == 0 )
         return;
 
     ObjetNetListStruct* netTable = g_TabObjNet;
 
     for( int i=0; i<g_NbrObjNet;  i++ )
     {
-        if( netTable[i].m_NetCode == LabelRef->m_NetCode )
+        if( netTable[i].GetNet() == LabelRef->GetNet() )
             continue;
 
         if( netTable[i].m_SheetNumber != LabelRef->m_SheetNumber )
@@ -1104,10 +1104,10 @@ static void LabelConnection( ObjetNetListStruct* LabelRef )
             /* Ici 2 labels identiques */
 
             /* Propagation du Netcode a tous les Objets de meme NetCode */
-            if( netTable[i].m_NetCode )
-                PropageNetCode( netTable[i].m_NetCode, LabelRef->m_NetCode, 0 );
+            if( netTable[i].GetNet() )
+                PropageNetCode( netTable[i].GetNet(), LabelRef->GetNet(), 0 );
             else
-                netTable[i].m_NetCode = LabelRef->m_NetCode;
+                netTable[i].SetNet( LabelRef->GetNet() );
         }
     }
 }
@@ -1124,7 +1124,7 @@ static int TriNetCode( const void* o1, const void* o2 )
     ObjetNetListStruct* Objet1 = (ObjetNetListStruct*) o1;
     ObjetNetListStruct* Objet2 = (ObjetNetListStruct*) o2;
     
-    return Objet1->m_NetCode - Objet2->m_NetCode;
+    return Objet1->GetNet() - Objet2->GetNet();
 }
 
 
@@ -1173,7 +1173,7 @@ static void SetUnconnectedFlag( ObjetNetListStruct* ListObj, int NbItems )
         NetItemTst = NetItemRef + 1;
 
         if( (NetItemTst >= Lim)
-           || (NetItemRef->m_NetCode != NetItemTst->m_NetCode) )
+           || (NetItemRef->GetNet() != NetItemTst->GetNet()) )
         {   
             /* Net analyse: mise a jour de m_FlagOfConnection */
             NetEnd = NetItemTst;
@@ -1195,7 +1195,7 @@ static void SetUnconnectedFlag( ObjetNetListStruct* ListObj, int NbItems )
         for( ; ; NetItemTst++ )
         {
             if( (NetItemTst >= Lim)
-               || (NetItemRef->m_NetCode != NetItemTst->m_NetCode) )
+               || (NetItemRef->GetNet() != NetItemTst->GetNet()) )
                 break;
 
             switch( NetItemTst->m_Type )

eeschema/netlist.h

@@ -70,7 +70,9 @@ public:
     SCH_SCREEN*     m_Screen;           /* Ecran d'appartenance */
     NetObjetType    m_Type;
     int             m_ElectricalType;   /* Pour Pins et sheet labels: type electrique */
+private:    
     int             m_NetCode;          /* pour elements simples */
+public:    
     int             m_BusNetCode;       /* pour connexions type bus */
     int             m_Member;           /* pour les labels type BUSWIRE ( labels de bus eclate )
                                          *  numero de membre */
@@ -85,6 +87,8 @@ public:
     void Show( std::ostream& out, int ndx );
 #endif
 
+    void SetNet( int aNetCode ) { m_NetCode = aNetCode; }
+    int GetNet() const { return m_NetCode; }
 };
 
 

gerbview/affiche.cpp

@@ -71,7 +71,7 @@ void Affiche_Infos_Piste( WinEDA_BasePcbFrame* frame, TRACK* pt_piste )
 
     frame->MsgPanel->EraseMsgBox();
 
-    d_index   = pt_piste->m_NetCode;
+    d_index   = pt_piste->GetNet();
     pt_D_code = ReturnToolDescr( layer, d_index, &ii );
 
     switch( pt_piste->Type() )

gerbview/block.cpp

@@ -334,7 +334,7 @@ void WinEDA_BasePcbFrame::Block_Move( wxDC* DC )
             track->Draw( DrawPanel, DC, GR_XOR );   // erase the display
             track->m_Start.x += deltaX; track->m_Start.y += deltaY;
             track->m_End.x   += deltaX; track->m_End.y += deltaY;
-            track->m_Param   += deltaX; track->m_Sous_Netcode += deltaY;
+            track->m_Param   += deltaX; track->SetSubNet( track->GetSubNet() + deltaY );
             track->Draw( DrawPanel, DC, GR_OR ); // redraw the moved track
         }
         track = track->Next();
@@ -349,7 +349,7 @@ void WinEDA_BasePcbFrame::Block_Move( wxDC* DC )
             zsegment->Draw( DrawPanel, DC, GR_XOR );   // erase the display
             zsegment->m_Start.x += deltaX; track->m_Start.y += deltaY;
             zsegment->m_End.x   += deltaX; track->m_End.y += deltaY;
-            zsegment->m_Param   += deltaX; track->m_Sous_Netcode += deltaY;
+            zsegment->m_Param   += deltaX; track->SetSubNet( track->GetSubNet() + deltaY );
             zsegment->Draw( DrawPanel, DC, GR_OR ); // redraw the moved zone zegment
         }
         zsegment = zsegment->Next();

gerbview/dcode.cpp

@@ -340,7 +340,7 @@ D_CODE * pt_Dcode;	/* Pointeur sur le D code*/
 	track = m_Pcb->m_Track;
 	for ( ; track != NULL ; track = (TRACK*) track->Pnext )
 		{
-		pt_Dcode = ReturnToolDescr(track->GetLayer(), track->m_NetCode);
+		pt_Dcode = ReturnToolDescr(track->GetLayer(), track->GetNet());
 		pt_Dcode->m_InUse = TRUE;
 
 		if (		// Line Item

gerbview/deltrack.cpp

@@ -28,7 +28,7 @@ void WinEDA_GerberFrame::Delete_DCode_Items( wxDC* DC, int dcode_value, int laye
     for( ; track != NULL; track = next_track )
     {
         next_track = track->Next();
-        if( dcode_value != track->m_NetCode )
+        if( dcode_value != track->GetNet() )
             continue;
         if( layer_number >= 0 && layer_number != track->GetLayer() )
             continue;

gerbview/readgerb.cpp

@@ -95,7 +95,7 @@
  *  Les Flash  sont représentées par des DRAWSEGMENTS
  *      - ronds ou ovales: DRAWSEGMENTS
  *      - rectangles: DRAWSEGMENTS
- *  la reference aux D-CODES est placée dans le membre m_NetCode
+ *  la reference aux D-CODES est placée dans le membre GetNet()
  */
 
 

gerbview/rs274d.cpp

@@ -112,7 +112,7 @@ static void Append_1_Flash_ROND_GERBER( int Dcode_tool,
     track->m_Start = track->m_End = pos;
     NEGATE( track->m_Start.y );
     NEGATE( track->m_End.y );
-    track->m_NetCode = Dcode_tool;
+    track->SetNet( Dcode_tool );
     track->m_Shape   = S_SPOT_CIRCLE;
 
     Trace_Segment( frame->DrawPanel, DC, track, GR_OR );
@@ -145,7 +145,7 @@ static void Append_1_Flash_GERBER( int Dcode_index,
     track->m_Start = track->m_End = pos;
     NEGATE( track->m_Start.y );
     NEGATE( track->m_End.y );
-    track->m_NetCode = Dcode_index;
+    track->SetNet( Dcode_index );
 
     if( forme == OVALE )
         track->m_Shape = S_SPOT_OVALE;
@@ -187,7 +187,7 @@ static void Append_1_Line_GERBER( int Dcode_index,
     NEGATE( track->m_Start.y );
     track->m_End = endpoint;
     NEGATE( track->m_End.y );
-    track->m_NetCode = Dcode_index;
+    track->SetNet( Dcode_index );
 
     Trace_Segment( frame->DrawPanel, DC, track, GR_OR );
 }
@@ -279,13 +279,15 @@ static void Append_1_SEG_ARC_GERBER( int Dcode_index,
         }
     }
 
-    track->m_NetCode      = Dcode_index;
+    track->SetNet( Dcode_index );
     track->m_Param        = center.x;
-    track->m_Sous_Netcode = center.y;
+    track->SetSubNet( center.y );
 
     NEGATE( track->m_Start.y );
     NEGATE( track->m_End.y );
-    NEGATE( track->m_Sous_Netcode );
+    
+    //NEGATE( track->GetSubNet() );
+    track->SetSubNet( -track->GetSubNet() );
 
     Trace_Segment( frame->DrawPanel, DC, track, GR_OR );
 }
@@ -745,7 +747,7 @@ bool GERBER_Descr::Execute_DCODE_Command( WinEDA_GerberFrame* frame, wxDC* DC,
             NEGATE( edge_poly->m_Start.y );
             edge_poly->m_End = m_CurrentPos;
             NEGATE( edge_poly->m_End.y );
-            edge_poly->m_NetCode = m_PolygonFillModeState;
+            edge_poly->SetNet( m_PolygonFillModeState );
             m_PreviousPos = m_CurrentPos;
             m_PolygonFillModeState = 1;
             break;

gerbview/tracepcb.cpp

@@ -112,7 +112,7 @@ void WinEDA_GerberFrame::Trace_Gerber( wxDC* DC, int draw_mode, int printmasklay
 		if ( printmasklayer != -1 )
 			if ( (track->ReturnMaskLayer() & printmasklayer) == 0 ) continue;
 
-        if( track->m_NetCode == 0 )    // StartPoint
+        if( track->GetNet() == 0 )    // StartPoint
         {
             if( nbpoints )
             {

gerbview/trpiste.cpp

@@ -44,7 +44,7 @@ void Draw_Track_Buffer( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb, int draw_
             if( (Track->ReturnMaskLayer() & printmasklayer) == 0 )
                 continue;
 
-        if( (dcode_hightlight == Track->m_NetCode)
+        if( (dcode_hightlight == Track->GetNet())
            && (Track->GetLayer() == layer) )
             Trace_Segment( panel, DC, Track, draw_mode | GR_SURBRILL );
         else
@@ -122,13 +122,13 @@ void Trace_Segment( WinEDA_DrawPanel* panel, wxDC* DC, TRACK* track, int draw_mo
         {
             GRArc1( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
                     track->m_End.x, track->m_End.y,
-                    track->m_Param, track->m_Sous_Netcode, 0, color );
+                    track->m_Param, track->GetSubNet(), 0, color );
         }
         else
         {
             GRArc1( &panel->m_ClipBox, DC, track->m_Start.x, track->m_Start.y,
                     track->m_End.x, track->m_End.y,
-                    track->m_Param, track->m_Sous_Netcode,
+                    track->m_Param, track->GetSubNet(),
                     track->m_Width, color );
         }
     }
@@ -344,7 +344,7 @@ void Affiche_DCodes_Pistes( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb, int d
             pos.x = (track->m_Start.x + track->m_End.x) / 2;
             pos.y = (track->m_Start.y + track->m_End.y) / 2;
         }
-        Line.Printf( wxT( "D%d" ), track->m_NetCode );
+        Line.Printf( wxT( "D%d" ), track->GetNet() );
         width  = track->m_Width;
         orient = TEXT_ORIENT_HORIZ;
         if( track->m_Shape >= S_SPOT_CIRCLE )   // forme flash

gerbview/undelete.cpp

@@ -44,7 +44,7 @@ void WinEDA_GerberFrame::UnDeleteItem( wxDC* DC )
         }
 
         PtStruct = g_UnDeleteStack[g_UnDeleteStackPtr];
-        net_code = ( (TRACK*) PtStruct )->m_NetCode;
+        net_code = ( (TRACK*) PtStruct )->GetNet();
         pt_track = ( (TRACK*) PtStruct )->GetBestInsertPoint( m_Pcb );
         ( (TRACK*) PtStruct )->Insert( m_Pcb, pt_track );
 

include/common.h

@@ -588,7 +588,7 @@ int         GetCommandOptions( const int argc, const char** argv, const char* st
                                const char** optarg, int* optind );
 
 
-void        valeur_param( int valeur, wxString& buf_texte );
+const wxString& valeur_param( int valeur, wxString& buf_texte );
 
 /* Retourne pour affichage la valeur d'un parametre, selon type d'unites choisies
  *  entree : valeur en mils , buffer de texte

pcbnew/affiche.cpp

@@ -43,7 +43,7 @@ void Affiche_Infos_Equipot( int netcode, WinEDA_BasePcbFrame* frame )
     {
         for( pad = module->m_Pads; pad != 0; pad = (D_PAD*) pad->Pnext )
         {
-            if( pad->m_NetCode == netcode )
+            if( pad->GetNet() == netcode )
                 ii++;
         }
     }
@@ -55,7 +55,7 @@ void Affiche_Infos_Equipot( int netcode, WinEDA_BasePcbFrame* frame )
     {
         ii++;
         if( Struct->Type() == TYPEVIA )
-            if( ( (SEGVIA*) Struct )->m_NetCode == netcode )
+            if( ( (SEGVIA*) Struct )->GetNet() == netcode )
                 nb_vias++;
     }
 

pcbnew/attribut.cpp

@@ -76,7 +76,7 @@ void WinEDA_PcbFrame::Attribut_net( wxDC* DC, int net_code, bool Flag_On )
     {
         for( ; Track != NULL; Track = (TRACK*) Track->Pnext )
         {
-            if( net_code == Track->m_NetCode )
+            if( net_code == Track->GetNet() )
                 break;
         }
     }
@@ -84,7 +84,7 @@ void WinEDA_PcbFrame::Attribut_net( wxDC* DC, int net_code, bool Flag_On )
     DrawPanel->CursorOff( DC );     // Erase cursor shape
     while( Track )                  /* Flag change */
     {
-        if( (net_code >= 0 ) && (net_code != Track->m_NetCode) )
+        if( (net_code >= 0 ) && (net_code != Track->GetNet()) )
             break;
         GetScreen()->SetModify();
         Track->SetState( SEGM_FIXE, Flag_On );

pcbnew/autoplac.cpp

@@ -449,7 +449,7 @@ int WinEDA_PcbFrame::GenPlaceBoard()
     TRACK TmpSegm( NULL );
 
     TmpSegm.SetLayer( -1 );
-    TmpSegm.m_NetCode = -1;
+    TmpSegm.SetNet( -1 );
     TmpSegm.m_Width   = g_GridRoutingSize / 2;
     for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
     {
@@ -970,7 +970,7 @@ void Build_PlacedPads_List( BOARD* Pcb )
             PtPad->m_physical_connexion = 0;
             PtPad->m_logical_connexion  = 0;
             PtPad->m_Parent = Module;
-            if( PtPad->m_NetCode )
+            if( PtPad->GetNet() )
                 Pcb->m_NbNodes++;
             pt_liste_pad++;
         }

pcbnew/autorout.cpp

-	/***************************************/
-	/* PCBNEW: Autorouting command control */
-	/***************************************/
+/***************************************/
+/* PCBNEW: Autorouting command control */
+/***************************************/
 
 #include "fctsys.h"
 #include "gr_basic.h"
@@ -16,18 +16,18 @@
 /* Variables locales */
 
 /********************************************************/
-void WinEDA_PcbFrame::Autoroute(wxDC * DC, int mode)
+void WinEDA_PcbFrame::Autoroute( wxDC* DC, int mode )
 /********************************************************/
 /* init board, route traces*/
 {
-int ii, start, stop;
-CHEVELU* ptmp;
-MODULE * Module = NULL;
-D_PAD * Pad = NULL;
-int autoroute_net_code = -1;
-wxString msg;
+    int      ii, start, stop;
+    CHEVELU* ptmp;
+    MODULE*  Module = NULL;
+    D_PAD*   Pad    = NULL;
+    int      autoroute_net_code = -1;
+    wxString msg;
 
-	if ( g_DesignSettings.m_CopperLayerCount > 1 )
+    if( g_DesignSettings.m_CopperLayerCount > 1 )
     {
         Route_Layer_TOP    = GetScreen()->m_Route_Layer_TOP;
         Route_Layer_BOTTOM = GetScreen()->m_Route_Layer_BOTTOM;
@@ -38,25 +38,25 @@ wxString msg;
             Route_Layer_BOTTOM = COPPER_LAYER_N;
     }
 
-	switch ( mode )
+    switch( mode )
     {
     case ROUTE_NET:
-			if ( GetScreen()->GetCurItem() )
+        if( GetScreen()->GetCurItem() )
         {
-				switch ( GetScreen()->GetCurItem()->Type() )
+            switch( GetScreen()->GetCurItem()->Type() )
             {
             case TYPEPAD:
                 Pad = (D_PAD*) GetScreen()->GetCurItem();
-						autoroute_net_code = Pad->m_NetCode;
+                autoroute_net_code = Pad->GetNet();
                 break;
 
             default:
                 break;
             }
         }
-			if( autoroute_net_code <= 0)
+        if( autoroute_net_code <= 0 )
         {
-				DisplayError(this, _("Net not selected")); return;
+            DisplayError( this, _( "Net not selected" ) ); return;
         }
         break;
 
@@ -64,7 +64,7 @@ wxString msg;
         Module = (MODULE*) GetScreen()->GetCurItem();
         if( (Module == NULL) || (Module->Type() != TYPEMODULE) )
         {
-				DisplayError(this, _("Module not selected") ); return;
+            DisplayError( this, _( "Module not selected" ) ); return;
         }
         break;
 
@@ -72,148 +72,164 @@ wxString msg;
         Pad = (D_PAD*) GetScreen()->GetCurItem();
         if( (Pad == NULL)  || (Pad->Type() != TYPEPAD) )
         {
-				DisplayError(this, _("Pad not selected") ); return;
+            DisplayError( this, _( "Pad not selected" ) ); return;
         }
         break;
- 
     }
+
     if( (m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK ) == 0 )
-		Compile_Ratsnest(DC, TRUE);
+        Compile_Ratsnest( DC, TRUE );
 
     /* Placement du flag CH_ROUTE_REQ sur les chevelus demandes */
     ptmp = (CHEVELU*) m_Pcb->m_Ratsnest;
-	for ( ii = m_Pcb->GetNumRatsnests(); ii > 0; ii--, ptmp ++ )
+    for( ii = m_Pcb->GetNumRatsnests(); ii > 0; ii--, ptmp++ )
     {
         ptmp->status &= ~CH_ROUTE_REQ;
-		switch ( mode )
+
+        switch( mode )
         {
         case ROUTE_ALL:
             ptmp->status |= CH_ROUTE_REQ; break;
 
         case ROUTE_NET:
-				if( autoroute_net_code == ptmp->m_NetCode)
+            if( autoroute_net_code == ptmp->GetNet() )
                 ptmp->status |= CH_ROUTE_REQ;
             break;
 
         case ROUTE_MODULE:
         {
-				D_PAD * pt_pad = (D_PAD *) Module->m_Pads;
-				for( ; pt_pad != NULL; pt_pad = (D_PAD *)pt_pad->Pnext)
+            D_PAD* pt_pad = (D_PAD*) Module->m_Pads;
+            for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
             {
                 if( ptmp->pad_start == pt_pad )
                     ptmp->status |= CH_ROUTE_REQ;
                 if( ptmp->pad_end == pt_pad )
                     ptmp->status |= CH_ROUTE_REQ;
             }
+
             break;
         }
+
         case ROUTE_PAD:
-				if( (ptmp->pad_start == Pad) || (ptmp->pad_end == Pad))
+            if( (ptmp->pad_start == Pad) || (ptmp->pad_end == Pad) )
                 ptmp->status |= CH_ROUTE_REQ;
             break;
         }
     }
-	ptmp = (CHEVELU*)m_Pcb->m_Ratsnest;
+
+    ptmp = (CHEVELU*) m_Pcb->m_Ratsnest;
 
     start = time( NULL );
 
     /* Calcul du pas de routage fixe a 5 mils et plus */
     g_GridRoutingSize = GetScreen()->GetGrid().x;
-	if (g_GridRoutingSize < 50 ) g_GridRoutingSize = 50 ;
-	E_scale = g_GridRoutingSize / 50 ; if (E_scale < 1 ) E_scale = 1 ;
+    if( g_GridRoutingSize < 50 )
+        g_GridRoutingSize = 50;
+    E_scale = g_GridRoutingSize / 50; if( E_scale < 1 )
+        E_scale = 1;
 
     /* calcule de Ncols et Nrow, taille de la matrice de routage */
-	ComputeMatriceSize(this, g_GridRoutingSize);
+    ComputeMatriceSize( this, g_GridRoutingSize );
 
     MsgPanel->EraseMsgBox();
 
     /* Creation du mapping du board */
     Nb_Sides = ONE_SIDE;
-	if(Route_Layer_TOP != Route_Layer_BOTTOM ) Nb_Sides = TWO_SIDES;
+    if( Route_Layer_TOP != Route_Layer_BOTTOM )
+        Nb_Sides = TWO_SIDES;
 
-	if ( Board.InitBoard() < 0 )
+    if( Board.InitBoard() < 0 )
     {
-		DisplayError(this, _("No memory for autorouting") );
+        DisplayError( this, _( "No memory for autorouting" ) );
         Board.UnInitBoard();  /* Libere la memoire BitMap */
         return;
     }
 
-	Affiche_Message( _("Place Cells") );
-	PlaceCells(m_Pcb, -1, FORCE_PADS);
+    Affiche_Message( _( "Place Cells" ) );
+    PlaceCells( m_Pcb, -1, FORCE_PADS );
 
     /* Construction de la liste des pistes a router */
-	Build_Work(m_Pcb, ptmp);
+    Build_Work( m_Pcb, ptmp );
 
     // DisplayBoard(DrawPanel, DC);
 
     if( Nb_Sides == TWO_SIDES )
-		Solve(DC, TWO_SIDES);	/* double face */
-	else Solve(DC, ONE_SIDE);	/* simple face */
+        Solve( DC, TWO_SIDES ); /* double face */
+    else
+        Solve( DC, ONE_SIDE );  /* simple face */
 
     /* Liberation de la memoire */
     FreeQueue();            /* Libere la memoire de routage */
     InitWork();             /* Libere la memoire de la liste des connexions a router */
     Board.UnInitBoard();    /* Libere la memoire BitMap */
     stop = time( NULL ) - start;
-	msg.Printf( wxT("time = %d second%s"), stop, (stop == 1) ? wxT("") : wxT("s") );
-	Affiche_Message(msg);
+    msg.Printf( wxT( "time = %d second%s" ), stop, (stop == 1) ? wxT( "" ) : wxT( "s" ) );
+    Affiche_Message( msg );
 }
 
+
 /************************************************/
-void WinEDA_PcbFrame::Reset_Noroutable(wxDC * DC)
+void WinEDA_PcbFrame::Reset_Noroutable( wxDC* DC )
 /*************************************************/
- /* Remet a 0 le flag CH_NOROUTABLE qui est positionne a 1 par Solve()
-	lorsque un chevelu n'a pas ete route.
-	Si ce flag est a 1 il n'est pas reroute
-*/
+
+/* Remet a 0 le flag CH_NOROUTABLE qui est positionne a 1 par Solve()
+ *  lorsque un chevelu n'a pas ete route.
+ *  Si ce flag est a 1 il n'est pas reroute
+ */
 {
-int ii;
-CHEVELU* pt_rats;
+    int      ii;
+    CHEVELU* pt_rats;
 
     if( (m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK )== 0 )
-		Compile_Ratsnest(DC, TRUE);
+        Compile_Ratsnest( DC, TRUE );
 
-	pt_rats = (CHEVELU*)m_Pcb->m_Ratsnest;
-	if( pt_rats == NULL ) return;
+    pt_rats = (CHEVELU*) m_Pcb->m_Ratsnest;
+    if( pt_rats == NULL )
+        return;
 
-	for ( ii = m_Pcb->GetNumRatsnests(); ii > 0 ; ii-- , pt_rats++)
+    for( ii = m_Pcb->GetNumRatsnests(); ii > 0; ii--, pt_rats++ )
     {
-		pt_rats->status &= ~CH_UNROUTABLE ;
+        pt_rats->status &= ~CH_UNROUTABLE;
     }
 }
 
+
 /*****************************************************/
-void DisplayBoard(WinEDA_DrawPanel * panel, wxDC * DC)
+void DisplayBoard( WinEDA_DrawPanel* panel, wxDC* DC )
 /****************************************************/
 /* Fonction de DEBUG : affiche le remplissage des cellules TOP et BOTTOM */
 {
-int row, col, i , j;
-int dcell0, dcell1 = 0, color;
-int maxi;
+    int row, col, i, j;
+    int dcell0, dcell1 = 0, color;
+    int maxi;
 
-	maxi = (/*ActiveScreen->Lim_XD - 20*/ 500) / Ncols;
+    maxi = ( /*ActiveScreen->Lim_XD - 20*/ 500) / Ncols;
     maxi = (maxi * 3 ) / 4;
-	if (!maxi) maxi = 1;
+    if( !maxi )
+        maxi = 1;
 
-	for ( col = 0; col < Ncols; col++)
+    for( col = 0; col < Ncols; col++ )
     {
-		for(row = 0; row < Nrows; row++)
+        for( row = 0; row < Nrows; row++ )
         {
             color  = 0;
-			dcell0 = GetCell(row,col,BOTTOM); if (dcell0 & HOLE) color = GREEN;
-			if(Nb_Sides) dcell1 = GetCell(row,col,TOP);
-			if ( dcell1 & HOLE ) color |= RED;
+            dcell0 = GetCell( row, col, BOTTOM ); if( dcell0 & HOLE )
+                color = GREEN;
+            if( Nb_Sides )
+                dcell1 = GetCell( row, col, TOP );
+            if( dcell1 & HOLE )
+                color |= RED;
             dcell0 |= dcell1;
-			if( !color && (dcell0 & VIA_IMPOSSIBLE)) color = BLUE ;
-			if(color)
+            if( !color && (dcell0 & VIA_IMPOSSIBLE) )
+                color = BLUE;
+            if( color )
             {
-				for (i = 0; i < maxi; i++)
-					for (j = 0; j < maxi; j++)
-						GRSPutPixel(&panel->m_ClipBox, DC,
-							(col*maxi)+i + 10,(row*maxi) + 60 + j, color);
+                for( i = 0; i < maxi; i++ )
+                    for( j = 0; j < maxi; j++ )
+                        GRSPutPixel( &panel->m_ClipBox, DC,
+                                     (col * maxi) + i + 10, (row * maxi) + 60 + j, color );
+
             }
         }
     }
 }
-
-

pcbnew/autorout.h

-	/****************************************************/
-	/*					AUTOROUT.H						*/
-	/* d‚clarations communes relative au routage, DRC	*/
-	/* et placement automatique des composants			*/
-	/****************************************************/
+/****************************************************/
+/*					AUTOROUT.H						*/
+/* d‚clarations communes relative au routage, DRC	*/
+/* et placement automatique des composants			*/
+/****************************************************/
 
 #ifndef AUTOROUT_H
 #define AUTOROUT_H
@@ -14,39 +14,53 @@
 #define ILLEGAL -1
 
 
-	/*****************************************************/
-	/* Structures de representation des pads et chevelus */
-	/*	pour etablissement du chevelu general complet	 */
-	/*****************************************************/
+/*****************************************************/
+/* Structures de representation des pads et chevelus */
+/*	pour etablissement du chevelu general complet	 */
+/*****************************************************/
 
 
-
-	/***********************************************/
-	/* description d'un segment de chevelu general */
-	/***********************************************/
-	/****************************/
-	/* bits d'etat du chevelu : */
-	/****************************/
+/***********************************************/
+/* description d'un segment de chevelu general */
+/***********************************************/
+/****************************/
+/* bits d'etat du chevelu : */
+/****************************/
 #define CH_VISIBLE    1     /* affichage permanent demande */
 #define CH_UNROUTABLE 2     /* non route par l'autorouteur */
 #define CH_ROUTE_REQ  4     /* doit etre route par l'autorouteur */
 #define CH_ACTIF      8     /* chevelu non encore routé */
 #define LOCAL_CHEVELU 0x8000    /* indique un chevelu reliant 2 pins d'un meme
-				module pour le calcul des chevelus relatifs a 1 seul module */
+                                 *  module pour le calcul des chevelus relatifs a 1 seul module */
 
 class CHEVELU
 {
-public:
+private:
     int    m_NetCode;   // numero de code du net ( = 0.. n , avec 0 si non connecte)
+
+public:
     int    status;      // etat: voir defines précédents (CH_ ...)
-	D_PAD * pad_start;  // pointeur sur le pad de depart
-	D_PAD * pad_end ;	// pointeur sur le pad de fin
+    D_PAD* pad_start;   // pointeur sur le pad de depart
+    D_PAD* pad_end;     // pointeur sur le pad de fin
     int    dist;        //  longeur du chevelu
+
+    /**
+     * Function GetNet
+     * @return int - the net code.
+     */
+    int GetNet() const
+    {
+        return m_NetCode;
+    }
+    void SetNet( int aNetCode )
+    {
+        m_NetCode = aNetCode;
+    };
 };
 
-	/****************************************************************/
-	/* description d'un point de piste pour le suivi des connexions */
-	/****************************************************************/
+/****************************************************************/
+/* description d'un point de piste pour le suivi des connexions */
+/****************************************************************/
 #define START_SUR_PAD   0x10
 #define END_SUR_PAD     0x20
 #define START_SUR_TRACK 0x40
@@ -57,14 +71,13 @@ public:
 
 
 /* Status bit (OR'ed bits) for class BOARD member .m_Status_Pcb */
-enum StatusPcbFlags
-{
+enum StatusPcbFlags {
     LISTE_PAD_OK = 1,                   /* Pad list is Ok */
     LISTE_CHEVELU_OK = 2,               /* General Rastnest is Ok */
     CHEVELU_LOCAL_OK = 4,               /* current MODULE rastnest is Ok */
     CONNEXION_OK = 8,                   /* Bit indicant que la liste des connexions existe */
     NET_CODES_OK = 0x10,    /* Bit indicant que les netcodes sont OK ( pas de modif
-						de noms de net */
+                             *  de noms de net */
     DO_NOT_SHOW_GENERAL_RASTNEST = 0x20 /* Do not display the general rastnest (used in module moves) */
 };
 
@@ -73,8 +86,7 @@ enum StatusPcbFlags
 
 
 /* Commandes d'autoplacement / autorouage possibles */
-enum CommandOpt
-{
+enum CommandOpt {
     PLACE_ALL,
     PLACE_OUT_OF_BOARD,
     PLACE_INCREMENTAL,
@@ -84,7 +96,7 @@ enum CommandOpt
     ROUTE_NET,
     ROUTE_MODULE,
     ROUTE_PAD
-	};
+};
 
 /* parametre Pas de routage pour routage automatique et generation des zones */
 
@@ -129,9 +141,9 @@ typedef int DistCell;
 class BOARDHEAD  /* header of blocks of BoardCell */
 {
 public:
-	BoardCell * m_BoardSide[2]; /* ptr to block of memory: 2-sided board */
-	DistCell * m_DistSide[2];	/* ptr to block of memory: path distance to cells */
-	char * m_DirSide[2];		/* header of blocks of chars:pointers back to source */
+    BoardCell* m_BoardSide[2];  /* ptr to block of memory: 2-sided board */
+    DistCell*  m_DistSide[2];   /* ptr to block of memory: path distance to cells */
+    char*      m_DirSide[2];    /* header of blocks of chars:pointers back to source */
     bool       m_InitBoardDone;
     int        m_Layers;
     int        m_Nrows, m_Ncols;
@@ -142,10 +154,9 @@ public:
     ~BOARDHEAD();
     int     InitBoard();
     void    UnInitBoard();
-
 };
 
-eda_global BOARDHEAD Board ;		/* 2-sided board */
+eda_global BOARDHEAD Board;        /* 2-sided board */
 
 
 /* Constantes utilisees pour le trace des cellules sur le BOARD */
@@ -160,4 +171,3 @@ eda_global BOARDHEAD Board ;		/* 2-sided board */
 
 
 #endif  /* AUTOROUT_H */
-

pcbnew/block.cpp

@@ -82,8 +82,12 @@ static bool InstallBlockCmdFrame( WinEDA_BasePcbFrame* parent,
 
     parent->DrawPanel->m_IgnoreMouseEvents = TRUE;
     WinEDA_ExecBlockCmdFrame* frame = new WinEDA_ExecBlockCmdFrame( parent, title );
-    nocmd = frame->ShowModal(); frame->Destroy();
-    parent->GetScreen()->     m_Curseur = oldpos;
+    
+    nocmd = frame->ShowModal(); 
+    frame->Destroy();
+    
+    parent->GetScreen()->m_Curseur = oldpos;
+    
     parent->DrawPanel->MouseToCursorSchema();
     parent->DrawPanel->m_IgnoreMouseEvents = FALSE;
 
@@ -494,6 +498,7 @@ void WinEDA_BasePcbFrame::Block_Delete( wxDC* DC )
     masque_layer = EDGE_LAYER;
     if( Block_Include_Draw_Items )
         masque_layer = ALL_LAYERS;
+    
     if( !Block_Include_Edges_Items )
         masque_layer &= ~EDGE_LAYER;
 

pcbnew/board.cpp

@@ -200,7 +200,7 @@ void PlaceCells( BOARD* Pcb, int net_code, int flag )
     ptr = (LISTE_PAD*) Pcb->m_Pads; ii = Pcb->m_NbPads;
     for( ; ii > 0; ii--, ptr++ )
     {
-        if( (net_code != (*ptr)->m_NetCode ) || (flag & FORCE_PADS) )
+        if( (net_code != (*ptr)->GetNet() ) || (flag & FORCE_PADS) )
         {
             Place_1_Pad_Board( Pcb, *ptr, HOLE, marge, WRITE_CELL );
         }
@@ -230,7 +230,7 @@ void PlaceCells( BOARD* Pcb, int net_code, int flag )
                 TmpSegm->m_Shape   = ( (EDGE_MODULE*) PtModStruct )->m_Shape;
                 TmpSegm->m_Width   = ( (EDGE_MODULE*) PtModStruct )->m_Width;
                 TmpSegm->m_Param   = ( (EDGE_MODULE*) PtModStruct )->m_Angle;
-                TmpSegm->m_NetCode = -1;
+                TmpSegm->SetNet( -1 );
 
                 TraceSegmentPcb( Pcb, TmpSegm, HOLE, marge, WRITE_CELL );
                 TraceSegmentPcb( Pcb, TmpSegm, VIA_IMPOSSIBLE, via_marge,
@@ -270,7 +270,7 @@ void PlaceCells( BOARD* Pcb, int net_code, int flag )
             TmpSegm->m_Shape   = DrawSegm->m_Shape;
             TmpSegm->m_Width   = DrawSegm->m_Width;
             TmpSegm->m_Param   = DrawSegm->m_Angle;
-            TmpSegm->m_NetCode = -1;
+            TmpSegm->SetNet( -1 );
 
             TraceSegmentPcb( Pcb, TmpSegm, type_cell, marge, WRITE_CELL );
 
@@ -313,7 +313,7 @@ void PlaceCells( BOARD* Pcb, int net_code, int flag )
     pt_segm = Pcb->m_Track;
     for( ; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
     {
-        if( net_code == pt_segm->m_NetCode )
+        if( net_code == pt_segm->GetNet() )
             continue;
         TraceSegmentPcb( Pcb, pt_segm, HOLE, marge, WRITE_CELL );
         TraceSegmentPcb( Pcb, pt_segm, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL );
@@ -323,7 +323,7 @@ void PlaceCells( BOARD* Pcb, int net_code, int flag )
     pt_segm = (TRACK*) Pcb->m_Zone;
     for( ; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
     {
-        if( net_code == pt_segm->m_NetCode )
+        if( net_code == pt_segm->GetNet() )
             continue;
         TraceSegmentPcb( Pcb, pt_segm, HOLE, marge, WRITE_CELL );
         TraceSegmentPcb( Pcb, pt_segm, VIA_IMPOSSIBLE, via_marge, WRITE_OR_CELL );
@@ -357,7 +357,7 @@ int Build_Work( BOARD* Pcb, CHEVELU* pt_base_chevelu )
             continue;
         pt_pad = pt_rats->pad_start;
 
-        current_net_code = pt_pad->m_NetCode;
+        current_net_code = pt_pad->GetNet();
         pt_ch = pt_rats;
 
         r1 = (pt_pad->m_Pos.y - Pcb->m_BoundaryBox.m_Pos.y + demi_pas ) / g_GridRoutingSize;

pcbnew/class_board.cpp

@@ -568,7 +568,7 @@ EQUIPOT* BOARD::FindNet( int anetcode ) const
     EQUIPOT* net = (EQUIPOT*) m_Equipots;
     while( net )
     {
-        if( net->m_NetCode == anetcode )
+        if( net->GetNet() == anetcode )
             break;
         net = (EQUIPOT*) net->Pnext;
     }

pcbnew/class_board_item.cpp

@@ -33,7 +33,7 @@ wxString BOARD_ITEM::MenuText( const BOARD* aPcb ) const
     {
     case PCB_EQUIPOT_STRUCT_TYPE:
         text << _( "Net" ) << ( (EQUIPOT*) item )->m_Netname << wxT( " " ) <<
-        ( (EQUIPOT*) item )->m_NetCode;
+        ( (EQUIPOT*) item )->GetNet();
         break;
 
     case TYPEMODULE:
@@ -60,7 +60,6 @@ wxString BOARD_ITEM::MenuText( const BOARD* aPcb ) const
         break;
 
     case TYPETEXTEMODULE:
-
         switch( ( (TEXTE_MODULE*) item )->m_Type )
         {
         case TEXT_is_REFERENCE:
@@ -78,7 +77,6 @@ wxString BOARD_ITEM::MenuText( const BOARD* aPcb ) const
                  << ( (MODULE*) GetParent() )->GetReference();
             break;
         }
-
         break;
 
     case TYPEEDGEMODULE:
@@ -124,13 +122,21 @@ wxString BOARD_ITEM::MenuText( const BOARD* aPcb ) const
         break;
 
     case TYPETRACK:
+        // deleting tracks requires all the information we can get to 
+        // disambiguate all the crap under the cursor!
+        {
+            wxString txt;
+            
             text << _( "Track" ) << wxT( " " ) << ((TRACK*)item)->ShowWidth();
-        net = aPcb->FindNet( ((TRACK*)item)->m_NetCode );
+            net = aPcb->FindNet( ((TRACK*)item)->GetNet() );
             if( net )
             {
                 text << wxT( " [" ) << net->m_Netname << wxT( "]" );
             }
-        text << _( " on " ) << ReturnPcbLayerName( item->GetLayer() ).Trim();
+            text << _( " on " ) << ReturnPcbLayerName( item->GetLayer() ).Trim() 
+                 << wxT("  ") << _("Net:") << ((TRACK*)item)->GetNet()
+                 << wxT("  ") << _("Length:") << valeur_param( (int) ((TRACK*)item)->GetLength(), txt );
+        }
         break;
 
     case TYPEZONE:
@@ -140,7 +146,7 @@ wxString BOARD_ITEM::MenuText( const BOARD* aPcb ) const
             TimeStampText.Printf( wxT( "(%8.8X)" ), item->m_TimeStamp );
             text << TimeStampText;
         }
-        net = aPcb->FindNet( ( (SEGZONE*) item )->m_NetCode );
+        net = aPcb->FindNet( ( (SEGZONE*) item )->GetNet() );
         if( net )
         {
             text << wxT( " [" ) << net->m_Netname << wxT( "]" );
@@ -160,7 +166,7 @@ wxString BOARD_ITEM::MenuText( const BOARD* aPcb ) const
                 text << wxT(" ") << _("Buried");
             // else say nothing about normal vias
             
-            net = aPcb->FindNet( via->m_NetCode );
+            net = aPcb->FindNet( via->GetNet() );
             if( net )
             {
                 text << wxT( " [" ) << net->m_Netname << wxT( "]" );

pcbnew/class_equipot.cpp

@@ -25,7 +25,7 @@
 EQUIPOT::EQUIPOT( BOARD_ITEM* StructFather ) :
     BOARD_ITEM( StructFather, PCB_EQUIPOT_STRUCT_TYPE )
 {
-    m_NetCode       = 0;
+    SetNet( 0 );
     m_NbNodes       = m_NbLink = m_NbNoconn = 0;
     m_Masque_Layer  = 0;
     m_Masque_Plan   = 0;
@@ -87,7 +87,7 @@ int EQUIPOT:: ReadEquipotDescr( FILE* File, int* LineNum )
         if( strncmp( Line, "Na", 2 ) == 0 ) /* Texte */
         {
             sscanf( Line + 2, " %d", &tmp );
-            m_NetCode = tmp;
+            SetNet( tmp );
 
             ReadDelimitedText( Ltmp, Line + 2, sizeof(Ltmp) );
             m_Netname = CONV_FROM_UTF8( Ltmp );
@@ -114,7 +114,7 @@ int EQUIPOT:: WriteEquipotDescr( FILE* File )
         return 0;
 
     fprintf( File, "$EQUIPOT\n" );
-    fprintf( File, "Na %d \"%.16s\"\n", m_NetCode, CONV_TO_UTF8( m_Netname ) );
+    fprintf( File, "Na %d \"%.16s\"\n", GetNet(), CONV_TO_UTF8( m_Netname ) );
     fprintf( File, "St %s\n", "~" );
     if( m_ForceWidth )
         fprintf( File, "Lw %d\n", m_ForceWidth );
@@ -135,6 +135,6 @@ void EQUIPOT::Show( int nestLevel, std::ostream& os )
     // for now, make it look like XML:
     NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() << 
        " name=\"" <<  m_Netname.mb_str() << '"' <<
-       " netcode=\"" << m_NetCode << "\"/>\n";
+       " netcode=\"" << GetNet() << "\"/>\n";
 }
 #endif

pcbnew/class_equipot.h

@@ -7,10 +7,13 @@
 
 class EQUIPOT : public BOARD_ITEM
 {
+private:
+    int        m_NetCode;       // numero de code interne du net
+
+
 public:
     wxString   m_Netname;       // nom du net
     int        status;          // no route, hight light...
-    int        m_NetCode;       // numero de code interne du net
     int        m_NbNodes;       // nombre de pads appartenant au net
     int        m_NbLink;        // nombre de chevelus
     int        m_NbNoconn;      // nombre de chevelus actifs
@@ -32,6 +35,13 @@ public:
     int     ReadEquipotDescr( FILE* File, int* LineNum );
     int     WriteEquipotDescr( FILE* File );
 
+    /**
+     * Function GetNet
+     * @return int - the netcode
+     */
+    int GetNet() const { return m_NetCode; }
+    void SetNet( int aNetCode ) { m_NetCode = aNetCode; }
+     
     
     /**
      * Function GetClass

pcbnew/class_pad.cpp

@@ -31,7 +31,7 @@ D_PAD::D_PAD( MODULE* parent ) :
 {
     m_NumPadName   = 0;
     m_Masque_Layer = CUIVRE_LAYER;
-    m_NetCode    = 0;               /* Numero de net pour comparaisons rapides */
+    SetNet( 0 );                    /* Numero de net pour comparaisons rapides */
     m_DrillShape = CIRCLE;          // Drill shape = circle
 
     m_Size.x = m_Size.y = 500;
@@ -169,7 +169,7 @@ void D_PAD::Copy( D_PAD* source )
     m_Masque_Layer = source->m_Masque_Layer;
 
     memcpy( m_Padname, source->m_Padname, sizeof(m_Padname) );  /* nom de la pastille */
-    m_NetCode    = source->m_NetCode;                           /* Numero de net pour comparaisons rapides */
+    SetNet( source->GetNet() );                                 /* Numero de net pour comparaisons rapides */
     m_Drill      = source->m_Drill;                             // Diametre de percage
     m_DrillShape = source->m_DrillShape;
     m_Offset     = source->m_Offset;                            // Offset de la forme
@@ -737,7 +737,10 @@ int D_PAD::ReadDescr( FILE* File, int* LineNum )
             break;
 
         case 'N':       /* Lecture du netname */
-            nn = sscanf( PtLine, "%d", &m_NetCode );
+            int netcode;
+            nn = sscanf( PtLine, "%d", &netcode );
+            SetNet( netcode );
+            
             /* Lecture du netname */
             ReadDelimitedText( BufLine, PtLine, sizeof(BufLine) );
             m_Netname = CONV_FROM_UTF8( StrPurge( BufLine ) );
@@ -834,7 +837,7 @@ int D_PAD::WriteDescr( FILE* File )
     fprintf( File, "At %s N %8.8X\n", texttype, m_Masque_Layer );
     NbLigne++;
 
-    fprintf( File, "Ne %d \"%s\"\n", m_NetCode, CONV_TO_UTF8( m_Netname ) );
+    fprintf( File, "Ne %d \"%s\"\n", GetNet(), CONV_TO_UTF8( m_Netname ) );
     NbLigne++;
 
     fprintf( File, "Po %d %d\n", m_Pos0.x, m_Pos0.y );
@@ -1095,7 +1098,7 @@ void D_PAD::Show( int nestLevel, std::ostream& os )
     NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str() <<
     " num=\""       << padname << '"' <<
     " net=\""       << m_Netname.mb_str() << '"' <<
-    " netcode=\""   << m_NetCode << '"' <<
+    " netcode=\""   << GetNet() << '"' <<
     " layerMask=\"" << layerMask << '"' << m_Pos << "/>\n";
 
 //    NestedSpace( nestLevel+1, os ) << m_Text.mb_str() << '\n';

pcbnew/class_pad.h

@@ -21,6 +21,9 @@ class Pcb3D_GLCanvas;
 /* Definition type Structure d'un pad */
 class D_PAD : public BOARD_ITEM
 {
+private:
+    int     m_NetCode;              // Net number for fast comparisons
+    
 public:
     union
     {
@@ -54,7 +57,6 @@ public:
     int     m_Attribut;             // NORMAL, SMD, CONN
     int     m_Orient;               // in 1/10 degrees
 
-    int     m_NetCode;              // Net number for fast comparisons
     int     m_logical_connexion;    // variable used in rastnest computations
                                     // handle block number in ratsnet connection
 
@@ -88,6 +90,15 @@ public:
     void            ComputeRayon();                   // compute m_Rayon, rayon du cercle exinscrit
     const wxPoint   ReturnShapePos();                 // retourne la position
 
+    
+    /**
+     * Function GetNet
+     * @return int - the netcode
+     */
+    int GetNet() const { return m_NetCode; }
+    void SetNet( int aNetCode ) { m_NetCode = aNetCode; }
+     
+    
     /**
      * Function Display_Infos
      * has knowledge about the frame and how and where to put status information

pcbnew/class_track.cpp

@@ -28,8 +28,8 @@ TRACK::TRACK( BOARD_ITEM* StructFather, KICAD_T idtype ) :
     m_Width        = 0;
     m_Shape        = S_SEGMENT;
     start          = end = NULL;
-    m_NetCode      = 0;
-    m_Sous_Netcode = 0;
+    SetNet( 0 );
+    SetSubNet( 0 );
     m_Drill        = -1;
     m_Param        = 0;
 }
@@ -73,7 +73,7 @@ TRACK::TRACK( const TRACK& Source ) :
     BOARD_ITEM( Source )
 {
     m_Shape     = Source.m_Shape;
-    m_NetCode   = Source.m_NetCode;
+    SetNet( Source.GetNet() );
     m_Flags     = Source.m_Flags;
     m_TimeStamp = Source.m_TimeStamp;
     SetStatus( Source.ReturnStatus() );
@@ -81,7 +81,7 @@ TRACK::TRACK( const TRACK& Source ) :
     m_End   = Source.m_End;
     m_Width = Source.m_Width;
     m_Drill = Source.m_Drill;
-    m_Sous_Netcode = Source.m_Sous_Netcode;
+    SetSubNet( Source.GetSubNet() );
     m_Param = Source.m_Param;
 }
 
@@ -121,6 +121,21 @@ bool TRACK::IsNull()
 }
 
 
+/*************************************************************/
+double TRACK::GetLength() const
+/*************************************************************/
+{
+    int dx = m_Start.x - m_End.x;
+    int dy = m_Start.y - m_End.y;
+
+    double dist = ( (double) dx * dx ) + ( (double) dy * dy );
+    
+    dist = sqrt( dist );
+    
+    return dist;
+}
+
+
 /*************************************************************/
 int TRACK::IsPointOnEnds( const wxPoint& point, int min_dist )
 /*************************************************************/
@@ -133,14 +148,14 @@ int TRACK::IsPointOnEnds( const wxPoint& point, int min_dist )
  *  if min_dist < 0: min_dist = track_width/2
  */
 {
-    int dx, dy;
     int result = 0;
 
     if( min_dist < 0 )
         min_dist = m_Width / 2;
 
-    dx = m_Start.x - point.x;
-    dy = m_Start.y - point.y;
+    int dx = m_Start.x - point.x;
+    int dy = m_Start.y - point.y;
+    
     if( min_dist == 0 )
     {
         if( (dx == 0) && (dy == 0 ) )
@@ -410,12 +425,12 @@ TRACK* TRACK::GetBestInsertPoint( BOARD* Pcb )
     /* Traitement du debut de liste */
     if( track == NULL )
         return NULL;                    /* pas de piste ! */
-    if( m_NetCode < track->m_NetCode )  /* insertion en tete de liste */
+    if( GetNet() < track->GetNet() )  /* insertion en tete de liste */
         return NULL;
 
     while( (NextTrack = (TRACK*) track->Pnext) != NULL )
     {
-        if( NextTrack->m_NetCode > this->m_NetCode )
+        if( NextTrack->GetNet() > this->GetNet() )
             break;
         track = NextTrack;
     }
@@ -436,16 +451,19 @@ TRACK* TRACK::GetStartNetCode( int NetCode )
     int    ii    = 0;
 
     if( NetCode == -1 )
-        NetCode = m_NetCode;
+        NetCode = GetNet();
 
     while( Track != NULL )
     {
-        if( Track->m_NetCode > NetCode )
+        if( Track->GetNet() > NetCode )
             break;
-        if( Track->m_NetCode == NetCode )
+        
+        if( Track->GetNet() == NetCode )
         {
-            ii++; break;
+            ii++; 
+            break;
         }
+        
         Track = (TRACK*) Track->Pnext;
     }
 
@@ -468,17 +486,20 @@ TRACK* TRACK::GetEndNetCode( int NetCode )
         return NULL;
 
     if( NetCode == -1 )
-        NetCode = m_NetCode;
+        NetCode = GetNet();
 
     while( Track != NULL )
     {
         NextS = (TRACK*) Track->Pnext;
-        if( Track->m_NetCode == NetCode )
+        if( Track->GetNet() == NetCode )
             ii++;
+        
         if( NextS == NULL )
             break;
-        if( NextS->m_NetCode > NetCode )
+        
+        if( NextS->GetNet() > NetCode )
             break;
+        
         Track = NextS;
     }
 
@@ -539,7 +560,7 @@ bool TRACK::WriteTrackDescr( FILE* File )
              m_Start.x, m_Start.y, m_End.x, m_End.y, m_Width, m_Drill );
 
     fprintf( File, "De %d %d %d %lX %X\n",
-            m_Layer, type, m_NetCode,
+            m_Layer, type, GetNet(),
             m_TimeStamp, ReturnStatus() );
     
     return TRUE;
@@ -724,7 +745,7 @@ void TRACK::Display_Infos( WinEDA_DrawFrame* frame )
       || Type() == TYPEZONE
       || Type() == TYPEVIA )
     {
-        EQUIPOT* equipot = ((WinEDA_PcbFrame*)frame)->m_Pcb->FindNet( m_NetCode );
+        EQUIPOT* equipot = ((WinEDA_PcbFrame*)frame)->m_Pcb->FindNet( GetNet() );
         
         if( equipot )
             msg = equipot->m_Netname;
@@ -734,7 +755,7 @@ void TRACK::Display_Infos( WinEDA_DrawFrame* frame )
         Affiche_1_Parametre( frame, text_pos, _( "NetName" ), msg, RED );
 
         /* Affiche net code :*/
-        msg.Printf( wxT( "%d .%d" ), m_NetCode, m_Sous_Netcode );
+        msg.Printf( wxT( "%d .%d" ), GetNet(), GetSubNet() );
         text_pos += 18;
         Affiche_1_Parametre( frame, text_pos, _( "NetCode" ), msg, RED );
     }
@@ -861,7 +882,7 @@ void TRACK::Show( int nestLevel, std::ostream& os )
         " layer=\""     << m_Layer      << '"' <<
         " width=\""     << m_Width      << '"' <<
 //        " drill=\""     << m_Drill      << '"' <<
-        " netcode=\""   << m_NetCode    << "\">" <<
+        " netcode=\""   << GetNet()    << "\">" <<
         "<start"        << m_Start      << "/>" <<
         "<end"          << m_End        << "/>";
         
@@ -900,7 +921,7 @@ void SEGVIA::Show( int nestLevel, std::ostream& os )
                         << ReturnPcbLayerName( botLayer ).Trim().mb_str() << '"' <<
         " width=\""     << m_Width      << '"' <<
         " drill=\""     << m_Drill      << '"' <<
-        " netcode=\""   << m_NetCode    << "\">" <<
+        " netcode=\""   << GetNet()    << "\">" <<
         "<pos"          << m_Start      << "/>";
         
     os << "</" << GetClass().Lower().mb_str() << ">\n"; 

pcbnew/class_track.h

@@ -32,14 +32,14 @@ public:
     BOARD_ITEM*     start;          // pointers on a connected item (pad or track)
     BOARD_ITEM*     end;            
     
-    int             m_NetCode;      // Net number
-    int             m_Sous_Netcode; /* In rastnest routines : for the current net,
-                                     *  block number (number common to the current connected items found) */
-
     // chain = 0 indique une connexion non encore traitee
     int             m_Param;        // Auxiliary variable ( used in some computations )
 
 protected:    
+    int             m_NetCode;      // Net number
+    int             m_Sous_Netcode; /* In rastnest routines : for the current net,
+                                     *  block number (number common to the current connected items found) */
+
     TRACK( const TRACK& track );    // protected so Copy() is used instead.
     
 public:
@@ -90,6 +90,30 @@ public:
     /* Recherche de la fin du net */
     TRACK*  GetEndNetCode( int NetCode );
 
+    /**
+     * Function GetNet
+     * @return int - the net code.
+     */
+    int GetNet() const { return m_NetCode; }
+    void SetNet( int aNetCode ) { m_NetCode = aNetCode; }
+
+
+    /**
+     * Function GetSubNet
+     * @return int - the sub net code.
+     */
+    int GetSubNet() const { return m_Sous_Netcode; }
+    void SetSubNet( int aSubNetCode ) { m_Sous_Netcode = aSubNetCode; }
+
+    
+    /**
+     * Function GetLength
+     * returns the length of the track using the hypotenuse calculation.
+     * @return double - the length of the track
+     */
+    double GetLength() const;
+    
+    
     /* Display on screen: */
     void    Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode );
 

pcbnew/clean.cpp

@@ -207,9 +207,9 @@ static void suppression_piste_non_connectee( WinEDA_PcbFrame* frame, wxDC* DC )
         if( frame->DrawPanel->m_AbortRequest )
             break;
 
-        if( PtSegm->m_NetCode != oldnetcode )
+        if( PtSegm->GetNet() != oldnetcode )
         {
-            PtStartNetCode = PtSegm; oldnetcode = PtSegm->m_NetCode;
+            PtStartNetCode = PtSegm; oldnetcode = PtSegm->GetNet();
         }
 
         flag_erase = 0; type_end = 0;
@@ -381,7 +381,7 @@ static int clean_segments( WinEDA_PcbFrame* frame, wxDC* DC )
                 continue;
             if( PtSegm->GetLayer() != pt_aux->GetLayer() )
                 continue;
-            if( PtSegm->m_NetCode != pt_aux->m_NetCode )
+            if( PtSegm->GetNet() != pt_aux->GetNet() )
                 break;
 
             if( (PtSegm->m_Start.x == pt_aux->m_Start.x )
@@ -676,14 +676,14 @@ int Netliste_Controle_piste( WinEDA_PcbFrame* frame, wxDC* DC, int affiche )
         net_code_s = -1;
         if( (PtSegm->start != NULL)
            && ( ( (EDA_BaseStruct*) (PtSegm->start) )->Type() == TYPEPAD ) )
-            net_code_s = ( (D_PAD*) (PtSegm->start) )->m_NetCode;
+            net_code_s = ( (D_PAD*) (PtSegm->start) )->GetNet();
 
         else
         {
             pt_aux = Locate_Piste_Connectee( PtSegm, frame->m_Pcb->m_Track,
                                              NULL, START );
             if( pt_aux )
-                net_code_s = pt_aux->m_NetCode;
+                net_code_s = pt_aux->GetNet();
         }
         if( net_code_s < 0 )
             continue;/* Extremite en l'air */
@@ -692,14 +692,14 @@ int Netliste_Controle_piste( WinEDA_PcbFrame* frame, wxDC* DC, int affiche )
         net_code_e = -1;
         if( (PtSegm->end != NULL)
          && ( ( (EDA_BaseStruct*) (PtSegm->end) )->Type() == TYPEPAD ) )
-            net_code_e = ( (D_PAD*) (PtSegm->end) )->m_NetCode;
+            net_code_e = ( (D_PAD*) (PtSegm->end) )->GetNet();
 
         else
         {
             pt_aux = Locate_Piste_Connectee( PtSegm, frame->m_Pcb->m_Track,
                                              NULL, END );
             if( pt_aux )
-                net_code_e = pt_aux->m_NetCode;
+                net_code_e = pt_aux->GetNet();
         }
 
         if( net_code_e < 0 )

pcbnew/controle.cpp

@@ -268,6 +268,11 @@ void WinEDA_BasePcbFrame::GeneralControle( wxDC* DC, wxPoint Mouse )
     if( delta.y <= 0 )
         delta.y = 1;
 
+#if 0 && defined(DEBUG)
+    printf( "delta.x=%d delta.y=%d grid.x=%d, grid.y=%d, zoom=%d\n", 
+           delta.x, delta.y, GetScreen()->GetGrid().x, GetScreen()->GetGrid().y, zoom );
+#endif
+    
     switch( g_KeyPressed )
     {
     case EDA_PANNING_UP_KEY:

pcbnew/cross-probing.cpp

@@ -85,7 +85,7 @@ void RemoteCommand(  const char* cmdline )
             pad = ReturnPad( module, pinName );
 
         if( pad )
-            netcode = pad->m_NetCode;
+            netcode = pad->GetNet();
 
         if( netcode > 0 )               /* hightlighted the net selected net*/
         {

pcbnew/deltrack.cpp

@@ -110,7 +110,7 @@ TRACK* WinEDA_PcbFrame::Delete_Segment( wxDC* DC, TRACK* Track )
     } // Fin traitement si trace en cours
 
 
-    current_net_code = Track->m_NetCode;
+    current_net_code = Track->GetNet();
     Track->Draw( DrawPanel, DC, GR_XOR );
 
     SaveItemEfface( Track, 1 );
@@ -128,7 +128,7 @@ void WinEDA_PcbFrame::Delete_Track( wxDC* DC, TRACK* Track )
 {
     if( Track != NULL )
     {
-        int current_net_code = Track->m_NetCode;
+        int current_net_code = Track->GetNet();
         Supprime_Une_Piste( DC, Track );
         GetScreen()->SetModify();
         test_1_net_connexion( DC, current_net_code );
@@ -152,7 +152,7 @@ void WinEDA_PcbFrame::Delete_net( wxDC* DC, TRACK* Track )
 
     if( IsOK( this, _( "Delete NET ?" ) ) )
     {
-        net_code_delete = pt_segm->m_NetCode;
+        net_code_delete = pt_segm->GetNet();
         /* Recherche du debut de la zone des pistes du net_code courant */
         pt_start = m_Pcb->m_Track->GetStartNetCode( net_code_delete );
 
@@ -160,7 +160,7 @@ void WinEDA_PcbFrame::Delete_net( wxDC* DC, TRACK* Track )
         pt_segm = pt_start;
         for( ii = 0; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
         {
-            if( pt_segm->m_NetCode != net_code_delete )
+            if( pt_segm->GetNet() != net_code_delete )
                 break;
             ii++;
         }

pcbnew/dragsegm.cpp

@@ -109,7 +109,7 @@ void Build_1_Pad_SegmentsToDrag(WinEDA_DrawPanel * panel, wxDC * DC, D_PAD * PtP
 */
 {
 TRACK * Track;
-int net_code = PtPad->m_NetCode;
+int net_code = PtPad->GetNet();
 int MasqueLayer;
 wxPoint pos;
 BOARD * pcb = ((WinEDA_BasePcbFrame*)(panel->m_Parent))->m_Pcb;
@@ -120,7 +120,7 @@ BOARD * pcb = ((WinEDA_BasePcbFrame*)(panel->m_Parent))->m_Pcb;
 	MasqueLayer = PtPad->m_Masque_Layer;
 	for( ; Track != NULL; Track = (TRACK*)Track->Pnext )
 	{
-		if( Track->m_NetCode != net_code ) break;	/* hors zone */
+		if( Track->GetNet() != net_code ) break;	/* hors zone */
 		if( (MasqueLayer & Track->ReturnMaskLayer()) == 0 ) continue; /* couches differentes */
 		if( pos == Track->m_Start )
 		{
@@ -172,7 +172,7 @@ BOARD * pcb = ((WinEDA_BasePcbFrame*)(panel->m_Parent))->m_Pcb;
 
 	for( ; Track != NULL; Track = (TRACK*)Track->Pnext )
 	{
-		if( Track->m_NetCode != net_code ) break;	/* hors zone */
+		if( Track->GetNet() != net_code ) break;	/* hors zone */
 		if( (MasqueLayer & Track->ReturnMaskLayer()) == 0 ) continue; /* couches differentes */
 		if ( Track->m_Flags & IS_DRAGGED) continue;		// already in list
 		if( Track->m_Start == point )

pcbnew/edit.cpp

@@ -337,7 +337,7 @@ void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
     case ID_POPUP_PCB_EDIT_NET:
         if( GetCurItem() == NULL )
             break;
-        Edit_Net_Width( &dc, ( (TRACK*) GetCurItem() )->m_NetCode );
+        Edit_Net_Width( &dc, ( (TRACK*) GetCurItem() )->GetNet() );
         DrawPanel->MouseToCursorSchema();
         GetScreen()->SetModify();
         break;
@@ -427,11 +427,11 @@ void WinEDA_PcbFrame::Process_Special_Functions( wxCommandEvent& event )
         break;
 
     case ID_POPUP_PCB_LOCK_ON_NET:
-        Attribut_net( &dc, ( (TRACK*) GetCurItem() )->m_NetCode, TRUE );
+        Attribut_net( &dc, ( (TRACK*) GetCurItem() )->GetNet(), TRUE );
         break;
 
     case ID_POPUP_PCB_LOCK_OFF_NET:
-        Attribut_net( &dc, ( (TRACK*) GetCurItem() )->m_NetCode, FALSE );
+        Attribut_net( &dc, ( (TRACK*) GetCurItem() )->GetNet(), FALSE );
         break;
 
     case ID_POPUP_PCB_SETFLAGS_TRACK_MNU:

pcbnew/edit_track_width.cpp

@@ -87,7 +87,7 @@ int nb_segm_non_modifies = 0;
 	/* balayage des segments */
 	for( pt_segm = m_Pcb->m_Track; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
 		{
-		if ( Netcode != pt_segm->m_NetCode ) /* mauvaise piste */
+		if ( Netcode != pt_segm->GetNet() ) /* mauvaise piste */
 			continue ;
 		/* piste d'un net trouvee */
 		errdrc = Edit_TrackSegm_Width(DC, pt_segm);

pcbnew/editrack-part2.cpp

@@ -146,7 +146,7 @@ void WinEDA_PcbFrame::ExChange_Track_Layer( TRACK* pt_segm, wxDC* DC )
         pt_segm->end   = Locate_Pad_Connecte( m_Pcb, pt_segm, END );
     }
 
-    test_1_net_connexion( DC, pt_track->m_NetCode );
+    test_1_net_connexion( DC, pt_track->GetNet() );
     pt_track->Display_Infos( this );
     GetScreen()->SetModify();
 }
@@ -219,7 +219,7 @@ void WinEDA_PcbFrame::Other_Layer_Route( TRACK* track, wxDC* DC )
     Via->m_Flags   = IS_NEW;
     Via->m_Width   = g_DesignSettings.m_CurrentViaSize;
     Via->m_Shape   = g_DesignSettings.m_CurrentViaType;
-    Via->m_NetCode = g_HightLigth_NetCode;
+    Via->SetNet( g_HightLigth_NetCode );
     Via->m_Start   = Via->m_End = g_CurrentTrackSegment->m_End;
 
     int old_layer = GetScreen()->m_Active_Layer;
@@ -321,7 +321,7 @@ void WinEDA_PcbFrame::Affiche_Status_Net( wxDC* DC )
     if( pt_segm == NULL )
         m_Pcb->Display_Infos( this );
     else
-        test_1_net_connexion( DC, pt_segm->m_NetCode );
+        test_1_net_connexion( DC, pt_segm->GetNet() );
 }
 
 
@@ -362,7 +362,7 @@ void WinEDA_PcbFrame::Show_1_Ratsnest( EDA_BaseStruct* item, wxDC* DC )
             pt_chevelu = (CHEVELU*) m_Pcb->m_Ratsnest;
             for( ii = m_Pcb->GetNumRatsnests(); ii > 0; pt_chevelu++, ii-- )
             {
-                if( pt_chevelu->m_NetCode == pt_pad->m_NetCode )
+                if( pt_chevelu->GetNet() == pt_pad->GetNet() )
                 {
                     if( (pt_chevelu->status & CH_VISIBLE) != 0 )
                         continue;

pcbnew/editrack.cpp

@@ -119,12 +119,12 @@ TRACK* WinEDA_PcbFrame::Begin_Route( TRACK* track, wxDC* DC )
                 
                 /* le debut de la piste est remis sur le centre du pad */
                 pos = pt_pad->m_Pos;
-                g_HightLigth_NetCode = pt_pad->m_NetCode;
+                g_HightLigth_NetCode = pt_pad->GetNet();
             }
             else /* le point d'accrochage est un segment */
             {
                 adr_buf = (TRACK*) LockPoint;
-                g_HightLigth_NetCode = adr_buf->m_NetCode;
+                g_HightLigth_NetCode = adr_buf->GetNet();
                 CreateLockPoint( &pos.x, &pos.y, adr_buf, NULL );
             }
         }
@@ -137,7 +137,7 @@ TRACK* WinEDA_PcbFrame::Begin_Route( TRACK* track, wxDC* DC )
         g_CurrentTrackSegment->m_Width   = g_DesignSettings.m_CurrentTrackWidth;
         g_CurrentTrackSegment->m_Start   = pos;
         g_CurrentTrackSegment->m_End     = g_CurrentTrackSegment->m_Start;
-        g_CurrentTrackSegment->m_NetCode = g_HightLigth_NetCode;
+        g_CurrentTrackSegment->SetNet( g_HightLigth_NetCode );
         if( pt_pad )
         {
             g_CurrentTrackSegment->start = pt_pad;
@@ -418,7 +418,7 @@ void WinEDA_PcbFrame::End_Route( TRACK* track, wxDC* DC )
                  *  peut-etre creer un point d'ancrage */
         {
             adr_buf = (TRACK*) LockPoint;
-            g_HightLigth_NetCode = adr_buf->m_NetCode;
+            g_HightLigth_NetCode = adr_buf->GetNet();
             /* creation eventuelle d'un point d'accrochage */
             LockPoint = CreateLockPoint( &g_CurrentTrackSegment->m_End.x,
                                          &g_CurrentTrackSegment->m_End.y,
@@ -458,7 +458,7 @@ void WinEDA_PcbFrame::End_Route( TRACK* track, wxDC* DC )
         }
 
         /* compute the new rastnest : */
-        test_1_net_connexion( DC, g_FirstTrackSegment->m_NetCode );
+        test_1_net_connexion( DC, g_FirstTrackSegment->GetNet() );
 
         GetScreen()->SetModify();
         m_Pcb->Display_Infos( this );

pcbnew/editrout.cpp

@@ -85,7 +85,7 @@ int nb_segm_non_modifies = 0;
 	/* balayage des segments */
 	for( pt_segm = m_Pcb->m_Track; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
 		{
-		if ( Netcode != pt_segm->m_NetCode ) /* mauvaise piste */
+		if ( Netcode != pt_segm->GetNet() ) /* mauvaise piste */
 			continue ;
 		/* piste d'un net trouvee */
 		errdrc = Edit_TrackSegm_Width(DC, pt_segm);

pcbnew/export_gencad.cpp

@@ -476,7 +476,7 @@ void CreateSignalsSection( FILE* file, BOARD* pcb )
             equipot->m_Netname << wxT( "NoConnection" ) << NbNoConn++;
         }
 
-        if( equipot->m_NetCode <= 0 )  // dummy equipot (non connexion)
+        if( equipot->GetNet() <= 0 )  // dummy equipot (non connexion)
             continue;
 
         msg = wxT( "\nSIGNAL " ) + equipot->m_Netname;
@@ -487,7 +487,7 @@ void CreateSignalsSection( FILE* file, BOARD* pcb )
             for( pad = module->m_Pads; pad != NULL; pad = (D_PAD*) pad->Pnext )
             {
                 wxString padname;
-                if( pad->m_NetCode != equipot->m_NetCode )
+                if( pad->GetNet() != equipot->GetNet() )
                     continue;
                 pad->ReturnStringPadName( padname );
                 msg.Printf( wxT( "NODE %s %.4s" ),
@@ -545,7 +545,7 @@ static int Track_list_Sort_by_Netcode( const void* refptr, const void* objptr )
 
     ref = *( (TRACK**) refptr );
     cmp = *( (TRACK**) objptr );
-    if( (diff = ref->m_NetCode - cmp->m_NetCode) )
+    if( (diff = ref->GetNet() - cmp->GetNet()) )
         return diff;
     if( (diff = ref->m_Width - cmp->m_Width) )
         return diff;
@@ -606,10 +606,10 @@ void CreateRoutesSection( FILE* file, BOARD* pcb )
     for( ii = 0; ii < nbitems; ii++ )
     {
         track = tracklist[ii];
-        if( old_netcode != track->m_NetCode )
+        if( old_netcode != track->GetNet() )
         {
-            old_netcode = track->m_NetCode;
-            EQUIPOT* equipot = pcb->FindNet( track->m_NetCode );
+            old_netcode = track->GetNet();
+            EQUIPOT* equipot = pcb->FindNet( track->GetNet() );
             wxString netname;
             if( equipot && (equipot->m_Netname != wxEmptyString) )
                 netname = equipot->m_Netname;

pcbnew/ioascii.cpp

@@ -177,7 +177,7 @@ int WinEDA_BasePcbFrame::ReadListeSegmentDescr( wxDC* DC, FILE* File,
             PtSegm->m_Drill = -1;
 
         PtSegm->SetLayer( layer );
-        PtSegm->m_NetCode = net_code; 
+        PtSegm->SetNet( net_code ); 
         PtSegm->SetState( flags, ON );
         
 #ifdef PCBNEW
@@ -356,7 +356,8 @@ int WinEDA_BasePcbFrame::ReadSetup( FILE* File, int* LineNum )
             data = strtok( NULL, " =\n\r" );
             if( data )
                 gy = atoi( data );
-            m_Auxiliary_Axis_Position.x = gx; m_Auxiliary_Axis_Position.y = gy;
+            m_Auxiliary_Axis_Position.x = gx; 
+            m_Auxiliary_Axis_Position.y = gy;
             continue;
         }
 #ifdef PCBNEW

pcbnew/modules.cpp

@@ -499,6 +499,7 @@ void WinEDA_BasePcbFrame::Change_Side_Module( MODULE* Module, wxDC* DC )
         if( DC )
         {
             Module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
+            
             /* affichage chevelu general si necessaire */
             ReCompile_Ratsnest_After_Changes( DC );
         }
@@ -730,6 +731,7 @@ void WinEDA_BasePcbFrame::Rotate_Module( wxDC* DC, MODULE* module,
         if( !(module->m_Flags & IS_MOVED) ) /* Rotation simple */
         {
             module->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
+            
             /* Reaffichage chevelu general si necessaire */
             ReCompile_Ratsnest_After_Changes( DC );
         }

pcbnew/move_copy_track.cpp

@@ -194,7 +194,7 @@ void WinEDA_PcbFrame::Start_MoveOneTrackSegment( TRACK* track, wxDC* DC, bool Dr
     {
         track->m_Flags = IS_DRAGGED | STARTPOINT | ENDPOINT;
         Collect_TrackSegmentsToDrag( DrawPanel, DC, track->m_Start,
-                                     track->ReturnMaskLayer(), track->m_NetCode );
+                                     track->ReturnMaskLayer(), track->GetNet() );
         NewTrack     = track;
         NbPtNewTrack = 1;
         PosInit = track->m_Start;
@@ -204,7 +204,7 @@ void WinEDA_PcbFrame::Start_MoveOneTrackSegment( TRACK* track, wxDC* DC, bool Dr
         int     diag = track->IsPointOnEnds( GetScreen()->m_Curseur, -1 );
         wxPoint pos  = (diag & STARTPOINT) ? track->m_Start : track->m_End;
         Collect_TrackSegmentsToDrag( DrawPanel, DC, pos,
-                                     track->ReturnMaskLayer(), track->m_NetCode );
+                                     track->ReturnMaskLayer(), track->GetNet() );
         track->m_Flags |= IS_DRAGGED;
         NewTrack     = NULL;
         NbPtNewTrack = 0;
@@ -214,7 +214,7 @@ void WinEDA_PcbFrame::Start_MoveOneTrackSegment( TRACK* track, wxDC* DC, bool Dr
     DrawPanel->ManageCurseur = Show_MoveTrack;
     DrawPanel->ForceCloseManageCurseur = Exit_MoveTrack;
 
-    g_HightLigth_NetCode = track->m_NetCode;
+    g_HightLigth_NetCode = track->GetNet();
     g_HightLigt_Status   = TRUE;
     DrawHightLight( DC, g_HightLigth_NetCode );
     DrawPanel->ManageCurseur( DrawPanel, DC, TRUE );

pcbnew/move_or_drag_track.cpp

@@ -618,7 +618,7 @@ void WinEDA_PcbFrame::Start_MoveOneNodeOrSegment( TRACK* track, wxDC* DC, int co
         if( command != ID_POPUP_PCB_MOVE_TRACK_SEGMENT )
         {
             Collect_TrackSegmentsToDrag( DrawPanel, DC, track->m_Start,
-                                         track->ReturnMaskLayer(), track->m_NetCode );
+                                         track->ReturnMaskLayer(), track->GetNet() );
         }
         NewTrack     = track;
         NbPtNewTrack = 1;
@@ -639,17 +639,17 @@ void WinEDA_PcbFrame::Start_MoveOneNodeOrSegment( TRACK* track, wxDC* DC, int co
         case ID_POPUP_PCB_DRAG_TRACK_SEGMENT:
             pos = track->m_Start;
             Collect_TrackSegmentsToDrag( DrawPanel, DC, pos,
-                                         track->ReturnMaskLayer(), track->m_NetCode );
+                                         track->ReturnMaskLayer(), track->GetNet() );
             pos = track->m_End;
             track->m_Flags |= IS_DRAGGED | ENDPOINT | STARTPOINT;
             Collect_TrackSegmentsToDrag( DrawPanel, DC, pos,
-                                         track->ReturnMaskLayer(), track->m_NetCode );
+                                         track->ReturnMaskLayer(), track->GetNet() );
             break;
 
         case ID_POPUP_PCB_MOVE_TRACK_NODE:
             pos = (diag & STARTPOINT) ? track->m_Start : track->m_End;
             Collect_TrackSegmentsToDrag( DrawPanel, DC, pos,
-                                         track->ReturnMaskLayer(), track->m_NetCode );
+                                         track->ReturnMaskLayer(), track->GetNet() );
             PosInit = pos;
             break;
         }
@@ -660,7 +660,7 @@ void WinEDA_PcbFrame::Start_MoveOneNodeOrSegment( TRACK* track, wxDC* DC, int co
     DrawPanel->ManageCurseur = Show_MoveNode;
     DrawPanel->ForceCloseManageCurseur = Abort_MoveTrack;
 
-    g_HightLigth_NetCode = track->m_NetCode;
+    g_HightLigth_NetCode = track->GetNet();
     g_HightLigt_Status   = TRUE;
     DrawHightLight( DC, g_HightLigth_NetCode );
     DrawPanel->ManageCurseur( DrawPanel, DC, TRUE );
@@ -753,7 +753,7 @@ void WinEDA_PcbFrame::Start_DragTrackSegmentAndKeepSlope( TRACK* track, wxDC* DC
     DrawPanel->ManageCurseur = Show_Drag_Track_Segment_With_Cte_Slope;
     DrawPanel->ForceCloseManageCurseur = Abort_MoveTrack;
 
-    g_HightLigth_NetCode = track->m_NetCode;
+    g_HightLigth_NetCode = track->GetNet();
     g_HightLigt_Status   = TRUE;
     DrawHightLight( DC, g_HightLigth_NetCode );
 
@@ -778,7 +778,7 @@ bool WinEDA_PcbFrame::PlaceDraggedTrackSegment( TRACK* Track, wxDC* DC )
     if( Track == NULL )
         return FALSE;
 
-    int current_net_code = Track->m_NetCode;
+    int current_net_code = Track->GetNet();
 
     // DRC control:
     if( Drc_On )

pcbnew/router.cpp

@@ -162,7 +162,7 @@ static void Out_Pads( BOARD* Pcb, FILE* outfile )
     if( pt_liste_pad == NULL )
         return;
 
-    netcode = (*pt_liste_pad)->m_NetCode;
+    netcode = (*pt_liste_pad)->GetNet();
     nb_pads = 1; plink = 0;
     for( ; pt_liste_pad < pt_liste_pad_limite; )
     {
@@ -171,7 +171,7 @@ static void Out_Pads( BOARD* Pcb, FILE* outfile )
         {
             if( pt_end_liste >= pt_liste_pad_limite )
                 break;
-            if( (*pt_end_liste)->m_NetCode != netcode )
+            if( (*pt_end_liste)->GetNet() != netcode )
                 break;
             nb_pads++;
         }
@@ -197,7 +197,7 @@ static void Out_Pads( BOARD* Pcb, FILE* outfile )
         for( ; pt_liste_pad < pt_end_liste; pt_liste_pad++ )
         {
             pt_pad  = *pt_liste_pad;
-            netcode = pt_pad->m_NetCode;
+            netcode = pt_pad->GetNet();
             plink   = pt_pad->m_physical_connexion;
             /* plink = numero unique si pad non deja connecte a une piste */
             if( plink <= 0 )
@@ -308,7 +308,7 @@ static void Out_Pads( BOARD* Pcb, FILE* outfile )
         nb_pads      = 1;
         pt_liste_pad = pt_start_liste = pt_end_liste;
         if( pt_start_liste < pt_liste_pad_limite )
-            netcode = (*pt_start_liste)->m_NetCode;
+            netcode = (*pt_start_liste)->GetNet();
     }
 }
 
@@ -332,9 +332,9 @@ static void ReturnNbViasAndTracks( BOARD* Pcb, int netcode, int* nb_vias,
 
     for( ; track != NULL; track = (TRACK*) track->Pnext )
     {
-        if( track->m_NetCode > netcode )
+        if( track->GetNet() > netcode )
             return;
-        if( track->m_NetCode != netcode )
+        if( track->GetNet() != netcode )
             continue;
         if( track->Type() == TYPEVIA )
             (*nb_vias)++;
@@ -362,12 +362,12 @@ static void GenExistantTracks( BOARD* Pcb, FILE* outfile,
 
     for( ; track != NULL; track = (TRACK*) track->Pnext )
     {
-        netcode = track->m_NetCode;
+        netcode = track->GetNet();
         if( netcode > current_net_code )
             return;
         if( netcode != current_net_code )
             continue;
-        plink = track->m_Sous_Netcode;
+        plink = track->GetSubNet();
         via_min_layer = track->GetLayer();
 
         if( track->Type() != type )

pcbnew/solve.cpp

@@ -361,7 +361,7 @@ static int Route_1_Trace( WinEDA_PcbFrame* pcbframe, wxDC* DC,
     masque_layers = masque_layer_TOP | masque_layer_BOTTOM;
 
     pt_cur_ch = pt_chevelu;
-    current_net_code   = pt_chevelu->m_NetCode;
+    current_net_code   = pt_chevelu->GetNet();
     pad_masque_layer_s = pt_cur_ch->pad_start->m_Masque_Layer;
     pad_masque_layer_e = pt_cur_ch->pad_end->m_Masque_Layer;
 
@@ -936,7 +936,7 @@ static void OrCell_Trace( BOARD* pcb, int col, int row,
                                                (g_GridRoutingSize * col);
         g_CurrentTrackSegment->m_Width   = g_DesignSettings.m_CurrentViaSize;
         g_CurrentTrackSegment->m_Shape   = g_DesignSettings.m_CurrentViaType;
-        g_CurrentTrackSegment->m_NetCode = current_net_code;
+        g_CurrentTrackSegment->SetNet( current_net_code );
     }
     else    /* Placement d'un segment standard */
     {
@@ -958,7 +958,7 @@ static void OrCell_Trace( BOARD* pcb, int col, int row,
         g_CurrentTrackSegment->SetState( SEGM_AR, ON );
         g_CurrentTrackSegment->m_End.x   = pcb->m_BoundaryBox.m_Pos.x + (g_GridRoutingSize * row);
         g_CurrentTrackSegment->m_End.y   = pcb->m_BoundaryBox.m_Pos.y + (g_GridRoutingSize * col);
-        g_CurrentTrackSegment->m_NetCode = current_net_code;
+        g_CurrentTrackSegment->SetNet( current_net_code );
 
         if( g_CurrentTrackSegment->Pback == NULL ) /* Start Piste */
         {
@@ -1090,7 +1090,7 @@ static void Place_Piste_en_Buffer( WinEDA_PcbFrame* pcbframe, wxDC* DC )
 
     Trace_Une_Piste( panel, DC, g_FirstTrackSegment, g_TrackSegmentCount, GR_OR );
 
-    pcbframe->test_1_net_connexion( DC, g_FirstTrackSegment->m_NetCode );
+    pcbframe->test_1_net_connexion( DC, g_FirstTrackSegment->GetNet() );
 
     /* Trace de la forme exacte de la piste en BOARD */
     for( pt_track = g_FirstTrackSegment; ; pt_track = (TRACK*) pt_track->Pnext )

pcbnew/surbrill.cpp

@@ -46,7 +46,7 @@ void WinEDA_PcbFrame::Liste_Equipot( wxCommandEvent& event )
         if( !WildCompareString( msg, Equipot->m_Netname, FALSE ) )
             continue;
 
-        Line.Printf( wxT( "net_code = %3.3d  [%.16s] " ), Equipot->m_NetCode,
+        Line.Printf( wxT( "net_code = %3.3d  [%.16s] " ), Equipot->GetNet(),
                     Equipot->m_Netname.GetData() );
         List->Append( Line );
     }
@@ -64,7 +64,7 @@ void WinEDA_PcbFrame::Liste_Equipot( wxCommandEvent& event )
             continue;
         if( ii == jj )
         {
-            ii = Equipot->m_NetCode;
+            ii = Equipot->GetNet();
             break;
         }
         jj++;
@@ -99,7 +99,7 @@ int WinEDA_PcbFrame::Select_High_Light( wxDC* DC )
     pt_piste = Locate_Pistes( m_Pcb->m_Track, masquelayer, CURSEUR_OFF_GRILLE );
     if( pt_piste )
     {
-        code = g_HightLigth_NetCode = pt_piste->m_NetCode;
+        code = g_HightLigth_NetCode = pt_piste->GetNet();
         Hight_Light( DC );
     }
     else
@@ -107,7 +107,7 @@ int WinEDA_PcbFrame::Select_High_Light( wxDC* DC )
         pt_pad = Locate_Any_Pad( m_Pcb, CURSEUR_OFF_GRILLE );
         if( pt_pad != NULL )
         {
-            code = g_HightLigth_NetCode = pt_pad->m_NetCode;
+            code = g_HightLigth_NetCode = pt_pad->GetNet();
             Hight_Light( DC );
             SendMessageToEESCHEMA( pt_pad );
         }
@@ -157,7 +157,7 @@ void WinEDA_PcbFrame::DrawHightLight( wxDC* DC, int NetCode )
     /* Redraw track and vias: */
     for( pts = m_Pcb->m_Track; pts != NULL; pts = (TRACK*) pts->Pnext )
     {
-        if( pts->m_NetCode == NetCode )
+        if( pts->GetNet() == NetCode )
         {
             pts->Draw( DrawPanel, DC, draw_mode );
         }
@@ -176,7 +176,7 @@ static void Pad_Surbrillance( WinEDA_DrawPanel* panel,
     /* trace des pastilles */
     for( pt_pad = Module->m_Pads; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
     {
-        if( pt_pad->m_NetCode == NetCode )
+        if( pt_pad->GetNet() == NetCode )
         {
             pt_pad->Draw( panel, DC, wxPoint( 0, 0 ), draw_mode );
         }

pcbnew/tr_modif.cpp

@@ -54,10 +54,10 @@ TRACK * BufDeb, *BufEnd;		/* Pointeurs de debut et de fin de la zone
 
 	/* Calcul des limites de recherche des segments de piste */
 	/* BufDeb pointe le 1er segment utile */
-	BufDeb = Pcb->m_Track->GetStartNetCode(pt_new_track->m_NetCode);
+	BufDeb = Pcb->m_Track->GetStartNetCode(pt_new_track->GetNet());
 
 	/* BufEnd Pointe le dernier segment */
-	BufEnd = BufDeb->GetEndNetCode(pt_new_track->m_NetCode);
+	BufEnd = BufDeb->GetEndNetCode(pt_new_track->GetNet());
 
 	/* nettoyage des flags pour tout le net */
 	for(pt_del = BufDeb; pt_del != NULL; pt_del = (TRACK*)pt_del->Pnext)

pcbnew/undelete.cpp

@@ -45,7 +45,7 @@ void WinEDA_PcbFrame::UnDeleteItem( wxDC* DC )
         }
 
         PtStruct = g_UnDeleteStack[g_UnDeleteStackPtr];
-        net_code = ( (TRACK*) PtStruct )->m_NetCode;
+        net_code = ( (TRACK*) PtStruct )->GetNet();
         pt_track = ( (TRACK*) PtStruct )->GetBestInsertPoint( m_Pcb );
         ( (TRACK*) PtStruct )->Insert( m_Pcb, pt_track );
         g_UnDeleteStack[g_UnDeleteStackPtr] = NULL;

pcbnew/xchgmod.cpp

@@ -559,7 +559,7 @@ MODULE* WinEDA_BasePcbFrame::Exchange_Module( wxWindow* winaff,
     for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
     {
         pt_pad->m_Netname = wxEmptyString;
-        pt_pad->m_NetCode = 0;
+        pt_pad->SetNet( 0 );
         pt_old_pad = OldModule->m_Pads;
         for( ; pt_old_pad != NULL; pt_old_pad = (D_PAD*) pt_old_pad->Pnext )
         {
@@ -567,7 +567,7 @@ MODULE* WinEDA_BasePcbFrame::Exchange_Module( wxWindow* winaff,
                          sizeof(pt_pad->m_Padname) ) == 0 )
             {
                 pt_pad->m_Netname = pt_old_pad->m_Netname;
-                pt_pad->m_NetCode = pt_old_pad->m_NetCode;
+                pt_pad->SetNet( pt_old_pad->GetNet() );
             }
         }
     }

pcbnew/zones.cpp

@@ -543,13 +543,13 @@ void WinEDA_PcbFrame::CaptureNetName( wxDC* DC )
         if( pt_pad )
         {
             pt_pad->Display_Infos( this );
-            netcode = pt_pad->m_NetCode;
+            netcode = pt_pad->GetNet();
         }
     }
     else
     {
         adrpiste->Display_Infos( this );
-        netcode = adrpiste->m_NetCode;
+        netcode = adrpiste->GetNet();
     }
 
     // Mise en surbrillance du net
@@ -584,7 +584,7 @@ static void Display_Zone_Netname( WinEDA_PcbFrame* frame )
     {
         for( ; pt_equipot != NULL; pt_equipot = (EQUIPOT*) pt_equipot->Pnext )
         {
-            if( pt_equipot->m_NetCode == g_HightLigth_NetCode )
+            if( pt_equipot->GetNet() == g_HightLigth_NetCode )
                 break;
         }
 
@@ -920,7 +920,7 @@ void WinEDA_PcbFrame::Fill_Zone( wxDC* DC )
     TRACK* pt_segm = m_Pcb->m_Track;
     for( ; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
     {
-        if( g_HightLigth_NetCode != pt_segm->m_NetCode )
+        if( g_HightLigth_NetCode != pt_segm->GetNet() )
             continue;
         if( pt_segm->GetLayer() != GetScreen()->m_Active_Layer )
             continue;
@@ -1087,7 +1087,7 @@ static void Genere_Segments_Zone( WinEDA_PcbFrame* frame, wxDC* DC, int net_code
                     /* un segment avait debute de longueur > 0 */
                     pt_track = new SEGZONE( frame->m_Pcb );
                     pt_track->SetLayer( layer );
-                    pt_track->m_NetCode   = net_code;
+                    pt_track->SetNet( net_code );
                     pt_track->m_Width     = g_GridRoutingSize;
                     pt_track->m_Start.x   = ux0; pt_track->m_Start.y = uy0;
                     pt_track->m_End.x     = ux1; pt_track->m_End.y = uy1;
@@ -1126,7 +1126,7 @@ static void Genere_Segments_Zone( WinEDA_PcbFrame* frame, wxDC* DC, int net_code
                     pt_track = new SEGZONE( frame->m_Pcb );
                     pt_track->SetLayer( layer );
                     pt_track->m_Width     = g_GridRoutingSize;
-                    pt_track->m_NetCode   = net_code;
+                    pt_track->SetNet( net_code );
                     pt_track->m_Start.x   = ux0; pt_track->m_Start.y = uy0;
                     pt_track->m_End.x     = ux1; pt_track->m_End.y = uy1;
                     pt_track->m_TimeStamp = s_TimeStamp;
@@ -1310,7 +1310,7 @@ static bool Genere_Pad_Connexion( WinEDA_PcbFrame* frame, wxDC* DC, int layer )
         pt_pad = *pt_liste_pad;
 
         /* la pastille doit etre du meme net */
-        if( pt_pad->m_NetCode != g_HightLigth_NetCode )
+        if( pt_pad->GetNet() != g_HightLigth_NetCode )
             continue;
 
         /* la pastille doit exister sur la couche */
@@ -1329,7 +1329,7 @@ static bool Genere_Pad_Connexion( WinEDA_PcbFrame* frame, wxDC* DC, int layer )
         pt_pad = *pt_liste_pad;
 
         /* la pastille doit etre du meme net */
-        if( pt_pad->m_NetCode != g_HightLigth_NetCode )
+        if( pt_pad->GetNet() != g_HightLigth_NetCode )
             continue;
         /* la pastille doit exister sur la couche */
         if( (pt_pad->m_Masque_Layer & g_TabOneLayerMask[layer]) == 0 )
@@ -1365,7 +1365,7 @@ static bool Genere_Pad_Connexion( WinEDA_PcbFrame* frame, wxDC* DC, int layer )
 
             pt_track->SetLayer( layer );
             pt_track->m_Width   = g_DesignSettings.m_CurrentTrackWidth;
-            pt_track->m_NetCode = g_HightLigth_NetCode;
+            pt_track->SetNet( g_HightLigth_NetCode );
             pt_track->start       = pt_pad;
             pt_track->m_Start.x   = cX; pt_track->m_Start.y = cY;
             pt_track->m_End.x     = cX + sommet[jj][0];