haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

This commit is contained in:
dickelbeck 2007-08-20 19:33:15 +00:00
parent 0421987b32
commit 49e32e096e
47 changed files with 1989 additions and 1803 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
change_log.txt
View File

@ -4,6 +4,26 @@ Started 2007-June-11
Please add newer entries at the top, list the date and your name with Please add newer entries at the top, list the date and your name with
email address. 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> 2007-Aug-20 UPDATE Geoff Harland <gharlandau@yahoo.com.au>
================================================================================ ================================================================================
+ eeschema & pcbnew + eeschema & pcbnew

4
eeschema/delete.cpp
View File

@ -13,10 +13,6 @@
#include "protos.h" #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, static int CountConnectedItems(WinEDA_SchematicFrame * frame,

12
eeschema/general.h
View File

@ -24,18 +24,6 @@
#define HIGHLIGHT_COLOR WHITE #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 */ /* Used for EDA_BaseStruct, .m_Select member */
#define IS_SELECTED 1 #define IS_SELECTED 1

216
gerbview/locate.cpp
View File

@ -13,7 +13,7 @@
/* variables locales */ /* variables locales */
int ux0, uy0, dx, dy, spot_cX, spot_cY; /* Variables utilisees pour int ux0, uy0, dx, dy, spot_cX, spot_cY; /* Variables utilisees pour
la localisation des segments */ * la localisation des segments */
/* fonctions locales */ /* fonctions locales */
static TRACK* Locate_Zone( TRACK* start_adresse, int layer, int typeloc ); 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_Zone( TRACK* start_adresse, wxPoint ref, int layer );
@ -22,24 +22,24 @@ static TRACK * Locate_Pistes(TRACK * start_adresse, wxPoint ref,int Layer);
static DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc ); static DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int typeloc );
static TEXTE_PCB* Locate_Texte_Pcb( TEXTE_PCB* pt_txt_pcb, int typeloc ); static TEXTE_PCB* Locate_Texte_Pcb( TEXTE_PCB* pt_txt_pcb, int typeloc );
static int distance( int seuil ); static int distance( int seuil );
/**/ /**/
/* Macro de calcul de la coord de pointage selon le curseur /* Macro de calcul de la coord de pointage selon le curseur
(ON/OFF grille) choisi * (ON/OFF grille) choisi
*/ */
#define SET_REF_POS( ref ) if( typeloc == CURSEUR_ON_GRILLE ) \ #define SET_REF_POS( ref ) if( typeloc == CURSEUR_ON_GRILLE ) \
{ ref = ActiveScreen->m_Curseur; } \ { ref = ActiveScreen->m_Curseur; } \
else { ref = ActiveScreen->m_MousePosition; } else { ref = ActiveScreen->m_MousePosition; }
/*************************************************************/ /*************************************************************/
EDA_BaseStruct* WinEDA_GerberFrame::Locate( int typeloc ) EDA_BaseStruct* WinEDA_GerberFrame::Locate( int typeloc )
/*************************************************************/ /*************************************************************/
/* Fonction de localisation generale /* Fonction de localisation generale
Affiche les caract de la stucture localisée et retourne un pointeur * Affiche les caract de la stucture localisée et retourne un pointeur
sur celle-ci * sur celle-ci
*/ */
{ {
TEXTE_PCB* pt_texte_pcb; TEXTE_PCB* pt_texte_pcb;
@ -57,10 +57,12 @@ int layer;
while( ( TrackLocate = Locate_Pistes( TrackLocate, layer, typeloc ) ) != NULL ) while( ( TrackLocate = Locate_Pistes( TrackLocate, layer, typeloc ) ) != NULL )
{ {
Track = TrackLocate; Track = TrackLocate;
if(TrackLocate->m_StructType == TYPEVIA) break ; if( TrackLocate->m_StructType == TYPEVIA )
break;
TrackLocate = (TRACK*) TrackLocate->Pnext; TrackLocate = (TRACK*) TrackLocate->Pnext;
} }
Affiche_Infos_Piste(this, Track) ;
Track->Display_Infos( this );
return Track; return Track;
} }
@ -68,7 +70,8 @@ int layer;
pt_texte_pcb = Locate_Texte_Pcb( (TEXTE_PCB*) m_Pcb->m_Drawings, typeloc ); pt_texte_pcb = Locate_Texte_Pcb( (TEXTE_PCB*) m_Pcb->m_Drawings, typeloc );
if( pt_texte_pcb ) // texte type PCB localise 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 )
@ -79,7 +82,8 @@ int layer;
if( ( TrackLocate = Locate_Zone( (TRACK*) m_Pcb->m_Zone, if( ( TrackLocate = Locate_Zone( (TRACK*) m_Pcb->m_Zone,
GetScreen()->m_Active_Layer, typeloc ) ) != NULL ) GetScreen()->m_Active_Layer, typeloc ) ) != NULL )
{ {
Affiche_Infos_Piste(this, TrackLocate) ; return TrackLocate; TrackLocate->Display_Infos( this );
return TrackLocate;
} }
MsgPanel->EraseMsgBox(); MsgPanel->EraseMsgBox();
@ -87,27 +91,29 @@ 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 /* Localisation de segments de contour du type edge pcb ou draw
(selon couche active) * (selon couche active)
Retourne: * Retourne:
Pointeur sur DEBUT du segment localise * Pointeur sur DEBUT du segment localise
NULL si rien trouve * NULL si rien trouve
*/ */
{ {
EDA_BaseStruct* PtStruct; EDA_BaseStruct* PtStruct;
DRAWSEGMENT* pts; DRAWSEGMENT* pts;
wxPoint ref; wxPoint ref;
PCB_SCREEN* screen = (PCB_SCREEN*) ActiveScreen; PCB_SCREEN* screen = (PCB_SCREEN*) ActiveScreen;
SET_REF_POS( ref ); SET_REF_POS( ref );
PtStruct = Pcb->m_Drawings; PtStruct = Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{ {
if( PtStruct->m_StructType != TYPEDRAWSEGMENT ) continue; if( PtStruct->m_StructType != TYPEDRAWSEGMENT )
continue;
pts = (DRAWSEGMENT*) PtStruct; pts = (DRAWSEGMENT*) PtStruct;
ux0 = pts->m_Start.x; uy0 = pts->m_Start.y; ux0 = pts->m_Start.x; uy0 = pts->m_Start.y;
/* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */ /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
@ -115,7 +121,8 @@ PCB_SCREEN * screen = (PCB_SCREEN *) ActiveScreen;
spot_cX = ref.x - ux0; spot_cY = ref.y - uy0; spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
/* detection : */ /* 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) ) if( (pts->m_Shape == S_CIRCLE) || (pts->m_Shape == S_ARC) )
{ {
@ -124,7 +131,8 @@ PCB_SCREEN * screen = (PCB_SCREEN *) ActiveScreen;
dist = (int) hypot( (double) (spot_cX), (double) (spot_cY) ); dist = (int) hypot( (double) (spot_cX), (double) (spot_cY) );
if( abs( rayon - dist ) <= (pts->m_Width / 2) ) 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 */ /* pour un arc, controle complementaire */
MouseAngle = (int) ArcTangente( spot_cY, spot_cX ); MouseAngle = (int) ArcTangente( spot_cY, spot_cX );
StAngle = (int) ArcTangente( dy, dx ); StAngle = (int) ArcTangente( dy, dx );
@ -135,16 +143,17 @@ PCB_SCREEN * screen = (PCB_SCREEN *) ActiveScreen;
StAngle -= 3600; EndAngle -= 3600; StAngle -= 3600; EndAngle -= 3600;
} }
if( (MouseAngle >= StAngle) && (MouseAngle <= EndAngle) ) if( (MouseAngle >= StAngle) && (MouseAngle <= EndAngle) )
return(pts); return pts;
}
}
else
{
if( distance( pts->m_Width / 2 ) )
return pts;
} }
} }
else return NULL;
{
if( distance( pts->m_Width /2 ) ) return( pts ) ;
}
}
return(NULL) ;
} }
@ -154,11 +163,11 @@ PCB_SCREEN * screen = (PCB_SCREEN *) ActiveScreen;
/****************************************************************************/ /****************************************************************************/
/* /*
1 - routine de localisation du segment de piste pointe par la souris. * 1 - routine de localisation du segment de piste pointe par la souris.
2 - routine de localisation du segment de piste pointe par le point * 2 - routine de localisation du segment de piste pointe par le point
ref_pX , ref_pY.r * ref_pX , ref_pY.r
*
La recherche commence a l'adresse start_adresse * La recherche commence a l'adresse start_adresse
*/ */
TRACK* Locate_Pistes( TRACK* start_adresse, int Layer, int typeloc ) TRACK* Locate_Pistes( TRACK* start_adresse, int Layer, int typeloc )
@ -167,7 +176,7 @@ wxPoint ref;
SET_REF_POS( ref ); SET_REF_POS( ref );
return( Locate_Pistes(start_adresse, ref, Layer) ); return Locate_Pistes( start_adresse, ref, Layer );
} }
@ -178,7 +187,8 @@ 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 */ /* calcul des coordonnees du segment teste */
l_piste = Track->m_Width >> 1; /* l_piste = demi largeur piste */ l_piste = Track->m_Width >> 1; /* l_piste = demi largeur piste */
ux0 = Track->m_Start.x; uy0 = Track->m_Start.y; /* coord de depart */ ux0 = Track->m_Start.x; uy0 = Track->m_Start.y; /* coord de depart */
@ -192,7 +202,7 @@ int l_piste ; /* demi-largeur de la piste */
{ {
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;
} }
@ -200,11 +210,14 @@ int l_piste ; /* demi-largeur de la piste */
if( Layer >= 0 ) if( Layer >= 0 )
if( Track->m_Layer != Layer ) if( Track->m_Layer != Layer )
continue;/* Segments sur couches differentes */ continue;/* Segments sur couches differentes */
if( distance(l_piste) ) return(Track) ; if( distance( l_piste ) )
return Track;
} }
return(NULL) ;
return NULL;
} }
/****************************************************************/ /****************************************************************/
/* TRACK * Locate_Zone(TRACK * start_adresse, int layer, */ /* TRACK * Locate_Zone(TRACK * start_adresse, int layer, */
/* int typeloc) */ /* int typeloc) */
@ -212,13 +225,13 @@ int l_piste ; /* demi-largeur de la piste */
/****************************************************************/ /****************************************************************/
/* /*
1 - routine de localisation du segment de zone pointe par la souris. * 1 - routine de localisation du segment de zone pointe par la souris.
2 - routine de localisation du segment de zone pointe par le point * 2 - routine de localisation du segment de zone pointe par le point
ref_pX , ref_pY.r * ref_pX , ref_pY.r
*
Si layer == -1 , le tst de la couche n'est pas fait * Si layer == -1 , le tst de la couche n'est pas fait
*
La recherche commence a l'adresse start_adresse * La recherche commence a l'adresse start_adresse
*/ */
TRACK* Locate_Zone( TRACK* start_adresse, int layer, int typeloc ) TRACK* Locate_Zone( TRACK* start_adresse, int layer, int typeloc )
@ -227,7 +240,7 @@ wxPoint ref;
SET_REF_POS( ref ); SET_REF_POS( ref );
return( Locate_Zone(start_adresse, ref, layer) ); return Locate_Zone( start_adresse, ref, layer );
} }
@ -247,12 +260,14 @@ int l_segm ; /* demi-largeur de la piste */
dx -= ux0; dy -= uy0; dx -= ux0; dy -= uy0;
spot_cX = ref.x - ux0; spot_cY = ref.y - uy0; spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
if((layer != -1) && (Zone->m_Layer != layer)) continue; if( (layer != -1) && (Zone->m_Layer != layer) )
if( distance(l_segm) ) return(Zone) ; continue;
} if( distance( l_segm ) )
return(NULL) ; return Zone;
} }
return NULL;
}
/***************************************************************/ /***************************************************************/
@ -260,8 +275,8 @@ int l_segm ; /* demi-largeur de la piste */
/***************************************************************/ /***************************************************************/
/* localisation des inscriptions sur le Pcb: /* localisation des inscriptions sur le Pcb:
entree : char pointeur sur le debut de la zone de recherche * entree : char pointeur sur le debut de la zone de recherche
retour : pointeur sur la description du texte localise * 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 )
@ -274,7 +289,8 @@ wxPoint ref;
PtStruct = (EDA_BaseStruct*) pt_txt_pcb; PtStruct = (EDA_BaseStruct*) pt_txt_pcb;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext ) for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{ {
if( PtStruct->m_StructType != TYPETEXTE ) continue; if( PtStruct->m_StructType != TYPETEXTE )
continue;
pt_txt_pcb = (TEXTE_PCB*) PtStruct; pt_txt_pcb = (TEXTE_PCB*) PtStruct;
angle = pt_txt_pcb->m_Orient; angle = pt_txt_pcb->m_Orient;
@ -288,11 +304,11 @@ wxPoint ref;
spot_cX = ref.x - ux0; spot_cY = ref.y - uy0; spot_cX = ref.x - ux0; spot_cY = ref.y - uy0;
RotatePoint( &spot_cX, &spot_cY, -angle ); RotatePoint( &spot_cX, &spot_cY, -angle );
if( ( abs( spot_cX ) <= abs( dx ) ) && ( abs( spot_cY ) <= abs( dy ) ) ) if( ( abs( spot_cX ) <= abs( dx ) ) && ( abs( spot_cY ) <= abs( dy ) ) )
return(pt_txt_pcb) ; return pt_txt_pcb;
}
return(NULL) ;
} }
return NULL;
}
/*****************************/ /*****************************/
@ -300,20 +316,20 @@ wxPoint ref;
/*****************************/ /*****************************/
/* /*
Calcul de la distance du curseur souris a un segment de droite : * Calcul de la distance du curseur souris a un segment de droite :
( piste, edge, contour module .. * ( piste, edge, contour module ..
retourne: * retourne:
0 si distance > seuil * 0 si distance > seuil
1 si distance <= seuil * 1 si distance <= seuil
Variables utilisees ( doivent etre initialisees avant appel , et * Variables utilisees ( doivent etre initialisees avant appel , et
sont ramenees au repere centre sur l'origine du segment) * sont ramenees au repere centre sur l'origine du segment)
dx, dy = coord de l'extremite segment. * dx, dy = coord de l'extremite segment.
spot_cX,spot_cY = coord du curseur souris * spot_cX,spot_cY = coord du curseur souris
la recherche se fait selon 4 cas: * la recherche se fait selon 4 cas:
segment horizontal * segment horizontal
segment vertical * segment vertical
segment 45 * segment 45
segment quelconque * segment quelconque
*/ */
int distance( int seuil ) int distance( int seuil )
@ -321,7 +337,7 @@ 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 */ segX, segY; /* coord extremite segment tj >= 0 */
int pointX, pointY;/* coord point a tester dans repere modifie dans lequel int pointX, pointY;/* coord point a tester dans repere modifie dans lequel
segX et segY sont >=0 */ * 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;
@ -340,81 +356,84 @@ int pointX, pointY; /* coord point a tester dans repere modifie dans lequel
{ {
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 */ /* Etude des extremites : cercle de rayon seuil */
if( (pointX < 0) && (pointX >= -seuil) ) if( (pointX < 0) && (pointX >= -seuil) )
{ {
if( ( (pointX * pointX) + (pointY * pointY) ) <= (seuil * seuil) ) if( ( (pointX * pointX) + (pointY * pointY) ) <= (seuil * seuil) )
return(1); return 1;
} }
if( (pointX > segX) && ( pointX <= (segX + seuil) ) ) if( (pointX > segX) && ( pointX <= (segX + seuil) ) )
{ {
if( (((pointX-segX) * (pointX-segX)) + (pointY*pointY)) <= (seuil*seuil) ) if( ( ( (pointX - segX) * (pointX - segX) ) + (pointY * pointY) ) <=
return(1); (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 < 0) && (pointY >= -seuil) )
{ {
if( ( (pointY * pointY) + (pointX * pointX) ) <= (seuil * seuil) ) if( ( (pointY * pointY) + (pointX * pointX) ) <= (seuil * seuil) )
return(1); return 1;
} }
if( (pointY > segY) && ( pointY <= (segY + seuil) ) ) if( (pointY > segY) && ( pointY <= (segY + seuil) ) )
{ {
if( ( ((pointY-segY) * (pointY-segY)) + (pointX*pointX)) <= (seuil*seuil) ) if( ( ( (pointY - segY) * (pointY - segY) ) + (pointX * pointX) ) <=
return(1); (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 /* on fait tourner les axes de 45 degre. la souris a alors les
coord : x1 = x*cos45 + y*sin45 * coord : x1 = x*cos45 + y*sin45
y1 = y*cos45 - x*sin45 * y1 = y*cos45 - x*sin45
et le segment de piste est alors horizontal. * et le segment de piste est alors horizontal.
recalcul des coord de la souris ( sin45 = cos45 = .707 = 7/10 * recalcul des coord de la souris ( sin45 = cos45 = .707 = 7/10
remarque : sin ou cos45 = .707, et lors du recalcul des coord * 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 * dx45 et dy45, lec coeff .707 est neglige, dx et dy sont en fait .707 fois
trop grands. (c.a.d trop petits) * trop grands. (c.a.d trop petits)
spot_cX,Y doit etre * par .707 * .707 = 0.5 */ * spot_cX,Y doit etre * par .707 * .707 = 0.5 */
cXrot = (pointX + pointY) >> 1; cXrot = (pointX + pointY) >> 1;
cYrot = (pointY - pointX) >> 1; cYrot = (pointY - pointX) >> 1;
/* recalcul des coord de l'extremite du segment , qui sera vertical /* recalcul des coord de l'extremite du segment , qui sera vertical
suite a l'orientation des axes sur l'ecran : dx45 = pointX (ou pointY) * suite a l'orientation des axes sur l'ecran : dx45 = pointX (ou pointY)
et est en fait 1,414 plus grand , et dy45 = 0 */ * 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 doit etre * .707 pour tenir compte du coeff de reduction sur dx,dy
seuil *= 7; seuil /= 10; seuil *= 7; seuil /= 10;
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 */ /* Etude des extremites : cercle de rayon seuil */
if( (cXrot < 0) && (cXrot >= -seuil) ) if( (cXrot < 0) && (cXrot >= -seuil) )
{ {
if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) ) if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) )
return(1); return 1;
} }
if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) ) if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) )
{ {
if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) ) if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) )
return(1); return 1;
} }
} }
} }
else /* orientation quelconque */ else /* orientation quelconque */
{ {
/* On fait un changement d'axe (rotation) de facon a ce que le segment /* 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; int angle;
angle = (int) ( atan2( (float) segY, (float) segX ) * 1800 / M_PI); angle = (int) ( atan2( (float) segY, (float) segX ) * 1800 / M_PI);
@ -423,25 +442,24 @@ int pointX, pointY; /* coord point a tester dans repere modifie dans lequel
RotatePoint( &segX, &segY, angle ); /* Rotation du segment */ RotatePoint( &segX, &segY, angle ); /* Rotation du segment */
/*la piste est Horizontale , par suite des modifs de coordonnes /*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 */ /* Etude des extremites : cercle de rayon seuil */
if( (cXrot < 0) && (cXrot >= -seuil) ) if( (cXrot < 0) && (cXrot >= -seuil) )
{ {
if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) ) if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) )
return(1); return 1;
} }
if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) ) if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) )
{ {
if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) ) if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) )
return(1); return 1;
} }
} }
} }
return(0) ; return 0;
} }

34
include/base_struct.h
View File

@ -83,7 +83,7 @@ enum SEARCH_RESULT {
typedef DrawStructureType KICAD_T; // shorter name typedef DrawStructureType KICAD_T; // shorter name
class EDA_BaseStruct; class EDA_BaseStruct;
class WinEDA_DrawFrame;
/** /**
* Class INSPECTOR * Class INSPECTOR
@ -132,7 +132,26 @@ public:
EDA_BaseStruct* m_Parent; /* Linked list: Link (parent struct) */ EDA_BaseStruct* m_Parent; /* Linked list: Link (parent struct) */
EDA_BaseStruct* m_Son; /* Linked list: Link (son struct) */ EDA_BaseStruct* m_Son; /* Linked list: Link (son struct) */
EDA_BaseStruct* m_Image; /* Link to an image copy for undelete or abort command */ EDA_BaseStruct* m_Image; /* Link to an image copy for undelete or abort command */
int m_Flags; // flags for editions and other 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 unsigned long m_TimeStamp; // Time stamp used for logical links
int m_Selected; /* Used by block commands, and selective editing */ int m_Selected; /* Used by block commands, and selective editing */
@ -178,6 +197,19 @@ public:
int draw_mode, int draw_mode,
int Color = -1 ); 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 * Function HitTest
* tests if the given wxPoint is within the bounds of this object. * tests if the given wxPoint is within the bounds of this object.

30
include/pcbstruct.h
View File

@ -234,6 +234,16 @@ public:
bool ComputeBoundaryBox( void ); 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 * Function Visit
* may be re-implemented for each derived class in order to handle * 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 ); 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) #if defined(DEBUG)
/** /**
* Function GetClass * Function GetClass
@ -340,6 +359,17 @@ public:
void Copy( DRAWSEGMENT* source ); 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 * Function HitTest
* tests if the given wxPoint is within the bounds of this object. * tests if the given wxPoint is within the bounds of this object.

349
pcbnew/affiche.cpp
View File

@ -14,353 +14,6 @@
/* Routines locales */ /* 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 ) 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(); frame->MsgPanel->EraseMsgBox();
equipot = GetEquipot( frame->m_Pcb, netcode ); equipot = frame->m_Pcb->FindNet( netcode );
if( equipot ) if( equipot )
Affiche_1_Parametre( frame, 1, _( "Net Name" ), equipot->m_Netname, RED ); Affiche_1_Parametre( frame, 1, _( "Net Name" ), equipot->m_Netname, RED );
else else

2
pcbnew/attribut.cpp
View File

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

70
pcbnew/class_board.cpp
View File

@ -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 // virtual, see pcbstruct.h
SEARCH_RESULT BOARD::Visit( INSPECTOR* inspector, const void* testData, SEARCH_RESULT BOARD::Visit( INSPECTOR* inspector, const void* testData,
const KICAD_T scanTypes[] ) 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) #if defined(DEBUG)
/** /**

10
pcbnew/class_cotation.cpp
View File

@ -8,6 +8,8 @@
#include "common.h" #include "common.h"
#include "pcbnew.h" #include "pcbnew.h"
#include "trigo.h" #include "trigo.h"
#include "wxstruct.h"
COTATION::COTATION( EDA_BaseStruct* StructFather ) : COTATION::COTATION( EDA_BaseStruct* StructFather ) :
EDA_BaseStruct( StructFather, TYPECOTATION ) 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 * Function HitTest
* tests if the given wxPoint is within the bounds of this object. * tests if the given wxPoint is within the bounds of this object.

10
pcbnew/class_cotation.h
View File

@ -42,6 +42,16 @@ public:
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset, int mode_color ); 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 * Function HitTest
* tests if the given wxPoint is within the bounds of this object. * tests if the given wxPoint is within the bounds of this object.

29
pcbnew/class_edge_mod.cpp
View File

@ -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 ) int EDGE_MODULE::WriteDescr( FILE* File )
/*****************************************/ /*****************************************/

11
pcbnew/class_edge_mod.h
View File

@ -42,6 +42,17 @@ public:
int draw_mode ); int draw_mode );
void Draw3D( Pcb3D_GLCanvas* glcanvas ); 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 * Function HitTest
* tests if the given wxPoint is within the bounds of this object. * tests if the given wxPoint is within the bounds of this object.

25
pcbnew/class_equipot.cpp
View File

@ -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 ) int EQUIPOT:: ReadEquipotDescr( FILE* File, int* LineNum )
/*********************************************************/ /*********************************************************/

7
pcbnew/class_module.h
View File

@ -130,7 +130,12 @@ public:
void DrawAncre( WinEDA_DrawPanel* panel, wxDC* DC, void DrawAncre( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int dim_ancre, int draw_mode ); 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 ); void Display_Infos( WinEDA_BasePcbFrame* frame );

2
pcbnew/class_pad.cpp
View File

@ -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 */ /* Affiche en bas d'ecran les caract de la pastille demandee */
{ {

10
pcbnew/class_pad.h
View File

@ -89,8 +89,14 @@ public:
void ComputeRayon( void ); // met a jour m_Rayon, rayon du cercle exinscrit void ComputeRayon( void ); // met a jour m_Rayon, rayon du cercle exinscrit
const wxPoint ReturnShapePos( void ); // retourne la position 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 * Function HitTest

38
pcbnew/class_pcb_text.cpp
View File

@ -150,6 +150,44 @@ void TEXTE_PCB::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
(g_AnchorColor & ITEM_NOT_SHOW) ? -1 : (g_AnchorColor & MASKCOLOR) ); (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) #if defined(DEBUG)
/** /**

11
pcbnew/class_pcb_text.h
View File

@ -26,6 +26,17 @@ public:
int ReadTextePcbDescr(FILE * File, int * LineNum); int ReadTextePcbDescr(FILE * File, int * LineNum);
int WriteTextePcbDescr(FILE * File); 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) #if defined(DEBUG)
/** /**
* Function GetClass * Function GetClass

64
pcbnew/class_text_mod.cpp
View File

@ -295,6 +295,70 @@ int TEXTE_MODULE::GetDrawRotation( void )
return rotation; 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) #if defined(DEBUG)
/** /**
* Function Show * Function Show

11
pcbnew/class_text_mod.h
View File

@ -56,6 +56,17 @@ public:
/* drawing functions */ /* drawing functions */
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, wxPoint offset, int draw_mode ); 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 * Function HitTest
* tests if the given wxPoint is within the bounds of this object. * tests if the given wxPoint is within the bounds of this object.

110
pcbnew/class_track.cpp
View File

@ -13,6 +13,7 @@
#endif #endif
#include "trigo.h" #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 * Function HitTest
* tests if the given wxPoint is within the bounds of this object. * tests if the given wxPoint is within the bounds of this object.

11
pcbnew/class_track.h
View File

@ -76,6 +76,17 @@ public:
int IsPointOnEnds( const wxPoint& point, int min_dist = 0 ); int IsPointOnEnds( const wxPoint& point, int min_dist = 0 );
bool IsNull( void ); // return TRUE if segment lenght = 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 * Function HitTest
* tests if the given wxPoint is within the bounds of this object. * tests if the given wxPoint is within the bounds of this object.

37
pcbnew/classpcb.cpp
View File

@ -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 * Function HitTest
* tests if the given wxPoint is within the bounds of this object. * tests if the given wxPoint is within the bounds of this object.

2
pcbnew/controle.cpp
View File

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

6
pcbnew/deltrack.cpp
View File

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

14
pcbnew/drc.cpp
View File

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

2
pcbnew/edit.cpp
View File

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

4
pcbnew/editedge.cpp
View File

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

6
pcbnew/editrack-part2.cpp
View File

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

6
pcbnew/editrack.cpp
View File

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

12
pcbnew/edtxtmod.cpp
View File

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

2
pcbnew/export_gencad.cpp
View File

@ -566,7 +566,7 @@ int nbitems, ii;
if ( old_netcode != track->m_NetCode ) if ( old_netcode != track->m_NetCode )
{ {
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; wxString netname;
if (equipot && (equipot->m_Netname != wxEmptyString) ) if (equipot && (equipot->m_Netname != wxEmptyString) )
netname = equipot->m_Netname; netname = equipot->m_Netname;

2
pcbnew/files.cpp
View File

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

84
pcbnew/locate.cpp
View File

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

2
pcbnew/modedit.cpp
View File

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

2
pcbnew/move_copy_track.cpp
View File

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

390
pcbnew/netlist.cpp
View File

@ -5,19 +5,19 @@
/* Fichier NETLIST.CPP */ /* Fichier NETLIST.CPP */
/* /*
Fonction de lecture de la netliste pour: * Fonction de lecture de la netliste pour:
- Chargement modules et nouvelles connexions * - Chargement modules et nouvelles connexions
- Test des modules (modules manquants ou en trop * - Test des modules (modules manquants ou en trop
- Recalcul du chevelu * - Recalcul du chevelu
*
Remarque importante: * Remarque importante:
Lors de la lecture de la netliste pour Chargement modules * Lors de la lecture de la netliste pour Chargement modules
et nouvelles connexions, l'identification des modules peut se faire selon * et nouvelles connexions, l'identification des modules peut se faire selon
2 criteres: * 2 criteres:
- la reference (U2, R5 ..): c'est le mode normal * - la reference (U2, R5 ..): c'est le mode normal
- le Time Stamp (Signature Temporelle), a utiliser apres reannotation * - le Time Stamp (Signature Temporelle), a utiliser apres reannotation
d'un schema, donc apres modification des references sans pourtant * d'un schema, donc apres modification des references sans pourtant
avoir reellement modifie le schema * avoir reellement modifie le schema
*/ */
#include "fctsys.h" #include "fctsys.h"
#include "gr_basic.h" #include "gr_basic.h"
@ -61,22 +61,22 @@ static int DisplayWarningCount ;
#include "dialog_netlist.cpp" #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(); 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 FullFileName;
@ -85,7 +85,8 @@ wxString msg;
if( NetNameBuffer.IsEmpty() ) /* Pas de nom specifie */ 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; FullFileName = NetNameBuffer;
@ -107,21 +108,22 @@ wxString msg;
/**************************************************************/ /**************************************************************/
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: /* 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 # EESchema Netlist Version 1.0 generee le 18/5/2005-12:30:22
( * (
( 40C08647 $noname R20 4,7K {Lib=R} * ( 40C08647 $noname R20 4,7K {Lib=R}
( 1 VCC ) * ( 1 VCC )
( 2 MODB_1 ) * ( 2 MODB_1 )
) * )
( 40C0863F $noname R18 4,7_k {Lib=R} * ( 40C0863F $noname R18 4,7_k {Lib=R}
( 1 VCC ) * ( 1 VCC )
( 2 MODA_1 ) * ( 2 MODA_1 )
) * )
} * }
#End #End
*/ */
{ {
@ -134,10 +136,13 @@ wxString msg;
ChangeExistantModule = m_ChangeExistantModuleCtrl->GetSelection() == 1 ? TRUE : FALSE; ChangeExistantModule = m_ChangeExistantModuleCtrl->GetSelection() == 1 ? TRUE : FALSE;
DisplayWarning = m_DisplayWarningCtrl->GetValue(); DisplayWarning = m_DisplayWarningCtrl->GetValue();
if ( DisplayWarning ) DisplayWarningCount = 8; if( DisplayWarning )
else DisplayWarningCount = 0; DisplayWarningCount = 8;
else
DisplayWarningCount = 0;
if( ! OpenNetlistFile(event) ) return; if( !OpenNetlistFile( event ) )
return;
msg = _( "Read Netlist " ) + NetNameBuffer; msg = _( "Read Netlist " ) + NetNameBuffer;
m_MessageWindow->AppendText( msg ); m_MessageWindow->AppendText( msg );
@ -147,7 +152,7 @@ wxString msg;
s_NbNewModules = 0; s_NbNewModules = 0;
/* Premiere lecture de la netliste: etablissement de la liste /* 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 ) )
{ {
@ -155,17 +160,21 @@ wxString msg;
if( Comment ) /* Commentaires en cours */ if( Comment ) /* Commentaires en cours */
{ {
if( (Text = strchr(Text,'}') ) == NULL )continue; if( ( Text = strchr( Text, '}' ) ) == NULL )
continue;
Comment = 0; Comment = 0;
} }
if( *Text == '{' ) /* Commentaires */ if( *Text == '{' ) /* Commentaires */
{ {
Comment = 1; Comment = 1;
if( (Text = strchr(Text,'}') ) == NULL ) continue; if( ( Text = strchr( Text, '}' ) ) == NULL )
continue;
} }
if ( *Text == '(' ) State++; if( *Text == '(' )
if ( *Text == ')' ) State--; State++;
if( *Text == ')' )
State--;
if( State == 2 ) if( State == 2 )
{ {
@ -183,6 +192,7 @@ wxString msg;
if( s_NbNewModules ) if( s_NbNewModules )
{ {
LoadListeModules( m_DC ); LoadListeModules( m_DC );
// Free module list: // Free module list:
MODULEtoLOAD* item, * next_item; MODULEtoLOAD* item, * next_item;
for( item = s_ModuleToLoad_List; item != NULL; item = next_item ) for( item = s_ModuleToLoad_List; item != NULL; item = next_item )
@ -190,6 +200,7 @@ wxString msg;
next_item = item->Next(); next_item = item->Next();
delete item; delete item;
} }
s_ModuleToLoad_List = NULL; s_ModuleToLoad_List = NULL;
} }
@ -201,17 +212,21 @@ wxString msg;
if( Comment ) /* Commentaires en cours */ if( Comment ) /* Commentaires en cours */
{ {
if( (Text = strchr(Text,'}') ) == NULL )continue; if( ( Text = strchr( Text, '}' ) ) == NULL )
continue;
Comment = 0; Comment = 0;
} }
if( *Text == '{' ) /* Commentaires */ if( *Text == '{' ) /* Commentaires */
{ {
Comment = 1; Comment = 1;
if( (Text = strchr(Text,'}') ) == NULL ) continue; if( ( Text = strchr( Text, '}' ) ) == NULL )
continue;
} }
if ( *Text == '(' ) State++; if( *Text == '(' )
if ( *Text == ')' ) State--; State++;
if( *Text == ')' )
State--;
if( State == 2 ) if( State == 2 )
{ {
@ -257,7 +272,7 @@ wxString msg;
} }
} }
Affiche_Infos_Status_Pcb(m_Parent); m_Parent->m_Pcb->Display_Infos( m_Parent );
} }
@ -265,21 +280,22 @@ wxString msg;
MODULE* WinEDA_NetlistFrame::ReadNetModule( char* Text, int* UseFichCmp, MODULE* WinEDA_NetlistFrame::ReadNetModule( char* Text, int* UseFichCmp,
int TstOnly ) int TstOnly )
/****************************************************************************/ /****************************************************************************/
/* charge la description d'une empreinte ,netliste type PCBNEW /* charge la description d'une empreinte ,netliste type PCBNEW
et met a jour le module correspondant * 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 charge
Si TstOnly != 0 si le module n'existe pas, il est ajoute a la liste des * Si TstOnly != 0 si le module n'existe pas, il est ajoute a la liste des
modules a charger * modules a charger
Text contient la premiere ligne de la description * Text contient la premiere ligne de la description
* UseFichCmp est un flag * UseFichCmp est un flag
si != 0, le fichier des composants .CMP sera utilise * si != 0, le fichier des composants .CMP sera utilise
est remis a 0 si le fichier n'existe pas * est remis a 0 si le fichier n'existe pas
*
Analyse les lignes type: * Analyse les lignes type:
( 40C08647 $noname R20 4,7K {Lib=R} * ( 40C08647 $noname R20 4,7K {Lib=R}
( 1 VCC ) * ( 1 VCC )
( 2 MODB_1 ) * ( 2 MODB_1 )
*/ */
{ {
MODULE* Module; MODULE* Module;
@ -297,16 +313,25 @@ bool Found;
strcpy( Line, Text ); strcpy( Line, Text );
TextValeur = wxT( "~" ); TextValeur = wxT( "~" );
if( (text = strtok(Line, " ()\t\n")) == NULL ) Error = 1; if( ( text = strtok( Line, " ()\t\n" ) ) == NULL )
else TextTimeStamp = CONV_FROM_UTF8(text); Error = 1;
if( ( text = strtok(NULL, " ()\t\n")) == NULL ) Error = 1; else
else TextNameLibMod = CONV_FROM_UTF8(text); TextTimeStamp = CONV_FROM_UTF8( text );
if( (text = strtok(NULL, " ()\t\n")) == NULL ) Error = 1; if( ( text = strtok( NULL, " ()\t\n" ) ) == NULL )
else TextCmpName = CONV_FROM_UTF8(text); Error = 1;
if( (text = strtok(NULL, " ()\t\n")) == NULL ) Error = -1; else
else TextValeur = CONV_FROM_UTF8(text); 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 ); if( Error > 0 )
return NULL;
TextTimeStamp.ToULong( &TimeStamp, 16 ); TextTimeStamp.ToULong( &TimeStamp, 16 );
@ -318,7 +343,8 @@ bool Found;
NextModule = (MODULE*) Module->Pnext; NextModule = (MODULE*) Module->Pnext;
if( m_Select_By_Timestamp->GetSelection() == 1 ) /* Reconnaissance par signature temporelle */ 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 */ else /* Reconnaissance par Reference */
{ {
@ -355,7 +381,8 @@ bool Found;
wxString msg; wxString msg;
msg.Printf( msg.Printf(
_( "Cmp %s: Mismatch! module is [%s] and netlist said [%s]\n" ), _( "Cmp %s: Mismatch! module is [%s] and netlist said [%s]\n" ),
TextCmpName.GetData(), Module->m_LibRef.GetData(), NameLibCmp.GetData()); TextCmpName.GetData(), Module->m_LibRef.GetData(),
NameLibCmp.GetData() );
m_MessageWindow->AppendText( msg ); m_MessageWindow->AppendText( msg );
if( DisplayWarningCount > 0 ) if( DisplayWarningCount > 0 )
{ {
@ -399,7 +426,7 @@ bool Found;
DisplayWarningCount--; 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 */ /* mise a jour des reperes ( nom et ref "Time Stamp") si module charge */
@ -407,17 +434,19 @@ bool Found;
Module->m_Value->m_Text = TextValeur; Module->m_Value->m_Text = TextValeur;
Module->m_TimeStamp = TimeStamp; 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 * Met a jour le netname de 1 pastille, Netliste ORCADPCB
entree : * entree :
Text = ligne de netliste lue ( (pad = net) ) * Text = ligne de netliste lue ( (pad = net) )
Module = adresse de la structure MODULE a qui appartient les pads * Module = adresse de la structure MODULE a qui appartient les pads
*/ */
{ {
D_PAD* pad; D_PAD* pad;
@ -427,13 +456,17 @@ bool trouve;
char Line[256]; char Line[256];
wxString Msg; 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( ( TextPinName = strtok( Line, " ()\t\n" ) ) == NULL )
if( (TextNetName = strtok(NULL, " ()\t\n")) == NULL ) Error = 1; Error = 1;
if(Error) return(0); if( ( TextNetName = strtok( NULL, " ()\t\n" ) ) == NULL )
Error = 1;
if( Error )
return 0;
/* recherche du pad */ /* recherche du pad */
pad = Module->m_Pads; trouve = FALSE; pad = Module->m_Pads; trouve = FALSE;
@ -444,7 +477,8 @@ wxString Msg;
trouve = TRUE; trouve = TRUE;
if( *TextNetName != '?' ) if( *TextNetName != '?' )
pad->m_Netname = CONV_FROM_UTF8( TextNetName ); pad->m_Netname = CONV_FROM_UTF8( TextNetName );
else pad->m_Netname.Empty(); else
pad->m_Netname.Empty();
} }
} }
@ -457,17 +491,18 @@ wxString Msg;
DisplayWarningCount--; DisplayWarningCount--;
} }
return(trouve); return trouve;
} }
/*****************************************************/ /*****************************************************/
MODULE* WinEDA_PcbFrame::ListAndSelectModuleName( void ) MODULE* WinEDA_PcbFrame::ListAndSelectModuleName( void )
/*****************************************************/ /*****************************************************/
/* liste les noms des modules du PCB /* liste les noms des modules du PCB
Retourne: * Retourne:
un pointeur sur le module selectionne * un pointeur sur le module selectionne
NULL si pas de selection * NULL si pas de selection
*/ */
{ {
int ii, jj, nb_empr; int ii, jj, nb_empr;
@ -477,12 +512,14 @@ const wxChar ** ListNames = NULL;
if( m_Pcb->m_Modules == NULL ) if( m_Pcb->m_Modules == NULL )
{ {
DisplayError(this, _("No Modules") ) ; return(0); DisplayError( this, _( "No Modules" ) ); return 0;
} }
/* Calcul du nombre des modules */ /* Calcul du nombre des modules */
nb_empr = 0; Module = (MODULE*) m_Pcb->m_Modules; nb_empr = 0; Module = (MODULE*) m_Pcb->m_Modules;
for( ;Module != NULL; Module = (MODULE*)Module->Pnext) nb_empr++; for( ; Module != NULL; Module = (MODULE*) Module->Pnext )
nb_empr++;
ListNames = (const wxChar**) MyZMalloc( (nb_empr + 1) * sizeof(wxChar *) ); ListNames = (const wxChar**) MyZMalloc( (nb_empr + 1) * sizeof(wxChar *) );
Module = (MODULE*) m_Pcb->m_Modules; 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++ )
@ -499,27 +536,29 @@ const wxChar ** ListNames = NULL;
{ {
Module = NULL; Module = NULL;
} }
else /* Recherche du module selectionne */ else /* Recherche du module selectionne */
{ {
Module = (MODULE*) m_Pcb->m_Modules; 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 ); free( ListNames );
return(Module); return Module;
} }
/***************************************************************/ /***************************************************************/
void WinEDA_NetlistFrame::ModulesControle( wxCommandEvent& event ) void WinEDA_NetlistFrame::ModulesControle( wxCommandEvent& event )
/***************************************************************/ /***************************************************************/
/* donne la liste : /* donne la liste :
1 - des empreintes doublées sur le PCB * 1 - des empreintes doublées sur le PCB
2 - des empreintes manquantes par rapport a la netliste * 2 - des empreintes manquantes par rapport a la netliste
3 - des empreintes supplémentaires par rapport a la netliste * 3 - des empreintes supplémentaires par rapport a la netliste
*/ */
#define MAX_LEN_TXT 32 #define MAX_LEN_TXT 32
{ {
@ -541,7 +580,8 @@ wxArrayString ModuleListFromNetlist;
/* Construction de la liste des references des modules de la netliste */ /* Construction de la liste des references des modules de la netliste */
NbModulesNetListe = BuildListeNetModules( event, ModuleListFromNetlist ); NbModulesNetListe = BuildListeNetModules( event, ModuleListFromNetlist );
if( NbModulesNetListe < 0 ) return; /* fichier non trouve */ if( NbModulesNetListe < 0 )
return; /* fichier non trouve */
if( NbModulesNetListe == 0 ) if( NbModulesNetListe == 0 )
{ {
@ -582,6 +622,7 @@ wxArrayString ModuleListFromNetlist;
break; break;
} }
} }
if( Module == NULL ) // Module missing, not found in board if( Module == NULL ) // Module missing, not found in board
{ {
List->Append( ModuleListFromNetlist[ii] ); List->Append( ModuleListFromNetlist[ii] );
@ -603,6 +644,7 @@ wxArrayString ModuleListFromNetlist;
break;/* Module trouve en netliste */ break;/* Module trouve en netliste */
} }
} }
if( ii == NbModulesNetListe ) /* Module not found in netlist */ if( ii == NbModulesNetListe ) /* Module not found in netlist */
{ {
List->Append( Module->m_Reference->m_Text ); List->Append( Module->m_Reference->m_Text );
@ -617,9 +659,10 @@ 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, * charge en BufName la liste des noms des modules de la netliste,
retourne le nombre des modules cités dans la netliste * retourne le nombre des modules cités dans la netliste
*/ */
{ {
int textlen; int textlen;
@ -627,7 +670,8 @@ int nb_modules_lus ;
int State, LineNum, Comment; int State, LineNum, Comment;
char Line[1024], * Text, * LibModName; char Line[1024], * Text, * LibModName;
if( ! OpenNetlistFile(event) ) return -1; if( !OpenNetlistFile( event ) )
return -1;
State = 0; LineNum = 0; Comment = 0; State = 0; LineNum = 0; Comment = 0;
nb_modules_lus = 0; nb_modules_lus = 0;
@ -638,25 +682,32 @@ char Line[1024], *Text, * LibModName;
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; Comment = 0;
} }
if( *Text == '{' ) /* Commentaires */ if( *Text == '{' ) /* Commentaires */
{ {
Comment = 1; Comment = 1;
if( (Text = strchr(Text,'}') ) == NULL ) continue; if( ( Text = strchr( Text, '}' ) ) == NULL )
continue;
} }
if ( *Text == '(' ) State++; if( *Text == '(' )
if ( *Text == ')' ) State--; State++;
if( *Text == ')' )
State--;
if( State == 2 ) if( State == 2 )
{ {
int Error = 0; int Error = 0;
if( strtok(Line, " ()\t\n") == NULL ) Error = 1; /* TimeStamp */ if( strtok( Line, " ()\t\n" ) == NULL )
if( ( LibModName = strtok(NULL, " ()\t\n")) == NULL ) Error = 1; /* nom Lib */ Error = 1; /* TimeStamp */
if( ( LibModName = strtok( NULL, " ()\t\n" ) ) == NULL )
Error = 1; /* nom Lib */
/* Lecture du nom (reference) du composant: */ /* 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++; nb_modules_lus++;
BufName.Add( CONV_FROM_UTF8( Text ) ); BufName.Add( CONV_FROM_UTF8( Text ) );
continue; continue;
@ -669,46 +720,46 @@ char Line[1024], *Text, * LibModName;
} }
fclose( source ); fclose( source );
return(nb_modules_lus); return nb_modules_lus;
} }
/*****************************************************************************************/ /*****************************************************************************************/
int WinEDA_NetlistFrame::ReadListeModules( const wxString* RefCmp, long TimeStamp, int WinEDA_NetlistFrame::ReadListeModules( const wxString* RefCmp, long TimeStamp,
wxString& NameModule ) wxString& NameModule )
/*****************************************************************************************/ /*****************************************************************************************/
/* /*
Lit le fichier .CMP donnant l'equivalence Modules / Composants * Lit le fichier .CMP donnant l'equivalence Modules / Composants
Retourne: * Retourne:
Si ce fichier existe: * Si ce fichier existe:
1 et le nom module dans NameModule * 1 et le nom module dans NameModule
-1 si module non trouve en fichier * -1 si module non trouve en fichier
sinon 0; * sinon 0;
*
parametres d'appel: * parametres d'appel:
RefCmp (NULL si selection par TimeStamp) * RefCmp (NULL si selection par TimeStamp)
TimeStamp (signature temporelle si elle existe, NULL sinon) * TimeStamp (signature temporelle si elle existe, NULL sinon)
pointeur sur le buffer recevant le nom du module * pointeur sur le buffer recevant le nom du module
*
Exemple de fichier: * Exemple de fichier:
*
Cmp-Mod V01 Genere par PcbNew le 29/10/2003-13:11:6 * Cmp-Mod V01 Genere par PcbNew le 29/10/2003-13:11:6
*
BeginCmp * BeginCmp
TimeStamp = 322D3011; * TimeStamp = 322D3011;
Reference = BUS1; * Reference = BUS1;
ValeurCmp = BUSPC; * ValeurCmp = BUSPC;
IdModule = BUS_PC; * IdModule = BUS_PC;
EndCmp * EndCmp
*
BeginCmp * BeginCmp
TimeStamp = 32307DE2; * TimeStamp = 32307DE2;
Reference = C1; * Reference = C1;
ValeurCmp = 47uF; * ValeurCmp = 47uF;
IdModule = CP6; * IdModule = CP6;
EndCmp * EndCmp
*
*/ */
{ {
wxString CmpFullFileName; wxString CmpFullFileName;
@ -718,7 +769,8 @@ int timestamp;
char* ptcar; char* ptcar;
FILE* FichCmp; FILE* FichCmp;
if( (RefCmp == NULL) && (TimeStamp == 0) ) return(0); if( (RefCmp == NULL) && (TimeStamp == 0) )
return 0;
CmpFullFileName = NetNameBuffer; CmpFullFileName = NetNameBuffer;
ChangeFileNameExt( CmpFullFileName, NetCmpExtBuffer ); ChangeFileNameExt( CmpFullFileName, NetCmpExtBuffer );
@ -730,12 +782,13 @@ FILE * FichCmp;
msg.Printf( _( "File <%s> not found, use Netlist for lib module selection" ), msg.Printf( _( "File <%s> not found, use Netlist for lib module selection" ),
CmpFullFileName.GetData() ); CmpFullFileName.GetData() );
DisplayError( this, msg, 20 ); DisplayError( this, msg, 20 );
return(0); 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 */ /* Ici une description de 1 composant commence */
refcurrcmp.Empty(); refcurrcmp.Empty();
@ -743,13 +796,15 @@ FILE * FichCmp;
timestamp = -1; 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 = ia + 11;
ptcar = strtok( ptcar, " =;\t\n" ); ptcar = strtok( ptcar, " =;\t\n" );
if( ptcar ) refcurrcmp = CONV_FROM_UTF8(ptcar); if( ptcar )
refcurrcmp = CONV_FROM_UTF8( ptcar );
continue; continue;
} }
@ -757,16 +812,20 @@ FILE * FichCmp;
{ {
ptcar = ia + 11; ptcar = ia + 11;
ptcar = strtok( ptcar, " =;\t\n" ); ptcar = strtok( ptcar, " =;\t\n" );
if( ptcar ) idmod = CONV_FROM_UTF8(ptcar); if( ptcar )
idmod = CONV_FROM_UTF8( ptcar );
continue; continue;
} }
if( strnicmp( ia, "TimeStamp =", 11 ) == 0 ) if( strnicmp( ia, "TimeStamp =", 11 ) == 0 )
{ {
ptcar = ia + 11; ptcar = ia + 11;
ptcar = strtok( ptcar, " =;\t\n" ); ptcar = strtok( ptcar, " =;\t\n" );
if( ptcar ) sscanf(ptcar, "%X", &timestamp); 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 */ /* Test du Composant lu en fichier: est-il le bon */
if( RefCmp ) if( RefCmp )
@ -775,7 +834,7 @@ FILE * FichCmp;
{ {
fclose( FichCmp ); fclose( FichCmp );
NameModule = idmod; NameModule = idmod;
return(1); return 1;
} }
} }
else if( TimeStamp != -1 ) else if( TimeStamp != -1 )
@ -784,20 +843,22 @@ FILE * FichCmp;
{ {
fclose( FichCmp ); fclose( FichCmp );
NameModule = idmod; NameModule = idmod;
return(1); return 1;
} }
} }
} }
fclose( FichCmp ); fclose( FichCmp );
return(-1); return -1;
} }
/***************************************************************/ /***************************************************************/
void WinEDA_NetlistFrame::Set_NetlisteName( wxCommandEvent& event ) void WinEDA_NetlistFrame::Set_NetlisteName( wxCommandEvent& event )
/***************************************************************/ /***************************************************************/
/* Selection un nouveau nom de netliste /* 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( "*" ) );
@ -814,16 +875,20 @@ wxString fullfilename, mask( wxT("*"));
TRUE TRUE
); );
if ( fullfilename.IsEmpty()) return; if( fullfilename.IsEmpty() )
return;
NetNameBuffer = fullfilename; 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 /* Fontion copiant en memoire de travail les caracteristiques
des nouveaux modules * des nouveaux modules
*/ */
{ {
MODULEtoLOAD* NewMod; MODULEtoLOAD* NewMod;
@ -838,10 +903,11 @@ 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 /* Routine de chargement des nouveaux modules en une seule lecture des
librairies * librairies
Si un module vient d'etre charge il est duplique, ce qui evite une lecture * Si un module vient d'etre charge il est duplique, ce qui evite une lecture
inutile de la librairie * inutile de la librairie
*/ */
{ {
MODULEtoLOAD* ref, * cmp; MODULEtoLOAD* ref, * cmp;
@ -849,7 +915,8 @@ int ii;
MODULE* Module = NULL; MODULE* Module = NULL;
wxPoint OldPos = m_Parent->m_CurrentScreen->m_Curseur; 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; ref = cmp = s_ModuleToLoad_List;
@ -858,7 +925,8 @@ wxPoint OldPos = m_Parent->m_CurrentScreen->m_Curseur;
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.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 else
{ {
@ -880,16 +948,18 @@ wxPoint OldPos = m_Parent->m_CurrentScreen->m_Curseur;
continue; continue;
} }
m_Parent->Place_Module( Module, DC ); m_Parent->Place_Module( Module, DC );
/* mise a jour des reperes ( nom et ref "Time Stamp") /* 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_Reference->m_Text = cmp->m_CmpName;
Module->m_TimeStamp = cmp->m_TimeStamp; Module->m_TimeStamp = cmp->m_TimeStamp;
} }
else else
{ /* module deja charge, on peut le dupliquer */ {
/* module deja charge, on peut le dupliquer */
MODULE* newmodule; MODULE* newmodule;
if ( Module == NULL ) continue; /* module non existant en libr */ if( Module == NULL )
continue; /* module non existant en libr */
newmodule = new MODULE( m_Parent->m_Pcb ); newmodule = new MODULE( m_Parent->m_Pcb );
newmodule->Copy( Module ); newmodule->Copy( Module );
newmodule->AddToChain( Module ); newmodule->AddToChain( Module );
@ -898,6 +968,7 @@ wxPoint OldPos = m_Parent->m_CurrentScreen->m_Curseur;
Module->m_TimeStamp = cmp->m_TimeStamp; Module->m_TimeStamp = cmp->m_TimeStamp;
} }
} }
m_Parent->m_CurrentScreen->m_Curseur = OldPos; m_Parent->m_CurrentScreen->m_Curseur = OldPos;
} }
@ -911,9 +982,11 @@ static int SortByLibName( MODULEtoLOAD ** ref, MODULEtoLOAD ** cmp )
return ii; return ii;
} }
/*************************************************/ /*************************************************/
void SortListModulesToLoadByLibname( int NbModules ) void SortListModulesToLoadByLibname( int NbModules )
/**************************************************/ /**************************************************/
/* Rearrage la liste des modules List par ordre alphabetique des noms lib des modules /* Rearrage la liste des modules List par ordre alphabetique des noms lib des modules
*/ */
{ {
@ -927,8 +1000,10 @@ int ii;
base_list[ii] = item; base_list[ii] = item;
item = item->Next(); item = item->Next();
} }
qsort( base_list, NbModules, sizeof(MODULEtoLOAD *), qsort( base_list, NbModules, sizeof(MODULEtoLOAD *),
( int( * ) ( const void*, const void* ) )SortByLibName ); ( int( * ) ( const void*, const void* ) )SortByLibName );
// Reconstruction du chainage: // Reconstruction du chainage:
s_ModuleToLoad_List = *base_list; s_ModuleToLoad_List = *base_list;
for( ii = 0; ii < NbModules - 1; ii++ ) for( ii = 0; ii < NbModules - 1; ii++ )
@ -936,6 +1011,7 @@ int ii;
item = base_list[ii]; item = base_list[ii];
item->Pnext = base_list[ii + 1]; item->Pnext = base_list[ii + 1];
} }
// Dernier item: Pnext = NULL: // Dernier item: Pnext = NULL:
item = base_list[ii]; item = base_list[ii];
item->Pnext = NULL; item->Pnext = NULL;

1
pcbnew/onrightclick.cpp
View File

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

11
pcbnew/pcbnew.h
View File

@ -36,17 +36,6 @@
#define ZOOM_CENTER -4 #define ZOOM_CENTER -4
#define ZOOM_REDRAW -5 #define ZOOM_REDRAW -5
/* Bits Flags utilis<69> en <20>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) */ /* Definition des cas ou l'on force l'affichage en SKETCH (membre .flags) */
#define FORCE_SKETCH (DRAG | EDIT ) #define FORCE_SKETCH (DRAG | EDIT )

4
pcbnew/pcbtexte.cpp
View File

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

25
pcbnew/protos.h
View File

@ -18,14 +18,6 @@ LISTE_PAD* CreateSortedPadListByXCoord(BOARD * pcb);
/**************/ /**************/
bool Read_Config(const wxString & project_name); 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 */ /* TRACEPCB.CPP */
/***************/ /***************/
@ -325,23 +317,6 @@ void Affiche_erreur(int nb_err) ;
/*****************************************************************/ /*****************************************************************/
/* AFFICHE.CPP: (Fonctions d'affichage de messages, parametres... */ /* 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); void Affiche_Infos_Equipot(int netcode, WinEDA_BasePcbFrame * frame);
/************/ /************/

7
pcbnew/ratsnest.cpp
View File

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

2
pcbnew/router.cpp
View File

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

2
pcbnew/solve.cpp
View File

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

37
pcbnew/undelete.cpp
View File

@ -17,6 +17,7 @@
/********************************************/ /********************************************/
void WinEDA_PcbFrame::UnDeleteItem( wxDC* DC ) void WinEDA_PcbFrame::UnDeleteItem( wxDC* DC )
/********************************************/ /********************************************/
/* Restitution d'un element (MODULE ou TRACK ) Efface /* Restitution d'un element (MODULE ou TRACK ) Efface
*/ */
{ {
@ -24,11 +25,13 @@ EDA_BaseStruct * PtStruct, *PtNext;
TRACK* pt_track; TRACK* pt_track;
int net_code; int net_code;
if( ! g_UnDeleteStackPtr ) return; if( !g_UnDeleteStackPtr )
return;
g_UnDeleteStackPtr--; g_UnDeleteStackPtr--;
PtStruct = g_UnDeleteStack[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 )
{ {
@ -48,18 +51,21 @@ int net_code;
g_UnDeleteStack[g_UnDeleteStackPtr] = NULL; g_UnDeleteStack[g_UnDeleteStackPtr] = NULL;
test_1_net_connexion( DC, net_code ); test_1_net_connexion( DC, net_code );
Affiche_Infos_Status_Pcb(this); m_Pcb->Display_Infos( this );
break; break;
case TYPEMODULE: case TYPEMODULE:
/* Erase general rastnest if needed */ /* 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, /* Reinsertion du module dans la liste chainee des modules,
en debut de chaine */ * en debut de chaine */
PtStruct->Pback = m_Pcb; PtStruct->Pback = m_Pcb;
PtNext = m_Pcb->m_Modules; PtNext = m_Pcb->m_Modules;
PtStruct->Pnext = PtNext; PtStruct->Pnext = PtNext;
if( PtNext) PtNext->Pback = PtStruct; if( PtNext )
PtNext->Pback = PtStruct;
m_Pcb->m_Modules = (MODULE*) PtStruct; m_Pcb->m_Modules = (MODULE*) PtStruct;
g_UnDeleteStack[g_UnDeleteStackPtr] = NULL; g_UnDeleteStack[g_UnDeleteStackPtr] = NULL;
@ -84,14 +90,15 @@ int net_code;
/**************************************************************/ /**************************************************************/
/* Sauvegarde d'un element aux fins de restitution par Undelete /* Sauvegarde d'un element aux fins de restitution par Undelete
Supporte actuellement : Module et segments de piste * Supporte actuellement : Module et segments de piste
*/ */
EDA_BaseStruct* WinEDA_PcbFrame::SaveItemEfface( EDA_BaseStruct* PtItem, int nbitems ) EDA_BaseStruct* WinEDA_PcbFrame::SaveItemEfface( EDA_BaseStruct* PtItem, int nbitems )
{ {
EDA_BaseStruct* NextS, * PtStruct = PtItem; EDA_BaseStruct* NextS, * PtStruct = PtItem;
int ii; 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 )
{ {
@ -101,6 +108,7 @@ int ii;
{ {
g_UnDeleteStack[ii] = g_UnDeleteStack[ii + 1]; g_UnDeleteStack[ii] = g_UnDeleteStack[ii + 1];
} }
g_UnDeleteStackPtr--;; g_UnDeleteStackPtr--;;
} }
@ -117,10 +125,12 @@ int ii;
NextS = PtStruct->Pnext; NextS = PtStruct->Pnext;
( (TRACK*) PtStruct )->UnLink(); ( (TRACK*) PtStruct )->UnLink();
PtStruct->SetState( DELETED, ON ); PtStruct->SetState( DELETED, ON );
if( nbitems <= 1 ) NextS = NULL; /* fin de chaine */ if( nbitems <= 1 )
NextS = NULL; /* fin de chaine */
PtStruct->Pnext = NextS; PtStruct->Pnext = NextS;
PtStruct->Pback = Back; Back = PtStruct; PtStruct->Pback = Back; Back = PtStruct;
if(NextS == NULL) break; if( NextS == NULL )
break;
} }
} }
break; break;
@ -135,10 +145,9 @@ int ii;
} }
break; break;
default: break; default:
break;
} }
return(g_UnDeleteStack[g_UnDeleteStackPtr-1]); return g_UnDeleteStack[g_UnDeleteStackPtr - 1];
} }

4
pcbnew/zones.cpp
View File

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