unified m_Flags, EDA_BaseStruct::Display_Infos(), and ~GetEquipot()

change_log.txt

@@ -4,6 +4,26 @@ Started 2007-June-11
 Please add newer entries at the top, list the date and your name with 
 email address.
 
+
+2007-Aug-20 UPDATE   Dick Hollenbeck <dick@softplc.com>
+================================================================================
++ pcbnew & eeschema
+  * Moved allowed m_Flags values from pcbnew.h, general.h, and eeschema/delete.cpp to base_struct.h 
+    near m_Flags itself.  Several of the flags values were changed.  I am only
+    comfortable with this change if m_Flags is not written to disk anywhere,
+    and we need to give that some thought.  If m_Flags is a memory only usage
+    and not saved to disk, then this change should be safe.  I could not find
+    any case where m_Flags was being saved do disk, but I could have missed one.
+    The reason for the change was to consolidate into one place the allowed values
+    so that as new flags are allowed there is no conflict.
+  * Moved most all the pcbnew/affiche.cpp functions to member functions of their
+    respective classes with the name Display_Infos().
+  * Moved GetEquipot() global function to BOARD::FindNet().
+  These changes are working towards a concise locate.cpp module, on the way
+  to implementing the multiple choice support.  Mass edits should be slowing down
+  in a day or so.
+   
+
 2007-Aug-20 UPDATE   Geoff Harland <gharlandau@yahoo.com.au>
 ================================================================================
 + eeschema & pcbnew

eeschema/delete.cpp

@@ -13,10 +13,6 @@
 
 #include "protos.h"
 
-#define SELECTEDNODE 1	/* flag indiquant que la structure a deja selectionnee */
-#define STRUCT_DELETED 2	/* Bit flag de Status pour structures effacee */
-#define CANDIDATE 4		/* flag indiquant que la structure est connectee */
-#define SKIP_STRUCT 8	/* flag indiquant que la structure ne doit pas etre traitee */
 
 /********************************************************************************/
 static int CountConnectedItems(WinEDA_SchematicFrame * frame,

eeschema/general.h

@@ -24,18 +24,6 @@
 
 #define HIGHLIGHT_COLOR WHITE
 
-/* Flags used in editing commnands (EDA_BaseStruct, .Flags )*/
-#define IS_CHANGED 1
-#define IS_LINKED 2
-#define IS_MOVED 4
-#define IS_NEW 8
-#define IS_DELETED 0x10
-#define IS_RESIZED 0x20
-#define IN_EDIT 0x40
-#define IS_WIRE_IMAGE 0x100
-#define STARTPOINT 0x200
-#define ENDPOINT 0x400
-#define SELECTED 0x800
 
 /* Used for EDA_BaseStruct, .m_Select member */
 #define IS_SELECTED 1

gerbview/locate.cpp

-		/***************************************************/
-		/* Localisation des elements pointes par la souris */
-		/***************************************************/
+/***************************************************/
+/* Localisation des elements pointes par la souris */
+/***************************************************/
 
 #include "fctsys.h"
 
@@ -12,74 +12,78 @@
 
 
 /* variables locales */
-int ux0 , uy0 ,dx, dy, spot_cX, spot_cY;	/* Variables utilisees pour
-							 la localisation des segments */
+int ux0, uy0, dx, dy, spot_cX, spot_cY;     /* Variables utilisees pour
+                                             *  la localisation des segments */
 /* fonctions locales */
-static TRACK * Locate_Zone(TRACK * start_adresse,int layer, int typeloc );
-static TRACK * Locate_Zone(TRACK * start_adresse, wxPoint ref, int layer);
-static TRACK * Locate_Pistes(TRACK * start_adresse,int Layer, int typeloc );
-static TRACK * Locate_Pistes(TRACK * start_adresse, wxPoint ref,int Layer);
-static DRAWSEGMENT * Locate_Segment_Pcb(BOARD * Pcb, int typeloc);
-static TEXTE_PCB * Locate_Texte_Pcb(TEXTE_PCB* pt_txt_pcb, int typeloc);
-static int distance(int seuil);
+static TRACK*       Locate_Zone( TRACK* start_adresse, int layer, int typeloc );
+static TRACK*       Locate_Zone( TRACK* start_adresse, wxPoint ref, int layer );
+static TRACK*       Locate_Pistes( TRACK* start_adresse, int Layer, int typeloc );
+static TRACK*       Locate_Pistes( TRACK* start_adresse, wxPoint ref, int Layer );
+static DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc );
+static TEXTE_PCB*   Locate_Texte_Pcb( TEXTE_PCB* pt_txt_pcb, int typeloc );
+static int          distance( int seuil );
+
 /**/
 
 /* Macro de calcul de la coord de pointage selon le curseur
-(ON/OFF grille) choisi
-*/
-#define SET_REF_POS(ref)  if(typeloc == CURSEUR_ON_GRILLE) \
-		{ ref = ActiveScreen->m_Curseur;} \
+ *  (ON/OFF grille) choisi
+ */
+#define SET_REF_POS( ref )  if( typeloc == CURSEUR_ON_GRILLE ) \
+    { ref = ActiveScreen->m_Curseur; } \
     else { ref = ActiveScreen->m_MousePosition; }
 
 
-
-
 /*************************************************************/
-EDA_BaseStruct * WinEDA_GerberFrame::Locate( int typeloc )
+EDA_BaseStruct* WinEDA_GerberFrame::Locate( int typeloc )
 /*************************************************************/
+
 /* Fonction de localisation generale
-	Affiche les caract de la stucture localisée et retourne un pointeur
-	sur celle-ci
-*/
+ *  Affiche les caract de la stucture localisée et retourne un pointeur
+ *  sur celle-ci
+ */
 {
-TEXTE_PCB * pt_texte_pcb;
-TRACK * Track , * TrackLocate ;
-DRAWSEGMENT * DrawSegm;
-int layer;
+    TEXTE_PCB*   pt_texte_pcb;
+    TRACK*       Track, * TrackLocate;
+    DRAWSEGMENT* DrawSegm;
+    int          layer;
 
     /* Localistion des pistes et vias, avec priorite aux vias */
     layer = GetScreen()->m_Active_Layer;
     Track = Locate_Pistes( m_Pcb->m_Track, -1, typeloc );
-	if ( Track != NULL )
+    if( Track != NULL )
     {
-		TrackLocate = Track ;	/* Reperage d'une piste ou via */
+        TrackLocate = Track;   /* Reperage d'une piste ou via */
         /* recherche de 1 via eventuelle */
-		while((TrackLocate = Locate_Pistes(TrackLocate, layer,typeloc)) != NULL )
+        while( ( TrackLocate = Locate_Pistes( TrackLocate, layer, typeloc ) ) != NULL )
         {
             Track = TrackLocate;
-			if(TrackLocate->m_StructType == TYPEVIA) break ;
+            if( TrackLocate->m_StructType == TYPEVIA )
+                break;
             TrackLocate = (TRACK*) TrackLocate->Pnext;
         }
-		Affiche_Infos_Piste(this, Track) ;
+
+        Track->Display_Infos( this );
         return Track;
     }
 
 
-	pt_texte_pcb = Locate_Texte_Pcb((TEXTE_PCB*) m_Pcb->m_Drawings, typeloc);
-	if(pt_texte_pcb ) // texte type PCB localise
+    pt_texte_pcb = Locate_Texte_Pcb( (TEXTE_PCB*) m_Pcb->m_Drawings, typeloc );
+    if( pt_texte_pcb ) // texte type PCB localise
     {
-		Affiche_Infos_PCB_Texte(this, pt_texte_pcb); return pt_texte_pcb;
+        pt_texte_pcb->Display_Infos( this );
+        return pt_texte_pcb;
     }
 
-	if ( (DrawSegm = Locate_Segment_Pcb(m_Pcb, typeloc)) != NULL)
+    if( ( DrawSegm = Locate_Segment_Pcb( m_Pcb, typeloc ) ) != NULL )
     {
         return DrawSegm;
     }
 
-	if( (TrackLocate = Locate_Zone((TRACK*)m_Pcb->m_Zone,
-					GetScreen()->m_Active_Layer,typeloc)) != NULL )
+    if( ( TrackLocate = Locate_Zone( (TRACK*) m_Pcb->m_Zone,
+                                    GetScreen()->m_Active_Layer, typeloc ) ) != NULL )
     {
-		Affiche_Infos_Piste(this, TrackLocate) ; return TrackLocate;
+        TrackLocate->Display_Infos( this ); 
+        return TrackLocate;
     }
 
     MsgPanel->EraseMsgBox();
@@ -87,47 +91,51 @@ int layer;
 }
 
 
-
 /********************************************************/
-DRAWSEGMENT * Locate_Segment_Pcb(BOARD * Pcb, int typeloc)
+DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc )
 /********************************************************/
+
 /* Localisation de segments de contour du type edge pcb ou draw
-	(selon couche active)
-	Retourne:
-		Pointeur sur DEBUT du segment localise
-		NULL si rien trouve
-*/
+ *  (selon couche active)
+ *  Retourne:
+ *      Pointeur sur DEBUT du segment localise
+ *      NULL si rien trouve
+ */
 {
-EDA_BaseStruct * PtStruct;
-DRAWSEGMENT * pts;
-wxPoint ref;
-PCB_SCREEN * screen = (PCB_SCREEN *) ActiveScreen;
-	SET_REF_POS(ref);
+    EDA_BaseStruct* PtStruct;
+    DRAWSEGMENT*    pts;
+    wxPoint         ref;
+    PCB_SCREEN*     screen = (PCB_SCREEN*) ActiveScreen;
+
+    SET_REF_POS( ref );
 
     PtStruct = Pcb->m_Drawings;
     for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
     {
-		if( PtStruct->m_StructType != TYPEDRAWSEGMENT ) continue;
-		pts = ( DRAWSEGMENT * ) PtStruct;
-		ux0 = pts->m_Start.x ; uy0 = pts->m_Start.y;
+        if( PtStruct->m_StructType != TYPEDRAWSEGMENT )
+            continue;
+        pts = (DRAWSEGMENT*) PtStruct;
+        ux0 = pts->m_Start.x; uy0 = pts->m_Start.y;
         /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
-		dx = pts->m_End.x - ux0 ; dy = pts->m_End.y - uy0 ;
-		spot_cX = ref.x - ux0; spot_cY = ref.y - uy0 ;
+        dx      = pts->m_End.x - ux0; dy = pts->m_End.y - uy0;
+        spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
 
         /* detection : */
-		if(pts->m_Layer != screen->m_Active_Layer) continue;
+        if( pts->m_Layer != screen->m_Active_Layer )
+            continue;
 
         if( (pts->m_Shape == S_CIRCLE) || (pts->m_Shape == S_ARC) )
         {
             int rayon, dist, StAngle, EndAngle, MouseAngle;
-			rayon = (int) hypot((double)(dx),(double)(dy) );
-			dist = (int) hypot((double)(spot_cX),(double)(spot_cY) );
-			if( abs(rayon-dist) <= (pts->m_Width/2) )
+            rayon = (int) hypot( (double) (dx), (double) (dy) );
+            dist  = (int) hypot( (double) (spot_cX), (double) (spot_cY) );
+            if( abs( rayon - dist ) <= (pts->m_Width / 2) )
             {
-				if(pts->m_Shape == S_CIRCLE) return(pts);
+                if( pts->m_Shape == S_CIRCLE )
+                    return pts;
                 /* pour un arc, controle complementaire */
-				MouseAngle = (int) ArcTangente(spot_cY, spot_cX);
-				StAngle = (int) ArcTangente(dy, dx);
+                MouseAngle = (int) ArcTangente( spot_cY, spot_cX );
+                StAngle    = (int) ArcTangente( dy, dx );
                 EndAngle   = StAngle + pts->m_Angle;
 
                 if( EndAngle > 3600 )
@@ -135,16 +143,17 @@ PCB_SCREEN * screen = (PCB_SCREEN *) ActiveScreen;
                     StAngle -= 3600; EndAngle -= 3600;
                 }
                 if( (MouseAngle >= StAngle) && (MouseAngle <= EndAngle) )
-					return(pts);
+                    return pts;
             }
         }
-
         else
         {
-			if( distance( pts->m_Width /2 ) ) return( pts ) ;
+            if( distance( pts->m_Width / 2 ) )
+                return pts;
         }
     }
-	return(NULL) ;
+
+    return NULL;
 }
 
 
@@ -154,294 +163,303 @@ PCB_SCREEN * screen = (PCB_SCREEN *) ActiveScreen;
 /****************************************************************************/
 
 /*
-1 -  routine de localisation du segment de piste pointe par la souris.
-2 -  routine de localisation du segment de piste pointe par le point
-			ref_pX , ref_pY.r
-
-	La recherche commence a l'adresse start_adresse
-*/
-
-TRACK * Locate_Pistes(TRACK * start_adresse,int Layer, int typeloc )
+ *  1 -  routine de localisation du segment de piste pointe par la souris.
+ *  2 -  routine de localisation du segment de piste pointe par le point
+ *          ref_pX , ref_pY.r
+ * 
+ *  La recherche commence a l'adresse start_adresse
+ */
+
+TRACK* Locate_Pistes( TRACK* start_adresse, int Layer, int typeloc )
 {
-wxPoint ref;
+    wxPoint ref;
 
-	SET_REF_POS(ref);
+    SET_REF_POS( ref );
 
-	return( Locate_Pistes(start_adresse, ref, Layer) );
+    return Locate_Pistes( start_adresse, ref, Layer );
 }
 
 
-TRACK * Locate_Pistes(TRACK * start_adresse, wxPoint ref, int Layer)
+TRACK* Locate_Pistes( TRACK* start_adresse, wxPoint ref, int Layer )
 {
-TRACK * Track;		/* pointeur sur les pistes */
-int l_piste ;					/* demi-largeur de la piste */
+    TRACK* Track;               /* pointeur sur les pistes */
+    int    l_piste;             /* demi-largeur de la piste */
 
-	for( Track = start_adresse; Track != NULL; Track = (TRACK*) Track->Pnext)
+    for( Track = start_adresse; Track != NULL; Track = (TRACK*) Track->Pnext )
     {
-		if( Track->GetState(BUSY|DELETED) ) continue;
+        if( Track->GetState( BUSY | DELETED ) )
+            continue;
         /* calcul des coordonnees du segment teste */
         l_piste = Track->m_Width >> 1;                  /* l_piste = demi largeur piste */
-		ux0 = Track->m_Start.x ; uy0 = Track->m_Start.y ; /* coord de depart */
-		dx =  Track->m_End.x ; dy =  Track->m_End.y ; /* coord d'arrivee */
+        ux0 = Track->m_Start.x; uy0 = Track->m_Start.y; /* coord de depart */
+        dx  = Track->m_End.x; dy = Track->m_End.y;      /* coord d'arrivee */
 
         /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
-		dx -= ux0 ; dy -= uy0 ;
-		spot_cX = ref.x - ux0 ; spot_cY = ref.y - uy0 ;
+        dx     -= ux0; dy -= uy0;
+        spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
 
-		if ( Track->m_StructType == TYPEVIA ) /* VIA rencontree */
+        if( Track->m_StructType == TYPEVIA ) /* VIA rencontree */
         {
-			if ((abs(spot_cX) <= l_piste ) && (abs(spot_cY) <=l_piste))
+            if( (abs( spot_cX ) <= l_piste ) && (abs( spot_cY ) <=l_piste) )
             {
-				return(Track) ;
+                return Track;
             }
-			continue ;
+            continue;
         }
 
-		if(Layer >= 0)
+        if( Layer >= 0 )
             if( Track->m_Layer != Layer )
-				continue;	/* Segments sur couches differentes */
-		if( distance(l_piste) ) return(Track) ;
+                continue;/* Segments sur couches differentes */
+        if( distance( l_piste ) )
+            return Track;
     }
-	return(NULL) ;
-}
 
-	/****************************************************************/
-	/* TRACK * Locate_Zone(TRACK * start_adresse, int layer,	 */
-	/*											int typeloc)		*/
-	/* TRACK * Locate_Zone(TRACK * start_adresse,wxPoint ref, int layer) */
-	/****************************************************************/
-
-/*
-1 -  routine de localisation du segment de zone pointe par la souris.
-2 -  routine de localisation du segment de zone pointe par le point
-			ref_pX , ref_pY.r
+    return NULL;
+}
 
-	Si layer == -1 , le tst de la couche n'est pas fait
 
-	La recherche commence a l'adresse start_adresse
-*/
+/****************************************************************/
+/* TRACK * Locate_Zone(TRACK * start_adresse, int layer,	 */
+/*											int typeloc)		*/
+/* TRACK * Locate_Zone(TRACK * start_adresse,wxPoint ref, int layer) */
+/****************************************************************/
 
-TRACK * Locate_Zone(TRACK * start_adresse,int layer, int typeloc )
+/*
+ *  1 -  routine de localisation du segment de zone pointe par la souris.
+ *  2 -  routine de localisation du segment de zone pointe par le point
+ *          ref_pX , ref_pY.r
+ * 
+ *  Si layer == -1 , le tst de la couche n'est pas fait
+ * 
+ *  La recherche commence a l'adresse start_adresse
+ */
+
+TRACK* Locate_Zone( TRACK* start_adresse, int layer, int typeloc )
 {
-wxPoint ref;
+    wxPoint ref;
 
-	SET_REF_POS(ref);
+    SET_REF_POS( ref );
 
-	return( Locate_Zone(start_adresse, ref, layer) );
+    return Locate_Zone( start_adresse, ref, layer );
 }
 
 
-TRACK * Locate_Zone(TRACK * start_adresse, wxPoint ref, int layer)
+TRACK* Locate_Zone( TRACK* start_adresse, wxPoint ref, int layer )
 {
-TRACK * Zone;		/* pointeur sur les pistes */
-int l_segm ;					/* demi-largeur de la piste */
+    TRACK* Zone;                /* pointeur sur les pistes */
+    int    l_segm;              /* demi-largeur de la piste */
 
-	for( Zone = start_adresse; Zone != NULL; Zone = (TRACK *) Zone->Pnext)
+    for( Zone = start_adresse; Zone != NULL; Zone = (TRACK*) Zone->Pnext )
     {
         /* calcul des coordonnees du segment teste */
         l_segm = Zone->m_Width >> 1;                        /* l_piste = demi largeur piste */
-		ux0 = Zone->m_Start.x ; uy0 = Zone->m_Start.y ; /* coord de depart */
-		dx =  Zone->m_End.x ; dy =  Zone->m_End.y ; /* coord d'arrivee */
+        ux0    = Zone->m_Start.x; uy0 = Zone->m_Start.y;    /* coord de depart */
+        dx = Zone->m_End.x; dy = Zone->m_End.y;             /* coord d'arrivee */
 
         /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
-		dx -= ux0 ; dy -= uy0 ;
-		spot_cX = ref.x - ux0 ; spot_cY = ref.y - uy0 ;
+        dx     -= ux0; dy -= uy0;
+        spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
 
-		if((layer != -1) && (Zone->m_Layer != layer)) continue;
-		if( distance(l_segm) ) return(Zone) ;
+        if( (layer != -1) && (Zone->m_Layer != layer) )
+            continue;
+        if( distance( l_segm ) )
+            return Zone;
     }
-	return(NULL) ;
-}
 
+    return NULL;
+}
 
 
-	/***************************************************************/
-	/* TEXTE_PCB * Locate_Texte_Pcb(char * pt_txt_pcb,int typeloc) */
-	/***************************************************************/
+/***************************************************************/
+/* TEXTE_PCB * Locate_Texte_Pcb(char * pt_txt_pcb,int typeloc) */
+/***************************************************************/
 
 /* localisation des inscriptions sur le Pcb:
-	entree : char pointeur sur le debut de la zone de recherche
-	retour : pointeur sur la description du texte localise
-*/
+ *  entree : char pointeur sur le debut de la zone de recherche
+ *  retour : pointeur sur la description du texte localise
+ */
 
-TEXTE_PCB * Locate_Texte_Pcb(TEXTE_PCB* pt_txt_pcb, int typeloc)
+TEXTE_PCB* Locate_Texte_Pcb( TEXTE_PCB* pt_txt_pcb, int typeloc )
 {
-int angle ;
-EDA_BaseStruct * PtStruct;
-wxPoint ref;
+    int             angle;
+    EDA_BaseStruct* PtStruct;
+    wxPoint         ref;
 
-	SET_REF_POS(ref);
-	PtStruct = (EDA_BaseStruct *) pt_txt_pcb ;
+    SET_REF_POS( ref );
+    PtStruct = (EDA_BaseStruct*) pt_txt_pcb;
     for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
     {
-		if( PtStruct->m_StructType != TYPETEXTE ) continue;
-		pt_txt_pcb = (TEXTE_PCB *) PtStruct;
+        if( PtStruct->m_StructType != TYPETEXTE )
+            continue;
+        pt_txt_pcb = (TEXTE_PCB*) PtStruct;
 
         angle = pt_txt_pcb->m_Orient;
         ux0   = pt_txt_pcb->m_Pos.x; uy0 = pt_txt_pcb->m_Pos.y;
-		dx  = (pt_txt_pcb->m_Size.x * pt_txt_pcb->GetLength()) / 2;
-		dy = pt_txt_pcb->m_Size.y /2 ;
+        dx    = ( pt_txt_pcb->m_Size.x * pt_txt_pcb->GetLength() ) / 2;
+        dy    = pt_txt_pcb->m_Size.y / 2;
 
         dx *= 13; dx /= 9;  /* Facteur de forme des lettres : 13/9 */
 
         /* la souris est-elle dans ce rectangle  autour du centre  */
-		spot_cX = ref.x - ux0 ; spot_cY = ref.y - uy0 ;
-		RotatePoint(&spot_cX, &spot_cY, -angle);
-		if( (abs(spot_cX) <= abs(dx) ) && ( abs(spot_cY) <= abs(dy) ) )
-			 return(pt_txt_pcb) ;
+        spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
+        RotatePoint( &spot_cX, &spot_cY, -angle );
+        if( ( abs( spot_cX ) <= abs( dx ) ) && ( abs( spot_cY ) <= abs( dy ) ) )
+            return pt_txt_pcb;
     }
-	return(NULL) ;
-}
 
+    return NULL;
+}
 
 
-	/*****************************/
-	/* int distance(int seuil) */
-	/*****************************/
+/*****************************/
+/* int distance(int seuil) */
+/*****************************/
 
 /*
- Calcul de la distance du curseur souris a un segment de droite :
- ( piste, edge, contour module ..
-	retourne:
-		0 si distance > seuil
-		1 si distance <= seuil
-	Variables utilisees ( doivent etre initialisees avant appel , et
-	sont ramenees au repere centre sur l'origine du segment)
-		dx, dy = coord de l'extremite segment.
-		spot_cX,spot_cY = coord du curseur souris
-	la recherche se fait selon 4 cas:
-		segment horizontal
-		segment vertical
-		segment 45
-		segment quelconque
-*/
-
-int distance(int seuil)
+ *  Calcul de la distance du curseur souris a un segment de droite :
+ *  ( piste, edge, contour module ..
+ *  retourne:
+ *      0 si distance > seuil
+ *      1 si distance <= seuil
+ *  Variables utilisees ( doivent etre initialisees avant appel , et
+ *  sont ramenees au repere centre sur l'origine du segment)
+ *      dx, dy = coord de l'extremite segment.
+ *      spot_cX,spot_cY = coord du curseur souris
+ *  la recherche se fait selon 4 cas:
+ *      segment horizontal
+ *      segment vertical
+ *      segment 45
+ *      segment quelconque
+ */
+
+int distance( int seuil )
 {
-int  cXrot, cYrot ,		/* coord du point (souris) dans le repere tourne */
+    int cXrot, cYrot,   /* coord du point (souris) dans le repere tourne */
         segX, segY;     /* coord extremite segment tj >= 0 */
-int pointX, pointY;	/* coord point a tester dans repere modifie dans lequel
-	 					segX et segY sont >=0 */
+    int pointX, pointY;/* coord point a tester dans repere modifie dans lequel
+                     *  segX et segY sont >=0 */
 
-	segX = dx ; segY = dy; pointX = spot_cX ; pointY = spot_cY ;
+    segX = dx; segY = dy; pointX = spot_cX; pointY = spot_cY;
 
     /*Recalcul coord pour que le segment soit dans 1er quadrant (coord >= 0)*/
-	if (segX < 0)	/* mise en >0 par symetrie par rapport a l'axe Y */
+    if( segX < 0 )   /* mise en >0 par symetrie par rapport a l'axe Y */
     {
-		segX = -segX ; pointX = - pointX ;
+        segX = -segX; pointX = -pointX;
     }
-	if (segY < 0)	/* mise en > 0 par symetrie par rapport a l'axe X */
+    if( segY < 0 )   /* mise en > 0 par symetrie par rapport a l'axe X */
     {
-		segY = -segY ; pointY = -pointY ;
+        segY = -segY; pointY = -pointY;
     }
 
 
-	if ( segY == 0 ) /* piste Horizontale */
+    if( segY == 0 ) /* piste Horizontale */
     {
-		if(abs(pointY) <= seuil )
+        if( abs( pointY ) <= seuil )
         {
-			if((pointX >= 0) && (pointX <= segX) ) return(1);
+            if( (pointX >= 0) && (pointX <= segX) )
+                return 1;
             /* Etude des extremites : cercle de rayon seuil */
             if( (pointX < 0) && (pointX >= -seuil) )
             {
-				if( ((pointX * pointX) + (pointY*pointY)) <= (seuil*seuil) )
-					return(1);
+                if( ( (pointX * pointX) + (pointY * pointY) ) <= (seuil * seuil) )
+                    return 1;
             }
-			if( (pointX > segX) && (pointX <= (segX+seuil)) )
+            if( (pointX > segX) && ( pointX <= (segX + seuil) ) )
             {
-				if( (((pointX-segX) * (pointX-segX)) + (pointY*pointY)) <= (seuil*seuil) )
-					return(1);
+                if( ( ( (pointX - segX) * (pointX - segX) ) + (pointY * pointY) ) <=
+                   (seuil * seuil) )
+                    return 1;
             }
         }
     }
-
-	else if ( segX == 0 ) /* piste verticale */
+    else if( segX == 0 ) /* piste verticale */
     {
-		if( abs(pointX) <= seuil)
+        if( abs( pointX ) <= seuil )
         {
-			if((pointY >= 0 ) && (pointY <= segY) ) return(1);
+            if( (pointY >= 0 ) && (pointY <= segY) )
+                return 1;
             if( (pointY < 0) && (pointY >= -seuil) )
             {
-				if( ((pointY * pointY) + (pointX*pointX)) <= (seuil*seuil) )
-					return(1);
+                if( ( (pointY * pointY) + (pointX * pointX) ) <= (seuil * seuil) )
+                    return 1;
             }
-			if( (pointY > segY) && (pointY <= (segY+seuil)) )
+            if( (pointY > segY) && ( pointY <= (segY + seuil) ) )
             {
-				if( ( ((pointY-segY) * (pointY-segY)) + (pointX*pointX)) <= (seuil*seuil) )
-					return(1);
+                if( ( ( (pointY - segY) * (pointY - segY) ) + (pointX * pointX) ) <=
+                   (seuil * seuil) )
+                    return 1;
             }
         }
     }
-
-	else if ( segX == segY )	/* piste a 45 degre */
+    else if( segX == segY )    /* piste a 45 degre */
     {
         /* on fait tourner les axes de 45 degre. la souris a alors les
-		coord : x1 = x*cos45 + y*sin45
-				y1 = y*cos45 - x*sin45
-		et le segment de piste est alors horizontal.
-		recalcul des coord de la souris ( sin45 = cos45 = .707 = 7/10 
-		remarque : sin ou cos45 = .707, et lors du recalcul des coord
-		dx45 et dy45, lec coeff .707 est neglige, dx et dy sont en fait .707 fois
-		trop grands. (c.a.d trop petits)
-		spot_cX,Y doit etre * par .707 * .707 = 0.5 */
-
-		cXrot = (pointX + pointY) >> 1 ;
-		cYrot = (pointY - pointX) >> 1 ;
+         *  coord : x1 = x*cos45 + y*sin45
+         *      y1 = y*cos45 - x*sin45
+         *  et le segment de piste est alors horizontal.
+         *  recalcul des coord de la souris ( sin45 = cos45 = .707 = 7/10
+         *  remarque : sin ou cos45 = .707, et lors du recalcul des coord
+         *  dx45 et dy45, lec coeff .707 est neglige, dx et dy sont en fait .707 fois
+         *  trop grands. (c.a.d trop petits)
+         *  spot_cX,Y doit etre * par .707 * .707 = 0.5 */
+
+        cXrot = (pointX + pointY) >> 1;
+        cYrot = (pointY - pointX) >> 1;
 
         /* recalcul des coord de l'extremite du segment , qui sera vertical
-		suite a l'orientation des axes sur l'ecran : dx45 = pointX (ou pointY)
-		et est en fait 1,414 plus grand , et dy45 = 0 */
+         *  suite a l'orientation des axes sur l'ecran : dx45 = pointX (ou pointY)
+         *  et est en fait 1,414 plus grand , et dy45 = 0 */
 
         // seuil doit etre * .707 pour tenir compte du coeff de reduction sur dx,dy
-		seuil *= 7 ; seuil /= 10 ;
-		if ( abs(cYrot) <= seuil) /* ok sur axe vertical) */
+        seuil *= 7; seuil /= 10;
+        if( abs( cYrot ) <= seuil ) /* ok sur axe vertical) */
         {
-			if ((cXrot >= 0) && (cXrot <= segX) ) return(1) ;
+            if( (cXrot >= 0) && (cXrot <= segX) )
+                return 1;
 
             /* Etude des extremites : cercle de rayon seuil */
             if( (cXrot < 0) && (cXrot >= -seuil) )
             {
-				if( ((cXrot * cXrot) + (cYrot*cYrot)) <= (seuil*seuil) )
-					return(1);
+                if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) )
+                    return 1;
             }
-			if( (cXrot > segX) && (cXrot <= (segX+seuil)) )
+            if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) )
             {
-				if( (((cXrot-segX) * (cXrot-segX)) + (cYrot*cYrot)) <= (seuil*seuil) )
-					return(1);
+                if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) )
+                    return 1;
             }
         }
     }
     else    /* orientation quelconque */
     {
         /* On fait un changement d'axe (rotation) de facon a ce que le segment
-		de piste soit horizontal dans le nouveau repere */
+         *  de piste soit horizontal dans le nouveau repere */
         int angle;
 
-		angle = (int)( atan2((float)segY, (float)segX) * 1800 / M_PI) ; 
+        angle = (int) ( atan2( (float) segY, (float) segX ) * 1800 / M_PI);
         cXrot = pointX; cYrot = pointY;
-		RotatePoint(&cXrot, &cYrot, angle);	/* Rotation du point a tester */
-		RotatePoint(&segX, &segY, angle) ;	/* Rotation du segment */
+        RotatePoint( &cXrot, &cYrot, angle );   /* Rotation du point a tester */
+        RotatePoint( &segX, &segY, angle );     /* Rotation du segment */
 
         /*la piste est Horizontale , par suite des modifs de coordonnes
-		et d'axe, donc segX = longueur du segment */
+         *  et d'axe, donc segX = longueur du segment */
 
-		if ( abs(cYrot) <= seuil ) /* ok sur axe vertical) */
+        if( abs( cYrot ) <= seuil ) /* ok sur axe vertical) */
         {
-			if ((cXrot >= 0) && (cXrot <= segX) ) return(1) ; 
+            if( (cXrot >= 0) && (cXrot <= segX) )
+                return 1;
             /* Etude des extremites : cercle de rayon seuil */
             if( (cXrot < 0) && (cXrot >= -seuil) )
             {
-				if( ((cXrot * cXrot) + (cYrot*cYrot)) <= (seuil*seuil) )
-					return(1);
+                if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) )
+                    return 1;
             }
-			if( (cXrot > segX) && (cXrot <= (segX+seuil)) )
+            if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) )
             {
-				if( (((cXrot-segX) * (cXrot-segX)) + (cYrot*cYrot)) <= (seuil*seuil) )
-					return(1);
+                if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) )
+                    return 1;
             }
         }
     }
-	return(0) ;
+    return 0;
 }
-
-

include/base_struct.h

@@ -83,7 +83,7 @@ enum SEARCH_RESULT {
 typedef DrawStructureType   KICAD_T;    // shorter name
 
 class EDA_BaseStruct;
-
+class WinEDA_DrawFrame;
 
 /**
  * Class INSPECTOR
@@ -132,7 +132,26 @@ public:
     EDA_BaseStruct* m_Parent;           /* Linked list: Link (parent struct) */
     EDA_BaseStruct* m_Son;              /* Linked list: Link (son struct) */
     EDA_BaseStruct* m_Image;            /* Link to an image copy for undelete or abort command */
+
     int             m_Flags;            // flags for editions and other
+#define IS_CHANGED      (1<<0)    
+#define IS_LINKED       (1<<1)
+#define IN_EDIT         (1<<2)
+#define IS_MOVED        (1<<3)
+#define IS_NEW          (1<<4)
+#define IS_RESIZED      (1<<5)
+#define IS_DRAGGED      (1<<6)
+#define IS_DELETED      (1<<7)
+#define IS_WIRE_IMAGE   (1<<8)
+#define STARTPOINT      (1<<9)
+#define ENDPOINT        (1<<10)
+#define SELECTED        (1<<11)
+#define SELECTEDNODE    (1<<12)         ///< flag indiquant que la structure a deja selectionnee
+#define STRUCT_DELETED  (1<<13)         ///< Bit flag de Status pour structures effacee
+#define CANDIDATE       (1<<14)         ///< flag indiquant que la structure est connectee
+#define SKIP_STRUCT     (1<<15)         ///< flag indiquant que la structure ne doit pas etre traitee
+
+
     unsigned long   m_TimeStamp;        // Time stamp used for logical links
     int             m_Selected;         /* Used by block commands, and selective editing */
 
@@ -178,6 +197,19 @@ public:
                           int               draw_mode,
                           int               Color = -1 );
 
+    
+    /**
+     * Function Display_Infos
+     * has knowledge about the frame and how and where to put status information
+     * about this object into the frame's message panel.
+     * @param frame A WinEDA_DrawFrame in which to print status information.
+     */ 
+    virtual void    Display_Infos( WinEDA_DrawFrame* frame )
+    {
+        // derived classes may implement this 
+    }
+    
+    
     /**
      * Function HitTest
      * tests if the given wxPoint is within the bounds of this object.

include/pcbstruct.h

@@ -234,6 +234,16 @@ public:
     bool    ComputeBoundaryBox( void );
 
     
+    /**
+     * Function Display_Infos
+     * has knowledge about the frame and how and where to put status information
+     * about this object into the frame's message panel.
+     * Is virtual from EDA_BaseStruct.
+     * @param frame A WinEDA_BasePcbFrame in which to print status information.
+     */ 
+    void            Display_Infos( WinEDA_DrawFrame* frame );
+    
+    
     /**
      * Function Visit
      * may be re-implemented for each derived class in order to handle
@@ -263,6 +273,15 @@ public:
     EDA_BaseStruct* FindPadOrModule( const wxPoint& refPos, int layer );
     
 
+    /**
+     * Function FindNet
+     * searches for a net with the given netcode.
+     * @param anetcode The netcode to search for.
+     * @return EQUIPOT* - the net or NULL if not found.
+     */
+    EQUIPOT* FindNet( int anetcode );
+    
+    
 #if defined(DEBUG)
     /**
      * Function GetClass
@@ -340,6 +359,17 @@ public:
 
     void    Copy( DRAWSEGMENT* source );
 
+
+    /**
+     * Function Display_Infos
+     * has knowledge about the frame and how and where to put status information
+     * about this object into the frame's message panel.
+     * Is virtual from EDA_BaseStruct.
+     * @param frame A WinEDA_BasePcbFrame in which to print status information.
+     */ 
+    void    Display_Infos( WinEDA_DrawFrame* frame );
+    
+    
     /**
      * Function HitTest
      * tests if the given wxPoint is within the bounds of this object.

pcbnew/affiche.cpp

@@ -14,353 +14,6 @@
 
 /* Routines locales */
 
-/*****************************************************************************/
-void Affiche_Infos_PCB_Texte( WinEDA_BasePcbFrame* frame, TEXTE_PCB* pt_texte )
-/*****************************************************************************/
-
-/* Affiche en bas d'ecran les caract du texte sur PCB
- *  Entree :
- *      pointeur de la description du texte
- */
-{
-    wxString msg;
-
-    frame->MsgPanel->EraseMsgBox();
-    if( pt_texte == NULL )
-        return;
-
-    if( pt_texte->m_StructType == TYPECOTATION )
-        Affiche_1_Parametre( frame, 1, _( "COTATION" ), pt_texte->m_Text, DARKGREEN );
-
-    else
-        Affiche_1_Parametre( frame, 1, _( "PCB Text" ), pt_texte->m_Text, DARKGREEN );
-
-    Affiche_1_Parametre( frame, 28, _( "Layer" ),
-                         ReturnPcbLayerName( pt_texte->m_Layer ),
-                         g_DesignSettings.m_LayerColor[pt_texte->m_Layer] & MASKCOLOR );
-
-    Affiche_1_Parametre( frame, 36, _( "Mirror" ), wxEmptyString, GREEN );
-    if( (pt_texte->m_Miroir & 1) )
-        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "No" ), DARKGREEN );
-    else
-        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Yes" ), DARKGREEN );
-
-    msg.Printf( wxT( "%.1f" ), (float) pt_texte->m_Orient / 10 );
-    Affiche_1_Parametre( frame, 43, _( "Orient" ), msg, DARKGREEN );
-
-    valeur_param( pt_texte->m_Width, msg );
-    Affiche_1_Parametre( frame, 50, _( "Width" ), msg, MAGENTA );
-
-    valeur_param( pt_texte->m_Size.x, msg );
-    Affiche_1_Parametre( frame, 60, _( "H Size" ), msg, RED );
-
-    valeur_param( pt_texte->m_Size.y, msg );
-    Affiche_1_Parametre( frame, 70, _( "V Size" ), msg, RED );
-}
-
-
-/************************************************************************/
-void Affiche_Infos_E_Texte( WinEDA_BasePcbFrame* frame, MODULE* Module,
-                            TEXTE_MODULE* pt_texte )
-/************************************************************************/
-
-/* Affiche en bas d'ecran les caract du texte sur empreinte
- *  Entree :
- *      pointeur de description sur le module
- *      pointeur de la description du texte
- */
-{
-    wxString msg, Line;
-    int      ii;
-
-    static const wxString text_type_msg[3] = { 
-        _( "Ref." ), _( "Value" ), _( "Text" ) };
-    
-    frame->MsgPanel->EraseMsgBox();
-
-    Line = Module->m_Reference->m_Text;
-    Affiche_1_Parametre( frame, 1, _( "Module" ), Line, DARKCYAN );
-
-    Line = pt_texte->m_Text;
-    Affiche_1_Parametre( frame, 10, _( "Text" ), Line, YELLOW );
-
-    ii = pt_texte->m_Type; 
-    if( ii > 2 )
-        ii = 2;
-    
-    Affiche_1_Parametre( frame, 20, _( "Type" ), text_type_msg[ii], DARKGREEN );
-
-    Affiche_1_Parametre( frame, 25, _( "Display" ), wxEmptyString, DARKGREEN );
-    if( pt_texte->m_NoShow )
-        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "No" ), DARKGREEN );
-    else
-        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Yes" ), DARKGREEN );
-
-    ii = pt_texte->m_Layer;
-    if( ii <= 28 )
-        Affiche_1_Parametre( frame, 28, _( "Layer" ), ReturnPcbLayerName( ii ), DARKGREEN );
-    else
-    {
-        msg.Printf( wxT( "%d" ), ii );
-        Affiche_1_Parametre( frame, 28, _( "Layer" ), msg, DARKGREEN );
-    }
-
-    msg = wxT( " Yes" );
-    if( pt_texte->m_Miroir & 1 )
-        msg = wxT( " No" );
-    
-    Affiche_1_Parametre( frame, 36, _( "Mirror" ), msg, DARKGREEN );
-
-    msg.Printf( wxT( "%.1f" ), (float) pt_texte->m_Orient / 10 );
-    Affiche_1_Parametre( frame, 42, _( "Orient" ), msg, DARKGREEN );
-
-    valeur_param( pt_texte->m_Width, msg );
-    Affiche_1_Parametre( frame, 48, _( "Width" ), msg, DARKGREEN );
-
-    valeur_param( pt_texte->m_Size.x, msg );
-    Affiche_1_Parametre( frame, 56, _( "H Size" ), msg, RED );
-
-    valeur_param( pt_texte->m_Size.y, msg );
-    Affiche_1_Parametre( frame, 64, _( "V Size" ), msg, RED );
-}
-
-
-/*********************************************************************/
-void Affiche_Infos_Piste( WinEDA_BasePcbFrame* frame, TRACK* pt_piste )
-/********************************************************************/
-
-/* Affiche les caract principales d'un segment de piste en bas d'ecran
- */
-{
-    wxString msg;
-    int      text_pos;
-
-    frame->MsgPanel->EraseMsgBox();
-
-    switch( pt_piste->m_StructType )
-    {
-    case TYPEVIA:
-        msg = g_ViaType_Name[pt_piste->m_Shape & 255];
-        break;
-
-    case TYPETRACK:
-        msg = _( "Track" );
-        break;
-
-    case TYPEZONE:
-        msg = _( "Zone" ); break;
-
-    default:
-        msg = wxT( "????" ); break;
-    }
-
-    text_pos = 1;
-    Affiche_1_Parametre( frame, text_pos, _( "Type" ), msg, DARKCYAN );
-
-    /* Affiche NetName pour les segments de piste type cuivre */
-    text_pos += 15;
-    if( ( pt_piste->m_StructType == TYPETRACK )
-       || ( pt_piste->m_StructType == TYPEZONE )
-       || ( pt_piste->m_StructType == TYPEVIA ) )
-    {
-        EQUIPOT* equipot = GetEquipot( frame->m_Pcb, pt_piste->m_NetCode );
-        if( equipot )
-        {
-            msg = equipot->m_Netname;
-        }
-        else
-            msg = wxT( "<noname>" );
-        Affiche_1_Parametre( frame, text_pos, _( "NetName" ), msg, RED );
-
-        /* Affiche net code :*/
-        msg.Printf( wxT( "%d .%d" ), pt_piste->m_NetCode, pt_piste->m_Sous_Netcode );
-        text_pos += 18;
-        Affiche_1_Parametre( frame, text_pos, _( "NetCode" ), msg, RED );
-    }
-    else
-    {
-        Affiche_1_Parametre( frame, text_pos, _( "Segment" ), wxEmptyString, RED );
-        if( pt_piste->m_Shape == S_CIRCLE )
-            Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Circle" ), RED );
-        else
-            Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Standard" ), RED );
-    }
-
-
-    /* Affiche les flags Status piste */
-    msg = wxT( ". . " );
-    if( pt_piste->GetState( SEGM_FIXE ) )
-        msg[0] = 'F';
-    
-    if( pt_piste->GetState( SEGM_AR ) )
-        msg[2] = 'A';
-    
-    text_pos = 42;
-    Affiche_1_Parametre( frame, text_pos, _( "Stat" ), msg, MAGENTA );
-
-    /* Affiche Layer(s) */
-    if( pt_piste->m_StructType == TYPEVIA )
-    {
-        SEGVIA* Via = (SEGVIA*) pt_piste;
-        int     top_layer, bottom_layer;
-        
-        Via->ReturnLayerPair( &top_layer, &bottom_layer );
-        msg = ReturnPcbLayerName( top_layer, TRUE ) + wxT( "/" ) 
-                + ReturnPcbLayerName( bottom_layer, TRUE );
-    }
-    else
-        msg = ReturnPcbLayerName( pt_piste->m_Layer );
-
-    text_pos += 5;
-    Affiche_1_Parametre( frame, text_pos, _( "Layer" ), msg, BROWN );
-
-    /* Affiche Epaisseur */
-    valeur_param( (unsigned) (pt_piste->m_Width), msg );
-    text_pos += 11;
-    
-    if( pt_piste->m_StructType == TYPEVIA ) // Display Diam and Drill values
-    {
-        Affiche_1_Parametre( frame, text_pos, _( "Diam" ), msg, DARKCYAN );
-
-        int drill_value = (pt_piste->m_Drill >= 0 ) ?
-                          pt_piste->m_Drill : g_DesignSettings.m_ViaDrill;
-        valeur_param( (unsigned) drill_value, msg );
-        
-        text_pos += 8;
-        wxString title = _( "Drill" );
-        
-        if( g_DesignSettings.m_ViaDrill >= 0 )
-            title += wxT( "*" );
-        
-        Affiche_1_Parametre( frame, text_pos, _( "Drill" ), msg, RED );
-    }
-    else
-        Affiche_1_Parametre( frame, text_pos, _( "Width" ), msg, DARKCYAN );
-}
-
-
-/************************************************************/
-void Affiche_Infos_DrawSegment( WinEDA_BasePcbFrame* frame,
-                                DRAWSEGMENT*         DrawSegment )
-/************************************************************/
-/* Affiche les caract principales d'un segment type drawind PCB en bas d'ecran */
-{
-    int      itype;
-    wxString msg;
-
-    frame->MsgPanel->EraseMsgBox();
-
-    itype = DrawSegment->m_Type & 0x0F;
-
-    msg = wxT( "DRAWING" );
-    if( DrawSegment->m_StructType == TYPECOTATION )
-        msg = wxT( "COTATION" );
-
-    Affiche_1_Parametre( frame, 1, _( "Type" ), msg, DARKCYAN );
-
-    Affiche_1_Parametre( frame, 16, _( "Shape" ), wxEmptyString, RED );
-    
-    if( DrawSegment->m_Shape == S_CIRCLE )
-        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Circle" ), RED );
-    
-    else if( DrawSegment->m_Shape == S_ARC )
-    {
-        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "  Arc  " ), RED );
-        msg.Printf( wxT( "%d" ), DrawSegment->m_Angle );
-        Affiche_1_Parametre( frame, 32, wxT( " l.arc " ), msg, RED );
-    }
-    else
-        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Segment" ), RED );
-
-    Affiche_1_Parametre( frame, 48, _( "Layer" ), ReturnPcbLayerName(
-                             DrawSegment->m_Layer ), BROWN );
-
-    /* Affiche Epaisseur */
-    valeur_param( (unsigned) (DrawSegment->m_Width), msg );
-    Affiche_1_Parametre( frame, 60, _( "Width" ), msg, DARKCYAN );
-}
-
-
-/*****************************************************************************/
-void Affiche_Infos_Segment_Module( WinEDA_BasePcbFrame* frame,
-                                   MODULE* Module, EDGE_MODULE* pt_edge )
-/*****************************************************************************/
-
-/* Affiche en bas d'ecran les caract du Segment contour d'un module
- *  Les parametres du module doivent etre a jour*/
-{
-    wxString bufcar;
-
-    if( Module == NULL )
-        return;
-
-    frame->MsgPanel->EraseMsgBox();
-
-    Affiche_1_Parametre( frame, 1, _( "Seg" ), wxEmptyString, DARKCYAN );
-    Affiche_1_Parametre( frame, 5, _( "Module" ), Module->m_Reference->m_Text, DARKCYAN );
-
-    Affiche_1_Parametre( frame, 14, _( "Value" ), Module->m_Value->m_Text, BLUE );
-
-    bufcar.Printf( wxT( "%8.8lX" ), Module->m_TimeStamp );
-    Affiche_1_Parametre( frame, 24, _( "TimeStamp" ), bufcar, BROWN );
-
-    Affiche_1_Parametre( frame, 34, _( "Mod Layer" ), ReturnPcbLayerName( Module->m_Layer ), RED );
-
-    Affiche_1_Parametre( frame, 44, _( "Seg Layer" ),
-                         ReturnPcbLayerName( Module->m_Layer ), RED );
-
-    valeur_param( pt_edge->m_Width, bufcar );
-    Affiche_1_Parametre( frame, 54, _( "Width" ), bufcar, BLUE );
-}
-
-
-/*********************************************************/
-void Affiche_Infos_Status_Pcb( WinEDA_BasePcbFrame* frame )
-/*********************************************************/
-/* Affiche l'etat du PCB : nb de pads, nets , connexions.. */
-#define POS_AFF_NBPADS      1
-#define POS_AFF_NBVIAS      8
-#define POS_AFF_NBNODES     16
-#define POS_AFF_NBLINKS     24
-#define POS_AFF_NBNETS      32
-#define POS_AFF_NBCONNECT   40
-#define POS_AFF_NBNOCONNECT 48
-{
-    int             nb_vias = 0, ii;
-    EDA_BaseStruct* Struct;
-    wxString        txt;
-
-    frame->MsgPanel->EraseMsgBox();
-
-    txt.Printf( wxT( "%d" ), frame->m_Pcb->m_NbPads );
-    Affiche_1_Parametre( frame, POS_AFF_NBPADS, _( "Pads" ), txt, DARKGREEN );
-
-    for( ii = 0, Struct = frame->m_Pcb->m_Track; Struct != NULL; Struct = Struct->Pnext )
-    {
-        ii++;
-        if( Struct->m_StructType == TYPEVIA )
-            nb_vias++;
-    }
-
-    txt.Printf( wxT( "%d" ), nb_vias );
-    Affiche_1_Parametre( frame, POS_AFF_NBVIAS, _( "Vias" ), txt, DARKGREEN );
-
-    txt.Printf( wxT( "%d" ), frame->m_Pcb->GetNumNodes() );
-    Affiche_1_Parametre( frame, POS_AFF_NBNODES, _( "Nodes" ), txt, DARKCYAN );
-
-    txt.Printf( wxT( "%d" ), frame->m_Pcb->m_NbLinks );
-    Affiche_1_Parametre( frame, POS_AFF_NBLINKS, _( "Links" ), txt, DARKGREEN );
-
-    txt.Printf( wxT( "%d" ), frame->m_Pcb->m_NbNets );
-    Affiche_1_Parametre( frame, POS_AFF_NBNETS, _( "Nets" ), txt, RED );
-
-    txt.Printf( wxT( "%d" ), frame->m_Pcb->m_NbLinks - frame->m_Pcb->GetNumNoconnect() );
-    Affiche_1_Parametre( frame, POS_AFF_NBCONNECT, _( "Connect" ), txt, DARKGREEN );
-
-    txt.Printf( wxT( "%d" ), frame->m_Pcb->GetNumNoconnect() );
-    Affiche_1_Parametre( frame, POS_AFF_NBNOCONNECT, _( "NoConn" ), txt, BLUE );
-}
-
 
 /*******************************************************************/
 void Affiche_Infos_Equipot( int netcode, WinEDA_BasePcbFrame* frame )
@@ -376,7 +29,7 @@ void Affiche_Infos_Equipot( int netcode, WinEDA_BasePcbFrame* frame )
 
     frame->MsgPanel->EraseMsgBox();
 
-    equipot = GetEquipot( frame->m_Pcb, netcode );
+    equipot = frame->m_Pcb->FindNet( netcode );
     if( equipot )
         Affiche_1_Parametre( frame, 1, _( "Net Name" ), equipot->m_Netname, RED );
     else

pcbnew/attribut.cpp

@@ -29,7 +29,7 @@ void WinEDA_PcbFrame::Attribut_Segment( TRACK* track, wxDC* DC, bool Flag_On )
     track->SetState( SEGM_FIXE, Flag_On );
     track->Draw( DrawPanel, DC, GR_OR | GR_SURBRILL );
     DrawPanel->CursorOn( DC );    // Display cursor shape
-    Affiche_Infos_Piste( this, track );
+    track->Display_Infos( this );
 }
 
 

pcbnew/class_board.cpp

@@ -256,6 +256,54 @@ bool BOARD::ComputeBoundaryBox( void )
 }
 
 
+// virtual, see pcbstruct.h
+void BOARD::Display_Infos( WinEDA_DrawFrame* frame )
+{
+/* Affiche l'etat du PCB : nb de pads, nets , connexions.. */
+#define POS_AFF_NBPADS      1
+#define POS_AFF_NBVIAS      8
+#define POS_AFF_NBNODES     16
+#define POS_AFF_NBLINKS     24
+#define POS_AFF_NBNETS      32
+#define POS_AFF_NBCONNECT   40
+#define POS_AFF_NBNOCONNECT 48
+
+    int             nb_vias = 0, ii;
+    EDA_BaseStruct* Struct;
+    wxString        txt;
+
+    frame->MsgPanel->EraseMsgBox();
+
+    txt.Printf( wxT( "%d" ), m_NbPads );
+    Affiche_1_Parametre( frame, POS_AFF_NBPADS, _( "Pads" ), txt, DARKGREEN );
+
+    for( ii = 0, Struct = m_Track; Struct != NULL; Struct = Struct->Pnext )
+    {
+        ii++;
+        if( Struct->m_StructType == TYPEVIA )
+            nb_vias++;
+    }
+
+    txt.Printf( wxT( "%d" ), nb_vias );
+    Affiche_1_Parametre( frame, POS_AFF_NBVIAS, _( "Vias" ), txt, DARKGREEN );
+
+    txt.Printf( wxT( "%d" ), GetNumNodes() );
+    Affiche_1_Parametre( frame, POS_AFF_NBNODES, _( "Nodes" ), txt, DARKCYAN );
+
+    txt.Printf( wxT( "%d" ), m_NbLinks );
+    Affiche_1_Parametre( frame, POS_AFF_NBLINKS, _( "Links" ), txt, DARKGREEN );
+
+    txt.Printf( wxT( "%d" ), m_NbNets );
+    Affiche_1_Parametre( frame, POS_AFF_NBNETS, _( "Nets" ), txt, RED );
+
+    txt.Printf( wxT( "%d" ), m_NbLinks - GetNumNoconnect() );
+    Affiche_1_Parametre( frame, POS_AFF_NBCONNECT, _( "Connect" ), txt, DARKGREEN );
+
+    txt.Printf( wxT( "%d" ), GetNumNoconnect() );
+    Affiche_1_Parametre( frame, POS_AFF_NBNOCONNECT, _( "NoConn" ), txt, BLUE );
+}
+
+
 // virtual, see pcbstruct.h     
 SEARCH_RESULT BOARD::Visit( INSPECTOR* inspector, const void* testData, 
     const KICAD_T scanTypes[] )
@@ -398,6 +446,28 @@ EDA_BaseStruct* BOARD::FindPadOrModule( const wxPoint& refPos, int layer )
 }
 
 
+/**
+ * Function FindNet
+ * searches for a net with the given netcode.
+ * @param anetcode The netcode to search for.
+ * @return EQUIPOT* - the net or NULL if not found.
+ */
+EQUIPOT* BOARD::FindNet( int anetcode )
+{
+    if( anetcode <= 0 )
+        return NULL;
+
+    EQUIPOT* net = (EQUIPOT*) m_Equipots;
+    while( net )
+    {
+        if( net->m_NetCode == anetcode )
+            break;
+        net = (EQUIPOT*) net->Pnext;
+    }
+    return net;
+}
+
+
 #if defined(DEBUG)
 
 /**

pcbnew/class_cotation.cpp

@@ -8,6 +8,8 @@
 #include "common.h"
 #include "pcbnew.h"
 #include "trigo.h"
+#include "wxstruct.h"
+
 
 COTATION::COTATION( EDA_BaseStruct* StructFather ) :
     EDA_BaseStruct( StructFather, TYPECOTATION )
@@ -362,6 +364,14 @@ void COTATION::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
 }
 
 
+// see class_cotation.h
+void COTATION::Display_Infos( WinEDA_DrawFrame* frame )
+{
+    // for now, display only the text within the COTATION using class TEXTE_PCB.
+    m_Text->Display_Infos( frame );
+}
+
+
 /**
  * Function HitTest
  * tests if the given wxPoint is within the bounds of this object.

pcbnew/class_cotation.h

@@ -42,6 +42,16 @@ public:
 
     void    Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int mode_color );
 
+    
+    /**
+     * Function Display_Infos
+     * has knowledge about the frame and how and where to put status information
+     * about this object into the frame's message panel.
+     * Is virtual from EDA_BaseStruct.
+     * @param frame A WinEDA_BasePcbFrame in which to print status information.
+     */ 
+    void    Display_Infos( WinEDA_DrawFrame* frame );
+    
     /**
      * Function HitTest
      * tests if the given wxPoint is within the bounds of this object.

pcbnew/class_edge_mod.cpp

@@ -268,6 +268,35 @@ void EDGE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
 }
 
 
+// see class_edge_mod.h     
+void EDGE_MODULE::Display_Infos( WinEDA_DrawFrame* frame )
+{
+    wxString bufcar;
+
+    MODULE* module = (MODULE*) m_Parent;
+    if( !module )
+        return;
+    
+    frame->MsgPanel->EraseMsgBox();
+
+    Affiche_1_Parametre( frame, 1, _( "Seg" ), wxEmptyString, DARKCYAN );
+
+    Affiche_1_Parametre( frame, 5, _( "Module" ), module->m_Reference->m_Text, DARKCYAN );
+    Affiche_1_Parametre( frame, 14, _( "Value" ), module->m_Value->m_Text, BLUE );
+    bufcar.Printf( wxT( "%8.8lX" ), module->m_TimeStamp );
+
+    Affiche_1_Parametre( frame, 24, _( "TimeStamp" ), bufcar, BROWN );
+
+    Affiche_1_Parametre( frame, 34, _( "Mod Layer" ), ReturnPcbLayerName( module->m_Layer ), RED );
+
+    Affiche_1_Parametre( frame, 44, _( "Seg Layer" ),
+                         ReturnPcbLayerName( module->m_Layer ), RED );
+
+    valeur_param( m_Width, bufcar );
+    Affiche_1_Parametre( frame, 54, _( "Width" ), bufcar, BLUE );
+}
+
+
 /*****************************************/
 int EDGE_MODULE::WriteDescr( FILE* File )
 /*****************************************/

pcbnew/class_edge_mod.h

@@ -42,6 +42,17 @@ public:
                   int draw_mode );
     void    Draw3D( Pcb3D_GLCanvas* glcanvas );
 
+
+    /**
+     * Function Display_Infos
+     * has knowledge about the frame and how and where to put status information
+     * about this object into the frame's message panel.
+     * Is virtual from EDA_BaseStruct.
+     * @param frame A WinEDA_BasePcbFrame in which to print status information.
+     */ 
+    void            Display_Infos( WinEDA_DrawFrame* frame );
+    
+    
     /**
      * Function HitTest
      * tests if the given wxPoint is within the bounds of this object.

pcbnew/class_equipot.cpp

@@ -67,31 +67,6 @@ void EQUIPOT::UnLink( void )
 }
 
 
-/*************************************************/
-EQUIPOT* GetEquipot( BOARD* pcb, int netcode )
-/**************************************************/
-
-/*
- *  retourne un pointeur sur la structure EQUIPOT de numero netcode
- */
-{
-    EQUIPOT* Equipot;
-
-    if( netcode <= 0 )
-        return NULL;
-
-    Equipot = (EQUIPOT*) pcb->m_Equipots;
-    while( Equipot )
-    {
-        if( Equipot->m_NetCode == netcode )
-            break;
-        Equipot = (EQUIPOT*) Equipot->Pnext;
-    }
-
-    return Equipot;
-}
-
-
 /*********************************************************/
 int EQUIPOT:: ReadEquipotDescr( FILE* File, int* LineNum )
 /*********************************************************/

pcbnew/class_module.h

@@ -130,7 +130,12 @@ public:
     void    DrawAncre( WinEDA_DrawPanel* panel, wxDC* DC,
                        const wxPoint& offset, int dim_ancre, int draw_mode );
 
-    /* miscellaneous */
+    /**
+     * Function Display_Infos
+     * has knowledge about the frame and how and where to put status information
+     * about this object into the frame's message panel.
+     * @param frame A WinEDA_BasePcbFrame in which to print status information.
+     */ 
     void    Display_Infos( WinEDA_BasePcbFrame* frame );
 
     

pcbnew/class_pad.cpp

@@ -786,7 +786,7 @@ int D_PAD::WriteDescr( FILE* File )
 
 
 /******************************************************/
-void D_PAD::Display_Infos( WinEDA_BasePcbFrame* frame )
+void D_PAD::Display_Infos( WinEDA_DrawFrame* frame )
 /******************************************************/
 /* Affiche en bas d'ecran les caract de la pastille demandee */
 {

pcbnew/class_pad.h

@@ -89,8 +89,14 @@ public:
     void            ComputeRayon( void );                   // met a jour m_Rayon, rayon du cercle exinscrit
     const wxPoint   ReturnShapePos( void );                 // retourne la position
 
-    // de la forme (pastilles excentrees)
-    void            Display_Infos( WinEDA_BasePcbFrame* frame );
+    /**
+     * Function Display_Infos
+     * has knowledge about the frame and how and where to put status information
+     * about this object into the frame's message panel.
+     * Is virtual from EDA_BaseStruct.
+     * @param frame A WinEDA_BasePcbFrame in which to print status information.
+     */ 
+    void            Display_Infos( WinEDA_DrawFrame* frame );
     
     /**
      * Function HitTest

pcbnew/class_pcb_text.cpp

@@ -150,6 +150,44 @@ void TEXTE_PCB::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
                          (g_AnchorColor & ITEM_NOT_SHOW) ? -1 : (g_AnchorColor & MASKCOLOR) );
 }
 
+
+
+// see class_pcb_text.h
+void TEXTE_PCB::Display_Infos( WinEDA_DrawFrame* frame )
+{
+    wxString msg;
+
+    frame->MsgPanel->EraseMsgBox();
+
+    if( m_Parent && m_Parent->m_StructType == TYPECOTATION )
+        Affiche_1_Parametre( frame, 1, _( "COTATION" ), m_Text, DARKGREEN );
+    else
+        Affiche_1_Parametre( frame, 1, _( "PCB Text" ), m_Text, DARKGREEN );
+    
+    Affiche_1_Parametre( frame, 28, _( "Layer" ),
+                         ReturnPcbLayerName( m_Layer ),
+                         g_DesignSettings.m_LayerColor[m_Layer] & MASKCOLOR );
+
+    Affiche_1_Parametre( frame, 36, _( "Mirror" ), wxEmptyString, GREEN );
+    if( m_Miroir & 1 )
+        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "No" ), DARKGREEN );
+    else
+        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Yes" ), DARKGREEN );
+
+    msg.Printf( wxT( "%.1f" ), (float) m_Orient / 10 );
+    Affiche_1_Parametre( frame, 43, _( "Orient" ), msg, DARKGREEN );
+
+    valeur_param( m_Width, msg );
+    Affiche_1_Parametre( frame, 50, _( "Width" ), msg, MAGENTA );
+
+    valeur_param( m_Size.x, msg );
+    Affiche_1_Parametre( frame, 60, _( "H Size" ), msg, RED );
+
+    valeur_param( m_Size.y, msg );
+    Affiche_1_Parametre( frame, 70, _( "V Size" ), msg, RED );
+}
+
+
 #if defined(DEBUG)
 
 /**

pcbnew/class_pcb_text.h

@@ -6,7 +6,7 @@
 
 #include "base_struct.h"
 
-class TEXTE_PCB: public EDA_BaseStruct, public EDA_TextStruct
+class TEXTE_PCB : public EDA_BaseStruct, public EDA_TextStruct
 {
 public:
 	TEXTE_PCB(EDA_BaseStruct * parent);
@@ -26,6 +26,17 @@ public:
 	int ReadTextePcbDescr(FILE * File, int * LineNum);
 	int WriteTextePcbDescr(FILE * File);
 
+    
+    /**
+     * Function Display_Infos
+     * has knowledge about the frame and how and where to put status information
+     * about this object into the frame's message panel.
+     * Is virtual from EDA_BaseStruct.
+     * @param frame A WinEDA_BasePcbFrame in which to print status information.
+     */ 
+    void    Display_Infos( WinEDA_DrawFrame* frame );
+    
+    
 #if defined(DEBUG)
     /**
      * Function GetClass

pcbnew/class_text_mod.cpp

@@ -295,6 +295,70 @@ int TEXTE_MODULE::GetDrawRotation( void )
     return rotation;
 }
 
+
+// see class_text_mod.h 
+void TEXTE_MODULE::Display_Infos( WinEDA_DrawFrame* frame )  
+{
+    wxString msg, Line;
+    int      ii;
+    
+    MODULE* module = (MODULE*) m_Parent;
+    
+    if( !module )
+        return;
+
+    static const wxString text_type_msg[3] = { 
+        _( "Ref." ), _( "Value" ), _( "Text" ) };
+    
+    frame->MsgPanel->EraseMsgBox();
+
+    Line = module->m_Reference->m_Text;
+    Affiche_1_Parametre( frame, 1, _( "Module" ), Line, DARKCYAN );
+
+    Line = m_Text;
+    Affiche_1_Parametre( frame, 10, _( "Text" ), Line, YELLOW );
+
+    ii = m_Type; 
+    if( ii > 2 )
+        ii = 2;
+    
+    Affiche_1_Parametre( frame, 20, _( "Type" ), text_type_msg[ii], DARKGREEN );
+
+    Affiche_1_Parametre( frame, 25, _( "Display" ), wxEmptyString, DARKGREEN );
+    if( m_NoShow )
+        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "No" ), DARKGREEN );
+    else
+        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Yes" ), DARKGREEN );
+
+    ii = m_Layer;
+    if( ii <= 28 )
+        Affiche_1_Parametre( frame, 28, _( "Layer" ), ReturnPcbLayerName( ii ), DARKGREEN );
+    else
+    {
+        msg.Printf( wxT( "%d" ), ii );
+        Affiche_1_Parametre( frame, 28, _( "Layer" ), msg, DARKGREEN );
+    }
+
+    msg = wxT( " Yes" );
+    if( m_Miroir & 1 )
+        msg = wxT( " No" );
+    
+    Affiche_1_Parametre( frame, 36, _( "Mirror" ), msg, DARKGREEN );
+
+    msg.Printf( wxT( "%.1f" ), (float) m_Orient / 10 );
+    Affiche_1_Parametre( frame, 42, _( "Orient" ), msg, DARKGREEN );
+
+    valeur_param( m_Width, msg );
+    Affiche_1_Parametre( frame, 48, _( "Width" ), msg, DARKGREEN );
+
+    valeur_param( m_Size.x, msg );
+    Affiche_1_Parametre( frame, 56, _( "H Size" ), msg, RED );
+
+    valeur_param( m_Size.y, msg );
+    Affiche_1_Parametre( frame, 64, _( "V Size" ), msg, RED );
+}
+
+
 #if defined(DEBUG)
 /**
  * Function Show

pcbnew/class_text_mod.h

@@ -56,6 +56,17 @@ public:
     /* drawing functions */
     void    Draw( WinEDA_DrawPanel* panel, wxDC* DC, wxPoint offset, int draw_mode );
 
+    
+    /**
+     * Function Display_Infos
+     * has knowledge about the frame and how and where to put status information
+     * about this object into the frame's message panel.
+     * Is virtual from EDA_BaseStruct.
+     * @param frame A WinEDA_BasePcbFrame in which to print status information.
+     */ 
+    void            Display_Infos( WinEDA_DrawFrame* frame );
+
+    
     /**
      * Function HitTest
      * tests if the given wxPoint is within the bounds of this object.

pcbnew/class_track.cpp

@@ -13,6 +13,7 @@
 #endif
 
 #include "trigo.h"
+#include "protos.h"
 
 
 /**************************************/
@@ -631,6 +632,115 @@ void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode )
 }
 
 
+// see class_track.h
+void TRACK::Display_Infos( WinEDA_DrawFrame* frame )
+{
+    wxString msg;
+    int      text_pos;
+
+    frame->MsgPanel->EraseMsgBox();
+
+    switch( m_StructType )
+    {
+    case TYPEVIA:
+        msg = g_ViaType_Name[m_Shape & 255];
+        break;
+
+    case TYPETRACK:
+        msg = _( "Track" );
+        break;
+
+    case TYPEZONE:
+        msg = _( "Zone" ); break;
+
+    default:
+        msg = wxT( "????" ); break;
+    }
+
+    text_pos = 1;
+    Affiche_1_Parametre( frame, text_pos, _( "Type" ), msg, DARKCYAN );
+
+    /* Affiche NetName pour les segments de piste type cuivre */
+    text_pos += 15;
+    if(  m_StructType == TYPETRACK 
+      || m_StructType == TYPEZONE
+      || m_StructType == TYPEVIA )
+    {
+        EQUIPOT* equipot = ((WinEDA_PcbFrame*)frame)->m_Pcb->FindNet( m_NetCode );
+        if( equipot )
+        {
+            msg = equipot->m_Netname;
+        }
+        else
+            msg = wxT( "<noname>" );
+        Affiche_1_Parametre( frame, text_pos, _( "NetName" ), msg, RED );
+
+        /* Affiche net code :*/
+        msg.Printf( wxT( "%d .%d" ), m_NetCode, m_Sous_Netcode );
+        text_pos += 18;
+        Affiche_1_Parametre( frame, text_pos, _( "NetCode" ), msg, RED );
+    }
+    else
+    {
+        Affiche_1_Parametre( frame, text_pos, _( "Segment" ), wxEmptyString, RED );
+        if( m_Shape == S_CIRCLE )
+            Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Circle" ), RED );
+        else
+            Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Standard" ), RED );
+    }
+
+    /* Affiche les flags Status piste */
+    msg = wxT( ". . " );
+    if( GetState( SEGM_FIXE ) )
+        msg[0] = 'F';
+    
+    if( GetState( SEGM_AR ) )
+        msg[2] = 'A';
+    
+    text_pos = 42;
+    Affiche_1_Parametre( frame, text_pos, _( "Stat" ), msg, MAGENTA );
+
+    /* Affiche Layer(s) */
+    if( m_StructType == TYPEVIA )
+    {
+        SEGVIA* Via = (SEGVIA*) this;
+        int     top_layer, bottom_layer;
+        
+        Via->ReturnLayerPair( &top_layer, &bottom_layer );
+        msg = ReturnPcbLayerName( top_layer, TRUE ) + wxT( "/" ) 
+                + ReturnPcbLayerName( bottom_layer, TRUE );
+    }
+    else
+        msg = ReturnPcbLayerName( m_Layer );
+
+    text_pos += 5;
+    Affiche_1_Parametre( frame, text_pos, _( "Layer" ), msg, BROWN );
+
+    /* Affiche Epaisseur */
+    valeur_param( (unsigned) m_Width, msg );
+    text_pos += 11;
+    
+    if( m_StructType == TYPEVIA )      // Display Diam and Drill values
+    {
+        Affiche_1_Parametre( frame, text_pos, _( "Diam" ), msg, DARKCYAN );
+
+        int drill_value = m_Drill >= 0  ?
+                          m_Drill : g_DesignSettings.m_ViaDrill;
+        valeur_param( (unsigned) drill_value, msg );
+        
+        text_pos += 8;
+        wxString title = _( "Drill" );
+        
+        if( g_DesignSettings.m_ViaDrill >= 0 )
+            title += wxT( "*" );
+        
+        Affiche_1_Parametre( frame, text_pos, _( "Drill" ), msg, RED );
+    }
+    else
+        Affiche_1_Parametre( frame, text_pos, _( "Width" ), msg, DARKCYAN );
+}
+
+
 /**
  * Function HitTest
  * tests if the given wxPoint is within the bounds of this object.

pcbnew/class_track.h

@@ -76,6 +76,17 @@ public:
     int     IsPointOnEnds( const wxPoint& point, int min_dist = 0 );
     bool    IsNull( void ); // return TRUE if segment lenght = 0
 
+    
+    /**
+     * Function Display_Infos
+     * has knowledge about the frame and how and where to put status information
+     * about this object into the frame's message panel.
+     * Is virtual from EDA_BaseStruct.
+     * @param frame A WinEDA_BasePcbFrame in which to print status information.
+     */ 
+    void    Display_Infos( WinEDA_DrawFrame* frame );
+
+    
     /**
      * Function HitTest
      * tests if the given wxPoint is within the bounds of this object.

pcbnew/classpcb.cpp

@@ -166,6 +166,43 @@ bool DRAWSEGMENT::ReadDrawSegmentDescr( FILE* File, int* LineNum )
 }
 
 
+// see pcbstruct.h
+void DRAWSEGMENT::Display_Infos( WinEDA_DrawFrame* frame )
+{
+    int      itype;
+    wxString msg;
+
+    frame->MsgPanel->EraseMsgBox();
+
+    itype = m_Type & 0x0F;
+
+    msg = wxT( "DRAWING" );
+
+    Affiche_1_Parametre( frame, 1, _( "Type" ), msg, DARKCYAN );
+
+    Affiche_1_Parametre( frame, 16, _( "Shape" ), wxEmptyString, RED );
+    
+    if( m_Shape == S_CIRCLE )
+        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Circle" ), RED );
+    
+    else if( m_Shape == S_ARC )
+    {
+        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "  Arc  " ), RED );
+        msg.Printf( wxT( "%d" ), m_Angle );
+        Affiche_1_Parametre( frame, 32, wxT( " l.arc " ), msg, RED );
+    }
+    else
+        Affiche_1_Parametre( frame, -1, wxEmptyString, _( "Segment" ), RED );
+
+    Affiche_1_Parametre( frame, 48, _( "Layer" ), 
+             ReturnPcbLayerName( m_Layer ), BROWN );
+
+    /* Affiche Epaisseur */
+    valeur_param( (unsigned) m_Width, msg );
+    Affiche_1_Parametre( frame, 60, _( "Width" ), msg, DARKCYAN );
+}
+
+
 /**
  * Function HitTest
  * tests if the given wxPoint is within the bounds of this object.

pcbnew/controle.cpp

@@ -34,7 +34,7 @@ void RemoteCommand( const char* cmdline )
     char*            idcmd;
     char*            text;
     WinEDA_PcbFrame* frame = EDA_Appl->m_PcbFrame;
-    MODULE*          module;
+    MODULE*          module = 0;
 
     strncpy( line, cmdline, sizeof(line) - 1 );
     msg = CONV_FROM_UTF8( line );

pcbnew/deltrack.cpp

@@ -117,7 +117,7 @@ TRACK* WinEDA_PcbFrame::Delete_Segment( wxDC* DC, TRACK* Track )
     GetScreen()->SetModify();
 
     test_1_net_connexion( DC, current_net_code );
-    Affiche_Infos_Status_Pcb( this );
+    m_Pcb->Display_Infos( this );
     return NULL;
 }
 
@@ -132,7 +132,7 @@ void WinEDA_PcbFrame::Delete_Track( wxDC* DC, TRACK* Track )
         Supprime_Une_Piste( DC, Track );
         GetScreen()->SetModify();
         test_1_net_connexion( DC, current_net_code );
-        Affiche_Infos_Status_Pcb( this );
+        m_Pcb->Display_Infos( this );
     }
 }
 
@@ -170,7 +170,7 @@ void WinEDA_PcbFrame::Delete_net( wxDC* DC, TRACK* Track )
         SaveItemEfface( pt_start, ii );
         GetScreen()->SetModify();
         test_1_net_connexion( DC, net_code_delete );
-        Affiche_Infos_Status_Pcb( this );
+        m_Pcb->Display_Infos( this );
     }
 }
 

pcbnew/drc.cpp

@@ -336,7 +336,7 @@ int WinEDA_PcbFrame::Test_DRC( wxDC* DC, bool TestPad2Pad, bool TestZone )
         {
             wxString msg;
             jj = 1;
-            EQUIPOT* equipot = GetEquipot( m_Pcb, pt_segm->m_NetCode );
+            EQUIPOT* equipot = m_Pcb->FindNet( pt_segm->m_NetCode );
             if( equipot )
                 msg = equipot->m_Netname + wxT( "        " );
             else
@@ -409,7 +409,7 @@ int WinEDA_PcbFrame::Test_DRC( wxDC* DC, bool TestPad2Pad, bool TestZone )
             {
                 jj = 1;
                 wxString msg;
-                EQUIPOT* equipot = GetEquipot( m_Pcb, pt_segm->m_NetCode );
+                EQUIPOT* equipot = m_Pcb->FindNet( pt_segm->m_NetCode );
                 if( equipot )
                     msg = equipot->m_Netname + wxT( "        " );
                 else
@@ -1296,7 +1296,7 @@ static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb,
     TRACK*   pt_segm;
     wxString msg;
     wxString tracktype, netname1, netname2;
-    EQUIPOT* equipot = GetEquipot( Pcb, pt_ref->m_NetCode );
+    EQUIPOT* equipot = Pcb->FindNet( pt_ref->m_NetCode );
 
     if( equipot )
         netname1 = equipot->m_Netname;
@@ -1314,7 +1314,7 @@ static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb,
     if( ( (EDA_BaseStruct*) pt_item )->m_StructType == TYPEPAD )
     {
         D_PAD* pad = (D_PAD*) pt_item;
-        equipot = GetEquipot( Pcb, pad->m_NetCode );
+        equipot = Pcb->FindNet( pad->m_NetCode );
         if( equipot )
             netname2 = equipot->m_Netname;
         erc_pos = pad->m_Pos;
@@ -1330,7 +1330,7 @@ static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb,
     else    /* erreur sur segment de piste */
     {
         pt_segm = (TRACK*) pt_item;
-        equipot = GetEquipot( Pcb, pt_segm->m_NetCode );
+        equipot = Pcb->FindNet( pt_segm->m_NetCode );
         if( equipot )
             netname2 = equipot->m_Netname;
         erc_pos = pt_segm->m_Start;
@@ -1393,13 +1393,13 @@ static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb,
     wxString pad_name2    = pad2->ReturnStringPadName();
     wxString module_name2 = ( (MODULE*) (pad2->m_Parent) )->m_Reference->m_Text;
     wxString netname1, netname2;
-    EQUIPOT* equipot = GetEquipot( Pcb, pad1->m_NetCode );
+    EQUIPOT* equipot = Pcb->FindNet( pad1->m_NetCode );
 
     if( equipot )
         netname1 = equipot->m_Netname;
     else
         netname1 = wxT( "<noname>" );
-    equipot = GetEquipot( Pcb, pad2->m_NetCode );
+    equipot = Pcb->FindNet( pad2->m_NetCode );
     if( equipot )
         netname2 = equipot->m_Netname;
     else

pcbnew/edit.cpp

@@ -121,7 +121,7 @@ void WinEDA_PcbFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
     {
         int netcode = Select_High_Light( DC );
         if( netcode < 0 )
-            Affiche_Infos_Status_Pcb( this );
+            m_Pcb->Display_Infos( this );
         else
             Affiche_Infos_Equipot( netcode, this );
     }

pcbnew/editedge.cpp

@@ -33,7 +33,7 @@ void WinEDA_PcbFrame::Start_Move_DrawItem( DRAWSEGMENT* drawitem, wxDC* DC )
     Trace_DrawSegmentPcb( DrawPanel, DC, drawitem, GR_XOR );
     drawitem->m_Flags |= IS_MOVED;
     cursor_pos = cursor_pos0 = GetScreen()->m_Curseur;
-    Affiche_Infos_DrawSegment( this, drawitem );
+    drawitem->Display_Infos( this );
     DrawPanel->ManageCurseur = Move_Segment;
     DrawPanel->ForceCloseManageCurseur = Exit_EditEdge;
     GetScreen()->SetCurItem( drawitem );
@@ -145,7 +145,7 @@ void WinEDA_PcbFrame::Drawing_SetNewWidth( DRAWSEGMENT* DrawSegm, wxDC* DC )
 
     Trace_DrawSegmentPcb( DrawPanel, DC, DrawSegm, GR_OR );
 
-    Affiche_Infos_DrawSegment( this, DrawSegm );
+    DrawSegm->Display_Infos( this );
 
     GetScreen()->SetModify();
 }

pcbnew/editrack-part2.cpp

@@ -147,7 +147,7 @@ void WinEDA_PcbFrame::ExChange_Track_Layer( TRACK* pt_segm, wxDC* DC )
     }
 
     test_1_net_connexion( DC, pt_track->m_NetCode );
-    Affiche_Infos_Piste( this, pt_track );
+    pt_track->Display_Infos( this );
     GetScreen()->SetModify();
 }
 
@@ -255,7 +255,7 @@ void WinEDA_PcbFrame::Other_Layer_Route( TRACK* track, wxDC* DC )
     }
 
     DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
-    Affiche_Infos_Piste( this, Via );
+    Via->Display_Infos( this );
 
     Affiche_Status_Box();
     SetToolbars();
@@ -276,7 +276,7 @@ void WinEDA_PcbFrame::Affiche_Status_Net( wxDC* DC )
 
     pt_segm = Locate_Pistes( m_Pcb->m_Track, masquelayer, CURSEUR_OFF_GRILLE );
     if( pt_segm == NULL )
-        Affiche_Infos_Status_Pcb( this );
+        m_Pcb->Display_Infos( this );
     else
         test_1_net_connexion( DC, pt_segm->m_NetCode );
 }

pcbnew/editrack.cpp

@@ -153,7 +153,7 @@ TRACK* WinEDA_PcbFrame::Begin_Route( TRACK* track, wxDC* DC )
             g_FirstTrackSegment->end = g_CurrentTrackSegment;
             g_FirstTrackSegment->SetState( BEGIN_ONPAD | END_ONPAD, OFF );
         }
-        Affiche_Infos_Piste( this, g_CurrentTrackSegment );
+        g_CurrentTrackSegment->Display_Infos( this );
         GetScreen()->SetCurItem( g_CurrentTrackSegment );
         DrawPanel->ManageCurseur( DrawPanel, DC, FALSE );
         if( Drc_On && (Drc( this, DC, g_CurrentTrackSegment, m_Pcb->m_Track, 1 ) == BAD_DRC) )
@@ -216,7 +216,7 @@ TRACK* WinEDA_PcbFrame::Begin_Route( TRACK* track, wxDC* DC )
             /* Show the new position */
             ShowNewTrackWhenMovingCursor( DrawPanel, DC, FALSE );
         }
-        Affiche_Infos_Piste( this, g_CurrentTrackSegment );
+        g_CurrentTrackSegment->Display_Infos( this );
     }
 
     GetScreen()->SetCurItem( g_CurrentTrackSegment );
@@ -456,7 +456,7 @@ void WinEDA_PcbFrame::End_Route( TRACK* track, wxDC* DC )
         test_1_net_connexion( DC, g_FirstTrackSegment->m_NetCode );
 
         GetScreen()->SetModify();
-        Affiche_Infos_Status_Pcb( this );
+        m_Pcb->Display_Infos( this );
     }
     /* Finish the work, clear used variables */
     g_FirstTrackSegment = NULL;

pcbnew/edtxtmod.cpp

@@ -58,7 +58,7 @@ TEXTE_MODULE* WinEDA_BasePcbFrame::CreateTextModule( MODULE* Module, wxDC* DC )
     Text->m_Flags = 0;
     Text->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
 
-    Affiche_Infos_E_Texte( this, Module, Text );
+    Text->Display_Infos( this );
 
     return Text;
 }
@@ -69,12 +69,10 @@ void WinEDA_BasePcbFrame::RotateTextModule( TEXTE_MODULE* Text, wxDC* DC )
 /**************************************************************************/
 /* Rotation de 90 du texte d'un module */
 {
-    MODULE* Module;
-
     if( Text == NULL )
         return;
 
-    Module = (MODULE*) Text->m_Parent;
+    MODULE* module = (MODULE*) Text->m_Parent;
 
     Text->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
 
@@ -85,9 +83,9 @@ void WinEDA_BasePcbFrame::RotateTextModule( TEXTE_MODULE* Text, wxDC* DC )
     /* Redessin du Texte */
     Text->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
 
-    Affiche_Infos_E_Texte( this, Module, Text );
+    Text->Display_Infos( this );
 
-    ( (MODULE*) Text->m_Parent )->m_LastEdit_Time = time( NULL );
+    module->m_LastEdit_Time = time( NULL );
     GetScreen()->SetModify();
 }
 
@@ -171,7 +169,7 @@ void WinEDA_BasePcbFrame::StartMoveTexteModule( TEXTE_MODULE* Text, wxDC* DC )
     MoveVector.x = MoveVector.y = 0;
     CursorInitialPosition = Text->m_Pos;
 
-    Affiche_Infos_E_Texte( this, Module, Text );
+    Text->Display_Infos( this );
 
     GetScreen()->SetCurItem( Text );
     DrawPanel->ManageCurseur = Show_MoveTexte_Module;

pcbnew/export_gencad.cpp

@@ -566,7 +566,7 @@ int nbitems, ii;
 		if ( old_netcode != track->m_NetCode )
 		{
 			old_netcode = track->m_NetCode;
-			EQUIPOT * equipot = GetEquipot( pcb, track->m_NetCode);
+			EQUIPOT * equipot = pcb->FindNet( track->m_NetCode);
 			wxString netname; 
 			if (equipot && (equipot->m_Netname != wxEmptyString) )
 				netname = equipot->m_Netname;

pcbnew/files.cpp

@@ -230,7 +230,7 @@ int WinEDA_PcbFrame::LoadOnePcbFile( const wxString& FullFileName, wxDC* DC, boo
     /* liste des pads recalculee avec Affichage des messages d'erreur */
     build_liste_pads();
 
-    Affiche_Infos_Status_Pcb( this );
+    m_Pcb->Display_Infos( this );
 
     g_SaveTime = time( NULL );
 

pcbnew/locate.cpp

@@ -92,35 +92,36 @@ EDA_BaseStruct* WinEDA_BasePcbFrame::Locate( int typeloc, int LayerSearch )
  * return a pointer to this item ( or NULL )
  */
 {
-    TEXTE_PCB*      pt_texte_pcb;
-    TRACK*          Track, * TrackLocate;
-    DRAWSEGMENT*    DrawSegm;
-    MODULE*         module;
-    D_PAD*          pt_pad;
     int             masque_layer;
     EDA_BaseStruct* item;
 
-    pt_texte_pcb = Locate_Texte_Pcb( m_Pcb->m_Drawings, LayerSearch, typeloc );
-    if( pt_texte_pcb ) // a PCB text is found
+    item = Locate_Texte_Pcb( m_Pcb->m_Drawings, LayerSearch, typeloc );
+    if( item ) 
     {
-        Affiche_Infos_PCB_Texte( this, pt_texte_pcb );
-        return pt_texte_pcb;
+        item->Display_Infos( this );
+        return item;
     }
 
-    DrawSegm = Locate_Segment_Pcb( m_Pcb, LayerSearch, typeloc );
-    if( DrawSegm != NULL )
+    item = Locate_Segment_Pcb( m_Pcb, LayerSearch, typeloc );
+    if( item )
     {
-        Affiche_Infos_DrawSegment( this, DrawSegm );
-        return DrawSegm;
+        item->Display_Infos( this );
+        return item;
     }
 
     item = Locate_Cotation( m_Pcb, LayerSearch, typeloc );
-    if( item != NULL )
+    if( item )
+    {
+        item->Display_Infos( this );
         return item;
+    }
 
     item = Locate_MirePcb( m_Pcb->m_Drawings, LayerSearch, typeloc );
     if( item != NULL )
+    {
+        item->Display_Infos( this );    // MIRES::Display_Infos() not implemented yet.
         return item;
+    }
 
     /* Search for tracks and vias, with via priority */
     if( LayerSearch == -1 )
@@ -128,10 +129,11 @@ EDA_BaseStruct* WinEDA_BasePcbFrame::Locate( int typeloc, int LayerSearch )
     else
         masque_layer = g_TabOneLayerMask[LayerSearch];
 
+    TRACK* Track;
     Track = Locate_Pistes( m_Pcb->m_Track, masque_layer, typeloc );
     if( Track != NULL )
     {
-        TrackLocate = Track;   /* a track or a via is found */
+        TRACK* TrackLocate = Track;   /* a track or a via is found */
         
         /* Search for a via */
         while( ( TrackLocate = Locate_Pistes( TrackLocate,
@@ -144,16 +146,18 @@ EDA_BaseStruct* WinEDA_BasePcbFrame::Locate( int typeloc, int LayerSearch )
             TrackLocate = (TRACK*) TrackLocate->Pnext;
         }
 
-        Affiche_Infos_Piste( this, Track );
+        Track->Display_Infos( this );
         return Track;
     }
 
-    /* Search for Pads */
-    if( ( pt_pad = Locate_Any_Pad( m_Pcb, typeloc ) ) != NULL )
+    item = Locate_Any_Pad( m_Pcb, typeloc );
+    if( item )
     {
-        pt_pad->Display_Infos( this ); return pt_pad;
+        item->Display_Infos( this ); 
+        return item;
     }
 
+    
     /* Search for a footprint text */
 
     // First search: locate texts for footprints on copper or component layer
@@ -162,48 +166,46 @@ EDA_BaseStruct* WinEDA_BasePcbFrame::Locate( int typeloc, int LayerSearch )
     // on the same layer
     if( LayerSearch == LAYER_CUIVRE_N   ||   LayerSearch == CMP_N )
     {
-        for( module = m_Pcb->m_Modules; module != NULL; module = (MODULE*) module->Pnext )
+        MODULE* module = m_Pcb->m_Modules;
+        for(   ;   module != NULL;  module = (MODULE*) module->Pnext )
         {
-            TEXTE_MODULE* pt_texte;
-
             if( module->m_Layer != LayerSearch )
                 continue;
 
-            pt_texte = LocateTexteModule( m_Pcb, &module, typeloc | VISIBLE_ONLY );
-            if( pt_texte != NULL )
+            item = LocateTexteModule( m_Pcb, &module, typeloc | VISIBLE_ONLY );
+            if( item )
             {
-                Affiche_Infos_E_Texte( this, module, pt_texte );
-                return pt_texte;
+                item->Display_Infos( this );
+                return item;
             }
         }
     }
 
     // Now Search footprint texts on all layers
+    MODULE* module;
     module = NULL;
+    item = LocateTexteModule( m_Pcb, &module, typeloc | VISIBLE_ONLY );
+    if( item )
     {
-        TEXTE_MODULE* pt_texte;
-        pt_texte = LocateTexteModule( m_Pcb, &module, typeloc | VISIBLE_ONLY );
-        if( pt_texte != NULL )
-        {
-            Affiche_Infos_E_Texte( this, module, pt_texte );
-            return pt_texte;
-        }
+        item->Display_Infos( this );
+        return item;
     }
 
     /* Search for a footprint */
-    module = Locate_Prefered_Module( m_Pcb, typeloc | VISIBLE_ONLY );
-    if( module != NULL )
+    item = Locate_Prefered_Module( m_Pcb, typeloc | VISIBLE_ONLY );
+    if( item )
     {
-        module->Display_Infos( this );
-        return module;
+        item->Display_Infos( this );
+        return item;
     }
 
     /* Search for zones */
-    if( ( TrackLocate = Locate_Zone( (TRACK*) m_Pcb->m_Zone,
-                                    GetScreen()->m_Active_Layer, typeloc ) ) != NULL )
+    item = Locate_Zone( (TRACK*) m_Pcb->m_Zone,
+                                    GetScreen()->m_Active_Layer, typeloc );
+    if( item )
     {
-        Affiche_Infos_Piste( this, TrackLocate );
-        return TrackLocate;
+        item->Display_Infos( this );
+        return item;
     }
 
     MsgPanel->EraseMsgBox();

pcbnew/modedit.cpp

@@ -31,7 +31,7 @@ EDA_BaseStruct* WinEDA_ModuleEditFrame::ModeditLocateAndDisplay( void )
     DrawStruct = Locate_Edge_Module( Module, CURSEUR_OFF_GRILLE );
     if( DrawStruct )
     {
-        Affiche_Infos_Segment_Module( this, Module, (EDGE_MODULE*) DrawStruct );
+        DrawStruct->Display_Infos( this );
     }
     else
         DrawStruct = Locate( CURSEUR_OFF_GRILLE, -1 );

pcbnew/move_copy_track.cpp

@@ -488,7 +488,7 @@ void WinEDA_PcbFrame::Place_Dupl_Route( Track* Track, wxDC* DC )
         }
     }
     NewTrack = NULL;
-    Affiche_Infos_Status_Pcb( Cmd );
+    m_Pcb->Display_Infos( Cmd );
     if( Etat_Surbrillance )
         Hight_Light( DC );
 }

pcbnew/netlist.cpp

-	/************************************/
-	/* PCBNEW: traitement des netlistes */
-	/************************************/
+/************************************/
+/* PCBNEW: traitement des netlistes */
+/************************************/
 
-	/* Fichier NETLIST.CPP */
+/* Fichier NETLIST.CPP */
 
 /*
-Fonction de lecture de la netliste pour:
-	- Chargement modules et nouvelles connexions 
-	- Test des modules (modules manquants ou en trop
-	- Recalcul du chevelu
-	
-Remarque importante:
-	Lors de la lecture de la netliste pour Chargement modules
-	et nouvelles connexions, l'identification des modules peut se faire selon
-	2 criteres:
-		- la reference (U2, R5 ..): c'est le mode normal
-		- le Time Stamp (Signature Temporelle), a utiliser apres reannotation
-			d'un schema, donc apres modification des references sans pourtant
-			avoir reellement modifie le schema
-*/
+ *  Fonction de lecture de la netliste pour:
+ *  - Chargement modules et nouvelles connexions
+ *  - Test des modules (modules manquants ou en trop
+ *  - Recalcul du chevelu
+ * 
+ *  Remarque importante:
+ *  Lors de la lecture de la netliste pour Chargement modules
+ *  et nouvelles connexions, l'identification des modules peut se faire selon
+ *  2 criteres:
+ *      - la reference (U2, R5 ..): c'est le mode normal
+ *      - le Time Stamp (Signature Temporelle), a utiliser apres reannotation
+ *          d'un schema, donc apres modification des references sans pourtant
+ *          avoir reellement modifie le schema
+ */
 #include "fctsys.h"
 #include "gr_basic.h"
 #include "common.h"
@@ -38,138 +38,147 @@ public:
     wxString m_CmpName;
 
 public:
-	MODULEtoLOAD(const wxString & libname, const wxString & cmpname, int timestamp);
-	~MODULEtoLOAD(void){};
-	MODULEtoLOAD * Next(void) { return (MODULEtoLOAD *) Pnext; }
+    MODULEtoLOAD( const wxString& libname, const wxString& cmpname, int timestamp );
+    ~MODULEtoLOAD( void ) { };
+    MODULEtoLOAD* Next( void ) { return (MODULEtoLOAD*) Pnext; }
 };
 
 /* Fonctions locales : */
-static void SortListModulesToLoadByLibname(int NbModules);
+static void SortListModulesToLoadByLibname( int NbModules );
 
 
 /* Variables locales */
 static int           s_NbNewModules;
-static MODULEtoLOAD * s_ModuleToLoad_List;
-FILE * source;
+static MODULEtoLOAD* s_ModuleToLoad_List;
+FILE* source;
 static bool          ChangeExistantModule;
 static bool          DisplayWarning = TRUE;
-static int DisplayWarningCount ;
+static int           DisplayWarningCount;
 
-	/*****************************/
-	/* class WinEDA_NetlistFrame */
-	/*****************************/
+/*****************************/
+/* class WinEDA_NetlistFrame */
+/*****************************/
 #include "dialog_netlist.cpp"
 
 
-
 /*************************************************************************/
-void WinEDA_PcbFrame::InstallNetlistFrame( wxDC * DC, const wxPoint & pos)
+void WinEDA_PcbFrame::InstallNetlistFrame( wxDC* DC, const wxPoint& pos )
 /*************************************************************************/
 {
-	WinEDA_NetlistFrame * frame = new WinEDA_NetlistFrame(this, DC);
+    WinEDA_NetlistFrame* frame = new WinEDA_NetlistFrame( this, DC );
+
     frame->ShowModal(); frame->Destroy();
 }
 
 
-
 /***************************************************************/
-bool WinEDA_NetlistFrame::OpenNetlistFile(wxCommandEvent& event)
+bool WinEDA_NetlistFrame::OpenNetlistFile( wxCommandEvent& event )
 /***************************************************************/
+
 /*
- routine de selection et d'ouverture du fichier Netlist
-*/
+ *  routine de selection et d'ouverture du fichier Netlist
+ */
 {
-wxString FullFileName;
-wxString msg;
+    wxString FullFileName;
+    wxString msg;
 
     if( NetNameBuffer.IsEmpty() ) /* Pas de nom specifie */
-		Set_NetlisteName(event);
+        Set_NetlisteName( event );
 
-	if( NetNameBuffer.IsEmpty() )  return(FALSE); /* toujours Pas de nom specifie */
+    if( NetNameBuffer.IsEmpty() )
+        return FALSE;                             /* toujours Pas de nom specifie */
 
     FullFileName = NetNameBuffer;
 
-	source = wxFopen(FullFileName, wxT("rt") );
-	if (source == 0)
+    source = wxFopen( FullFileName, wxT( "rt" ) );
+    if( source == 0 )
     {
-		msg.Printf(_("Netlist file %s not found"),FullFileName.GetData()) ;
-		DisplayError(this, msg) ;
-		return FALSE ;
+        msg.Printf( _( "Netlist file %s not found" ), FullFileName.GetData() );
+        DisplayError( this, msg );
+        return FALSE;
     }
 
-	msg = wxT("Netlist "); msg << FullFileName;
-	SetTitle(msg);
+    msg = wxT( "Netlist " ); msg << FullFileName;
+    SetTitle( msg );
 
     return TRUE;
 }
 
 
 /**************************************************************/
-void WinEDA_NetlistFrame::ReadPcbNetlist(wxCommandEvent& event)
+void WinEDA_NetlistFrame::ReadPcbNetlist( wxCommandEvent& event )
 /**************************************************************/
+
 /* mise a jour des empreintes :
-	corrige les Net Names, les textes, les "TIME STAMP"
-
-	Analyse les lignes:
-# EESchema Netlist Version 1.0 generee le  18/5/2005-12:30:22
-(
- ( 40C08647 $noname R20 4,7K {Lib=R}
-  (    1 VCC )
-  (    2 MODB_1 )
- )
- ( 40C0863F $noname R18 4,7_k {Lib=R}
-  (    1 VCC )
-  (    2 MODA_1 )
- )
-}
-#End
-*/
+ *  corrige les Net Names, les textes, les "TIME STAMP"
+ * 
+ *  Analyse les lignes:
+ # EESchema Netlist Version 1.0 generee le  18/5/2005-12:30:22
+ *  (
+ *  ( 40C08647 $noname R20 4,7K {Lib=R}
+ *  (    1 VCC )
+ *  (    2 MODB_1 )
+ *  )
+ *  ( 40C0863F $noname R18 4,7_k {Lib=R}
+ *  (    1 VCC )
+ *  (    2 MODA_1 )
+ *  )
+ *  }
+ #End
+ */
 {
-int LineNum, State, Comment;
-MODULE * Module = NULL;
-D_PAD * PtPad;
-char Line[256], *Text;
-int UseFichCmp = 1;
-wxString msg;
+    int      LineNum, State, Comment;
+    MODULE*  Module = NULL;
+    D_PAD*   PtPad;
+    char     Line[256], * Text;
+    int      UseFichCmp = 1;
+    wxString msg;
 
     ChangeExistantModule = m_ChangeExistantModuleCtrl->GetSelection() == 1 ? TRUE : FALSE;
     DisplayWarning = m_DisplayWarningCtrl->GetValue();
-    if ( DisplayWarning ) DisplayWarningCount = 8;
-    else  DisplayWarningCount = 0;
+    if( DisplayWarning )
+        DisplayWarningCount = 8;
+    else
+        DisplayWarningCount = 0;
 
-	if( ! OpenNetlistFile(event) ) return;
+    if( !OpenNetlistFile( event ) )
+        return;
 
-	msg = _("Read Netlist ") + NetNameBuffer;
-	m_MessageWindow->AppendText(msg);
+    msg = _( "Read Netlist " ) + NetNameBuffer;
+    m_MessageWindow->AppendText( msg );
 
     m_Parent->m_CurrentScreen->SetModify();
-	m_Parent->m_Pcb->m_Status_Pcb = 0 ; State = 0; LineNum = 0; Comment = 0;
+    m_Parent->m_Pcb->m_Status_Pcb = 0; State = 0; LineNum = 0; Comment = 0;
     s_NbNewModules = 0;
 
     /* Premiere lecture de la netliste: etablissement de la liste
-		des modules a charger
+     *  des modules a charger
      */
-	while( GetLine( source, Line, &LineNum) )
+    while( GetLine( source, Line, &LineNum ) )
     {
-		Text = StrPurge(Line);
+        Text = StrPurge( Line );
 
-		if ( Comment ) /* Commentaires en cours */
+        if( Comment ) /* Commentaires en cours */
         {
-			if( (Text = strchr(Text,'}') ) == NULL )continue;
+            if( ( Text = strchr( Text, '}' ) ) == NULL )
+                continue;
             Comment = 0;
         }
-		if ( *Text == '{' ) /* Commentaires */
+        if( *Text == '{' ) /* Commentaires */
         {
             Comment = 1;
-			if( (Text = strchr(Text,'}') ) == NULL ) continue;
+            if( ( Text = strchr( Text, '}' ) ) == NULL )
+                continue;
         }
 
-		if ( *Text == '(' ) State++;
-		if ( *Text == ')' ) State--;
+        if( *Text == '(' )
+            State++;
+        if( *Text == ')' )
+            State--;
 
         if( State == 2 )
         {
-			Module = ReadNetModule(Text, & UseFichCmp, TESTONLY);
+            Module = ReadNetModule( Text, &UseFichCmp, TESTONLY );
             continue;
         }
 
@@ -182,48 +191,54 @@ wxString msg;
     /* Chargement des nouveaux modules */
     if( s_NbNewModules )
     {
-		LoadListeModules(m_DC);
+        LoadListeModules( m_DC );
+
         // Free module list:
-		MODULEtoLOAD * item, *next_item;
-		for ( item = s_ModuleToLoad_List; item != NULL; item = next_item )
+        MODULEtoLOAD* item, * next_item;
+        for( item = s_ModuleToLoad_List; item != NULL; item = next_item )
         {
             next_item = item->Next();
             delete item;
         }
+
         s_ModuleToLoad_List = NULL;
     }
 
     /* Relecture de la netliste, tous les modules sont ici charges */
-	fseek(source, 0, SEEK_SET); LineNum = 0;
-	while( GetLine( source, Line, &LineNum) )
+    fseek( source, 0, SEEK_SET ); LineNum = 0;
+    while( GetLine( source, Line, &LineNum ) )
     {
-		Text = StrPurge(Line);
+        Text = StrPurge( Line );
 
-		if ( Comment ) /* Commentaires en cours */
+        if( Comment ) /* Commentaires en cours */
         {
-			if( (Text = strchr(Text,'}') ) == NULL )continue;
+            if( ( Text = strchr( Text, '}' ) ) == NULL )
+                continue;
             Comment = 0;
         }
-		if ( *Text == '{' ) /* Commentaires */
+        if( *Text == '{' ) /* Commentaires */
         {
             Comment = 1;
-			if( (Text = strchr(Text,'}') ) == NULL ) continue;
+            if( ( Text = strchr( Text, '}' ) ) == NULL )
+                continue;
         }
 
-		if ( *Text == '(' ) State++;
-		if ( *Text == ')' ) State--;
+        if( *Text == '(' )
+            State++;
+        if( *Text == ')' )
+            State--;
 
         if( State == 2 )
         {
-			Module = ReadNetModule(Text, & UseFichCmp, READMODULE );
+            Module = ReadNetModule( Text, &UseFichCmp, READMODULE );
             if( Module == NULL )
             {      /* empreinte non trouvee dans la netliste */
-				continue ;
+                continue;
             }
             else /* Raz netnames sur pads */
             {
                 PtPad = Module->m_Pads;
-				for( ; PtPad != NULL; PtPad = (D_PAD *)PtPad->Pnext )
+                for( ; PtPad != NULL; PtPad = (D_PAD*) PtPad->Pnext )
                 {
                     PtPad->m_Netname = wxEmptyString;
                 }
@@ -233,99 +248,110 @@ wxString msg;
 
         if( State >= 3 )
         {
-			if ( Module )
+            if( Module )
             {
-				SetPadNetName( Text, Module);
+                SetPadNetName( Text, Module );
             }
             State--;
         }
     }
 
-	fclose(source);
+    fclose( source );
 
     /* Mise a jour et Cleanup du circuit imprime: */
-	m_Parent->Compile_Ratsnest(m_DC, TRUE);
+    m_Parent->Compile_Ratsnest( m_DC, TRUE );
 
     if( m_Parent->m_Pcb->m_Track )
     {
         if( m_DeleteBadTracks->GetSelection() == 1 )
         {
             wxBeginBusyCursor();;
-			Netliste_Controle_piste(m_Parent, m_DC, TRUE);
-			m_Parent->Compile_Ratsnest(m_DC, TRUE);
+            Netliste_Controle_piste( m_Parent, m_DC, TRUE );
+            m_Parent->Compile_Ratsnest( m_DC, TRUE );
             wxEndBusyCursor();;
         }
     }
 
-	Affiche_Infos_Status_Pcb(m_Parent);
+    m_Parent->m_Pcb->Display_Infos( m_Parent );
 }
 
 
 /****************************************************************************/
-MODULE * WinEDA_NetlistFrame::ReadNetModule(char * Text, int * UseFichCmp,
-		int TstOnly)
+MODULE* WinEDA_NetlistFrame::ReadNetModule( char* Text, int* UseFichCmp,
+                                            int TstOnly )
 /****************************************************************************/
-/* charge la description d'une empreinte ,netliste type PCBNEW
-	et met a jour le module correspondant
 
-	Si TstOnly == 0 si le module n'existe pas, il est charge
-	Si TstOnly != 0 si le module n'existe pas, il est ajoute a la liste des
-		modules a charger
-	Text contient la premiere ligne de la description
+/* charge la description d'une empreinte ,netliste type PCBNEW
+ *  et met a jour le module correspondant
+ * 
+ *  Si TstOnly == 0 si le module n'existe pas, il est charge
+ *  Si TstOnly != 0 si le module n'existe pas, il est ajoute a la liste des
+ *      modules a charger
+ *  Text contient la premiere ligne de la description
  * UseFichCmp est un flag
-			si != 0, le fichier des composants .CMP sera utilise
-			est remis a 0 si le fichier n'existe pas
-
-Analyse les lignes type:
-( 40C08647 $noname R20 4,7K {Lib=R}
-  (    1 VCC )
-  (    2 MODB_1 )
-*/
+ *          si != 0, le fichier des composants .CMP sera utilise
+ *          est remis a 0 si le fichier n'existe pas
+ * 
+ *  Analyse les lignes type:
+ *  ( 40C08647 $noname R20 4,7K {Lib=R}
+ *  (    1 VCC )
+ *  (    2 MODB_1 )
+ */
 {
-MODULE * Module;
-char * text;
-wxString TextTimeStamp;
-wxString TextNameLibMod;
-wxString TextValeur;
-wxString TextCmpName;
-wxString NameLibCmp;
-unsigned long TimeStamp = 0;
-int Error = 0;
-char Line[1024];
-bool Found;
-
-	strcpy(Line,Text);
-
-	TextValeur = wxT("~");
-	if( (text = strtok(Line, " ()\t\n")) == NULL ) Error = 1;
-	else TextTimeStamp = CONV_FROM_UTF8(text);
-	if( ( text = strtok(NULL, " ()\t\n")) == NULL ) Error = 1;
-	else TextNameLibMod = CONV_FROM_UTF8(text);
-	if( (text = strtok(NULL, " ()\t\n")) == NULL ) Error = 1;
-	else TextCmpName = CONV_FROM_UTF8(text);
-	if( (text = strtok(NULL, " ()\t\n")) == NULL ) Error = -1;
-	else TextValeur = CONV_FROM_UTF8(text);
-
-	if( Error > 0 ) return( NULL );
-		
-	TextTimeStamp.ToULong( &TimeStamp, 16);
+    MODULE*       Module;
+    char*         text;
+    wxString      TextTimeStamp;
+    wxString      TextNameLibMod;
+    wxString      TextValeur;
+    wxString      TextCmpName;
+    wxString      NameLibCmp;
+    unsigned long TimeStamp = 0;
+    int           Error = 0;
+    char          Line[1024];
+    bool          Found;
+
+    strcpy( Line, Text );
+
+    TextValeur = wxT( "~" );
+    if( ( text = strtok( Line, " ()\t\n" ) ) == NULL )
+        Error = 1;
+    else
+        TextTimeStamp = CONV_FROM_UTF8( text );
+    if( ( text = strtok( NULL, " ()\t\n" ) ) == NULL )
+        Error = 1;
+    else
+        TextNameLibMod = CONV_FROM_UTF8( text );
+    if( ( text = strtok( NULL, " ()\t\n" ) ) == NULL )
+        Error = 1;
+    else
+        TextCmpName = CONV_FROM_UTF8( text );
+    if( ( text = strtok( NULL, " ()\t\n" ) ) == NULL )
+        Error = -1;
+    else
+        TextValeur = CONV_FROM_UTF8( text );
+
+    if( Error > 0 )
+        return NULL;
+
+    TextTimeStamp.ToULong( &TimeStamp, 16 );
 
     /* Tst si composant deja charge */
     Module = (MODULE*) m_Parent->m_Pcb->m_Modules;
-	MODULE * NextModule;
+    MODULE* NextModule;
     for( Found = FALSE; Module != NULL; Module = NextModule )
     {
-		NextModule = (MODULE*)Module->Pnext;
+        NextModule = (MODULE*) Module->Pnext;
         if( m_Select_By_Timestamp->GetSelection()  == 1 ) /* Reconnaissance par signature temporelle */
         {
-			if( TimeStamp == Module->m_TimeStamp) Found = TRUE;
+            if( TimeStamp == Module->m_TimeStamp )
+                Found = TRUE;
         }
         else    /* Reconnaissance par Reference */
         {
-			if( TextCmpName.CmpNoCase(Module->m_Reference->m_Text) == 0 )
+            if( TextCmpName.CmpNoCase( Module->m_Reference->m_Text ) == 0 )
                 Found = TRUE;
         }
-		if ( Found ) // Test si module (m_LibRef) et module specifie en netlist concordent
+        if( Found ) // Test si module (m_LibRef) et module specifie en netlist concordent
         {
             if( TstOnly != TESTONLY )
             {
@@ -334,32 +360,33 @@ bool Found;
                 {
                     if( m_Select_By_Timestamp->GetSelection()  == 1 )
                     {   /* Reconnaissance par signature temporelle */
-						*UseFichCmp = ReadListeModules(NULL, TimeStamp, NameLibCmp);
+                        *UseFichCmp = ReadListeModules( NULL, TimeStamp, NameLibCmp );
                     }
                     else    /* Reconnaissance par Reference */
                     {
-						*UseFichCmp = ReadListeModules(&TextCmpName, 0l, NameLibCmp);
+                        *UseFichCmp = ReadListeModules( &TextCmpName, 0l, NameLibCmp );
                     }
                 }
-				if (Module->m_LibRef.CmpNoCase(NameLibCmp) != 0 )
-				{// Module Mismatch: Current module and module specified in netlist are diff.
-					if ( ChangeExistantModule )
+                if( Module->m_LibRef.CmpNoCase( NameLibCmp ) != 0 )
+                { // Module Mismatch: Current module and module specified in netlist are diff.
+                    if( ChangeExistantModule )
                     {
-						MODULE * NewModule =
-								m_Parent->Get_Librairie_Module(this, wxEmptyString, NameLibCmp, TRUE);
+                        MODULE* NewModule =
+                            m_Parent->Get_Librairie_Module( this, wxEmptyString, NameLibCmp, TRUE );
                         if( NewModule ) /* Nouveau module trouve : changement de module */
-							Module = m_Parent->Exchange_Module(this, Module, NewModule);
+                            Module = m_Parent->Exchange_Module( this, Module, NewModule );
                     }
                     else
                     {
                         wxString msg;
                         msg.Printf(
-							_("Cmp %s: Mismatch! module is [%s] and netlist said [%s]\n"),
-						TextCmpName.GetData(), Module->m_LibRef.GetData(), NameLibCmp.GetData());
-						m_MessageWindow->AppendText(msg);
-						if ( DisplayWarningCount > 0)
+                            _( "Cmp %s: Mismatch! module is [%s] and netlist said [%s]\n" ),
+                            TextCmpName.GetData(), Module->m_LibRef.GetData(),
+                            NameLibCmp.GetData() );
+                        m_MessageWindow->AppendText( msg );
+                        if( DisplayWarningCount > 0 )
                         {
-							DisplayError(this, msg, 2);
+                            DisplayError( this, msg, 2 );
                             DisplayWarningCount--;
                         }
                     }
@@ -375,31 +402,31 @@ bool Found;
 
         if( *UseFichCmp )
         {
-			if( m_Select_By_Timestamp->GetSelection()  == 1)
+            if( m_Select_By_Timestamp->GetSelection()  == 1 )
             {       /* Reconnaissance par signature temporelle */
-				*UseFichCmp = ReadListeModules(NULL, TimeStamp, NameLibCmp);
+                *UseFichCmp = ReadListeModules( NULL, TimeStamp, NameLibCmp );
             }
             else    /* Reconnaissance par Reference */
             {
-				*UseFichCmp = ReadListeModules(&TextCmpName, 0l, NameLibCmp);
+                *UseFichCmp = ReadListeModules( &TextCmpName, 0l, NameLibCmp );
             }
         }
 
 
-		if( TstOnly == TESTONLY)
-			AddToList(NameLibCmp, TextCmpName, TimeStamp);
+        if( TstOnly == TESTONLY )
+            AddToList( NameLibCmp, TextCmpName, TimeStamp );
         else
         {
             wxString msg;
-			msg.Printf( _("Component [%s] not found"), TextCmpName.GetData());
-			m_MessageWindow->AppendText( msg + wxT("\n"));
-			if (DisplayWarningCount> 0)
+            msg.Printf( _( "Component [%s] not found" ), TextCmpName.GetData() );
+            m_MessageWindow->AppendText( msg + wxT( "\n" ) );
+            if( DisplayWarningCount> 0 )
             {
-				DisplayError(this, msg, 2);
+                DisplayError( this, msg, 2 );
                 DisplayWarningCount--;
             }
         }
-		return(NULL);	/* Le module n'avait pas pu etre charge */
+        return NULL;    /* Le module n'avait pas pu etre charge */
     }
 
     /* mise a jour des reperes ( nom et ref "Time Stamp") si module charge */
@@ -407,91 +434,101 @@ bool Found;
     Module->m_Value->m_Text = TextValeur;
     Module->m_TimeStamp = TimeStamp;
 
-	return(Module) ; /* composant trouve */
+    return Module;  /* composant trouve */
 }
 
+
 /********************************************************************/
-int WinEDA_NetlistFrame::SetPadNetName( char * Text, MODULE * Module)
+int WinEDA_NetlistFrame::SetPadNetName( char* Text, MODULE* Module )
 /********************************************************************/
+
 /*
-Met a jour le netname de 1 pastille, Netliste ORCADPCB
-	entree :
-		Text = ligne de netliste lue ( (pad = net) )
-		Module = adresse de la structure MODULE a qui appartient les pads
-*/
+ *  Met a jour le netname de 1 pastille, Netliste ORCADPCB
+ *  entree :
+ *      Text = ligne de netliste lue ( (pad = net) )
+ *      Module = adresse de la structure MODULE a qui appartient les pads
+ */
 {
-D_PAD * pad;
-char * TextPinName, * TextNetName;
-int Error = 0;
-bool trouve;
-char Line[256];
-wxString Msg;
+    D_PAD*   pad;
+    char*    TextPinName, * TextNetName;
+    int      Error = 0;
+    bool     trouve;
+    char     Line[256];
+    wxString Msg;
 
-	if( Module == NULL ) return ( 0 );
+    if( Module == NULL )
+        return 0;
 
-	strcpy( Line, Text);
+    strcpy( Line, Text );
 
-	if( (TextPinName = strtok(Line, " ()\t\n")) == NULL ) Error = 1;
-	if( (TextNetName = strtok(NULL, " ()\t\n")) == NULL ) Error = 1;
-	if(Error) return(0);
+    if( ( TextPinName = strtok( Line, " ()\t\n" ) ) == NULL )
+        Error = 1;
+    if( ( TextNetName = strtok( NULL, " ()\t\n" ) ) == NULL )
+        Error = 1;
+    if( Error )
+        return 0;
 
     /* recherche du pad */
     pad = Module->m_Pads; trouve = FALSE;
-	for( ; pad != NULL; pad = (D_PAD *)pad->Pnext )
+    for( ; pad != NULL; pad = (D_PAD*) pad->Pnext )
     {
-		if( strnicmp( TextPinName, pad->m_Padname, 4) == 0 )
+        if( strnicmp( TextPinName, pad->m_Padname, 4 ) == 0 )
         { /* trouve */
             trouve = TRUE;
             if( *TextNetName != '?' )
-				pad->m_Netname = CONV_FROM_UTF8(TextNetName);
-			else pad->m_Netname.Empty();
+                pad->m_Netname = CONV_FROM_UTF8( TextNetName );
+            else
+                pad->m_Netname.Empty();
         }
     }
 
     if( !trouve && (DisplayWarningCount > 0) )
     {
-		wxString pin_name = CONV_FROM_UTF8(TextPinName);
-		Msg.Printf( _("Module [%s]: Pad [%s] not found"),
+        wxString pin_name = CONV_FROM_UTF8( TextPinName );
+        Msg.Printf( _( "Module [%s]: Pad [%s] not found" ),
                    Module->m_Reference->m_Text.GetData(), pin_name.GetData() );
-		DisplayError(this, Msg, 1);
+        DisplayError( this, Msg, 1 );
         DisplayWarningCount--;
     }
 
-	return(trouve);
+    return trouve;
 }
 
 
 /*****************************************************/
-MODULE * WinEDA_PcbFrame::ListAndSelectModuleName(void)
+MODULE* WinEDA_PcbFrame::ListAndSelectModuleName( void )
 /*****************************************************/
+
 /*	liste les noms des modules du PCB
-	Retourne:
-		un pointeur sur le module selectionne
-		NULL si pas de selection
-*/
+ *  Retourne:
+ *      un pointeur sur le module selectionne
+ *      NULL si pas de selection
+ */
 {
-int ii, jj, nb_empr;
-MODULE * Module;
-WinEDAListBox * ListBox;
-const wxChar ** ListNames = NULL;
+    int            ii, jj, nb_empr;
+    MODULE*        Module;
+    WinEDAListBox* ListBox;
+    const wxChar** ListNames = NULL;
 
     if( m_Pcb->m_Modules == NULL )
     {
-		DisplayError(this, _("No Modules") ) ; return(0);
+        DisplayError( this, _( "No Modules" ) ); return 0;
     }
 
     /* Calcul du nombre des modules */
-	nb_empr = 0; Module = (MODULE*)m_Pcb->m_Modules;
-	for( ;Module != NULL; Module = (MODULE*)Module->Pnext) nb_empr++;
-	ListNames = (const wxChar**) MyZMalloc( (nb_empr + 1) * sizeof(wxChar*) );
+    nb_empr = 0; Module = (MODULE*) m_Pcb->m_Modules;
+    for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
+        nb_empr++;
+
+    ListNames = (const wxChar**) MyZMalloc( (nb_empr + 1) * sizeof(wxChar *) );
     Module    = (MODULE*) m_Pcb->m_Modules;
-	for( ii = 0; Module != NULL; Module = (MODULE*)Module->Pnext, ii++)
+    for( ii = 0; Module != NULL; Module = (MODULE*) Module->Pnext, ii++ )
     {
         ListNames[ii] = Module->m_Reference->m_Text.GetData();
     }
 
-	ListBox = new WinEDAListBox(this, _("Components"),
-					ListNames, wxEmptyString);
+    ListBox = new WinEDAListBox( this, _( "Components" ),
+                                 ListNames, wxEmptyString );
     ii = ListBox->ShowModal(); ListBox->Destroy();
 
 
@@ -499,114 +536,119 @@ const wxChar ** ListNames = NULL;
     {
         Module = NULL;
     }
-
     else /* Recherche du module selectionne */
     {
         Module = (MODULE*) m_Pcb->m_Modules;
-		for( jj = 0; Module != NULL; Module = (MODULE*)Module->Pnext, jj++)
+        for( jj = 0; Module != NULL; Module = (MODULE*) Module->Pnext, jj++ )
         {
-			if( Module->m_Reference->m_Text.Cmp(ListNames[ii]) == 0 ) break;
+            if( Module->m_Reference->m_Text.Cmp( ListNames[ii] ) == 0 )
+                break;
         }
     }
 
-	free(ListNames);
-	return(Module);
+    free( ListNames );
+    return Module;
 }
 
+
 /***************************************************************/
-void WinEDA_NetlistFrame::ModulesControle(wxCommandEvent& event)
+void WinEDA_NetlistFrame::ModulesControle( wxCommandEvent& event )
 /***************************************************************/
+
 /* donne la liste :
-1 - des empreintes doubles sur le PCB
-2 - des empreintes manquantes par rapport a la netliste
-3 - des empreintes supplmentaires par rapport a la netliste
-*/
+ *  1 - des empreintes doubles sur le PCB
+ *  2 - des empreintes manquantes par rapport a la netliste
+ *  3 - des empreintes supplmentaires par rapport a la netliste
+ */
 #define MAX_LEN_TXT 32
 {
-int ii, NbModulesPcb;
-MODULE * Module, * pt_aux;
-int NbModulesNetListe ,nberr = 0 ;
-WinEDA_TextFrame * List;
-wxArrayString ModuleListFromNetlist;
+    int               ii, NbModulesPcb;
+    MODULE*           Module, * pt_aux;
+    int               NbModulesNetListe, nberr = 0;
+    WinEDA_TextFrame* List;
+    wxArrayString     ModuleListFromNetlist;
 
     /* determination du nombre des modules du PCB*/
     NbModulesPcb = 0; Module = (MODULE*) m_Parent->m_Pcb->m_Modules;
-	for( ;Module != NULL; Module = (MODULE*)Module->Pnext)
+    for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
         NbModulesPcb++;
 
     if( NbModulesPcb == 0 )
     {
-		DisplayError(this, _("No modules"), 10); return;
+        DisplayError( this, _( "No modules" ), 10 ); return;
     }
 
     /* Construction de la liste des references des modules de la netliste */
-	NbModulesNetListe = BuildListeNetModules(event, ModuleListFromNetlist);
-	if( NbModulesNetListe < 0 ) return; /* fichier non trouve */
+    NbModulesNetListe = BuildListeNetModules( event, ModuleListFromNetlist );
+    if( NbModulesNetListe < 0 )
+        return;                         /* fichier non trouve */
 
     if( NbModulesNetListe == 0 )
     {
-		DisplayError(this, _("No modules in NetList"), 10); return;
+        DisplayError( this, _( "No modules in NetList" ), 10 ); return;
     }
 
-	List = new WinEDA_TextFrame(this, _("Check Modules"));
+    List = new WinEDA_TextFrame( this, _( "Check Modules" ) );
 
     /* recherche des doubles */
-	List->Append(_("Duplicates"));
+    List->Append( _( "Duplicates" ) );
 
     Module = (MODULE*) m_Parent->m_Pcb->m_Modules;
-	for( ;Module != NULL; Module = (MODULE*)Module->Pnext)
+    for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
     {
-		pt_aux = (MODULE*)Module->Pnext;
-		for( ; pt_aux != NULL; pt_aux = (MODULE*)pt_aux->Pnext)
+        pt_aux = (MODULE*) Module->Pnext;
+        for( ; pt_aux != NULL; pt_aux = (MODULE*) pt_aux->Pnext )
         {
-			if( Module->m_Reference->m_Text.CmpNoCase(pt_aux->m_Reference->m_Text) == 0 )
+            if( Module->m_Reference->m_Text.CmpNoCase( pt_aux->m_Reference->m_Text ) == 0 )
             {
-				List->Append(Module->m_Reference->m_Text);
-				nberr++ ;
+                List->Append( Module->m_Reference->m_Text );
+                nberr++;
                 break;
             }
         }
     }
 
     /* recherche des manquants par rapport a la netliste*/
-	List->Append(_("Lack:") );
+    List->Append( _( "Lack:" ) );
 
-	for ( ii = 0 ; ii < NbModulesNetListe ; ii++ )
+    for( ii = 0; ii < NbModulesNetListe; ii++ )
     {
         Module = (MODULE*) m_Parent->m_Pcb->m_Modules;
-		for( ;Module != NULL; Module = (MODULE*)Module->Pnext)
+        for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
         {
             if( Module->m_Reference->m_Text.CmpNoCase(
-					ModuleListFromNetlist[ii]) == 0 )
+                    ModuleListFromNetlist[ii] ) == 0 )
             {
                 break;
             }
         }
+
         if( Module == NULL )    // Module missing, not found in board
         {
-			List->Append(ModuleListFromNetlist[ii]);
-			nberr++ ;
+            List->Append( ModuleListFromNetlist[ii] );
+            nberr++;
         }
     }
 
     /* recherche des modules supplementaires (i.e. Non en Netliste) */
-	List->Append( _("Not in Netlist:") );
+    List->Append( _( "Not in Netlist:" ) );
 
     Module = (MODULE*) m_Parent->m_Pcb->m_Modules;
-	for( ;Module != NULL; Module = Module->Next())
+    for( ; Module != NULL; Module = Module->Next() )
     {
-		for (ii = 0; ii < NbModulesNetListe; ii++ )
+        for( ii = 0; ii < NbModulesNetListe; ii++ )
         {
             if( Module->m_Reference->m_Text.CmpNoCase(
-					ModuleListFromNetlist[ii]) == 0 )
+                    ModuleListFromNetlist[ii] ) == 0 )
             {
-				break ;/* Module trouve en netliste */
+                break;/* Module trouve en netliste */
             }
         }
+
         if( ii == NbModulesNetListe )   /* Module not found in netlist */
         {
-			List->Append(Module->m_Reference->m_Text);
-			nberr++ ;
+            List->Append( Module->m_Reference->m_Text );
+            nberr++;
         }
     }
 
@@ -615,50 +657,59 @@ wxArrayString ModuleListFromNetlist;
 
 
 /**************************************************************************************************/
-int WinEDA_NetlistFrame::BuildListeNetModules(wxCommandEvent& event, wxArrayString & BufName)
+int WinEDA_NetlistFrame::BuildListeNetModules( wxCommandEvent& event, wxArrayString& BufName )
 /**************************************************************************************************/
+
 /*
-	charge en BufName la liste des noms des modules de la netliste,
-	retourne le nombre des modules cits dans la netliste
-*/
+ *  charge en BufName la liste des noms des modules de la netliste,
+ *  retourne le nombre des modules cits dans la netliste
+ */
 {
-int textlen;
-int nb_modules_lus ;
-int State, LineNum, Comment;
-char Line[1024], *Text, * LibModName;
+    int  textlen;
+    int  nb_modules_lus;
+    int  State, LineNum, Comment;
+    char Line[1024], * Text, * LibModName;
 
-	if( ! OpenNetlistFile(event) ) return -1;
+    if( !OpenNetlistFile( event ) )
+        return -1;
 
     State = 0; LineNum = 0; Comment = 0;
     nb_modules_lus = 0;
     textlen = MAX_LEN_TXT;
 
-	while( GetLine( source, Line, &LineNum) )
+    while( GetLine( source, Line, &LineNum ) )
     {
-		Text = StrPurge(Line);
-		if ( Comment ) /* Commentaires en cours */
+        Text = StrPurge( Line );
+        if( Comment ) /* Commentaires en cours */
         {
-			if( (Text = strchr(Text,'}') ) == NULL )continue;
+            if( ( Text = strchr( Text, '}' ) ) == NULL )
+                continue;
             Comment = 0;
         }
-		if ( *Text == '{' ) /* Commentaires */
+        if( *Text == '{' ) /* Commentaires */
         {
             Comment = 1;
-			if( (Text = strchr(Text,'}') ) == NULL ) continue;
+            if( ( Text = strchr( Text, '}' ) ) == NULL )
+                continue;
         }
 
-		if ( *Text == '(' ) State++;
-		if ( *Text == ')' ) State--;
+        if( *Text == '(' )
+            State++;
+        if( *Text == ')' )
+            State--;
 
         if( State == 2 )
         {
             int Error = 0;
-			if( strtok(Line, " ()\t\n") == NULL ) Error = 1; /* TimeStamp */
-			if( ( LibModName = strtok(NULL, " ()\t\n")) == NULL ) Error = 1; /* nom Lib */
+            if( strtok( Line, " ()\t\n" ) == NULL )
+                Error = 1;                                                  /* TimeStamp */
+            if( ( LibModName = strtok( NULL, " ()\t\n" ) ) == NULL )
+                Error = 1;                                                  /* nom Lib */
             /* Lecture du nom (reference) du composant: */
-			if( (Text = strtok(NULL, " ()\t\n")) == NULL ) Error = 1;
+            if( ( Text = strtok( NULL, " ()\t\n" ) ) == NULL )
+                Error = 1;
             nb_modules_lus++;
-			BufName.Add(CONV_FROM_UTF8(Text));
+            BufName.Add( CONV_FROM_UTF8( Text ) );
             continue;
         }
 
@@ -668,143 +719,153 @@ char Line[1024], *Text, * LibModName;
         }
     }
 
-	fclose(source);
-	return(nb_modules_lus);
+    fclose( source );
+    return nb_modules_lus;
 }
 
 
-
 /*****************************************************************************************/
-int WinEDA_NetlistFrame::ReadListeModules(const wxString * RefCmp, long TimeStamp,
-			wxString & NameModule)
+int WinEDA_NetlistFrame::ReadListeModules( const wxString* RefCmp, long TimeStamp,
+                                           wxString& NameModule )
 /*****************************************************************************************/
+
 /*
-	Lit le fichier .CMP donnant l'equivalence Modules / Composants
-	Retourne:
-	Si ce fichier existe:
-		1 et le nom module dans NameModule
-		-1 si module non trouve en fichier
-	sinon 0;
-
-	parametres d'appel:
-		RefCmp		(NULL si selection par TimeStamp)
-		TimeStamp	(signature temporelle si elle existe, NULL sinon)
-		pointeur sur le buffer recevant le nom du module
-
-	Exemple de fichier:
-
-Cmp-Mod V01 Genere par PcbNew le 29/10/2003-13:11:6
-
-BeginCmp
-TimeStamp = 322D3011;
-Reference = BUS1;
-ValeurCmp = BUSPC;
-IdModule  = BUS_PC;
-EndCmp
-
-BeginCmp
-TimeStamp = 32307DE2;
-Reference = C1;
-ValeurCmp = 47uF;
-IdModule  = CP6;
-EndCmp
-
-*/
+ *  Lit le fichier .CMP donnant l'equivalence Modules / Composants
+ *  Retourne:
+ *  Si ce fichier existe:
+ *      1 et le nom module dans NameModule
+ *      -1 si module non trouve en fichier
+ *  sinon 0;
+ * 
+ *  parametres d'appel:
+ *      RefCmp		(NULL si selection par TimeStamp)
+ *      TimeStamp	(signature temporelle si elle existe, NULL sinon)
+ *      pointeur sur le buffer recevant le nom du module
+ * 
+ *  Exemple de fichier:
+ * 
+ *  Cmp-Mod V01 Genere par PcbNew le 29/10/2003-13:11:6
+ * 
+ *  BeginCmp
+ *  TimeStamp = 322D3011;
+ *  Reference = BUS1;
+ *  ValeurCmp = BUSPC;
+ *  IdModule  = BUS_PC;
+ *  EndCmp
+ * 
+ *  BeginCmp
+ *  TimeStamp = 32307DE2;
+ *  Reference = C1;
+ *  ValeurCmp = 47uF;
+ *  IdModule  = CP6;
+ *  EndCmp
+ * 
+ */
 {
-wxString CmpFullFileName;
-wxString refcurrcmp, idmod;
-char ia[1024];
-int timestamp;
-char *ptcar;
-FILE * FichCmp;
+    wxString CmpFullFileName;
+    wxString refcurrcmp, idmod;
+    char     ia[1024];
+    int      timestamp;
+    char*    ptcar;
+    FILE*    FichCmp;
 
-	if( (RefCmp == NULL) && (TimeStamp == 0) ) return(0);
+    if( (RefCmp == NULL) && (TimeStamp == 0) )
+        return 0;
 
     CmpFullFileName = NetNameBuffer;
-	ChangeFileNameExt(CmpFullFileName,NetCmpExtBuffer) ;
+    ChangeFileNameExt( CmpFullFileName, NetCmpExtBuffer );
 
-	FichCmp = wxFopen(CmpFullFileName, wxT("rt") );
-	if (FichCmp == NULL)
+    FichCmp = wxFopen( CmpFullFileName, wxT( "rt" ) );
+    if( FichCmp == NULL )
     {
         wxString msg;
-		msg.Printf( _("File <%s> not found, use Netlist for lib module selection"),
-				CmpFullFileName.GetData()) ;
-		DisplayError(this, msg, 20) ;
-		return(0);
+        msg.Printf( _( "File <%s> not found, use Netlist for lib module selection" ),
+                   CmpFullFileName.GetData() );
+        DisplayError( this, msg, 20 );
+        return 0;
     }
 
-	while( fgets(ia,sizeof(ia),FichCmp) != NULL )
+    while( fgets( ia, sizeof(ia), FichCmp ) != NULL )
     {
-		if( strnicmp(ia,"BeginCmp",8) != 0 ) continue;
+        if( strnicmp( ia, "BeginCmp", 8 ) != 0 )
+            continue;
 
         /* Ici une description de 1 composant commence */
         refcurrcmp.Empty();
         idmod.Empty();
         timestamp = -1;
-		while( fgets(ia,sizeof(ia),FichCmp) != NULL )
+        while( fgets( ia, sizeof(ia), FichCmp ) != NULL )
         {
-			if( strnicmp(ia,"EndCmp",6) == 0 ) break;
+            if( strnicmp( ia, "EndCmp", 6 ) == 0 )
+                break;
 
-			if( strnicmp(ia,"Reference =",11) == 0 )
+            if( strnicmp( ia, "Reference =", 11 ) == 0 )
             {
-				ptcar = ia+11;
-				ptcar = strtok(ptcar," =;\t\n");
-				if( ptcar ) refcurrcmp = CONV_FROM_UTF8(ptcar);
+                ptcar = ia + 11;
+                ptcar = strtok( ptcar, " =;\t\n" );
+                if( ptcar )
+                    refcurrcmp = CONV_FROM_UTF8( ptcar );
                 continue;
             }
 
-			if( strnicmp(ia,"IdModule  =",11) == 0 )
+            if( strnicmp( ia, "IdModule  =", 11 ) == 0 )
             {
-				ptcar = ia+11;
-				ptcar = strtok(ptcar," =;\t\n");
-				if( ptcar ) idmod = CONV_FROM_UTF8(ptcar);
+                ptcar = ia + 11;
+                ptcar = strtok( ptcar, " =;\t\n" );
+                if( ptcar )
+                    idmod = CONV_FROM_UTF8( ptcar );
                 continue;
             }
-			if( strnicmp(ia,"TimeStamp =",11) == 0 )
+            if( strnicmp( ia, "TimeStamp =", 11 ) == 0 )
             {
-				ptcar = ia+11;
-				ptcar = strtok(ptcar," =;\t\n");
-				if( ptcar ) sscanf(ptcar, "%X", &timestamp);
+                ptcar = ia + 11;
+                ptcar = strtok( ptcar, " =;\t\n" );
+                if( ptcar )
+                    sscanf( ptcar, "%X", &timestamp );
             }
-			}/* Fin lecture 1 descr composant */
+        }
+
+        /* Fin lecture 1 descr composant */
 
         /* Test du Composant lu en fichier: est-il le bon */
         if( RefCmp )
         {
-			if( RefCmp->CmpNoCase(refcurrcmp) == 0 )
+            if( RefCmp->CmpNoCase( refcurrcmp ) == 0 )
             {
-				fclose(FichCmp);
+                fclose( FichCmp );
                 NameModule = idmod;
-				return(1);
+                return 1;
             }
         }
         else if( TimeStamp != -1 )
         {
             if( TimeStamp == timestamp )
             {
-				fclose(FichCmp);
+                fclose( FichCmp );
                 NameModule = idmod;
-				return(1);
+                return 1;
             }
         }
     }
-	fclose(FichCmp);
-	return(-1);
+
+    fclose( FichCmp );
+    return -1;
 }
 
 
 /***************************************************************/
-void WinEDA_NetlistFrame::Set_NetlisteName(wxCommandEvent& event)
+void WinEDA_NetlistFrame::Set_NetlisteName( wxCommandEvent& event )
 /***************************************************************/
+
 /* Selection un nouveau nom de netliste
-	Affiche la liste des fichiers netlistes pour selection sur liste
+ *  Affiche la liste des fichiers netlistes pour selection sur liste
  */
 {
-wxString fullfilename, mask( wxT("*"));
+    wxString fullfilename, mask( wxT( "*" ) );
 
     mask += NetExtBuffer;
 
-	fullfilename = EDA_FileSelector( _("Netlist Selection:"),
+    fullfilename = EDA_FileSelector( _( "Netlist Selection:" ),
                                      wxEmptyString,     /* Chemin par defaut */
                                      NetNameBuffer,     /* nom fichier par defaut */
                                      NetExtBuffer,      /* extension par defaut */
@@ -814,21 +875,25 @@ wxString fullfilename, mask( wxT("*"));
                                      TRUE
                                      );
 
-	if ( fullfilename.IsEmpty()) return;
+    if( fullfilename.IsEmpty() )
+        return;
     NetNameBuffer = fullfilename;
-	SetTitle(fullfilename);
+    SetTitle( fullfilename );
 }
 
+
 /***********************************************************************************/
-void WinEDA_NetlistFrame::AddToList(const wxString & NameLibCmp, const wxString & CmpName,int TimeStamp )
+void WinEDA_NetlistFrame::AddToList( const wxString& NameLibCmp, const wxString& CmpName,
+                                     int TimeStamp )
 /************************************************************************************/
+
 /* Fontion copiant en memoire de travail les caracteristiques
-	des nouveaux modules
-*/
+ *  des nouveaux modules
+ */
 {
-MODULEtoLOAD * NewMod;
+    MODULEtoLOAD* NewMod;
 
-	NewMod = new MODULEtoLOAD(NameLibCmp, CmpName, TimeStamp);
+    NewMod = new MODULEtoLOAD( NameLibCmp, CmpName, TimeStamp );
     NewMod->Pnext = s_ModuleToLoad_List;
     s_ModuleToLoad_List = NewMod;
     s_NbNewModules++;
@@ -836,117 +901,128 @@ MODULEtoLOAD * NewMod;
 
 
 /***************************************************************/
-void WinEDA_NetlistFrame::LoadListeModules(wxDC * DC)
+void WinEDA_NetlistFrame::LoadListeModules( wxDC* DC )
 /***************************************************************/
+
 /* Routine de chargement des nouveaux modules en une seule lecture des
-	librairies
-	Si un module vient d'etre charge il est duplique, ce qui evite une lecture
-	inutile de la librairie
-*/
+ *  librairies
+ *  Si un module vient d'etre charge il est duplique, ce qui evite une lecture
+ *  inutile de la librairie
+ */
 {
-MODULEtoLOAD * ref, *cmp;
-int ii;
-MODULE * Module = NULL;
-wxPoint OldPos = m_Parent->m_CurrentScreen->m_Curseur;
+    MODULEtoLOAD* ref, * cmp;
+    int           ii;
+    MODULE*       Module = NULL;
+    wxPoint       OldPos = m_Parent->m_CurrentScreen->m_Curseur;
 
-	if( s_NbNewModules == 0 ) return;
+    if( s_NbNewModules == 0 )
+        return;
 
-	SortListModulesToLoadByLibname(s_NbNewModules);
+    SortListModulesToLoadByLibname( s_NbNewModules );
     ref = cmp = s_ModuleToLoad_List;
 
     // Calcul de la coordonne de placement des modules:
-	if ( m_Parent->SetBoardBoundaryBoxFromEdgesOnly() )
+    if( m_Parent->SetBoardBoundaryBoxFromEdgesOnly() )
     {
         m_Parent->m_CurrentScreen->m_Curseur.x = m_Parent->m_Pcb->m_BoundaryBox.GetRight() + 5000;
-		m_Parent->m_CurrentScreen->m_Curseur.y = m_Parent->m_Pcb->m_BoundaryBox.GetBottom() + 10000;
+        m_Parent->m_CurrentScreen->m_Curseur.y = m_Parent->m_Pcb->m_BoundaryBox.GetBottom() +
+                                                 10000;
     }
     else
     {
-		m_Parent->m_CurrentScreen->m_Curseur = wxPoint(0,0);
+        m_Parent->m_CurrentScreen->m_Curseur = wxPoint( 0, 0 );
     }
 
     for( ii = 0; ii < s_NbNewModules; ii++, cmp = cmp->Next() )
     {
         if( (ii == 0) || ( ref->m_LibName != cmp->m_LibName) )
         {   /* Nouveau Module a charger */
-			Module = m_Parent->Get_Librairie_Module(this, wxEmptyString, cmp->m_LibName, FALSE );
+            Module = m_Parent->Get_Librairie_Module( this, wxEmptyString, cmp->m_LibName, FALSE );
             ref    = cmp;
-			if ( Module == NULL )
+            if( Module == NULL )
             {
                 wxString msg;
-				msg.Printf(_("Component [%s]: footprint <%s> not found"),
-						cmp->m_CmpName.GetData(), cmp->m_LibName.GetData());
-				DisplayError(this, msg);
+                msg.Printf( _( "Component [%s]: footprint <%s> not found" ),
+                           cmp->m_CmpName.GetData(), cmp->m_LibName.GetData() );
+                DisplayError( this, msg );
                 continue;
             }
-			m_Parent->Place_Module(Module, DC);
+            m_Parent->Place_Module( Module, DC );
+
             /* mise a jour des reperes ( nom et ref "Time Stamp")
-				si module charge */
+             *  si module charge */
             Module->m_Reference->m_Text = cmp->m_CmpName;
             Module->m_TimeStamp = cmp->m_TimeStamp;
         }
-
         else
-		{	/* module deja charge, on peut le dupliquer */
-			MODULE * newmodule;
-			if ( Module == NULL ) continue;	/* module non existant en libr */
-			newmodule = new MODULE(m_Parent->m_Pcb);
-			newmodule->Copy(Module);
-			newmodule->AddToChain(Module);
+        {
+            /* module deja charge, on peut le dupliquer */
+            MODULE* newmodule;
+            if( Module == NULL )
+                continue;                   /* module non existant en libr */
+            newmodule = new MODULE( m_Parent->m_Pcb );
+            newmodule->Copy( Module );
+            newmodule->AddToChain( Module );
             Module = newmodule;
             Module->m_Reference->m_Text = cmp->m_CmpName;
             Module->m_TimeStamp = cmp->m_TimeStamp;
         }
     }
+
     m_Parent->m_CurrentScreen->m_Curseur = OldPos;
 }
 
 
 /* Routine utilisee par qsort pour le tri des modules a charger
-*/
-static int SortByLibName( MODULEtoLOAD ** ref, MODULEtoLOAD ** cmp )
+ */
+static int SortByLibName( MODULEtoLOAD** ref, MODULEtoLOAD** cmp )
 {
-	int ii = (*ref)->m_LibName.CmpNoCase((*cmp)->m_LibName);
+    int ii = (*ref)->m_LibName.CmpNoCase( (*cmp)->m_LibName );
 
     return ii;
 }
 
+
 /*************************************************/
-void SortListModulesToLoadByLibname(int NbModules)
+void SortListModulesToLoadByLibname( int NbModules )
 /**************************************************/
+
 /* Rearrage la liste des modules List par ordre alphabetique des noms lib des modules
-*/
+ */
 {
-MODULEtoLOAD ** base_list, * item;
-int ii;
+    MODULEtoLOAD** base_list, * item;
+    int            ii;
 
-	base_list = (MODULEtoLOAD **) MyMalloc( NbModules * sizeof(MODULEtoLOAD *) );
+    base_list = (MODULEtoLOAD**) MyMalloc( NbModules * sizeof(MODULEtoLOAD *) );
 
-	for ( ii = 0, item = s_ModuleToLoad_List; ii < NbModules; ii++ )
+    for( ii = 0, item = s_ModuleToLoad_List; ii < NbModules; ii++ )
     {
         base_list[ii] = item;
         item = item->Next();
     }
-	qsort( base_list, NbModules, sizeof(MODULEtoLOAD*),
-			(int(*)(const void *, const void *) )SortByLibName);
+
+    qsort( base_list, NbModules, sizeof(MODULEtoLOAD *),
+           ( int( * ) ( const void*, const void* ) )SortByLibName );
+
     // Reconstruction du chainage:
     s_ModuleToLoad_List = *base_list;
-	for ( ii = 0; ii < NbModules-1; ii++ )
+    for( ii = 0; ii < NbModules - 1; ii++ )
     {
         item = base_list[ii];
         item->Pnext = base_list[ii + 1];
     }
+
     // Dernier item: Pnext = NULL:
     item = base_list[ii];
     item->Pnext = NULL;
 
-	free(base_list);
+    free( base_list );
 }
 
 
 /*****************************************************************************/
-MODULEtoLOAD::MODULEtoLOAD(const wxString & libname, const wxString & cmpname,
-			int timestamp) : EDA_BaseStruct(TYPE_NOT_INIT)
+MODULEtoLOAD::MODULEtoLOAD( const wxString& libname, const wxString& cmpname,
+                            int timestamp ) : EDA_BaseStruct( TYPE_NOT_INIT )
 /*****************************************************************************/
 {
     m_LibName   = libname;

pcbnew/onrightclick.cpp

@@ -643,6 +643,7 @@ void CreatePopUpMenuForFootprints( MODULE* Module, wxMenu* menu, bool full_menu
     msg << wxT( " " ) << Module->m_Reference->m_Text;
 
     sub_menu_footprint = new wxMenu;
+    
     ADD_MENUITEM_WITH_SUBMENU( menu, sub_menu_footprint, -1, msg, module_xpm )
     if( full_menu )
     {

pcbnew/pcbnew.h

@@ -36,17 +36,6 @@
 #define ZOOM_CENTER -4
 #define ZOOM_REDRAW -5
 
-/* Bits Flags utilis� en �ition (membre .m_Flags de EDA_BaseStruct)*/
-#define IS_LINKED  1
-#define IN_EDIT    2
-#define IS_MOVED   4
-#define IS_NEW     8
-#define IS_RESIZED 0x10
-#define IS_DRAGGED 0x20
-#define STARTPOINT 0x100
-#define ENDPOINT   0x200
-#define SELECTED   0x400
-
 /* Definition des cas ou l'on force l'affichage en SKETCH (membre .flags) */
 #define FORCE_SKETCH (DRAG | EDIT )
 

pcbnew/pcbtexte.cpp

@@ -288,7 +288,7 @@ void WinEDA_PcbFrame::StartMoveTextePcb( TEXTE_PCB* TextePcb, wxDC* DC )
     old_pos = TextePcb->m_Pos;
     TextePcb->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_XOR );
     TextePcb->m_Flags |= IS_MOVED;
-    Affiche_Infos_PCB_Texte( this, TextePcb );
+    TextePcb->Display_Infos( this );
     DrawPanel->ManageCurseur = Move_Texte_Pcb;
     DrawPanel->ForceCloseManageCurseur = Exit_Texte_Pcb;
     m_CurrentScreen->SetCurItem( TextePcb );
@@ -399,7 +399,7 @@ void WinEDA_PcbFrame::Rotate_Texte_Pcb( TEXTE_PCB* TextePcb, wxDC* DC )
 
     /* Redessin du Texte */
     TextePcb->Draw( DrawPanel, DC, wxPoint( 0, 0 ), drawmode );
-    Affiche_Infos_PCB_Texte( this, TextePcb );
+    TextePcb->Display_Infos( this );
 
     m_CurrentScreen->SetModify();
 }

pcbnew/protos.h

@@ -18,14 +18,6 @@ LISTE_PAD* CreateSortedPadListByXCoord(BOARD * pcb);
 /**************/
 bool Read_Config(const wxString & project_name);
 
-/*********************/
-/* CLASS_EQUIPOT.CPP */
-/*********************/
-
-EQUIPOT * GetEquipot(BOARD * pcb, int netcode);
-		/* retourne un pointeur sur la structure EQUIPOT de numero netcode */
-
-
 /***************/
 /* TRACEPCB.CPP */
 /***************/
@@ -325,23 +317,6 @@ void Affiche_erreur(int nb_err) ;
 /*****************************************************************/
 /* AFFICHE.CPP: (Fonctions d'affichage de messages, parametres... */
 /*****************************************************************/
-void Affiche_Infos_Segment_Module(WinEDA_BasePcbFrame * frame, MODULE* pt_module,EDGE_MODULE* pt_edge);
-	/* Affiche en bas d'ecran les caract du Segment contour d'un module */
-
-void Affiche_Infos_Piste(WinEDA_BasePcbFrame * frame, TRACK* pt_piste) ;
-	/* Affiche les caract principales d'un segment de piste en bas d'ecran */
-
-void Affiche_Infos_E_Texte(WinEDA_BasePcbFrame * frame, MODULE * adr_empreinte,TEXTE_MODULE *pt_texte) ;
-	/* Affiche en bas d'ecran les caract du texte sur empreinte */
-void Affiche_Infos_PCB_Texte(WinEDA_BasePcbFrame * frame, TEXTE_PCB* pt_texte);
-	/* Affiche en bas d'ecran les caract du texte type PCB */
-
-void Affiche_Infos_Status_Pcb(WinEDA_BasePcbFrame * frame); /* Affiche l'etat du PCB:
-									 nb de pads, nets , connexions.. */
-
-void Affiche_Infos_DrawSegment(WinEDA_BasePcbFrame * frame, DRAWSEGMENT * DrawSegment);
-					/* Affiche les caract principales d'un segment type
-					drawing PCB en bas d'ecran */
 void Affiche_Infos_Equipot(int netcode, WinEDA_BasePcbFrame * frame);
 
 	/************/

pcbnew/ratsnest.cpp

@@ -61,7 +61,8 @@ wxString msg;
 	// Reaffichage des chevelus actifs
 	if( g_Show_Ratsnest ) DrawGeneralRatsnest( DC, 0 );
 
-	if ( display_status_pcb ) Affiche_Infos_Status_Pcb(this);
+	if ( display_status_pcb ) 
+        m_Pcb->Display_Infos( this );
 }
 
 
@@ -376,7 +377,7 @@ EQUIPOT * equipot;
 		m_Pcb->m_NbLinks += nbpads;
 
 		/* fin de liste trouvee: calcul du chevelu du net "net_code" */
-		equipot = GetEquipot(m_Pcb, current_net_code);
+		equipot = m_Pcb->FindNet( current_net_code);
 		if(equipot == NULL)
 			DisplayError(this, wxT("Gen ratsnest err: NULL equipot") );
 		else
@@ -617,7 +618,7 @@ EQUIPOT * equipot;
 
 	for ( net_code = 1; ; net_code++)
 		{
-		equipot = GetEquipot(m_Pcb, net_code);
+		equipot = m_Pcb->FindNet( net_code );
 		if(equipot == NULL ) break;
 		if( ref_netcode && (net_code != ref_netcode) ) continue;
 

pcbnew/router.cpp

@@ -179,7 +179,7 @@ int no_conn = Pcb->m_NbPads+1;	/* valeur incrementee pour indiquer
 			if ( nb_pads < 2 )
 			{
 				wxString Line;
-				EQUIPOT * equipot = GetEquipot(Pcb, netcode);
+				EQUIPOT * equipot = Pcb->FindNet( netcode );
 				Line.Printf( wxT("Warning: %d pad, net %s"),
             					nb_pads, equipot->m_Netname.GetData());
 				DisplayError(NULL, Line,20);

pcbnew/solve.cpp

@@ -217,7 +217,7 @@ wxString msg;
 			}
 
 		Ncurrent++;
-		pt_equipot = GetEquipot(m_Pcb, current_net_code);
+		pt_equipot = m_Pcb->FindNet( current_net_code );
 		if( pt_equipot)
 			{
 			msg.Printf( wxT("[%8.8s]"),pt_equipot->m_Netname.GetData());

pcbnew/undelete.cpp

-	/********************************************************/
-	/* Effacements : Routines de sauvegarde et d'effacement */
-	/********************************************************/
+/********************************************************/
+/* Effacements : Routines de sauvegarde et d'effacement */
+/********************************************************/
 
 #include "fctsys.h"
 #include "gr_basic.h"
@@ -15,130 +15,139 @@
 /* Routines Locales */
 
 /********************************************/
-void WinEDA_PcbFrame::UnDeleteItem(wxDC * DC)
+void WinEDA_PcbFrame::UnDeleteItem( wxDC* DC )
 /********************************************/
+
 /* Restitution d'un element (MODULE ou TRACK ) Efface
-*/
+ */
 {
-EDA_BaseStruct * PtStruct, *PtNext;
-TRACK * pt_track;
-int net_code;
+    EDA_BaseStruct* PtStruct, * PtNext;
+    TRACK*          pt_track;
+    int             net_code;
 
-	if( ! g_UnDeleteStackPtr ) return;
+    if( !g_UnDeleteStackPtr )
+        return;
 
-	g_UnDeleteStackPtr --;
+    g_UnDeleteStackPtr--;
     PtStruct = g_UnDeleteStack[g_UnDeleteStackPtr];
-	if ( PtStruct == NULL ) return;	// Ne devrait pas se produire
+    if( PtStruct == NULL )
+        return;                     // Ne devrait pas se produire
 
-	switch(PtStruct->m_StructType)
+    switch( PtStruct->m_StructType )
     {
     case TYPEVIA:
     case TYPETRACK:
-			for( ; PtStruct != NULL; PtStruct = PtNext)
+        for( ; PtStruct != NULL; PtStruct = PtNext )
         {
             PtNext = PtStruct->Pnext;
-				PtStruct->SetState(DELETED,OFF);	/* Effacement du bit DELETED */
-				((TRACK*)PtStruct)->Draw(DrawPanel, DC, GR_OR);
+            PtStruct->SetState( DELETED, OFF );     /* Effacement du bit DELETED */
+            ( (TRACK*) PtStruct )->Draw( DrawPanel, DC, GR_OR );
         }
 
         PtStruct = g_UnDeleteStack[g_UnDeleteStackPtr];
-			net_code = ((TRACK*)PtStruct)->m_NetCode;
-			pt_track = ( (TRACK*) PtStruct)->GetBestInsertPoint( m_Pcb );
-			((TRACK*)PtStruct)->Insert(m_Pcb, pt_track);
+        net_code = ( (TRACK*) PtStruct )->m_NetCode;
+        pt_track = ( (TRACK*) PtStruct )->GetBestInsertPoint( m_Pcb );
+        ( (TRACK*) PtStruct )->Insert( m_Pcb, pt_track );
         g_UnDeleteStack[g_UnDeleteStackPtr] = NULL;
 
-			test_1_net_connexion(DC, net_code );
-			Affiche_Infos_Status_Pcb(this);
+        test_1_net_connexion( DC, net_code );
+        m_Pcb->Display_Infos( this );
         break;
 
     case TYPEMODULE:
         /* Erase general rastnest if needed */
-			if(g_Show_Ratsnest) DrawGeneralRatsnest(DC);
+        if( g_Show_Ratsnest )
+            DrawGeneralRatsnest( DC );
+
         /* Reinsertion du module dans la liste chainee des modules,
-			en debut de chaine */
+         *  en debut de chaine */
         PtStruct->Pback = m_Pcb;
         PtNext = m_Pcb->m_Modules;
         PtStruct->Pnext = PtNext;
-			if( PtNext) PtNext->Pback = PtStruct;
-			m_Pcb->m_Modules = (MODULE*)PtStruct;
+        if( PtNext )
+            PtNext->Pback = PtStruct;
+        m_Pcb->m_Modules = (MODULE*) PtStruct;
         g_UnDeleteStack[g_UnDeleteStackPtr] = NULL;
 
-			((MODULE *) PtStruct)->Draw(DrawPanel, DC, wxPoint(0,0), GR_OR);
+        ( (MODULE*) PtStruct )->Draw( DrawPanel, DC, wxPoint( 0, 0 ), GR_OR );
 
-			PtStruct->SetState(DELETED,OFF);	/* Creal DELETED flag */
+        PtStruct->SetState( DELETED, OFF );     /* Creal DELETED flag */
         PtStruct->m_Flags   = 0;
-			m_Pcb->m_Status_Pcb = 0 ;
+        m_Pcb->m_Status_Pcb = 0;
         build_liste_pads();
         ReCompile_Ratsnest_After_Changes( DC );
         break;
 
     default:
-			DisplayError(this, wxT("WinEDA_PcbFrame::UnDeleteItem(): unexpected Struct type"));
+        DisplayError( this, wxT( "WinEDA_PcbFrame::UnDeleteItem(): unexpected Struct type" ) );
         break;
     }
 }
 
 
-	/**************************************************************/
-	/* void * SaveItemEfface(int type, void * PtItem, int nbitems) */
-	/**************************************************************/
+/**************************************************************/
+/* void * SaveItemEfface(int type, void * PtItem, int nbitems) */
+/**************************************************************/
 
 /* Sauvegarde d'un element aux fins de restitution par Undelete
-	Supporte actuellement : Module et segments de piste
-*/
-EDA_BaseStruct * WinEDA_PcbFrame::SaveItemEfface(EDA_BaseStruct * PtItem, int nbitems)
+ *  Supporte actuellement : Module et segments de piste
+ */
+EDA_BaseStruct* WinEDA_PcbFrame::SaveItemEfface( EDA_BaseStruct* PtItem, int nbitems )
 {
-EDA_BaseStruct * NextS, * PtStruct = PtItem;
-int ii;
+    EDA_BaseStruct* NextS, * PtStruct = PtItem;
+    int             ii;
 
-	if( (PtItem == NULL) || (nbitems == 0) ) return NULL;
+    if( (PtItem == NULL) || (nbitems == 0) )
+        return NULL;
 
-	if (g_UnDeleteStackPtr >= UNDELETE_STACK_SIZE )
+    if( g_UnDeleteStackPtr >= UNDELETE_STACK_SIZE )
     {
         /* Delete last deleted item, and shift stack. */
-		DeleteStructList(g_UnDeleteStack[0]);
-		for (ii = 0; ii < (g_UnDeleteStackPtr-1); ii++)
+        DeleteStructList( g_UnDeleteStack[0] );
+        for( ii = 0; ii < (g_UnDeleteStackPtr - 1); ii++ )
         {
             g_UnDeleteStack[ii] = g_UnDeleteStack[ii + 1];
         }
+
         g_UnDeleteStackPtr--;;
     }
 
-	switch ( PtStruct->m_StructType )
+    switch( PtStruct->m_StructType )
     {
     case TYPEVIA:
     case TYPETRACK:
     {
-			EDA_BaseStruct * Back = NULL;
+        EDA_BaseStruct* Back = NULL;
         g_UnDeleteStack[g_UnDeleteStackPtr++] = PtStruct;
 
-			for ( ; nbitems > 0; nbitems--, PtStruct = NextS)
+        for( ; nbitems > 0; nbitems--, PtStruct = NextS )
         {
             NextS = PtStruct->Pnext;
-				((TRACK*)PtStruct)->UnLink();
-				PtStruct->SetState(DELETED, ON);
-				if( nbitems <= 1 ) NextS = NULL;	/* fin de chaine */
+            ( (TRACK*) PtStruct )->UnLink();
+            PtStruct->SetState( DELETED, ON );
+            if( nbitems <= 1 )
+                NextS = NULL;                       /* fin de chaine */
             PtStruct->Pnext = NextS;
             PtStruct->Pback = Back; Back = PtStruct;
-				if(NextS == NULL) break;
+            if( NextS == NULL )
+                break;
         }
     }
         break;
 
     case TYPEMODULE:
     {
-			MODULE * Module = (MODULE*)PtItem;
+        MODULE* Module = (MODULE*) PtItem;
         Module->UnLink();
-			Module->SetState(DELETED, ON);
+        Module->SetState( DELETED, ON );
         g_UnDeleteStack[g_UnDeleteStackPtr++] = Module;
         build_liste_pads();
     }
         break;
 
-		default: break;
+    default:
+        break;
     }
 
-	return(g_UnDeleteStack[g_UnDeleteStackPtr-1]);
+    return g_UnDeleteStack[g_UnDeleteStackPtr - 1];
 }
-
-

pcbnew/zones.cpp

@@ -548,7 +548,7 @@ void WinEDA_PcbFrame::CaptureNetName( wxDC* DC )
     }
     else
     {
-        Affiche_Infos_Piste( this, adrpiste );
+        adrpiste->Display_Infos( this );
         netcode = adrpiste->m_NetCode;
     }
 
@@ -901,7 +901,7 @@ void WinEDA_PcbFrame::Fill_Zone( wxDC* DC )
     /* Affichage du NetName */
     if( g_HightLigth_NetCode > 0 )
     {
-        pt_equipot = GetEquipot( m_Pcb, g_HightLigth_NetCode );
+        pt_equipot = m_Pcb->FindNet( g_HightLigth_NetCode );
         if( pt_equipot == NULL )
         {
             if( g_HightLigth_NetCode > 0 )