diff --git a/change_log.txt b/change_log.txt
index e467916a0b..a4735e32ce 100644
--- a/change_log.txt
+++ b/change_log.txt
@@ -5,6 +5,20 @@ Please add newer entries at the top, list the date and your name with
email address.
+2007-Aug-08 UPDATE Dick Hollenbeck <dick@softplc.com>
+================================================================================
++ pcbnew & common
+ * Renamed locate.cpp's distance() to DistanceTest() and moved it to trigo.cpp.
+ Pass more parameters to DistanceTest and removed globals that were used by
+ distance() in locate.cpp.
+ Moved and renamed DistanceTest function proto from protos.h to trigo.h.
+ * Implemented HitTest() for class_cotation, class_mire, and a few other classes
+ by factoring out existing code from locate.cpp. locate.cpp should operate
+ exactly the same as before.
+ * Detected that the suspected class_module hit-testing bug was not real,
+ i.e. no bug found.
+
+
2007-aug-08 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================
+ eeschema
diff --git a/common/trigo.cpp b/common/trigo.cpp
index a8f194596e..8ef468a978 100644
--- a/common/trigo.cpp
+++ b/common/trigo.cpp
@@ -9,6 +9,163 @@
#include "trigo.h"
+
+
+/*****************************/
+bool DistanceTest( int seuil, int dx, int dy, int spot_cX, int spot_cY )
+/*****************************/
+
+/*
+ * Calcul de la distance du curseur souris a un segment de droite :
+ * ( piste, edge, contour module ..
+ * retourne:
+ * false si distance > seuil
+ * true si distance <= seuil
+ * Variables utilisees ( doivent etre initialisees avant appel , et
+ * sont ramenees au repere centre sur l'origine du segment)
+ * dx, dy = coord de l'extremite segment.
+ * spot_cX,spot_cY = coord du curseur souris
+ * la recherche se fait selon 4 cas:
+ * segment horizontal
+ * segment vertical
+ * segment 45
+ * segment quelconque
+ */
+{
+ int cXrot, cYrot, /* coord du point (souris) dans le repere tourne */
+ segX, segY; /* coord extremite segment tj >= 0 */
+ int pointX, pointY; /* coord point a tester dans repere modifie dans lequel
+ * segX et segY sont >=0 */
+
+ segX = dx; segY = dy; pointX = spot_cX; pointY = spot_cY;
+
+ /*Recalcul coord pour que le segment soit dans 1er quadrant (coord >= 0)*/
+ if( segX < 0 ) /* mise en >0 par symetrie par rapport a l'axe Y */
+ {
+ segX = -segX; pointX = -pointX;
+ }
+ if( segY < 0 ) /* mise en > 0 par symetrie par rapport a l'axe X */
+ {
+ segY = -segY; pointY = -pointY;
+ }
+
+
+ if( segY == 0 ) /* piste Horizontale */
+ {
+ if( abs( pointY ) <= seuil )
+ {
+ if( (pointX >= 0) && (pointX <= segX) )
+ return 1;
+ /* Etude des extremites : cercle de rayon seuil */
+ if( (pointX < 0) && (pointX >= -seuil) )
+ {
+ if( ( (pointX * pointX) + (pointY * pointY) ) <= (seuil * seuil) )
+ return true;
+ }
+ if( (pointX > segX) && ( pointX <= (segX + seuil) ) )
+ {
+ if( ( ( (pointX - segX) * (pointX - segX) ) + (pointY * pointY) ) <=
+ (seuil * seuil) )
+ return true;
+ }
+ }
+ }
+ else if( segX == 0 ) /* piste verticale */
+ {
+ if( abs( pointX ) <= seuil )
+ {
+ if( (pointY >= 0 ) && (pointY <= segY) )
+ return true;
+ if( (pointY < 0) && (pointY >= -seuil) )
+ {
+ if( ( (pointY * pointY) + (pointX * pointX) ) <= (seuil * seuil) )
+ return true;
+ }
+ if( (pointY > segY) && ( pointY <= (segY + seuil) ) )
+ {
+ if( ( ( (pointY - segY) * (pointY - segY) ) + (pointX * pointX) ) <=
+ (seuil * seuil) )
+ return true;
+ }
+ }
+ }
+ else if( segX == segY ) /* piste a 45 degre */
+ {
+ /* on fait tourner les axes de 45 degre. la souris a alors les
+ * coord : x1 = x*cos45 + y*sin45
+ * y1 = y*cos45 - x*sin45
+ * et le segment de piste est alors horizontal.
+ * recalcul des coord de la souris ( sin45 = cos45 = .707 = 7/10
+ * remarque : sin ou cos45 = .707, et lors du recalcul des coord
+ * dx45 et dy45, lec coeff .707 est neglige, dx et dy sont en fait .707 fois
+ * trop grands. (c.a.d trop petits)
+ * spot_cX,Y doit etre * par .707 * .707 = 0.5 */
+
+ cXrot = (pointX + pointY) >> 1;
+ cYrot = (pointY - pointX) >> 1;
+
+ /* recalcul des coord de l'extremite du segment , qui sera vertical
+ * suite a l'orientation des axes sur l'ecran : dx45 = pointX (ou pointY)
+ * et est en fait 1,414 plus grand , et dy45 = 0 */
+
+ // seuil doit etre * .707 pour tenir compte du coeff de reduction sur dx,dy
+ seuil *= 7; seuil /= 10;
+ if( abs( cYrot ) <= seuil ) /* ok sur axe vertical) */
+ {
+ if( (cXrot >= 0) && (cXrot <= segX) )
+ return true;
+
+ /* Etude des extremites : cercle de rayon seuil */
+ if( (cXrot < 0) && (cXrot >= -seuil) )
+ {
+ if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) )
+ return true;
+ }
+ if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) )
+ {
+ if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) )
+ return true;
+ }
+ }
+ }
+ else /* orientation quelconque */
+ {
+ /* On fait un changement d'axe (rotation) de facon a ce que le segment
+ * de piste soit horizontal dans le nouveau repere */
+ int angle;
+
+ angle = (int) ( atan2( (float) segY, (float) segX ) * 1800 / M_PI);
+ cXrot = pointX; cYrot = pointY;
+
+ RotatePoint( &cXrot, &cYrot, angle ); /* Rotation du point a tester */
+ RotatePoint( &segX, &segY, angle ); /* Rotation du segment */
+
+ /* la piste est Horizontale , par suite des modifs de coordonnes
+ * et d'axe, donc segX = longueur du segment */
+
+ if( abs( cYrot ) <= seuil ) /* ok sur axe vertical) */
+ {
+ if( (cXrot >= 0) && (cXrot <= segX) )
+ return true;
+
+ /* Etude des extremites : cercle de rayon seuil */
+ if( (cXrot < 0) && (cXrot >= -seuil) )
+ {
+ if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) )
+ return true;
+ }
+ if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) )
+ {
+ if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) )
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+
+
/***********************************/
int ArcTangente( int dy, int dx )
/***********************************/
@@ -217,3 +374,5 @@ void RotatePoint( double* pX, double* pY, int angle )
*pY = fpy;
}
}
+
+
diff --git a/include/pcbstruct.h b/include/pcbstruct.h
index 65e89fc9fc..bfbfcb57e7 100644
--- a/include/pcbstruct.h
+++ b/include/pcbstruct.h
@@ -235,7 +235,6 @@ public:
#if defined(DEBUG)
-
/**
* Function GetClass
* returns the class name.
@@ -264,7 +263,7 @@ public:
* @param typeloc
* @return EDA_BaseStruct* - if a direct hit, else NULL.
*/
- EDA_BaseStruct* FindPadOrModule( const wxPoint& refPos, int layer, int typeloc );
+ EDA_BaseStruct* FindPadOrModule( const wxPoint& refPos, int layer );
#endif
};
@@ -322,6 +321,27 @@ public:
void UnLink( void );
void Copy( DRAWSEGMENT* source );
+
+ /**
+ * Function HitTest
+ * tests if the given wxPoint is within the bounds of this object.
+ * @param ref_pos A wxPoint to test
+ * @return bool - true if a hit, else false
+ */
+ bool HitTest( const wxPoint& ref_pos );
+
+#if defined(DEBUG)
+ /**
+ * Function GetClass
+ * returns the class name.
+ * @return wxString
+ */
+ wxString GetClass() const
+ {
+ return wxT("pgraphic");
+ }
+#endif
+
};
diff --git a/include/trigo.h b/include/trigo.h
index 73a650fb6b..c55ec32bce 100644
--- a/include/trigo.h
+++ b/include/trigo.h
@@ -7,7 +7,7 @@
#define TRIGO_H
-/* Prototype des fonctions de TRIGO.CC */
+/* Prototype des fonctions de trigo.cpp */
void RotatePoint(int *pX, int *pY, int angle);
void RotatePoint(int *pX, int *pY, int cx, int cy, int angle);
void RotatePoint(wxPoint *point, const wxPoint & centre, int angle);
@@ -19,6 +19,7 @@ int ArcTangente(int dy, int dx);
Analogue a atan2 ( mais plus rapide pour les caculs si
l'angle est souvent 0, -1800, ou +- 900 */
+bool DistanceTest( int seuil, int dx, int dy, int spot_cX, int spot_cY );
diff --git a/pcbnew/class_board.cpp b/pcbnew/class_board.cpp
index 96e5aca7e6..ddd45bd911 100644
--- a/pcbnew/class_board.cpp
+++ b/pcbnew/class_board.cpp
@@ -290,75 +290,64 @@ void BOARD::Show( int nestLevel, std::ostream& os )
// see pcbstruct.h
-EDA_BaseStruct* BOARD::FindPadOrModule( const wxPoint& refPos, int layer, int typeloc )
+EDA_BaseStruct* BOARD::FindPadOrModule( const wxPoint& refPos, int layer )
{
class PadOrModule : public INSPECTOR
{
public:
EDA_BaseStruct* found;
int layer;
- int typeloc;
- PadOrModule( int alayer, int atypeloc ) :
- found(0),
- layer(alayer),
- typeloc(atypeloc) {}
+ PadOrModule( int alayer ) :
+ found(0), // found is NULL
+ layer(alayer)
+ {
+ }
SEARCH_RESULT Inspect( EDA_BaseStruct* testItem, const void* testData )
{
- const wxPoint* refPos = (const wxPoint*) testData;
+ const wxPoint& refPos = *(const wxPoint*) testData;
- if( testItem->m_StructType == TYPEMODULE )
+ if( testItem->m_StructType == TYPEPAD )
{
- int mlayer = ((MODULE*)testItem)->m_Layer;
-
- if( typeloc & MATCH_LAYER )
- {
- if( layer != mlayer )
- return SEARCH_CONTINUE;
- }
-
- if( typeloc & VISIBLE_ONLY )
- {
- if( !IsModuleLayerVisible(mlayer) )
- return SEARCH_CONTINUE;
- }
-
- if( testItem->HitTest( *refPos ) )
+ if( testItem->HitTest( refPos ) )
{
found = testItem;
return SEARCH_QUIT;
}
}
- else if( testItem->m_StructType == TYPEPAD )
- {
- if( testItem->HitTest( *refPos ) )
- {
- found = testItem;
- return SEARCH_QUIT;
- }
- }
- else { int debug=1; /* this should not happen, because of scanTypes */ }
+ else if( testItem->m_StructType == TYPEMODULE )
+ {
+ int mlayer = ((MODULE*)testItem)->m_Layer;
+
+ // consider only visible modules
+ if( IsModuleLayerVisible( mlayer ) )
+ {
+ if( testItem->HitTest( refPos ) )
+ {
+ // save regardless of layer test, but only quit if
+ // layer matches, otherwise use this item if no future
+ // layer match.
+ found = testItem;
+
+ if( layer == mlayer )
+ return SEARCH_QUIT;
+ }
+ }
+ }
return SEARCH_CONTINUE;
}
-
};
- PadOrModule inspector1( layer, MATCH_LAYER );
- PadOrModule inspector2( layer, VISIBLE_ONLY );
+ PadOrModule inspector( layer );
+ // search only for PADs first, then MODULES, and preferably a layer match
static const KICAD_T scanTypes[] = { TYPEPAD, TYPEMODULE, EOT };
- // search the current layer first
- if( SEARCH_QUIT == IterateForward( m_Modules, &inspector1, &refPos, scanTypes ) )
- return inspector1.found;
-
- // if not found, set layer to don't care and search again
- if( SEARCH_QUIT == IterateForward( m_Modules, &inspector2, &refPos, scanTypes ) )
- return inspector2.found;
+ IterateForward( m_Modules, &inspector, &refPos, scanTypes );
- return NULL;
+ return inspector.found;
}
#endif
diff --git a/pcbnew/class_cotation.cpp b/pcbnew/class_cotation.cpp
index 0733dcb8be..6b8d4cf8cb 100644
--- a/pcbnew/class_cotation.cpp
+++ b/pcbnew/class_cotation.cpp
@@ -7,348 +7,476 @@
#include "common.h"
#include "pcbnew.h"
+#include "trigo.h"
-
-
-COTATION::COTATION(EDA_BaseStruct * StructFather):
- EDA_BaseStruct( StructFather, TYPECOTATION)
+COTATION::COTATION( EDA_BaseStruct* StructFather ) :
+ EDA_BaseStruct( StructFather, TYPECOTATION )
{
- m_Layer = DRAW_LAYER;
- m_Width = 50;
- m_Value = 0;
- m_Shape = 0;
- m_Unit = INCHES;
- m_Text = new TEXTE_PCB(this);
+ m_Layer = DRAW_LAYER;
+ m_Width = 50;
+ m_Value = 0;
+ m_Shape = 0;
+ m_Unit = INCHES;
+ m_Text = new TEXTE_PCB( this );
}
+
/* Effacement memoire de la structure */
-COTATION::~COTATION(void)
+COTATION::~COTATION( void )
{
- delete m_Text;
+ delete m_Text;
}
+
/* supprime du chainage la structure Struct
- les structures arrieres et avant sont chainees directement
+ * les structures arrieres et avant sont chainees directement
*/
void COTATION::UnLink( void )
{
- /* Modification du chainage arriere */
- if( Pback )
- {
- if( Pback->m_StructType != TYPEPCB)
- {
- Pback->Pnext = Pnext;
- }
+ /* Modification du chainage arriere */
+ if( Pback )
+ {
+ if( Pback->m_StructType != TYPEPCB )
+ {
+ Pback->Pnext = Pnext;
+ }
+ else /* Le chainage arriere pointe sur la structure "Pere" */
+ {
+ ( (BOARD*) Pback )->m_Drawings = Pnext;
+ }
+ }
- else /* Le chainage arriere pointe sur la structure "Pere" */
- {
- ((BOARD*)Pback)->m_Drawings = Pnext;
- }
- }
+ /* Modification du chainage avant */
+ if( Pnext )
+ Pnext->Pback = Pback;
- /* Modification du chainage avant */
- if( Pnext) Pnext->Pback = Pback;
-
- Pnext = Pback = NULL;
+ Pnext = Pback = NULL;
}
+
/* Changement du texte de la cotation */
-void COTATION:: SetText(const wxString & NewText)
+void COTATION:: SetText( const wxString& NewText )
{
- m_Text->m_Text = NewText;
+ m_Text->m_Text = NewText;
}
/*************************************/
-void COTATION::Copy(COTATION * source)
+void COTATION::Copy( COTATION* source )
/*************************************/
{
- m_Value = source->m_Value;
- m_Layer = source->m_Layer;
- m_Width = source->m_Width;
- m_Pos = source->m_Pos;
- m_Shape = source->m_Shape;
- m_Unit = source->m_Unit;
- m_TimeStamp = GetTimeStamp();
- m_Text->Copy(source->m_Text);
+ m_Value = source->m_Value;
+ m_Layer = source->m_Layer;
+ m_Width = source->m_Width;
+ m_Pos = source->m_Pos;
+ m_Shape = source->m_Shape;
+ m_Unit = source->m_Unit;
+ m_TimeStamp = GetTimeStamp();
+ m_Text->Copy( source->m_Text );
- Barre_ox = source->Barre_ox; Barre_oy = source->Barre_oy;
- Barre_fx = source->Barre_fx; Barre_fy = source->Barre_fy;
- TraitG_ox = source->TraitG_ox; TraitG_oy = source->TraitG_oy;
- TraitG_fx = source->TraitG_fx; TraitG_fy = source->TraitG_fy;
- TraitD_ox = source->TraitD_ox; TraitD_oy = source->TraitD_oy;
- TraitD_fx = source->TraitD_fx; TraitD_fy = source->TraitD_fy;
- FlecheD1_ox = source->FlecheD1_ox; FlecheD1_oy = source->FlecheD1_oy;
- FlecheD1_fx = source->FlecheD1_fx; FlecheD1_fy = source->FlecheD1_fy;
- FlecheD2_ox = source->FlecheD2_ox; FlecheD2_oy = source->FlecheD2_oy;
- FlecheD2_fx = source->FlecheD2_fx; FlecheD2_fy = source->FlecheD2_fy;
- FlecheG1_ox = source->FlecheG1_ox; FlecheG1_oy = source->FlecheG1_oy;
- FlecheG1_fx = source->FlecheG1_fx; FlecheG1_fy = source->FlecheG1_fy;
- FlecheG2_ox = source->FlecheG2_ox; FlecheG2_oy = source->FlecheG2_oy;
- FlecheG2_fx = source->FlecheG2_fx; FlecheG2_fy = source->FlecheG2_fy;
+ Barre_ox = source->Barre_ox; Barre_oy = source->Barre_oy;
+ Barre_fx = source->Barre_fx; Barre_fy = source->Barre_fy;
+ TraitG_ox = source->TraitG_ox; TraitG_oy = source->TraitG_oy;
+ TraitG_fx = source->TraitG_fx; TraitG_fy = source->TraitG_fy;
+ TraitD_ox = source->TraitD_ox; TraitD_oy = source->TraitD_oy;
+ TraitD_fx = source->TraitD_fx; TraitD_fy = source->TraitD_fy;
+ FlecheD1_ox = source->FlecheD1_ox; FlecheD1_oy = source->FlecheD1_oy;
+ FlecheD1_fx = source->FlecheD1_fx; FlecheD1_fy = source->FlecheD1_fy;
+ FlecheD2_ox = source->FlecheD2_ox; FlecheD2_oy = source->FlecheD2_oy;
+ FlecheD2_fx = source->FlecheD2_fx; FlecheD2_fy = source->FlecheD2_fy;
+ FlecheG1_ox = source->FlecheG1_ox; FlecheG1_oy = source->FlecheG1_oy;
+ FlecheG1_fx = source->FlecheG1_fx; FlecheG1_fy = source->FlecheG1_fy;
+ FlecheG2_ox = source->FlecheG2_ox; FlecheG2_oy = source->FlecheG2_oy;
+ FlecheG2_fx = source->FlecheG2_fx; FlecheG2_fy = source->FlecheG2_fy;
}
/***************************************************************/
-bool COTATION::ReadCotationDescr(FILE * File, int * LineNum)
+bool COTATION::ReadCotationDescr( FILE* File, int* LineNum )
/***************************************************************/
{
-char Line[2048], Text[2048];
+ char Line[2048], Text[2048];
- while( GetLine(File, Line, LineNum ) != NULL )
- {
- if(strnicmp(Line,"$EndCOTATION",4) == 0) return TRUE;
+ while( GetLine( File, Line, LineNum ) != NULL )
+ {
+ if( strnicmp( Line, "$EndCOTATION", 4 ) == 0 )
+ return TRUE;
- if(Line[0] == 'V')
- {
- sscanf( Line+2," %d",&m_Value);
- continue;
- }
+ if( Line[0] == 'V' )
+ {
+ sscanf( Line + 2, " %d", &m_Value );
+ continue;
+ }
- if(Line[0] == 'G')
- {
- sscanf( Line+2," %d %d %lX",&m_Shape, &m_Layer, &m_TimeStamp);
+ if( Line[0] == 'G' )
+ {
+ sscanf( Line + 2, " %d %d %lX", &m_Shape, &m_Layer, &m_TimeStamp );
- /* Mise a jour des param .layer des sous structures */
- if ( m_Layer < FIRST_NO_COPPER_LAYER )
- m_Layer = FIRST_NO_COPPER_LAYER;
- if ( m_Layer > LAST_NO_COPPER_LAYER )
- m_Layer = LAST_NO_COPPER_LAYER;
+ /* Mise a jour des param .layer des sous structures */
+ if( m_Layer < FIRST_NO_COPPER_LAYER )
+ m_Layer = FIRST_NO_COPPER_LAYER;
+ if( m_Layer > LAST_NO_COPPER_LAYER )
+ m_Layer = LAST_NO_COPPER_LAYER;
- m_Text->m_Layer = m_Layer;
- continue;
- }
+ m_Text->m_Layer = m_Layer;
+ continue;
+ }
- if(Line[0] == 'T')
- {
- ReadDelimitedText(Text, Line+2, sizeof(Text) );
- m_Text->m_Text = CONV_FROM_UTF8(Text);
- continue;
- }
+ if( Line[0] == 'T' )
+ {
+ ReadDelimitedText( Text, Line + 2, sizeof(Text) );
+ m_Text->m_Text = CONV_FROM_UTF8( Text );
+ continue;
+ }
- if(Line[0] == 'P')
- {
- sscanf( Line+2," %d %d %d %d %d %d %d",
- &m_Text->m_Pos.x, &m_Text->m_Pos.y,
- &m_Text->m_Size.x, &m_Text->m_Size.y,
- &m_Text->m_Width,&m_Text->m_Orient,
- &m_Text->m_Miroir);
+ if( Line[0] == 'P' )
+ {
+ sscanf( Line + 2, " %d %d %d %d %d %d %d",
+ &m_Text->m_Pos.x, &m_Text->m_Pos.y,
+ &m_Text->m_Size.x, &m_Text->m_Size.y,
+ &m_Text->m_Width, &m_Text->m_Orient,
+ &m_Text->m_Miroir );
- m_Pos = m_Text->m_Pos;
- continue;
- }
+ m_Pos = m_Text->m_Pos;
+ continue;
+ }
- if( Line[0] == 'S')
- {
- switch( Line[1] )
- {
- int Dummy;
- case 'b' :
- sscanf( Line+2," %d %d %d %d %d %d",
- &Dummy,
- &Barre_ox, &Barre_oy,
- &Barre_fx, &Barre_fy,
- &m_Width );
- break;
+ if( Line[0] == 'S' )
+ {
+ switch( Line[1] )
+ {
+ int Dummy;
- case 'd':
- sscanf( Line+2," %d %d %d %d %d %d",
- &Dummy,
- &TraitD_ox, &TraitD_oy,
- &TraitD_fx, &TraitD_fy,
- &Dummy );
- break;
+ case 'b':
+ sscanf( Line + 2, " %d %d %d %d %d %d",
+ &Dummy,
+ &Barre_ox, &Barre_oy,
+ &Barre_fx, &Barre_fy,
+ &m_Width );
+ break;
- case 'g':
- sscanf( Line+2," %d %d %d %d %d %d",
- &Dummy,
- &TraitG_ox, &TraitG_oy,
- &TraitG_fx, &TraitG_fy,
- &Dummy );
- break;
+ case 'd':
+ sscanf( Line + 2, " %d %d %d %d %d %d",
+ &Dummy,
+ &TraitD_ox, &TraitD_oy,
+ &TraitD_fx, &TraitD_fy,
+ &Dummy );
+ break;
- case '1':
- sscanf( Line+2," %d %d %d %d %d %d",
- &Dummy,
- &FlecheD1_ox, &FlecheD1_oy,
- &FlecheD1_fx, &FlecheD1_fy,
- &Dummy );
- break;
+ case 'g':
+ sscanf( Line + 2, " %d %d %d %d %d %d",
+ &Dummy,
+ &TraitG_ox, &TraitG_oy,
+ &TraitG_fx, &TraitG_fy,
+ &Dummy );
+ break;
- case '2':
- sscanf( Line+2," %d %d %d %d %d %d",
- &Dummy,
- &FlecheD2_ox, &FlecheD2_oy,
- &FlecheD2_fx, &FlecheD2_fy,
- &Dummy );
- break;
+ case '1':
+ sscanf( Line + 2, " %d %d %d %d %d %d",
+ &Dummy,
+ &FlecheD1_ox, &FlecheD1_oy,
+ &FlecheD1_fx, &FlecheD1_fy,
+ &Dummy );
+ break;
- case '3':
- sscanf( Line+2," %d %d %d %d %d %d\n",
- &Dummy,
- &FlecheG1_ox, &FlecheG1_oy,
- &FlecheG1_fx, &FlecheG1_fy,
- &Dummy);
- break;
+ case '2':
+ sscanf( Line + 2, " %d %d %d %d %d %d",
+ &Dummy,
+ &FlecheD2_ox, &FlecheD2_oy,
+ &FlecheD2_fx, &FlecheD2_fy,
+ &Dummy );
+ break;
- case '4':
- sscanf( Line+2," %d %d %d %d %d %d",
- &Dummy,
- &FlecheG2_ox, &FlecheG2_oy,
- &FlecheG2_fx, &FlecheG2_fy,
- &Dummy );
- break;
- }
+ case '3':
+ sscanf( Line + 2, " %d %d %d %d %d %d\n",
+ &Dummy,
+ &FlecheG1_ox, &FlecheG1_oy,
+ &FlecheG1_fx, &FlecheG1_fy,
+ &Dummy );
+ break;
- continue;
- }
- }
- return FALSE;
+ case '4':
+ sscanf( Line + 2, " %d %d %d %d %d %d",
+ &Dummy,
+ &FlecheG2_ox, &FlecheG2_oy,
+ &FlecheG2_fx, &FlecheG2_fy,
+ &Dummy );
+ break;
+ }
+
+ continue;
+ }
+ }
+
+ return FALSE;
}
/**************************************************/
-bool COTATION::WriteCotationDescr(FILE * File)
+bool COTATION::WriteCotationDescr( FILE* File )
/**************************************************/
{
- if( GetState(DELETED) ) return FALSE;
+ if( GetState( DELETED ) )
+ return FALSE;
- fprintf( File, "$COTATION\n");
+ fprintf( File, "$COTATION\n" );
- fprintf( File,"Ge %d %d %lX\n",m_Shape,
- m_Layer, m_TimeStamp);
+ fprintf( File, "Ge %d %d %lX\n", m_Shape,
+ m_Layer, m_TimeStamp );
- fprintf( File,"Va %d\n",m_Value);
+ fprintf( File, "Va %d\n", m_Value );
- if( ! m_Text->m_Text.IsEmpty() )
- fprintf( File,"Te \"%s\"\n",CONV_TO_UTF8(m_Text->m_Text));
- else fprintf( File,"Te \"?\"\n");
+ if( !m_Text->m_Text.IsEmpty() )
+ fprintf( File, "Te \"%s\"\n", CONV_TO_UTF8( m_Text->m_Text ) );
+ else
+ fprintf( File, "Te \"?\"\n" );
- fprintf( File,"Po %d %d %d %d %d %d %d\n",
- m_Text->m_Pos.x, m_Text->m_Pos.y,
- m_Text->m_Size.x, m_Text->m_Size.y,
- m_Text->m_Width,m_Text->m_Orient,
- m_Text->m_Miroir);
+ fprintf( File, "Po %d %d %d %d %d %d %d\n",
+ m_Text->m_Pos.x, m_Text->m_Pos.y,
+ m_Text->m_Size.x, m_Text->m_Size.y,
+ m_Text->m_Width, m_Text->m_Orient,
+ m_Text->m_Miroir );
- fprintf( File,"Sb %d %d %d %d %d %d\n",S_SEGMENT,
- Barre_ox, Barre_oy,
- Barre_fx, Barre_fy, m_Width );
+ fprintf( File, "Sb %d %d %d %d %d %d\n", S_SEGMENT,
+ Barre_ox, Barre_oy,
+ Barre_fx, Barre_fy, m_Width );
- fprintf( File,"Sd %d %d %d %d %d %d\n",S_SEGMENT,
- TraitD_ox, TraitD_oy,
- TraitD_fx, TraitD_fy, m_Width );
+ fprintf( File, "Sd %d %d %d %d %d %d\n", S_SEGMENT,
+ TraitD_ox, TraitD_oy,
+ TraitD_fx, TraitD_fy, m_Width );
- fprintf( File,"Sg %d %d %d %d %d %d\n",S_SEGMENT,
- TraitG_ox, TraitG_oy,
- TraitG_fx, TraitG_fy, m_Width );
+ fprintf( File, "Sg %d %d %d %d %d %d\n", S_SEGMENT,
+ TraitG_ox, TraitG_oy,
+ TraitG_fx, TraitG_fy, m_Width );
- fprintf( File,"S1 %d %d %d %d %d %d\n",S_SEGMENT,
- FlecheD1_ox, FlecheD1_oy,
- FlecheD1_fx, FlecheD1_fy, m_Width );
+ fprintf( File, "S1 %d %d %d %d %d %d\n", S_SEGMENT,
+ FlecheD1_ox, FlecheD1_oy,
+ FlecheD1_fx, FlecheD1_fy, m_Width );
- fprintf( File,"S2 %d %d %d %d %d %d\n",S_SEGMENT,
- FlecheD2_ox, FlecheD2_oy,
- FlecheD2_fx, FlecheD2_fy, m_Width );
+ fprintf( File, "S2 %d %d %d %d %d %d\n", S_SEGMENT,
+ FlecheD2_ox, FlecheD2_oy,
+ FlecheD2_fx, FlecheD2_fy, m_Width );
- fprintf( File,"S3 %d %d %d %d %d %d\n",S_SEGMENT,
- FlecheG1_ox, FlecheG1_oy,
- FlecheG1_fx, FlecheG1_fy, m_Width );
+ fprintf( File, "S3 %d %d %d %d %d %d\n", S_SEGMENT,
+ FlecheG1_ox, FlecheG1_oy,
+ FlecheG1_fx, FlecheG1_fy, m_Width );
- fprintf( File,"S4 %d %d %d %d %d %d\n",S_SEGMENT,
- FlecheG2_ox, FlecheG2_oy,
- FlecheG2_fx, FlecheG2_fy, m_Width );
+ fprintf( File, "S4 %d %d %d %d %d %d\n", S_SEGMENT,
+ FlecheG2_ox, FlecheG2_oy,
+ FlecheG2_fx, FlecheG2_fy, m_Width );
- fprintf( File, "$EndCOTATION\n");
+ fprintf( File, "$EndCOTATION\n" );
- return(1);
+ return 1;
}
-
-
/************************************************************************/
-void COTATION::Draw(WinEDA_DrawPanel * panel , wxDC * DC,
- const wxPoint & offset, int mode_color)
+void COTATION::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
+ const wxPoint& offset, int mode_color )
/************************************************************************/
+
/* impression de 1 cotation : serie de n segments + 1 texte
-*/
+ */
{
-int ox, oy, typeaff, width, gcolor;
-int zoom = panel->GetScreen()->GetZoom();
+ int ox, oy, typeaff, width, gcolor;
+ int zoom = panel->GetScreen()->GetZoom();
- ox = offset.x;
- oy = offset.y;
+ ox = offset.x;
+ oy = offset.y;
- m_Text->Draw(panel, DC, offset, mode_color );
+ m_Text->Draw( panel, DC, offset, mode_color );
- gcolor = g_DesignSettings.m_LayerColor[m_Layer];
- if( (gcolor & ITEM_NOT_SHOW) != 0 ) return ;
+ gcolor = g_DesignSettings.m_LayerColor[m_Layer];
+ if( (gcolor & ITEM_NOT_SHOW) != 0 )
+ return;
- GRSetDrawMode(DC, mode_color);
- typeaff = DisplayOpt.DisplayDrawItems;
- width = m_Width;
- if( width/zoom < 2 ) typeaff = FILAIRE;
+ GRSetDrawMode( DC, mode_color );
+ typeaff = DisplayOpt.DisplayDrawItems;
+
+ width = m_Width;
+ if( width / zoom < 2 )
+ typeaff = FILAIRE;
- switch( typeaff )
- {
- case FILAIRE:
- width = 0;
- case FILLED:
- GRLine(&panel->m_ClipBox, DC,
- Barre_ox - ox, Barre_oy - oy,
- Barre_fx - ox, Barre_fy- oy, width, gcolor);
- GRLine(&panel->m_ClipBox, DC,
- TraitG_ox - ox, TraitG_oy - oy,
- TraitG_fx - ox, TraitG_fy- oy, width, gcolor);
- GRLine(&panel->m_ClipBox, DC,
- TraitD_ox - ox, TraitD_oy - oy,
- TraitD_fx - ox, TraitD_fy- oy, width, gcolor);
- GRLine(&panel->m_ClipBox, DC,
- FlecheD1_ox - ox, FlecheD1_oy - oy,
- FlecheD1_fx - ox, FlecheD1_fy- oy, width, gcolor);
- GRLine(&panel->m_ClipBox, DC,
- FlecheD2_ox - ox, FlecheD2_oy - oy,
- FlecheD2_fx - ox, FlecheD2_fy- oy, width, gcolor);
- GRLine(&panel->m_ClipBox, DC,
- FlecheG1_ox - ox, FlecheG1_oy - oy,
- FlecheG1_fx - ox, FlecheG1_fy- oy, width, gcolor);
- GRLine(&panel->m_ClipBox, DC,
- FlecheG2_ox - ox, FlecheG2_oy - oy,
- FlecheG2_fx - ox, FlecheG2_fy- oy, width, gcolor);
- break;
+ switch( typeaff )
+ {
+ case FILAIRE:
+ width = 0;
- case SKETCH:
- GRCSegm(&panel->m_ClipBox, DC,
- Barre_ox - ox, Barre_oy - oy,
- Barre_fx - ox, Barre_fy- oy,
- width, gcolor);
- GRCSegm(&panel->m_ClipBox, DC,
- TraitG_ox - ox, TraitG_oy - oy,
- TraitG_fx - ox, TraitG_fy- oy,
- width, gcolor);
- GRCSegm(&panel->m_ClipBox, DC,
- TraitD_ox - ox, TraitD_oy - oy,
- TraitD_fx - ox, TraitD_fy- oy,
- width, gcolor);
- GRCSegm(&panel->m_ClipBox, DC,
- FlecheD1_ox - ox, FlecheD1_oy - oy,
- FlecheD1_fx - ox, FlecheD1_fy- oy,
- width, gcolor);
- GRCSegm(&panel->m_ClipBox, DC,
- FlecheD2_ox - ox, FlecheD2_oy - oy,
- FlecheD2_fx - ox, FlecheD2_fy- oy,
- width, gcolor);
- GRCSegm(&panel->m_ClipBox, DC,
- FlecheG1_ox - ox, FlecheG1_oy - oy,
- FlecheG1_fx - ox, FlecheG1_fy- oy,
- width, gcolor);
- GRCSegm(&panel->m_ClipBox, DC,
- FlecheG2_ox - ox, FlecheG2_oy - oy,
- FlecheG2_fx - ox, FlecheG2_fy - oy,
- width, gcolor);
- break;
- }
+ case FILLED:
+ GRLine( &panel->m_ClipBox, DC,
+ Barre_ox - ox, Barre_oy - oy,
+ Barre_fx - ox, Barre_fy - oy, width, gcolor );
+ GRLine( &panel->m_ClipBox, DC,
+ TraitG_ox - ox, TraitG_oy - oy,
+ TraitG_fx - ox, TraitG_fy - oy, width, gcolor );
+ GRLine( &panel->m_ClipBox, DC,
+ TraitD_ox - ox, TraitD_oy - oy,
+ TraitD_fx - ox, TraitD_fy - oy, width, gcolor );
+ GRLine( &panel->m_ClipBox, DC,
+ FlecheD1_ox - ox, FlecheD1_oy - oy,
+ FlecheD1_fx - ox, FlecheD1_fy - oy, width, gcolor );
+ GRLine( &panel->m_ClipBox, DC,
+ FlecheD2_ox - ox, FlecheD2_oy - oy,
+ FlecheD2_fx - ox, FlecheD2_fy - oy, width, gcolor );
+ GRLine( &panel->m_ClipBox, DC,
+ FlecheG1_ox - ox, FlecheG1_oy - oy,
+ FlecheG1_fx - ox, FlecheG1_fy - oy, width, gcolor );
+ GRLine( &panel->m_ClipBox, DC,
+ FlecheG2_ox - ox, FlecheG2_oy - oy,
+ FlecheG2_fx - ox, FlecheG2_fy - oy, width, gcolor );
+ break;
+
+ case SKETCH:
+ GRCSegm( &panel->m_ClipBox, DC,
+ Barre_ox - ox, Barre_oy - oy,
+ Barre_fx - ox, Barre_fy - oy,
+ width, gcolor );
+ GRCSegm( &panel->m_ClipBox, DC,
+ TraitG_ox - ox, TraitG_oy - oy,
+ TraitG_fx - ox, TraitG_fy - oy,
+ width, gcolor );
+ GRCSegm( &panel->m_ClipBox, DC,
+ TraitD_ox - ox, TraitD_oy - oy,
+ TraitD_fx - ox, TraitD_fy - oy,
+ width, gcolor );
+ GRCSegm( &panel->m_ClipBox, DC,
+ FlecheD1_ox - ox, FlecheD1_oy - oy,
+ FlecheD1_fx - ox, FlecheD1_fy - oy,
+ width, gcolor );
+ GRCSegm( &panel->m_ClipBox, DC,
+ FlecheD2_ox - ox, FlecheD2_oy - oy,
+ FlecheD2_fx - ox, FlecheD2_fy - oy,
+ width, gcolor );
+ GRCSegm( &panel->m_ClipBox, DC,
+ FlecheG1_ox - ox, FlecheG1_oy - oy,
+ FlecheG1_fx - ox, FlecheG1_fy - oy,
+ width, gcolor );
+ GRCSegm( &panel->m_ClipBox, DC,
+ FlecheG2_ox - ox, FlecheG2_oy - oy,
+ FlecheG2_fx - ox, FlecheG2_fy - oy,
+ width, gcolor );
+ break;
+ }
}
+/**
+ * Function HitTest
+ * tests if the given wxPoint is within the bounds of this object.
+ * @param ref_pos A wxPoint to test
+ * @return bool - true if a hit, else false
+ */
+bool COTATION::HitTest( const wxPoint& ref_pos )
+{
+ int ux0, uy0;
+ int dx, dy, spot_cX, spot_cY;
+
+ if( m_Text )
+ {
+ // because HitTest() is present in both base classes of TEXTE_PCB
+ // use a clarifying cast to tell compiler which HitTest()
+ // to call.
+ if( static_cast<EDA_TextStruct*>(m_Text)->HitTest( ref_pos ) )
+ return true;
+ }
+
+ /* Localisation des SEGMENTS ?) */
+ ux0 = Barre_ox;
+ uy0 = Barre_oy;
+
+ /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
+ dx = Barre_fx - ux0;
+ dy = Barre_fy - uy0;
+
+ spot_cX = ref_pos.x - ux0;
+ spot_cY = ref_pos.y - uy0;
+
+ if( DistanceTest( m_Width / 2, dx, dy, spot_cX, spot_cY ) )
+ return true;
+
+ ux0 = TraitG_ox;
+ uy0 = TraitG_oy;
+
+ /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
+ dx = TraitG_fx - ux0;
+ dy = TraitG_fy - uy0;
+
+ spot_cX = ref_pos.x - ux0;
+ spot_cY = ref_pos.y - uy0;
+
+ /* detection : */
+ if( DistanceTest( m_Width / 2, dx, dy, spot_cX, spot_cY ) )
+ return true;
+
+ ux0 = TraitD_ox;
+ uy0 = TraitD_oy;
+
+ /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
+ dx = TraitD_fx - ux0;
+ dy = TraitD_fy - uy0;
+
+ spot_cX = ref_pos.x - ux0;
+ spot_cY = ref_pos.y - uy0;
+
+ /* detection : */
+ if( DistanceTest( m_Width / 2, dx, dy, spot_cX, spot_cY ) )
+ return true;
+
+ ux0 = FlecheD1_ox;
+ uy0 = FlecheD1_oy;
+
+ /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
+ dx = FlecheD1_fx - ux0;
+ dy = FlecheD1_fy - uy0;
+
+ spot_cX = ref_pos.x - ux0;
+ spot_cY = ref_pos.y - uy0;
+
+ /* detection : */
+ if( DistanceTest( m_Width / 2, dx, dy, spot_cX, spot_cY ) )
+ return true;
+
+ ux0 = FlecheD2_ox;
+ uy0 = FlecheD2_oy;
+
+ /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
+ dx = FlecheD2_fx - ux0;
+ dy = FlecheD2_fy - uy0;
+
+ spot_cX = ref_pos.x - ux0;
+ spot_cY = ref_pos.y - uy0;
+
+ if( DistanceTest( m_Width / 2, dx, dy, spot_cX, spot_cY ) )
+ return true;
+
+ ux0 = FlecheG1_ox;
+ uy0 = FlecheG1_oy;
+
+ /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
+ dx = FlecheG1_fx - ux0;
+ dy = FlecheG1_fy - uy0;
+
+ spot_cX = ref_pos.x - ux0;
+ spot_cY = ref_pos.y - uy0;
+
+ if( DistanceTest( m_Width / 2, dx, dy, spot_cX, spot_cY ) )
+ return true;
+
+ ux0 = FlecheG2_ox;
+ uy0 = FlecheG2_oy;
+
+ /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
+ dx = FlecheG2_fx - ux0;
+ dy = FlecheG2_fy - uy0;
+
+ spot_cX = ref_pos.x - ux0;
+ spot_cY = ref_pos.y - uy0;
+
+ if( DistanceTest( m_Width / 2, dx, dy, spot_cX, spot_cY ) )
+ return true;
+
+ return false;
+}
+
diff --git a/pcbnew/class_cotation.h b/pcbnew/class_cotation.h
index 9148bcd9c9..7da75cd619 100644
--- a/pcbnew/class_cotation.h
+++ b/pcbnew/class_cotation.h
@@ -6,42 +6,62 @@
#include "base_struct.h"
-class COTATION: public EDA_BaseStruct
+class COTATION : public EDA_BaseStruct
{
- public:
- int m_Layer; // 0.. 32 ( NON bit a bit)
- int m_Width;
- wxPoint m_Pos;
- int m_Shape;
- int m_Unit; /* 0 = inches, 1 = mm */
- int m_Value; /* valeur en unites PCB de la cote */
+public:
+ int m_Layer; // 0.. 32 ( NON bit a bit)
+ int m_Width;
+ wxPoint m_Pos;
+ int m_Shape;
+ int m_Unit; /* 0 = inches, 1 = mm */
+ int m_Value; /* valeur en unites PCB de la cote */
- TEXTE_PCB * m_Text; /* pour affichage du texte */
- int Barre_ox, Barre_oy, Barre_fx, Barre_fy;
- int TraitG_ox, TraitG_oy, TraitG_fx, TraitG_fy;
- int TraitD_ox, TraitD_oy, TraitD_fx, TraitD_fy;
- int FlecheD1_ox, FlecheD1_oy, FlecheD1_fx, FlecheD1_fy;
- int FlecheD2_ox, FlecheD2_oy, FlecheD2_fx, FlecheD2_fy;
- int FlecheG1_ox, FlecheG1_oy, FlecheG1_fx, FlecheG1_fy;
- int FlecheG2_ox, FlecheG2_oy, FlecheG2_fx, FlecheG2_fy;
+ TEXTE_PCB* m_Text; /* pour affichage du texte */
+ int Barre_ox, Barre_oy, Barre_fx, Barre_fy;
+ int TraitG_ox, TraitG_oy, TraitG_fx, TraitG_fy;
+ int TraitD_ox, TraitD_oy, TraitD_fx, TraitD_fy;
+ int FlecheD1_ox, FlecheD1_oy, FlecheD1_fx, FlecheD1_fy;
+ int FlecheD2_ox, FlecheD2_oy, FlecheD2_fx, FlecheD2_fy;
+ int FlecheG1_ox, FlecheG1_oy, FlecheG1_fx, FlecheG1_fy;
+ int FlecheG2_ox, FlecheG2_oy, FlecheG2_fx, FlecheG2_fy;
- public:
- COTATION(EDA_BaseStruct * StructFather);
- ~COTATION(void);
+public:
+ COTATION( EDA_BaseStruct* StructFather );
+ ~COTATION( void );
- bool ReadCotationDescr(FILE * File, int * LineNum);
- bool WriteCotationDescr(FILE * File);
+ bool ReadCotationDescr( FILE* File, int* LineNum );
+ bool WriteCotationDescr( FILE* File );
- /* supprime du chainage la structure Struct */
- void UnLink( void );
+ /* supprime du chainage la structure Struct */
+ void UnLink( void );
- /* Modification du texte de la cotation */
- void SetText(const wxString & NewText);
+ /* Modification du texte de la cotation */
+ void SetText( const wxString& NewText );
- void Copy(COTATION * source);
+ void Copy( COTATION* source );
- 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 HitTest
+ * tests if the given wxPoint is within the bounds of this object.
+ * @param ref_pos A wxPoint to test
+ * @return bool - true if a hit, else false
+ */
+ bool HitTest( const wxPoint& ref_pos );
+
+
+#if defined(DEBUG)
+ /**
+ * Function GetClass
+ * returns the class name.
+ * @return wxString
+ */
+ wxString GetClass() const
+ {
+ return wxT( "DIMENSION" );
+ }
+#endif
};
-#endif // #define COTATION_H
+#endif // #define COTATION_H
diff --git a/pcbnew/class_edge_mod.cpp b/pcbnew/class_edge_mod.cpp
index cf45cb25f3..0ab755eb33 100644
--- a/pcbnew/class_edge_mod.cpp
+++ b/pcbnew/class_edge_mod.cpp
@@ -438,6 +438,73 @@ int EDGE_MODULE::ReadDescr( char* Line, FILE* File,
}
+/**
+ * Function HitTest
+ * tests if the given wxPoint is within the bounds of this object.
+ * @param refPos A wxPoint to test
+ * @return bool - true if a hit, else false
+ */
+bool EDGE_MODULE::HitTest( const wxPoint& ref_pos )
+{
+ int uxf, uyf;
+ int rayon, dist;
+ int dx, dy, spot_cX, spot_cY;
+ int ux0, uy0;
+
+ ux0 = m_Start.x;
+ uy0 = m_Start.y;
+
+ uxf = m_End.x;
+ uyf = m_End.y;
+
+ switch( m_Shape )
+ {
+ case S_SEGMENT:
+ /* recalcul des coordonnees avec ux0,uy0 = origine des coord. */
+ spot_cX = ref_pos.x - ux0;
+ spot_cY = ref_pos.y - uy0;
+
+ dx = uxf - ux0;
+ dy = uyf - uy0;
+ if( DistanceTest( m_Width/2, dx, dy, spot_cX, spot_cY ) )
+ return true;
+ break;
+
+ case S_CIRCLE:
+ rayon = (int) hypot( (double) (uxf - ux0), (double) (uyf - uy0) );
+ dist = (int) hypot( (double) (ref_pos.x - ux0), (double) (ref_pos.y - uy0) );
+ if( abs( rayon - dist ) <= m_Width )
+ return true;
+ break;
+
+ case S_ARC:
+ rayon = (int) hypot( (double) (uxf - ux0), (double) (uyf - uy0) );
+ dist = (int) hypot( (double) (ref_pos.x - ux0), (double) (ref_pos.y - uy0) );
+
+ if( abs( rayon - dist ) > m_Width )
+ break;
+
+ /* pour un arc, controle complementaire */
+ int mouseAngle = (int) ArcTangente( ref_pos.y - uy0, ref_pos.x - ux0 );
+ int stAngle = (int) ArcTangente( uyf - uy0, uxf - ux0 );
+ int endAngle = stAngle + m_Angle;
+
+ if( endAngle > 3600 )
+ {
+ stAngle -= 3600;
+ endAngle -= 3600;
+ }
+
+ if( (mouseAngle >= stAngle) && (mouseAngle <= endAngle) )
+ return true;
+
+ break;
+ }
+
+ return false; // an unknown m_Shape also returns false
+}
+
+
#if defined(DEBUG)
/**
* Function Show
diff --git a/pcbnew/class_edge_mod.h b/pcbnew/class_edge_mod.h
index 843be47d65..0b9b9b9f74 100644
--- a/pcbnew/class_edge_mod.h
+++ b/pcbnew/class_edge_mod.h
@@ -41,6 +41,14 @@ public:
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode );
void Draw3D( Pcb3D_GLCanvas* glcanvas );
+
+ /**
+ * Function HitTest
+ * tests if the given wxPoint is within the bounds of this object.
+ * @param refPos A wxPoint to test
+ * @return bool - true if a hit, else false
+ */
+ bool HitTest( const wxPoint& refPos );
#if defined(DEBUG)
/**
@@ -50,7 +58,7 @@ public:
*/
virtual wxString GetClass() const
{
- return wxT( "GRAPHIC" );
+ return wxT( "MGRAPHIC" );
// return wxT( "EDGE" ); ?
}
diff --git a/pcbnew/class_mire.cpp b/pcbnew/class_mire.cpp
index 7d2325262b..e4b81732fa 100644
--- a/pcbnew/class_mire.cpp
+++ b/pcbnew/class_mire.cpp
@@ -9,15 +9,15 @@
#include "pcbnew.h"
-
-MIREPCB::MIREPCB(EDA_BaseStruct * StructFather):
- EDA_BaseStruct( StructFather, TYPEMIRE)
+MIREPCB::MIREPCB( EDA_BaseStruct* StructFather ) :
+ EDA_BaseStruct( StructFather, TYPEMIRE )
{
- m_Shape = 0;
- m_Size = 5000;
+ m_Shape = 0;
+ m_Size = 5000;
}
-MIREPCB::~MIREPCB(void)
+
+MIREPCB::~MIREPCB( void )
{
}
@@ -25,161 +25,186 @@ MIREPCB::~MIREPCB(void)
/***************************/
void MIREPCB::UnLink( void )
/***************************/
+
/* supprime du chainage la structure Struct
- les structures arrieres et avant sont chainees directement
+ * les structures arrieres et avant sont chainees directement
*/
{
- /* Modification du chainage arriere */
- if( Pback )
- {
- if( Pback->m_StructType != TYPEPCB)
- {
- Pback->Pnext = Pnext;
- }
+ /* Modification du chainage arriere */
+ if( Pback )
+ {
+ if( Pback->m_StructType != TYPEPCB )
+ {
+ Pback->Pnext = Pnext;
+ }
+ else /* Le chainage arriere pointe sur la structure "Pere" */
+ {
+ ( (BOARD*) Pback )->m_Drawings = Pnext;
+ }
+ }
- else /* Le chainage arriere pointe sur la structure "Pere" */
- {
- ((BOARD*)Pback)->m_Drawings = Pnext;
- }
- }
+ /* Modification du chainage avant */
+ if( Pnext )
+ Pnext->Pback = Pback;
- /* Modification du chainage avant */
- if( Pnext) Pnext->Pback = Pback;
-
- Pnext = Pback = NULL;
+ Pnext = Pback = NULL;
}
/**********************************/
-void MIREPCB::Copy(MIREPCB * source)
+void MIREPCB::Copy( MIREPCB* source )
/**********************************/
{
- m_Layer = source->m_Layer;
- m_Width = source->m_Width;
- m_Pos = source->m_Pos;
- m_Shape = source->m_Shape;
- m_Size = source->m_Size;
- m_TimeStamp = GetTimeStamp();
+ m_Layer = source->m_Layer;
+ m_Width = source->m_Width;
+ m_Pos = source->m_Pos;
+ m_Shape = source->m_Shape;
+ m_Size = source->m_Size;
+ m_TimeStamp = GetTimeStamp();
}
/**************************************************************/
-bool MIREPCB::ReadMirePcbDescr(FILE * File, int * LineNum)
+bool MIREPCB::ReadMirePcbDescr( FILE* File, int* LineNum )
/**************************************************************/
+
/* Lecture de la description de 1 segment type Drawing PCB
-*/
+ */
{
-char Line[256];
+ char Line[256];
- while( GetLine(File, Line, LineNum ) != NULL )
- {
- if(strnicmp(Line,"$End",4 ) == 0 ) return TRUE; /* fin de liste */
- if(Line[0] == 'P')
- {
- sscanf( Line+2," %X %d %d %d %d %d %lX",
- &m_Shape, &m_Layer,
- &m_Pos.x, &m_Pos.y,
- &m_Size, &m_Width, &m_TimeStamp );
- if ( m_Layer < FIRST_NO_COPPER_LAYER )
- m_Layer = FIRST_NO_COPPER_LAYER;
- if ( m_Layer > LAST_NO_COPPER_LAYER )
- m_Layer = LAST_NO_COPPER_LAYER;
+ while( GetLine( File, Line, LineNum ) != NULL )
+ {
+ if( strnicmp( Line, "$End", 4 ) == 0 )
+ return TRUE; /* fin de liste */
+ if( Line[0] == 'P' )
+ {
+ sscanf( Line + 2, " %X %d %d %d %d %d %lX",
+ &m_Shape, &m_Layer,
+ &m_Pos.x, &m_Pos.y,
+ &m_Size, &m_Width, &m_TimeStamp );
+ if( m_Layer < FIRST_NO_COPPER_LAYER )
+ m_Layer = FIRST_NO_COPPER_LAYER;
+ if( m_Layer > LAST_NO_COPPER_LAYER )
+ m_Layer = LAST_NO_COPPER_LAYER;
+ }
+ }
- }
- }
- return FALSE;
+ return FALSE;
}
/************************************************/
-bool MIREPCB::WriteMirePcbDescr(FILE * File)
+bool MIREPCB::WriteMirePcbDescr( FILE* File )
/************************************************/
{
- if( GetState(DELETED) ) return FALSE;
+ if( GetState( DELETED ) )
+ return FALSE;
- fprintf( File, "$MIREPCB\n");
- fprintf( File,"Po %X %d %d %d %d %d %8.8lX\n",
- m_Shape, m_Layer,
- m_Pos.x, m_Pos.y,
- m_Size, m_Width, m_TimeStamp );
- fprintf( File, "$EndMIREPCB\n");
- return TRUE;
+ fprintf( File, "$MIREPCB\n" );
+ fprintf( File, "Po %X %d %d %d %d %d %8.8lX\n",
+ m_Shape, m_Layer,
+ m_Pos.x, m_Pos.y,
+ m_Size, m_Width, m_TimeStamp );
+ fprintf( File, "$EndMIREPCB\n" );
+ return TRUE;
}
/**********************************************************/
-void MIREPCB::Draw(WinEDA_DrawPanel * panel, wxDC * DC,
- const wxPoint & offset, int mode_color)
+void MIREPCB::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
+ const wxPoint& offset, int mode_color )
/**********************************************************/
+
/* Affichage de 1 mire : 2 segments + 1 cercle
- le cercle a pour rayon le demi rayon de la mire
- les 2 traits ont pour longueur le diametre de la mire
-*/
+ * le cercle a pour rayon le demi rayon de la mire
+ * les 2 traits ont pour longueur le diametre de la mire
+ */
{
-int rayon, ox, oy, gcolor, width;
-int dx1,dx2, dy1, dy2;
-int typeaff;
-int zoom;
+ int rayon, ox, oy, gcolor, width;
+ int dx1, dx2, dy1, dy2;
+ int typeaff;
+ int zoom;
- ox = m_Pos.x + offset.x;
- oy = m_Pos.y + offset.y;
+ ox = m_Pos.x + offset.x;
+ oy = m_Pos.y + offset.y;
- gcolor = g_DesignSettings.m_LayerColor[m_Layer];
- if ( (gcolor & ITEM_NOT_SHOW) != 0 ) return;
+ gcolor = g_DesignSettings.m_LayerColor[m_Layer];
+ if( (gcolor & ITEM_NOT_SHOW) != 0 )
+ return;
- zoom = panel->GetZoom();
+ zoom = panel->GetZoom();
- GRSetDrawMode(DC, mode_color);
- typeaff = DisplayOpt.DisplayDrawItems;
- width = m_Width;
- if( width/zoom < 2 ) typeaff = FILAIRE;
+ GRSetDrawMode( DC, mode_color );
+ typeaff = DisplayOpt.DisplayDrawItems;
+ width = m_Width;
+ if( width / zoom < 2 )
+ typeaff = FILAIRE;
- /* Trace du cercle: */
- rayon = m_Size / 4;
- switch( typeaff )
- {
- case FILAIRE:
- width = 0;
- case FILLED:
- GRCircle(&panel->m_ClipBox, DC, ox, oy, rayon, width, gcolor);
- break;
+ /* Trace du cercle: */
+ rayon = m_Size / 4;
- case SKETCH:
- GRCircle(&panel->m_ClipBox, DC, ox, oy, rayon + (width/2), gcolor) ;
- GRCircle(&panel->m_ClipBox, DC, ox, oy, rayon - (width/2), gcolor) ;
- break;
- }
+ switch( typeaff )
+ {
+ case FILAIRE:
+ width = 0;
+
+ case FILLED:
+ GRCircle( &panel->m_ClipBox, DC, ox, oy, rayon, width, gcolor );
+ break;
+
+ case SKETCH:
+ GRCircle( &panel->m_ClipBox, DC, ox, oy, rayon + (width / 2), gcolor );
+ GRCircle( &panel->m_ClipBox, DC, ox, oy, rayon - (width / 2), gcolor );
+ break;
+ }
- /* Trace des 2 traits */
- rayon = m_Size/2;
- dx1 = rayon, dy1 = 0;
- dx2 = 0, dy2 = rayon;
+ /* Trace des 2 traits */
+ rayon = m_Size / 2;
+ dx1 = rayon, dy1 = 0;
+ dx2 = 0, dy2 = rayon;
- if( m_Shape) /* Forme X */
- {
- dx1 = dy1 = (rayon * 7)/5;
- dx2 = dx1; dy2 = -dy1;
- }
+ if( m_Shape ) /* Forme X */
+ {
+ dx1 = dy1 = (rayon * 7) / 5;
+ dx2 = dx1; dy2 = -dy1;
+ }
- switch( typeaff )
- {
- case FILAIRE:
- case FILLED:
- GRLine(&panel->m_ClipBox, DC, ox - dx1, oy - dy1,
- ox + dx1, oy + dy1, width, gcolor);
- GRLine(&panel->m_ClipBox, DC, ox - dx2, oy - dy2,
- ox + dx2, oy + dy2, width, gcolor);
- break;
+ switch( typeaff )
+ {
+ case FILAIRE:
+ case FILLED:
+ GRLine( &panel->m_ClipBox, DC, ox - dx1, oy - dy1,
+ ox + dx1, oy + dy1, width, gcolor );
+ GRLine( &panel->m_ClipBox, DC, ox - dx2, oy - dy2,
+ ox + dx2, oy + dy2, width, gcolor );
+ break;
- case SKETCH:
- GRCSegm(&panel->m_ClipBox, DC, ox - dx1, oy - dy1,
- ox + dx1, oy + dy1,
- width, gcolor);
- GRCSegm(&panel->m_ClipBox, DC, ox - dx2, oy - dy2,
- ox + dx2, oy + dy2,
- width, gcolor);
- break;
- }
+ case SKETCH:
+ GRCSegm( &panel->m_ClipBox, DC, ox - dx1, oy - dy1,
+ ox + dx1, oy + dy1,
+ width, gcolor );
+ GRCSegm( &panel->m_ClipBox, DC, ox - dx2, oy - dy2,
+ ox + dx2, oy + dy2,
+ width, gcolor );
+ break;
+ }
+}
+
+
+/**
+ * Function HitTest
+ * tests if the given wxPoint is within the bounds of this object.
+ * @param refPos A wxPoint to test
+ * @return bool - true if a hit, else false
+ */
+bool MIREPCB::HitTest( const wxPoint& refPos )
+{
+ int dX = refPos.x - m_Pos.x;
+ int dY = refPos.y - m_Pos.y;
+ int rayon = m_Size / 2;
+
+ return abs(dX)<=rayon && abs(dY)<=rayon;
}
diff --git a/pcbnew/class_mire.h b/pcbnew/class_mire.h
index 4c3c551c4c..ee1f5279be 100644
--- a/pcbnew/class_mire.h
+++ b/pcbnew/class_mire.h
@@ -7,31 +7,38 @@
#include "base_struct.h"
-class MIREPCB: public EDA_BaseStruct
- {
- public:
- int m_Layer; // 0.. 32 ( NON bit a bit)
- int m_Width;
- wxPoint m_Pos;
- int m_Shape; // bit 0 : 0 = forme +, 1 = forme X
- int m_Size;
+class MIREPCB : public EDA_BaseStruct
+{
+public:
+ int m_Layer; // 0.. 32 ( NON bit a bit)
+ int m_Width;
+ wxPoint m_Pos;
+ int m_Shape; // bit 0 : 0 = forme +, 1 = forme X
+ int m_Size;
- public:
- MIREPCB(EDA_BaseStruct * StructFather);
- ~MIREPCB(void);
+public:
+ MIREPCB( EDA_BaseStruct* StructFather );
+ ~MIREPCB( void );
- bool WriteMirePcbDescr(FILE * File);
- bool ReadMirePcbDescr(FILE * File, int * LineNum);
+ bool WriteMirePcbDescr( FILE* File );
+ bool ReadMirePcbDescr( FILE* File, int* LineNum );
- /* supprime du chainage la structure Struct */
- void UnLink( void );
+ /* supprime du chainage la structure Struct */
+ void UnLink( void );
- void Copy(MIREPCB * source);
+ void Copy( MIREPCB* source );
- 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 HitTest
+ * tests if the given wxPoint is within the bounds of this object.
+ * @param refPos A wxPoint to test
+ * @return bool - true if a hit, else false
+ */
+ bool HitTest( const wxPoint& refPos );
};
-
-#endif // #define MIRE_H
+#endif // #define MIRE_H
diff --git a/pcbnew/class_module.h b/pcbnew/class_module.h
index 783bc59eb8..ffff2d6dc5 100644
--- a/pcbnew/class_module.h
+++ b/pcbnew/class_module.h
@@ -144,7 +144,6 @@ public:
#if defined(DEBUG)
-
/**
* Function GetClass
* returns the class name.
diff --git a/pcbnew/class_track.cpp b/pcbnew/class_track.cpp
index 6a228e8f88..93bbc3db70 100644
--- a/pcbnew/class_track.cpp
+++ b/pcbnew/class_track.cpp
@@ -12,551 +12,665 @@
#include "cvpcb.h"
#endif
+#include "trigo.h"
- /**************************************/
- /* Classes pour Pistes, Vias et Zones */
- /**************************************/
+/**************************************/
+/* Classes pour Pistes, Vias et Zones */
+/**************************************/
/* Constructeur des classes type pistes, vias et zones */
-TRACK::TRACK(EDA_BaseStruct * StructFather, DrawStructureType idtype):
- EDA_BaseLineStruct( StructFather, idtype)
+TRACK::TRACK( EDA_BaseStruct* StructFather, DrawStructureType idtype ) :
+ EDA_BaseLineStruct( StructFather, idtype )
{
- m_Shape = S_SEGMENT;
- start = end = NULL;
- m_NetCode = 0;
- m_Sous_Netcode = 0;
- m_Drill = -1;
- m_Param = 0;
+ m_Shape = S_SEGMENT;
+ start = end = NULL;
+ m_NetCode = 0;
+ m_Sous_Netcode = 0;
+ m_Drill = -1;
+ m_Param = 0;
}
-SEGZONE::SEGZONE(EDA_BaseStruct * StructFather):
- TRACK( StructFather, TYPEZONE)
+
+SEGZONE::SEGZONE( EDA_BaseStruct* StructFather ) :
+ TRACK( StructFather, TYPEZONE )
{
}
-SEGVIA::SEGVIA(EDA_BaseStruct * StructFather):
- TRACK( StructFather, TYPEVIA)
+
+SEGVIA::SEGVIA( EDA_BaseStruct* StructFather ) :
+ TRACK( StructFather, TYPEVIA )
{
}
+
+
/* Copy constructor */
-TRACK::TRACK(const TRACK & Source):
- EDA_BaseLineStruct( Source.m_Parent, (DrawStructureType)Source.m_StructType)
+TRACK::TRACK( const TRACK& Source ) :
+ EDA_BaseLineStruct( Source.m_Parent, (DrawStructureType)Source.m_StructType )
{
- m_StructType = Source.m_StructType;
- m_Shape = Source.m_Shape;
- m_NetCode = Source.m_NetCode;
- m_Flags = Source.m_Flags;
- m_TimeStamp = Source.m_TimeStamp;
- SetStatus(Source.ReturnStatus() );
- m_Layer = Source.m_Layer;
- m_Start = Source.m_Start;
- m_End = Source.m_End;
- m_Width = Source.m_Width;
- m_Drill = Source.m_Drill;
- m_Sous_Netcode = Source.m_Sous_Netcode;
- m_Param = Source.m_Param;
-
+ m_StructType = Source.m_StructType;
+ m_Shape = Source.m_Shape;
+ m_NetCode = Source.m_NetCode;
+ m_Flags = Source.m_Flags;
+ m_TimeStamp = Source.m_TimeStamp;
+ SetStatus( Source.ReturnStatus() );
+ m_Layer = Source.m_Layer;
+ m_Start = Source.m_Start;
+ m_End = Source.m_End;
+ m_Width = Source.m_Width;
+ m_Drill = Source.m_Drill;
+ m_Sous_Netcode = Source.m_Sous_Netcode;
+ m_Param = Source.m_Param;
}
/***********************/
-bool TRACK::IsNull(void)
+bool TRACK::IsNull( void )
/***********************/
-// return TRUE if segment lenght = 0
+
+// return TRUE if segment length = 0
{
- if ( ( m_StructType != TYPEVIA ) && ( m_Start == m_End ) )
- return TRUE;
- else return FALSE;
+ if( ( m_StructType != TYPEVIA ) && ( m_Start == m_End ) )
+ return TRUE;
+ else
+ return FALSE;
}
+
/*************************************************************/
-int TRACK::IsPointOnEnds(const wxPoint & point, int min_dist)
+int TRACK::IsPointOnEnds( const wxPoint& point, int min_dist )
/*************************************************************/
+
/* Return:
- STARTPOINT if point if near (dist = min_dist) star point
- ENDPOINT if point if near (dist = min_dist) end point
- STARTPOINT|ENDPOINT if point if near (dist = min_dist) both ends
- 0 if no
- if min_dist < 0: min_dist = track_width/2
-*/
+ * STARTPOINT if point if near (dist = min_dist) star point
+ * ENDPOINT if point if near (dist = min_dist) end point
+ * STARTPOINT|ENDPOINT if point if near (dist = min_dist) both ends
+ * 0 if no
+ * if min_dist < 0: min_dist = track_width/2
+ */
{
-int dx, dy;
-int result = 0;
+ int dx, dy;
+ int result = 0;
- if ( min_dist < 0 ) min_dist = m_Width / 2;
+ if( min_dist < 0 )
+ min_dist = m_Width / 2;
- dx = m_Start.x - point.x;
- dy = m_Start.y - point.y;
- if ( min_dist == 0 )
- {
- if( (dx == 0) && (dy == 0 ) ) result |= STARTPOINT;
- }
- else
- {
- double dist = ((double)dx *dx) + ((double)dy*dy);
- dist = sqrt(dist);
- if ( min_dist >= (int) dist ) result |= STARTPOINT;
- }
+ dx = m_Start.x - point.x;
+ dy = m_Start.y - point.y;
+ if( min_dist == 0 )
+ {
+ if( (dx == 0) && (dy == 0 ) )
+ result |= STARTPOINT;
+ }
+ else
+ {
+ double dist = ( (double) dx * dx ) + ( (double) dy * dy );
+ dist = sqrt( dist );
+ if( min_dist >= (int) dist )
+ result |= STARTPOINT;
+ }
- dx = m_End.x - point.x;
- dy = m_End.y - point.y;
- if ( min_dist == 0 )
- {
- if( (dx == 0) && (dy == 0 ) ) result |= ENDPOINT;
- }
- else
- {
- double dist = ((double)dx *dx) + ((double)dy*dy);
- dist = sqrt(dist);
- if ( min_dist >= (int) dist ) result |= ENDPOINT;
- }
+ dx = m_End.x - point.x;
+ dy = m_End.y - point.y;
+ if( min_dist == 0 )
+ {
+ if( (dx == 0) && (dy == 0 ) )
+ result |= ENDPOINT;
+ }
+ else
+ {
+ double dist = ( (double) dx * dx ) + ( (double) dy * dy );
+ dist = sqrt( dist );
+ if( min_dist >= (int) dist )
+ result |= ENDPOINT;
+ }
- return result;
+ return result;
}
+
/******************************************/
-bool SEGVIA::IsViaOnLayer(int layer_number )
+bool SEGVIA::IsViaOnLayer( int layer_number )
/******************************************/
+
/* Retoune TRUE si Via sur layer layer_number
-*/
+ */
{
-int via_type = Shape();
+ int via_type = Shape();
- if( via_type == VIA_NORMALE )
- {
- if ( layer_number <= LAYER_CMP_N ) return TRUE;
- else return FALSE;
- }
+ if( via_type == VIA_NORMALE )
+ {
+ if( layer_number <= LAYER_CMP_N )
+ return TRUE;
+ else
+ return FALSE;
+ }
- // VIA_BORGNE ou VIA_ENTERREE:
+ // VIA_BORGNE ou VIA_ENTERREE:
-int bottom_layer, top_layer;
- ReturnLayerPair(& top_layer, & bottom_layer);
- if ( (bottom_layer <= layer_number) && (top_layer >= layer_number) )
- return TRUE;
- else return FALSE;
+ int bottom_layer, top_layer;
+ ReturnLayerPair( &top_layer, &bottom_layer );
+ if( (bottom_layer <= layer_number) && (top_layer >= layer_number) )
+ return TRUE;
+ else
+ return FALSE;
}
/***********************************/
-int TRACK::ReturnMaskLayer(void)
+int TRACK::ReturnMaskLayer( void )
/***********************************/
+
/* Retourne le masque (liste bit a bit ) des couches occupees par le segment
- de piste pointe par PtSegm.
- Si PtSegm pointe une via, il y a plusieurs couches occupees
-*/
+ * de piste pointe par PtSegm.
+ * Si PtSegm pointe une via, il y a plusieurs couches occupees
+ */
{
- if( m_StructType == TYPEVIA )
- {
- int via_type = m_Shape & 15;
- if( via_type == VIA_NORMALE ) return (ALL_CU_LAYERS);
- // VIA_BORGNE ou VIA_ENTERREE:
- int bottom_layer = (m_Layer >> 4) & 15;
- int top_layer = m_Layer & 15;
- if ( bottom_layer > top_layer ) EXCHG (bottom_layer, top_layer);
- int layermask = 0;
- while ( bottom_layer <= top_layer )
- {
- layermask |= g_TabOneLayerMask[bottom_layer++];
- }
- return (layermask);
- }
- else return(g_TabOneLayerMask[m_Layer]);
+ if( m_StructType == TYPEVIA )
+ {
+ int via_type = m_Shape & 15;
+ if( via_type == VIA_NORMALE )
+ return ALL_CU_LAYERS;
+
+ // VIA_BORGNE ou VIA_ENTERREE:
+ int bottom_layer = (m_Layer >> 4) & 15;
+ int top_layer = m_Layer & 15;
+ if( bottom_layer > top_layer )
+ EXCHG( bottom_layer, top_layer );
+ int layermask = 0;
+ while( bottom_layer <= top_layer )
+ {
+ layermask |= g_TabOneLayerMask[bottom_layer++];
+ }
+
+ return layermask;
+ }
+ else
+ return g_TabOneLayerMask[m_Layer];
}
+/*********************************************************/
+void SEGVIA::SetLayerPair( int top_layer, int bottom_layer )
+/*********************************************************/
-/*********************************************************/
-void SEGVIA::SetLayerPair(int top_layer, int bottom_layer)
-/*********************************************************/
/* Met a jour .m_Layer pour une via:
- m_Layer code les 2 couches limitant la via
-*/
+ * m_Layer code les 2 couches limitant la via
+ */
{
-int via_type = m_Shape & 255;
+ int via_type = m_Shape & 255;
- if( via_type == VIA_NORMALE )
- {
- top_layer = LAYER_CMP_N; bottom_layer = LAYER_CUIVRE_N;
- }
+ if( via_type == VIA_NORMALE )
+ {
+ top_layer = LAYER_CMP_N; bottom_layer = LAYER_CUIVRE_N;
+ }
- if ( bottom_layer > top_layer ) EXCHG (bottom_layer, top_layer);
- m_Layer = (top_layer & 15) + ( (bottom_layer & 15) << 4 );
+ if( bottom_layer > top_layer )
+ EXCHG( bottom_layer, top_layer );
+ m_Layer = (top_layer & 15) + ( (bottom_layer & 15) << 4 );
}
+
/***************************************************************/
-void SEGVIA::ReturnLayerPair(int * top_layer, int * bottom_layer)
+void SEGVIA::ReturnLayerPair( int* top_layer, int* bottom_layer )
/***************************************************************/
+
/* Retourne les 2 couches limitant la via
- les pointeurs top_layer et bottom_layer peuvent etre NULLs
-*/
+ * les pointeurs top_layer et bottom_layer peuvent etre NULLs
+ */
{
-int b_layer = (m_Layer >> 4) & 15;
-int t_layer = m_Layer & 15;
+ int b_layer = (m_Layer >> 4) & 15;
+ int t_layer = m_Layer & 15;
- if ( b_layer > t_layer ) EXCHG (b_layer, t_layer);
- if ( top_layer ) * top_layer = t_layer;
- if ( bottom_layer ) * bottom_layer = b_layer;
+ if( b_layer > t_layer )
+ EXCHG( b_layer, t_layer );
+ if( top_layer )
+ *top_layer = t_layer;
+ if( bottom_layer )
+ *bottom_layer = b_layer;
}
/************************/
-TRACK * TRACK::Next(void)
+TRACK* TRACK::Next( void )
/************************/
{
- return (TRACK *) Pnext;
+ return (TRACK*) Pnext;
}
-
/* supprime du chainage la structure Struct
- les structures arrieres et avant sont chainees directement
+ * les structures arrieres et avant sont chainees directement
*/
void TRACK::UnLink( void )
{
- /* Modification du chainage arriere */
- if( Pback )
- {
- if( Pback->m_StructType != TYPEPCB)
- {
- Pback->Pnext = Pnext;
- }
+ /* Modification du chainage arriere */
+ if( Pback )
+ {
+ if( Pback->m_StructType != TYPEPCB )
+ {
+ Pback->Pnext = Pnext;
+ }
+ else /* Le chainage arriere pointe sur la structure "Pere" */
+ {
+ if( GetState( DELETED ) ) // A REVOIR car Pback = NULL si place en undelete
+ {
+ if( g_UnDeleteStack )
+ g_UnDeleteStack[g_UnDeleteStackPtr - 1] = Pnext;
+ }
+ else
+ {
+ if( m_StructType == TYPEZONE )
+ {
+ ( (BOARD*) Pback )->m_Zone = (TRACK*) Pnext;
+ }
+ else
+ {
+ ( (BOARD*) Pback )->m_Track = (TRACK*) Pnext;
+ }
+ }
+ }
+ }
- else /* Le chainage arriere pointe sur la structure "Pere" */
- {
- if ( GetState(DELETED) ) // A REVOIR car Pback = NULL si place en undelete
- {
- if( g_UnDeleteStack ) g_UnDeleteStack[g_UnDeleteStackPtr-1] = Pnext;
- }
- else
- {
- if (m_StructType == TYPEZONE)
- {
- ((BOARD*)Pback)->m_Zone = (TRACK*)Pnext;
- }
- else
- {
- ((BOARD*)Pback)->m_Track = (TRACK*)Pnext;
- }
- }
- }
- }
+ /* Modification du chainage avant */
+ if( Pnext )
+ Pnext->Pback = Pback;
- /* Modification du chainage avant */
- if( Pnext) Pnext->Pback = Pback;
-
- Pnext = Pback = NULL;
+ Pnext = Pback = NULL;
}
+
/************************************************************/
-void TRACK::Insert(BOARD * Pcb, EDA_BaseStruct * InsertPoint)
+void TRACK::Insert( BOARD* Pcb, EDA_BaseStruct* InsertPoint )
/************************************************************/
+
/* Ajoute un element ou une liste a une liste de base
- Si Insertpoint == NULL: insertion en debut de
- liste Pcb->Track ou Pcb->Zone
- Insertion a la suite de InsertPoint
- Si InsertPoint == NULL, insertion en tete de liste
-*/
+ * Si Insertpoint == NULL: insertion en debut de
+ * liste Pcb->Track ou Pcb->Zone
+ * Insertion a la suite de InsertPoint
+ * Si InsertPoint == NULL, insertion en tete de liste
+ */
{
-TRACK* track, *NextS;
- /* Insertion du debut de la chaine a greffer */
- if (InsertPoint == NULL)
- {
- Pback = Pcb;
- if (m_StructType == TYPEZONE)
- {
- NextS = Pcb->m_Zone; Pcb->m_Zone = this;
- }
- else
- {
- NextS = Pcb->m_Track; Pcb->m_Track = this;
- }
- }
+ TRACK* track, * NextS;
- else
- {
- NextS = (TRACK*)InsertPoint->Pnext;
- Pback = InsertPoint;
- InsertPoint->Pnext = this;
- }
+ /* Insertion du debut de la chaine a greffer */
+ if( InsertPoint == NULL )
+ {
+ Pback = Pcb;
+ if( m_StructType == TYPEZONE )
+ {
+ NextS = Pcb->m_Zone; Pcb->m_Zone = this;
+ }
+ else
+ {
+ NextS = Pcb->m_Track; Pcb->m_Track = this;
+ }
+ }
+ else
+ {
+ NextS = (TRACK*) InsertPoint->Pnext;
+ Pback = InsertPoint;
+ InsertPoint->Pnext = this;
+ }
- /* Chainage de la fin de la liste a greffer */
- track = this;
- while ( track->Pnext ) track = (TRACK*) track->Pnext;
- /* Track pointe la fin de la chaine a greffer */
- track->Pnext = NextS;
- if ( NextS ) NextS->Pback = track;
+ /* Chainage de la fin de la liste a greffer */
+ track = this;
+ while( track->Pnext )
+ track = (TRACK*) track->Pnext;
+
+ /* Track pointe la fin de la chaine a greffer */
+ track->Pnext = NextS;
+ if( NextS )
+ NextS->Pback = track;
}
/***********************************************/
-TRACK * TRACK::GetBestInsertPoint( BOARD * Pcb )
+TRACK* TRACK::GetBestInsertPoint( BOARD* Pcb )
/***********************************************/
+
/* Recherche du meilleur point d'insertion pour le nouveau segment de piste
- Retourne
- un pointeur sur le segment de piste APRES lequel l'insertion
- doit se faire ( dernier segment du net d'apartenance )
- NULL si pas de piste ( liste vide );
-*/
+ * Retourne
+ * un pointeur sur le segment de piste APRES lequel l'insertion
+ * doit se faire ( dernier segment du net d'apartenance )
+ * NULL si pas de piste ( liste vide );
+ */
{
-TRACK * track, * NextTrack;
+ TRACK* track, * NextTrack;
- if( m_StructType == TYPEZONE ) track = Pcb->m_Zone;
- else track = Pcb->m_Track;
+ if( m_StructType == TYPEZONE )
+ track = Pcb->m_Zone;
+ else
+ track = Pcb->m_Track;
- /* Traitement du debut de liste */
- if ( track == NULL ) return(NULL); /* pas de piste ! */
- if ( m_NetCode < track->m_NetCode ) /* insertion en tete de liste */
- return(NULL);
+ /* Traitement du debut de liste */
+ if( track == NULL )
+ return NULL; /* pas de piste ! */
+ if( m_NetCode < track->m_NetCode ) /* insertion en tete de liste */
+ return NULL;
- while( (NextTrack = (TRACK*)track->Pnext) != NULL )
- {
- if ( NextTrack->m_NetCode > this->m_NetCode ) break;
- track = NextTrack;
- }
- return ( track);
+ while( (NextTrack = (TRACK*) track->Pnext) != NULL )
+ {
+ if( NextTrack->m_NetCode > this->m_NetCode )
+ break;
+ track = NextTrack;
+ }
+
+ return track;
}
+
/* Recherche du debut du net
- ( les elements sont classes par net_code croissant )
- la recherche se fait a partir de this
- si net_code == -1 le netcode de this sera utilise
- Retourne un pointeur sur le debut du net, ou NULL si net non trouve
-*/
-TRACK * TRACK::GetStartNetCode(int NetCode )
+ * ( les elements sont classes par net_code croissant )
+ * la recherche se fait a partir de this
+ * si net_code == -1 le netcode de this sera utilise
+ * Retourne un pointeur sur le debut du net, ou NULL si net non trouve
+ */
+TRACK* TRACK::GetStartNetCode( int NetCode )
{
-TRACK * Track = this;
-int ii = 0;
+ TRACK* Track = this;
+ int ii = 0;
- if( NetCode == -1 ) NetCode = m_NetCode;
+ if( NetCode == -1 )
+ NetCode = m_NetCode;
- while( Track != NULL)
- {
- if ( Track->m_NetCode > NetCode ) break;
- if ( Track->m_NetCode == NetCode )
- {
- ii++; break;
- }
- Track = (TRACK*) Track->Pnext;
- }
- if ( ii ) return(Track);
- else return (NULL);
+ while( Track != NULL )
+ {
+ if( Track->m_NetCode > NetCode )
+ break;
+ if( Track->m_NetCode == NetCode )
+ {
+ ii++; break;
+ }
+ Track = (TRACK*) Track->Pnext;
+ }
+
+ if( ii )
+ return Track;
+ else
+ return NULL;
}
+
/* Recherche de la fin du net
- Retourne un pointeur sur la fin du net, ou NULL si net non trouve
-*/
-TRACK * TRACK::GetEndNetCode(int NetCode)
+ * Retourne un pointeur sur la fin du net, ou NULL si net non trouve
+ */
+TRACK* TRACK::GetEndNetCode( int NetCode )
{
-TRACK * NextS, * Track = this;
-int ii = 0;
+ TRACK* NextS, * Track = this;
+ int ii = 0;
- if( Track == NULL ) return(NULL);
+ if( Track == NULL )
+ return NULL;
- if( NetCode == -1 ) NetCode = m_NetCode;
+ if( NetCode == -1 )
+ NetCode = m_NetCode;
- while( Track != NULL)
- {
- NextS = (TRACK*)Track->Pnext;
- if(Track->m_NetCode == NetCode) ii++;
- if ( NextS == NULL ) break;
- if ( NextS->m_NetCode > NetCode) break;
- Track = NextS;
- }
- if ( ii ) return(Track);
- else return (NULL);
+ while( Track != NULL )
+ {
+ NextS = (TRACK*) Track->Pnext;
+ if( Track->m_NetCode == NetCode )
+ ii++;
+ if( NextS == NULL )
+ break;
+ if( NextS->m_NetCode > NetCode )
+ break;
+ Track = NextS;
+ }
+
+ if( ii )
+ return Track;
+ else
+ return NULL;
}
/**********************************/
-TRACK * TRACK:: Copy( int NbSegm )
+TRACK* TRACK:: Copy( int NbSegm )
/**********************************/
+
/* Copie d'un Element ou d'une chaine de n elements
- Retourne un pointeur sur le nouvel element ou le debut de la
- nouvelle chaine
-*/
+ * Retourne un pointeur sur le nouvel element ou le debut de la
+ * nouvelle chaine
+ */
{
-TRACK * NewTrack, * FirstTrack, *OldTrack, * Source = this;
-int ii;
+ TRACK* NewTrack, * FirstTrack, * OldTrack, * Source = this;
+ int ii;
- FirstTrack = NewTrack = new TRACK(*Source);
+ FirstTrack = NewTrack = new TRACK( *Source );
- for( ii = 1; ii < NbSegm; ii++ )
- {
- Source = Source->Next();
- if( Source == NULL ) break;
- OldTrack = NewTrack;
- NewTrack = new TRACK(*Source);
- NewTrack->Insert(NULL, OldTrack);
- }
+ for( ii = 1; ii < NbSegm; ii++ )
+ {
+ Source = Source->Next();
+ if( Source == NULL )
+ break;
+ OldTrack = NewTrack;
+ NewTrack = new TRACK( *Source );
+ NewTrack->Insert( NULL, OldTrack );
+ }
- return (FirstTrack);
+ return FirstTrack;
}
+
/********************************************/
-bool TRACK::WriteTrackDescr(FILE * File)
+bool TRACK::WriteTrackDescr( FILE* File )
/********************************************/
{
-int type;
+ int type;
- type = 0;
- if( m_StructType == TYPEVIA ) type = 1;
+ type = 0;
+ if( m_StructType == TYPEVIA )
+ type = 1;
- if( GetState(DELETED) ) return FALSE;
+ if( GetState( DELETED ) )
+ return FALSE;
- fprintf( File,"Po %d %d %d %d %d %d %d\n",m_Shape,
- m_Start.x, m_Start.y, m_End.x, m_End.y, m_Width, m_Drill);
+ fprintf( File, "Po %d %d %d %d %d %d %d\n", m_Shape,
+ m_Start.x, m_Start.y, m_End.x, m_End.y, m_Width, m_Drill );
- fprintf( File,"De %d %d %d %lX %X\n",
- m_Layer, type ,m_NetCode,
- m_TimeStamp, ReturnStatus());
- return TRUE;
+ fprintf( File, "De %d %d %d %lX %X\n",
+ m_Layer, type, m_NetCode,
+ m_TimeStamp, ReturnStatus() );
+ return TRUE;
}
+
/**********************************************************************/
-void TRACK::Draw(WinEDA_DrawPanel * panel, wxDC * DC, int draw_mode)
+void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode )
/*********************************************************************/
- /* routine de trace de 1 segment de piste.
-Parametres :
- draw_mode = mode ( GR_XOR, GR_OR..)
-*/
+
+/* routine de trace de 1 segment de piste.
+ * Parametres :
+ * draw_mode = mode ( GR_XOR, GR_OR..)
+ */
{
-int l_piste;
-int color;
-int zoom;
-int rayon;
-int curr_layer = ((PCB_SCREEN*)panel->GetScreen())->m_Active_Layer;
+ int l_piste;
+ int color;
+ int zoom;
+ int rayon;
+ int curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
- if(m_StructType == TYPEZONE && (! DisplayOpt.DisplayZones) )
- return;
+ if( m_StructType == TYPEZONE && (!DisplayOpt.DisplayZones) )
+ return;
- GRSetDrawMode(DC, draw_mode);
+ GRSetDrawMode( DC, draw_mode );
- if ( m_StructType == TYPEVIA ) /* VIA rencontree */
- color = g_DesignSettings.m_ViaColor[m_Shape];
- else color = g_DesignSettings.m_LayerColor[m_Layer];
+ if( m_StructType == TYPEVIA ) /* VIA rencontree */
+ color = g_DesignSettings.m_ViaColor[m_Shape];
+ else
+ color = g_DesignSettings.m_LayerColor[m_Layer];
- if( (color & (ITEM_NOT_SHOW | HIGHT_LIGHT_FLAG)) == ITEM_NOT_SHOW) return ;
+ if( ( color & (ITEM_NOT_SHOW | HIGHT_LIGHT_FLAG) ) == ITEM_NOT_SHOW )
+ return;
- if ( DisplayOpt.ContrastModeDisplay )
- {
- if ( m_StructType == TYPEVIA )
- {
- if ( ! ((SEGVIA*)this)->IsViaOnLayer(curr_layer) )
- {
- color &= ~MASKCOLOR;
- color |= DARKDARKGRAY;
- }
- }
- else if ( m_Layer != curr_layer)
- {
- color &= ~MASKCOLOR;
- color |= DARKDARKGRAY;
- }
- }
+ if( DisplayOpt.ContrastModeDisplay )
+ {
+ if( m_StructType == TYPEVIA )
+ {
+ if( !( (SEGVIA*) this )->IsViaOnLayer( curr_layer ) )
+ {
+ color &= ~MASKCOLOR;
+ color |= DARKDARKGRAY;
+ }
+ }
+ else if( m_Layer != curr_layer )
+ {
+ color &= ~MASKCOLOR;
+ color |= DARKDARKGRAY;
+ }
+ }
- if( draw_mode & GR_SURBRILL)
- {
- if( draw_mode & GR_AND) color &= ~HIGHT_LIGHT_FLAG;
- else color |= HIGHT_LIGHT_FLAG;
- }
- if ( color & HIGHT_LIGHT_FLAG)
- color = ColorRefs[color & MASKCOLOR].m_LightColor;
+ if( draw_mode & GR_SURBRILL )
+ {
+ if( draw_mode & GR_AND )
+ color &= ~HIGHT_LIGHT_FLAG;
+ else
+ color |= HIGHT_LIGHT_FLAG;
+ }
+ if( color & HIGHT_LIGHT_FLAG )
+ color = ColorRefs[color & MASKCOLOR].m_LightColor;
- zoom = panel->GetZoom();
+ zoom = panel->GetZoom();
- l_piste = m_Width >> 1;
+ l_piste = m_Width >> 1;
- if ( m_StructType == TYPEVIA ) /* VIA rencontree */
- {
- rayon = l_piste; if( rayon < zoom ) rayon = zoom;
- GRCircle(&panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon, color) ;
- if ( rayon > (4*zoom) )
- {
- int drill_rayon, inner_rayon = rayon-(2*zoom);
- GRCircle(&panel->m_ClipBox, DC, m_Start.x, m_Start.y,
- inner_rayon, color);
- // Draw the via hole if the display option request it
- if ( DisplayOpt.m_DisplayViaMode != VIA_HOLE_NOT_SHOW)
- {
- if ( (DisplayOpt.m_DisplayViaMode == ALL_VIA_HOLE_SHOW)
- || ( m_Drill > 0 ) )
- {
- if ( m_Drill > 0 ) drill_rayon = m_Drill / 2;
- else drill_rayon = g_DesignSettings.m_ViaDrill / 2;
- if( drill_rayon < inner_rayon ) // We can show the via hole
- {
- GRCircle(&panel->m_ClipBox, DC, m_Start.x, m_Start.y,
- drill_rayon , color);
- }
- }
- }
+ if( m_StructType == TYPEVIA ) /* VIA rencontree */
+ {
+ rayon = l_piste; if( rayon < zoom )
+ rayon = zoom;
+ GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon, color );
+ if( rayon > (4 * zoom) )
+ {
+ int drill_rayon, inner_rayon = rayon - (2 * zoom);
+ GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y,
+ inner_rayon, color );
- if(DisplayOpt.DisplayTrackIsol)
- GRCircle(&panel->m_ClipBox, DC, m_Start.x, m_Start.y,
- rayon + g_DesignSettings.m_TrackClearence, color);
- }
- return;
- }
+ // Draw the via hole if the display option request it
+ if( DisplayOpt.m_DisplayViaMode != VIA_HOLE_NOT_SHOW )
+ {
+ if( (DisplayOpt.m_DisplayViaMode == ALL_VIA_HOLE_SHOW)
+ || ( m_Drill > 0 ) )
+ {
+ if( m_Drill > 0 )
+ drill_rayon = m_Drill / 2;
+ else
+ drill_rayon = g_DesignSettings.m_ViaDrill / 2;
+ if( drill_rayon < inner_rayon ) // We can show the via hole
+ {
+ GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y,
+ drill_rayon, color );
+ }
+ }
+ }
- if(m_Shape == S_CIRCLE)
- {
- rayon = (int)hypot((double)(m_End.x - m_Start.x),
- (double)(m_End.y - m_Start.y) );
- if ( (l_piste/zoom) < L_MIN_DESSIN)
- {
- GRCircle(&panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon , color) ;
- }
+ if( DisplayOpt.DisplayTrackIsol )
+ GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y,
+ rayon + g_DesignSettings.m_TrackClearence, color );
+ }
+ return;
+ }
- else
- {
- if(l_piste <= zoom) /* trace simplifie si l_piste/zoom <= 1 */
- {
- GRCircle(&panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon, color);
- }
- else if( ( ! DisplayOpt.DisplayPcbTrackFill) || GetState(FORCE_SKETCH))
- {
- GRCircle(&panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon-l_piste, color);
- GRCircle(&panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon+l_piste, color);
- }
- else
- {
- GRCircle(&panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon,
- m_Width, color);
- }
- }
- return;
- }
+ if( m_Shape == S_CIRCLE )
+ {
+ rayon = (int) hypot( (double) (m_End.x - m_Start.x),
+ (double) (m_End.y - m_Start.y) );
+ if( (l_piste / zoom) < L_MIN_DESSIN )
+ {
+ GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon, color );
+ }
+ else
+ {
+ if( l_piste <= zoom ) /* trace simplifie si l_piste/zoom <= 1 */
+ {
+ GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon, color );
+ }
+ else if( ( !DisplayOpt.DisplayPcbTrackFill) || GetState( FORCE_SKETCH ) )
+ {
+ GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon - l_piste, color );
+ GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon + l_piste, color );
+ }
+ else
+ {
+ GRCircle( &panel->m_ClipBox, DC, m_Start.x, m_Start.y, rayon,
+ m_Width, color );
+ }
+ }
+ return;
+ }
- if ( (l_piste/zoom) < L_MIN_DESSIN)
- {
- GRLine(&panel->m_ClipBox, DC, m_Start.x, m_Start.y,
- m_End.x, m_End.y, 0, color);
- return;
- }
+ if( (l_piste / zoom) < L_MIN_DESSIN )
+ {
+ GRLine( &panel->m_ClipBox, DC, m_Start.x, m_Start.y,
+ m_End.x, m_End.y, 0, color );
+ return;
+ }
- if( (! DisplayOpt.DisplayPcbTrackFill) || GetState(FORCE_SKETCH) )
- {
- GRCSegm(&panel->m_ClipBox, DC, m_Start.x, m_Start.y,
- m_End.x, m_End.y, m_Width, color) ;
- }
- else
- {
- GRFillCSegm(&panel->m_ClipBox, DC, m_Start.x, m_Start.y,
- m_End.x, m_End.y, m_Width, color) ;
- }
+ if( (!DisplayOpt.DisplayPcbTrackFill) || GetState( FORCE_SKETCH ) )
+ {
+ GRCSegm( &panel->m_ClipBox, DC, m_Start.x, m_Start.y,
+ m_End.x, m_End.y, m_Width, color );
+ }
+ else
+ {
+ GRFillCSegm( &panel->m_ClipBox, DC, m_Start.x, m_Start.y,
+ m_End.x, m_End.y, m_Width, color );
+ }
- /* Trace de l'isolation (pour segments type CUIVRE et TRACK uniquement */
- if( (DisplayOpt.DisplayTrackIsol) && (m_Layer <= CMP_N )
- && ( m_StructType == TYPETRACK) )
- {
- GRCSegm(&panel->m_ClipBox, DC, m_Start.x, m_Start.y,
- m_End.x, m_End.y,
- m_Width + (g_DesignSettings.m_TrackClearence*2), color) ;
- }
+ /* Trace de l'isolation (pour segments type CUIVRE et TRACK uniquement */
+ if( (DisplayOpt.DisplayTrackIsol) && (m_Layer <= CMP_N )
+ && ( m_StructType == TYPETRACK) )
+ {
+ GRCSegm( &panel->m_ClipBox, DC, m_Start.x, m_Start.y,
+ m_End.x, m_End.y,
+ m_Width + (g_DesignSettings.m_TrackClearence * 2), color );
+ }
}
+/**
+ * Function HitTest
+ * tests if the given wxPoint is within the bounds of this object.
+ * @param ref_pos A wxPoint to test
+ * @return bool - true if a hit, else false
+ */
+bool TRACK::HitTest( const wxPoint& ref_pos )
+{
+ int l_piste; /* demi-largeur de la piste */
+ int dx, dy, spot_cX, spot_cY;
+ int ux0, uy0;
+
+ /* calcul des coordonnees du segment teste */
+ l_piste = m_Width >> 1; /* l_piste = demi largeur piste */
+
+ ux0 = m_Start.x;
+ uy0 = m_Start.y; /* coord de depart */
+
+ dx = m_End.x;
+ dy = m_End.y; /* coord d'arrivee */
+
+ /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
+ dx -= ux0;
+ dy -= uy0;
+
+ spot_cX = ref_pos.x - ux0;
+ spot_cY = ref_pos.y - uy0;
+
+ if( m_StructType == TYPEVIA ) /* VIA rencontree */
+ {
+ if( (abs( spot_cX ) <= l_piste ) && (abs( spot_cY ) <=l_piste) )
+ return true;
+ else
+ return false;
+ }
+ else
+ {
+ if( DistanceTest( l_piste, dx, dy, spot_cX, spot_cY ) )
+ return true;
+ }
+
+ return false;
+}
+
diff --git a/pcbnew/class_track.h b/pcbnew/class_track.h
index 30235a17d9..3562dfe32b 100644
--- a/pcbnew/class_track.h
+++ b/pcbnew/class_track.h
@@ -10,84 +10,135 @@
/* Type des Vias (shape)*/
/* Forme des Vias ( parametre .shape ) */
-#define VIA_NORMALE 3 /* type via : traversante (throught via) */
-#define VIA_ENTERREE 2 /* type via : enterree ou aveugle (blind via) */
-#define VIA_BORGNE 1 /* type via : borgne ou demi-traversante (buried via) */
-#define VIA_NOT_DEFINED 0 /* reserved */
-#define SQUARE_VIA 0x80000000 /* Flag pour forme carree */
+#define VIA_NORMALE 3 /* type via : traversante (throught via) */
+#define VIA_ENTERREE 2 /* type via : enterree ou aveugle (blind via) */
+#define VIA_BORGNE 1 /* type via : borgne ou demi-traversante (buried via) */
+#define VIA_NOT_DEFINED 0 /* reserved */
+#define SQUARE_VIA 0x80000000 /* Flag pour forme carree */
/***/
-class TRACK: public EDA_BaseLineStruct
+class TRACK : public EDA_BaseLineStruct
{
public:
- int m_Shape; // vias: shape and type, Track = shape..
- int m_Drill; // for vias: via drill (- 1 for default value)
- EDA_BaseStruct * start,* end; // pointers on a connected item (pad or track)
- int m_NetCode; // Net number
- int m_Sous_Netcode; /* In rastnest routines : for the current net,
- block number (number common to the current connected items found) */
- // chain = 0 indique une connexion non encore traitee
- int m_Param; // Auxiliary variable ( used in some computations )
+ int m_Shape; // vias: shape and type, Track = shape..
+ int m_Drill; // for vias: via drill (- 1 for default value)
+ EDA_BaseStruct* start, * end; // pointers on a connected item (pad or track)
+ int m_NetCode; // Net number
+ int m_Sous_Netcode; /* In rastnest routines : for the current net,
+ * block number (number common to the current connected items found) */
+
+ // chain = 0 indique une connexion non encore traitee
+ int m_Param; // Auxiliary variable ( used in some computations )
public:
- TRACK(EDA_BaseStruct * StructFather, DrawStructureType idtype = TYPETRACK);
- TRACK(const TRACK & track);
+ TRACK( EDA_BaseStruct* StructFather, DrawStructureType idtype = TYPETRACK );
+ TRACK( const TRACK& track );
- TRACK * Next(void); // Retourne le chainage avant
- TRACK * Back(void) // Retourne le chainage avant
- {
- return (TRACK*) Pback;
- }
+ TRACK* Next( void ); // Retourne le chainage avant
- /* supprime du chainage la structure Struct */
- void UnLink( void );
+ TRACK* Back( void ) // Retourne le chainage avant
+ {
+ return (TRACK*) Pback;
+ }
- // Read/write data
- bool WriteTrackDescr(FILE * File);
- /* Ajoute un element a la liste */
- void Insert(BOARD * Pcb, EDA_BaseStruct * InsertPoint);
+ /* supprime du chainage la structure Struct */
+ void UnLink( void );
- /* Recherche du meilleur point d'insertion */
- TRACK * GetBestInsertPoint( BOARD * Pcb);
+ // Read/write data
+ bool WriteTrackDescr( FILE* File );
- /* Copie d'un Element d'une chaine de n elements */
- TRACK * Copy( int NbSegm = 1 );
+ /* Ajoute un element a la liste */
+ void Insert( BOARD* Pcb, EDA_BaseStruct* InsertPoint );
- /* Recherche du debut du net
- ( les elements sont classes par net_code croissant ) */
- TRACK * GetStartNetCode(int NetCode );
- /* Recherche de la fin du net */
- TRACK * GetEndNetCode(int NetCode);
+ /* Recherche du meilleur point d'insertion */
+ TRACK* GetBestInsertPoint( BOARD* Pcb );
- /* Display on screen: */
- void Draw(WinEDA_DrawPanel * panel, wxDC * DC, int draw_mode);
+ /* Copie d'un Element d'une chaine de n elements */
+ TRACK* Copy( int NbSegm = 1 );
- /* divers */
- int Shape(void) { return m_Shape & 0xFF; }
+ /* Recherche du debut du net
+ * ( les elements sont classes par net_code croissant ) */
+ TRACK* GetStartNetCode( int NetCode );
- int ReturnMaskLayer(void);
- int IsPointOnEnds(const wxPoint & point, int min_dist = 0);
- bool IsNull(void); // return TRUE if segment lenght = 0
+ /* Recherche de la fin du net */
+ TRACK* GetEndNetCode( int NetCode );
+
+ /* Display on screen: */
+ void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode );
+
+ /* divers */
+ int Shape( void ) { return m_Shape & 0xFF; }
+
+ int ReturnMaskLayer( void );
+ int IsPointOnEnds( const wxPoint& point, int min_dist = 0 );
+ bool IsNull( void ); // return TRUE if segment lenght = 0
+
+ /**
+ * Function HitTest
+ * tests if the given wxPoint is within the bounds of this object.
+ * @param refPos A wxPoint to test
+ * @return bool - true if a hit, else false
+ */
+ bool HitTest( const wxPoint& refPos );
+
+#if defined(DEBUG)
+ /**
+ * Function GetClass
+ * returns the class name.
+ * @return wxString
+ */
+ wxString GetClass() const
+ {
+ return wxT("TRACK");
+ }
+
+#endif
+
};
-class SEGZONE: public TRACK
+class SEGZONE : public TRACK
{
public:
- SEGZONE(EDA_BaseStruct * StructFather);
+ SEGZONE( EDA_BaseStruct* StructFather );
+
+#if defined(DEBUG)
+ /**
+ * Function GetClass
+ * returns the class name.
+ * @return wxString
+ */
+ wxString GetClass() const
+ {
+ return wxT("ZONE");
+ }
+#endif
+
};
-class SEGVIA: public TRACK
+class SEGVIA : public TRACK
{
public:
- SEGVIA(EDA_BaseStruct * StructFather);
- bool IsViaOnLayer(int layer);
- void SetLayerPair(int top_layer, int bottom_layer);
- void ReturnLayerPair(int * top_layer, int * bottom_layer);
+ SEGVIA( EDA_BaseStruct* StructFather );
+ bool IsViaOnLayer( int layer );
+ void SetLayerPair( int top_layer, int bottom_layer );
+ void ReturnLayerPair( int* top_layer, int* bottom_layer );
+
+#if defined(DEBUG)
+ /**
+ * Function GetClass
+ * returns the class name.
+ * @return wxString
+ */
+ wxString GetClass() const
+ {
+ return wxT("VIA");
+ }
+#endif
+
};
-
#endif /* CLASS_TRACK_H */
diff --git a/pcbnew/classpcb.cpp b/pcbnew/classpcb.cpp
index 0613ac792f..c7b9d8d261 100644
--- a/pcbnew/classpcb.cpp
+++ b/pcbnew/classpcb.cpp
@@ -16,6 +16,7 @@
#endif
#include "protos.h"
+#include "trigo.h"
/**************************************************************/
@@ -165,6 +166,61 @@ bool DRAWSEGMENT::ReadDrawSegmentDescr( FILE* File, int* LineNum )
}
+/**
+ * Function HitTest
+ * tests if the given wxPoint is within the bounds of this object.
+ * @param ref_pos A wxPoint to test
+ * @return bool - true if a hit, else false
+ */
+bool DRAWSEGMENT::HitTest( const wxPoint& ref_pos )
+{
+ int ux0 = m_Start.x;
+ int uy0 = m_Start.y;
+
+ /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
+ int dx = m_End.x - ux0;
+ int dy = m_End.y - uy0;
+
+ int spot_cX = ref_pos.x - ux0;
+ int spot_cY = ref_pos.y - uy0;
+
+ if( m_Shape==S_CIRCLE || m_Shape==S_ARC )
+ {
+ int rayon, dist, stAngle, endAngle, mouseAngle;
+
+ rayon = (int) hypot( (double) (dx), (double) (dy) );
+ dist = (int) hypot( (double) (spot_cX), (double) (spot_cY) );
+
+ if( abs( rayon - dist ) <= (m_Width / 2) )
+ {
+ if( m_Shape == S_CIRCLE )
+ return true;
+
+ /* pour un arc, controle complementaire */
+ mouseAngle = (int) ArcTangente( spot_cY, spot_cX );
+ stAngle = (int) ArcTangente( dy, dx );
+ endAngle = stAngle + m_Angle;
+
+ if( endAngle > 3600 )
+ {
+ stAngle -= 3600;
+ endAngle -= 3600;
+ }
+
+ if( mouseAngle >= stAngle && mouseAngle <= endAngle )
+ return true;
+ }
+ }
+ else
+ {
+ if( DistanceTest( m_Width / 2, dx, dy, spot_cX, spot_cY ) )
+ return true;
+ }
+ return false;
+}
+
+
+
/*******************/
/* Classe MARQUEUR */
/*******************/
diff --git a/pcbnew/drc.cpp b/pcbnew/drc.cpp
index 6d34840eab..fab88cf317 100644
--- a/pcbnew/drc.cpp
+++ b/pcbnew/drc.cpp
@@ -1,6 +1,6 @@
- /****************************/
- /* DRC control */
- /****************************/
+/****************************/
+/* DRC control */
+/****************************/
#include "fctsys.h"
#include "gr_basic.h"
@@ -14,1345 +14,1542 @@
/* variables locales */
class WinEDA_DrcFrame;
-WinEDA_DrcFrame * DrcFrame;
+WinEDA_DrcFrame* DrcFrame;
/* saving drc options */
-static bool s_Pad2PadTestOpt = true;
-static bool s_UnconnectedTestOpt = true;
-static bool s_ZonesTestOpt = false;
-static bool s_CreateRptFileOpt = false;
-static FILE * s_RptFile = NULL;
-static wxString s_RptFilename;
+static bool s_Pad2PadTestOpt = true;
+static bool s_UnconnectedTestOpt = true;
+static bool s_ZonesTestOpt = false;
+static bool s_CreateRptFileOpt = false;
+static FILE* s_RptFile = NULL;
+static wxString s_RptFilename;
-static int ErrorsDRC_Count;
-static MARQUEUR * current_marqueur; /* Pour gestion des marqueurs sur pcb */
+static int ErrorsDRC_Count;
+static MARQUEUR* current_marqueur; /* Pour gestion des marqueurs sur pcb */
-static bool AbortDrc, DrcInProgress = FALSE;
-static int spot_cX, spot_cY; /* position d'elements a tester */
-static int finx, finy; // coord relatives de l'extremite du segm de reference
-static int segm_angle; // angle d'inclinaison du segment de reference en 0,1 degre
-static int segm_long; // longueur du segment de reference
-static int xcliplo,ycliplo,xcliphi,ycliphi ; /* coord de la surface de securite du segment a comparer */
+static bool AbortDrc, DrcInProgress = FALSE;
+static int spot_cX, spot_cY; /* position d'elements a tester */
+static int finx, finy; // coord relatives de l'extremite du segm de reference
+static int segm_angle; // angle d'inclinaison du segment de reference en 0,1 degre
+static int segm_long; // longueur du segment de reference
+static int xcliplo, ycliplo, xcliphi, ycliphi; /* coord de la surface de securite du segment a comparer */
/* Routines Locales */
-static int Pad_to_Pad_Isol(D_PAD * pad_ref, D_PAD * pad, const int dist_min);
-static bool Test_Pad_to_Pads_Drc(WinEDA_BasePcbFrame *frame, wxDC * DC, D_PAD * pad_ref,
- LISTE_PAD * start_buffer, LISTE_PAD * end_buffer, int max_size, bool show_err);
-static int TestClearanceSegmToPad(const D_PAD* pad_to_test, int seg_width, int isol);
-static int TestMarginToCircle(int cx, int cy, int rayon, int longueur);
-static int Tst_Ligne(int x1,int y1,int x2,int y2);
-static void Affiche_Erreur_DRC(WinEDA_DrawPanel * panel, wxDC * DC, BOARD * Pcb,
- TRACK * pt_ref, void * pt_item, int errnumber);
-static void Affiche_Erreur_DRC(WinEDA_DrawPanel * panel, wxDC * DC,
- BOARD * Pcb, D_PAD * pad1, D_PAD * pad2);
+static int Pad_to_Pad_Isol( D_PAD* pad_ref, D_PAD* pad, const int dist_min );
+static bool Test_Pad_to_Pads_Drc( WinEDA_BasePcbFrame* frame,
+ wxDC* DC,
+ D_PAD* pad_ref,
+ LISTE_PAD* start_buffer,
+ LISTE_PAD* end_buffer,
+ int max_size,
+ bool show_err );
+static int TestClearanceSegmToPad( const D_PAD* pad_to_test, int seg_width, int isol );
+static int TestMarginToCircle( int cx, int cy, int rayon, int longueur );
+static int Tst_Ligne( int x1, int y1, int x2, int y2 );
+static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb,
+ TRACK* pt_ref, void* pt_item, int errnumber );
+static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC,
+ BOARD* Pcb, D_PAD* pad1, D_PAD* pad2 );
-
- /*******************************************/
- /* Frame d'option et execution DRC general */
- /*******************************************/
+/*******************************************/
+/* Frame d'option et execution DRC general */
+/*******************************************/
#include "dialog_drc.cpp"
/***************************************************************/
-void WinEDA_DrcFrame::ListUnconnectedPads(wxCommandEvent & event)
+void WinEDA_DrcFrame::ListUnconnectedPads( wxCommandEvent& event )
/***************************************************************/
{
- if( (m_Parent->m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0 )
- {
- m_Parent->Compile_Ratsnest( m_DC, TRUE);
- }
- if( m_Parent->m_Pcb->m_Ratsnest == NULL ) return;
+ if( (m_Parent->m_Pcb->m_Status_Pcb & LISTE_CHEVELU_OK) == 0 )
+ {
+ m_Parent->Compile_Ratsnest( m_DC, TRUE );
+ }
+ if( m_Parent->m_Pcb->m_Ratsnest == NULL )
+ return;
-CHEVELU* Ratsnest = m_Parent->m_Pcb->m_Ratsnest;
-int draw_mode = GR_SURBRILL | GR_OR;
-WinEDA_DrawPanel * panel = m_Parent->DrawPanel;
-int ii;
-wxString msg;
-float convert = 0.0001;
+ CHEVELU* Ratsnest = m_Parent->m_Pcb->m_Ratsnest;
+ int draw_mode = GR_SURBRILL | GR_OR;
+ WinEDA_DrawPanel* panel = m_Parent->DrawPanel;
+ int ii;
+ wxString msg;
+ float convert = 0.0001;
- msg = _("Look for active routes\n");
- m_logWindow->AppendText(msg);
- if ( s_RptFile ) fprintf(s_RptFile, "%s", CONV_TO_UTF8(msg) );
+ msg = _( "Look for active routes\n" );
+ m_logWindow->AppendText( msg );
+ if( s_RptFile )
+ fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );
- m_UnconnectedCount = 0;
- for( ii = m_Parent->m_Pcb->GetNumRatsnests() ;ii > 0; Ratsnest++, ii--)
- {
- if( (Ratsnest->status & CH_ACTIF) == 0) continue;
- m_UnconnectedCount++;
- if ( m_UnconnectedCount == 1 ) m_logWindow->AppendText(_("Unconnected found:\n") );
- D_PAD * pad = Ratsnest->pad_start;
- pad->Draw(panel, m_DC, wxPoint(0,0),draw_mode);
- wxString pad_name = pad->ReturnStringPadName();
- wxString module_name = ((MODULE*)(pad->m_Parent))->m_Reference->m_Text;
- msg.Printf(_("%d > Pad %s (%s) @ %.4f,%.4f and "), m_UnconnectedCount,
- pad_name.GetData(), module_name.GetData(), pad->m_Pos.x * convert, pad->m_Pos.y * convert);
- m_logWindow->AppendText(msg);
- if ( s_RptFile ) fprintf(s_RptFile, "%s", CONV_TO_UTF8(msg) );
+ m_UnconnectedCount = 0;
+ for( ii = m_Parent->m_Pcb->GetNumRatsnests(); ii > 0; Ratsnest++, ii-- )
+ {
+ if( (Ratsnest->status & CH_ACTIF) == 0 )
+ continue;
+ m_UnconnectedCount++;
+ if( m_UnconnectedCount == 1 )
+ m_logWindow->AppendText( _( "Unconnected found:\n" ) );
+ D_PAD* pad = Ratsnest->pad_start;
+ pad->Draw( panel, m_DC, wxPoint( 0, 0 ), draw_mode );
+ wxString pad_name = pad->ReturnStringPadName();
+ wxString module_name = ( (MODULE*) (pad->m_Parent) )->m_Reference->m_Text;
+ msg.Printf( _( "%d > Pad %s (%s) @ %.4f,%.4f and " ), m_UnconnectedCount,
+ pad_name.GetData(), module_name.GetData(
+ ), pad->m_Pos.x * convert, pad->m_Pos.y * convert );
+ m_logWindow->AppendText( msg );
+ if( s_RptFile )
+ fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );
- pad = Ratsnest->pad_end;
- pad->Draw(panel, m_DC, wxPoint(0,0),draw_mode);
- pad_name = pad->ReturnStringPadName();
- module_name = ((MODULE*)(pad->m_Parent))->m_Reference->m_Text;
- msg.Printf(_("Pad %s (%s) @ %.4f,%.4f\n"),
- pad_name.GetData(), module_name.GetData(), pad->m_Pos.x * convert, pad->m_Pos.y * convert);
- m_logWindow->AppendText(msg);
- if ( s_RptFile ) fprintf(s_RptFile, "%s", CONV_TO_UTF8(msg) );
- }
+ pad = Ratsnest->pad_end;
+ pad->Draw( panel, m_DC, wxPoint( 0, 0 ), draw_mode );
+ pad_name = pad->ReturnStringPadName();
+ module_name = ( (MODULE*) (pad->m_Parent) )->m_Reference->m_Text;
+ msg.Printf( _( "Pad %s (%s) @ %.4f,%.4f\n" ),
+ pad_name.GetData(), module_name.GetData(
+ ), pad->m_Pos.x * convert, pad->m_Pos.y * convert );
+ m_logWindow->AppendText( msg );
+ if( s_RptFile )
+ fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );
+ }
- if ( m_UnconnectedCount ) msg.Printf(_("Active routes: %d\n"), m_UnconnectedCount);
- else msg = _("OK! (No active routes)\n");
- m_logWindow->AppendText(msg);
- if ( s_RptFile ) fprintf(s_RptFile, "%s", CONV_TO_UTF8(msg) );
+ if( m_UnconnectedCount )
+ msg.Printf( _( "Active routes: %d\n" ), m_UnconnectedCount );
+ else
+ msg = _( "OK! (No active routes)\n" );
+ m_logWindow->AppendText( msg );
+ if( s_RptFile )
+ fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );
}
/****************************************************/
-void WinEDA_DrcFrame::TestDrc(wxCommandEvent & event)
+void WinEDA_DrcFrame::TestDrc( wxCommandEvent& event )
/****************************************************/
{
-int errors;
-wxString msg;
-
- if ( ! DrcInProgress )
- {
- if ( m_CreateRptCtrl->IsChecked() ) // Create a file rpt
- {
- s_RptFilename = m_RptFilenameCtrl->GetValue();
- if ( s_RptFilename.IsEmpty() ) OnButtonBrowseRptFileClick( event );
- if ( ! s_RptFilename.IsEmpty() ) s_RptFile = wxFopen(s_RptFilename, wxT("w"));
- else s_RptFile = NULL;
- }
-
- if ( s_RptFile )
- {
- fprintf(s_RptFile, "Drc report for %s\n", CONV_TO_UTF8(m_Parent->m_CurrentScreen->m_FileName) );
- char line[256];
- fprintf(s_RptFile, "Created on %s\n", DateAndTime(line));
- }
+ int errors;
+ wxString msg;
- s_Pad2PadTestOpt = m_Pad2PadTestCtrl->IsChecked();
- s_UnconnectedTestOpt = m_UnconnectedTestCtrl->IsChecked();
- s_ZonesTestOpt = m_ZonesTestCtrl->IsChecked();
- AbortDrc = FALSE;
- m_logWindow->Clear();
- g_DesignSettings.m_TrackClearence =
- ReturnValueFromTextCtrl(*m_SetClearance, m_Parent->m_InternalUnits);
- /* Test DRC errors (clearance errors, bad connections .. */
- errors = m_Parent->Test_DRC(m_DC, m_Pad2PadTestCtrl->IsChecked(), m_ZonesTestCtrl->IsChecked());
- /* Search for active routes (unconnected pads) */
- if ( m_UnconnectedTestCtrl->IsChecked() ) ListUnconnectedPads(event);
- else m_UnconnectedCount = 0;
- if ( errors )
- msg.Printf(_("** End Drc: %d errors **\n"),errors);
- else if ( m_UnconnectedCount == 0 )
- msg = _("** End Drc: No Error **\n");
- m_logWindow->AppendText(msg);
-
- if ( s_RptFile ) fprintf(s_RptFile, "%s", CONV_TO_UTF8(msg) );
-
- if ( s_RptFile )
- {
- msg.Printf( _("Report file <%s> created\n"), s_RptFilename.GetData());
- m_logWindow->AppendText(msg);
- fclose(s_RptFile);
- s_RptFile = NULL;
- }
+ if( !DrcInProgress )
+ {
+ if( m_CreateRptCtrl->IsChecked() ) // Create a file rpt
+ {
+ s_RptFilename = m_RptFilenameCtrl->GetValue();
+ if( s_RptFilename.IsEmpty() )
+ OnButtonBrowseRptFileClick( event );
+ if( !s_RptFilename.IsEmpty() )
+ s_RptFile = wxFopen( s_RptFilename, wxT( "w" ) );
+ else
+ s_RptFile = NULL;
+ }
- }
- else wxBell();
+ if( s_RptFile )
+ {
+ fprintf( s_RptFile, "Drc report for %s\n",
+ CONV_TO_UTF8( m_Parent->m_CurrentScreen->m_FileName ) );
+ char line[256];
+ fprintf( s_RptFile, "Created on %s\n", DateAndTime( line ) );
+ }
+
+ s_Pad2PadTestOpt = m_Pad2PadTestCtrl->IsChecked();
+ s_UnconnectedTestOpt = m_UnconnectedTestCtrl->IsChecked();
+ s_ZonesTestOpt = m_ZonesTestCtrl->IsChecked();
+ AbortDrc = FALSE;
+ m_logWindow->Clear();
+ g_DesignSettings.m_TrackClearence =
+ ReturnValueFromTextCtrl( *m_SetClearance, m_Parent->m_InternalUnits );
+ /* Test DRC errors (clearance errors, bad connections .. */
+ errors = m_Parent->Test_DRC( m_DC, m_Pad2PadTestCtrl->IsChecked(
+ ), m_ZonesTestCtrl->IsChecked() );
+ /* Search for active routes (unconnected pads) */
+ if( m_UnconnectedTestCtrl->IsChecked() )
+ ListUnconnectedPads( event );
+ else
+ m_UnconnectedCount = 0;
+ if( errors )
+ msg.Printf( _( "** End Drc: %d errors **\n" ), errors );
+ else if( m_UnconnectedCount == 0 )
+ msg = _( "** End Drc: No Error **\n" );
+ m_logWindow->AppendText( msg );
+
+ if( s_RptFile )
+ fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );
+
+ if( s_RptFile )
+ {
+ msg.Printf( _( "Report file <%s> created\n" ), s_RptFilename.GetData() );
+ m_logWindow->AppendText( msg );
+ fclose( s_RptFile );
+ s_RptFile = NULL;
+ }
+ }
+ else
+ wxBell();
}
+
/*********************************************************/
-void WinEDA_DrcFrame::DelDRCMarkers(wxCommandEvent & event)
+void WinEDA_DrcFrame::DelDRCMarkers( wxCommandEvent& event )
/*********************************************************/
{
- if ( ! DrcInProgress )
- {
- m_Parent->Erase_Marqueurs();
- m_Parent->DrawPanel->ReDraw(m_DC,TRUE);
- }
- else wxBell();
+ if( !DrcInProgress )
+ {
+ m_Parent->Erase_Marqueurs();
+ m_Parent->DrawPanel->ReDraw( m_DC, TRUE );
+ }
+ else
+ wxBell();
}
+
/******************************************************/
-void WinEDA_PcbFrame::Install_Test_DRC_Frame(wxDC * DC)
+void WinEDA_PcbFrame::Install_Test_DRC_Frame( wxDC* DC )
/******************************************************/
+
/* Test des isolements : teste les isolements des pistes et place un
- marqueur sur les divers segments en defaut
- Principe:
- Appelle la routine drc() pour chaque segment de piste existant
-*/
+ * marqueur sur les divers segments en defaut
+ * Principe:
+ * Appelle la routine drc() pour chaque segment de piste existant
+ */
{
- AbortDrc = FALSE;
- DrcFrame = new WinEDA_DrcFrame(this, DC);
- DrcFrame->ShowModal(); DrcFrame->Destroy();
- DrcFrame = NULL;
+ AbortDrc = FALSE;
+ DrcFrame = new WinEDA_DrcFrame( this, DC );
+ DrcFrame->ShowModal(); DrcFrame->Destroy();
+ DrcFrame = NULL;
}
/************************************************************************/
-int WinEDA_PcbFrame::Test_DRC(wxDC * DC, bool TestPad2Pad, bool TestZone)
+int WinEDA_PcbFrame::Test_DRC( wxDC* DC, bool TestPad2Pad, bool TestZone )
/************************************************************************/
+
/* Test des isolements : teste les isolements des pistes et place un
- marqueur sur les divers segments en defaut
- Principe:
- Appelle la routine drc() pour chaque segment de piste existant
-*/
+ * marqueur sur les divers segments en defaut
+ * Principe:
+ * Appelle la routine drc() pour chaque segment de piste existant
+ */
{
-int ii, jj, old_net;
-int flag_err_Drc;
-TRACK * pt_segm;
-D_PAD * pad;
-MARQUEUR * Marqueur;
-EDA_BaseStruct * PtStruct;
-wxString Line;
-#define PRINT_NB_PAD_POS 42
-#define PRINT_PAD_ERR_POS 48
-#define PRINT_TST_POS 20
-#define PRINT_NB_SEGM_POS 26
-#define PRINT_TRACK_ERR_POS 32
+ int ii, jj, old_net;
+ int flag_err_Drc;
+ TRACK* pt_segm;
+ D_PAD* pad;
+ MARQUEUR* Marqueur;
+ EDA_BaseStruct* PtStruct;
+ wxString Line;
+
+#define PRINT_NB_PAD_POS 42
+#define PRINT_PAD_ERR_POS 48
+#define PRINT_TST_POS 20
+#define PRINT_NB_SEGM_POS 26
+#define PRINT_TRACK_ERR_POS 32
#define PRINT_NB_ZONESEGM_POS 60
-#define PRINT_ZONE_ERR_POS 70
+#define PRINT_ZONE_ERR_POS 70
- DrcInProgress = TRUE;
+ DrcInProgress = TRUE;
ErrorsDRC_Count = 0;
- Compile_Ratsnest(DC, TRUE);
+ Compile_Ratsnest( DC, TRUE );
- MsgPanel->EraseMsgBox();
+ MsgPanel->EraseMsgBox();
- m_CurrentScreen->SetRefreshReq();
+ m_CurrentScreen->SetRefreshReq();
- /* Effacement des anciens marqueurs */
- Erase_Marqueurs();
+ /* Effacement des anciens marqueurs */
+ Erase_Marqueurs();
- if ( TestPad2Pad ) /* Test DRC des pads entre eux */
- {
- Line.Printf( wxT("%d"),m_Pcb->m_NbPads) ;
- Affiche_1_Parametre(this, PRINT_NB_PAD_POS, wxT("NbPad"),Line,RED) ;
- Affiche_1_Parametre(this, PRINT_PAD_ERR_POS, wxT("Pad Err"), wxT("0"), LIGHTRED);
- if ( DrcFrame ) DrcFrame->m_logWindow->AppendText(_("Tst Pad to Pad\n"));
- LISTE_PAD * pad_list_start = CreateSortedPadListByXCoord(m_Pcb);
- LISTE_PAD * pad_list_limit = &pad_list_start[m_Pcb->m_NbPads];
- int max_size = 0;
- LISTE_PAD * pad_list;
- /* Compute the max size of the pads ( used to stop the test) */
- for ( pad_list = pad_list_start; pad_list < pad_list_limit; pad_list++)
- {
- pad = * pad_list;
- if ( pad->m_Rayon > max_size ) max_size = pad->m_Rayon;
- }
- /* Test the pads */
- for ( pad_list = pad_list_start; pad_list < pad_list_limit; pad_list++)
- {
- pad = * pad_list;
- if ( Test_Pad_to_Pads_Drc(this, DC, pad, pad_list, pad_list_limit, max_size, TRUE) == BAD_DRC )
- {
- Marqueur = current_marqueur;
- current_marqueur = NULL;
- if( Marqueur == NULL )
- {
- DisplayError(this, wxT("Test_Drc(): internal err"));
- return ErrorsDRC_Count;
- }
- Line.Printf( wxT("%d"),ErrorsDRC_Count) ;
- Affiche_1_Parametre(this, PRINT_PAD_ERR_POS,wxEmptyString,Line, LIGHTRED);
- Marqueur->Pnext = m_Pcb->m_Drawings;
- Marqueur->Pback = m_Pcb;
+ if( TestPad2Pad ) /* Test DRC des pads entre eux */
+ {
+ Line.Printf( wxT( "%d" ), m_Pcb->m_NbPads );
+ Affiche_1_Parametre( this, PRINT_NB_PAD_POS, wxT( "NbPad" ), Line, RED );
+ Affiche_1_Parametre( this, PRINT_PAD_ERR_POS, wxT( "Pad Err" ), wxT( "0" ), LIGHTRED );
+
+ if( DrcFrame )
+ DrcFrame->m_logWindow->AppendText( _( "Tst Pad to Pad\n" ) );
+
+ LISTE_PAD* pad_list_start = CreateSortedPadListByXCoord( m_Pcb );
+ LISTE_PAD* pad_list_limit = &pad_list_start[m_Pcb->m_NbPads];
+ int max_size = 0;
+ LISTE_PAD* pad_list;
+ /* Compute the max size of the pads ( used to stop the test) */
+ for( pad_list = pad_list_start; pad_list < pad_list_limit; pad_list++ )
+ {
+ pad = *pad_list;
+ if( pad->m_Rayon > max_size )
+ max_size = pad->m_Rayon;
+ }
- PtStruct = m_Pcb->m_Drawings;
- if(PtStruct) PtStruct->Pback = Marqueur;
- m_Pcb->m_Drawings = Marqueur;
- }
- }
- free(pad_list_start);
- }
-
- /* Test track segments */
- Line.Printf( wxT("%d"),m_Pcb->m_NbSegmTrack) ;
- Affiche_1_Parametre(this, PRINT_NB_SEGM_POS,_("SegmNb"),Line,RED) ;
- Affiche_1_Parametre(this, PRINT_TRACK_ERR_POS,_("Track Err"), wxT("0"), LIGHTRED);
- pt_segm = m_Pcb->m_Track;
+ /* Test the pads */
+ for( pad_list = pad_list_start; pad_list < pad_list_limit; pad_list++ )
+ {
+ pad = *pad_list;
+ if( Test_Pad_to_Pads_Drc( this, DC, pad, pad_list, pad_list_limit, max_size,
+ TRUE ) == BAD_DRC )
+ {
+ Marqueur = current_marqueur;
+ current_marqueur = NULL;
+ if( Marqueur == NULL )
+ {
+ DisplayError( this, wxT( "Test_Drc(): internal err" ) );
+ return ErrorsDRC_Count;
+ }
+ Line.Printf( wxT( "%d" ), ErrorsDRC_Count );
+ Affiche_1_Parametre( this, PRINT_PAD_ERR_POS, wxEmptyString, Line, LIGHTRED );
+ Marqueur->Pnext = m_Pcb->m_Drawings;
+ Marqueur->Pback = m_Pcb;
- if ( DrcFrame ) DrcFrame->m_logWindow->AppendText( _("Tst Tracks\n") );
- for( ii = 0, old_net = -1, jj = 0; pt_segm != NULL; pt_segm = (TRACK*)pt_segm->Pnext, ii++, jj--)
- {
- if( pt_segm->Pnext == NULL) break;
- if ( jj == 0 )
- {
- jj = 10;
- wxYield();
- if(AbortDrc)
- {
- AbortDrc = FALSE; break;
- }
- /* Print stats */
- Line.Printf( wxT("%d"),ii);
- Affiche_1_Parametre(this, PRINT_TST_POS, wxT("Test"),Line,CYAN) ;
- }
+ PtStruct = m_Pcb->m_Drawings;
+ if( PtStruct )
+ PtStruct->Pback = Marqueur;
+ m_Pcb->m_Drawings = Marqueur;
+ }
+ }
- if ( old_net != pt_segm->m_NetCode)
- {
- wxString msg;
- jj = 1;
- EQUIPOT * equipot = GetEquipot(m_Pcb, pt_segm->m_NetCode);
- if ( equipot ) msg = equipot->m_Netname + wxT(" ");
- else msg = wxT("<noname>");
- Affiche_1_Parametre(this, 0,_("Netname"),msg, YELLOW);
- old_net = pt_segm->m_NetCode;
- }
+ free( pad_list_start );
+ }
- g_HightLigth_NetCode = pt_segm->m_NetCode;
- flag_err_Drc = Drc(this, DC, pt_segm,(TRACK*)pt_segm->Pnext, 1);
- if(flag_err_Drc == BAD_DRC)
- {
- Marqueur = current_marqueur;
- current_marqueur = NULL;
- if( Marqueur == NULL )
- {
- DisplayError(this, wxT("Test_Drc(): internal err"));
- return ErrorsDRC_Count;
- }
- Marqueur->Pnext = m_Pcb->m_Drawings;
- Marqueur->Pback = m_Pcb;
+ /* Test track segments */
+ Line.Printf( wxT( "%d" ), m_Pcb->m_NbSegmTrack );
+ Affiche_1_Parametre( this, PRINT_NB_SEGM_POS, _( "SegmNb" ), Line, RED );
+ Affiche_1_Parametre( this, PRINT_TRACK_ERR_POS, _( "Track Err" ), wxT( "0" ), LIGHTRED );
+ pt_segm = m_Pcb->m_Track;
- PtStruct = m_Pcb->m_Drawings;
- if(PtStruct) PtStruct->Pback = Marqueur;
- m_Pcb->m_Drawings = Marqueur;
+ if( DrcFrame )
+ DrcFrame->m_logWindow->AppendText( _( "Tst Tracks\n" ) );
+
+ for( ii = 0, old_net = -1, jj = 0;
+ pt_segm != NULL;
+ pt_segm = (TRACK*) pt_segm->Pnext, ii++, jj-- )
+ {
+ if( pt_segm->Pnext == NULL )
+ break;
+ if( jj == 0 )
+ {
+ jj = 10;
+ wxYield();
+ if( AbortDrc )
+ {
+ AbortDrc = FALSE; break;
+ }
+ /* Print stats */
+ Line.Printf( wxT( "%d" ), ii );
+ Affiche_1_Parametre( this, PRINT_TST_POS, wxT( "Test" ), Line, CYAN );
+ }
- GRSetDrawMode(DC, GR_OR);
- pt_segm->Draw(DrawPanel, DC, RED^LIGHTRED );
- Line.Printf( wxT("%d"),ErrorsDRC_Count);
- Affiche_1_Parametre(this, PRINT_TRACK_ERR_POS,wxEmptyString,Line, LIGHTRED);
- }
- }
+ if( old_net != pt_segm->m_NetCode )
+ {
+ wxString msg;
+ jj = 1;
+ EQUIPOT* equipot = GetEquipot( m_Pcb, pt_segm->m_NetCode );
+ if( equipot )
+ msg = equipot->m_Netname + wxT( " " );
+ else
+ msg = wxT( "<noname>" );
+ Affiche_1_Parametre( this, 0, _( "Netname" ), msg, YELLOW );
+ old_net = pt_segm->m_NetCode;
+ }
- /* Test zone segments segments */
- if ( TestZone )
- {
- m_Pcb->m_NbSegmZone = 0;
- for( pt_segm = (TRACK*)m_Pcb->m_Zone; pt_segm != NULL; pt_segm = (TRACK*)pt_segm->Pnext)
- m_Pcb->m_NbSegmZone++;
- Line.Printf( wxT("%d"),m_Pcb->m_NbSegmZone) ;
- Affiche_1_Parametre(this, PRINT_NB_ZONESEGM_POS,_("SegmNb"),Line,RED) ;
- Affiche_1_Parametre(this, PRINT_ZONE_ERR_POS,_("Zone Err"), wxT("0"), LIGHTRED);
+ g_HightLigth_NetCode = pt_segm->m_NetCode;
+ flag_err_Drc = Drc( this, DC, pt_segm, (TRACK*) pt_segm->Pnext, 1 );
+ if( flag_err_Drc == BAD_DRC )
+ {
+ Marqueur = current_marqueur;
+ current_marqueur = NULL;
+ if( Marqueur == NULL )
+ {
+ DisplayError( this, wxT( "Test_Drc(): internal err" ) );
+ return ErrorsDRC_Count;
+ }
+ Marqueur->Pnext = m_Pcb->m_Drawings;
+ Marqueur->Pback = m_Pcb;
- if ( DrcFrame ) DrcFrame->m_logWindow->AppendText( _("Tst Zones\n") );
-
- pt_segm = (TRACK*)m_Pcb->m_Zone;
- for( ii = 0, old_net = -1, jj = 0; pt_segm != NULL; pt_segm = (TRACK*)pt_segm->Pnext, ii++, jj--)
- {
- if( pt_segm->Pnext == NULL) break;
- if ( jj == 0 )
- {
- jj = 100;
- wxYield();
- if(AbortDrc)
- {
- AbortDrc = FALSE; break;
- }
- /* Print stats */
- Line.Printf( wxT("%d"),ii);
- Affiche_1_Parametre(this, PRINT_TST_POS, wxT("Test"),Line,CYAN) ;
- }
+ PtStruct = m_Pcb->m_Drawings;
+ if( PtStruct )
+ PtStruct->Pback = Marqueur;
+ m_Pcb->m_Drawings = Marqueur;
- if ( old_net != pt_segm->m_NetCode)
- {
- jj = 1;
- wxString msg;
- EQUIPOT * equipot = GetEquipot(m_Pcb, pt_segm->m_NetCode);
- if ( equipot ) msg = equipot->m_Netname + wxT(" ");
- else msg = wxT("<noname>");
- Affiche_1_Parametre(this, 0,_("Netname"),msg, YELLOW);
- old_net = pt_segm->m_NetCode;
- }
- g_HightLigth_NetCode = pt_segm->m_NetCode;
- /* Test drc with other zone segments, and pads */
- flag_err_Drc = Drc(this, DC, pt_segm,(TRACK*)pt_segm->Pnext, 1);
- if(flag_err_Drc == BAD_DRC)
- {
- Marqueur = current_marqueur;
- current_marqueur = NULL;
- if( Marqueur == NULL )
- {
- DisplayError(this, wxT("Test_Drc(): internal err"));
- return ErrorsDRC_Count;
- }
- Marqueur->Pnext = m_Pcb->m_Drawings;
- Marqueur->Pback = m_Pcb;
+ GRSetDrawMode( DC, GR_OR );
+ pt_segm->Draw( DrawPanel, DC, RED ^ LIGHTRED );
+ Line.Printf( wxT( "%d" ), ErrorsDRC_Count );
+ Affiche_1_Parametre( this, PRINT_TRACK_ERR_POS, wxEmptyString, Line, LIGHTRED );
+ }
+ }
- PtStruct = m_Pcb->m_Drawings;
- if(PtStruct) PtStruct->Pback = Marqueur;
- m_Pcb->m_Drawings = Marqueur;
+ /* Test zone segments segments */
+ if( TestZone )
+ {
+ m_Pcb->m_NbSegmZone = 0;
+ for( pt_segm = (TRACK*) m_Pcb->m_Zone; pt_segm != NULL; pt_segm = (TRACK*) pt_segm->Pnext )
+ m_Pcb->m_NbSegmZone++;
- GRSetDrawMode(DC, GR_OR);
- pt_segm->Draw(DrawPanel, DC, RED^LIGHTRED );
- Line.Printf( wxT("%d"),ErrorsDRC_Count);
- Affiche_1_Parametre(this, PRINT_ZONE_ERR_POS, wxEmptyString, Line, LIGHTRED);
- }
-
- /* Test drc with track segments */
- int tmp = m_Pcb->m_NbPads; m_Pcb->m_NbPads = 0; // Pads already tested: disable pad test
- flag_err_Drc = Drc(this, DC, pt_segm, m_Pcb->m_Track, 1);
- m_Pcb->m_NbPads = tmp;
- if(flag_err_Drc == BAD_DRC)
- {
- Marqueur = current_marqueur;
- current_marqueur = NULL;
- if( Marqueur == NULL )
- {
- DisplayError(this, wxT("Test_Drc(): internal err"));
- return ErrorsDRC_Count;
- }
- Marqueur->Pnext = m_Pcb->m_Drawings;
- Marqueur->Pback = m_Pcb;
+ Line.Printf( wxT( "%d" ), m_Pcb->m_NbSegmZone );
+ Affiche_1_Parametre( this, PRINT_NB_ZONESEGM_POS, _( "SegmNb" ), Line, RED );
+ Affiche_1_Parametre( this, PRINT_ZONE_ERR_POS, _( "Zone Err" ), wxT( "0" ), LIGHTRED );
- PtStruct = m_Pcb->m_Drawings;
- if(PtStruct) PtStruct->Pback = Marqueur;
- m_Pcb->m_Drawings = Marqueur;
+ if( DrcFrame )
+ DrcFrame->m_logWindow->AppendText( _( "Tst Zones\n" ) );
- GRSetDrawMode(DC, GR_OR);
- pt_segm->Draw(DrawPanel, DC, RED^LIGHTRED );
- Line.Printf( wxT("%d"),ErrorsDRC_Count);
- Affiche_1_Parametre(this, PRINT_ZONE_ERR_POS, wxEmptyString, Line, LIGHTRED);
- }
- }
- }
+ pt_segm = (TRACK*) m_Pcb->m_Zone;
+ for( ii = 0, old_net = -1, jj = 0;
+ pt_segm != NULL;
+ pt_segm = (TRACK*) pt_segm->Pnext, ii++, jj-- )
+ {
+ if( pt_segm->Pnext == NULL )
+ break;
+ if( jj == 0 )
+ {
+ jj = 100;
+ wxYield();
+ if( AbortDrc )
+ {
+ AbortDrc = FALSE; break;
+ }
+ /* Print stats */
+ Line.Printf( wxT( "%d" ), ii );
+ Affiche_1_Parametre( this, PRINT_TST_POS, wxT( "Test" ), Line, CYAN );
+ }
+
+ if( old_net != pt_segm->m_NetCode )
+ {
+ jj = 1;
+ wxString msg;
+ EQUIPOT* equipot = GetEquipot( m_Pcb, pt_segm->m_NetCode );
+ if( equipot )
+ msg = equipot->m_Netname + wxT( " " );
+ else
+ msg = wxT( "<noname>" );
+ Affiche_1_Parametre( this, 0, _( "Netname" ), msg, YELLOW );
+ old_net = pt_segm->m_NetCode;
+ }
+ g_HightLigth_NetCode = pt_segm->m_NetCode;
+ /* Test drc with other zone segments, and pads */
+ flag_err_Drc = Drc( this, DC, pt_segm, (TRACK*) pt_segm->Pnext, 1 );
+ if( flag_err_Drc == BAD_DRC )
+ {
+ Marqueur = current_marqueur;
+ current_marqueur = NULL;
+ if( Marqueur == NULL )
+ {
+ DisplayError( this, wxT( "Test_Drc(): internal err" ) );
+ return ErrorsDRC_Count;
+ }
+ Marqueur->Pnext = m_Pcb->m_Drawings;
+ Marqueur->Pback = m_Pcb;
+
+ PtStruct = m_Pcb->m_Drawings;
+ if( PtStruct )
+ PtStruct->Pback = Marqueur;
+ m_Pcb->m_Drawings = Marqueur;
+
+ GRSetDrawMode( DC, GR_OR );
+ pt_segm->Draw( DrawPanel, DC, RED ^ LIGHTRED );
+ Line.Printf( wxT( "%d" ), ErrorsDRC_Count );
+ Affiche_1_Parametre( this, PRINT_ZONE_ERR_POS, wxEmptyString, Line, LIGHTRED );
+ }
+
+ /* Test drc with track segments */
+ int tmp = m_Pcb->m_NbPads; m_Pcb->m_NbPads = 0; // Pads already tested: disable pad test
+ flag_err_Drc = Drc( this, DC, pt_segm, m_Pcb->m_Track, 1 );
+
+ m_Pcb->m_NbPads = tmp;
+
+ if( flag_err_Drc == BAD_DRC )
+ {
+ Marqueur = current_marqueur;
+ current_marqueur = NULL;
+ if( Marqueur == NULL )
+ {
+ DisplayError( this, wxT( "Test_Drc(): internal err" ) );
+ return ErrorsDRC_Count;
+ }
+ Marqueur->Pnext = m_Pcb->m_Drawings;
+ Marqueur->Pback = m_Pcb;
+
+ PtStruct = m_Pcb->m_Drawings;
+ if( PtStruct )
+ PtStruct->Pback = Marqueur;
+ m_Pcb->m_Drawings = Marqueur;
+
+ GRSetDrawMode( DC, GR_OR );
+ pt_segm->Draw( DrawPanel, DC, RED ^ LIGHTRED );
+ Line.Printf( wxT( "%d" ), ErrorsDRC_Count );
+ Affiche_1_Parametre( this, PRINT_ZONE_ERR_POS, wxEmptyString, Line, LIGHTRED );
+ }
+ }
+ }
- AbortDrc = FALSE;
- DrcInProgress = FALSE;
- return ErrorsDRC_Count;
+ AbortDrc = FALSE;
+ DrcInProgress = FALSE;
+ return ErrorsDRC_Count;
}
/***********************************************************************/
-int Drc(WinEDA_BasePcbFrame *frame, wxDC * DC,
- TRACK * pt_segment, TRACK * StartBuffer, int show_err)
+int Drc( WinEDA_BasePcbFrame* frame, wxDC* DC,
+ TRACK* pt_segment, TRACK* StartBuffer, int show_err )
/***********************************************************************/
+
/*
-Teste le segment en cours de trace:
- pt_segment = pointeur sur segment a controler
- StartBuffer = adresse de la zone des pistes a controler
- (typiquement m_Pcb->m_Track)
- show_err (flag) si 0 pas d'affichage d'erreur sur ecran
- retourne :
- BAD_DRC (1) si Violation DRC
- OK_DRC (0) si OK
-*/
+ * Teste le segment en cours de trace:
+ * pt_segment = pointeur sur segment a controler
+ * StartBuffer = adresse de la zone des pistes a controler
+ * (typiquement m_Pcb->m_Track)
+ * show_err (flag) si 0 pas d'affichage d'erreur sur ecran
+ * retourne :
+ * BAD_DRC (1) si Violation DRC
+ * OK_DRC (0) si OK
+ */
{
-int ii ;
-TRACK * pttrack;
-int x0,y0,xf,yf ; // coord des extremites du segment teste dans le repere modifie
-int dx, dy; // utilise pour calcul des dim x et dim y des segments
-int w_dist;
-int MaskLayer ;
-int net_code_ref;
-int org_X, org_Y; // Origine sur le PCB des axes du repere centre sur
- // l'origine du segment de reference
-wxPoint shape_pos;
+ int ii;
+ TRACK* pttrack;
+ int x0, y0, xf, yf; // coord des extremites du segment teste dans le repere modifie
+ int dx, dy; // utilise pour calcul des dim x et dim y des segments
+ int w_dist;
+ int MaskLayer;
+ int net_code_ref;
+ int org_X, org_Y; // Origine sur le PCB des axes du repere centre sur
+ // l'origine du segment de reference
+ wxPoint shape_pos;
- org_X = pt_segment->m_Start.x; org_Y = pt_segment->m_Start.y ;
- finx = dx = pt_segment->m_End.x - org_X ;
- finy = dy = pt_segment->m_End.y - org_Y ;
- MaskLayer = pt_segment->ReturnMaskLayer();
- net_code_ref = pt_segment->m_NetCode;
+ org_X = pt_segment->m_Start.x; org_Y = pt_segment->m_Start.y;
+ finx = dx = pt_segment->m_End.x - org_X;
+ finy = dy = pt_segment->m_End.y - org_Y;
+ MaskLayer = pt_segment->ReturnMaskLayer();
+ net_code_ref = pt_segment->m_NetCode;
- segm_angle = 0;
- if( dx || dy)
- {
- /* calcul de l'angle d'inclinaison en 0,1 degre */
- segm_angle = ArcTangente(dy,dx);
- /* Calcul de la longueur du segment en segm_long : dx = longueur */
- RotatePoint(&dx, &dy, segm_angle); /* segm_long = longueur, yf = 0 */
- }
+ segm_angle = 0;
+ if( dx || dy )
+ {
+ /* calcul de l'angle d'inclinaison en 0,1 degre */
+ segm_angle = ArcTangente( dy, dx );
+ /* Calcul de la longueur du segment en segm_long : dx = longueur */
+ RotatePoint( &dx, &dy, segm_angle ); /* segm_long = longueur, yf = 0 */
+ }
- /* Ici le segment a ete tourne de segm_angle, et est horizontal, dx > 0 */
- segm_long = dx;
+ /* Ici le segment a ete tourne de segm_angle, et est horizontal, dx > 0 */
+ segm_long = dx;
- /******************************************/
- /* Phase 1 : test DRC track to pads :*/
- /******************************************/
+ /******************************************/
+ /* Phase 1 : test DRC track to pads :*/
+ /******************************************/
- /* calcul de la distance min aux pads : */
- w_dist = (unsigned)(pt_segment->m_Width >> 1 ) ;
- for ( ii = 0 ; ii < frame->m_Pcb->m_NbPads ; ii++)
- {
- D_PAD * pt_pad = frame->m_Pcb->m_Pads[ii];
+ /* calcul de la distance min aux pads : */
+ w_dist = (unsigned) (pt_segment->m_Width >> 1 );
+ for( ii = 0; ii < frame->m_Pcb->m_NbPads; ii++ )
+ {
+ D_PAD* pt_pad = frame->m_Pcb->m_Pads[ii];
- /* Pas de probleme si les pads sont en surface autre que la couche,
- sauf si le trou de percage gene (cas des pastilles perc�es simple
- face sur CI double face */
- if( (pt_pad->m_Masque_Layer & MaskLayer ) == 0 )
- {
- /* We must test the pad hole. In order to use the function "TestClearanceSegmToPad",
- a pseudo pad is used, with a shape and a size like the hole */
- if ( pt_pad->m_Drill.x == 0 ) continue;
- D_PAD pseudo_pad((MODULE*)NULL);
- pseudo_pad.m_Size = pt_pad->m_Drill;
- pseudo_pad.m_Pos = pt_pad->m_Pos;
- pseudo_pad.m_PadShape = pt_pad->m_DrillShape;
- pseudo_pad.m_Orient = pt_pad->m_Orient;
- pseudo_pad.ComputeRayon();
- spot_cX = pseudo_pad.m_Pos.x - org_X;
- spot_cY = pseudo_pad.m_Pos.y - org_Y;
- if( TestClearanceSegmToPad(&pseudo_pad, w_dist, g_DesignSettings.m_TrackClearence) != OK_DRC )
- {
- ErrorsDRC_Count++;
- if( show_err )
- Affiche_Erreur_DRC(frame->DrawPanel, DC,
- frame->m_Pcb, pt_segment,pt_pad,0);
- return(BAD_DRC);
- }
- continue;
- }
+ /* Pas de probleme si les pads sont en surface autre que la couche,
+ * sauf si le trou de percage gene (cas des pastilles perc�s simple
+ * face sur CI double face */
+ if( (pt_pad->m_Masque_Layer & MaskLayer ) == 0 )
+ {
+ /* We must test the pad hole. In order to use the function "TestClearanceSegmToPad",
+ * a pseudo pad is used, with a shape and a size like the hole */
+ if( pt_pad->m_Drill.x == 0 )
+ continue;
+ D_PAD pseudo_pad( (MODULE*) NULL );
- /* Le pad doit faire partie d'un net mais pas de probleme
- si le pad est du meme net */
- if( pt_pad->m_NetCode && (net_code_ref == pt_pad->m_NetCode) )
- continue ;
+ pseudo_pad.m_Size = pt_pad->m_Drill;
+ pseudo_pad.m_Pos = pt_pad->m_Pos;
+ pseudo_pad.m_PadShape = pt_pad->m_DrillShape;
+ pseudo_pad.m_Orient = pt_pad->m_Orient;
+ pseudo_pad.ComputeRayon();
+ spot_cX = pseudo_pad.m_Pos.x - org_X;
+ spot_cY = pseudo_pad.m_Pos.y - org_Y;
+ if( TestClearanceSegmToPad( &pseudo_pad, w_dist,
+ g_DesignSettings.m_TrackClearence ) != OK_DRC )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel, DC,
+ frame->m_Pcb, pt_segment, pt_pad, 0 );
+ return BAD_DRC;
+ }
+ continue;
+ }
- /* Test DRC pour les pads */
+ /* Le pad doit faire partie d'un net mais pas de probleme
+ * si le pad est du meme net */
+ if( pt_pad->m_NetCode && (net_code_ref == pt_pad->m_NetCode) )
+ continue;
+
+ /* Test DRC pour les pads */
shape_pos = pt_pad->ReturnShapePos();
- spot_cX = shape_pos.x - org_X;
- spot_cY = shape_pos.y - org_Y;
- if( TestClearanceSegmToPad(pt_pad, w_dist, g_DesignSettings.m_TrackClearence) == OK_DRC ) continue ;
+ spot_cX = shape_pos.x - org_X;
+ spot_cY = shape_pos.y - org_Y;
+ if( TestClearanceSegmToPad( pt_pad, w_dist, g_DesignSettings.m_TrackClearence ) == OK_DRC )
+ continue;
- /* extremite sur pad ou defaut d'isolation trouve */
- else
- {
- ErrorsDRC_Count++;
- if( show_err )
- Affiche_Erreur_DRC(frame->DrawPanel, DC,
- frame->m_Pcb, pt_segment,pt_pad,1);
- return(BAD_DRC);
- }
- }
+ /* extremite sur pad ou defaut d'isolation trouve */
+ else
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel, DC,
+ frame->m_Pcb, pt_segment, pt_pad, 1 );
+ return BAD_DRC;
+ }
+ }
- /**********************************************/
- /* Phase 2 : test DRC avec les autres pistes :*/
- /**********************************************/
+ /**********************************************/
+ /* Phase 2 : test DRC avec les autres pistes :*/
+ /**********************************************/
- /* Ici le segment de reference est sur l'axe X */
+ /* Ici le segment de reference est sur l'axe X */
- /* Comparaison du segment de reference aux autres segments de piste */
- pttrack = StartBuffer ;
- for ( ;pttrack != NULL ; pttrack = (TRACK*) pttrack->Pnext )
- {
- //pas de probleme si le segment a tester est du meme net:
- if( net_code_ref == pttrack->m_NetCode ) continue ;
- //pas de probleme si le segment a tester est sur une autre couche :
- if( (MaskLayer & pttrack->ReturnMaskLayer() ) == 0 ) continue ;
+ /* Comparaison du segment de reference aux autres segments de piste */
+ pttrack = StartBuffer;
+ for( ; pttrack != NULL; pttrack = (TRACK*) pttrack->Pnext )
+ {
+ //pas de probleme si le segment a tester est du meme net:
+ if( net_code_ref == pttrack->m_NetCode )
+ continue;
- /* calcul de la Distance mini = Isol+ rayon ou demi largeur seg ref
- + rayon ou demi largeur seg a comparer */
- w_dist = pt_segment->m_Width >> 1;
- w_dist += pttrack->m_Width >> 1;
- w_dist += g_DesignSettings.m_TrackClearence;
+ //pas de probleme si le segment a tester est sur une autre couche :
+ if( ( MaskLayer & pttrack->ReturnMaskLayer() ) == 0 )
+ continue;
- /* si le segment de reference est une via, le traitement est ici */
- if ( pt_segment->m_StructType == TYPEVIA )
- {
- int orgx, orgy; // origine du repere d'axe X = segment a comparer
- int angle = 0; // angle du segment a tester;
- orgx = pttrack->m_Start.x; orgy = pttrack->m_Start.y;
- dx = pttrack->m_End.x - orgx ; dy = pttrack->m_End.y - orgy;
- x0 = pt_segment->m_Start.x - orgx ; y0 = pt_segment->m_Start.y - orgy ;
+ /* calcul de la Distance mini = Isol+ rayon ou demi largeur seg ref
+ + rayon ou demi largeur seg a comparer */
+ w_dist = pt_segment->m_Width >> 1;
+ w_dist += pttrack->m_Width >> 1;
+ w_dist += g_DesignSettings.m_TrackClearence;
- if( pttrack->m_StructType == TYPEVIA) /* Tst distance entre 2 vias */
- {
- if( (int)hypot((float)x0,(float)y0) < w_dist )
- {
- ErrorsDRC_Count++;
- if( show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,21);
- return(BAD_DRC) ;
- }
- }
- else /* Tst distance de via a segment */
- {
- /* calcul de l'angle */
- angle = ArcTangente(dy,dx);
+ /* si le segment de reference est une via, le traitement est ici */
+ if( pt_segment->m_StructType == TYPEVIA )
+ {
+ int orgx, orgy; // origine du repere d'axe X = segment a comparer
+ int angle = 0; // angle du segment a tester;
+ orgx = pttrack->m_Start.x; orgy = pttrack->m_Start.y;
+ dx = pttrack->m_End.x - orgx; dy = pttrack->m_End.y - orgy;
+ x0 = pt_segment->m_Start.x - orgx; y0 = pt_segment->m_Start.y - orgy;
- /* Calcul des coord dans le nouveau repere */
- RotatePoint(&dx, &dy, angle);
- RotatePoint(&x0, &y0, angle);
+ if( pttrack->m_StructType == TYPEVIA ) /* Tst distance entre 2 vias */
+ {
+ if( (int) hypot( (float) x0, (float) y0 ) < w_dist )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel,
+ DC,
+ frame->m_Pcb,
+ pt_segment,
+ pttrack,
+ 21 );
+ return BAD_DRC;
+ }
+ }
+ else /* Tst distance de via a segment */
+ {
+ /* calcul de l'angle */
+ angle = ArcTangente( dy, dx );
- if( TestMarginToCircle(x0, y0, w_dist, dx) == BAD_DRC )
- {
- ErrorsDRC_Count++;
- if(show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,20);
- return(BAD_DRC) ;
- }
- }
- continue;
- }
+ /* Calcul des coord dans le nouveau repere */
+ RotatePoint( &dx, &dy, angle );
+ RotatePoint( &x0, &y0, angle );
- /* calcule x0,y0, xf,yf = coord de debut et fin du segment de piste
- a tester, dans le repere axe X = segment de reference */
- x0 = pttrack->m_Start.x - org_X ; y0 = pttrack->m_Start.y - org_Y ;
- xf = pttrack->m_End.x - org_X ; yf = pttrack->m_End.y - org_Y ;
+ if( TestMarginToCircle( x0, y0, w_dist, dx ) == BAD_DRC )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel,
+ DC,
+ frame->m_Pcb,
+ pt_segment,
+ pttrack,
+ 20 );
+ return BAD_DRC;
+ }
+ }
+ continue;
+ }
- RotatePoint(&x0, &y0, segm_angle); RotatePoint(&xf, &yf, segm_angle);
+ /* calcule x0,y0, xf,yf = coord de debut et fin du segment de piste
+ * a tester, dans le repere axe X = segment de reference */
+ x0 = pttrack->m_Start.x - org_X; y0 = pttrack->m_Start.y - org_Y;
+ xf = pttrack->m_End.x - org_X; yf = pttrack->m_End.y - org_Y;
- if ( pttrack->m_StructType == TYPEVIA )
- {
- if( TestMarginToCircle(x0, y0,w_dist,segm_long) == OK_DRC) continue;
- ErrorsDRC_Count++;
- if(show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,21);
- return(BAD_DRC) ;
- }
+ RotatePoint( &x0, &y0, segm_angle ); RotatePoint( &xf, &yf, segm_angle );
+
+ if( pttrack->m_StructType == TYPEVIA )
+ {
+ if( TestMarginToCircle( x0, y0, w_dist, segm_long ) == OK_DRC )
+ continue;
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pt_segment, pttrack, 21 );
+ return BAD_DRC;
+ }
- /*
- le segment de reference est Horizontal, par suite des modifs d'axe.
- 3 cas : segment a comparer parallele, perp ou incline
- */
- if ( y0 == yf ) // segments paralleles
- {
- if ( abs(y0) >= w_dist ) continue ;
- if ( x0 > xf) EXCHG (x0,xf) ; /* pour que x0 <= xf */
+ /*
+ * le segment de reference est Horizontal, par suite des modifs d'axe.
+ * 3 cas : segment a comparer parallele, perp ou incline
+ */
+ if( y0 == yf ) // segments paralleles
+ {
+ if( abs( y0 ) >= w_dist )
+ continue;
+ if( x0 > xf )
+ EXCHG( x0, xf ); /* pour que x0 <= xf */
- if ( x0 > (-w_dist) && x0 < (segm_long + w_dist)) /* Risque de defaut */
- {
- /* test fin tenant compte des formes arrondies des extremites */
- if ( x0 >= 0 && x0 <= segm_long )
- {
- ErrorsDRC_Count++;
- if ( show_err )
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,2);
- return(BAD_DRC) ;
- }
- if( TestMarginToCircle(x0, y0, w_dist,segm_long) == BAD_DRC)
- {
- ErrorsDRC_Count++;
- if(show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,2);
- return(BAD_DRC) ;
- }
- }
- if ( xf > (-w_dist) && xf < (segm_long + w_dist))
- {
- /* test fin tenant compte des formes arrondies des extremites */
- if ( xf >= 0 && xf <= segm_long )
- {
- ErrorsDRC_Count++;
- if(show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,3);
- return(BAD_DRC) ;
- }
- if( TestMarginToCircle(xf, yf, w_dist,segm_long) == BAD_DRC)
- {
- ErrorsDRC_Count++;
- if(show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,3);
- return(BAD_DRC) ;
- }
- }
+ if( x0 > (-w_dist) && x0 < (segm_long + w_dist) ) /* Risque de defaut */
+ {
+ /* test fin tenant compte des formes arrondies des extremites */
+ if( x0 >= 0 && x0 <= segm_long )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel,
+ DC,
+ frame->m_Pcb,
+ pt_segment,
+ pttrack,
+ 2 );
+ return BAD_DRC;
+ }
+ if( TestMarginToCircle( x0, y0, w_dist, segm_long ) == BAD_DRC )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel,
+ DC,
+ frame->m_Pcb,
+ pt_segment,
+ pttrack,
+ 2 );
+ return BAD_DRC;
+ }
+ }
+ if( xf > (-w_dist) && xf < (segm_long + w_dist) )
+ {
+ /* test fin tenant compte des formes arrondies des extremites */
+ if( xf >= 0 && xf <= segm_long )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel,
+ DC,
+ frame->m_Pcb,
+ pt_segment,
+ pttrack,
+ 3 );
+ return BAD_DRC;
+ }
+ if( TestMarginToCircle( xf, yf, w_dist, segm_long ) == BAD_DRC )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel,
+ DC,
+ frame->m_Pcb,
+ pt_segment,
+ pttrack,
+ 3 );
+ return BAD_DRC;
+ }
+ }
- if ( x0 <=0 && xf >= 0 )
- {
- ErrorsDRC_Count++;
- if(show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,4);
- return(BAD_DRC) ;
- }
- }
+ if( x0 <=0 && xf >= 0 )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pt_segment, pttrack, 4 );
+ return BAD_DRC;
+ }
+ }
+ else if( x0 == xf ) // segments perpendiculaires
+ {
+ if( ( x0 <= (-w_dist) ) || ( x0 >= (segm_long + w_dist) ) )
+ continue;
- else if ( x0 == xf ) // segments perpendiculaires
- {
- if ( (x0 <= (-w_dist)) || (x0 >= (segm_long + w_dist))) continue ;
+ /* test si les segments se croisent */
+ if( y0 > yf )
+ EXCHG( y0, yf );
+ if( (y0 < 0) && (yf > 0) )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pt_segment, pttrack, 6 );
+ return BAD_DRC;
+ }
- /* test si les segments se croisent */
- if( y0 > yf ) EXCHG(y0, yf);
- if( (y0 < 0) && (yf > 0) )
- {
- ErrorsDRC_Count++;
- if( show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,6);
- return(BAD_DRC);
- }
+ /* ici l'erreur est due a une extremite pres d'une extremite du segm
+ * de reference */
+ if( TestMarginToCircle( x0, y0, w_dist, segm_long ) == BAD_DRC )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pt_segment, pttrack, 7 );
+ return BAD_DRC;
+ }
+ if( TestMarginToCircle( xf, yf, w_dist, segm_long ) == BAD_DRC )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pt_segment, pttrack, 8 );
+ return BAD_DRC;
+ }
+ }
+ else // segments quelconques entre eux */
+ {
+ int bflag = OK_DRC;
+ /* calcul de la "surface de securite du segment de reference */
+ /* premiere passe : la piste est assimilee a un rectangle */
- /* ici l'erreur est due a une extremite pres d'une extremite du segm
- de reference */
- if(TestMarginToCircle(x0,y0,w_dist,segm_long) == BAD_DRC)
- {
- ErrorsDRC_Count++;
- if(show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,7);
- return(BAD_DRC) ;
- }
- if(TestMarginToCircle(xf,yf,w_dist,segm_long) == BAD_DRC)
- {
- ErrorsDRC_Count++;
- if(show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,8);
- return(BAD_DRC) ;
- }
- }
- else // segments quelconques entre eux */
- {
- int bflag = OK_DRC;
- /* calcul de la "surface de securite du segment de reference */
- /* premiere passe : la piste est assimilee a un rectangle */
+ xcliplo = ycliplo = -w_dist;
+ xcliphi = segm_long + w_dist; ycliphi = w_dist;
- xcliplo = ycliplo = -w_dist;
- xcliphi = segm_long + w_dist; ycliphi = w_dist;
+ bflag = Tst_Ligne( x0, y0, xf, yf );
+ if( bflag == BAD_DRC )
+ {
+ /* 2eme passe : la piste a des extremites arrondies.
+ * Si le defaut de drc est du a une extremite : le calcul
+ * est affine pour tenir compte de cet arrondi */
- bflag = Tst_Ligne(x0,y0,xf,yf);
- if (bflag == BAD_DRC)
- {
- /* 2eme passe : la piste a des extremites arrondies.
- Si le defaut de drc est du a une extremite : le calcul
- est affine pour tenir compte de cet arrondi */
+ xcliplo = 0; xcliphi = segm_long;
+ bflag = Tst_Ligne( x0, y0, xf, yf );
- xcliplo = 0 ; xcliphi = segm_long ;
- bflag = Tst_Ligne(x0,y0,xf,yf) ;
+ if( bflag == BAD_DRC )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel,
+ DC,
+ frame->m_Pcb,
+ pt_segment,
+ pttrack,
+ 9 );
+ return BAD_DRC;
+ }
+ else // L'erreur est due a une extremite du segment de reference:
+ {
+ // il faut tester les extremites de ce segment
+ int angle, rx0, ry0, rxf, ryf;
+ x0 = pttrack->m_Start.x; y0 = pttrack->m_Start.y;
+ xf = pttrack->m_End.x; yf = pttrack->m_End.y;
+ dx = xf - x0; dy = yf - y0;
+ /* calcul de l'angle d'inclinaison en 0,1 degre */
+ angle = ArcTangente( dy, dx );
+ /* Calcul de la longueur du segment: dx = longueur */
+ RotatePoint( &dx, &dy, angle );
- if(bflag == BAD_DRC)
- {
- ErrorsDRC_Count++;
- if(show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,9);
- return(BAD_DRC) ;
- }
+ /* calcul des coord du segment de reference ds le repere
+ * d'axe X = segment courant en tst */
+ rx0 = pt_segment->m_Start.x - x0;
+ ry0 = pt_segment->m_Start.y - y0;
+ rxf = pt_segment->m_End.x - x0;
+ ryf = pt_segment->m_End.y - y0;
- else // L'erreur est due a une extremite du segment de reference:
- { // il faut tester les extremites de ce segment
- int angle, rx0,ry0,rxf,ryf;
- x0 = pttrack->m_Start.x; y0 = pttrack->m_Start.y;
- xf = pttrack->m_End.x; yf = pttrack->m_End.y;
- dx = xf - x0; dy = yf - y0;
- /* calcul de l'angle d'inclinaison en 0,1 degre */
- angle = ArcTangente(dy,dx);
- /* Calcul de la longueur du segment: dx = longueur */
- RotatePoint(&dx, &dy, angle);
+ RotatePoint( &rx0, &ry0, angle );
+ RotatePoint( &rxf, &ryf, angle );
+ if( TestMarginToCircle( rx0, ry0, w_dist, dx ) == BAD_DRC )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel,
+ DC,
+ frame->m_Pcb,
+ pt_segment,
+ pttrack,
+ 10 );
+ return BAD_DRC;
+ }
+ if( TestMarginToCircle( rxf, ryf, w_dist, dx ) == BAD_DRC )
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel,
+ DC,
+ frame->m_Pcb,
+ pt_segment,
+ pttrack,
+ 11 );
+ return BAD_DRC;
+ }
+ }
+ }
+ }
+ }
- /* calcul des coord du segment de reference ds le repere
- d'axe X = segment courant en tst */
- rx0 = pt_segment->m_Start.x - x0;
- ry0 = pt_segment->m_Start.y - y0;
- rxf = pt_segment->m_End.x - x0;
- ryf = pt_segment->m_End.y - y0;
-
- RotatePoint(&rx0,&ry0, angle);
- RotatePoint(&rxf,&ryf, angle);
- if(TestMarginToCircle(rx0,ry0,w_dist,dx) == BAD_DRC)
- {
- ErrorsDRC_Count++;
- if(show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,10);
- return(BAD_DRC) ;
- }
- if(TestMarginToCircle(rxf,ryf,w_dist,dx) == BAD_DRC)
- {
- ErrorsDRC_Count++;
- if(show_err)
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pt_segment,pttrack,11);
- return(BAD_DRC) ;
- }
- }
- }
- }
- }
- return(OK_DRC) ;
+ return OK_DRC;
}
+
/*****************************************************************************/
-static bool Test_Pad_to_Pads_Drc(WinEDA_BasePcbFrame *frame, wxDC * DC, D_PAD * pad_ref,
- LISTE_PAD * start_buffer, LISTE_PAD * end_buffer, int max_size, bool show_err)
+static bool Test_Pad_to_Pads_Drc( WinEDA_BasePcbFrame* frame,
+ wxDC* DC,
+ D_PAD* pad_ref,
+ LISTE_PAD* start_buffer,
+ LISTE_PAD* end_buffer,
+ int max_size,
+ bool show_err )
/*****************************************************************************/
+
/* Teste l'isolation de pad_ref avec les autres pads.
- end_buffer = upper limit of the pad list.
- max_size = size of the biggest pad (used to stop the test when the X distance is > max_size)
-*/
+ * end_buffer = upper limit of the pad list.
+ * max_size = size of the biggest pad (used to stop the test when the X distance is > max_size)
+ */
{
-int MaskLayer;
-D_PAD * pad;
-LISTE_PAD * pad_list = start_buffer;
-
- MaskLayer = pad_ref->m_Masque_Layer & ALL_CU_LAYERS;
- int x_limite = max_size + g_DesignSettings.m_TrackClearence +
- pad_ref->m_Rayon + pad_ref->m_Pos.x;
- for ( ; pad_list < end_buffer ; pad_list++)
- {
- pad = * pad_list;
- if ( pad == pad_ref ) continue;
-
- /* We can stop the test when pad->m_Pos.x > x_limite
- because the list is sorted by X values */
- if ( pad->m_Pos.x > x_limite ) break;
+ int MaskLayer;
+ D_PAD* pad;
+ LISTE_PAD* pad_list = start_buffer;
- /* Pas de probleme si les pads ne sont pas sur les memes couches cuivre*/
- if( (pad->m_Masque_Layer & MaskLayer ) == 0 ) continue;
+ MaskLayer = pad_ref->m_Masque_Layer & ALL_CU_LAYERS;
+ int x_limite = max_size + g_DesignSettings.m_TrackClearence +
+ pad_ref->m_Rayon + pad_ref->m_Pos.x;
+ for( ; pad_list < end_buffer; pad_list++ )
+ {
+ pad = *pad_list;
+ if( pad == pad_ref )
+ continue;
- /* Le pad doit faire partie d'un net,
- mais pas de probleme si les pads sont du meme net */
- if( pad->m_NetCode && (pad_ref->m_NetCode == pad->m_NetCode) )
- continue ;
+ /* We can stop the test when pad->m_Pos.x > x_limite
+ * because the list is sorted by X values */
+ if( pad->m_Pos.x > x_limite )
+ break;
- /* pas de pb si les pads sont du meme module et
- de la meme reference ( pads multiples ) */
- if ( (pad->m_Parent == pad_ref->m_Parent) && (pad->m_NumPadName == pad_ref->m_NumPadName) )
- continue;
+ /* Pas de probleme si les pads ne sont pas sur les memes couches cuivre*/
+ if( (pad->m_Masque_Layer & MaskLayer ) == 0 )
+ continue;
- if( Pad_to_Pad_Isol(pad_ref, pad, g_DesignSettings.m_TrackClearence) == OK_DRC ) continue ;
- else /* defaut d'isolation trouve */
- {
- ErrorsDRC_Count++;
- if( show_err )
- Affiche_Erreur_DRC(frame->DrawPanel, DC, frame->m_Pcb, pad_ref, pad);
- return(BAD_DRC);
- }
- }
- return OK_DRC;
+ /* Le pad doit faire partie d'un net,
+ * mais pas de probleme si les pads sont du meme net */
+ if( pad->m_NetCode && (pad_ref->m_NetCode == pad->m_NetCode) )
+ continue;
+
+ /* pas de pb si les pads sont du meme module et
+ * de la meme reference ( pads multiples ) */
+ if( (pad->m_Parent == pad_ref->m_Parent) && (pad->m_NumPadName == pad_ref->m_NumPadName) )
+ continue;
+
+ if( Pad_to_Pad_Isol( pad_ref, pad, g_DesignSettings.m_TrackClearence ) == OK_DRC )
+ continue;
+ else /* defaut d'isolation trouve */
+ {
+ ErrorsDRC_Count++;
+ if( show_err )
+ Affiche_Erreur_DRC( frame->DrawPanel, DC, frame->m_Pcb, pad_ref, pad );
+ return BAD_DRC;
+ }
+ }
+
+ return OK_DRC;
}
+
/**************************************************************************************/
-static int Pad_to_Pad_Isol(D_PAD * pad_ref, D_PAD * pad, const int dist_min)
+static int Pad_to_Pad_Isol( D_PAD* pad_ref, D_PAD* pad, const int dist_min )
/***************************************************************************************/
+
/* Return OK_DRC si clearance between pad_ref and pad is >= dist_min
- or BAD_DRC if not */
+ * or BAD_DRC if not */
{
-wxPoint rel_pos;
-int dist, diag;
-wxPoint shape_pos;
-int pad_angle;
-
- rel_pos = pad->ReturnShapePos();
+ wxPoint rel_pos;
+ int dist, diag;
+ wxPoint shape_pos;
+ int pad_angle;
+
+ rel_pos = pad->ReturnShapePos();
shape_pos = pad_ref->ReturnShapePos();
- // rel_pos is pad position relative to the pad_ref position
- rel_pos.x -= shape_pos.x;
- rel_pos.y -= shape_pos.y;
- dist = (int) hypot( (double) rel_pos.x, (double) rel_pos.y);
- diag = OK_DRC;
+ // rel_pos is pad position relative to the pad_ref position
+ rel_pos.x -= shape_pos.x;
+ rel_pos.y -= shape_pos.y;
+ dist = (int) hypot( (double) rel_pos.x, (double) rel_pos.y );
- /* tst rapide: si les cercles exinscrits sont distants de dist_min au moins,
- il n'y a pas de risque: */
- if ( (dist - pad_ref->m_Rayon - pad->m_Rayon) >= dist_min )
- return OK_DRC;
+ diag = OK_DRC;
- /* Ici les pads sont proches et les cercles exinxcrits sont trop proches
- Selon les formes relatives il peut y avoir ou non erreur */
-
- bool swap_pads = false;
- if ( (pad_ref->m_PadShape != CIRCLE) && (pad->m_PadShape == CIRCLE) )
- swap_pads = true;
- else if ( (pad_ref->m_PadShape != OVALE) && (pad->m_PadShape == OVALE) )
- swap_pads = true;
-
- if ( swap_pads )
- {
- EXCHG (pad_ref, pad);
- rel_pos.x = - rel_pos.x;
- rel_pos.y = - rel_pos.y;
- }
-
- switch (pad_ref->m_PadShape)
- {
- case CIRCLE: // pad_ref is like a track segment with a null lenght
- segm_long = 0;
- segm_angle = 0;
- finx = finy = 0;
- spot_cX = rel_pos.x;
- spot_cY = rel_pos.y;
- diag = TestClearanceSegmToPad(pad, pad_ref->m_Rayon, dist_min );
- break;
+ /* tst rapide: si les cercles exinscrits sont distants de dist_min au moins,
+ * il n'y a pas de risque: */
+ if( (dist - pad_ref->m_Rayon - pad->m_Rayon) >= dist_min )
+ return OK_DRC;
- case RECT:
- RotatePoint(&rel_pos.x, &rel_pos.y, pad_ref->m_Orient);
- pad_angle = pad_ref->m_Orient + pad->m_Orient; // pad_angle = pad orient relative to the pad_ref orient
- NORMALIZE_ANGLE_POS(pad_angle);
- if ( pad->m_PadShape == RECT )
- {
- wxSize size = pad->m_Size;
- if ( (pad_angle == 0) || (pad_angle == 900) || (pad_angle == 1800) || (pad_angle == 2700))
- {
- if ( (pad_angle == 900) || (pad_angle == 2700) )
- {
- EXCHG(size.x, size.y );
- }
- // Test DRC:
- diag = BAD_DRC;
- rel_pos.x = ABS(rel_pos.x); rel_pos.y = ABS(rel_pos.y);
- if ( (rel_pos.x - ((size.x + pad_ref->m_Size.x)/2) ) >= dist_min )
- diag = OK_DRC;
- if ( (rel_pos.y - ((size.y + pad_ref->m_Size.y)/2) ) >= dist_min )
- diag = OK_DRC;
- }
-
- else // Any other orient
- { /* TODO : any orient ... */
- }
- }
- break;
+ /* Ici les pads sont proches et les cercles exinxcrits sont trop proches
+ * Selon les formes relatives il peut y avoir ou non erreur */
- case OVALE: /* an oval pad is like a track segment */
- {
- /* Create and test a track segment with same dimensions */
- int segm_width;
- segm_angle = pad_ref->m_Orient; // Segment orient.
- if ( pad_ref->m_Size.y < pad_ref->m_Size.x ) /* We suppose the pad is an horizontal oval */
- {
- segm_width = pad_ref->m_Size.y;
- segm_long = pad_ref->m_Size.x - pad_ref->m_Size.y;
- }
- else // it was a vertical oval, change to a rotated horizontal one
- {
- segm_width = pad_ref->m_Size.x;
- segm_long = pad_ref->m_Size.y - pad_ref->m_Size.x;
- segm_angle += 900;
- }
- /* the start point must be 0,0 and currently rel_pos is relative the center of pad coordinate */
- int sx = - segm_long /2, sy = 0; // Start point coordinate of the horizontal equivalent segment
- RotatePoint(&sx, &sy, segm_angle); // True start point coordinate of the equivalent segment
- spot_cX = rel_pos.x + sx;
- spot_cY = rel_pos.y + sy; // pad position / segment origin
- finx = - sx;
- finy = - sy; // end of segment coordinate
- diag = TestClearanceSegmToPad(pad, segm_width/2, dist_min);
- break;
- }
+ bool swap_pads = false;
+ if( (pad_ref->m_PadShape != CIRCLE) && (pad->m_PadShape == CIRCLE) )
+ swap_pads = true;
+ else if( (pad_ref->m_PadShape != OVALE) && (pad->m_PadShape == OVALE) )
+ swap_pads = true;
- default:
- /* TODO...*/
- break;
- }
- return diag;
+ if( swap_pads )
+ {
+ EXCHG( pad_ref, pad );
+ rel_pos.x = -rel_pos.x;
+ rel_pos.y = -rel_pos.y;
+ }
+
+ switch( pad_ref->m_PadShape )
+ {
+ case CIRCLE: // pad_ref is like a track segment with a null lenght
+ segm_long = 0;
+ segm_angle = 0;
+ finx = finy = 0;
+ spot_cX = rel_pos.x;
+ spot_cY = rel_pos.y;
+ diag = TestClearanceSegmToPad( pad, pad_ref->m_Rayon, dist_min );
+ break;
+
+ case RECT:
+ RotatePoint( &rel_pos.x, &rel_pos.y, pad_ref->m_Orient );
+ pad_angle = pad_ref->m_Orient + pad->m_Orient; // pad_angle = pad orient relative to the pad_ref orient
+ NORMALIZE_ANGLE_POS( pad_angle );
+ if( pad->m_PadShape == RECT )
+ {
+ wxSize size = pad->m_Size;
+ if( (pad_angle == 0) || (pad_angle == 900) || (pad_angle == 1800) ||
+ (pad_angle == 2700) )
+ {
+ if( (pad_angle == 900) || (pad_angle == 2700) )
+ {
+ EXCHG( size.x, size.y );
+ }
+
+ // Test DRC:
+ diag = BAD_DRC;
+ rel_pos.x = ABS( rel_pos.x ); rel_pos.y = ABS( rel_pos.y );
+ if( ( rel_pos.x - ( (size.x + pad_ref->m_Size.x) / 2 ) ) >= dist_min )
+ diag = OK_DRC;
+ if( ( rel_pos.y - ( (size.y + pad_ref->m_Size.y) / 2 ) ) >= dist_min )
+ diag = OK_DRC;
+ }
+ else // Any other orient
+ {
+ /* TODO : any orient ... */
+ }
+ }
+ break;
+
+ case OVALE: /* an oval pad is like a track segment */
+ {
+ /* Create and test a track segment with same dimensions */
+ int segm_width;
+ segm_angle = pad_ref->m_Orient; // Segment orient.
+ if( pad_ref->m_Size.y < pad_ref->m_Size.x ) /* We suppose the pad is an horizontal oval */
+ {
+ segm_width = pad_ref->m_Size.y;
+ segm_long = pad_ref->m_Size.x - pad_ref->m_Size.y;
+ }
+ else // it was a vertical oval, change to a rotated horizontal one
+ {
+ segm_width = pad_ref->m_Size.x;
+ segm_long = pad_ref->m_Size.y - pad_ref->m_Size.x;
+ segm_angle += 900;
+ }
+ /* the start point must be 0,0 and currently rel_pos is relative the center of pad coordinate */
+ int sx = -segm_long / 2, sy = 0; // Start point coordinate of the horizontal equivalent segment
+ RotatePoint( &sx, &sy, segm_angle ); // True start point coordinate of the equivalent segment
+ spot_cX = rel_pos.x + sx;
+ spot_cY = rel_pos.y + sy; // pad position / segment origin
+ finx = -sx;
+ finy = -sy; // end of segment coordinate
+ diag = TestClearanceSegmToPad( pad, segm_width / 2, dist_min );
+ break;
+ }
+
+ default:
+ /* TODO...*/
+ break;
+ }
+
+ return diag;
}
+
/***************************************************************************/
-static int TestClearanceSegmToPad(const D_PAD* pad_to_test, int w_segm, int dist_min)
+static int TestClearanceSegmToPad( const D_PAD* pad_to_test, int w_segm, int dist_min )
/****************************************************************************/
+
/*
- Routine adaptee de la "distance()" (LOCATE.CPP)
- teste la distance du pad au segment de droite en cours
-
- retourne:
- 0 si distance >= dist_min
- 1 si distance < dist_min
- Parametres d'appel:
- pad_to_test = pointeur sur le pad a tester
- w_segm = demi largeur du segment a tester
- dist_min = marge a respecter
-
- en variables globales
- segm_long = longueur du segment en test
- segm_angle = angle d'inclinaison du segment;
- finx, finy = coord fin du segment / origine
- spot_cX, spot_cY = position du pad / origine du segment
-*/
+ * Routine adaptee de la "distance()" (LOCATE.CPP)
+ * teste la distance du pad au segment de droite en cours
+ *
+ * retourne:
+ * 0 si distance >= dist_min
+ * 1 si distance < dist_min
+ * Parametres d'appel:
+ * pad_to_test = pointeur sur le pad a tester
+ * w_segm = demi largeur du segment a tester
+ * dist_min = marge a respecter
+ *
+ * en variables globales
+ * segm_long = longueur du segment en test
+ * segm_angle = angle d'inclinaison du segment;
+ * finx, finy = coord fin du segment / origine
+ * spot_cX, spot_cY = position du pad / origine du segment
+ */
{
-int p_dimx, p_dimy ; /* demi - dimensions X et Y du pad a controler */
-int bflag;
-int orient;
-int x0, y0, xf, yf ;
-int seuil;
-int deltay;
+ int p_dimx, p_dimy; /* demi - dimensions X et Y du pad a controler */
+ int bflag;
+ int orient;
+ int x0, y0, xf, yf;
+ int seuil;
+ int deltay;
- seuil = w_segm + dist_min;
- p_dimx = pad_to_test->m_Size.x >> 1 ;
- p_dimy = pad_to_test->m_Size.y >> 1 ;
+ seuil = w_segm + dist_min;
+ p_dimx = pad_to_test->m_Size.x >> 1;
+ p_dimy = pad_to_test->m_Size.y >> 1;
- if (pad_to_test->m_PadShape == CIRCLE )
- {
- /* calcul des coord centre du pad dans le repere axe X confondu
- avec le segment en tst */
- RotatePoint(&spot_cX, &spot_cY, segm_angle);
- return (TestMarginToCircle(spot_cX, spot_cY, seuil+p_dimx, segm_long));
- }
- else
- {
- /* calcul de la "surface de securite" du pad de reference */
- xcliplo = spot_cX - seuil - p_dimx ;
- ycliplo = spot_cY - seuil - p_dimy;
- xcliphi = spot_cX + seuil + p_dimx;
- ycliphi = spot_cY + seuil + p_dimy;
- x0 = y0 = 0 ; xf = finx; yf = finy ;
- orient = pad_to_test->m_Orient;
- RotatePoint(&x0,&y0,spot_cX, spot_cY, -orient);
- RotatePoint(&xf,&yf,spot_cX, spot_cY, -orient);
+ if( pad_to_test->m_PadShape == CIRCLE )
+ {
+ /* calcul des coord centre du pad dans le repere axe X confondu
+ * avec le segment en tst */
+ RotatePoint( &spot_cX, &spot_cY, segm_angle );
+ return TestMarginToCircle( spot_cX, spot_cY, seuil + p_dimx, segm_long );
+ }
+ else
+ {
+ /* calcul de la "surface de securite" du pad de reference */
+ xcliplo = spot_cX - seuil - p_dimx;
+ ycliplo = spot_cY - seuil - p_dimy;
+ xcliphi = spot_cX + seuil + p_dimx;
+ ycliphi = spot_cY + seuil + p_dimy;
+
+ x0 = y0 = 0;
+
+ xf = finx;
+ yf = finy;
+
+ orient = pad_to_test->m_Orient;
+
+ RotatePoint( &x0, &y0, spot_cX, spot_cY, -orient );
+ RotatePoint( &xf, &yf, spot_cX, spot_cY, -orient );
- bflag = Tst_Ligne(x0,y0,xf,yf) ;
+ bflag = Tst_Ligne( x0, y0, xf, yf );
- if (bflag == OK_DRC) return (OK_DRC);
- /* Erreur DRC : analyse fine de la forme de la pastille */
+ if( bflag == OK_DRC )
+ return OK_DRC;
+ /* Erreur DRC : analyse fine de la forme de la pastille */
- switch (pad_to_test->m_PadShape )
- {
- default: return(BAD_DRC);
+ switch( pad_to_test->m_PadShape )
+ {
+ default:
+ return BAD_DRC;
- case OVALE :
- /* test de la pastille ovale ramenee au type ovale vertical */
- if (p_dimx > p_dimy)
- {
- EXCHG(p_dimx,p_dimy); orient += 900;
- if(orient >= 3600) orient -=3600;
- }
- deltay = p_dimy - p_dimx;
- /* ici: p_dimx = rayon,
- delta = dist centre cercles a centre pad */
+ case OVALE:
+ /* test de la pastille ovale ramenee au type ovale vertical */
+ if( p_dimx > p_dimy )
+ {
+ EXCHG( p_dimx, p_dimy ); orient += 900;
+ if( orient >= 3600 )
+ orient -= 3600;
+ }
+ deltay = p_dimy - p_dimx;
- /* Test du rectangle separant les 2 demi cercles */
- xcliplo = spot_cX - seuil - p_dimx;
- ycliplo = spot_cY - w_segm - deltay;
- xcliphi = spot_cX + seuil + p_dimx;
- ycliphi = spot_cY + w_segm + deltay;
+ /* ici: p_dimx = rayon,
+ * delta = dist centre cercles a centre pad */
- bflag = Tst_Ligne(x0,y0,xf,yf);
- if (bflag == BAD_DRC) return(BAD_DRC);
+ /* Test du rectangle separant les 2 demi cercles */
+ xcliplo = spot_cX - seuil - p_dimx;
+ ycliplo = spot_cY - w_segm - deltay;
+ xcliphi = spot_cX + seuil + p_dimx;
+ ycliphi = spot_cY + w_segm + deltay;
- /* test des 2 cercles */
- x0 = spot_cX; /* x0,y0 = centre du cercle superieur du pad ovale */
- y0 = spot_cY + deltay;
- RotatePoint(&x0,&y0, spot_cX, spot_cY, orient);
- RotatePoint(&x0,&y0, segm_angle);
- bflag = TestMarginToCircle(x0,y0,p_dimx + seuil, segm_long);
- if( bflag == BAD_DRC) return(BAD_DRC);
+ bflag = Tst_Ligne( x0, y0, xf, yf );
+ if( bflag == BAD_DRC )
+ return BAD_DRC;
- x0 = spot_cX; /* x0,y0 = centre du cercle inferieur du pad ovale */
- y0 = spot_cY - deltay;
- RotatePoint(&x0,&y0, spot_cX, spot_cY, orient);
- RotatePoint(&x0,&y0, segm_angle);
- bflag = TestMarginToCircle(x0,y0,p_dimx + seuil, segm_long);
- if( bflag == BAD_DRC) return(BAD_DRC);
- break;
+ /* test des 2 cercles */
+ x0 = spot_cX; /* x0,y0 = centre du cercle superieur du pad ovale */
+ y0 = spot_cY + deltay;
+ RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
+ RotatePoint( &x0, &y0, segm_angle );
+ bflag = TestMarginToCircle( x0, y0, p_dimx + seuil, segm_long );
+ if( bflag == BAD_DRC )
+ return BAD_DRC;
- case RECT: /* 2 rectangle + 4 1/4 cercles a tester */
- /* Test du rectangle dimx + seuil, dimy */
- xcliplo = spot_cX - p_dimx - seuil;
- ycliplo = spot_cY - p_dimy;
- xcliphi = spot_cX + p_dimx + seuil;
- ycliphi = spot_cY + p_dimy;
+ x0 = spot_cX; /* x0,y0 = centre du cercle inferieur du pad ovale */
+ y0 = spot_cY - deltay;
+ RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
+ RotatePoint( &x0, &y0, segm_angle );
+ bflag = TestMarginToCircle( x0, y0, p_dimx + seuil, segm_long );
+ if( bflag == BAD_DRC )
+ return BAD_DRC;
+ break;
- bflag = Tst_Ligne(x0,y0,xf,yf);
- if (bflag == BAD_DRC)
- {
- return(BAD_DRC);
- }
+ case RECT: /* 2 rectangle + 4 1/4 cercles a tester */
+ /* Test du rectangle dimx + seuil, dimy */
+ xcliplo = spot_cX - p_dimx - seuil;
+ ycliplo = spot_cY - p_dimy;
+ xcliphi = spot_cX + p_dimx + seuil;
+ ycliphi = spot_cY + p_dimy;
- /* Test du rectangle dimx , dimy + seuil */
- xcliplo = spot_cX - p_dimx;
- ycliplo = spot_cY - p_dimy - seuil;
- xcliphi = spot_cX + p_dimx;
- ycliphi = spot_cY + p_dimy + seuil;
+ bflag = Tst_Ligne( x0, y0, xf, yf );
+ if( bflag == BAD_DRC )
+ {
+ return BAD_DRC;
+ }
- bflag = Tst_Ligne(x0,y0,xf,yf);
- if (bflag == BAD_DRC)
- {
- return(BAD_DRC);
- }
+ /* Test du rectangle dimx , dimy + seuil */
+ xcliplo = spot_cX - p_dimx;
+ ycliplo = spot_cY - p_dimy - seuil;
+ xcliphi = spot_cX + p_dimx;
+ ycliphi = spot_cY + p_dimy + seuil;
- /* test des 4 cercles ( surface d'solation autour des sommets */
- /* test du coin sup. gauche du pad */
- x0 = spot_cX - p_dimx;
- y0 = spot_cY - p_dimy;
- RotatePoint(&x0,&y0, spot_cX, spot_cY, orient);
- RotatePoint(&x0,&y0, segm_angle);
- bflag = TestMarginToCircle(x0, y0, seuil, segm_long);
- if( bflag == BAD_DRC)
- {
- return(BAD_DRC);
- }
+ bflag = Tst_Ligne( x0, y0, xf, yf );
+ if( bflag == BAD_DRC )
+ {
+ return BAD_DRC;
+ }
- /* test du coin sup. droit du pad */
- x0 = spot_cX + p_dimx;
- y0 = spot_cY - p_dimy;
- RotatePoint(&x0,&y0, spot_cX, spot_cY, orient);
- RotatePoint(&x0,&y0, segm_angle);
- bflag = TestMarginToCircle(x0, y0, seuil, segm_long);
- if( bflag == BAD_DRC)
- {
- return(BAD_DRC);
- }
+ /* test des 4 cercles ( surface d'solation autour des sommets */
+ /* test du coin sup. gauche du pad */
+ x0 = spot_cX - p_dimx;
+ y0 = spot_cY - p_dimy;
+ RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
+ RotatePoint( &x0, &y0, segm_angle );
+ bflag = TestMarginToCircle( x0, y0, seuil, segm_long );
+ if( bflag == BAD_DRC )
+ {
+ return BAD_DRC;
+ }
- /* test du coin inf. gauche du pad */
- x0 = spot_cX - p_dimx;
- y0 = spot_cY + p_dimy;
- RotatePoint(&x0,&y0, spot_cX, spot_cY, orient);
- RotatePoint(&x0,&y0, segm_angle);
- bflag = TestMarginToCircle(x0, y0, seuil, segm_long);
- if( bflag == BAD_DRC)
- {
- return(BAD_DRC);
- }
+ /* test du coin sup. droit du pad */
+ x0 = spot_cX + p_dimx;
+ y0 = spot_cY - p_dimy;
+ RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
+ RotatePoint( &x0, &y0, segm_angle );
+ bflag = TestMarginToCircle( x0, y0, seuil, segm_long );
+ if( bflag == BAD_DRC )
+ {
+ return BAD_DRC;
+ }
- /* test du coin inf. droit du pad */
- x0 = spot_cX + p_dimx;
- y0 = spot_cY + p_dimy;
- RotatePoint(&x0,&y0, spot_cX, spot_cY, orient);
- RotatePoint(&x0,&y0, segm_angle);
- bflag = TestMarginToCircle(x0, y0, seuil, segm_long);
- if( bflag == BAD_DRC)
- {
- return(BAD_DRC);
- }
+ /* test du coin inf. gauche du pad */
+ x0 = spot_cX - p_dimx;
+ y0 = spot_cY + p_dimy;
+ RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
+ RotatePoint( &x0, &y0, segm_angle );
+ bflag = TestMarginToCircle( x0, y0, seuil, segm_long );
+ if( bflag == BAD_DRC )
+ {
+ return BAD_DRC;
+ }
- break;
+ /* test du coin inf. droit du pad */
+ x0 = spot_cX + p_dimx;
+ y0 = spot_cY + p_dimy;
+ RotatePoint( &x0, &y0, spot_cX, spot_cY, orient );
+ RotatePoint( &x0, &y0, segm_angle );
+ bflag = TestMarginToCircle( x0, y0, seuil, segm_long );
+ if( bflag == BAD_DRC )
+ {
+ return BAD_DRC;
+ }
- }
- }
- return(OK_DRC) ;
+ break;
+ }
+ }
+ return OK_DRC;
}
+
/*******************************************************************/
-static int TestMarginToCircle(int cx, int cy, int rayon, int longueur )
+static int TestMarginToCircle( int cx, int cy, int rayon, int longueur )
/*******************************************************************/
+
/*
- Routine analogue a TestClearanceSegmToPad.
- Calcul de la distance d'un cercle (via ronde, extremite de piste)
- au segment de droite en cours de controle (segment de reference dans
- son repere )
- parametres:
- cx, cy: centre du cercle (surface ronde) a tester, dans le repere
- segment de reference
- rayon = rayon du cercle
- longueur = longueur du segment dans son repere (i.e. coord de fin)
- retourne:
- OK_DRC si distance >= rayon
- BAD_DRC si distance < rayon
-*/
+ * Routine analogue a TestClearanceSegmToPad.
+ * Calcul de la distance d'un cercle (via ronde, extremite de piste)
+ * au segment de droite en cours de controle (segment de reference dans
+ * son repere )
+ * parametres:
+ * cx, cy: centre du cercle (surface ronde) a tester, dans le repere
+ * segment de reference
+ * rayon = rayon du cercle
+ * longueur = longueur du segment dans son repere (i.e. coord de fin)
+ * retourne:
+ * OK_DRC si distance >= rayon
+ * BAD_DRC si distance < rayon
+ */
{
- if ( abs(cy) > rayon) return(OK_DRC);
+ if( abs( cy ) > rayon )
+ return OK_DRC;
- if ( (cx >= -rayon ) && (cx <= (longueur+rayon) ) )
- {
- if( (cx >= 0) && (cx <= longueur) ) return(BAD_DRC) ;
- if( cx > longueur) cx -= longueur ;
- if( hypot((double)cx, (double)cy) < rayon ) return(BAD_DRC);
- }
+ if( (cx >= -rayon ) && ( cx <= (longueur + rayon) ) )
+ {
+ if( (cx >= 0) && (cx <= longueur) )
+ return BAD_DRC;
+ if( cx > longueur )
+ cx -= longueur;
+ if( hypot( (double) cx, (double) cy ) < rayon )
+ return BAD_DRC;
+ }
- return(OK_DRC) ;
+ return OK_DRC;
}
/******************************************************************************/
-static void Affiche_Erreur_DRC(WinEDA_DrawPanel * panel, wxDC * DC, BOARD * Pcb,
- TRACK * pt_ref, void * pt_item, int errnumber)
+static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb,
+ TRACK* pt_ref, void* pt_item, int errnumber )
/******************************************************************************/
/* affiche les erreurs de DRC :
- Message d'erreur
- +
- Marqueur
- number = numero d'identification
-*/
+ * Message d'erreur
+ +
+ * Marqueur
+ * number = numero d'identification
+ */
{
-wxPoint erc_pos;
-TRACK * pt_segm;
-wxString msg;
-wxString tracktype, netname1, netname2;
-EQUIPOT * equipot = GetEquipot(Pcb, pt_ref->m_NetCode);
- if ( equipot ) netname1 = equipot->m_Netname;
- else netname1 = wxT("<noname>");
- netname2 = wxT("<noname>");
+ wxPoint erc_pos;
+ TRACK* pt_segm;
+ wxString msg;
+ wxString tracktype, netname1, netname2;
+ EQUIPOT* equipot = GetEquipot( Pcb, pt_ref->m_NetCode );
- tracktype = wxT("Track");
- if ( pt_ref->m_StructType == TYPEVIA ) tracktype = wxT("Via");
- if ( pt_ref->m_StructType == TYPEZONE ) tracktype = wxT("Zone");
+ if( equipot )
+ netname1 = equipot->m_Netname;
+ else
+ netname1 = wxT( "<noname>" );
+ netname2 = wxT( "<noname>" );
+
+ tracktype = wxT( "Track" );
+ if( pt_ref->m_StructType == TYPEVIA )
+ tracktype = wxT( "Via" );
+ if( pt_ref->m_StructType == TYPEZONE )
+ tracktype = wxT( "Zone" );
- if( ((EDA_BaseStruct*)pt_item)->m_StructType == TYPEPAD )
- {
- D_PAD * pad = (D_PAD*) pt_item;
- equipot = GetEquipot(Pcb, pad->m_NetCode);
- if ( equipot ) netname2 = equipot->m_Netname;
- erc_pos = pad->m_Pos;
- wxString pad_name = pad->ReturnStringPadName();
- wxString module_name = ((MODULE*)(pad->m_Parent))->m_Reference->m_Text;
- msg.Printf(_("%d Drc Err %d %s (net %s)and PAD %s (%s) net %s @ %d,%d\n"),
- ErrorsDRC_Count, errnumber, tracktype.GetData(),
- netname1.GetData(),
- pad_name.GetData(), module_name.GetData(),
- netname2.GetData(),
- erc_pos.x, erc_pos.y);
- }
- else /* erreur sur segment de piste */
- {
- pt_segm = (TRACK *) pt_item;
- equipot = GetEquipot(Pcb, pt_segm->m_NetCode);
- if ( equipot ) netname2 = equipot->m_Netname;
- erc_pos = pt_segm->m_Start;
- if(pt_segm->m_StructType == TYPEVIA)
- {
- msg.Printf(_("%d Err type %d: %s (net %s) and VIA (net %s) @ %d,%d\n"),
- ErrorsDRC_Count, errnumber, tracktype.GetData(),
- netname1.GetData(), netname2.GetData(),
- erc_pos.x,erc_pos.y);
- }
- else
- {
- wxPoint erc_pos_f = pt_segm->m_End;
- if(hypot( (double)(erc_pos_f.x - pt_ref->m_End.x),(double)(erc_pos_f.y - pt_ref->m_End.y) )
- < hypot( (double)(erc_pos.x - pt_ref->m_End.x),(double)(erc_pos.y - pt_ref->m_End.y) ) )
- {
- EXCHG(erc_pos_f.x, erc_pos.x); EXCHG(erc_pos_f.y, erc_pos.y);
- }
- msg.Printf(_("%d Err type %d: %s (net %s) and track (net %s) @ %d,%d\n"),
- ErrorsDRC_Count, errnumber, tracktype.GetData(),
- netname1.GetData(), netname2.GetData(),
- erc_pos.x,erc_pos.y);
- }
- }
+ if( ( (EDA_BaseStruct*) pt_item )->m_StructType == TYPEPAD )
+ {
+ D_PAD* pad = (D_PAD*) pt_item;
+ equipot = GetEquipot( Pcb, pad->m_NetCode );
+ if( equipot )
+ netname2 = equipot->m_Netname;
+ erc_pos = pad->m_Pos;
+ wxString pad_name = pad->ReturnStringPadName();
+ wxString module_name = ( (MODULE*) (pad->m_Parent) )->m_Reference->m_Text;
+ msg.Printf( _( "%d Drc Err %d %s (net %s)and PAD %s (%s) net %s @ %d,%d\n" ),
+ ErrorsDRC_Count, errnumber, tracktype.GetData(),
+ netname1.GetData(),
+ pad_name.GetData(), module_name.GetData(),
+ netname2.GetData(),
+ erc_pos.x, erc_pos.y );
+ }
+ else /* erreur sur segment de piste */
+ {
+ pt_segm = (TRACK*) pt_item;
+ equipot = GetEquipot( Pcb, pt_segm->m_NetCode );
+ if( equipot )
+ netname2 = equipot->m_Netname;
+ erc_pos = pt_segm->m_Start;
+ if( pt_segm->m_StructType == TYPEVIA )
+ {
+ msg.Printf( _( "%d Err type %d: %s (net %s) and VIA (net %s) @ %d,%d\n" ),
+ ErrorsDRC_Count, errnumber, tracktype.GetData(),
+ netname1.GetData(), netname2.GetData(),
+ erc_pos.x, erc_pos.y );
+ }
+ else
+ {
+ wxPoint erc_pos_f = pt_segm->m_End;
+ if( hypot( (double) (erc_pos_f.x - pt_ref->m_End.x),
+ (double) (erc_pos_f.y - pt_ref->m_End.y) )
+ < hypot( (double) (erc_pos.x - pt_ref->m_End.x),
+ (double) (erc_pos.y - pt_ref->m_End.y) ) )
+ {
+ EXCHG( erc_pos_f.x, erc_pos.x ); EXCHG( erc_pos_f.y, erc_pos.y );
+ }
+ msg.Printf( _( "%d Err type %d: %s (net %s) and track (net %s) @ %d,%d\n" ),
+ ErrorsDRC_Count, errnumber, tracktype.GetData(),
+ netname1.GetData(), netname2.GetData(),
+ erc_pos.x, erc_pos.y );
+ }
+ }
- if ( DrcFrame ) DrcFrame->m_logWindow->AppendText(msg);
- else panel->m_Parent->Affiche_Message(msg);
- if ( s_RptFile ) fprintf(s_RptFile, "%s", CONV_TO_UTF8(msg) );
+ if( DrcFrame )
+ DrcFrame->m_logWindow->AppendText( msg );
+ else
+ panel->m_Parent->Affiche_Message( msg );
+ if( s_RptFile )
+ fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );
- if(current_marqueur == NULL) current_marqueur = new MARQUEUR(Pcb);
- current_marqueur->m_Pos = wxPoint(erc_pos.x, erc_pos.y);
- current_marqueur->m_Color = WHITE;
- current_marqueur->m_Diag = msg;
- current_marqueur->Draw(panel, DC, GR_OR);
+ if( current_marqueur == NULL )
+ current_marqueur = new MARQUEUR( Pcb );
+ current_marqueur->m_Pos = wxPoint( erc_pos.x, erc_pos.y );
+ current_marqueur->m_Color = WHITE;
+ current_marqueur->m_Diag = msg;
+ current_marqueur->Draw( panel, DC, GR_OR );
}
/******************************************************************************/
-static void Affiche_Erreur_DRC(WinEDA_DrawPanel * panel, wxDC * DC, BOARD * Pcb,
- D_PAD * pad1, D_PAD * pad2)
+static void Affiche_Erreur_DRC( WinEDA_DrawPanel* panel, wxDC* DC, BOARD* Pcb,
+ D_PAD* pad1, D_PAD* pad2 )
/******************************************************************************/
/* affiche les erreurs de DRC :
- Message d'erreur
- +
- Marqueur
- number = numero d'identification
-*/
+ * Message d'erreur
+ +
+ * Marqueur
+ * number = numero d'identification
+ */
{
-wxString msg;
+ wxString msg;
- wxString pad_name1 = pad1->ReturnStringPadName();
- wxString module_name1 = ((MODULE*)(pad1->m_Parent))->m_Reference->m_Text;
- wxString pad_name2 = pad2->ReturnStringPadName();
- wxString module_name2 = ((MODULE*)(pad2->m_Parent))->m_Reference->m_Text;
- wxString netname1, netname2;
- EQUIPOT * equipot = GetEquipot(Pcb, pad1->m_NetCode);
- if ( equipot ) netname1 = equipot->m_Netname;
- else netname1 = wxT("<noname>");
- equipot = GetEquipot(Pcb, pad2->m_NetCode);
- if ( equipot ) netname2 = equipot->m_Netname;
- else netname2 = wxT("<noname>");
+ wxString pad_name1 = pad1->ReturnStringPadName();
+ wxString module_name1 = ( (MODULE*) (pad1->m_Parent) )->m_Reference->m_Text;
+ wxString pad_name2 = pad2->ReturnStringPadName();
+ wxString module_name2 = ( (MODULE*) (pad2->m_Parent) )->m_Reference->m_Text;
+ wxString netname1, netname2;
+ EQUIPOT* equipot = GetEquipot( Pcb, pad1->m_NetCode );
- msg.Printf( _("%d Drc Err: PAD %s (%s) net %s @ %d,%d and PAD %s (%s) net %s @ %d,%d\n"),
- ErrorsDRC_Count, pad_name1.GetData(), module_name1.GetData(),
- netname1.GetData(), pad1->m_Pos.x,pad1->m_Pos.y,
- pad_name2.GetData(), module_name2.GetData(),
- netname2.GetData(), pad2->m_Pos.x, pad2->m_Pos.y);
- if ( DrcFrame ) DrcFrame->m_logWindow->AppendText(msg);
- else panel->m_Parent->Affiche_Message(msg);
- if ( s_RptFile ) fprintf(s_RptFile, "%s", CONV_TO_UTF8(msg) );
+ if( equipot )
+ netname1 = equipot->m_Netname;
+ else
+ netname1 = wxT( "<noname>" );
+ equipot = GetEquipot( Pcb, pad2->m_NetCode );
+ if( equipot )
+ netname2 = equipot->m_Netname;
+ else
+ netname2 = wxT( "<noname>" );
- if(current_marqueur == NULL) current_marqueur = new MARQUEUR(Pcb);
- current_marqueur->m_Pos = pad1->m_Pos;
- current_marqueur->m_Color = WHITE;
- current_marqueur->m_Diag = msg;
- current_marqueur->Draw(panel, DC, GR_OR);
+ msg.Printf( _( "%d Drc Err: PAD %s (%s) net %s @ %d,%d and PAD %s (%s) net %s @ %d,%d\n" ),
+ ErrorsDRC_Count, pad_name1.GetData(), module_name1.GetData(),
+ netname1.GetData(), pad1->m_Pos.x, pad1->m_Pos.y,
+ pad_name2.GetData(), module_name2.GetData(),
+ netname2.GetData(), pad2->m_Pos.x, pad2->m_Pos.y );
+ if( DrcFrame )
+ DrcFrame->m_logWindow->AppendText( msg );
+ else
+ panel->m_Parent->Affiche_Message( msg );
+ if( s_RptFile )
+ fprintf( s_RptFile, "%s", CONV_TO_UTF8( msg ) );
+
+ if( current_marqueur == NULL )
+ current_marqueur = new MARQUEUR( Pcb );
+ current_marqueur->m_Pos = pad1->m_Pos;
+ current_marqueur->m_Color = WHITE;
+ current_marqueur->m_Diag = msg;
+ current_marqueur->Draw( panel, DC, GR_OR );
}
- /**********************************************/
- /* int Tst_Ligne(int x1,int y1,int x2,int y2) */
- /**********************************************/
+/**********************************************/
+/* int Tst_Ligne(int x1,int y1,int x2,int y2) */
+/**********************************************/
/* Routine utilisee pour tester si une piste est en contact avec une autre piste.
-
- Cette routine controle si la ligne (x1,y1 x2,y2) a une partie s'inscrivant
- dans le cadre (xcliplo,ycliplo xcliphi,ycliphi) (variables globales,
- locales a ce fichier)
-
- Retourne OK_DRC si aucune partie commune
- Retourne BAD_DRC si partie commune
-*/
+ *
+ * Cette routine controle si la ligne (x1,y1 x2,y2) a une partie s'inscrivant
+ * dans le cadre (xcliplo,ycliplo xcliphi,ycliphi) (variables globales,
+ * locales a ce fichier)
+ *
+ * Retourne OK_DRC si aucune partie commune
+ * Retourne BAD_DRC si partie commune
+ */
#define us unsigned int
-static inline int USCALE(us arg, us num, us den)
- {
- int ii;
-
- ii = (int)( ((float) arg * num) / den);
- return( ii );
- }
-
-#define WHEN_OUTSIDE return(OK_DRC)
-#define WHEN_INSIDE
-
-static int Tst_Ligne(int x1,int y1,int x2,int y2)
+static inline int USCALE( us arg, us num, us den )
{
-int temp;
+ int ii;
-do {
- if(x1 > x2) { EXCHG(x1,x2); EXCHG(y1,y2); }
- if((x2 < xcliplo) || (x1 > xcliphi)) { WHEN_OUTSIDE; }
- if(y1 < y2)
- {
- if((y2 < ycliplo) || (y1 > ycliphi)) { WHEN_OUTSIDE;}
- if(y1 < ycliplo)
- {
- temp = USCALE((x2 - x1),(ycliplo - y1),(y2 - y1));
- if((x1 += temp) > xcliphi) { WHEN_OUTSIDE; }
- y1 = ycliplo;
- WHEN_INSIDE;
- }
- if(y2 > ycliphi)
- {
- temp = USCALE((x2 - x1),(y2 - ycliphi),(y2 - y1));
- if((x2 -= temp) < xcliplo) { WHEN_OUTSIDE; }
- y2 = ycliphi;
- WHEN_INSIDE;
- }
- if(x1 < xcliplo)
- {
- temp = USCALE((y2 - y1),(xcliplo - x1),(x2 - x1));
- y1 += temp; x1 = xcliplo;
- WHEN_INSIDE;
- }
- if(x2 > xcliphi)
- {
- temp = USCALE((y2 - y1),(x2 - xcliphi),(x2 - x1));
- y2 -= temp; x2 = xcliphi;
- WHEN_INSIDE;
- }
- }
- else
- {
- if((y1 < ycliplo) || (y2 > ycliphi)) { WHEN_OUTSIDE; }
- if(y1 > ycliphi)
- {
- temp = USCALE((x2 - x1),(y1 - ycliphi),(y1 - y2));
- if((x1 += temp) > xcliphi) { WHEN_OUTSIDE; }
- y1 = ycliphi;
- WHEN_INSIDE;
- }
- if(y2 < ycliplo)
- {
- temp = USCALE((x2 - x1),(ycliplo - y2),(y1 - y2));
- if((x2 -= temp) < xcliplo) { WHEN_OUTSIDE; }
- y2 = ycliplo;
- WHEN_INSIDE;
- }
- if(x1 < xcliplo)
- {
- temp = USCALE((y1 - y2),(xcliplo - x1),(x2 - x1));
- y1 -= temp; x1 = xcliplo;
- WHEN_INSIDE;
- }
- if(x2 > xcliphi)
- {
- temp = USCALE((y1 - y2),(x2 - xcliphi),(x2 - x1));
- y2 += temp; x2 = xcliphi;
- WHEN_INSIDE;
- }
- }
- } while(0);
-
- if ( ((x2 + x1)/2 <= xcliphi ) && ((x2+x1)/2 >= xcliplo) \
- && ((y2 + y1)/2 <= ycliphi ) && ((y2+y1)/2 >= ycliplo) )
- {
- return(BAD_DRC) ;
- }
-
- else return(OK_DRC);
+ ii = (int) ( ( (float) arg * num ) / den );
+ return ii;
}
+#define WHEN_OUTSIDE return (OK_DRC)
+#define WHEN_INSIDE
+
+static int Tst_Ligne( int x1, int y1, int x2, int y2 )
+{
+ int temp;
+
+ do {
+ if( x1 > x2 )
+ {
+ EXCHG( x1, x2 ); EXCHG( y1, y2 );
+ }
+ if( (x2 < xcliplo) || (x1 > xcliphi) )
+ {
+ WHEN_OUTSIDE;
+ }
+ if( y1 < y2 )
+ {
+ if( (y2 < ycliplo) || (y1 > ycliphi) )
+ {
+ WHEN_OUTSIDE;
+ }
+ if( y1 < ycliplo )
+ {
+ temp = USCALE( (x2 - x1), (ycliplo - y1), (y2 - y1) );
+ if( (x1 += temp) > xcliphi )
+ {
+ WHEN_OUTSIDE;
+ }
+ y1 = ycliplo;
+ WHEN_INSIDE;
+ }
+ if( y2 > ycliphi )
+ {
+ temp = USCALE( (x2 - x1), (y2 - ycliphi), (y2 - y1) );
+ if( (x2 -= temp) < xcliplo )
+ {
+ WHEN_OUTSIDE;
+ }
+ y2 = ycliphi;
+ WHEN_INSIDE;
+ }
+ if( x1 < xcliplo )
+ {
+ temp = USCALE( (y2 - y1), (xcliplo - x1), (x2 - x1) );
+ y1 += temp; x1 = xcliplo;
+ WHEN_INSIDE;
+ }
+ if( x2 > xcliphi )
+ {
+ temp = USCALE( (y2 - y1), (x2 - xcliphi), (x2 - x1) );
+ y2 -= temp; x2 = xcliphi;
+ WHEN_INSIDE;
+ }
+ }
+ else
+ {
+ if( (y1 < ycliplo) || (y2 > ycliphi) )
+ {
+ WHEN_OUTSIDE;
+ }
+ if( y1 > ycliphi )
+ {
+ temp = USCALE( (x2 - x1), (y1 - ycliphi), (y1 - y2) );
+ if( (x1 += temp) > xcliphi )
+ {
+ WHEN_OUTSIDE;
+ }
+ y1 = ycliphi;
+ WHEN_INSIDE;
+ }
+ if( y2 < ycliplo )
+ {
+ temp = USCALE( (x2 - x1), (ycliplo - y2), (y1 - y2) );
+ if( (x2 -= temp) < xcliplo )
+ {
+ WHEN_OUTSIDE;
+ }
+ y2 = ycliplo;
+ WHEN_INSIDE;
+ }
+ if( x1 < xcliplo )
+ {
+ temp = USCALE( (y1 - y2), (xcliplo - x1), (x2 - x1) );
+ y1 -= temp; x1 = xcliplo;
+ WHEN_INSIDE;
+ }
+ if( x2 > xcliphi )
+ {
+ temp = USCALE( (y1 - y2), (x2 - xcliphi), (x2 - x1) );
+ y2 += temp; x2 = xcliphi;
+ WHEN_INSIDE;
+ }
+ }
+ } while( 0 );
+
+ if( ( (x2 + x1) / 2 <= xcliphi ) && ( (x2 + x1) / 2 >= xcliplo ) \
+ && ( (y2 + y1) / 2 <= ycliphi ) && ( (y2 + y1) / 2 >= ycliplo ) )
+ {
+ return BAD_DRC;
+ }
+ else
+ return OK_DRC;
+}
diff --git a/pcbnew/edit.cpp b/pcbnew/edit.cpp
index bc1a711092..c2b3f441c0 100644
--- a/pcbnew/edit.cpp
+++ b/pcbnew/edit.cpp
@@ -128,8 +128,7 @@ void WinEDA_PcbFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
#if defined(DEBUG)
DrawStruct = m_Pcb->FindPadOrModule(
GetScreen()->RefPos(true),
- GetScreen()->m_Active_Layer,
- VISIBLE_ONLY );
+ GetScreen()->m_Active_Layer );
#else
DrawStruct = PcbGeneralLocateAndDisplay();
#endif
diff --git a/pcbnew/locate.cpp b/pcbnew/locate.cpp
index 522c06f5e2..3436f24923 100644
--- a/pcbnew/locate.cpp
+++ b/pcbnew/locate.cpp
@@ -13,10 +13,7 @@
#include "protos.h"
-
-/* variables locales */
-int ux0, uy0, dx, dy, spot_cX, spot_cY; /* Variables utilisees pour
- * la localisation des segments */
+
/* fonctions locales */
EDA_BaseStruct* Locate_MirePcb( EDA_BaseStruct* PtStruct, int LayerSearch, int typeloc );
@@ -302,72 +299,21 @@ EDGE_MODULE* Locate_Edge_Module( MODULE* module, int typeloc )
* NULL si rien trouve
*/
{
- EDGE_MODULE* edge_mod;
- EDA_BaseStruct* PtStruct;
- int uxf, uyf, type_trace;
- int rayon, dist;
- wxPoint ref_pos; /* coord du point de localisation */
-
- /* pour localisation d'arcs, angle du point de debut, de fin et du point de reference */
- int StAngle, EndAngle, MouseAngle;
-
if( !module )
return NULL;
- ref_pos = RefPos( typeloc );
+ /* coord du point de localisation */
+ wxPoint ref_pos = RefPos( typeloc );
- PtStruct = module->m_Drawings;
- for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
+ EDA_BaseStruct* PtStruct = module->m_Drawings;
+ for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPEEDGEMODULE )
continue;
- edge_mod = (EDGE_MODULE*) PtStruct;
- type_trace = edge_mod->m_Shape;
- ux0 = edge_mod->m_Start.x; uy0 = edge_mod->m_Start.y;
- uxf = edge_mod->m_End.x; uyf = edge_mod->m_End.y;
-
- switch( type_trace )
- {
- case S_SEGMENT:
- /* recalcul des coordonnees avec ux0,uy0 = origine des coord. */
- spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
- dx = uxf - ux0; dy = uyf - uy0;
- /* detection : */
- if( distance( edge_mod->m_Width / 2 ) )
- return edge_mod;
- break;
-
- case S_CIRCLE:
- rayon = (int) hypot( (double) (uxf - ux0), (double) (uyf - uy0) );
- dist = (int) hypot( (double) (ref_pos.x - ux0), (double) (ref_pos.y - uy0) );
-
- if( abs( rayon - dist ) <= edge_mod->m_Width )
- return edge_mod;
- break;
-
- case S_ARC:
- rayon = (int) hypot( (double) (uxf - ux0), (double) (uyf - uy0) );
- dist = (int) hypot( (double) (ref_pos.x - ux0), (double) (ref_pos.y - uy0) );
-
- if( abs( rayon - dist ) > edge_mod->m_Width )
- break;
-
- /* pour un arc, controle complementaire */
- MouseAngle = (int) ArcTangente( ref_pos.y - uy0, ref_pos.x - ux0 );
- StAngle = (int) ArcTangente( uyf - uy0, uxf - ux0 );
- EndAngle = StAngle + edge_mod->m_Angle;
-
- if( EndAngle > 3600 )
- {
- StAngle -= 3600; EndAngle -= 3600;
- }
-
- if( (MouseAngle >= StAngle) && (MouseAngle <= EndAngle) )
- return edge_mod;
-
- break;
- }
+ // calls virtual EDGE_MODULE::HitTest()
+ if( PtStruct->HitTest( ref_pos ) )
+ return (EDGE_MODULE*) PtStruct;
}
return NULL;
@@ -383,105 +329,17 @@ EDA_BaseStruct* Locate_Cotation( BOARD* Pcb, int LayerSearch, int typeloc )
* return a pointer to the located item, or NULL
*/
{
- EDA_BaseStruct* PtStruct;
- COTATION* Cotation;
- TEXTE_PCB* pt_txt;
- wxPoint ref_pos;
- int ux0, uy0;
+ wxPoint ref_pos = RefPos( typeloc );
- ref_pos = RefPos( typeloc );
-
- PtStruct = Pcb->m_Drawings;
+ EDA_BaseStruct* PtStruct = Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPECOTATION )
continue;
-
- Cotation = (COTATION*) PtStruct;
- if( (Cotation->m_Layer != LayerSearch) && (LayerSearch != -1) )
- continue;
- /* Localisation du texte ? */
- pt_txt = Cotation->m_Text;
- if( pt_txt )
- {
- // because HitTest() is present in both base classes of TEXTE_PCB
- // use a dis-ambiguating cast to tell compiler which HitTest()
- // to call.
- if( static_cast<EDA_TextStruct*>(pt_txt)->HitTest( ref_pos ) )
- return PtStruct;
- }
-
- /* Localisation des SEGMENTS ?) */
- ux0 = Cotation->Barre_ox; uy0 = Cotation->Barre_oy;
-
- /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
- dx = Cotation->Barre_fx - ux0; dy = Cotation->Barre_fy - uy0;
- spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
-
- /* detection : */
- if( distance( Cotation->m_Width / 2 ) )
- return PtStruct;
-
- ux0 = Cotation->TraitG_ox; uy0 = Cotation->TraitG_oy;
-
- /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
- dx = Cotation->TraitG_fx - ux0; dy = Cotation->TraitG_fy - uy0;
- spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
-
- /* detection : */
- if( distance( Cotation->m_Width / 2 ) )
- return PtStruct;
-
- ux0 = Cotation->TraitD_ox; uy0 = Cotation->TraitD_oy;
-
- /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
- dx = Cotation->TraitD_fx - ux0; dy = Cotation->TraitD_fy - uy0;
- spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
-
- /* detection : */
- if( distance( Cotation->m_Width / 2 ) )
- return PtStruct;
-
- ux0 = Cotation->FlecheD1_ox; uy0 = Cotation->FlecheD1_oy;
-
- /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
- dx = Cotation->FlecheD1_fx - ux0; dy = Cotation->FlecheD1_fy - uy0;
- spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
-
- /* detection : */
- if( distance( Cotation->m_Width / 2 ) )
- return PtStruct;
-
- ux0 = Cotation->FlecheD2_ox; uy0 = Cotation->FlecheD2_oy;
-
- /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
- dx = Cotation->FlecheD2_fx - ux0; dy = Cotation->FlecheD2_fy - uy0;
- spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
-
- /* detection : */
- if( distance( Cotation->m_Width / 2 ) )
- return PtStruct;
-
- ux0 = Cotation->FlecheG1_ox; uy0 = Cotation->FlecheG1_oy;
-
- /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
- dx = Cotation->FlecheG1_fx - ux0; dy = Cotation->FlecheG1_fy - uy0;
- spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
-
- /* detection : */
- if( distance( Cotation->m_Width / 2 ) )
- return PtStruct;
-
- ux0 = Cotation->FlecheG2_ox; uy0 = Cotation->FlecheG2_oy;
-
- /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
- dx = Cotation->FlecheG2_fx - ux0; dy = Cotation->FlecheG2_fy - uy0;
- spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
-
- /* detection : */
- if( distance( Cotation->m_Width / 2 ) )
- return PtStruct;
+ // calls virtual COTATION::HitTest()
+ if( PtStruct->HitTest( ref_pos ) )
+ return (COTATION*) PtStruct;
}
return NULL;
@@ -499,73 +357,32 @@ DRAWSEGMENT* Locate_Segment_Pcb( BOARD* Pcb, int LayerSearch, int typeloc )
* Le segment sur la couche active est d�tect� en priorite
*/
{
- EDA_BaseStruct* PtStruct;
- DRAWSEGMENT* pts, * locate_segm = NULL;
- wxPoint ref_pos;
+
+ DRAWSEGMENT* locate_segm = NULL;
PCB_SCREEN* screen = (PCB_SCREEN*) ActiveScreen;
+
+ wxPoint ref_pos = RefPos( typeloc );
- ref_pos = RefPos( typeloc );
-
- PtStruct = Pcb->m_Drawings;
+ EDA_BaseStruct* PtStruct = Pcb->m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPEDRAWSEGMENT )
continue;
- pts = (DRAWSEGMENT*) PtStruct;
+
+ DRAWSEGMENT* pts = (DRAWSEGMENT*) PtStruct;
+
if( (pts->m_Layer != LayerSearch) && (LayerSearch != -1) )
continue;
-
- ux0 = pts->m_Start.x; uy0 = pts->m_Start.y;
-
- /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
- dx = pts->m_End.x - ux0; dy = pts->m_End.y - uy0;
- spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
- /* detection : */
- if( (pts->m_Shape == S_CIRCLE) || (pts->m_Shape == S_ARC) )
+ if( pts->HitTest( ref_pos ) )
{
- int rayon, dist, StAngle, EndAngle, MouseAngle;
+ // return this hit if layer matches, else remember in
+ // case no layer match is found.
+ if( pts->m_Layer == screen->m_Active_Layer )
+ return pts;
- rayon = (int) hypot( (double) (dx), (double) (dy) );
- dist = (int) hypot( (double) (spot_cX), (double) (spot_cY) );
-
- if( abs( rayon - dist ) <= (pts->m_Width / 2) )
- {
- if( pts->m_Shape == S_CIRCLE )
- {
- if( pts->m_Layer == screen->m_Active_Layer )
- return pts;
- else if( !locate_segm )
- locate_segm = pts;
- }
-
- /* pour un arc, controle complementaire */
- MouseAngle = (int) ArcTangente( spot_cY, spot_cX );
- StAngle = (int) ArcTangente( dy, dx );
- EndAngle = StAngle + pts->m_Angle;
-
- if( EndAngle > 3600 )
- {
- StAngle -= 3600; EndAngle -= 3600;
- }
- if( (MouseAngle >= StAngle) && (MouseAngle <= EndAngle) )
- {
- if( pts->m_Layer == screen->m_Active_Layer )
- return pts;
- else if( !locate_segm )
- locate_segm = pts;
- }
- }
- }
- else
- {
- if( distance( pts->m_Width / 2 ) )
- {
- if( pts->m_Layer == screen->m_Active_Layer )
- return pts;
- else if( !locate_segm )
- locate_segm = pts;
- }
+ else if( !locate_segm )
+ locate_segm = pts;
}
}
@@ -651,14 +468,6 @@ D_PAD* Locate_Pads( MODULE* module, const wxPoint& ref_pos, int masque_layer )
D_PAD* pt_pad = module->m_Pads;
for( ; pt_pad != NULL; pt_pad = (D_PAD*) pt_pad->Pnext )
{
- /*
- wxPoint shape_pos = ReturnShapePos();
-
- why the global ux0?
- ux0 = shape_pos.x;
- uy0 = shape_pos.y; // pos x,y du centre du pad
- */
-
/* ... et sur la bonne couche */
if( (pt_pad->m_Masque_Layer & masque_layer) == 0 )
continue;
@@ -704,8 +513,6 @@ MODULE* Locate_Prefered_Module( BOARD* Pcb, int typeloc )
if( (typeloc & IGNORE_LOCKED) && pt_module->IsLocked() )
continue;
- /* Localisation: test des dimensions minimales, choix du meilleur candidat */
-
/* calcul de priorite: la priorite est donnee a la couche
* d'appartenance du module et a la couche cuivre si le module
* est sur couche serigr,adhesive cuivre, a la couche cmp si le module
@@ -718,6 +525,8 @@ MODULE* Locate_Prefered_Module( BOARD* Pcb, int typeloc )
else if( layer==ADHESIVE_N_CMP || layer==SILKSCREEN_N_CMP )
layer = CMP_N;
+ /* Localisation: test des dimensions minimales, choix du meilleur candidat */
+
/* calcul des dimensions du cadre :*/
lx = pt_module->m_BoundaryBox.GetWidth();
ly = pt_module->m_BoundaryBox.GetHeight();
@@ -998,42 +807,30 @@ TRACK* Locate_Pistes( TRACK* start_adresse, int MasqueLayer, int typeloc )
TRACK* Locate_Pistes( TRACK* start_adresse, const wxPoint& ref_pos, int MasqueLayer )
{
- TRACK* Track; /* pointeur sur les pistes */
- int l_piste; /* demi-largeur de la piste */
-
- for( Track = start_adresse; Track != NULL; Track = (TRACK*) Track->Pnext )
+ for( TRACK* Track = start_adresse; Track; Track = (TRACK*) Track->Pnext )
{
if( Track->GetState( BUSY | DELETED ) )
continue;
+
if( (g_DesignSettings.m_LayerColor[Track->m_Layer] & ITEM_NOT_SHOW) )
continue;
- /* calcul des coordonnees du segment teste */
- l_piste = Track->m_Width >> 1; /* l_piste = demi largeur piste */
- ux0 = Track->m_Start.x; uy0 = Track->m_Start.y; /* coord de depart */
- dx = Track->m_End.x; dy = Track->m_End.y; /* coord d'arrivee */
-
- /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
- dx -= ux0; dy -= uy0;
- spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
-
if( Track->m_StructType == TYPEVIA ) /* VIA rencontree */
{
- if( (abs( spot_cX ) <= l_piste ) && (abs( spot_cY ) <=l_piste) )
- {
+ if( Track->HitTest( ref_pos ) )
+ return Track;
+ }
+ else
+ {
+ if( MasqueLayer != -1 )
+ if( (g_TabOneLayerMask[Track->m_Layer] & MasqueLayer) == 0 )
+ continue; /* Segments sur couches differentes */
+
+ if( Track->HitTest( ref_pos ) )
return Track;
- }
- continue;
}
-
- if( MasqueLayer != -1 )
- if( (g_TabOneLayerMask[Track->m_Layer] & MasqueLayer) == 0 )
- continue; /* Segments sur couches differentes */
-
- if( distance( l_piste ) )
- return Track;
}
-
+
return NULL;
}
@@ -1065,23 +862,12 @@ TRACK* Locate_Zone( TRACK* start_adresse, int layer, int typeloc )
TRACK* Locate_Zone( TRACK* start_adresse, const wxPoint& ref_pos, int layer )
{
- TRACK* Zone; /* pointeur sur les pistes */
- int l_segm; /* demi-largeur de la piste */
-
- for( Zone = start_adresse; Zone != NULL; Zone = (TRACK*) Zone->Pnext )
+ for( TRACK* Zone = start_adresse; Zone; Zone = (TRACK*) Zone->Pnext )
{
- /* calcul des coordonnees du segment teste */
- l_segm = Zone->m_Width >> 1; /* l_piste = demi largeur piste */
- ux0 = Zone->m_Start.x; uy0 = Zone->m_Start.y; /* coord de depart */
- dx = Zone->m_End.x; dy = Zone->m_End.y; /* coord d'arrivee */
-
- /* recalcul des coordonnees avec ux0, uy0 = origine des coordonnees */
- dx -= ux0; dy -= uy0;
- spot_cX = ref_pos.x - ux0; spot_cY = ref_pos.y - uy0;
-
if( (layer != -1) && (Zone->m_Layer != layer) )
continue;
- if( distance( l_segm ) )
+
+ if( Zone->HitTest( ref_pos ) )
return Zone;
}
@@ -1123,159 +909,6 @@ TEXTE_PCB* Locate_Texte_Pcb( EDA_BaseStruct* PtStruct, int LayerSearch, int type
}
-/*****************************/
-int distance( int seuil )
-/*****************************/
-
-/*
- * Calcul de la distance du curseur souris a un segment de droite :
- * ( piste, edge, contour module ..
- * retourne:
- * 0 si distance > seuil
- * 1 si distance <= seuil
- * Variables utilisees ( doivent etre initialisees avant appel , et
- * sont ramenees au repere centre sur l'origine du segment)
- * dx, dy = coord de l'extremite segment.
- * spot_cX,spot_cY = coord du curseur souris
- * la recherche se fait selon 4 cas:
- * segment horizontal
- * segment vertical
- * segment 45
- * segment quelconque
- */
-{
- int cXrot, cYrot, /* coord du point (souris) dans le repere tourne */
- segX, segY; /* coord extremite segment tj >= 0 */
- int pointX, pointY; /* coord point a tester dans repere modifie dans lequel
- * segX et segY sont >=0 */
-
- segX = dx; segY = dy; pointX = spot_cX; pointY = spot_cY;
-
- /*Recalcul coord pour que le segment soit dans 1er quadrant (coord >= 0)*/
- if( segX < 0 ) /* mise en >0 par symetrie par rapport a l'axe Y */
- {
- segX = -segX; pointX = -pointX;
- }
- if( segY < 0 ) /* mise en > 0 par symetrie par rapport a l'axe X */
- {
- segY = -segY; pointY = -pointY;
- }
-
-
- if( segY == 0 ) /* piste Horizontale */
- {
- if( abs( pointY ) <= seuil )
- {
- if( (pointX >= 0) && (pointX <= segX) )
- return 1;
- /* Etude des extremites : cercle de rayon seuil */
- if( (pointX < 0) && (pointX >= -seuil) )
- {
- if( ( (pointX * pointX) + (pointY * pointY) ) <= (seuil * seuil) )
- return 1;
- }
- if( (pointX > segX) && ( pointX <= (segX + seuil) ) )
- {
- if( ( ( (pointX - segX) * (pointX - segX) ) + (pointY * pointY) ) <=
- (seuil * seuil) )
- return 1;
- }
- }
- }
- else if( segX == 0 ) /* piste verticale */
- {
- if( abs( pointX ) <= seuil )
- {
- if( (pointY >= 0 ) && (pointY <= segY) )
- return 1;
- if( (pointY < 0) && (pointY >= -seuil) )
- {
- if( ( (pointY * pointY) + (pointX * pointX) ) <= (seuil * seuil) )
- return 1;
- }
- if( (pointY > segY) && ( pointY <= (segY + seuil) ) )
- {
- if( ( ( (pointY - segY) * (pointY - segY) ) + (pointX * pointX) ) <=
- (seuil * seuil) )
- return 1;
- }
- }
- }
- else if( segX == segY ) /* piste a 45 degre */
- {
- /* on fait tourner les axes de 45 degre. la souris a alors les
- * coord : x1 = x*cos45 + y*sin45
- * y1 = y*cos45 - x*sin45
- * et le segment de piste est alors horizontal.
- * recalcul des coord de la souris ( sin45 = cos45 = .707 = 7/10
- * remarque : sin ou cos45 = .707, et lors du recalcul des coord
- * dx45 et dy45, lec coeff .707 est neglige, dx et dy sont en fait .707 fois
- * trop grands. (c.a.d trop petits)
- * spot_cX,Y doit etre * par .707 * .707 = 0.5 */
-
- cXrot = (pointX + pointY) >> 1;
- cYrot = (pointY - pointX) >> 1;
-
- /* recalcul des coord de l'extremite du segment , qui sera vertical
- * suite a l'orientation des axes sur l'ecran : dx45 = pointX (ou pointY)
- * et est en fait 1,414 plus grand , et dy45 = 0 */
-
- // seuil doit etre * .707 pour tenir compte du coeff de reduction sur dx,dy
- seuil *= 7; seuil /= 10;
- if( abs( cYrot ) <= seuil ) /* ok sur axe vertical) */
- {
- if( (cXrot >= 0) && (cXrot <= segX) )
- return 1;
-
- /* Etude des extremites : cercle de rayon seuil */
- if( (cXrot < 0) && (cXrot >= -seuil) )
- {
- if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) )
- return 1;
- }
- if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) )
- {
- if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) )
- return 1;
- }
- }
- }
- else /* orientation quelconque */
- {
- /* On fait un changement d'axe (rotation) de facon a ce que le segment
- * de piste soit horizontal dans le nouveau repere */
- int angle;
-
- angle = (int) ( atan2( (float) segY, (float) segX ) * 1800 / M_PI);
- cXrot = pointX; cYrot = pointY;
-
- RotatePoint( &cXrot, &cYrot, angle ); /* Rotation du point a tester */
- RotatePoint( &segX, &segY, angle ); /* Rotation du segment */
-
- /* la piste est Horizontale , par suite des modifs de coordonnes
- * et d'axe, donc segX = longueur du segment */
-
- if( abs( cYrot ) <= seuil ) /* ok sur axe vertical) */
- {
- if( (cXrot >= 0) && (cXrot <= segX) )
- return 1;
-
- /* Etude des extremites : cercle de rayon seuil */
- if( (cXrot < 0) && (cXrot >= -seuil) )
- {
- if( ( (cXrot * cXrot) + (cYrot * cYrot) ) <= (seuil * seuil) )
- return 1;
- }
- if( (cXrot > segX) && ( cXrot <= (segX + seuil) ) )
- {
- if( ( ( (cXrot - segX) * (cXrot - segX) ) + (cYrot * cYrot) ) <= (seuil * seuil) )
- return 1;
- }
- }
- }
- return 0;
-}
-
/*******************************************************************************/
D_PAD* Fast_Locate_Pad_Connecte( BOARD* Pcb, const wxPoint& ref_pos, int masque_layer )
@@ -1396,11 +1029,10 @@ EDA_BaseStruct* Locate_MirePcb( EDA_BaseStruct* PtStruct, int LayerSearch,
int typeloc )
/***********************************************************************/
-/* Serach for a photo target
+/* Search for a photo target
*/
{
wxPoint ref_pos;/* coord du point de localisation */
- int dX, dY, rayon;
if( PtStruct == NULL )
return NULL;
@@ -1417,13 +1049,10 @@ EDA_BaseStruct* Locate_MirePcb( EDA_BaseStruct* PtStruct, int LayerSearch,
if( LayerSearch != -1 && item->m_Layer != LayerSearch )
continue;
- dX = ref_pos.x - item->m_Pos.x;
- dY = ref_pos.y - item->m_Pos.y;
- rayon = item->m_Size / 2;
-
- if( (abs( dX ) <= rayon ) && ( abs( dY ) <= rayon ) )
- break; /* Mire Localisee */
+ if( item->HitTest( ref_pos ) )
+ break;
}
return PtStruct;
}
+
diff --git a/pcbnew/protos.h b/pcbnew/protos.h
index 808e1996da..538c9ab535 100644
--- a/pcbnew/protos.h
+++ b/pcbnew/protos.h
@@ -198,24 +198,6 @@ D_PAD * Fast_Locate_Pad_Connecte(BOARD * Pcb, const wxPoint & ref_pos, int layer
(bonne position ET bonne couche). */
-int distance(int seuil);
- /*
- Calcul de la distance du curseur souris a un segment de droite :
- ( piste, edge, contour module ..
- retourne:
- 0 si distance > seuil
- 1 si distance <= seuil
- Variables utilisees ( externes doivent etre initialisees avant appel , et
- sont ramenees au repere centre sur l'origine du segment)
- dx, dy = coord de l'extremite segment.
- spot_cX,spot_cY = coord du curseur souris
- la recherche se fait selon 4 cas:
- segment horizontal
- segment vertical
- segment 45
- segment quelconque
- */
-
TRACK * Locate_Zone(TRACK * start_adresse,int layer, int typeloc);
TRACK * Locate_Zone(TRACK * start_adresse, const wxPoint & ref_pos,int layer);
/*
diff --git a/pcbnew/zones.h b/pcbnew/zones.h
index 1f3d95e604..22d97041e7 100644
--- a/pcbnew/zones.h
+++ b/pcbnew/zones.h
@@ -122,5 +122,5 @@ public:
WinEDA_PcbFrame * m_Parent;
};
-#endif
- // _ZONES_H_
+#endif // _ZONES_H_
+