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

Code cleaning. Removed obscure code to draw texts

This commit is contained in:
charras 2008-12-16 19:44:57 +00:00
parent de78cdb12e
commit beeaf53a0b
19 changed files with 495 additions and 633 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
3d-viewer/3d_draw.cpp
View File

@ -92,18 +92,18 @@ GLuint Pcb3D_GLCanvas::CreateDrawGL_List()
*/ */
{ {
WinEDA_BasePcbFrame* pcbframe = m_Parent->m_Parent; WinEDA_BasePcbFrame* pcbframe = m_Parent->m_Parent;
BOARD* pcb = pcbframe->m_Pcb; BOARD* pcb = pcbframe->m_Pcb;
TRACK* track; TRACK* track;
SEGZONE* segzone; SEGZONE* segzone;
int ii; int ii;
wxBusyCursor dummy; wxBusyCursor dummy;
m_gllist = glGenLists( 1 ); m_gllist = glGenLists( 1 );
pcb->ComputeBoundaryBox(); pcb->ComputeBoundaryBox();
g_Parm_3D_Visu.m_BoardSettings = pcb->m_BoardSettings; g_Parm_3D_Visu.m_BoardSettings = pcb->m_BoardSettings;
g_Parm_3D_Visu.m_BoardSize = pcb->m_BoundaryBox.GetSize(); g_Parm_3D_Visu.m_BoardSize = pcb->m_BoundaryBox.GetSize();
g_Parm_3D_Visu.m_BoardPos = pcb->m_BoundaryBox.Centre(); g_Parm_3D_Visu.m_BoardPos = pcb->m_BoundaryBox.Centre();
g_Parm_3D_Visu.m_BoardPos.y = -g_Parm_3D_Visu.m_BoardPos.y; g_Parm_3D_Visu.m_BoardPos.y = -g_Parm_3D_Visu.m_BoardPos.y;
g_Parm_3D_Visu.m_Layers = pcb->m_BoardSettings->m_CopperLayerCount; g_Parm_3D_Visu.m_Layers = pcb->m_BoardSettings->m_CopperLayerCount;
@ -232,7 +232,7 @@ GLuint Pcb3D_GLCanvas::CreateDrawGL_List()
} }
/* draw footprints */ /* draw footprints */
MODULE* Module = pcb->m_Modules; MODULE* Module = pcb->m_Modules;
for( ; Module != NULL; Module = Module->Next() ) for( ; Module != NULL; Module = Module->Next() )
{ {
Module->Draw3D( this ); Module->Draw3D( this );
@ -291,8 +291,8 @@ void Pcb3D_GLCanvas::Draw3D_Via( SEGVIA* via )
r = via->m_Width * g_Parm_3D_Visu.m_BoardScale / 2; r = via->m_Width * g_Parm_3D_Visu.m_BoardScale / 2;
hole = via->GetDrillValue(); hole = via->GetDrillValue();
hole *= g_Parm_3D_Visu.m_BoardScale / 2; hole *= g_Parm_3D_Visu.m_BoardScale / 2;
x = via->m_Start.x * g_Parm_3D_Visu.m_BoardScale; x = via->m_Start.x * g_Parm_3D_Visu.m_BoardScale;
y = via->m_Start.y * g_Parm_3D_Visu.m_BoardScale; y = via->m_Start.y * g_Parm_3D_Visu.m_BoardScale;
via->ReturnLayerPair( &top_layer, &bottom_layer ); via->ReturnLayerPair( &top_layer, &bottom_layer );
@ -308,6 +308,7 @@ void Pcb3D_GLCanvas::Draw3D_Via( SEGVIA* via )
continue; continue;
SetGLColor( color ); SetGLColor( color );
// SetGLColor( LIGHTGRAY ); // SetGLColor( LIGHTGRAY );
glNormal3f( 0.0, 0.0, (layer == COPPER_LAYER_N) ? -1.0 : 1.0 ); glNormal3f( 0.0, 0.0, (layer == COPPER_LAYER_N) ? -1.0 : 1.0 );
if( layer == COPPER_LAYER_N ) if( layer == COPPER_LAYER_N )
@ -395,52 +396,48 @@ void Pcb3D_GLCanvas::Draw3D_DrawSegment( DRAWSEGMENT* segment )
} }
/* function to draw 3D segments, called by DrawGraphicText
* When DrawGraphicText is called to draw a text to an OpenGL DC
* it calls Draw3dTextSegm to each segment to draw.
* 2 parameters used by Draw3D_FilledSegment are not handled by DrawGraphicText
* but are used in Draw3D_FilledSegment().
* they are 2 local variables. This is an ugly, but trivial code.
* Using DrawGraphicText to draw all texts ensure texts have the same shape
* in all contexts
*/
static double s_Text3DWidth, s_Text3DZPos;
static void Draw3dTextSegm( int x0, int y0, int xf, int yf )
{
double startx = x0 * g_Parm_3D_Visu.m_BoardScale;
double starty = y0 * g_Parm_3D_Visu.m_BoardScale;
double endx = xf * g_Parm_3D_Visu.m_BoardScale;
double endy = yf * g_Parm_3D_Visu.m_BoardScale;
Draw3D_FilledSegment( startx, -starty, endx, -endy, s_Text3DWidth, s_Text3DZPos );
}
/*************************************************************/ /*************************************************************/
void Pcb3D_GLCanvas::Draw3D_DrawText( TEXTE_PCB* text ) void Pcb3D_GLCanvas::Draw3D_DrawText( TEXTE_PCB* text )
/*************************************************************/ /*************************************************************/
{ {
int layer = text->GetLayer(); if( !Get3DLayerEnable( layer ) )
double x, y, xf, yf; return;
double zpos, w; int layer = text->GetLayer();
int color = g_Parm_3D_Visu.m_BoardSettings->m_LayerColor[layer]; int color = g_Parm_3D_Visu.m_BoardSettings->m_LayerColor[layer];
#define BUFFSIZE 50
int coord[(BUFFSIZE+2)*2];
int ii, jj, kk, ll, nbpoints;
if( Get3DLayerEnable( layer ) ) SetGLColor( color );
{ s_Text3DZPos = g_Parm_3D_Visu.m_LayerZcoord[layer];
zpos = g_Parm_3D_Visu.m_LayerZcoord[layer]; s_Text3DWidth = text->m_Width * g_Parm_3D_Visu.m_BoardScale;
glNormal3f( 0.0, 0.0, Get3DLayerSide( layer ) ); glNormal3f( 0.0, 0.0, Get3DLayerSide( layer ) );
DrawGraphicText( NULL, NULL,
jj = 5; ii = jj + 1; text->m_Pos, (EDA_Colors) color, text->m_Text,
while( ii < text->m_TextDrawingsSize ) text->m_Orient, text->m_Size,
{ text->m_HJustify,
nbpoints = text->m_TextDrawings[jj]; text->m_VJustify,
if( nbpoints > BUFFSIZE ) text->m_Width, text->m_Italic,
nbpoints = BUFFSIZE; Draw3dTextSegm );
for( kk = 0, ll = 0; (kk < nbpoints) && (ii < text->m_TextDrawingsSize); kk++ )
{
coord[ll++] = text->m_TextDrawings[ii++] + text->m_Pos.x;
coord[ll++] = text->m_TextDrawings[ii++] + text->m_Pos.y;
}
jj = ii++;
for( kk = 0, ll = 0; kk < (nbpoints - 1); kk++, ll += 2 )
{
SetGLColor( color );
w = text->m_Width * g_Parm_3D_Visu.m_BoardScale;
x = coord[ll] * g_Parm_3D_Visu.m_BoardScale;
y = coord[ll + 1] * g_Parm_3D_Visu.m_BoardScale;
xf = coord[ll + 2] * g_Parm_3D_Visu.m_BoardScale;
yf = coord[ll + 3] * g_Parm_3D_Visu.m_BoardScale;
Draw3D_FilledSegment( x, -y, xf, -yf, w, zpos );
}
}
}
} }
@ -473,7 +470,7 @@ void MODULE::Draw3D( Pcb3D_GLCanvas* glcanvas )
/* Draw module shape: 3D shape if exists (or module edge if not exists) */ /* Draw module shape: 3D shape if exists (or module edge if not exists) */
S3D_MASTER* Struct3D = m_3D_Drawings; S3D_MASTER* Struct3D = m_3D_Drawings;
bool As3dShape = FALSE; bool As3dShape = FALSE;
if( g_Parm_3D_Visu.m_Draw3DModule ) if( g_Parm_3D_Visu.m_Draw3DModule )
{ {
glPushMatrix(); glPushMatrix();
@ -591,7 +588,7 @@ void D_PAD::Draw3D( Pcb3D_GLCanvas* glcanvas )
int angle, delta_angle; int angle, delta_angle;
int coord[4][2]; int coord[4][2];
double fcoord[8][2], f_hole_coord[8][2]; double fcoord[8][2], f_hole_coord[8][2];
double scale; double scale;
double zpos; double zpos;
wxPoint shape_pos; wxPoint shape_pos;
double x, y, r, w, hole, holeX, holeY; double x, y, r, w, hole, holeX, holeY;
@ -682,10 +679,10 @@ void D_PAD::Draw3D( Pcb3D_GLCanvas* glcanvas )
RotatePoint( &delta_cx, &delta_cy, angle ); RotatePoint( &delta_cx, &delta_cy, angle );
{ {
double ox, oy, fx, fy; double ox, oy, fx, fy;
ox = (double) (ux0 + delta_cx) * scale; ox = (double) ( ux0 + delta_cx ) * scale;
oy = (double) (uy0 + delta_cy) * scale; oy = (double) ( uy0 + delta_cy ) * scale;
fx = (double) (ux0 - delta_cx) * scale; fx = (double) ( ux0 - delta_cx ) * scale;
fy = (double) (uy0 - delta_cy) * scale; fy = (double) ( uy0 - delta_cy ) * scale;
for( layer = FIRST_COPPER_LAYER; layer <= LAST_COPPER_LAYER; layer++ ) for( layer = FIRST_COPPER_LAYER; layer <= LAST_COPPER_LAYER; layer++ )
{ {
if( layer && (layer == nlmax) ) if( layer && (layer == nlmax) )
@ -738,8 +735,8 @@ void D_PAD::Draw3D( Pcb3D_GLCanvas* glcanvas )
coord[ii][0] += ux0; coord[ii][0] += ux0;
coord[ii][1] += uy0; coord[ii][1] += uy0;
ll = ii * 2; ll = ii * 2;
fcoord[ll][0] = coord[ii][0] * scale; fcoord[ll][0] = coord[ii][0] *scale;
fcoord[ll][1] = coord[ii][1] * scale; fcoord[ll][1] = coord[ii][1] *scale;
} }
for( ii = 0; ii < 7; ii += 2 ) for( ii = 0; ii < 7; ii += 2 )
@ -794,7 +791,7 @@ void D_PAD::Draw3D( Pcb3D_GLCanvas* glcanvas )
glEnd(); glEnd();
} }
} }
break; break;
default: default:
break; break;
@ -896,8 +893,8 @@ static void Draw3D_FilledSegment( double startx, double starty,
dy = endy - starty; dy = endy - starty;
angle = (int) ( ( atan2( dy, dx ) * 1800 / M_PI ) + 0.5 ); angle = (int) ( ( atan2( dy, dx ) * 1800 / M_PI ) + 0.5 );
RotatePoint( &dx, &dy, angle ); // apres rotation: dx = longueur du segment RotatePoint( &dx, &dy, angle ); // apres rotation: dx = longueur du segment
// dy = 0; // dy = 0;
width /= 2; width /= 2;
glBegin( GL_POLYGON ); glBegin( GL_POLYGON );
@ -962,8 +959,8 @@ static void Draw3D_FilledSegmentWithHole( double startx,
holey -= starty; holey -= starty;
angle = (int) ( ( atan2( endy, endx ) * 1800 / M_PI ) + 0.5 ); angle = (int) ( ( atan2( endy, endx ) * 1800 / M_PI ) + 0.5 );
RotatePoint( &endx, &endy, angle ); // apres rotation: endx = longueur du segment RotatePoint( &endx, &endy, angle ); // apres rotation: endx = longueur du segment
// endy = 0; // endy = 0;
RotatePoint( &holex, &holey, angle ); RotatePoint( &holex, &holey, angle );
width /= 2; width /= 2;
@ -999,8 +996,8 @@ static void Draw3D_FilledSegmentWithHole( double startx,
for( ii = 0; ii <= 8; ii++ ) for( ii = 0; ii <= 8; ii++ )
{ {
theta = -ii * 225; theta = -ii * 225;
x = 0.0; x = 0.0;
y = width; y = width;
RotatePoint( &x, &y, -angle + theta ); RotatePoint( &x, &y, -angle + theta );
xin = 0.0; xin = 0.0;
yin = holeradius; yin = holeradius;

396
common/base_struct.cpp
View File

@ -132,8 +132,8 @@ void EDA_BaseStruct::Show( int nestLevel, std::ostream& os )
wxString s = GetClass(); wxString s = GetClass();
NestedSpace( nestLevel, os ) << '<' << s.Lower().mb_str() << ">" NestedSpace( nestLevel, os ) << '<' << s.Lower().mb_str() << ">"
<< " Need ::Show() override for this class " << " Need ::Show() override for this class "
<< "</" << s.Lower().mb_str() << ">\n"; << "</" << s.Lower().mb_str() << ">\n";
} }
@ -147,11 +147,14 @@ void EDA_BaseStruct::Show( int nestLevel, std::ostream& os )
std::ostream& EDA_BaseStruct::NestedSpace( int nestLevel, std::ostream& os ) std::ostream& EDA_BaseStruct::NestedSpace( int nestLevel, std::ostream& os )
{ {
for( int i = 0; i<nestLevel; ++i ) for( int i = 0; i<nestLevel; ++i )
os << " "; // number of spaces here controls indent per nest level os << " ";
// number of spaces here controls indent per nest level
return os; return os;
} }
#endif #endif
@ -160,28 +163,20 @@ std::ostream& EDA_BaseStruct::NestedSpace( int nestLevel, std::ostream& os )
/**************************************************/ /**************************************************/
EDA_TextStruct::EDA_TextStruct( const wxString& text ) EDA_TextStruct::EDA_TextStruct( const wxString& text )
{ {
m_Size.x = m_Size.y = DEFAULT_SIZE_TEXT; /* XY size of font */ m_Size.x = m_Size.y = DEFAULT_SIZE_TEXT; /* XY size of font */
m_Orient = 0; /* Orient in 0.1 degrees */ m_Orient = 0; /* Orient in 0.1 degrees */
m_Attributs = 0; m_Attributs = 0;
m_Miroir = 0; // vue normale / miroir m_Miroir = 0; // display mirror if 1
m_HJustify = GR_TEXT_HJUSTIFY_CENTER; m_HJustify = GR_TEXT_HJUSTIFY_CENTER;
m_VJustify = GR_TEXT_VJUSTIFY_CENTER; /* Justifications Horiz et Vert du texte */ m_VJustify = GR_TEXT_VJUSTIFY_CENTER; /* Justifications Horiz et Vert du texte */
m_Width = 0; /* epaisseur du trait */ m_Width = 0; /* thickness */
m_CharType = 0; /* normal, bold, italic ... */ m_Italic = false; /* true = italic shape */
m_Text = 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<6E>*/
} }
EDA_TextStruct::~EDA_TextStruct() EDA_TextStruct::~EDA_TextStruct()
{ {
if( m_TextDrawings ) /* pointeur sur la liste des segments de dessin */
{
free( m_TextDrawings ); m_TextDrawings = NULL;
}
m_TextDrawingsSize = 0; /* nombre de sommets a dessiner */
} }
@ -259,337 +254,62 @@ int EDA_TextStruct::Pitch()
/***************************************************************/ /***************************************************************/
void EDA_TextStruct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, void EDA_TextStruct::Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
const wxPoint& offset, int color, int draw_mode, const wxPoint& aOffset, EDA_Colors aColor,
int display_mode, int anchor_color ) int aDrawMode,
GRFillMode aDisplayMode, EDA_Colors aAnchor_color )
/***************************************************************/ /***************************************************************/
/* /** Function Draw
* Trace de 1 texte type EDA_TextStruct. * @param aPanel = the current DrawPanel
* offset = Offset de trace (usuellement (0,0) * @param aDC = the current Device Context
* color = couleur du texte * @param aOffset = draw offset (usually (0,0))
* draw_mode = GR_OR, GR_XOR.., -1 si mode courant. * @param EDA_Colors aColor = text color
* display_mode = FILAIRE, FILLED ou SKETCH * @param aDrawMode = GR_OR, GR_XOR.., -1 to use the current mode.
* anchor_color = couleur de l'ancre ( -1 si pas d'ancre ). * @param aDisplayMode = FILAIRE, FILLED or SKETCH
* @param EDA_Colors aAnchor_color = anchor color ( UNSPECIFIED_COLOR = do not draw anchor ).
*/ */
{ {
int zoom; int zoom;
int coord[104];
int ii, jj, kk, ll, nbpoints;
int width; int width;
if( m_TextDrawings == NULL ) /* pointeur sur la liste des segments de dessin */ zoom = aPanel->GetZoom();
CreateDrawData(); width = m_Width;
if( aDisplayMode == FILAIRE )
if( m_TextDrawings == NULL )
return;
zoom = panel->GetZoom();
width = m_Width / zoom;
if( display_mode == FILAIRE )
width = 0; width = 0;
/* choix de la couleur du texte : */ if( aDrawMode != -1 )
if( draw_mode != -1 ) GRSetDrawMode( aDC, aDrawMode );
GRSetDrawMode( DC, draw_mode );
/* trace du texte */ /* Draw text anchor, if allowed */
if( zoom > m_ZoomLevelDrawable ) if( aAnchor_color != UNSPECIFIED_COLOR )
{ {
GRLine( &panel->m_ClipBox, DC, int anchor_size = 2 * zoom;
m_TextDrawings[1] + offset.x + m_Pos.x, aAnchor_color = (EDA_Colors) (aAnchor_color & MASKCOLOR);
m_TextDrawings[2] + offset.y + m_Pos.y,
m_TextDrawings[3] + offset.x + m_Pos.x, int cX = m_Pos.x + aOffset.x;
m_TextDrawings[4] + offset.y + m_Pos.y, int cY = m_Pos.y + aOffset.y;
width, color );
GRLine( &aPanel->m_ClipBox, aDC, cX - anchor_size, cY,
cX + anchor_size, cY, 0, aAnchor_color );
GRLine( &aPanel->m_ClipBox, aDC, cX, cY - anchor_size,
cX, cY + anchor_size, 0, aAnchor_color );
} }
else
{
/* trace ancre du texte ? */
if( anchor_color != -1 )
{
int anchor_size = 2 * zoom;
anchor_color &= MASKCOLOR;
/* calcul de la position du texte */ if( aDisplayMode == SKETCH )
int cX = m_Pos.x - offset.x; width = -width;
int cY = m_Pos.y - offset.y;
/* trace ancre du texte */ DrawGraphicText( aPanel, aDC,
GRLine( &panel->m_ClipBox, DC, cX - anchor_size, cY, aOffset + m_Pos, aColor, m_Text,
cX + anchor_size, cY, 0, anchor_color ); m_Orient, m_Size,
m_HJustify, m_VJustify, width, m_Italic );
GRLine( &panel->m_ClipBox, DC, cX, cY - anchor_size,
cX, cY + anchor_size, 0, anchor_color );
}
jj = 5; ii = jj + 1;
while( ii < m_TextDrawingsSize )
{
nbpoints = m_TextDrawings[jj];
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;
coord[ll++] = m_TextDrawings[ii++] + offset.y + m_Pos.y;
}
jj = ii++;
if( width > 2 )
{
for( kk = 0, ll = 0; kk < (nbpoints - 1); kk++, ll += 2 )
{
if( display_mode == SKETCH )
GRCSegm( &panel->m_ClipBox, DC,
coord[ll], coord[ll + 1],
coord[ll + 2], coord[ll + 3],
m_Width, color );
else
GRFillCSegm( &panel->m_ClipBox, DC,
coord[ll], coord[ll + 1],
coord[ll + 2], coord[ll + 3],
m_Width, color );
}
}
else
GRPoly( &panel->m_ClipBox, DC, nbpoints, coord, 0, 0, color, color );
}
}
} }
/****************************************/ /******************/
void EDA_TextStruct::CreateDrawData() /* Class EDA_Rect */
/****************************************/ /******************/
/* 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;
int k1, k2, x0, y0;
int size_h, size_v, espacement;
char f_cod, plume = 'U';
const wxChar* ptr;
const SH_CODE* ptcar;
int ux0, uy0, dx, dy; // Coord de trace des segments de texte & variables de calcul */
int cX, cY; // Centre du texte
int ox, oy; // coord de trace du caractere courant
int* coord; // liste des coord des segments a tracer
int coord_count_max = 1000;
if( m_TextDrawings ) /* pointeur sur la liste des segments de dessin */
{
free( m_TextDrawings ); m_TextDrawings = 0;
}
m_TextDrawingsSize = 0; /* nombre de segments a dessiner */
nbchar = m_Text.Length();
if( nbchar == 0 )
return;
size_h = m_Size.x;
size_v = m_Size.y;
espacement = Pitch();
if( m_Miroir == 0 )
{
size_h = -size_h; espacement = -espacement;
}
kk = 0; ptr = m_Text.GetData(); /* ptr pointe 1er caractere du texte */
/* calcul de la position du debut des textes: ox et oy */
ox = cX = 0; oy = cY = 0;
/* Calcul du cadrage du texte */
dx = (espacement * nbchar) / 2;
dy = size_v / 2; /* Decalage du debut du texte / centre */
ux0 = uy0 = 0; /* Decalage du centre du texte / ccord de ref */
if( (m_Orient == 0) || (m_Orient == 1800) ) /* Texte Horizontal */
{
switch( m_HJustify )
{
case GR_TEXT_HJUSTIFY_CENTER:
break;
case GR_TEXT_HJUSTIFY_RIGHT:
ux0 = -dx;
break;
case GR_TEXT_HJUSTIFY_LEFT:
ux0 = dx;
break;
}
switch( m_VJustify )
{
case GR_TEXT_VJUSTIFY_CENTER:
break;
case GR_TEXT_VJUSTIFY_TOP:
uy0 = dy;
break;
case GR_TEXT_VJUSTIFY_BOTTOM:
uy0 = -dy;
break;
}
}
else /* Texte Vertical */
{
switch( m_HJustify )
{
case GR_TEXT_HJUSTIFY_CENTER:
break;
case GR_TEXT_HJUSTIFY_RIGHT:
ux0 = -dy;
break;
case GR_TEXT_HJUSTIFY_LEFT:
ux0 = dy;
break;
}
switch( m_VJustify )
{
case GR_TEXT_VJUSTIFY_CENTER:
break;
case GR_TEXT_VJUSTIFY_TOP:
uy0 = dx;
break;
case GR_TEXT_VJUSTIFY_BOTTOM:
uy0 = -dx;
break;
}
}
cX += ux0; cY += uy0;
ox = cX - dx;; oy = cY + dy;
/* lorsque les chars sont trop petits pour etre dessines,
* le texte est symbolise par une barre */
m_ZoomLevelDrawable = MAX( ABS(m_Size.x), ABS(m_Size.y) ) / 3;
dx = (espacement * nbchar) / 2;
dy = size_v / 2; /* Decalage du debut du texte / centre */
ux0 = cX - dx;
uy0 = cY;
dx += cX;
dy = cY;
RotatePoint( &ux0, &uy0, cX, cY, m_Orient );
RotatePoint( &dx, &dy, cX, cY, m_Orient );
coord = (int*) MyMalloc( (coord_count_max + 2) * sizeof(int) );
coord[0] = 2;
coord[1] = ux0; coord[2] = uy0;
coord[3] = dx; coord[4] = dy;
jj = 5; ii = jj + 1; nbpoints = 0;
while( kk++ < nbchar )
{
x0 = 0; y0 = 0;
#if defined(wxUSE_UNICODE) && defined(KICAD_CYRILLIC)
AsciiCode = (*ptr) & 0x7FF;
if ( AsciiCode > 0x40F && AsciiCode < 0x450 ) // big small Cyr
AsciiCode = utf8_to_ascii[AsciiCode - 0x410] & 0xFF;
else
AsciiCode = AsciiCode & 0xFF;
#else
AsciiCode = (*ptr) & 255;
#endif
ptcar = graphic_fonte_shape[AsciiCode]; /* ptcar pointe la description
* du caractere a dessiner */
for( endcar = FALSE; !endcar; ptcar++ )
{
f_cod = *ptcar;
/* get code n de la forme selectionnee */
switch( f_cod )
{
case 'X':
endcar = TRUE; /* fin du caractere */
break;
case 'U':
if( nbpoints && (plume == 'D' ) )
{
if( jj >= coord_count_max )
{
coord_count_max *= 2;
coord = (int*) realloc( coord, coord_count_max * sizeof(int) );
}
coord[jj] = nbpoints;
jj = ii++;
}
plume = f_cod;
nbpoints = 0;
break;
case 'D':
plume = f_cod;
nbpoints = 1; /* 1 point va suivre (origine du trac<61> */
break;
default:
{
k1 = f_cod; /* trace sur axe V */
k1 = -( (k1 * size_v) / 9 );
ptcar++;
f_cod = *ptcar;
k2 = f_cod; /* trace sur axe H */
k2 = (k2 * size_h) / 9;
dx = k2 + ox;
dy = k1 + oy;
RotatePoint( &dx, &dy, cX, cY, m_Orient );
if( ii >= coord_count_max )
{
coord_count_max *= 2;
coord = (int*) realloc( coord, coord_count_max * sizeof(int) );
}
coord[ii++] = dx;
coord[ii++] = dy;
nbpoints++;
break;
}
}
/* end switch */
}
/* end boucle for = end trace de 1 caractere */
ptr++;
ox += espacement;
}
/* 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 EDA_Rect::Normalize()
@ -646,15 +366,6 @@ bool EDA_Rect::Intersects( const EDA_Rect aRect ) const
// this logic taken from wxWidgets' geometry.cpp file: // this logic taken from wxWidgets' geometry.cpp file:
bool rc; bool rc;
#if 0 && defined(DEBUG)
std::cout << "this: ";
std::cout << m_Pos << m_Size << '\n';
std::cout << "aRect: ";
std::cout << aRect.m_Pos << aRect.m_Size;
#endif
int left = MAX( m_Pos.x, aRect.m_Pos.x ); int left = MAX( m_Pos.x, aRect.m_Pos.x );
int right = MIN( m_Pos.x + m_Size.x, aRect.m_Pos.x + aRect.m_Size.x ); int right = MIN( m_Pos.x + m_Size.x, aRect.m_Pos.x + aRect.m_Size.x );
int top = MAX( m_Pos.y, aRect.m_Pos.y ); int top = MAX( m_Pos.y, aRect.m_Pos.y );
@ -665,8 +376,6 @@ bool EDA_Rect::Intersects( const EDA_Rect aRect ) const
else else
rc = false; rc = false;
//D( std::cout << "rc=" << rc << '\n'; )
return rc; return rc;
} }
@ -771,4 +480,3 @@ void EDA_Rect::Merge( const EDA_Rect& aRect )
end.y = MAX( end.y, rect_end.y ); end.y = MAX( end.y, rect_end.y );
SetEnd( end ); SetEnd( end );
} }

111
common/drawtxt.cpp
View File

@ -23,25 +23,34 @@
/****************************************************************************************************/ /****************************************************************************************************/
void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC, void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
const wxPoint& aPos, enum EDA_Colors aColor, const wxString& aText, const wxPoint& aPos, EDA_Colors aColor, const wxString& aText,
int aOrient, const wxSize& aSize, int aH_justify, int aV_justify, int aWidth ) int aOrient, const wxSize& aSize,
enum GRTextHorizJustifyType aH_justify,
enum GRTextVertJustifyType aV_justify,
int aWidth, bool aItalic,
void (* aCallback) (int x0, int y0, int xf, int yf))
/****************************************************************************************************/ /****************************************************************************************************/
/** Function DrawGraphicText /** Function DrawGraphicText
* Draw a graphic text (like module texts)
* Draw a graphic text (like module texts) * Draw a graphic text (like module texts)
* @param aPanel = the current DrawPanel * @param aPanel = the current DrawPanel
* @param aPos = text position (according to aH_justify, aV_justify) * @param aPos = text position (according to h_justify, v_justify)
* @param aColor (enum EDA_Colors) = text color * @param aColor (enum EDA_Colors) = text color
* @param aText = text to draw * @param aText = text to draw
* @param aOrient = angle in 0.1 degree * @param aOrient = angle in 0.1 degree
* @param aSize = text size (size.x or size.y can be < 0 for mirrored texts) * @param aSize = text size (size.x or size.y can be < 0 for mirrored texts)
* @param aH_justify = horizontal justification (Left, center, right) * @param aH_justify = horizontal justification (Left, center, right)
* @param aV_justify = vertical justification (bottom, center, top) * @param aV_justify = vertical justification (bottom, center, top)
* @param aWidth = line aWidth (pen aWidth) (default = 0) * @param aWidth = line width (pen width) (default = 0)
* if width < 0 : draw segments in sketch mode, width = abs(width)
* @param aItalic = true to simulate an italic font
* @param aCallback() = function called (if non null) to draw each segment.
* used only to draw 3D texts
*/ */
{ {
int ii, kk, nbchar, AsciiCode, endcar; int ii, kk, char_count, AsciiCode, endcar;
int k1, k2, x0, y0; int x0, y0;
int zoom; int zoom;
int size_h, size_v, espacement; int size_h, size_v, espacement;
SH_CODE f_cod, plume = 'U'; SH_CODE f_cod, plume = 'U';
@ -51,9 +60,12 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
int cX, cY; // Texte center int cX, cY; // Texte center
int ox, oy; // Draw coordinates for the current char int ox, oy; // Draw coordinates for the current char
int coord[100]; // Buffer coordinate used to draw polylines (char shapes) int coord[100]; // Buffer coordinate used to draw polylines (char shapes)
bool sketch_mode = FALSE; bool sketch_mode = false;
zoom = aPanel->GetZoom(); if ( aPanel )
zoom = aPanel->GetZoom();
else
zoom = 1;
size_h = aSize.x; size_h = aSize.x;
size_v = aSize.y; size_v = aSize.y;
@ -63,14 +75,20 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
aWidth = -aWidth; aWidth = -aWidth;
sketch_mode = TRUE; sketch_mode = TRUE;
} }
kk = 0; kk = 0;
ptr = 0; /* ptr = text index */ ptr = 0; /* ptr = text index */
nbchar = aText.Len(); char_count = aText.Len();
if( nbchar == 0 ) if( char_count == 0 )
return; return;
espacement = (10 * size_h ) / 9; // this is the pitch between chars espacement = (10 * size_h ) / 9; // this is the pitch between chars
if ( espacement > 0 )
espacement += ABS(aWidth);
else
espacement -= ABS(aWidth);
ox = cX = aPos.x; ox = cX = aPos.x;
oy = cY = aPos.y; oy = cY = aPos.y;
@ -79,7 +97,7 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
{ {
int xm, ym, ll, xc, yc; int xm, ym, ll, xc, yc;
int textsize = ABS( espacement ); int textsize = ABS( espacement );
ll = (textsize * nbchar) / zoom; ll = (textsize * char_count) / zoom;
xc = GRMapX( cX ); xc = GRMapX( cX );
yc = GRMapY( cY ); yc = GRMapY( cY );
@ -101,7 +119,7 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
/* Compute the position ux0, uy0 of the first letter , next */ /* Compute the position ux0, uy0 of the first letter , next */
dx = (espacement * nbchar) / 2; dx = (espacement * char_count) / 2;
dy = size_v / 2; /* dx, dy = draw offset between first letter and text center */ dy = size_v / 2; /* dx, dy = draw offset between first letter and text center */
ux0 = uy0 = 0; /* Decalage du centre du texte / coord de ref */ ux0 = uy0 = 0; /* Decalage du centre du texte / coord de ref */
@ -178,7 +196,7 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
if( ABS( (aSize.x / zoom) ) < 3 ) /* chars trop petits pour etre dessines */ if( ABS( (aSize.x / zoom) ) < 3 ) /* chars trop petits pour etre dessines */
{ /* le texte est symbolise par une barre */ { /* le texte est symbolise par une barre */
dx = (espacement * nbchar) / 2; dx = (espacement * char_count) / 2;
dy = size_v / 2; /* Decalage du debut du texte / centre */ dy = size_v / 2; /* Decalage du debut du texte / centre */
ux0 = cX - dx; ux0 = cX - dx;
@ -190,34 +208,15 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
RotatePoint( &ux0, &uy0, cX, cY, aOrient ); RotatePoint( &ux0, &uy0, cX, cY, aOrient );
RotatePoint( &dx, &dy, cX, cY, aOrient ); RotatePoint( &dx, &dy, cX, cY, aOrient );
GRLine( &aPanel->m_ClipBox, DC, ux0, uy0, dx, dy, aWidth, aColor ); if ( aCallback )
aCallback( ux0, uy0, dx, dy );
else
GRLine( &aPanel->m_ClipBox, DC, ux0, uy0, dx, dy, aWidth, aColor );
return; return;
} }
#if 0 while( kk++ < char_count )
dx = (espacement * nbchar) / 2;
dy = size_v / 2;/* Decalage du debut du texte / centre */
ux0 = cX - dx;
uy0 = cY;
dx += cX;
dy = cY;
RotatePoint( &ux0, &uy0, cX, cY, aOrient );
RotatePoint( &dx, &dy, cX, cY, aOrient );
DC->SetTextForeground( wxColour(
ColorRefs[aColor].r,
ColorRefs[aColor].g,
ColorRefs[aColor].b ) );
DC->DrawRotatedText( Text, GRMapX( ux0 ), GRMapY( uy0 ), (double) aOrient / 10.0 );
return;
#endif
while( kk++ < nbchar )
{ {
x0 = 0; y0 = 0; x0 = 0; y0 = 0;
#if defined(wxUSE_UNICODE) && defined(KICAD_CYRILLIC) #if defined(wxUSE_UNICODE) && defined(KICAD_CYRILLIC)
@ -247,8 +246,16 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
if( ii && (plume == 'D' ) ) if( ii && (plume == 'D' ) )
{ {
if( aWidth <= 1 ) if( aWidth <= 1 )
GRPoly( &aPanel->m_ClipBox, DC, ii / 2, coord, 0, 0, aWidth = 0;
aColor, aColor ); if ( aCallback )
{
int ik, * coordptr;
coordptr = coord;
for( ik = 0; ik < (ii - 2); ik += 2, coordptr += 2 )
aCallback( *coordptr, *(coordptr + 1),
*(coordptr + 2), *(coordptr + 3) );
}
else if( sketch_mode ) else if( sketch_mode )
{ {
int ik, * coordptr; int ik, * coordptr;
@ -270,7 +277,8 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
default: default:
{ {
k1 = f_cod; /* trace sur axe V */ int y, k1, k2;
y = k1 = f_cod; /* trace sur axe V */
k1 = -( (k1 * size_v) / 9 ); k1 = -( (k1 * size_v) / 9 );
ptcar++; ptcar++;
@ -278,6 +286,9 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
k2 = f_cod; /* trace sur axe H */ k2 = f_cod; /* trace sur axe H */
k2 = (k2 * size_h) / 9; k2 = (k2 * size_h) / 9;
// To simulate an italic font, add a x offset depending on the y offset
if ( aItalic )
k2 -= k1/8;
dx = k2 + ox; dy = k1 + oy; dx = k2 + ox; dy = k1 + oy;
RotatePoint( &dx, &dy, cX, cY, aOrient ); RotatePoint( &dx, &dy, cX, cY, aOrient );
@ -290,19 +301,20 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* DC,
/* end switch */ /* end switch */
} }
/* end boucle for = end trace de 1 caractere */ /* end draw 1 char */
ptr++; ox += espacement; ptr++; ox += espacement;
} }
/* end trace du texte */
} }
/******************************************************************************************/ /******************************************************************************************/
void PlotGraphicText( int aFormat_plot, const wxPoint& aPos, enum EDA_Colors aColor, void PlotGraphicText( int aFormat_plot, const wxPoint& aPos, enum EDA_Colors aColor,
const wxString& aText, const wxString& aText,
int aOrient, const wxSize& aSize, int aH_justify, int aV_justify ) int aOrient, const wxSize& aSize,
enum GRTextHorizJustifyType aH_justify,
enum GRTextVertJustifyType aV_justify,
bool aItalic )
/******************************************************************************************/ /******************************************************************************************/
/** Function PlotGraphicText /** Function PlotGraphicText
@ -317,7 +329,7 @@ void PlotGraphicText( int aFormat_plot, const wxPoint& aPos, enum EDA_Colors aCo
* @param aV_justify = vertical justification (bottom, center, top) * @param aV_justify = vertical justification (bottom, center, top)
*/ */
{ {
int kk, nbchar, end, AsciiCode; int kk, char_count, end, AsciiCode;
int k1, k2, x0, y0, ox, oy; int k1, k2, x0, y0, ox, oy;
int size_h, size_v, espacement; int size_h, size_v, espacement;
SH_CODE f_cod, plume = 'U'; SH_CODE f_cod, plume = 'U';
@ -357,14 +369,14 @@ void PlotGraphicText( int aFormat_plot, const wxPoint& aPos, enum EDA_Colors aCo
ptr = 0; /* ptr = text index */ ptr = 0; /* ptr = text index */
/* calcul de la position du debut des textes: ox et oy */ /* calcul de la position du debut des textes: ox et oy */
nbchar = aText.Len(); char_count = aText.Len();
espacement = (10 * size_h ) / 9; espacement = (10 * size_h ) / 9;
ox = cX = aPos.x; ox = cX = aPos.x;
oy = cY = aPos.y; oy = cY = aPos.y;
/* Calcul du cadrage du texte */ /* Calcul du cadrage du texte */
dx = (espacement * nbchar) / 2; dx = (espacement * char_count) / 2;
dy = size_v / 2; /* Decalage du debut du texte / centre */ dy = size_v / 2; /* Decalage du debut du texte / centre */
ux0 = uy0 = 0; /* Decalage du centre du texte / ccord de ref */ ux0 = uy0 = 0; /* Decalage du centre du texte / ccord de ref */
@ -438,7 +450,7 @@ void PlotGraphicText( int aFormat_plot, const wxPoint& aPos, enum EDA_Colors aCo
FctPlume( wxPoint( 0, 0 ), 'Z' ); FctPlume( wxPoint( 0, 0 ), 'Z' );
while( kk++ < nbchar ) while( kk++ < char_count )
{ {
#if defined(wxUSE_UNICODE) && defined(KICAD_CYRILLIC) #if defined(wxUSE_UNICODE) && defined(KICAD_CYRILLIC)
AsciiCode = aText.GetChar(ptr) & 0x7FF; AsciiCode = aText.GetChar(ptr) & 0x7FF;
@ -474,6 +486,9 @@ void PlotGraphicText( int aFormat_plot, const wxPoint& aPos, enum EDA_Colors aCo
k2 = f_cod; /* trace sur axe H */ k2 = f_cod; /* trace sur axe H */
k2 = (k2 * size_h) / 9; k2 = (k2 * size_h) / 9;
// To simulate an italic font, add a x offset depending on the y offset
if ( aItalic )
k2 -= k1/8;
dx = k2 + ox; dx = k2 + ox;
dy = k1 + oy; dy = k1 + oy;

2
eeschema/class_hierarchical_PIN_sheet.cpp
View File

@ -72,7 +72,7 @@ void Hierarchical_PIN_Sheet_Struct::Draw( WinEDA_DrawPanel* panel, wxDC* DC, con
/********************************************************************************************/ /********************************************************************************************/
/* Routine de dessin des Labels type hierarchie */ /* Routine de dessin des Labels type hierarchie */
{ {
int side; GRTextHorizJustifyType side;
EDA_Colors txtcolor; EDA_Colors txtcolor;
int posx, tposx, posy, size2; int posx, tposx, posy, size2;
wxSize size; wxSize size;

34
eeschema/class_sch_cmp_field.cpp
View File

@ -53,36 +53,12 @@ void SCH_CMP_FIELD::SwapData( SCH_CMP_FIELD* copyitem )
EXCHG( m_Orient, copyitem->m_Orient ); EXCHG( m_Orient, copyitem->m_Orient );
EXCHG( m_Miroir, copyitem->m_Miroir ); EXCHG( m_Miroir, copyitem->m_Miroir );
EXCHG( m_Attributs, copyitem->m_Attributs ); EXCHG( m_Attributs, copyitem->m_Attributs );
EXCHG( m_CharType, copyitem->m_CharType ); EXCHG( m_Italic, copyitem->m_Italic );
EXCHG( m_HJustify, copyitem->m_HJustify ); EXCHG( m_HJustify, copyitem->m_HJustify );
EXCHG( m_VJustify, copyitem->m_VJustify ); EXCHG( m_VJustify, copyitem->m_VJustify );
EXCHG( m_ZoomLevelDrawable, copyitem->m_ZoomLevelDrawable );
EXCHG( m_TextDrawings, copyitem->m_TextDrawings );
EXCHG( m_TextDrawingsSize, copyitem->m_TextDrawingsSize );
} }
#if 0
/***********************************************************/
void SCH_CMP_FIELD::PartTextCopy( SCH_CMP_FIELD* target )
/***********************************************************/
{
target->m_Text = m_Text;
if( m_FieldId >= FIELD1 )
target->m_Name = m_Name;
target->m_Layer = m_Layer;
target->m_Pos = m_Pos;
target->m_Size = m_Size;
target->m_Attributs = m_Attributs;
target->m_FieldId = m_FieldId;
target->m_Orient = m_Orient;
target->m_HJustify = m_HJustify;
target->m_VJustify = m_VJustify;
target->m_Flags = m_Flags;
}
#endif
/*********************************/ /*********************************/
bool SCH_CMP_FIELD::IsVoid() bool SCH_CMP_FIELD::IsVoid()
/*********************************/ /*********************************/
@ -92,8 +68,8 @@ bool SCH_CMP_FIELD::IsVoid()
*/ */
{ {
if( m_Text.IsEmpty() || m_Text == wxT( "~" ) ) if( m_Text.IsEmpty() || m_Text == wxT( "~" ) )
return TRUE; return true;
return FALSE; return false;
} }
@ -142,7 +118,7 @@ EDA_Rect SCH_CMP_FIELD::GetBoundaryBox() const
y2 = pos.y + (DrawLibItem->m_Transform[1][0] * x1) y2 = pos.y + (DrawLibItem->m_Transform[1][0] * x1)
+ (DrawLibItem->m_Transform[1][1] * y1); + (DrawLibItem->m_Transform[1][1] * y1);
/* If the component orientation is +/- 90 deg, the text orienation must be changed */ /* If the component orientation is +/- 90 deg, the text orientation must be changed */
if( DrawLibItem->m_Transform[0][1] ) if( DrawLibItem->m_Transform[0][1] )
{ {
if( orient == TEXT_ORIENT_HORIZ ) if( orient == TEXT_ORIENT_HORIZ )
@ -206,7 +182,9 @@ EDA_Rect SCH_CMP_FIELD::GetBoundaryBox() const
} }
/*********************************************/
bool SCH_CMP_FIELD::Save( FILE* aFile ) const bool SCH_CMP_FIELD::Save( FILE* aFile ) const
/*********************************************/
{ {
char hjustify = 'C'; char hjustify = 'C';
if( m_HJustify == GR_TEXT_HJUSTIFY_LEFT ) if( m_HJustify == GR_TEXT_HJUSTIFY_LEFT )

1
eeschema/class_sch_cmp_field.h
View File

@ -44,7 +44,6 @@ public:
} }
void PartTextCopy( SCH_CMP_FIELD* target );
void Place( WinEDA_SchematicFrame* frame, wxDC* DC ); void Place( WinEDA_SchematicFrame* frame, wxDC* DC );
EDA_Rect GetBoundaryBox() const; EDA_Rect GetBoundaryBox() const;

157
eeschema/classes_body_items.h
View File

@ -107,7 +107,7 @@ public:
EDA_LibComponentStruct* m_Entry; // Pointer to the component in lib EDA_LibComponentStruct* m_Entry; // Pointer to the component in lib
bool m_DrawPinText; // Are pin texts drawn ? bool m_DrawPinText; // Are pin texts drawn ?
DrawPinPrms(EDA_LibComponentStruct* entry, bool drawpintext = true) DrawPinPrms( EDA_LibComponentStruct* entry, bool drawpintext = true )
{ {
m_Entry = entry; m_Entry = entry;
m_DrawPinText = drawpintext; m_DrawPinText = drawpintext;
@ -145,20 +145,20 @@ public:
virtual ~LibEDA_BaseStruct() { } virtual ~LibEDA_BaseStruct() { }
/** Function Draw (virtual pure) /** Function Draw (virtual pure)
* Draw A body item * Draw A body item
* @param aPanel = DrawPanel to use (can be null) mainly used for clipping purposes * @param aPanel = DrawPanel to use (can be null) mainly used for clipping purposes
* @param aDC = Device Context (can be null) * @param aDC = Device Context (can be null)
* @param aOffset = offset to draw * @param aOffset = offset to draw
* @param aColor = -1 to use the normal body item color, or use this color if >= 0 * @param aColor = -1 to use the normal body item color, or use this color if >= 0
* @param aDrawMode = GR_OR, GR_XOR, ... * @param aDrawMode = GR_OR, GR_XOR, ...
* @param aData = value or pointer used to pass others parametres, depending on body items. * @param aData = value or pointer used to pass others parametres, depending on body items.
* used for some items to force to force no fill mode * used for some items to force to force no fill mode
* ( has meaning only for items what can be filled ). used in printing or moving objects mode * ( has meaning only for items what can be filled ). used in printing or moving objects mode
* or to pass refernce to the lib component for pins * or to pass refernce to the lib component for pins
* @param aTransformMatrix = Transform Matrix (rotaion, mirror ..) * @param aTransformMatrix = Transform Matrix (rotaion, mirror ..)
*/ */
virtual void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor, virtual void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void * aData, int aTransformMatrix[2][2] ) = 0; int aDrawMode, void* aData, int aTransformMatrix[2][2] ) = 0;
/** /**
* Function Save * Function Save
@ -166,9 +166,9 @@ public:
* @param aFile The FILE to write to. * @param aFile The FILE to write to.
* @return bool - true if success writing else false. * @return bool - true if success writing else false.
*/ */
virtual bool Save( FILE* aFile ) const = 0; virtual bool Save( FILE* aFile ) const = 0;
void Display_Infos_DrawEntry( WinEDA_DrawFrame* frame ); void Display_Infos_DrawEntry( WinEDA_DrawFrame* frame );
}; };
@ -202,36 +202,37 @@ public:
return wxT( "LibDrawPin" ); return wxT( "LibDrawPin" );
} }
/** /**
* Function Save * Function Save
* writes the data structures for this object out to a FILE in "*.brd" format. * writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to. * @param aFile The FILE to write to.
* @return bool - true if success writing else false. * @return bool - true if success writing else false.
*/ */
virtual bool Save( FILE* aFile ) const; virtual bool Save( FILE* aFile ) const;
LibDrawPin* GenCopy(); LibDrawPin* GenCopy();
void Display_Infos( WinEDA_DrawFrame* frame ); void Display_Infos( WinEDA_DrawFrame* frame );
wxPoint ReturnPinEndPoint(); wxPoint ReturnPinEndPoint();
int ReturnPinDrawOrient( int TransMat[2][2] ); int ReturnPinDrawOrient( int TransMat[2][2] );
void ReturnPinStringNum( wxString& buffer ) const; void ReturnPinStringNum( wxString& buffer ) const;
void SetPinNumFromString( wxString& buffer ); void SetPinNumFromString( wxString& buffer );
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor, void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void * aData, int aTransformMatrix[2][2] ); int aDrawMode, void* aData, int aTransformMatrix[2][2] );
void DrawPinSymbol( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& pin_pos, void DrawPinSymbol( WinEDA_DrawPanel* panel, wxDC* DC, const wxPoint& pin_pos,
int orient, int orient,
int DrawMode, int Color = -1 ); int DrawMode, int Color = -1 );
void DrawPinTexts( WinEDA_DrawPanel* panel, wxDC* DC, void DrawPinTexts( WinEDA_DrawPanel* panel, wxDC* DC,
wxPoint& pin_pos, int orient, wxPoint& pin_pos, int orient,
int TextInside, bool DrawPinNum, bool DrawPinName, int TextInside, bool DrawPinNum, bool DrawPinName,
int Color, int DrawMode ); int Color, int DrawMode );
void PlotPinTexts( wxPoint& pin_pos, int orient, void PlotPinTexts( wxPoint& pin_pos, int orient,
int TextInside, bool DrawPinNum, bool DrawPinName ); int TextInside, bool DrawPinNum, bool DrawPinName );
}; };
@ -253,18 +254,21 @@ public:
{ {
return wxT( "LibDrawArc" ); return wxT( "LibDrawArc" );
} }
/** /**
* Function Save * Function Save
* writes the data structures for this object out to a FILE in "*.brd" format. * writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to. * @param aFile The FILE to write to.
* @return bool - true if success writing else false. * @return bool - true if success writing else false.
*/ */
virtual bool Save( FILE* aFile ) const; virtual bool Save( FILE* aFile ) const;
LibDrawArc* GenCopy(); LibDrawArc* GenCopy();
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor, void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void * aData, int aTransformMatrix[2][2] ); int aDrawMode, void* aData, int aTransformMatrix[2][2] );
}; };
/*****************************/ /*****************************/
@ -273,7 +277,7 @@ public:
class LibDrawCircle : public LibEDA_BaseStruct class LibDrawCircle : public LibEDA_BaseStruct
{ {
public: public:
int m_Rayon; int m_Rayon;
public: public:
LibDrawCircle(); LibDrawCircle();
@ -282,18 +286,21 @@ public:
{ {
return wxT( "LibDrawCircle" ); return wxT( "LibDrawCircle" );
} }
/** /**
* Function Save * Function Save
* writes the data structures for this object out to a FILE in "*.brd" format. * writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to. * @param aFile The FILE to write to.
* @return bool - true if success writing else false. * @return bool - true if success writing else false.
*/ */
virtual bool Save( FILE* aFile ) const; virtual bool Save( FILE* aFile ) const;
LibDrawCircle* GenCopy(); LibDrawCircle* GenCopy();
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor, void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void * aData, int aTransformMatrix[2][2] ); int aDrawMode, void* aData, int aTransformMatrix[2][2] );
}; };
@ -318,18 +325,21 @@ public:
{ {
return wxT( "LibDrawText" ); return wxT( "LibDrawText" );
} }
/** /**
* Function Save * Function Save
* writes the data structures for this object out to a FILE in "*.brd" format. * writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to. * @param aFile The FILE to write to.
* @return bool - true if success writing else false. * @return bool - true if success writing else false.
*/ */
virtual bool Save( FILE* aFile ) const; virtual bool Save( FILE* aFile ) const;
LibDrawText* GenCopy(); LibDrawText* GenCopy();
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor, void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void * aData, int aTransformMatrix[2][2] ); int aDrawMode, void* aData, int aTransformMatrix[2][2] );
}; };
@ -348,18 +358,21 @@ public:
{ {
return wxT( "LibDrawSquare" ); return wxT( "LibDrawSquare" );
} }
/** /**
* Function Save * Function Save
* writes the data structures for this object out to a FILE in "*.brd" format. * writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to. * @param aFile The FILE to write to.
* @return bool - true if success writing else false. * @return bool - true if success writing else false.
*/ */
virtual bool Save( FILE* aFile ) const; virtual bool Save( FILE* aFile ) const;
LibDrawSquare* GenCopy(); LibDrawSquare* GenCopy();
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor, void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void * aData, int aTransformMatrix[2][2] ); int aDrawMode, void* aData, int aTransformMatrix[2][2] );
}; };
/**********************************/ /**********************************/
@ -377,18 +390,21 @@ public:
{ {
return wxT( "LibDrawSegment" ); return wxT( "LibDrawSegment" );
} }
/** /**
* Function Save * Function Save
* writes the data structures for this object out to a FILE in "*.brd" format. * writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to. * @param aFile The FILE to write to.
* @return bool - true if success writing else false. * @return bool - true if success writing else false.
*/ */
virtual bool Save( FILE* aFile ) const; virtual bool Save( FILE* aFile ) const;
LibDrawSegment* GenCopy(); LibDrawSegment* GenCopy();
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor, void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void * aData, int aTransformMatrix[2][2] ); int aDrawMode, void* aData, int aTransformMatrix[2][2] );
}; };
/*********************************************/ /*********************************************/
@ -397,8 +413,8 @@ public:
class LibDrawPolyline : public LibEDA_BaseStruct class LibDrawPolyline : public LibEDA_BaseStruct
{ {
public: public:
int m_CornersCount; int m_CornersCount;
int* m_PolyList; int* m_PolyList;
public: public:
LibDrawPolyline(); LibDrawPolyline();
@ -414,18 +430,20 @@ public:
return wxT( "LibDrawPolyline" ); return wxT( "LibDrawPolyline" );
} }
/** /**
* Function Save * Function Save
* writes the data structures for this object out to a FILE in "*.brd" format. * writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to. * @param aFile The FILE to write to.
* @return bool - true if success writing else false. * @return bool - true if success writing else false.
*/ */
virtual bool Save( FILE* aFile ) const; virtual bool Save( FILE* aFile ) const;
LibDrawPolyline* GenCopy();
void AddPoint( const wxPoint& point );
LibDrawPolyline* GenCopy();
void AddPoint( const wxPoint& point );
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor, void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void * aData, int aTransformMatrix[2][2] ); int aDrawMode, void* aData, int aTransformMatrix[2][2] );
}; };
@ -443,21 +461,22 @@ class LibDrawField : public LibEDA_BaseStruct
{ {
public: public:
int m_FieldId; /* 0 a 11 int m_FieldId; /* 0 a 11
* 0 = Reference; 1 = Value * 0 = Reference; 1 = Value
* 2 = Default footprint, 3 = subsheet (not used, reserved) * 2 = Default footprint, 3 = subsheet (not used, reserved)
* .. 11 other fields * .. 11 other fields
*/ */
wxSize m_Size; wxSize m_Size;
int m_Orient; /* Orientation */ int m_Orient; /* Orientation */
int m_Attributs; /* Attributes (Non visible ...) */ int m_Attributs; /* Attributes (Non visible ...) */
int m_HJustify, m_VJustify; /* Horiz and Vert Text Justifications */ enum GRTextHorizJustifyType m_HJustify; /* Horizontal Text Justify */
wxString m_Text; /* Field Data */ enum GRTextVertJustifyType m_VJustify; /* Vertical Text Justify */
wxString m_Name; /* Field Name */ wxString m_Text; /* Field Data */
wxString m_Name; /* Field Name */
public: public:
LibDrawField* Next() const { return (LibDrawField*) Pnext; } LibDrawField* Next() const { return (LibDrawField*) Pnext; }
LibDrawField* Back() const { return (LibDrawField*) Pback; } LibDrawField* Back() const { return (LibDrawField*) Pback; }
LibDrawField( int idfield = 2 ); LibDrawField( int idfield = 2 );
@ -466,19 +485,23 @@ public:
{ {
return wxT( "LibDrawField" ); return wxT( "LibDrawField" );
} }
/** /**
* Function Save * Function Save
* writes the data structures for this object out to a FILE in "*.brd" format. * writes the data structures for this object out to a FILE in "*.brd" format.
* @param aFile The FILE to write to. * @param aFile The FILE to write to.
* @return bool - true if success writing else false. * @return bool - true if success writing else false.
*/ */
virtual bool Save( FILE* aFile ) const; virtual bool Save( FILE* aFile ) const;
LibDrawField* GenCopy(); LibDrawField* GenCopy();
void Copy( LibDrawField* Target ); void Copy( LibDrawField* Target );
void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor, void Draw( WinEDA_DrawPanel * aPanel, wxDC * aDC, const wxPoint &aOffset, int aColor,
int aDrawMode, void * aData, int aTransformMatrix[2][2] ); int aDrawMode, void* aData, int aTransformMatrix[2][2] );
/** /**
* Function HitTest * Function HitTest
* tests if the given wxPoint is within the bounds of this object. * tests if the given wxPoint is within the bounds of this object.

4
eeschema/edit_component_in_lib.cpp
View File

@ -106,11 +106,11 @@ void WinEDA_PartPropertiesFrame::CopyBufferToFieldData( LibDrawField* Field )
* field "Field" * field "Field"
*/ */
{ {
int hjustify[3] = { GRTextHorizJustifyType hjustify[3] = {
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_CENTER,
GR_TEXT_HJUSTIFY_RIGHT GR_TEXT_HJUSTIFY_RIGHT
}; };
int vjustify[3] = { GRTextVertJustifyType vjustify[3] = {
GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_CENTER,
GR_TEXT_VJUSTIFY_TOP GR_TEXT_VJUSTIFY_TOP
}; };

61
eeschema/eelibs_draw_components.cpp
View File

@ -253,7 +253,8 @@ void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel,
EDA_Colors color; EDA_Colors color;
wxPoint pos; /* Position des textes */ wxPoint pos; /* Position des textes */
SCH_COMPONENT* DrawLibItem = (SCH_COMPONENT*) m_Parent; SCH_COMPONENT* DrawLibItem = (SCH_COMPONENT*) m_Parent;
int hjustify, vjustify; GRTextHorizJustifyType hjustify;
GRTextVertJustifyType vjustify;
int LineWidth = MAX( m_Width, g_DrawMinimunLineWidth ); int LineWidth = MAX( m_Width, g_DrawMinimunLineWidth );
if( m_Attributs & TEXT_NO_VISIBLE ) if( m_Attributs & TEXT_NO_VISIBLE )
@ -280,19 +281,61 @@ void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel,
else else
orient = TEXT_ORIENT_HORIZ; orient = TEXT_ORIENT_HORIZ;
/* Y a t-il rotation, miroir (pour les justifications)*/ /* Y a t-il rotation, miroir (pour les justifications)*/
EXCHG( hjustify, vjustify ); GRTextHorizJustifyType tmp = hjustify;
hjustify = (GRTextHorizJustifyType) vjustify;
vjustify = (GRTextVertJustifyType) tmp;
if( DrawLibItem->m_Transform[1][0] < 0 ) if( DrawLibItem->m_Transform[1][0] < 0 )
vjustify = -vjustify; switch ( vjustify )
{
case GR_TEXT_VJUSTIFY_BOTTOM:
vjustify = GR_TEXT_VJUSTIFY_TOP;
break;
case GR_TEXT_VJUSTIFY_TOP:
vjustify = GR_TEXT_VJUSTIFY_BOTTOM;
break;
default:
break;
}
if( DrawLibItem->m_Transform[1][0] > 0 ) if( DrawLibItem->m_Transform[1][0] > 0 )
hjustify = -hjustify; switch ( hjustify )
{
case GR_TEXT_HJUSTIFY_LEFT:
hjustify = GR_TEXT_HJUSTIFY_RIGHT;
break;
case GR_TEXT_HJUSTIFY_RIGHT:
hjustify = GR_TEXT_HJUSTIFY_LEFT;
break;
default:
break;
}
} }
else else
{ {
/* Texte horizontal: Y a t-il miroir (pour les justifications)*/ /* Texte horizontal: Y a t-il miroir (pour les justifications)*/
if( DrawLibItem->m_Transform[0][0] < 0 ) if( DrawLibItem->m_Transform[0][0] < 0 )
hjustify = -hjustify; switch ( hjustify )
{
case GR_TEXT_HJUSTIFY_LEFT:
hjustify = GR_TEXT_HJUSTIFY_RIGHT;
break;
case GR_TEXT_HJUSTIFY_RIGHT:
hjustify = GR_TEXT_HJUSTIFY_LEFT;
break;
default:
break;
}
if( DrawLibItem->m_Transform[1][1] > 0 ) if( DrawLibItem->m_Transform[1][1] > 0 )
vjustify = -vjustify; switch ( vjustify )
{
case GR_TEXT_VJUSTIFY_BOTTOM:
vjustify = GR_TEXT_VJUSTIFY_TOP;
break;
case GR_TEXT_VJUSTIFY_TOP:
vjustify = GR_TEXT_VJUSTIFY_BOTTOM;
break;
default:
break;
}
} }
if( m_FieldId == REFERENCE ) if( m_FieldId == REFERENCE )
@ -309,9 +352,9 @@ void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel,
m_Size, m_Size,
hjustify, vjustify, LineWidth ); hjustify, vjustify, LineWidth );
} }
else // Si il y a plusieurs parts par boitier, ajouter a la reference l'identification de la selection ( A, B ... ) else // For more than one part per package, we must add the part selection to the reference )
{ {
/* On ajoute alors A ou B ... a la reference */ /* Adding A ou B ... or .1 .2 ... to the reference */
wxString fulltext = m_Text; wxString fulltext = m_Text;
#if defined(KICAD_GOST) #if defined(KICAD_GOST)
fulltext.Append( '.'); fulltext.Append( '.');
@ -320,7 +363,7 @@ void SCH_CMP_FIELD::Draw( WinEDA_DrawPanel* panel,
fulltext.Append( 'A' - 1 + DrawLibItem->m_Multi ); fulltext.Append( 'A' - 1 + DrawLibItem->m_Multi );
#endif #endif
DrawGraphicText( panel, DC, pos, color, fulltext.GetData(), DrawGraphicText( panel, DC, pos, color, fulltext,
orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ, orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
m_Size, m_Size,
hjustify, vjustify, LineWidth ); hjustify, vjustify, LineWidth );

6
eeschema/eelibs_read_libraryfiles.cpp
View File

@ -871,7 +871,7 @@ GetLibEntryField (EDA_LibComponentStruct* LibEntry,
* ou n = 0 (REFERENCE), 1 (VALUE) , 2 .. 11 = autres champs, facultatifs * ou n = 0 (REFERENCE), 1 (VALUE) , 2 .. 11 = autres champs, facultatifs
*/ */
{ {
int posx, posy, size, orient, hjustify, vjustify; int posx, posy, size, orient;
bool draw; bool draw;
char* Text, char* Text,
Char1[256], Char2[256], Char1[256], Char2[256],
@ -919,8 +919,8 @@ GetLibEntryField (EDA_LibComponentStruct* LibEntry,
draw = TRUE; if( Char2[0] == 'I' ) draw = TRUE; if( Char2[0] == 'I' )
draw = FALSE; draw = FALSE;
hjustify = GR_TEXT_HJUSTIFY_CENTER; GRTextHorizJustifyType hjustify = GR_TEXT_HJUSTIFY_CENTER;
vjustify = GR_TEXT_VJUSTIFY_CENTER; GRTextVertJustifyType vjustify = GR_TEXT_VJUSTIFY_CENTER;
if( nbparam >= 6 ) if( nbparam >= 6 )
{ {

4
eeschema/load_one_schematic_file.cpp
View File

@ -670,8 +670,8 @@ static int ReadPartDescr( wxWindow* frame, char* Line, FILE* f,
int fieldNdx; int fieldNdx;
char FieldUserName[1024]; char FieldUserName[1024];
int hjustify = GR_TEXT_HJUSTIFY_CENTER; GRTextHorizJustifyType hjustify = GR_TEXT_HJUSTIFY_CENTER;
int vjustify = GR_TEXT_VJUSTIFY_CENTER; GRTextVertJustifyType vjustify = GR_TEXT_VJUSTIFY_CENTER;
FieldUserName[0] = 0; FieldUserName[0] = 0;

59
eeschema/plot.cpp
View File

@ -376,7 +376,6 @@ static void PlotTextField( SCH_COMPONENT* DrawLibItem,
{ {
wxPoint textpos; /* Position des textes */ wxPoint textpos; /* Position des textes */
SCH_CMP_FIELD* field = DrawLibItem->GetField( FieldNumber ); SCH_CMP_FIELD* field = DrawLibItem->GetField( FieldNumber );
int hjustify, vjustify;
int orient; int orient;
EDA_Colors color = UNSPECIFIED_COLOR; EDA_Colors color = UNSPECIFIED_COLOR;
@ -391,7 +390,8 @@ static void PlotTextField( SCH_COMPONENT* DrawLibItem,
/* Calcul de la position des textes, selon orientation du composant */ /* Calcul de la position des textes, selon orientation du composant */
orient = field->m_Orient; orient = field->m_Orient;
hjustify = field->m_HJustify; vjustify = field->m_VJustify; GRTextHorizJustifyType hjustify = field->m_HJustify;
GRTextVertJustifyType vjustify = field->m_VJustify;
textpos = field->m_Pos - DrawLibItem->m_Pos; // textpos is the text position relative to the component anchor textpos = field->m_Pos - DrawLibItem->m_Pos; // textpos is the text position relative to the component anchor
textpos = TransformCoordinate( DrawLibItem->m_Transform, textpos ) + DrawLibItem->m_Pos; textpos = TransformCoordinate( DrawLibItem->m_Transform, textpos ) + DrawLibItem->m_Pos;
@ -404,19 +404,62 @@ static void PlotTextField( SCH_COMPONENT* DrawLibItem,
else else
orient = TEXT_ORIENT_HORIZ; orient = TEXT_ORIENT_HORIZ;
/* Y a t-il rotation, miroir (pour les justifications)*/ /* Y a t-il rotation, miroir (pour les justifications)*/
EXCHG( hjustify, vjustify ); GRTextHorizJustifyType tmp = hjustify;
hjustify = (GRTextHorizJustifyType) vjustify;
vjustify = (GRTextVertJustifyType) tmp;
if( DrawLibItem->m_Transform[1][0] < 0 ) if( DrawLibItem->m_Transform[1][0] < 0 )
vjustify = -vjustify; switch ( vjustify )
{
case GR_TEXT_VJUSTIFY_BOTTOM:
vjustify = GR_TEXT_VJUSTIFY_TOP;
break;
case GR_TEXT_VJUSTIFY_TOP:
vjustify = GR_TEXT_VJUSTIFY_BOTTOM;
break;
default:
break;
}
if( DrawLibItem->m_Transform[1][0] > 0 ) if( DrawLibItem->m_Transform[1][0] > 0 )
hjustify = -hjustify; switch ( hjustify )
{
case GR_TEXT_HJUSTIFY_LEFT:
hjustify = GR_TEXT_HJUSTIFY_RIGHT;
break;
case GR_TEXT_HJUSTIFY_RIGHT:
hjustify = GR_TEXT_HJUSTIFY_LEFT;
break;
default:
break;
}
} }
else else
{ {
/* Texte horizontal: Y a t-il miroir (pour les justifications)*/ /* Texte horizontal: Y a t-il miroir (pour les justifications)*/
if( DrawLibItem->m_Transform[0][0] < 0 ) if( DrawLibItem->m_Transform[0][0] < 0 )
hjustify = -hjustify; switch ( hjustify )
{
case GR_TEXT_HJUSTIFY_LEFT:
hjustify = GR_TEXT_HJUSTIFY_RIGHT;
break;
case GR_TEXT_HJUSTIFY_RIGHT:
hjustify = GR_TEXT_HJUSTIFY_LEFT;
break;
default:
break;
}
if( DrawLibItem->m_Transform[1][1] > 0 ) if( DrawLibItem->m_Transform[1][1] > 0 )
vjustify = -vjustify; switch ( vjustify )
{
case GR_TEXT_VJUSTIFY_BOTTOM:
vjustify = GR_TEXT_VJUSTIFY_TOP;
break;
case GR_TEXT_VJUSTIFY_TOP:
vjustify = GR_TEXT_VJUSTIFY_BOTTOM;
break;
default:
break;
}
} }
SetCurrentLineWidth( -1 ); SetCurrentLineWidth( -1 );
@ -686,7 +729,6 @@ static void PlotSheetLabelStruct( Hierarchical_PIN_Sheet_Struct* Struct )
/***********************************************************************/ /***********************************************************************/
/* Routine de dessin des Sheet Labels type hierarchie */ /* Routine de dessin des Sheet Labels type hierarchie */
{ {
int side;
EDA_Colors txtcolor = UNSPECIFIED_COLOR; EDA_Colors txtcolor = UNSPECIFIED_COLOR;
int posx, tposx, posy, size, size2; int posx, tposx, posy, size, size2;
int coord[16]; int coord[16];
@ -695,6 +737,7 @@ static void PlotSheetLabelStruct( Hierarchical_PIN_Sheet_Struct* Struct )
txtcolor = ReturnLayerColor( Struct->GetLayer() ); txtcolor = ReturnLayerColor( Struct->GetLayer() );
posx = Struct->m_Pos.x; posy = Struct->m_Pos.y; size = Struct->m_Size.x; posx = Struct->m_Pos.x; posy = Struct->m_Pos.y; size = Struct->m_Size.x;
GRTextHorizJustifyType side;
if( Struct->m_Edge ) if( Struct->m_Edge )
{ {
tposx = posx - size; tposx = posx - size;

88
include/base_struct.h
View File

@ -5,6 +5,7 @@
#ifndef BASE_STRUCT_H #ifndef BASE_STRUCT_H
#define BASE_STRUCT_H #define BASE_STRUCT_H
#include "colors.h"
#if defined (DEBUG) #if defined (DEBUG)
#include <iostream> // needed for Show() #include <iostream> // needed for Show()
@ -127,7 +128,6 @@ public:
}; };
/** /**
* Class EDA_Rect * Class EDA_Rect
* handles the component boundary box. * handles the component boundary box.
@ -144,8 +144,9 @@ public:
EDA_Rect() { }; EDA_Rect() { };
EDA_Rect( const wxPoint& aPos, const wxSize& aSize ) : EDA_Rect( const wxPoint& aPos, const wxSize& aSize ) :
m_Pos( aPos ), m_Size( aSize ) m_Pos( aPos )
{} , m_Size( aSize )
{ }
wxPoint Centre() wxPoint Centre()
{ {
@ -182,6 +183,7 @@ public:
m_Size.x = pos.x - m_Pos.x; m_Size.y = pos.y - m_Pos.y; m_Size.x = pos.x - m_Pos.x; m_Size.y = pos.y - m_Pos.y;
} }
/** /**
* Function Intersects * Function Intersects
* @return bool - true if the argument rectangle intersects this rectangle. * @return bool - true if the argument rectangle intersects this rectangle.
@ -195,15 +197,14 @@ public:
*/ */
operator wxRect() const { return wxRect( m_Pos, m_Size ); } operator wxRect() const { return wxRect( m_Pos, m_Size ); }
EDA_Rect& Inflate( wxCoord dx, wxCoord dy ); EDA_Rect& Inflate( wxCoord dx, wxCoord dy );
/** Function Merge /** Function Merge
* Modify Position and Size of this in order to contain the given rect * Modify Position and Size of this in order to contain the given rect
* mainly used to calculate bounding boxes * mainly used to calculate bounding boxes
* @param aRect = given rect to merge with this * @param aRect = given rect to merge with this
*/ */
void Merge( const EDA_Rect & aRect ); void Merge( const EDA_Rect& aRect );
}; };
@ -236,7 +237,7 @@ protected:
public: public:
int m_Flags; // flags for editing and other misc. uses int m_Flags; // flags for editing and other misc. uses
#define IS_CHANGED (1 << 0) #define IS_CHANGED (1 << 0)
#define IS_LINKED (1 << 1) #define IS_LINKED (1 << 1)
#define IN_EDIT (1 << 2) #define IN_EDIT (1 << 2)
@ -259,11 +260,11 @@ public:
EDA_BaseStruct* m_Image; /* Link to an image copy for undelete or abort command */ EDA_BaseStruct* m_Image; /* Link to an image copy for undelete or abort command */
unsigned long m_TimeStamp; // Time stamp used for logical links unsigned long m_TimeStamp; // Time stamp used for logical links
int m_Selected; /* Used by block commands, and selective editing */ int m_Selected; /* Used by block commands, and selective editing */
private: private:
int m_Status; int m_Status;
private: private:
void InitVars(); void InitVars();
@ -284,11 +285,11 @@ public:
KICAD_T Type() const { return m_StructType; } KICAD_T Type() const { return m_StructType; }
EDA_BaseStruct* Next() const { return (EDA_BaseStruct*) Pnext; } EDA_BaseStruct* Next() const { return (EDA_BaseStruct*) Pnext; }
EDA_BaseStruct* Back() const { return (EDA_BaseStruct*) Pback; } EDA_BaseStruct* Back() const { return (EDA_BaseStruct*) Pback; }
EDA_BaseStruct* GetParent() const { return m_Parent; } EDA_BaseStruct* GetParent() const { return m_Parent; }
EDA_BaseStruct* GetSon() const { return m_Son; } EDA_BaseStruct* GetSon() const { return m_Son; }
DHEAD* GetList() const { return m_List; } DHEAD* GetList() const { return m_List; }
void SetNext( EDA_BaseStruct* aNext ) { Pnext = aNext; } void SetNext( EDA_BaseStruct* aNext ) { Pnext = aNext; }
void SetBack( EDA_BaseStruct* aBack ) { Pback = aBack; } void SetBack( EDA_BaseStruct* aBack ) { Pback = aBack; }
@ -320,6 +321,7 @@ public:
m_Status = new_status; m_Status = new_status;
} }
/** /**
* Function Display_Infos * Function Display_Infos
* has knowledge about the frame and how and where to put status information * has knowledge about the frame and how and where to put status information
@ -343,6 +345,7 @@ public:
return false; // derived classes should override this function return false; // derived classes should override this function
} }
/** /**
* Function HitTest (overlayed) * Function HitTest (overlayed)
* tests if the given EDA_Rect intersect this object. * tests if the given EDA_Rect intersect this object.
@ -355,6 +358,7 @@ public:
return false; // derived classes should override this function return false; // derived classes should override this function
} }
/** /**
* Function GetBoundingBox * Function GetBoundingBox
* returns the orthogonal, bounding box of this object for display purposes. * returns the orthogonal, bounding box of this object for display purposes.
@ -365,14 +369,16 @@ public:
virtual EDA_Rect GetBoundingBox() virtual EDA_Rect GetBoundingBox()
{ {
#if defined (DEBUG) #if defined (DEBUG)
printf("Missing GetBoundingBox()\n"); printf( "Missing GetBoundingBox()\n" );
Show( 0, std::cout ); // tell me which classes still need GetBoundingBox support Show( 0, std::cout ); // tell me which classes still need GetBoundingBox support
#endif #endif
// return a zero-sized box per default. derived classes should override this // return a zero-sized box per default. derived classes should override this
EDA_Rect ret( wxPoint( 0, 0 ), wxSize( 0, 0 ) ); EDA_Rect ret( wxPoint( 0, 0 ), wxSize( 0, 0 ) );
return ret; return ret;
} }
/** /**
* Function IterateForward * Function IterateForward
* walks through the object tree calling the inspector() on each object * walks through the object tree calling the inspector() on each object
@ -449,26 +455,27 @@ public:
}; };
// Text justify: // Graphic Text justify:
// Values -1,0,1 are used in computations, do not change them // Values -1,0,1 are used in computations, do not change them
typedef enum { enum GRTextHorizJustifyType {
GR_TEXT_HJUSTIFY_LEFT = -1, GR_TEXT_HJUSTIFY_LEFT = -1,
GR_TEXT_HJUSTIFY_CENTER = 0, GR_TEXT_HJUSTIFY_CENTER = 0,
GR_TEXT_HJUSTIFY_RIGHT = 1 GR_TEXT_HJUSTIFY_RIGHT = 1
} GRTextHorizJustifyType; };
typedef enum { enum GRTextVertJustifyType {
GR_TEXT_VJUSTIFY_TOP = -1, GR_TEXT_VJUSTIFY_TOP = -1,
GR_TEXT_VJUSTIFY_CENTER = 0, GR_TEXT_VJUSTIFY_CENTER = 0,
GR_TEXT_VJUSTIFY_BOTTOM = 1 GR_TEXT_VJUSTIFY_BOTTOM = 1
} GRTextVertJustifyType; };
/* Options to show solid segments (segments, texts...) */
/* controle des remplissages a l'ecran (Segments textes...)*/ enum GRFillMode {
#define FILAIRE 0 FILAIRE = 0, // segments are drawn as lines
#define FILLED 1 FILLED, // normal mode: segments have thickness
#define SKETCH 2 SKETCH // skect mode: segments have thickness, but are not filled
};
#define DEFAULT_SIZE_TEXT 60 /* default text height (in mils or 1/1000") */ #define DEFAULT_SIZE_TEXT 60 /* default text height (in mils or 1/1000") */
@ -489,18 +496,13 @@ public:
int m_Orient; /* Orient in 0.1 degrees */ int m_Orient; /* Orient in 0.1 degrees */
int m_Miroir; // Display Normal / mirror int m_Miroir; // Display Normal / mirror
int m_Attributs; /* flags (visible...) */ int m_Attributs; /* flags (visible...) */
int m_CharType; /* normal, bold, italic ... */ bool m_Italic; /* true to simulate an italic font... */
int m_HJustify, m_VJustify; /* Horiz and Vert Justifications */ GRTextHorizJustifyType m_HJustify; /* Horiz Justify */
int m_ZoomLevelDrawable; /* zoom level to draw text. GRTextVertJustifyType m_VJustify; /* Vertical and Vert Justify */
* if zoom < m_ZoomLevelDrawable: the text is drawn as a single line
*/
int* m_TextDrawings; /* list of segments to draw, for the Draw function */
int m_TextDrawingsSize; /* segment count */
public: public:
EDA_TextStruct( const wxString& text = wxEmptyString ); EDA_TextStruct( const wxString& text = wxEmptyString );
virtual ~EDA_TextStruct(); virtual ~EDA_TextStruct();
void CreateDrawData();
int GetLength() const { return m_Text.Length(); }; int GetLength() const { return m_Text.Length(); };
@ -510,9 +512,19 @@ public:
*/ */
int Pitch(); int Pitch();
void Draw( WinEDA_DrawPanel* panel, wxDC* DC, /** Function Draw
const wxPoint& offset, int color, * @param aPanel = the current DrawPanel
int draw_mode, int display_mode = FILAIRE, int anchor_color = -1 ); * @param aDC = the current Device Context
* @param aOffset = draw offset (usually (0,0))
* @param EDA_Colors aColor = text color
* @param aDraw_mode = GR_OR, GR_XOR.., -1 to use the current mode.
* @param GRFillMode aDisplay_mode = FILAIRE, FILLED or SKETCH
* @param EDA_Colors aAnchor_color = anchor color ( UNSPECIFIED_COLOR = do not draw anchor ).
*/
void Draw( WinEDA_DrawPanel* aPanel, wxDC* aDC,
const wxPoint& aOffset, EDA_Colors aColor,
int aDisplayMode, GRFillMode aDisplay_mode = FILAIRE,
EDA_Colors aAnchor_color = UNSPECIFIED_COLOR );
/** /**
* Function HitTest * Function HitTest

15
include/common.h
View File

@ -439,10 +439,17 @@ double round( double aNumber );
* @param aV_justify = vertical justification (bottom, center, top) * @param aV_justify = vertical justification (bottom, center, top)
* @param aWidth = line width (pen width) (default = 0) * @param aWidth = line width (pen width) (default = 0)
* if width < 0 : draw segments in sketch mode, width = abs(width) * if width < 0 : draw segments in sketch mode, width = abs(width)
* @param aItalic = true to simulate an italic font
* @param aCallback() = function called (if non null) to draw each segment.
* used only to draw 3D texts
*/ */
void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* aDC, void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* aDC,
const wxPoint& aPos, enum EDA_Colors aColor, const wxString& aText, const wxPoint& aPos, enum EDA_Colors aColor, const wxString& aText,
int aOrient, const wxSize& aSize, int aH_justify, int aV_justify, int aWidth = 0); int aOrient, const wxSize& aSize,
enum GRTextHorizJustifyType aH_justify,
enum GRTextVertJustifyType aV_justify,
int aWidth = 0, bool aItalic = false,
void (*aCallback)(int x0, int y0, int xf, int yf) = NULL);
/** Function PlotGraphicText /** Function PlotGraphicText
* same as DrawGraphicText, but plot graphic text insteed of draw it * same as DrawGraphicText, but plot graphic text insteed of draw it
@ -454,10 +461,14 @@ void DrawGraphicText( WinEDA_DrawPanel* aPanel, wxDC* aDC,
* @param aSize = text size (size.x or size.y can be < 0 for mirrored texts) * @param aSize = text size (size.x or size.y can be < 0 for mirrored texts)
* @param aH_justify = horizontal justification (Left, center, right) * @param aH_justify = horizontal justification (Left, center, right)
* @param aV_justify = vertical justification (bottom, center, top) * @param aV_justify = vertical justification (bottom, center, top)
* @param aItalic = true to simulate an italic font
*/ */
void PlotGraphicText( int aFormat_plot, const wxPoint& aPos, enum EDA_Colors aColor, void PlotGraphicText( int aFormat_plot, const wxPoint& aPos, enum EDA_Colors aColor,
const wxString& aText, const wxString& aText,
int aOrient, const wxSize& aSize, int aH_justify, int aV_justify ); int aOrient, const wxSize& aSize,
enum GRTextHorizJustifyType aH_justify,
enum GRTextVertJustifyType aV_justify,
bool aItalic = false );
/***************/ /***************/
/* CONFIRM.CPP */ /* CONFIRM.CPP */

3
pcbnew/block.cpp
View File

@ -710,8 +710,6 @@ void WinEDA_BasePcbFrame::Block_Rotate( wxDC* DC )
STRUCT->m_Orient += 900; STRUCT->m_Orient += 900;
if( STRUCT->m_Orient >= 3600 ) if( STRUCT->m_Orient >= 3600 )
STRUCT->m_Orient -= 3600; STRUCT->m_Orient -= 3600;
STRUCT->CreateDrawData();
break; break;
case TYPE_MIRE: case TYPE_MIRE:
@ -896,7 +894,6 @@ void WinEDA_BasePcbFrame::Block_Invert( wxDC* DC )
STRUCT->m_Miroir ^= 1; /* inverse miroir */ STRUCT->m_Miroir ^= 1; /* inverse miroir */
} }
STRUCT->SetLayer( ChangeSideNumLayer( STRUCT->GetLayer() ) ); STRUCT->SetLayer( ChangeSideNumLayer( STRUCT->GetLayer() ) );
STRUCT->CreateDrawData();
break; break;
case TYPE_MIRE: case TYPE_MIRE:

8
pcbnew/class_pcb_text.cpp
View File

@ -40,7 +40,7 @@ void TEXTE_PCB::Copy( TEXTE_PCB* source )
m_Layer = source->m_Layer; m_Layer = source->m_Layer;
m_Width = source->m_Width; m_Width = source->m_Width;
m_Attributs = source->m_Attributs; m_Attributs = source->m_Attributs;
m_CharType = source->m_CharType; m_Italic = source->m_Italic;
m_HJustify = source->m_HJustify; m_HJustify = source->m_HJustify;
m_VJustify = source->m_VJustify; m_VJustify = source->m_VJustify;
@ -135,9 +135,9 @@ void TEXTE_PCB::Draw( WinEDA_DrawPanel* panel, wxDC* DC,
if( color & ITEM_NOT_SHOW ) if( color & ITEM_NOT_SHOW )
return; return;
EDA_TextStruct::Draw( panel, DC, offset, color, EDA_TextStruct::Draw( panel, DC, offset, (EDA_Colors) color,
DrawMode, DisplayOpt.DisplayDrawItems, DrawMode, (GRFillMode)DisplayOpt.DisplayDrawItems,
(g_AnchorColor & ITEM_NOT_SHOW) ? -1 : (g_AnchorColor & MASKCOLOR) ); (g_AnchorColor & ITEM_NOT_SHOW) ? UNSPECIFIED_COLOR : (EDA_Colors)g_AnchorColor );
} }

47
pcbnew/class_track.cpp
View File

@ -635,6 +635,49 @@ void TRACK::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoin
m_End.x, m_End.y, m_End.x, m_End.y,
m_Width + (g_DesignSettings.m_TrackClearence * 2), color ); m_Width + (g_DesignSettings.m_TrackClearence * 2), color );
} }
/* Display the short netname:
* we must filter tracks, to avoid a lot of texts.
* - only horizontal or vertical tracks are eligible
* - only tracks with a length > 10 * thickness are eligible
*/
#define THRESHOLD 10
if( (m_End.x - m_Start.x) != 0 && (m_End.y - m_Start.y) != 0 )
return;
int len = ABS( (m_End.x - m_Start.x) + (m_End.y - m_Start.y) );
if( len < THRESHOLD * m_Width )
return;
if( GetNet() == 0 )
return;
EQUIPOT* net = ( (BOARD*) GetParent() )->FindNet( GetNet() );
if( net == NULL )
return;
int textlen = net->GetShortNetname().Len();
if( textlen > 0 )
{
// calculate a good size for the text
int tsize = MIN( m_Width, len / textlen );
wxPoint tpos = m_Start + m_End;
tpos.x /= 2;
tpos.y /= 2;
// Calculate angle: if the track segment is vertical, angle = 90 degrees
int angle = 0;
if ( (m_End.x - m_Start.x) == 0 ) // Vertical segment
angle = 900; // angle is in 0.1 degree
if( ( tsize / zoom) >= 6 )
{
tsize = (tsize * 8) / 10; // small reduction to give a better look
DrawGraphicText( panel, DC, tpos,
WHITE, net->GetShortNetname(), angle, wxSize( tsize, tsize ),
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, tsize / 7 );
}
}
} }
@ -768,12 +811,12 @@ void SEGVIA::Draw( WinEDA_DrawPanel* panel, wxDC* DC, int draw_mode, const wxPoi
// Display the short netname: // Display the short netname:
if( GetNet() == 0 ) if( GetNet() == 0 )
return; return;
EQUIPOT* net = ((BOARD*)GetParent())->FindNet( GetNet() ); EQUIPOT* net = ( (BOARD*) GetParent() )->FindNet( GetNet() );
if( net == NULL ) if( net == NULL )
return; return;
int len = net->GetShortNetname().Len(); int len = net->GetShortNetname().Len();
if ( len > 0 ) if( len > 0 )
{ {
// calculate a good size for the text // calculate a good size for the text
int tsize = m_Width / len; int tsize = m_Width / len;

3
pcbnew/cotation.cpp
View File

@ -178,8 +178,6 @@ void WinEDA_CotationPropertiesFrame::OnOkClick( wxCommandEvent& event )
CurrentCotation->SetLayer( m_SelLayerBox->GetChoice() + FIRST_NO_COPPER_LAYER ); CurrentCotation->SetLayer( m_SelLayerBox->GetChoice() + FIRST_NO_COPPER_LAYER );
CurrentCotation->m_Text->SetLayer( m_SelLayerBox->GetChoice() + FIRST_NO_COPPER_LAYER ); CurrentCotation->m_Text->SetLayer( m_SelLayerBox->GetChoice() + FIRST_NO_COPPER_LAYER );
CurrentCotation->m_Text->CreateDrawData();
if( m_DC ) // Affichage nouveau texte if( m_DC ) // Affichage nouveau texte
{ {
/* Redessin du Texte */ /* Redessin du Texte */
@ -482,5 +480,4 @@ static void Ajuste_Details_Cotation( COTATION* Cotation )
Cotation->m_Value = mesure; Cotation->m_Value = mesure;
valeur_param( Cotation->m_Value, msg ); valeur_param( Cotation->m_Value, msg );
Cotation->SetText( msg ); Cotation->SetText( msg );
Cotation->m_Text->CreateDrawData();
} }

4
pcbnew/pcbtexte.cpp
View File

@ -233,7 +233,6 @@ void WinEDA_TextPCBPropertiesFrame::OnOkClick( wxCommandEvent& event )
CurrentTextPCB->m_Miroir = (m_Mirror->GetSelection() == 0) ? 1 : 0; CurrentTextPCB->m_Miroir = (m_Mirror->GetSelection() == 0) ? 1 : 0;
CurrentTextPCB->m_Orient = m_Orient->GetSelection() * 900; CurrentTextPCB->m_Orient = m_Orient->GetSelection() * 900;
CurrentTextPCB->SetLayer( m_SelLayerBox->GetChoice() ); CurrentTextPCB->SetLayer( m_SelLayerBox->GetChoice() );
CurrentTextPCB->CreateDrawData();
if( m_DC ) // Affichage nouveau texte if( m_DC ) // Affichage nouveau texte
{ {
@ -283,7 +282,6 @@ void WinEDA_PcbFrame::Place_Texte_Pcb( TEXTE_PCB* TextePcb, wxDC* DC )
if( TextePcb == NULL ) if( TextePcb == NULL )
return; return;
TextePcb->CreateDrawData();
TextePcb->Draw( DrawPanel, DC, GR_OR ); TextePcb->Draw( DrawPanel, DC, GR_OR );
DrawPanel->ManageCurseur = NULL; DrawPanel->ManageCurseur = NULL;
DrawPanel->ForceCloseManageCurseur = NULL; DrawPanel->ForceCloseManageCurseur = NULL;
@ -407,8 +405,6 @@ void WinEDA_PcbFrame::Rotate_Texte_Pcb( TEXTE_PCB* TextePcb, wxDC* DC )
if( TextePcb->m_Orient < 0 ) if( TextePcb->m_Orient < 0 )
TextePcb->m_Orient += 3600; TextePcb->m_Orient += 3600;
TextePcb->CreateDrawData();
/* Redessin du Texte */ /* Redessin du Texte */
TextePcb->Draw( DrawPanel, DC, drawmode ); TextePcb->Draw( DrawPanel, DC, drawmode );
TextePcb->Display_Infos( this ); TextePcb->Display_Infos( this );