Skip to content

K
kicad-source-mirror
Commit c1e3416a authored by dickelbeck's avatar dickelbeck
Browse files
Options

searching and beautifying

parent 66080848
Expand all Show whitespace changes
Inline Side-by-side
Showing with 3168 additions and 2703 deletions
change_log.txt
View file @ c1e3416a
...@@ -5,6 +5,20 @@ Please add newer entries at the top, list the date and your name with ...@@ -5,6 +5,20 @@ Please add newer entries at the top, list the date and your name with
email address. 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> 2007-aug-08 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
================================================================================ ================================================================================
+ eeschema + eeschema
......
common/trigo.cpp
View file @ c1e3416a
...@@ -9,6 +9,163 @@ ...@@ -9,6 +9,163 @@
#include "trigo.h" #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 ) int ArcTangente( int dy, int dx )
/***********************************/ /***********************************/
...@@ -217,3 +374,5 @@ void RotatePoint( double* pX, double* pY, int angle ) ...@@ -217,3 +374,5 @@ void RotatePoint( double* pX, double* pY, int angle )
*pY = fpy; *pY = fpy;
} }
} }
include/pcbstruct.h
View file @ c1e3416a
...@@ -235,7 +235,6 @@ public: ...@@ -235,7 +235,6 @@ public:
#if defined(DEBUG) #if defined(DEBUG)
/** /**
* Function GetClass * Function GetClass
* returns the class name. * returns the class name.
...@@ -264,7 +263,7 @@ public: ...@@ -264,7 +263,7 @@ public:
* @param typeloc * @param typeloc
* @return EDA_BaseStruct* - if a direct hit, else NULL. * @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 #endif
}; };
...@@ -322,6 +321,27 @@ public: ...@@ -322,6 +321,27 @@ public:
void UnLink( void ); void UnLink( void );
void Copy( DRAWSEGMENT* source ); 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
}; };
......
include/trigo.h
View file @ c1e3416a
...@@ -7,7 +7,7 @@ ...@@ -7,7 +7,7 @@
#define TRIGO_H #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 angle);
void RotatePoint(int *pX, int *pY, int cx, int cy, int angle); void RotatePoint(int *pX, int *pY, int cx, int cy, int angle);
void RotatePoint(wxPoint *point, const wxPoint & centre, int angle); void RotatePoint(wxPoint *point, const wxPoint & centre, int angle);
...@@ -19,6 +19,7 @@ int ArcTangente(int dy, int dx); ...@@ -19,6 +19,7 @@ int ArcTangente(int dy, int dx);
Analogue a atan2 ( mais plus rapide pour les caculs si Analogue a atan2 ( mais plus rapide pour les caculs si
l'angle est souvent 0, -1800, ou +- 900 */ l'angle est souvent 0, -1800, ou +- 900 */
bool DistanceTest( int seuil, int dx, int dy, int spot_cX, int spot_cY );
......
pcbnew/class_board.cpp
View file @ c1e3416a
...@@ -290,75 +290,64 @@ void BOARD::Show( int nestLevel, std::ostream& os ) ...@@ -290,75 +290,64 @@ void BOARD::Show( int nestLevel, std::ostream& os )
// see pcbstruct.h // 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 class PadOrModule : public INSPECTOR
{ {
public: public:
EDA_BaseStruct* found; EDA_BaseStruct* found;
int layer; int layer;
int typeloc;
PadOrModule( int alayer, int atypeloc ) : PadOrModule( int alayer ) :
found(0), found(0), // found is NULL
layer(alayer), layer(alayer)
typeloc(atypeloc) {}
SEARCH_RESULT Inspect( EDA_BaseStruct* testItem, const void* testData )
{
const wxPoint* refPos = (const wxPoint*) testData;
if( testItem->m_StructType == TYPEMODULE )
{ {
int mlayer = ((MODULE*)testItem)->m_Layer;
if( typeloc & MATCH_LAYER )
{
if( layer != mlayer )
return SEARCH_CONTINUE;
} }
if( typeloc & VISIBLE_ONLY ) SEARCH_RESULT Inspect( EDA_BaseStruct* testItem, const void* testData )
{ {
if( !IsModuleLayerVisible(mlayer) ) const wxPoint& refPos = *(const wxPoint*) testData;
return SEARCH_CONTINUE;
}
if( testItem->HitTest( *refPos ) ) if( testItem->m_StructType == TYPEPAD )
{
if( testItem->HitTest( refPos ) )
{ {
found = testItem; found = testItem;
return SEARCH_QUIT; return SEARCH_QUIT;
} }
} }
else if( testItem->m_StructType == TYPEPAD )
else if( testItem->m_StructType == TYPEMODULE )
{
int mlayer = ((MODULE*)testItem)->m_Layer;
// consider only visible modules
if( IsModuleLayerVisible( mlayer ) )
{ {
if( testItem->HitTest( *refPos ) ) 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; found = testItem;
if( layer == mlayer )
return SEARCH_QUIT; return SEARCH_QUIT;
} }
} }
else { int debug=1; /* this should not happen, because of scanTypes */ } }
return SEARCH_CONTINUE; return SEARCH_CONTINUE;
} }
}; };
PadOrModule inspector1( layer, MATCH_LAYER ); PadOrModule inspector( layer );
PadOrModule inspector2( layer, VISIBLE_ONLY );
// search only for PADs first, then MODULES, and preferably a layer match
static const KICAD_T scanTypes[] = { TYPEPAD, TYPEMODULE, EOT }; static const KICAD_T scanTypes[] = { TYPEPAD, TYPEMODULE, EOT };
// search the current layer first IterateForward( m_Modules, &inspector, &refPos, scanTypes );
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;
return NULL; return inspector.found;
} }
#endif #endif
pcbnew/class_cotation.cpp
View file @ c1e3416a
This diff is collapsed.
pcbnew/class_cotation.h
View file @ c1e3416a
...@@ -6,9 +6,9 @@ ...@@ -6,9 +6,9 @@
#include "base_struct.h" #include "base_struct.h"
class COTATION: public EDA_BaseStruct class COTATION : public EDA_BaseStruct
{ {
public: public:
int m_Layer; // 0.. 32 ( NON bit a bit) int m_Layer; // 0.. 32 ( NON bit a bit)
int m_Width; int m_Width;
wxPoint m_Pos; wxPoint m_Pos;
...@@ -16,7 +16,7 @@ class COTATION: public EDA_BaseStruct ...@@ -16,7 +16,7 @@ class COTATION: public EDA_BaseStruct
int m_Unit; /* 0 = inches, 1 = mm */ int m_Unit; /* 0 = inches, 1 = mm */
int m_Value; /* valeur en unites PCB de la cote */ int m_Value; /* valeur en unites PCB de la cote */
TEXTE_PCB * m_Text; /* pour affichage du texte */ TEXTE_PCB* m_Text; /* pour affichage du texte */
int Barre_ox, Barre_oy, Barre_fx, Barre_fy; int Barre_ox, Barre_oy, Barre_fx, Barre_fy;
int TraitG_ox, TraitG_oy, TraitG_fx, TraitG_fy; int TraitG_ox, TraitG_oy, TraitG_fx, TraitG_fy;
int TraitD_ox, TraitD_oy, TraitD_fx, TraitD_fy; int TraitD_ox, TraitD_oy, TraitD_fx, TraitD_fy;
...@@ -25,23 +25,43 @@ class COTATION: public EDA_BaseStruct ...@@ -25,23 +25,43 @@ class COTATION: public EDA_BaseStruct
int FlecheG1_ox, FlecheG1_oy, FlecheG1_fx, FlecheG1_fy; int FlecheG1_ox, FlecheG1_oy, FlecheG1_fx, FlecheG1_fy;
int FlecheG2_ox, FlecheG2_oy, FlecheG2_fx, FlecheG2_fy; int FlecheG2_ox, FlecheG2_oy, FlecheG2_fx, FlecheG2_fy;
public: public:
COTATION(EDA_BaseStruct * StructFather); COTATION( EDA_BaseStruct* StructFather );
~COTATION(void); ~COTATION( void );
bool ReadCotationDescr(FILE * File, int * LineNum); bool ReadCotationDescr( FILE* File, int* LineNum );
bool WriteCotationDescr(FILE * File); bool WriteCotationDescr( FILE* File );
/* supprime du chainage la structure Struct */ /* supprime du chainage la structure Struct */
void UnLink( void ); void UnLink( void );
/* Modification du texte de la cotation */ /* Modification du texte de la cotation */
void SetText(const wxString & NewText); 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
pcbnew/class_edge_mod.cpp
View file @ c1e3416a
...@@ -438,6 +438,73 @@ int EDGE_MODULE::ReadDescr( char* Line, FILE* File, ...@@ -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) #if defined(DEBUG)
/** /**
* Function Show * Function Show
......
pcbnew/class_edge_mod.h
View file @ c1e3416a
...@@ -42,6 +42,14 @@ public: ...@@ -42,6 +42,14 @@ public:
int draw_mode ); int draw_mode );
void Draw3D( Pcb3D_GLCanvas* glcanvas ); 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) #if defined(DEBUG)
/** /**
* Function GetClass * Function GetClass
...@@ -50,7 +58,7 @@ public: ...@@ -50,7 +58,7 @@ public:
*/ */
virtual wxString GetClass() const virtual wxString GetClass() const
{ {
return wxT( "GRAPHIC" ); return wxT( "MGRAPHIC" );
// return wxT( "EDGE" ); ? // return wxT( "EDGE" ); ?
} }
......
pcbnew/class_mire.cpp
View file @ c1e3416a
...@@ -9,15 +9,15 @@ ...@@ -9,15 +9,15 @@
#include "pcbnew.h" #include "pcbnew.h"
MIREPCB::MIREPCB( EDA_BaseStruct* StructFather ) :
MIREPCB::MIREPCB(EDA_BaseStruct * StructFather): EDA_BaseStruct( StructFather, TYPEMIRE )
EDA_BaseStruct( StructFather, TYPEMIRE)
{ {
m_Shape = 0; m_Shape = 0;
m_Size = 5000; m_Size = 5000;
} }
MIREPCB::~MIREPCB(void)
MIREPCB::~MIREPCB( void )
{ {
} }
...@@ -25,33 +25,34 @@ MIREPCB::~MIREPCB(void) ...@@ -25,33 +25,34 @@ MIREPCB::~MIREPCB(void)
/***************************/ /***************************/
void MIREPCB::UnLink( void ) void MIREPCB::UnLink( void )
/***************************/ /***************************/
/* supprime du chainage la structure Struct /* 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 */ /* Modification du chainage arriere */
if( Pback ) if( Pback )
{ {
if( Pback->m_StructType != TYPEPCB) if( Pback->m_StructType != TYPEPCB )
{ {
Pback->Pnext = Pnext; Pback->Pnext = Pnext;
} }
else /* Le chainage arriere pointe sur la structure "Pere" */ else /* Le chainage arriere pointe sur la structure "Pere" */
{ {
((BOARD*)Pback)->m_Drawings = Pnext; ( (BOARD*) Pback )->m_Drawings = Pnext;
} }
} }
/* Modification du chainage avant */ /* Modification du chainage avant */
if( Pnext) Pnext->Pback = Pback; 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_Layer = source->m_Layer;
...@@ -64,101 +65,109 @@ void MIREPCB::Copy(MIREPCB * source) ...@@ -64,101 +65,109 @@ void MIREPCB::Copy(MIREPCB * source)
/**************************************************************/ /**************************************************************/
bool MIREPCB::ReadMirePcbDescr(FILE * File, int * LineNum) bool MIREPCB::ReadMirePcbDescr( FILE* File, int* LineNum )
/**************************************************************/ /**************************************************************/
/* Lecture de la description de 1 segment type Drawing PCB /* Lecture de la description de 1 segment type Drawing PCB
*/ */
{ {
char Line[256]; char Line[256];
while( GetLine(File, Line, LineNum ) != NULL ) while( GetLine( File, Line, LineNum ) != NULL )
{ {
if(strnicmp(Line,"$End",4 ) == 0 ) return TRUE; /* fin de liste */ if( strnicmp( Line, "$End", 4 ) == 0 )
if(Line[0] == 'P') return TRUE; /* fin de liste */
if( Line[0] == 'P' )
{ {
sscanf( Line+2," %X %d %d %d %d %d %lX", sscanf( Line + 2, " %X %d %d %d %d %d %lX",
&m_Shape, &m_Layer, &m_Shape, &m_Layer,
&m_Pos.x, &m_Pos.y, &m_Pos.x, &m_Pos.y,
&m_Size, &m_Width, &m_TimeStamp ); &m_Size, &m_Width, &m_TimeStamp );
if ( m_Layer < FIRST_NO_COPPER_LAYER ) if( m_Layer < FIRST_NO_COPPER_LAYER )
m_Layer = FIRST_NO_COPPER_LAYER; m_Layer = FIRST_NO_COPPER_LAYER;
if ( m_Layer > LAST_NO_COPPER_LAYER ) if( m_Layer > LAST_NO_COPPER_LAYER )
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, "$MIREPCB\n" );
fprintf( File,"Po %X %d %d %d %d %d %8.8lX\n", fprintf( File, "Po %X %d %d %d %d %d %8.8lX\n",
m_Shape, m_Layer, m_Shape, m_Layer,
m_Pos.x, m_Pos.y, m_Pos.x, m_Pos.y,
m_Size, m_Width, m_TimeStamp ); m_Size, m_Width, m_TimeStamp );
fprintf( File, "$EndMIREPCB\n"); fprintf( File, "$EndMIREPCB\n" );
return TRUE; return TRUE;
} }
/**********************************************************/ /**********************************************************/
void MIREPCB::Draw(WinEDA_DrawPanel * panel, wxDC * DC, void MIREPCB::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint & offset, int mode_color) const wxPoint& offset, int mode_color )
/**********************************************************/ /**********************************************************/
/* Affichage de 1 mire : 2 segments + 1 cercle /* Affichage de 1 mire : 2 segments + 1 cercle
le cercle a pour rayon le demi rayon 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 * les 2 traits ont pour longueur le diametre de la mire
*/ */
{ {
int rayon, ox, oy, gcolor, width; int rayon, ox, oy, gcolor, width;
int dx1,dx2, dy1, dy2; int dx1, dx2, dy1, dy2;
int typeaff; int typeaff;
int zoom; int zoom;
ox = m_Pos.x + offset.x; ox = m_Pos.x + offset.x;
oy = m_Pos.y + offset.y; oy = m_Pos.y + offset.y;
gcolor = g_DesignSettings.m_LayerColor[m_Layer]; gcolor = g_DesignSettings.m_LayerColor[m_Layer];
if ( (gcolor & ITEM_NOT_SHOW) != 0 ) return; if( (gcolor & ITEM_NOT_SHOW) != 0 )
return;
zoom = panel->GetZoom(); zoom = panel->GetZoom();
GRSetDrawMode(DC, mode_color); GRSetDrawMode( DC, mode_color );
typeaff = DisplayOpt.DisplayDrawItems; typeaff = DisplayOpt.DisplayDrawItems;
width = m_Width; width = m_Width;
if( width/zoom < 2 ) typeaff = FILAIRE; if( width / zoom < 2 )
typeaff = FILAIRE;
/* Trace du cercle: */ /* Trace du cercle: */
rayon = m_Size / 4; rayon = m_Size / 4;
switch( typeaff ) switch( typeaff )
{ {
case FILAIRE: case FILAIRE:
width = 0; width = 0;
case FILLED: case FILLED:
GRCircle(&panel->m_ClipBox, DC, ox, oy, rayon, width, gcolor); GRCircle( &panel->m_ClipBox, DC, ox, oy, rayon, width, gcolor );
break; break;
case SKETCH: case SKETCH:
GRCircle(&panel->m_ClipBox, DC, ox, oy, rayon + (width/2), gcolor) ; GRCircle( &panel->m_ClipBox, DC, ox, oy, rayon + (width / 2), gcolor );
GRCircle(&panel->m_ClipBox, DC, ox, oy, rayon - (width/2), gcolor) ; GRCircle( &panel->m_ClipBox, DC, ox, oy, rayon - (width / 2), gcolor );
break; break;
} }
/* Trace des 2 traits */ /* Trace des 2 traits */
rayon = m_Size/2; rayon = m_Size / 2;
dx1 = rayon, dy1 = 0; dx1 = rayon, dy1 = 0;
dx2 = 0, dy2 = rayon; dx2 = 0, dy2 = rayon;
if( m_Shape) /* Forme X */ if( m_Shape ) /* Forme X */
{ {
dx1 = dy1 = (rayon * 7)/5; dx1 = dy1 = (rayon * 7) / 5;
dx2 = dx1; dy2 = -dy1; dx2 = dx1; dy2 = -dy1;
} }
...@@ -166,20 +175,36 @@ int zoom; ...@@ -166,20 +175,36 @@ int zoom;
{ {
case FILAIRE: case FILAIRE:
case FILLED: case FILLED:
GRLine(&panel->m_ClipBox, DC, ox - dx1, oy - dy1, GRLine( &panel->m_ClipBox, DC, ox - dx1, oy - dy1,
ox + dx1, oy + dy1, width, gcolor); ox + dx1, oy + dy1, width, gcolor );
GRLine(&panel->m_ClipBox, DC, ox - dx2, oy - dy2, GRLine( &panel->m_ClipBox, DC, ox - dx2, oy - dy2,
ox + dx2, oy + dy2, width, gcolor); ox + dx2, oy + dy2, width, gcolor );
break; break;
case SKETCH: case SKETCH:
GRCSegm(&panel->m_ClipBox, DC, ox - dx1, oy - dy1, GRCSegm( &panel->m_ClipBox, DC, ox - dx1, oy - dy1,
ox + dx1, oy + dy1, ox + dx1, oy + dy1,
width, gcolor); width, gcolor );
GRCSegm(&panel->m_ClipBox, DC, ox - dx2, oy - dy2, GRCSegm( &panel->m_ClipBox, DC, ox - dx2, oy - dy2,
ox + dx2, oy + dy2, ox + dx2, oy + dy2,
width, gcolor); width, gcolor );
break; 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;
}
pcbnew/class_mire.h
View file @ c1e3416a
...@@ -7,31 +7,38 @@ ...@@ -7,31 +7,38 @@
#include "base_struct.h" #include "base_struct.h"
class MIREPCB: public EDA_BaseStruct class MIREPCB : public EDA_BaseStruct
{ {
public: public:
int m_Layer; // 0.. 32 ( NON bit a bit) int m_Layer; // 0.. 32 ( NON bit a bit)
int m_Width; int m_Width;
wxPoint m_Pos; wxPoint m_Pos;
int m_Shape; // bit 0 : 0 = forme +, 1 = forme X int m_Shape; // bit 0 : 0 = forme +, 1 = forme X
int m_Size; int m_Size;
public: public:
MIREPCB(EDA_BaseStruct * StructFather); MIREPCB( EDA_BaseStruct* StructFather );
~MIREPCB(void); ~MIREPCB( void );
bool WriteMirePcbDescr(FILE * File); bool WriteMirePcbDescr( FILE* File );
bool ReadMirePcbDescr(FILE * File, int * LineNum); bool ReadMirePcbDescr( FILE* File, int* LineNum );
/* supprime du chainage la structure Struct */ /* supprime du chainage la structure Struct */
void UnLink( void ); 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
pcbnew/class_module.h
View file @ c1e3416a
...@@ -144,7 +144,6 @@ public: ...@@ -144,7 +144,6 @@ public:
#if defined(DEBUG) #if defined(DEBUG)
/** /**
* Function GetClass * Function GetClass
* returns the class name. * returns the class name.
......
pcbnew/class_track.cpp
View file @ c1e3416a
This diff is collapsed.
pcbnew/class_track.h
View file @ c1e3416a
...@@ -19,75 +19,126 @@ ...@@ -19,75 +19,126 @@
/***/ /***/
class TRACK: public EDA_BaseLineStruct class TRACK : public EDA_BaseLineStruct
{ {
public: public:
int m_Shape; // vias: shape and type, Track = shape.. int m_Shape; // vias: shape and type, Track = shape..
int m_Drill; // for vias: via drill (- 1 for default value) int m_Drill; // for vias: via drill (- 1 for default value)
EDA_BaseStruct * start,* end; // pointers on a connected item (pad or track) EDA_BaseStruct* start, * end; // pointers on a connected item (pad or track)
int m_NetCode; // Net number int m_NetCode; // Net number
int m_Sous_Netcode; /* In rastnest routines : for the current net, int m_Sous_Netcode; /* In rastnest routines : for the current net,
block number (number common to the current connected items found) */ * block number (number common to the current connected items found) */
// chain = 0 indique une connexion non encore traitee // chain = 0 indique une connexion non encore traitee
int m_Param; // Auxiliary variable ( used in some computations ) int m_Param; // Auxiliary variable ( used in some computations )
public: public:
TRACK(EDA_BaseStruct * StructFather, DrawStructureType idtype = TYPETRACK); TRACK( EDA_BaseStruct* StructFather, DrawStructureType idtype = TYPETRACK );
TRACK(const TRACK & track); TRACK( const TRACK& track );
TRACK* Next( void ); // Retourne le chainage avant
TRACK * Next(void); // Retourne le chainage avant TRACK* Back( void ) // Retourne le chainage avant
TRACK * Back(void) // Retourne le chainage avant
{ {
return (TRACK*) Pback; return (TRACK*) Pback;
} }
/* supprime du chainage la structure Struct */ /* supprime du chainage la structure Struct */
void UnLink( void ); void UnLink( void );
// Read/write data // Read/write data
bool WriteTrackDescr(FILE * File); bool WriteTrackDescr( FILE* File );
/* Ajoute un element a la liste */ /* Ajoute un element a la liste */
void Insert(BOARD * Pcb, EDA_BaseStruct * InsertPoint); void Insert( BOARD* Pcb, EDA_BaseStruct* InsertPoint );
/* Recherche du meilleur point d'insertion */ /* Recherche du meilleur point d'insertion */
TRACK * GetBestInsertPoint( BOARD * Pcb); TRACK* GetBestInsertPoint( BOARD* Pcb );
/* Copie d'un Element d'une chaine de n elements */ /* Copie d'un Element d'une chaine de n elements */
TRACK * Copy( int NbSegm = 1 ); TRACK* Copy( int NbSegm = 1 );
/* Recherche du debut du net /* Recherche du debut du net
( les elements sont classes par net_code croissant ) */ * ( les elements sont classes par net_code croissant ) */
TRACK * GetStartNetCode(int NetCode ); TRACK* GetStartNetCode( int NetCode );
/* Recherche de la fin du net */ /* Recherche de la fin du net */
TRACK * GetEndNetCode(int NetCode); TRACK* GetEndNetCode( int NetCode );
/* Display on screen: */ /* Display on screen: */
void Draw(WinEDA_DrawPanel * panel, wxDC * DC, int draw_mode); void Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode );
/* divers */ /* divers */
int Shape(void) { return m_Shape & 0xFF; } 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
int ReturnMaskLayer(void);
int IsPointOnEnds(const wxPoint & point, int min_dist = 0);
bool IsNull(void); // return TRUE if segment lenght = 0
}; };
class SEGZONE: public TRACK class SEGZONE : public TRACK
{ {
public: 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: public:
SEGVIA(EDA_BaseStruct * StructFather); SEGVIA( EDA_BaseStruct* StructFather );
bool IsViaOnLayer(int layer); bool IsViaOnLayer( int layer );
void SetLayerPair(int top_layer, int bottom_layer); void SetLayerPair( int top_layer, int bottom_layer );
void ReturnLayerPair(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 */ #endif /* CLASS_TRACK_H */
pcbnew/classpcb.cpp
View file @ c1e3416a
...@@ -16,6 +16,7 @@ ...@@ -16,6 +16,7 @@
#endif #endif
#include "protos.h" #include "protos.h"
#include "trigo.h"
/**************************************************************/ /**************************************************************/
...@@ -165,6 +166,61 @@ bool DRAWSEGMENT::ReadDrawSegmentDescr( FILE* File, int* LineNum ) ...@@ -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 */ /* Classe MARQUEUR */
/*******************/ /*******************/
......
pcbnew/drc.cpp
View file @ c1e3416a
This diff is collapsed.
pcbnew/edit.cpp
View file @ c1e3416a
...@@ -128,8 +128,7 @@ void WinEDA_PcbFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos ) ...@@ -128,8 +128,7 @@ void WinEDA_PcbFrame::OnLeftClick( wxDC* DC, const wxPoint& MousePos )
#if defined(DEBUG) #if defined(DEBUG)
DrawStruct = m_Pcb->FindPadOrModule( DrawStruct = m_Pcb->FindPadOrModule(
GetScreen()->RefPos(true), GetScreen()->RefPos(true),
GetScreen()->m_Active_Layer, GetScreen()->m_Active_Layer );
VISIBLE_ONLY );
#else #else
DrawStruct = PcbGeneralLocateAndDisplay(); DrawStruct = PcbGeneralLocateAndDisplay();
#endif #endif
......
pcbnew/locate.cpp
View file @ c1e3416a
This diff is collapsed.
pcbnew/protos.h
View file @ c1e3416a
...@@ -198,24 +198,6 @@ D_PAD * Fast_Locate_Pad_Connecte(BOARD * Pcb, const wxPoint & ref_pos, int layer ...@@ -198,24 +198,6 @@ D_PAD * Fast_Locate_Pad_Connecte(BOARD * Pcb, const wxPoint & ref_pos, int layer
(bonne position ET bonne couche). */ (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,int layer, int typeloc);
TRACK * Locate_Zone(TRACK * start_adresse, const wxPoint & ref_pos,int layer); TRACK * Locate_Zone(TRACK * start_adresse, const wxPoint & ref_pos,int layer);
/* /*
......
pcbnew/zones.h
View file @ c1e3416a
...@@ -122,5 +122,5 @@ public: ...@@ -122,5 +122,5 @@ public:
WinEDA_PcbFrame * m_Parent; WinEDA_PcbFrame * m_Parent;
}; };
#endif #endif // _ZONES_H_
// _ZONES_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment