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

beautification, commenting, and renaming

This commit is contained in:
dickelbeck 2007-08-04 20:05:54 +00:00
parent caa42eafca
commit 2e4c17a8b0
9 changed files with 1191 additions and 1050 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
change_log.txt
View File

@ -6,10 +6,18 @@ email address.
2007-Aug-05 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
+ pcbnew & common
Changed the function name of Locate( const wxPoint& ref_pos ) to bool HitTest(..)
in both class_text_mod and base_struct.
More beautification and commenting.
2007-Aug-04 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
+ pcbnew
Read-ability formatting, I am playing with a C++ beautifier called uncrustify.
Read-ability formatting, I am playing with a C++ beautifier called "uncrustify".
I had to patch it and spent 2 days getting it configured. Patch not
sent upstream yet.
Fixed a bug in "display local ratsnest pad or module": if you had a small

172
common/base_struct.cpp
View File

@ -69,8 +69,6 @@ wxT("unknown")
};
enum textbox {
ID_TEXTBOX_LIST = 8010
};
@ -94,6 +92,7 @@ EDA_BaseStruct::EDA_BaseStruct(int idType)
m_StructType = idType;
}
/********************************************/
void EDA_BaseStruct::InitVars( void )
/********************************************/
@ -114,21 +113,25 @@ void EDA_BaseStruct::InitVars(void)
/* Gestion de l'etat (status) de la structure (active, deleted..) */
int EDA_BaseStruct::GetState( int type )
{
return(m_Status & type);
return m_Status & type;
}
void EDA_BaseStruct::SetState( int type, int state )
{
if( state ) m_Status |= type; /* state = ON ou OFF */
else m_Status &= ~type;
if( state )
m_Status |= type;/* state = ON ou OFF */
else
m_Status &= ~type;
}
/*********************************************************/
void EDA_BaseStruct::AddToChain( EDA_BaseStruct* laststruct )
/*********************************************************/
/*
addition d'une nouvelle struct a la liste chainée, apres la structure laststruct
* addition d'une nouvelle struct a la liste chain<EFBFBD>, apres la structure laststruct
*/
{
Pnext = laststruct->Pnext;
@ -141,45 +144,53 @@ addition d'une nouvelle struct a la liste chain
void EDA_BaseStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& offset,
int draw_mode, int Color )
/**************************************************************************************/
/* Virtual
*/
{
wxString msg, name;
msg.Printf( wxT("EDA_BaseStruct::Draw() error. Method for struct type %d used but not implemented ("),
msg.Printf( wxT(
"EDA_BaseStruct::Draw() error. Method for struct type %d used but not implemented (" ),
m_StructType );
msg += ReturnClassName() + wxT( ")\n" );
printf( CONV_TO_UTF8( msg ) );
}
#if 0
/**************************************************************/
void EDA_BaseStruct::Place( WinEDA_DrawFrame* frame, wxDC* DC )
/**************************************************************/
/* fonction virtuelle de placement: non utilisee en pcbnew (utilisee eeschema)
---- A mieux utiliser (TODO...)
* ---- A mieux utiliser (TODO...)
*/
{
}
#endif
/*********************************************/
wxString EDA_BaseStruct::ReturnClassName( void )
/*********************************************/
/* Used at run time for diags: return the class name of the item,
from its .m_StructType value.
* from its .m_StructType value.
*/
{
int ii = m_StructType;
wxString classname;
if ( (ii < 0) || (ii > MAX_STRUCT_TYPE_ID) ) ii = MAX_STRUCT_TYPE_ID;
if( (ii < 0) || (ii > MAX_STRUCT_TYPE_ID) )
ii = MAX_STRUCT_TYPE_ID;
classname = DrawStructureTypeName[ii];
return classname;
}
/**********************************************************************************************/
EDA_BaseLineStruct::EDA_BaseLineStruct( EDA_BaseStruct* StructFather, DrawStructureType idtype ) :
EDA_BaseStruct( StructFather, idtype )
@ -191,7 +202,7 @@ EDA_BaseLineStruct::EDA_BaseLineStruct(EDA_BaseStruct * StructFather, DrawStruct
/*********************************************************/
/* EDA_TextStruct (classe de base, non utilisée seule */
/* EDA_TextStruct (classe de base, non utilis<EFBFBD> seule */
/*********************************************************/
EDA_TextStruct::EDA_TextStruct( const wxString& text )
{
@ -207,7 +218,7 @@ EDA_TextStruct::EDA_TextStruct(const wxString & text)
m_Text = text;
m_ZoomLevelDrawable = 0; /* Niveau de zoom acceptable pour affichage normal */
m_TextDrawings = NULL; /* Pointeur sur le dessin du caractere */
m_TextDrawingsSize = 0; /* taille du tableau pointé */
m_TextDrawingsSize = 0; /* taille du tableau point<6E>*/
}
@ -220,14 +231,18 @@ EDA_TextStruct::~EDA_TextStruct(void)
m_TextDrawingsSize = 0; /* nombre de sommets a dessiner */
}
/********************************/
int EDA_TextStruct::Len_Size( void )
/********************************/
// Return the text lenght in internal units
{
int nbchar = m_Text.Len();
int len;
if ( nbchar == 0 ) return 0;
if( nbchar == 0 )
return 0;
len = ( (10 * m_Size.x ) / 9 ) * nbchar;
return len;
@ -235,12 +250,13 @@ int len;
/*************************************************/
int EDA_TextStruct::Locate(const wxPoint & posref)
bool EDA_TextStruct::HitTest( const wxPoint& posref )
/*************************************************/
/* locate function
return:
1 if posref is inside the text area.
0 else.
* return:
* true if posref is inside the text area.
* false else.
*/
{
int dx, dy;
@ -250,33 +266,42 @@ int spot_cX, spot_cY;
dy = m_Size.y / 2;
/* Is the ref point inside the text area ? */
spot_cX = posref.x - m_Pos.x ; spot_cY = posref.y - m_Pos.y ;
spot_cX = posref.x - m_Pos.x;
spot_cY = posref.y - m_Pos.y;
RotatePoint( &spot_cX, &spot_cY, -m_Orient );
if( (abs(spot_cX) <= abs(dx) ) && ( abs(spot_cY) <= abs(dy) ) ) return 1;
return 0;
if( ( abs( spot_cX ) <= abs( dx ) ) && ( abs( spot_cY ) <= abs( dy ) ) )
return true;
return false;
}
/*******************************/
int EDA_TextStruct::Pitch( void )
/*******************************/
/* retourne le pas entre 2 caracteres
*/
{
return ( (10 * m_Size.x ) / 9 ) + m_Width;
}
/***************************************************************/
void EDA_TextStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
const wxPoint& offset, int color, int draw_mode,
int display_mode, int anchor_color )
/***************************************************************/
/*
Trace de 1 texte type EDA_TextStruct.
offset = Offset de trace (usuellement (0,0)
color = couleur du texte
draw_mode = GR_OR, GR_XOR.., -1 si mode courant.
display_mose = FILAIRE, FILLED ou SKETCH
anchor_color = couleur de l'ancre ( -1 si pas d'ancre ).
* Trace de 1 texte type EDA_TextStruct.
* offset = Offset de trace (usuellement (0,0)
* color = couleur du texte
* draw_mode = GR_OR, GR_XOR.., -1 si mode courant.
* display_mose = FILAIRE, FILLED ou SKETCH
* anchor_color = couleur de l'ancre ( -1 si pas d'ancre ).
*/
{
int zoom;
@ -286,13 +311,16 @@ int width;
if( m_TextDrawings == NULL ) /* pointeur sur la liste des segments de dessin */
CreateDrawData();
if( m_TextDrawings == NULL) return;
if( m_TextDrawings == NULL )
return;
zoom = panel->GetZoom();
width = m_Width / zoom;
if ( display_mode == FILAIRE ) width = 0;
if( display_mode == FILAIRE )
width = 0;
/* choix de la couleur du texte : */
if ( draw_mode != -1 ) GRSetDrawMode(DC, draw_mode);
if( draw_mode != -1 )
GRSetDrawMode( DC, draw_mode );
/* trace du texte */
if( zoom > m_ZoomLevelDrawable )
@ -304,7 +332,6 @@ int width;
m_TextDrawings[4] + offset.y + m_Pos.y,
width, color );
}
else
{
/* trace ancre du texte ? */
@ -325,7 +352,8 @@ int width;
while( ii < m_TextDrawingsSize )
{
nbpoints = m_TextDrawings[jj];
if (nbpoints > 50 ) nbpoints = 50;
if( nbpoints > 50 )
nbpoints = 50;
for( kk = 0, ll = 0; (kk < nbpoints) && (ii < m_TextDrawingsSize); kk++ )
{
coord[ll] = m_TextDrawings[ii] + offset.x + m_Pos.x;
@ -333,6 +361,7 @@ int width;
coord[ll] = m_TextDrawings[ii] + offset.y + m_Pos.y;
ll++; ii++;
}
jj = ii; ii++;
if( width > 2 )
@ -345,7 +374,8 @@ int width;
coord[ll + 2], coord[ll + 3],
m_Width, color );
else GRFillCSegm(&panel->m_ClipBox, DC,
else
GRFillCSegm( &panel->m_ClipBox, DC,
coord[ll], coord[ll + 1],
coord[ll + 2], coord[ll + 3],
m_Width, color );
@ -353,24 +383,25 @@ int width;
}
else
GRPoly( &panel->m_ClipBox, DC, nbpoints, coord, 0, 0, color, color );
}
}
}
}
}
}
/****************************************/
void EDA_TextStruct::CreateDrawData( void )
/****************************************/
/* Cree le tableau de données nécessaire au trace d'un texte (pcb, module..)
Met a jour:
m_ZoomLevelDrawable Niveau de zoom acceptable pour affichage normal
m_TextDrawings Pointeur sur le tableau de données
m_TextDrawingsSize taille (en int) du tableau
Codage dans le tableau:
Suite des coord des sommets des polygones a tracer précédé du nombre de sommets
nn xx1 yy1 xx2 yy2 .. xxn yyn mm xx1 yy1 xx2 yy2 .. xxm yym
les 2 premiers sommets sont le segment symbolisant le texte pour les
affichages a trop petite echelle
/* Cree le tableau de donn<6E>s n<>essaire au trace d'un texte (pcb, module..)
* Met a jour:
* m_ZoomLevelDrawable Niveau de zoom acceptable pour affichage normal
* m_TextDrawings Pointeur sur le tableau de donn<EFBFBD>s
* m_TextDrawingsSize taille (en int) du tableau
* Codage dans le tableau:
* Suite des coord des sommets des polygones a tracer pr<EFBFBD><EFBFBD><EFBFBD>du nombre de sommets
* nn xx1 yy1 xx2 yy2 .. xxn yyn mm xx1 yy1 xx2 yy2 .. xxm yym
* les 2 premiers sommets sont le segment symbolisant le texte pour les
* affichages a trop petite echelle
*/
{
int ii, jj, kk, nbchar, nbpoints, AsciiCode, endcar;
@ -392,7 +423,8 @@ int coord_count_max = 1000;
m_TextDrawingsSize = 0; /* nombre de segments a dessiner */
nbchar = m_Text.Length();
if ( nbchar == 0 ) return;
if( nbchar == 0 )
return;
size_h = m_Size.x;
size_v = m_Size.y;
@ -443,7 +475,6 @@ int coord_count_max = 1000;
break;
}
}
else /* Texte Vertical */
{
switch( m_HJustify )
@ -478,7 +509,7 @@ int coord_count_max = 1000;
ox = cX - dx;; oy = cY + dy;
/* lorsque les chars sont trop petits pour etre dessines,
le texte est symbolise par une barre */
* le texte est symbolise par une barre */
m_ZoomLevelDrawable = m_Size.x / 3;
dx = (espacement * nbchar) / 2;
dy = size_v / 2; /* Decalage du debut du texte / centre */
@ -498,11 +529,13 @@ int coord_count_max = 1000;
x0 = 0; y0 = 0;
AsciiCode = (*ptr) & 255;
ptcar = graphic_fonte_shape[AsciiCode]; /* ptcar pointe la description
du caractere a dessiner */
* du caractere a dessiner */
for( endcar = FALSE; !endcar; ptcar++ )
{
f_cod = *ptcar ; /* get code n de la forme selectionnee */
f_cod = *ptcar;
/* get code n de la forme selectionnee */
switch( f_cod )
{
case 'X':
@ -525,7 +558,7 @@ int coord_count_max = 1000;
case 'D':
plume = f_cod;
nbpoints = 1; /* 1 point va suivre (origine du tracé) */
nbpoints = 1; /* 1 point va suivre (origine du trac<61> */
break;
default:
@ -547,21 +580,27 @@ int coord_count_max = 1000;
nbpoints++;
break;
}
} /* end switch */
} /* end boucle for = end trace de 1 caractere */
}
/* end switch */
}
/* end boucle for = end trace de 1 caractere */
ptr++; ox += espacement;
} /* end trace du texte */
}
/* end trace du texte */
m_TextDrawings = (int*) realloc( coord, ii * sizeof(int) );
m_TextDrawingsSize = ii; //taille (en int) du tableau
}
/******************************/
void EDA_Rect::Normalize( void )
/******************************/
// Ensure the height ant width are >= 0
{
if( m_Size.y < 0 )
@ -580,8 +619,9 @@ void EDA_Rect::Normalize(void)
/*******************************************/
bool EDA_Rect::Inside( const wxPoint& point )
/*******************************************/
/* Return TRUE if point is in Rect
Accept rect size < 0
* Accept rect size < 0
*/
{
int rel_posx = point.x - m_Pos.x;
@ -597,12 +637,13 @@ wxSize size = m_Size;
{
size.y = -size.y; rel_posy += size.y;
}
return ( (rel_posx >= 0) && (rel_posy >= 0)
return (rel_posx >= 0) && (rel_posy >= 0)
&& ( rel_posy <= size.y)
&& ( rel_posx <= size.x)
);
;
}
/**************************************************/
EDA_Rect& EDA_Rect::Inflate( wxCoord dx, wxCoord dy )
/**************************************************/
@ -639,16 +680,15 @@ EDA_Rect& EDA_Rect::Inflate(wxCoord dx, wxCoord dy)
}
/**************************/
/* class DrawPickedStruct */
/**************************/
/* This class has only one useful member: .m_PickedStruct, used as a link.
It does not describe really an item.
It is used to create a linked list of selected items (in block selection).
Each DrawPickedStruct item has is member: .m_PickedStruct pointing the
real selected item
* It does not describe really an item.
* It is used to create a linked list of selected items (in block selection).
* Each DrawPickedStruct item has is member: .m_PickedStruct pointing the
* real selected item
*/
/*******************************************************************/
@ -659,6 +699,7 @@ DrawPickedStruct::DrawPickedStruct(EDA_BaseStruct *pickedstruct ) :
m_PickedStruct = pickedstruct;
}
DrawPickedStruct::~DrawPickedStruct( void )
{
}
@ -667,8 +708,9 @@ DrawPickedStruct::~DrawPickedStruct(void)
/*********************************************/
void DrawPickedStruct::DeleteWrapperList( void )
/*********************************************/
/* Delete this item all the items of the linked list
Free the wrapper, but DOES NOT delete the picked items linked by .m_PickedStruct
* Free the wrapper, but DOES NOT delete the picked items linked by .m_PickedStruct
*/
{
DrawPickedStruct* wrapp_struct, * next_struct;

115
common/trigo.cpp
View File

@ -12,63 +12,77 @@
/***********************************/
int ArcTangente( int dy, int dx )
/***********************************/
/* Retourne l'arc tangente en 0.1 degres du vecteur de coord dx, dy
entre -1800 et 1800
Analogue a atan2 ( mais plus rapide pour les calculs si
l'angle est souvent 0, -1800, ou +- 900
* entre -1800 et 1800
* Analogue a atan2 ( mais plus rapide pour les calculs si
* l'angle est souvent 0, -1800, ou +- 900
*/
{
double fangle;
if( dy == 0 )
{
if(dx >= 0 ) return(0);
else return(-1800);
if( dx >= 0 )
return 0;
else
return -1800;
}
if( dx == 0 )
{
if(dy >= 0 ) return(900);
else return(-900);
if( dy >= 0 )
return 900;
else
return -900;
}
if( dx == dy )
{
if(dx >= 0) return(450);
else return(-1800+450);
if( dx >= 0 )
return 450;
else
return -1800 + 450;
}
if( dx == -dy )
{
if(dx >= 0) return(-450);
else return(1800-450);
if( dx >= 0 )
return -450;
else
return 1800 - 450;
}
fangle = atan2( (double) dy, (double) dx ) / M_PI * 1800;
return( (int) round(fangle) );
return (int) round( fangle );
}
/*********************************************/
void RotatePoint( int* pX, int* pY, int angle )
/*********************************************/
/*
Fonction surchargee!
calcule les nouvelles coord du point de coord pX, pY,
pour une rotation de centre 0, 0, et d'angle angle ( en 1/10 degre)
* Fonction surchargee!
* calcule les nouvelles coord du point de coord pX, pY,
* pour une rotation de centre 0, 0, et d'angle angle ( en 1/10 degre)
*/
{
float fpx, fpy;
int tmp;
while (angle < 0) angle += 3600;
while (angle >= 3600) angle -= 3600;
while( angle < 0 )
angle += 3600;
if (angle == 0) return;
while( angle >= 3600 )
angle -= 3600;
if( angle == 0 )
return;
/* Calcul des coord :
coord: xrot = y*sin + x*cos
yrot = y*cos - x*sin
* coord: xrot = y*sin + x*cos
* yrot = y*cos - x*sin
*/
if( angle == 900 ) /* sin = 1, cos = 0 */
{
@ -76,25 +90,24 @@ int tmp;
*pX = *pY;
*pY = -tmp;
}
else if( angle == 1800 ) /* sin = 0, cos = -1 */
{
*pX = -*pX;
*pY = -*pY;
}
else if( angle == 2700 ) /* sin = -1, cos = 0 */
{
tmp = *pX;
*pX = -*pY;
*pY = tmp;
}
else
{
fpx = (*pY * fsinus[angle]) + (*pX * fcosinus[angle]);
fpy = (*pY * fcosinus[angle]) - (*pX * fsinus[angle]);
*pX = (int)round(fpx); *pY = (int)round(fpy);
*pX = (int) round( fpx );
*pY = (int) round( fpy );
}
}
@ -102,32 +115,40 @@ int tmp;
/************************************************************/
void RotatePoint( int* pX, int* pY, int cx, int cy, int angle )
/*************************************************************/
/*
Fonction surchargee!
calcule les nouvelles coord du point de coord pX, pY,
pour une rotation de centre cx, cy, et d'angle angle ( en 1/10 degre)
* Fonction surchargee!
* calcule les nouvelles coord du point de coord pX, pY,
* pour une rotation de centre cx, cy, et d'angle angle ( en 1/10 degre)
*/
{
int ox, oy;
ox = *pX - cx; oy = *pY - cy;
ox = *pX - cx;
oy = *pY - cy;
RotatePoint( &ox, &oy, angle );
*pX = ox + cx;
*pY = oy + cy;
}
/*****************************************************************/
void RotatePoint( wxPoint* point, const wxPoint& centre, int angle )
/*****************************************************************/
/*
Fonction surchargee!
calcule les nouvelles coord du point point,
pour une rotation de centre centre, et d'angle angle ( en 1/10 degre)
* Fonction surchargee!
* calcule les nouvelles coord du point point,
* pour une rotation de centre centre, et d'angle angle ( en 1/10 degre)
*/
{
int ox, oy;
ox = point->x - centre.x; oy = point->y - centre.y;
ox = point->x - centre.x;
oy = point->y - centre.y;
RotatePoint( &ox, &oy, angle );
point->x = ox + centre.x;
point->y = oy + centre.y;
@ -140,8 +161,11 @@ void RotatePoint(double *pX, double *pY, double cx, double cy, int angle)
{
double ox, oy;
ox = *pX - cx; oy = *pY - cy;
ox = *pX - cx;
oy = *pY - cy;
RotatePoint( &ox, &oy, angle );
*pX = ox + cx;
*pY = oy + cy;
}
@ -150,39 +174,46 @@ double ox, oy;
/*************************************************/
void RotatePoint( double* pX, double* pY, int angle )
/*************************************************/
/* Calcul des coord :
coord: xrot = y*sin + x*cos
yrot = y*cos - x*sin
* coord: xrot = y*sin + x*cos
* yrot = y*cos - x*sin
*/
{
double tmp;
while (angle < 0) angle += 3600;
while (angle >= 3600) angle -= 3600;
if (angle == 0) return;
while( angle < 0 )
angle += 3600;
while( angle >= 3600 )
angle -= 3600;
if( angle == 0 )
return;
if( angle == 900 ) /* sin = 1, cos = 0 */
{
tmp = *pX;
*pX = *pY;
*pY = -tmp;
}
else if( angle == 1800 ) /* sin = 0, cos = -1 */
{
*pX = -*pX;
*pY = -*pY;
}
else if( angle == 2700 ) /* sin = -1, cos = 0 */
{
tmp = *pX;
*pX = -*pY;
*pY = tmp;
}
else
{
double fpx = (*pY * fsinus[angle]) + (*pX * fcosinus[angle]);
double fpy = (*pY * fcosinus[angle]) - (*pX * fsinus[angle]);
*pX = fpx; *pY = fpy;
*pX = fpx;
*pY = fpy;
}
}

10
include/base_struct.h
View File

@ -179,8 +179,14 @@ public:
const wxPoint& offset, int color,
int draw_mode, int display_mode = FILAIRE, int anchor_color = -1 );
/* locate functions */
int Locate( const wxPoint& posref );
/**
* Function HitTest
* tests if the given wxPoint is within the bounds of this object.
* @param posref A wxPoint to test
* @return bool - true if a hit, else false
*/
bool HitTest( const wxPoint& posref );
int Len_Size( void ); // Return the text lenght in internal units
};

51
pcbnew/class_board.cpp
View File

@ -9,7 +9,6 @@
#include "bitmaps.h"
/*****************/
/* Class BOARD: */
/*****************/
@ -43,6 +42,7 @@ BOARD::BOARD(EDA_BaseStruct * parent, WinEDA_BasePcbFrame * frame):
// de determination des contours de zone
}
/***************/
/* Destructeur */
/***************/
@ -60,7 +60,6 @@ void BOARD::UnLink( void )
{
Pback->Pnext = Pnext;
}
else /* Le chainage arriere pointe sur la structure "Pere" */
{
// Pback-> = Pnext;
@ -68,48 +67,58 @@ void BOARD::UnLink( void )
}
/* Modification du chainage avant */
if( Pnext) Pnext->Pback = Pback;
if( Pnext )
Pnext->Pback = Pback;
Pnext = Pback = NULL;
}
/* Routines de calcul des nombres de segments pistes et zones */
int BOARD::GetNumSegmTrack( void )
{
TRACK* CurTrack = m_Track;
int ii = 0;
for ( ;CurTrack != NULL; CurTrack = (TRACK*)CurTrack->Pnext ) ii++;
for( ; CurTrack != NULL; CurTrack = (TRACK*) CurTrack->Pnext )
ii++;
m_NbSegmTrack = ii;
return(ii);
return ii;
}
int BOARD::GetNumSegmZone( void )
{
TRACK* CurTrack = m_Zone;
int ii = 0;
for ( ;CurTrack != NULL; CurTrack = (TRACK*)CurTrack->Pnext ) ii++;
for( ; CurTrack != NULL; CurTrack = (TRACK*) CurTrack->Pnext )
ii++;
m_NbSegmZone = ii;
return(ii);
return ii;
}
// retourne le nombre de connexions manquantes
int BOARD::GetNumNoconnect( void )
{
return(m_NbNoconnect);
return m_NbNoconnect;
}
// retourne le nombre de chevelus
int BOARD::GetNumRatsnests( void )
{
return(m_NbLinks);
return m_NbLinks;
}
// retourne le nombre de pads a netcode > 0
int BOARD::GetNumNodes( void )
{
return(m_NbNodes);
return m_NbNodes;
}
@ -118,13 +127,13 @@ bool BOARD::ComputeBoundaryBox(void)
/***********************************/
/* Determine le rectangle d'encadrement du pcb
Ce rectangle englobe les contours pcb, pads , vias et piste
Sortie:
m_PcbBox
retourne:
0 si aucun element utile
1 sinon
* Ce rectangle englobe les contours pcb, pads , vias et piste
* Sortie:
* m_PcbBox
*
* retourne:
* 0 si aucun element utile
* 1 sinon
*/
{
int rayon, cx, cy, d, xmin, ymin, xmax, ymax;
@ -140,9 +149,12 @@ TRACK * Track;
PtStruct = m_Drawings;
for( ; PtStruct != NULL; PtStruct = PtStruct->Pnext )
{
if( PtStruct->m_StructType != TYPEDRAWSEGMENT ) continue;
if( PtStruct->m_StructType != TYPEDRAWSEGMENT )
continue;
ptr = (DRAWSEGMENT*) PtStruct;
d = (ptr->m_Width / 2) + 1;
if( ptr->m_Shape == S_CIRCLE )
{
cx = ptr->m_Start.x; cy = ptr->m_Start.y;
@ -240,6 +252,5 @@ TRACK * Track;
m_BoundaryBox.SetWidth( xmax - xmin );
m_BoundaryBox.SetHeight( ymax - ymin );
return(Has_Items);
return Has_Items;
}

97
pcbnew/class_text_mod.cpp
View File

@ -46,14 +46,17 @@ MODULE * Module = (MODULE*) m_Parent;
{
m_Pos = Module->m_Pos;
m_Layer = Module->m_Layer;
if( Module->m_Layer == CUIVRE_N) m_Layer = SILKSCREEN_N_CU;
if(Module->m_Layer == CMP_N) m_Layer = SILKSCREEN_N_CMP;
if((Module->m_Layer == SILKSCREEN_N_CU) ||
(Module->m_Layer == ADHESIVE_N_CU) || (Module->m_Layer == CUIVRE_N))
if( Module->m_Layer == CUIVRE_N )
m_Layer = SILKSCREEN_N_CU;
if( Module->m_Layer == CMP_N )
m_Layer = SILKSCREEN_N_CMP;
if( (Module->m_Layer == SILKSCREEN_N_CU)
|| (Module->m_Layer == ADHESIVE_N_CU) || (Module->m_Layer == CUIVRE_N) )
m_Miroir = 0;
}
}
TEXTE_MODULE::~TEXTE_MODULE( void )
{
}
@ -61,7 +64,8 @@ TEXTE_MODULE:: ~TEXTE_MODULE(void)
void TEXTE_MODULE::Copy( TEXTE_MODULE* source ) // copy structure
{
if (source == NULL) return;
if( source == NULL )
return;
m_Pos = source->m_Pos;
m_Layer = source->m_Layer;
@ -78,8 +82,9 @@ void TEXTE_MODULE::Copy(TEXTE_MODULE * source) // copy structure
m_Text = source->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 TEXTE_MODULE::UnLink( void )
{
@ -90,7 +95,6 @@ void TEXTE_MODULE::UnLink( void )
{
Pback->Pnext = Pnext;
}
else /* Le chainage arriere pointe sur la structure "Pere" */
{
( (MODULE*) Pback )->m_Drawings = Pnext;
@ -98,7 +102,8 @@ void TEXTE_MODULE::UnLink( void )
}
/* Modification du chainage avant */
if( Pnext) Pnext->Pback = Pback;
if( Pnext )
Pnext->Pback = Pback;
Pnext = Pback = NULL;
}
@ -111,6 +116,7 @@ int TEXTE_MODULE:: GetLength(void)
return m_Text.Len();
}
/******************************************/
void TEXTE_MODULE:: SetWidth( int new_width )
/******************************************/
@ -118,14 +124,16 @@ void TEXTE_MODULE:: SetWidth(int new_width)
m_Width = new_width;
}
// mise a jour des coordonnées absolues pour affichage
// mise a jour des coordonn<6E>s absolues pour affichage
void TEXTE_MODULE:: SetDrawCoord( void )
{
MODULE* Module = (MODULE*) m_Parent;
m_Pos = m_Pos0;
if ( Module == NULL ) return;
if( Module == NULL )
return;
int angle = Module->m_Orient;
NORMALIZE_ANGLE_POS( angle );
@ -135,12 +143,14 @@ MODULE * Module = (MODULE *) m_Parent;
m_Pos.y += Module->m_Pos.y;
}
// mise a jour des coordonnées relatives au module
// mise a jour des coordonn<6E>s relatives au module
void TEXTE_MODULE:: SetLocalCoord( void )
{
MODULE* Module = (MODULE*) m_Parent;
if ( Module == NULL ) return;
if( Module == NULL )
return;
m_Pos0.x = m_Pos.x - Module->m_Pos.x;
m_Pos0.y = m_Pos.y - Module->m_Pos.y;
@ -151,40 +161,46 @@ MODULE * Module = (MODULE *) m_Parent;
RotatePoint( &m_Pos0.x, &m_Pos0.y, -angle );
}
/* locate functions */
int TEXTE_MODULE:: Locate(const wxPoint & posref)
bool TEXTE_MODULE::HitTest( const wxPoint& posref )
{
int mX, mY, dx, dy;
MODULE* Module = (MODULE*) m_Parent;
int angle = m_Orient;
if (Module) angle += Module->m_Orient;
if( Module )
angle += Module->m_Orient;
dx = ( m_Size.x * GetLength() ) / 2;
dy = m_Size.y / 2;
dx = ( (dx * 10) / 9 ) + m_Width; /* Facteur de forme des lettres : 10/9 */
/* le point de reference est tourné de - angle
pour se ramener a un rectangle de reference horizontal */
mX = posref.x - m_Pos.x; mY = posref.y - m_Pos.y;
/* le point de reference est tourn<72>de - angle
* pour se ramener a un rectangle de reference horizontal */
mX = posref.x - m_Pos.x;
mY = posref.y - m_Pos.y;
RotatePoint( &mX, &mY, -angle );
/* le point de reference est-il dans ce rectangle */
if( ( abs( mX ) <= abs( dx ) ) && ( abs( mY ) <= abs( dy ) ) )
{
return 1;
return true;
}
return 0;
return false;
}
/******************************************************************************************/
void TEXTE_MODULE::Draw( WinEDA_DrawPanel* panel, wxDC* DC, wxPoint offset, int draw_mode )
/******************************************************************************************/
/* trace 1 texte de module
Utilise la police definie dans grfonte.h
(Se reporter a ce fichier pour les explications complementaires)
offset = offset de trace ( reference au centre du texte)
draw_mode = GR_OR, GR_XOR..
* Utilise la police definie dans grfonte.h
* (Se reporter a ce fichier pour les explications complementaires)
* offset = offset de trace ( reference au centre du texte)
* draw_mode = GR_OR, GR_XOR..
*/
{
int zoom;
@ -196,7 +212,8 @@ WinEDA_BasePcbFrame * frame;
MODULE* Module = (MODULE*) m_Parent;
if ( panel == NULL ) return;
if( panel == NULL )
return;
screen = (PCB_SCREEN*) panel->GetScreen();
frame = (WinEDA_BasePcbFrame*) panel->m_Parent;
@ -211,7 +228,8 @@ MODULE * Module = (MODULE *) m_Parent;
width = m_Width;
if( (frame->m_DisplayModText == FILAIRE) || ( (width / zoom) < L_MIN_DESSIN ) )
width = 0;
else if ( frame->m_DisplayModText == SKETCH ) width = -width;
else if( frame->m_DisplayModText == SKETCH )
width = -width;
GRSetDrawMode( DC, draw_mode );
@ -229,16 +247,22 @@ MODULE * Module = (MODULE *) m_Parent;
color = g_DesignSettings.m_LayerColor[Module->m_Layer];
if( Module && Module->m_Layer == CUIVRE_N) color = g_ModuleTextCUColor;
if( Module && Module->m_Layer == CMP_N) color = g_ModuleTextCMPColor;
if( Module && Module->m_Layer == CUIVRE_N )
color = g_ModuleTextCUColor;
if( Module && Module->m_Layer == CMP_N )
color = g_ModuleTextCMPColor;
if ( (color & ITEM_NOT_SHOW) != 0 ) return;
if( (color & ITEM_NOT_SHOW) != 0 )
return;
if(m_NoShow) color = g_ModuleTextNOVColor;
if ( (color & ITEM_NOT_SHOW) != 0 ) return;
if( m_NoShow )
color = g_ModuleTextNOVColor;
if( (color & ITEM_NOT_SHOW) != 0 )
return;
/* Si le texte doit etre mis en miroir: modif des parametres */
if( miroir == 0 ) size.x = - size.x;
if( miroir == 0 )
size.x = -size.x;
/* Trace du texte */
DrawGraphicText( panel, DC, pos, color, m_Text,
@ -249,6 +273,7 @@ MODULE * Module = (MODULE *) m_Parent;
/******************************************/
int TEXTE_MODULE::GetDrawRotation( void )
/******************************************/
/* Return text rotation for drawings and plotting
*/
{
@ -256,12 +281,16 @@ int rotation;
MODULE* Module = (MODULE*) m_Parent;
rotation = m_Orient;
if ( Module ) rotation += Module->m_Orient;
if( Module )
rotation += Module->m_Orient;
NORMALIZE_ANGLE_POS( rotation );
// if( (rotation > 900 ) && (rotation < 2700 ) ) rotation -= 1800; // For angle = 0 .. 180 deg
while ( rotation > 900 ) rotation -= 1800; // For angle = -90 .. 90 deg
while( rotation > 900 )
rotation -= 1800;
// For angle = -90 .. 90 deg
return rotation;
}

17
pcbnew/class_text_mod.h
View File

@ -38,11 +38,12 @@ public:
int Pitch( void ); /* retourne le pas entre 2 caracteres */
int GetDrawRotation( void ); // Return text rotation for drawings and plotting
void SetDrawCoord(void); // mise a jour des coordonnées absolues de tracé
void SetDrawCoord( void ); // mise a jour des coordonn<6E>s absolues de trac<61>
// a partir des coord relatives
void SetLocalCoord(void); // mise a jour des coordonnées relatives
// a partir des coord absolues de tracé
void SetLocalCoord( void ); // mise a jour des coordonn<6E>s relatives
// a partir des coord absolues de trac<61>
/* Reading and writing data on files */
int WriteDescr( FILE* File );
int ReadDescr( FILE* File, int* LineNum = NULL );
@ -50,7 +51,11 @@ public:
/* drawing functions */
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, wxPoint offset, int draw_mode );
/* locate functions */
int Locate(const wxPoint & posref);
/**
* Function HitTest
* tests if the given wxPoint is within the bounds of this object.
* @param posref A wxPoint to test
* @return bool - true if a hit, else false
*/
bool HitTest( const wxPoint& posref );
};

13
pcbnew/hotkeys.cpp
View File

@ -34,6 +34,7 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
{
bool PopupOn = GetScreen()->m_CurrentItem
&& GetScreen()->m_CurrentItem->m_Flags;
bool ItemFree = (GetScreen()->m_CurrentItem == 0 )
|| (GetScreen()->m_CurrentItem->m_Flags == 0);
@ -163,10 +164,18 @@ void WinEDA_PcbFrame::OnHotKey( wxDC* DC, int hotkey,
if( module == NULL ) // no footprint found
{
module = Locate_Prefered_Module( m_Pcb, CURSEUR_OFF_GRILLE );
if( module ) // a footprint is found, but locked or on an other layer
if( module )
{
// a footprint is found, but locked or on an other layer
if( module->IsLocked() )
DisplayInfo( this, _( "Footprint found, but locked" ) );
{
wxString msg;
msg.Printf( _("Footprint %s found, but locked"),
module->m_Reference->m_Text.GetData() );
DisplayInfo( this, msg );
}
module = NULL;
}
}

10
pcbnew/locate.cpp
View File

@ -426,7 +426,7 @@ EDA_BaseStruct* Locate_Cotation( BOARD* Pcb, int LayerSearch, int typeloc )
pt_txt = Cotation->m_Text;
if( pt_txt )
{
if( pt_txt->Locate( ref_pos ) )
if( pt_txt->HitTest( ref_pos ) )
return PtStruct;
}
@ -857,7 +857,7 @@ TEXTE_MODULE* LocateTexteModule( BOARD* Pcb, MODULE** PtModule, int typeloc )
// hit-test the reference text
pt_txt_mod = module->m_Reference;
if( pt_txt_mod->Locate( ref_pos ) )
if( pt_txt_mod->HitTest( ref_pos ) )
{
if( PtModule )
*PtModule = module;
@ -866,7 +866,7 @@ TEXTE_MODULE* LocateTexteModule( BOARD* Pcb, MODULE** PtModule, int typeloc )
// hit-test the value text
pt_txt_mod = module->m_Value;
if( pt_txt_mod->Locate( ref_pos ) )
if( pt_txt_mod->HitTest( ref_pos ) )
{
if( PtModule )
*PtModule = module;
@ -881,7 +881,7 @@ TEXTE_MODULE* LocateTexteModule( BOARD* Pcb, MODULE** PtModule, int typeloc )
continue;
pt_txt_mod = (TEXTE_MODULE*) PtStruct;
if( pt_txt_mod->Locate( ref_pos ) )
if( pt_txt_mod->HitTest( ref_pos ) )
{
if( PtModule )
*PtModule = module;
@ -1151,7 +1151,7 @@ TEXTE_PCB* Locate_Texte_Pcb( EDA_BaseStruct* PtStruct, int LayerSearch, int type
if( PtStruct->m_StructType != TYPETEXTE )
continue;
TEXTE_PCB* pt_txt_pcb = (TEXTE_PCB*) PtStruct;
if( pt_txt_pcb->Locate( ref ) )
if( pt_txt_pcb->HitTest( ref ) )
{
if( pt_txt_pcb->m_Layer == LayerSearch )
return pt_txt_pcb;