void LIB_POLYLINE::drawGraphic( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aOffset,
EDA_COLOR_T aColor, GR_DRAWMODE aDrawMode, void* aData,
const TRANSFORM& aTransform )
{
wxPoint pos1;
EDA_COLOR_T color = GetLayerColor( LAYER_DEVICE );
wxPoint* buffer = NULL;
if( aColor < 0 ) // Used normal color or selected color
{
if( IsSelected() )
color = GetItemSelectedColor();
}
else
{
color = aColor;
}
buffer = new wxPoint[ m_PolyPoints.size() ];
for( unsigned ii = 0; ii < m_PolyPoints.size(); ii++ )
{
buffer[ii] = aTransform.TransformCoordinate( m_PolyPoints[ii] ) + aOffset;
}
FILL_T fill = aData ? NO_FILL : m_Fill;
if( aColor >= 0 )
fill = NO_FILL;
GRSetDrawMode( aDC, aDrawMode );
EDA_RECT* const clipbox = aPanel? aPanel->GetClipBox() : NULL;
if( fill == FILLED_WITH_BG_BODYCOLOR )
GRPoly( clipbox, aDC, m_PolyPoints.size(), buffer, 1, GetPenSize(),
(m_Flags & IS_MOVED) ? color : GetLayerColor( LAYER_DEVICE_BACKGROUND ),
GetLayerColor( LAYER_DEVICE_BACKGROUND ) );
else if( fill == FILLED_SHAPE )
GRPoly( clipbox, aDC, m_PolyPoints.size(), buffer, 1, GetPenSize(),
color, color );
else
GRPoly( clipbox, aDC, m_PolyPoints.size(), buffer, 0, GetPenSize(),
color, color );
delete[] buffer;
/* Set to one (1) to draw bounding box around polyline to validate
* bounding box calculation. */
#if 0
EDA_RECT bBox = GetBoundingBox();
bBox.RevertYAxis();
bBox = aTransform.TransformCoordinate( bBox );
bBox.Move( aOffset );
GRRect( clipbox, aDC, bBox, 0, LIGHTMAGENTA );
#endif
}
/* This function shows on screen the bounding box of the inductor that will be
* created at the end of the build inductor process
*/
static void ShowBoundingBoxMicroWaveInductor( EDA_DRAW_PANEL* aPanel, wxDC* aDC,
const wxPoint& aPosition, bool aErase )
{
/* Calculate the orientation and size of the box containing the inductor:
* the box is a rectangle with height = lenght/2
* the shape is defined by a rectangle, nor necessary horizontal or vertical
*/
GRSetDrawMode( aDC, GR_XOR );
wxPoint poly[5];
wxPoint pt = s_inductor_pattern.m_End - s_inductor_pattern.m_Start;
double angle = -ArcTangente( pt.y, pt.x );
int len = KiROUND( EuclideanNorm( pt ) );
// calculate corners
pt.x = 0; pt.y = len / 4;
RotatePoint( &pt, angle );
poly[0] = s_inductor_pattern.m_Start + pt;
poly[1] = s_inductor_pattern.m_End + pt;
pt.x = 0; pt.y = -len / 4;
RotatePoint( &pt, angle );
poly[2] = s_inductor_pattern.m_End + pt;
poly[3] = s_inductor_pattern.m_Start + pt;
poly[4] = poly[0];
if( aErase )
{
GRPoly( aPanel->GetClipBox(), aDC, 5, poly, false, 0, YELLOW, YELLOW );
}
s_inductor_pattern.m_End = aPanel->GetParent()->GetCrossHairPosition();
pt = s_inductor_pattern.m_End - s_inductor_pattern.m_Start;
angle = -ArcTangente( pt.y, pt.x );
len = KiROUND( EuclideanNorm( pt ) );
// calculate new corners
pt.x = 0; pt.y = len / 4;
RotatePoint( &pt, angle );
poly[0] = s_inductor_pattern.m_Start + pt;
poly[1] = s_inductor_pattern.m_End + pt;
pt.x = 0; pt.y = -len / 4;
RotatePoint( &pt, angle );
poly[2] = s_inductor_pattern.m_End + pt;
poly[3] = s_inductor_pattern.m_Start + pt;
poly[4] = poly[0];
GRPoly( aPanel->GetClipBox(), aDC, 5, poly, false, 0, YELLOW, YELLOW );
}
void LIB_BEZIER::drawGraphic( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aOffset,
void* aData, const TRANSFORM& aTransform )
{
std::vector<wxPoint> PolyPointsTraslated;
COLOR4D color = GetLayerColor( LAYER_DEVICE );
COLOR4D bgColor = GetLayerColor( LAYER_DEVICE_BACKGROUND );
BEZIER_POLY converter( m_BezierPoints );
converter.GetPoly( m_PolyPoints );
PolyPointsTraslated.clear();
for( unsigned int i = 0; i < m_PolyPoints.size() ; i++ )
PolyPointsTraslated.push_back( aTransform.TransformCoordinate( m_PolyPoints[i] ) +
aOffset );
FILL_T fill = aData ? NO_FILL : m_Fill;
EDA_RECT* const clipbox = aPanel? aPanel->GetClipBox() : NULL;
if( fill == FILLED_WITH_BG_BODYCOLOR )
{
GRPoly( clipbox, aDC, m_PolyPoints.size(), &PolyPointsTraslated[0], 1, GetPenSize(),
bgColor, bgColor );
}
else if( fill == FILLED_SHAPE )
{
GRPoly( clipbox, aDC, m_PolyPoints.size(), &PolyPointsTraslated[0], 1, GetPenSize(),
color, color );
}
else
{
GRPoly( clipbox, aDC, m_PolyPoints.size(), &PolyPointsTraslated[0], 0, GetPenSize(),
color, color );
}
}
// Helper function for drawing character polylines
static void DrawGraphicTextPline( EDA_RECT* aClipBox,
wxDC* aDC,
EDA_COLOR_T aColor,
int aWidth,
bool aSketchMode,
int point_count,
wxPoint* coord,
void (* aCallback)( int x0, int y0, int xf, int yf ),
PLOTTER* aPlotter )
{
if( aPlotter )
{
aPlotter->MoveTo( coord[0] );
for( int ik = 1; ik < point_count; ik++ )
{
aPlotter->LineTo( coord[ik] );
}
aPlotter->PenFinish();
}
else if( aCallback )
{
for( int ik = 0; ik < (point_count - 1); ik++ )
{
aCallback( coord[ik].x, coord[ik].y,
coord[ik + 1].x, coord[ik + 1].y );
}
}
else if( aDC )
{
if( aSketchMode )
{
for( int ik = 0; ik < (point_count - 1); ik++ )
GRCSegm( aClipBox, aDC, coord[ik].x, coord[ik].y,
coord[ik + 1].x, coord[ik + 1].y, aWidth, aColor );
}
else
GRPoly( aClipBox, aDC, point_count, coord, 0,
aWidth, aColor, aColor );
}
}
void SCH_GLOBALLABEL::Draw( EDA_DRAW_PANEL* panel, wxDC* DC, const wxPoint& aOffset )
{
static std::vector <wxPoint> Poly;
COLOR4D color = GetLayerColor( m_Layer );
wxPoint text_offset = aOffset + GetSchematicTextOffset();
int linewidth = GetThickness() == 0 ? GetDefaultLineThickness() : GetThickness();
linewidth = Clamp_Text_PenSize( linewidth, GetTextSize(), IsBold() );
int save_width = GetThickness();
SetThickness( linewidth );
EDA_RECT* clipbox = panel? panel->GetClipBox() : NULL;
EDA_TEXT::Draw( clipbox, DC, text_offset, color, GR_DEFAULT_DRAWMODE );
SetThickness( save_width ); // restore initial value
CreateGraphicShape( Poly, GetTextPos() + aOffset );
GRPoly( clipbox, DC, Poly.size(), &Poly[0], 0, linewidth, color, color );
}
void SCH_HIERLABEL::Draw( EDA_DRAW_PANEL* panel,
wxDC* DC,
const wxPoint& offset,
GR_DRAWMODE DrawMode,
EDA_COLOR_T Color )
{
static std::vector <wxPoint> Poly;
EDA_COLOR_T color;
int linewidth = m_Thickness == 0 ?
GetDefaultLineThickness() : m_Thickness;
EDA_RECT* clipbox = panel? panel->GetClipBox() : NULL;
linewidth = Clamp_Text_PenSize( linewidth, m_Size, m_Bold );
if( Color >= 0 )
color = Color;
else
color = GetLayerColor( m_Layer );
GRSetDrawMode( DC, DrawMode );
std::swap( linewidth, m_Thickness ); // Set the minimum width
wxPoint text_offset = offset + GetSchematicTextOffset();
EDA_TEXT::Draw( clipbox, DC, text_offset, color, DrawMode, FILLED, UNSPECIFIED_COLOR );
std::swap( linewidth, m_Thickness ); // set initial value
CreateGraphicShape( Poly, m_Pos + offset );
GRPoly( clipbox, DC, Poly.size(), &Poly[0], 0, linewidth, color, color );
if( m_isDangling && panel )
DrawDanglingSymbol( panel, DC, m_Pos + offset, color );
// Enable these line to draw the bounding box (debug tests purposes only)
#if 0
{
EDA_RECT BoundaryBox = GetBoundingBox();
GRRect( clipbox, DC, BoundaryBox, 0, BROWN );
}
#endif
}
void EDGE_MODULE::Draw(WinEDA_DrawPanel * panel, wxDC * DC,
const wxPoint & offset, int draw_mode)
/********************************************************************************/
/* Affichage d'un segment contour de module :
Entree : ox, oy = offset de trace
draw_mode = mode de trace ( GR_OR, GR_XOR, GR_AND)
Les contours sont de differents type:
- Segment
- Cercles
- Arcs
*/
{
int ux0, uy0, dx, dy,rayon, StAngle, EndAngle;
int color , type_trace;
int zoom;
int typeaff;
PCB_SCREEN * screen;
WinEDA_BasePcbFrame * frame;
MODULE * Module = NULL;
if ( m_Parent && (m_Parent->m_StructType == TYPEMODULE) )
Module = (MODULE*) m_Parent;
GRSetDrawMode(DC, draw_mode);
color = g_DesignSettings.m_LayerColor[m_Layer];
if ( panel ) screen = (PCB_SCREEN *) panel->m_Parent->m_CurrentScreen;
else screen = ActiveScreen;
frame = screen->GetParentPcbFrame();
zoom = screen->GetZoom();
type_trace = m_Shape;
ux0 = m_Start.x - offset.x; uy0 = m_Start.y - offset.y;
dx = m_End.x - offset.x ;
dy = m_End.y - offset.y ;
typeaff = frame->m_DisplayModEdge;
if( m_Layer <= CMP_N )
typeaff = frame->m_DisplayPcbTrackFill;
if( (m_Width /zoom) < L_MIN_DESSIN ) typeaff = FILAIRE;
switch (type_trace )
{
case S_SEGMENT:
if( typeaff == FILAIRE)
GRLine(&panel->m_ClipBox, DC, ux0, uy0, dx, dy, color);
else Affiche_1_Segment(panel, DC, ux0,uy0,dx,dy,m_Width,
typeaff,color);
break ;
case S_CIRCLE:
rayon = (int)hypot((double)(dx-ux0),(double)(dy-uy0) );
if( typeaff == FILAIRE)
{
GRCircle(&panel->m_ClipBox, DC, ux0, uy0, rayon, color) ;
}
else
{
if(typeaff == FILLED )
{
GRCircle(&panel->m_ClipBox, DC, ux0, uy0, rayon, m_Width, color);
}
else
{
GRCircle(&panel->m_ClipBox, DC, ux0, uy0, rayon + (m_Width/2), color) ;
GRCircle(&panel->m_ClipBox, DC, ux0, uy0, rayon - (m_Width/2), color) ;
}
}
break;
case S_ARC:
rayon = (int)hypot((double)(dx-ux0),(double)(dy-uy0) );
StAngle = (int)ArcTangente( dy-uy0, dx-ux0 );
EndAngle = StAngle + m_Angle;
if ( StAngle > EndAngle) EXCHG (StAngle, EndAngle);
if( typeaff == FILAIRE)
{
GRArc(&panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle, rayon, color) ;
}
else if(typeaff == FILLED )
{
GRArc(&panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle, rayon,
m_Width, color);
}
else
{
GRArc(&panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle,
rayon + (m_Width/2), color) ;
GRArc(&panel->m_ClipBox, DC, ux0, uy0, StAngle, EndAngle,
rayon - (m_Width/2), color) ;
}
break;
case S_POLYGON:
{
// We must compute true coordinates from m_PolyList
// which are relative to module position, orientation 0
int ii, * source, * ptr, * ptr_base;
ptr = ptr_base = (int*) MyMalloc( 2 * m_PolyCount * sizeof(int) );
source = m_PolyList;
for (ii = 0; ii < m_PolyCount; ii++ )
{
int x, y;
x = *source; source++; y = *source; source++;
if ( Module )
{
RotatePoint (&x, &y, Module->m_Orient);
x += Module->m_Pos.x;
y += Module->m_Pos.y;
}
x += m_Start0.x - offset.x;
y += m_Start0.y - offset.y;
*ptr = x; ptr++; *ptr = y; ptr++;
}
GRPoly(&panel->m_ClipBox, DC, m_PolyCount, ptr_base,
TRUE, color, color);
free ( ptr_base);
break;
}
}
}
void ZONE_CONTAINER::DrawFilledArea( EDA_DRAW_PANEL* panel,
wxDC* DC, GR_DRAWMODE aDrawMode, const wxPoint& offset )
{
static std::vector <char> CornersTypeBuffer;
static std::vector <wxPoint> CornersBuffer;
// outline_mode is false to show filled polys,
// and true to show polygons outlines only (test and debug purposes)
bool outline_mode = DisplayOpt.DisplayZonesMode == 2 ? true : false;
if( DC == NULL )
return;
if( DisplayOpt.DisplayZonesMode == 1 ) // Do not show filled areas
return;
if( m_FilledPolysList.GetCornersCount() == 0 ) // Nothing to draw
return;
BOARD* brd = GetBoard();
LAYER_NUM curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
EDA_COLOR_T color = brd->GetLayerColor( m_Layer );
if( brd->IsLayerVisible( m_Layer ) == false && ( color & HIGHLIGHT_FLAG ) != HIGHLIGHT_FLAG )
return;
GRSetDrawMode( DC, aDrawMode );
if( DisplayOpt.ContrastModeDisplay )
{
if( !IsOnLayer( curr_layer ) )
ColorTurnToDarkDarkGray( &color );
}
if( aDrawMode & GR_HIGHLIGHT )
ColorChangeHighlightFlag( &color, !(aDrawMode & GR_AND) );
ColorApplyHighlightFlag( &color );
SetAlpha( &color, 150 );
CornersTypeBuffer.clear();
CornersBuffer.clear();
// Draw all filled areas
int imax = m_FilledPolysList.GetCornersCount() - 1;
for( int ic = 0; ic <= imax; ic++ )
{
const CPolyPt& corner = m_FilledPolysList.GetCorner( ic );
wxPoint coord( corner.x + offset.x, corner.y + offset.y );
CornersBuffer.push_back( coord );
CornersTypeBuffer.push_back( (char) corner.m_utility );
// the last corner of a filled area is found: draw it
if( (corner.end_contour) || (ic == imax) )
{
/* Draw the current filled area: draw segments outline first
* Curiously, draw segments outline first and after draw filled polygons
* with outlines thickness = 0 is a faster than
* just draw filled polygons but with outlines thickness = m_ZoneMinThickness
* So DO NOT use draw filled polygons with outlines having a thickness > 0
* Note: Extra segments ( added to joint holes with external outline) flagged by
* m_utility != 0 are not drawn
* Note not all polygon libraries provide a flag for these extra-segments, therefore
* the m_utility member can be always 0
*/
{
// Draw outlines:
if( (m_ZoneMinThickness > 1) || outline_mode )
{
int ilim = CornersBuffer.size() - 1;
for( int is = 0, ie = ilim; is <= ilim; ie = is, is++ )
{
int x0 = CornersBuffer[is].x;
int y0 = CornersBuffer[is].y;
int x1 = CornersBuffer[ie].x;
int y1 = CornersBuffer[ie].y;
// Draw only basic outlines, not extra segments.
if( CornersTypeBuffer[ie] == 0 )
{
if( !DisplayOpt.DisplayPcbTrackFill || GetState( FORCE_SKETCH ) )
GRCSegm( panel->GetClipBox(), DC,
x0, y0, x1, y1,
m_ZoneMinThickness, color );
else
GRFillCSegm( panel->GetClipBox(), DC,
x0, y0, x1, y1,
m_ZoneMinThickness, color );
}
}
}
// Draw areas:
if( m_FillMode==0 && !outline_mode )
GRPoly( panel->GetClipBox(), DC, CornersBuffer.size(), &CornersBuffer[0],
true, 0, color, color );
}
CornersTypeBuffer.clear();
CornersBuffer.clear();
}
}
if( m_FillMode == 1 && !outline_mode ) // filled with segments
{
for( unsigned ic = 0; ic < m_FillSegmList.size(); ic++ )
{
wxPoint start = m_FillSegmList[ic].m_Start + offset;
wxPoint end = m_FillSegmList[ic].m_End + offset;
if( !DisplayOpt.DisplayPcbTrackFill || GetState( FORCE_SKETCH ) )
GRCSegm( panel->GetClipBox(), DC, start.x, start.y, end.x, end.y,
m_ZoneMinThickness, color );
else
GRFillCSegm( panel->GetClipBox(), DC, start.x, start.y, end.x, end.y,
m_ZoneMinThickness, color );
}
}
}
void EDGE_MODULE::Draw( EDA_DRAW_PANEL* panel, wxDC* DC, GR_DRAWMODE draw_mode,
const wxPoint& offset )
{
int ux0, uy0, dx, dy, radius, StAngle, EndAngle;
int typeaff;
LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
MODULE* module = (MODULE*) m_Parent;
if( !module )
return;
BOARD* brd = GetBoard( );
if( brd->IsLayerVisible( m_Layer ) == false )
return;
EDA_COLOR_T color = brd->GetLayerColor( m_Layer );
if(( draw_mode & GR_ALLOW_HIGHCONTRAST ) && DisplayOpt.ContrastModeDisplay )
{
if( !IsOnLayer( curr_layer ) )
ColorTurnToDarkDarkGray( &color );
}
PCB_BASE_FRAME* frame = (PCB_BASE_FRAME*) panel->GetParent();
ux0 = m_Start.x - offset.x;
uy0 = m_Start.y - offset.y;
dx = m_End.x - offset.x;
dy = m_End.y - offset.y;
GRSetDrawMode( DC, draw_mode );
typeaff = frame->m_DisplayModEdge;
if( IsCopperLayer( m_Layer ) )
{
typeaff = frame->m_DisplayPcbTrackFill;
if( !typeaff )
typeaff = SKETCH;
}
if( DC->LogicalToDeviceXRel( m_Width ) <= MIN_DRAW_WIDTH )
typeaff = LINE;
switch( m_Shape )
{
case S_SEGMENT:
if( typeaff == LINE )
GRLine( panel->GetClipBox(), DC, ux0, uy0, dx, dy, 0, color );
else if( typeaff == FILLED )
GRLine( panel->GetClipBox(), DC, ux0, uy0, dx, dy, m_Width, color );
else
// SKETCH Mode
GRCSegm( panel->GetClipBox(), DC, ux0, uy0, dx, dy, m_Width, color );
break;
case S_CIRCLE:
radius = KiROUND( Distance( ux0, uy0, dx, dy ) );
if( typeaff == LINE )
{
GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius, color );
}
else
{
if( typeaff == FILLED )
{
GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius, m_Width, color );
}
else // SKETCH Mode
{
GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius + (m_Width / 2), color );
GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius - (m_Width / 2), color );
}
}
break;
case S_ARC:
radius = KiROUND( Distance( ux0, uy0, dx, dy ) );
StAngle = ArcTangente( dy - uy0, dx - ux0 );
EndAngle = StAngle + m_Angle;
if( !panel->GetPrintMirrored() )
{
if( StAngle > EndAngle )
EXCHG( StAngle, EndAngle );
}
else // Mirrored mode: arc orientation is reversed
{
if( StAngle < EndAngle )
EXCHG( StAngle, EndAngle );
}
if( typeaff == LINE )
{
GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle, radius, color );
}
else if( typeaff == FILLED )
{
GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle, radius, m_Width, color );
}
else // SKETCH Mode
{
GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle,
radius + (m_Width / 2), color );
GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle,
radius - (m_Width / 2), color );
}
break;
case S_POLYGON:
{
// We must compute true coordinates from m_PolyPoints
// which are relative to module position, orientation 0
std::vector<wxPoint> points = m_PolyPoints;
for( unsigned ii = 0; ii < points.size(); ii++ )
{
wxPoint& pt = points[ii];
RotatePoint( &pt.x, &pt.y, module->GetOrientation() );
pt += module->GetPosition() - offset;
}
GRPoly( panel->GetClipBox(), DC, points.size(), &points[0], true, m_Width, color, color );
}
break;
default:
break;
}
}
void DrawGraphicText(WinEDA_DrawPanel * panel, wxDC * DC,
const wxPoint & Pos, int gcolor, const wxString & Text,
int orient, const wxSize & Size, int h_justify, int v_justify, int width)
/*****************************************************************************/
/* Draw a graphic text (like module texts)
Text = text to draw
Pos = text position (according to h_justify, v_justify)
Size = text size (size.x or size.y can be < 0 for mirrored texts)
orient = angle in 0.1 degree
mode_color = GR_OR, GR_XOR..
h_justify = horizontal justification (Left, center, right)
v_justify = vertical justification (bottom, center, top)
width = line width (pen width) (default = 0)
if width < 0 : draw segments in sketch mode, width = abs(width)
*/
{
int ii, kk,nbchar, AsciiCode, endcar;
int k1 , k2, x0, y0;
int zoom;
int size_h , size_v , espacement ;
char f_cod , plume = 'U';
const SH_CODE * ptcar;
int ptr;
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[100]; // liste des coord des segments a tracer
bool sketch_mode = FALSE;
zoom = panel->GetZoom();
size_h = Size.x;
size_v = Size.y;
if ( width < 0 )
{
width = - width;
sketch_mode = TRUE;
}
kk = 0 ; ptr = 0; /* ptr = text index */
/* calcul de la position du debut des textes: ox et oy */
nbchar = Text.Len();
if ( nbchar == 0 ) return;
espacement = (10 * size_h ) / 9;
ox = cX = Pos.x; oy = cY = Pos.y;
/* Si le texte est totalement hors fenetre d'affichage, terminé! */
if ( panel )
{
int xm, ym, ll, xc, yc;
int textsize = ABS(espacement);
ll = (textsize * nbchar) / zoom;
xc = GRMapX(cX);
yc = GRMapY(cY);
x0 = panel->m_ClipBox.GetX() - ll;
y0 = panel->m_ClipBox.GetY() -ll ;
xm = panel->m_ClipBox.GetRight() + ll;
ym = panel->m_ClipBox.GetBottom() + ll;
if ( xc < x0 ) return;
if ( yc < y0 ) return;
if ( xc > xm ) return;
if ( yc > ym ) return;
}
/* 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 / coord de ref */
if( (orient == 0) || (orient == 1800) ) /* Texte Horizontal */
{
switch(h_justify)
{
case GR_TEXT_HJUSTIFY_CENTER:
break;
case GR_TEXT_HJUSTIFY_RIGHT:
ux0 = - dx;
break;
case GR_TEXT_HJUSTIFY_LEFT:
ux0 = dx;
break;
}
switch(v_justify)
{
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(h_justify)
{
case GR_TEXT_HJUSTIFY_CENTER:
break;
case GR_TEXT_HJUSTIFY_RIGHT:
ux0 = - dy;
break;
case GR_TEXT_HJUSTIFY_LEFT:
ux0 = dy;
break;
}
switch(v_justify)
{
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;
if( (Size.x/zoom) == 0 ) return;
if( ABS((Size.x/zoom)) < 3) /* chars trop petits pour etre dessines */
{ /* le texte est symbolise par une barre */
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, orient);
RotatePoint(&dx, &dy, cX, cY, orient);
GRLine(&panel->m_ClipBox, DC, ux0, uy0, dx, dy, gcolor);
return;
}
#if 0
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, orient);
RotatePoint(&dx, &dy, cX, cY, orient);
DC->SetTextForeground( wxColour(
ColorRefs[gcolor].r,
ColorRefs[gcolor].g,
ColorRefs[gcolor].b) );
DC->DrawRotatedText(Text, GRMapX(ux0), GRMapY(uy0), (double) orient / 10.0);
return;
#endif
while(kk++ < nbchar)
{
x0 = 0 ; y0 = 0 ;
AsciiCode = Text.GetChar(ptr) & 255;
ptcar = graphic_fonte_shape[AsciiCode] ; /* ptcar pointe la description
du caractere a dessiner */
for(ii = 0, 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(ii && (plume == 'D' ) )
{
if ( width <= 1 )
GRPoly(&panel->m_ClipBox, DC, ii /2, coord, 0,
gcolor, gcolor);
else if ( sketch_mode )
{
int ik, * coordptr;
coordptr = coord;
for ( ik = 0; ik < (ii-2); ik += 2, coordptr+= 2)
GRCSegm(&panel->m_ClipBox, DC, *coordptr, *(coordptr+1),
*(coordptr+2), *(coordptr+3), width, gcolor) ;
}
else
GRPolyLines(&panel->m_ClipBox, DC, ii /2, coord,
gcolor, gcolor, width);
}
plume = f_cod; ii = 0;
break;
case 'D' : plume = f_cod ; 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, orient);
coord[ii] = dx; ii++; coord[ii] = dy; ii++;
break ;
}
} /* end switch */
} /* end boucle for = end trace de 1 caractere */
ptr++; ox += espacement;
} /* end trace du texte */
}
void ZONE_CONTAINER::DrawFilledArea( EDA_DRAW_PANEL* panel,
wxDC* DC, GR_DRAWMODE aDrawMode, const wxPoint& offset )
{
static std::vector <wxPoint> CornersBuffer;
DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)panel->GetDisplayOptions();
// outline_mode is false to show filled polys,
// and true to show polygons outlines only (test and debug purposes)
bool outline_mode = displ_opts->m_DisplayZonesMode == 2 ? true : false;
if( DC == NULL )
return;
if( displ_opts->m_DisplayZonesMode == 1 ) // Do not show filled areas
return;
if( m_FilledPolysList.IsEmpty() ) // Nothing to draw
return;
BOARD* brd = GetBoard();
LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
COLOR4D color = brd->GetLayerColor( m_Layer );
if( brd->IsLayerVisible( m_Layer ) == false && !( aDrawMode & GR_HIGHLIGHT ) )
return;
GRSetDrawMode( DC, aDrawMode );
if( displ_opts->m_ContrastModeDisplay )
{
if( !IsOnLayer( curr_layer ) )
color = COLOR4D( DARKDARKGRAY );
}
if( ( aDrawMode & GR_HIGHLIGHT ) && !( aDrawMode & GR_AND ) )
color.SetToLegacyHighlightColor();
color.a = 0.588;
for ( int ic = 0; ic < m_FilledPolysList.OutlineCount(); ic++ )
{
const SHAPE_LINE_CHAIN& path = m_FilledPolysList.COutline( ic );
CornersBuffer.clear();
wxPoint p0;
for( int j = 0; j < path.PointCount(); j++ )
{
const VECTOR2I& corner = path.CPoint( j );
wxPoint coord( corner.x + offset.x, corner.y + offset.y );
if( j == 0 )
p0 = coord;
CornersBuffer.push_back( coord );
}
CornersBuffer.push_back( p0 );
// Draw outlines:
if( ( m_ZoneMinThickness > 1 ) || outline_mode )
{
int ilim = CornersBuffer.size() - 1;
for( int is = 0, ie = ilim; is <= ilim; ie = is, is++ )
{
int x0 = CornersBuffer[is].x;
int y0 = CornersBuffer[is].y;
int x1 = CornersBuffer[ie].x;
int y1 = CornersBuffer[ie].y;
// Draw only basic outlines, not extra segments.
if( !displ_opts->m_DisplayPcbTrackFill || GetState( FORCE_SKETCH ) )
GRCSegm( panel->GetClipBox(), DC,
x0, y0, x1, y1,
m_ZoneMinThickness, color );
else
GRFillCSegm( panel->GetClipBox(), DC,
x0, y0, x1, y1, m_ZoneMinThickness, color );
}
}
// Draw areas:
if( m_FillMode == 0 && !outline_mode )
GRPoly( panel->GetClipBox(), DC, CornersBuffer.size(), &CornersBuffer[0],
true, 0, color, color );
}
if( m_FillMode == 1 && !outline_mode ) // filled with segments
{
for( unsigned ic = 0; ic < m_FillSegmList.size(); ic++ )
{
wxPoint start = m_FillSegmList[ic].m_Start + offset;
wxPoint end = m_FillSegmList[ic].m_End + offset;
if( !displ_opts->m_DisplayPcbTrackFill || GetState( FORCE_SKETCH ) )
GRCSegm( panel->GetClipBox(), DC, start.x, start.y, end.x, end.y,
m_ZoneMinThickness, color );
else
GRFillCSegm( panel->GetClipBox(), DC, start.x, start.y, end.x, end.y,
m_ZoneMinThickness, color );
}
}
}
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 ).
*/
{
int zoom;
int coord[100];
int ii, jj, kk, ll, nbpoints;
int width;
if( m_TextDrawings == NULL) /* pointeur sur la liste des segments de dessin */
CreateDrawData();
if( m_TextDrawings == NULL) return;
zoom = panel->GetZoom();
width = m_Width / zoom;
if ( display_mode == FILAIRE ) width = 0;
/* choix de la couleur du texte : */
if ( draw_mode != -1 ) GRSetDrawMode(DC, draw_mode);
/* trace du texte */
if ( zoom > m_ZoomLevelDrawable)
{
GRLine(&panel->m_ClipBox, DC,
m_TextDrawings[1] + offset.x + m_Pos.x,
m_TextDrawings[2] + offset.y + m_Pos.y,
m_TextDrawings[3] + offset.x + m_Pos.x,
m_TextDrawings[4] + offset.y + m_Pos.y,
color);
}
else
{
/* trace ancre du texte ? */
if( anchor_color != -1)
{
int anchor_size = 2 * zoom;
anchor_color &= MASKCOLOR;
/* calcul de la position du texte */
int cX = m_Pos.x - offset.x;
int cY = m_Pos.y - offset.y;
/* trace ancre du texte */
GRLine(&panel->m_ClipBox, DC, cX - anchor_size, cY,
cX + anchor_size, cY, anchor_color);
GRLine(&panel->m_ClipBox, DC, cX, cY - anchor_size ,
cX, cY + anchor_size , 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;
ll++; ii++;
coord[ll] = m_TextDrawings[ii] + offset.y + m_Pos.y;
ll++; ii++;
}
jj = ii; 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, color, color);
}
}
}
void EDGE_MODULE::Draw( EDA_DRAW_PANEL* panel, wxDC* DC, GR_DRAWMODE draw_mode,
const wxPoint& offset )
{
int ux0, uy0, dx, dy, radius, StAngle, EndAngle;
PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
MODULE* module = (MODULE*) m_Parent;
if( !module )
return;
BOARD* brd = GetBoard( );
if( brd->IsLayerVisible( m_Layer ) == false )
return;
auto frame = static_cast<PCB_BASE_FRAME*> ( panel->GetParent() );
auto color = frame->Settings().Colors().GetLayerColor( m_Layer );
auto displ_opts = (PCB_DISPLAY_OPTIONS*)( panel->GetDisplayOptions() );
if(( draw_mode & GR_ALLOW_HIGHCONTRAST ) && displ_opts && displ_opts->m_ContrastModeDisplay )
{
if( !IsOnLayer( curr_layer ) )
color = COLOR4D( DARKDARKGRAY );
}
ux0 = m_Start.x - offset.x;
uy0 = m_Start.y - offset.y;
dx = m_End.x - offset.x;
dy = m_End.y - offset.y;
GRSetDrawMode( DC, draw_mode );
bool filled = displ_opts ? displ_opts->m_DisplayModEdgeFill : FILLED;
if( IsCopperLayer( m_Layer ) )
filled = displ_opts ? displ_opts->m_DisplayPcbTrackFill : FILLED;
switch( m_Shape )
{
case S_SEGMENT:
if( filled )
GRLine( panel->GetClipBox(), DC, ux0, uy0, dx, dy, m_Width, color );
else
// SKETCH Mode
GRCSegm( panel->GetClipBox(), DC, ux0, uy0, dx, dy, m_Width, color );
break;
case S_CIRCLE:
radius = KiROUND( Distance( ux0, uy0, dx, dy ) );
if( filled )
{
GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius, m_Width, color );
}
else // SKETCH Mode
{
GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius + (m_Width / 2), color );
GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius - (m_Width / 2), color );
}
break;
case S_ARC:
radius = KiROUND( Distance( ux0, uy0, dx, dy ) );
StAngle = ArcTangente( dy - uy0, dx - ux0 );
EndAngle = StAngle + m_Angle;
if( !panel->GetPrintMirrored() )
{
if( StAngle > EndAngle )
std::swap( StAngle, EndAngle );
}
else // Mirrored mode: arc orientation is reversed
{
if( StAngle < EndAngle )
std::swap( StAngle, EndAngle );
}
if( filled )
{
GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle, radius, m_Width, color );
}
else // SKETCH Mode
{
GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle,
radius + (m_Width / 2), color );
GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle,
radius - (m_Width / 2), color );
}
break;
case S_POLYGON:
if( m_Poly.IsEmpty() )
break;
{
// We must compute absolute coordinates from m_PolyPoints
// which are relative to module position, orientation 0
std::vector<wxPoint> points;
for( auto iter = m_Poly.CIterate(); iter; iter++ )
{
points.push_back( wxPoint( iter->x,iter->y ) );
}
for( unsigned ii = 0; ii < points.size(); ii++ )
{
wxPoint& pt = points[ii];
RotatePoint( &pt.x, &pt.y, module->GetOrientation() );
pt += module->GetPosition() - offset;
}
GRPoly( panel->GetClipBox(), DC, points.size(), &points[0], true, m_Width, color, color );
}
break;
default:
break;
}
}
