void DrawGraphicHaloText( EDA_RECT* aClipBox, wxDC * aDC,
const wxPoint &aPos,
enum EDA_COLOR_T aBgColor,
enum EDA_COLOR_T aColor1,
enum EDA_COLOR_T aColor2,
const wxString &aText,
double aOrient,
const wxSize &aSize,
enum EDA_TEXT_HJUSTIFY_T aH_justify,
enum EDA_TEXT_VJUSTIFY_T aV_justify,
int aWidth, bool aItalic, bool aBold,
void (*aCallback)( int x0, int y0, int xf, int yf ),
PLOTTER * aPlotter )
{
// Swap color if contrast would be better
if( ColorIsLight( aBgColor ) )
{
EDA_COLOR_T c = aColor1;
aColor1 = aColor2;
aColor2 = c;
}
DrawGraphicText( aClipBox, aDC, aPos, aColor1, aText, aOrient, aSize,
aH_justify, aV_justify, aWidth, aItalic, aBold,
aCallback, aPlotter );
DrawGraphicText( aClipBox, aDC, aPos, aColor2, aText, aOrient, aSize,
aH_justify, aV_justify, aWidth / 4, aItalic, aBold,
aCallback, aPlotter );
}
void WinEDA_LibeditFrame::EditField(wxDC * DC, LibDrawField *Field)
/******************************************************************/
{
wxString Text;
int color;
wxString title = wxT("Text:");
if( Field == NULL) return;
switch (Field->m_FieldId)
{
case REFERENCE:
title = wxT("Reference:");
color = ReturnLayerColor(LAYER_REFERENCEPART);
break;
case VALUE:
title = wxT("Value:");
color = ReturnLayerColor(LAYER_VALUEPART);
break;
default:
color = ReturnLayerColor(LAYER_FIELDS);
break;
}
if( Field->m_Attributs & TEXT_NO_VISIBLE ) color = DARKGRAY;
Text = Field->m_Text;
Get_Message(title,Text, this);
Text.Replace( wxT(" ") , wxT("_") );
GRSetDrawMode(DC, g_XorMode);
DrawGraphicText(DrawPanel, DC, wxPoint(Field->m_Pos.x, - Field->m_Pos.y),
color, Field->m_Text,
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify);
if( ! Text.IsEmpty() )
{
SaveCopyInUndoList();
Field->m_Text = Text;
}
else DisplayError(this, _("No new text: no change") );
if( Field->m_Flags == 0 ) GRSetDrawMode(DC, GR_DEFAULT_DRAWMODE);
DrawGraphicText(DrawPanel, DC, wxPoint(Field->m_Pos.x, - Field->m_Pos.y),
color, Field->m_Text,
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify);
m_CurrentScreen->SetModify();
if ( Field->m_FieldId == VALUE ) ReCreateHToolbar();
}
/**
* Function PLOTTER::Text
* same as DrawGraphicText, but plot graphic text insteed of draw it
* @param aPos = text position (according to aH_justify, aV_justify)
* @param aColor (COLOR4D) = text color
* @param aText = text to draw
* @param aOrient = angle in 0.1 degree
* @param aSize = text size (size.x or size.y can be < 0 for mirrored texts)
* @param aH_justify = horizontal justification (Left, center, right)
* @param aV_justify = vertical justification (bottom, center, top)
* @param aWidth = line width (pen width) (default = 0)
* if width < 0 : draw segments in sketch mode, width = abs(width)
* Use a value min(aSize.x, aSize.y) / 5 for a bold text
* @param aItalic = true to simulate an italic font
* @param aBold = true to use a bold font Useful only with default width value (aWidth = 0)
* @param aMultilineAllowed = true to plot text as multiline, otherwise single line
*/
void PLOTTER::Text( const wxPoint& aPos,
const COLOR4D aColor,
const wxString& aText,
double aOrient,
const wxSize& aSize,
enum EDA_TEXT_HJUSTIFY_T aH_justify,
enum EDA_TEXT_VJUSTIFY_T aV_justify,
int aWidth,
bool aItalic,
bool aBold,
bool aMultilineAllowed,
void* aData )
{
int textPensize = aWidth;
if( textPensize == 0 && aBold ) // Use default values if aWidth == 0
textPensize = GetPenSizeForBold( std::min( aSize.x, aSize.y ) );
if( textPensize >= 0 )
textPensize = Clamp_Text_PenSize( aWidth, aSize, aBold );
else
textPensize = -Clamp_Text_PenSize( -aWidth, aSize, aBold );
SetCurrentLineWidth( textPensize, aData );
SetColor( aColor );
DrawGraphicText( NULL, NULL, aPos, aColor, aText,
aOrient, aSize,
aH_justify, aV_justify,
textPensize, aItalic, aBold, NULL, this );
if( aWidth != textPensize )
SetCurrentLineWidth( aWidth, aData );
}
void WinEDA_LibeditFrame::RotateField(wxDC * DC, LibDrawField *Field)
/********************************************************************/
/* Routine de modification de l'orientation ( Horiz ou Vert. ) du champ.
si un champ est en cours d'edition, modif de celui ci.
sinon Modif du champ pointe par la souris
*/
{
int color;
if( Field == NULL) return;
m_CurrentScreen->SetModify();
switch (Field->m_FieldId)
{
case REFERENCE:
color = ReturnLayerColor(LAYER_REFERENCEPART);
break;
case VALUE:
color = ReturnLayerColor(LAYER_VALUEPART);
break;
default:
color = ReturnLayerColor(LAYER_FIELDS);
break;
}
if( Field->m_Attributs & TEXT_NO_VISIBLE ) color = DARKGRAY;
GRSetDrawMode(DC, g_XorMode);
DrawGraphicText(DrawPanel, DC, wxPoint(Field->m_Pos.x, - Field->m_Pos.y),
color, Field->m_Text,
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify);
if( Field->m_Orient) Field->m_Orient = 0;
else Field->m_Orient = 1;
if( Field->m_Flags == 0 ) GRSetDrawMode(DC, GR_DEFAULT_DRAWMODE);
DrawGraphicText(DrawPanel, DC, wxPoint(Field->m_Pos.x, - Field->m_Pos.y),
color, Field->m_Text,
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify);
}
static void ShowMoveField(WinEDA_DrawPanel * panel, wxDC *DC, bool erase)
{
int color;
LibDrawField *Field = (LibDrawField *)CurrentDrawItem;
if( (CurrentLibEntry == NULL) || (Field == NULL) ) return;
GRSetDrawMode(DC, g_XorMode);
switch (Field->m_FieldId)
{
case VALUE:
color = ReturnLayerColor(LAYER_VALUEPART);
break;
case REFERENCE:
color = ReturnLayerColor(LAYER_REFERENCEPART);
break;
default:
color = ReturnLayerColor(LAYER_FIELDS);
break;
}
if( Field->m_Attributs & TEXT_NO_VISIBLE ) color = DARKGRAY;
if( erase )
DrawGraphicText(panel, DC,
wxPoint(LastTextPosition.x, - LastTextPosition.y),
color, Field->m_Text,
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify);
LastTextPosition.x = panel->GetScreen()->m_Curseur.x;
LastTextPosition.y = - panel->GetScreen()->m_Curseur.y;
Field->m_Pos = LastTextPosition;
DrawGraphicText(panel, DC,
wxPoint(LastTextPosition.x, - LastTextPosition.y),
color, Field->m_Text,
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify);
}
static void export_vrml_pcbtext( TEXTE_PCB* text )
{
// Coupling by globals! Ewwww...
s_text_layer = text->GetLayer();
s_text_width = text->m_Thickness;
wxSize size = text->m_Size;
if( text->m_Mirror )
NEGATE( size.x );
if( text->m_MultilineAllowed )
{
wxPoint pos = text->m_Pos;
wxArrayString* list = wxStringSplit( text->m_Text, '\n' );
wxPoint offset;
offset.y = text->GetInterline();
RotatePoint( &offset, text->GetOrientation() );
for( unsigned i = 0; i<list->Count(); i++ )
{
wxString txt = list->Item( i );
DrawGraphicText( NULL, NULL, pos, BLACK,
txt, text->GetOrientation(), size,
text->m_HJustify, text->m_VJustify,
text->m_Thickness, text->m_Italic,
true,
vrml_text_callback );
pos += offset;
}
delete (list);
}
else
{
DrawGraphicText( NULL, NULL, text->m_Pos, BLACK,
text->m_Text, text->GetOrientation(), size,
text->m_HJustify, text->m_VJustify,
text->m_Thickness, text->m_Italic,
true,
vrml_text_callback );
}
}
void TEXTE_PCB::TransformShapeWithClearanceToPolygonSet(
SHAPE_POLY_SET& aCornerBuffer,
int aClearanceValue,
int aCircleToSegmentsCount,
double aCorrectionFactor ) const
{
wxSize size = GetSize();
if( IsMirrored() )
size.x = -size.x;
s_cornerBuffer = &aCornerBuffer;
s_textWidth = GetThickness() + ( 2 * aClearanceValue );
s_textCircle2SegmentCount = aCircleToSegmentsCount;
EDA_COLOR_T color = BLACK; // not actually used, but needed by DrawGraphicText
if( IsMultilineAllowed() )
{
wxArrayString strings_list;
wxStringSplit( GetShownText(), strings_list, '\n' );
std::vector<wxPoint> positions;
positions.reserve( strings_list.Count() );
GetPositionsOfLinesOfMultilineText( positions, strings_list.Count() );
for( unsigned ii = 0; ii < strings_list.Count(); ii++ )
{
wxString txt = strings_list.Item( ii );
DrawGraphicText( NULL, NULL, positions[ii], color,
txt, GetOrientation(), size,
GetHorizJustify(), GetVertJustify(),
GetThickness(), IsItalic(),
true, addTextSegmToPoly );
}
}
else
{
DrawGraphicText( NULL, NULL, GetTextPosition(), color,
GetShownText(), GetOrientation(), size,
GetHorizJustify(), GetVertJustify(),
GetThickness(), IsItalic(),
true, addTextSegmToPoly );
}
}
// Same as function TransformGraphicShapesWithClearanceToPolygonSet but
// this only render text
void MODULE::TransformGraphicTextWithClearanceToPolygonSet(
PCB_LAYER_ID aLayer, SHAPE_POLY_SET& aCornerBuffer, int aInflateValue, int aError ) const
{
std::vector<TEXTE_MODULE *> texts; // List of TEXTE_MODULE to convert
for( EDA_ITEM* item = GraphicalItemsList(); item != NULL; item = item->Next() )
{
switch( item->Type() )
{
case PCB_MODULE_TEXT_T:
{
TEXTE_MODULE* text = static_cast<TEXTE_MODULE*>( item );
if( text->GetLayer() == aLayer && text->IsVisible() )
texts.push_back( text );
break;
}
case PCB_MODULE_EDGE_T:
// This function does not render this
break;
default:
break;
}
}
// Convert texts sur modules
if( Reference().GetLayer() == aLayer && Reference().IsVisible() )
texts.push_back( &Reference() );
if( Value().GetLayer() == aLayer && Value().IsVisible() )
texts.push_back( &Value() );
prms.m_cornerBuffer = &aCornerBuffer;
for( unsigned ii = 0; ii < texts.size(); ii++ )
{
TEXTE_MODULE *textmod = texts[ii];
prms.m_textWidth = textmod->GetThickness() + ( 2 * aInflateValue );
prms.m_error = aError;
wxSize size = textmod->GetTextSize();
if( textmod->IsMirrored() )
size.x = -size.x;
DrawGraphicText( NULL, NULL, textmod->GetTextPos(), BLACK,
textmod->GetShownText(), textmod->GetDrawRotation(), size,
textmod->GetHorizJustify(), textmod->GetVertJustify(),
textmod->GetThickness(), textmod->IsItalic(),
true, addTextSegmToPoly, &prms );
}
}
static void export_vrml_pcbtext( MODEL_VRML& aModel, TEXTE_PCB* text )
{
model_vrml->s_text_layer = text->GetLayer();
model_vrml->s_text_width = text->GetThickness();
wxSize size = text->GetSize();
if( text->IsMirrored() )
NEGATE( size.x );
EDA_COLOR_T color = BLACK; // not actually used, but needed by DrawGraphicText
if( text->IsMultilineAllowed() )
{
wxArrayString* list = wxStringSplit( text->GetShownText(), '\n' );
std::vector<wxPoint> positions;
positions.reserve( list->Count() );
text->GetPositionsOfLinesOfMultilineText( positions, list->Count() );
for( unsigned ii = 0; ii < list->Count(); ii++ )
{
wxString txt = list->Item( ii );
DrawGraphicText( NULL, NULL, positions[ii], color,
txt, text->GetOrientation(), size,
text->GetHorizJustify(), text->GetVertJustify(),
text->GetThickness(), text->IsItalic(),
true,
vrml_text_callback );
}
delete (list);
}
else
{
DrawGraphicText( NULL, NULL, text->GetTextPosition(), color,
text->GetShownText(), text->GetOrientation(), size,
text->GetHorizJustify(), text->GetVertJustify(),
text->GetThickness(), text->IsItalic(),
true,
vrml_text_callback );
}
}
void LIB_FIELD::drawGraphic( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aOffset,
EDA_COLOR_T aColor, GR_DRAWMODE aDrawMode, void* aData,
const TRANSFORM& aTransform )
{
wxPoint text_pos;
int color;
int linewidth = GetPenSize();
if( m_Bold )
linewidth = GetPenSizeForBold( m_Size.x );
else
linewidth = Clamp_Text_PenSize( linewidth, m_Size, m_Bold );
if( ( m_Attributs & TEXT_NO_VISIBLE ) && ( aColor < 0 ) )
{
color = GetInvisibleItemColor();
}
else if( IsSelected() && ( aColor < 0 ) )
{
color = GetItemSelectedColor();
}
else
{
color = aColor;
}
if( color < 0 )
color = GetDefaultColor();
text_pos = aTransform.TransformCoordinate( m_Pos ) + aOffset;
wxString text;
if( aData )
text = *(wxString*)aData;
else
text = m_Text;
GRSetDrawMode( aDC, aDrawMode );
EDA_RECT* clipbox = aPanel? aPanel->GetClipBox() : NULL;
DrawGraphicText( clipbox, aDC, text_pos, (EDA_COLOR_T) color, text, m_Orient, m_Size,
m_HJustify, m_VJustify, linewidth, m_Italic, m_Bold );
/* Set to one (1) to draw bounding box around field text to validate
* bounding box calculation. */
#if 0
EDA_RECT bBox = GetBoundingBox();
EDA_RECT grBox;
grBox.SetOrigin( aTransform.TransformCoordinate( bBox.GetOrigin() ) );
grBox.SetEnd( aTransform.TransformCoordinate( bBox.GetEnd() ) );
grBox.Move( aOffset );
GRRect( clipbox, aDC, grBox, 0, LIGHTMAGENTA );
#endif
}
void EDA_TEXT::TransformTextShapeToSegmentList( std::vector<wxPoint>& aCornerBuffer ) const
{
wxSize size = GetSize();
if( IsMirrored() )
NEGATE( size.x );
s_cornerBuffer = &aCornerBuffer;
EDA_COLOR_T color = BLACK; // not actually used, but needed by DrawGraphicText
if( IsMultilineAllowed() )
{
wxArrayString* list = wxStringSplit( GetText(), '\n' );
std::vector<wxPoint> positions;
positions.reserve( list->Count() );
GetPositionsOfLinesOfMultilineText( positions, list->Count() );
for( unsigned ii = 0; ii < list->Count(); ii++ )
{
wxString txt = list->Item( ii );
DrawGraphicText( NULL, NULL, positions[ii], color,
txt, GetOrientation(), size,
GetHorizJustify(), GetVertJustify(),
GetThickness(), IsItalic(),
true, addTextSegmToBuffer );
}
delete list;
}
else
{
DrawGraphicText( NULL, NULL, GetTextPosition(), color,
GetText(), GetOrientation(), size,
GetHorizJustify(), GetVertJustify(),
GetThickness(), IsItalic(),
true, addTextSegmToBuffer );
}
}
void Affiche_DCodes_Pistes(WinEDA_DrawPanel * panel, wxDC * DC, BOARD * Pcb, int drawmode)
/*****************************************************************************************/
{
TRACK * track;
wxPoint pos;
int width, orient;
wxString Line;
GRSetDrawMode(DC, drawmode);
track = Pcb->m_Track;
for ( ; track != NULL ; track = (TRACK*) track->Pnext )
{
if ( (track->m_Shape == S_ARC) ||
(track->m_Shape == S_CIRCLE) ||
(track->m_Shape == S_ARC_RECT) )
{
pos.x = track->m_Start.x;
pos.y = track->m_Start.y;
}
else
{
pos.x = (track->m_Start.x + track->m_End.x) / 2;
pos.y = (track->m_Start.y + track->m_End.y) / 2;
}
Line.Printf( wxT("D%d"), track->m_NetCode);
width = track->m_Width;
orient = TEXT_ORIENT_HORIZ;
if ( track->m_Shape >= S_SPOT_CIRCLE) // forme flash
{
width /= 3;
}
else // lines
{
int dx, dy;
dx = track->m_Start.x - track->m_End.x;
dy = track->m_Start.y - track->m_End.y;
if ( abs(dx) < abs(dy) ) orient = TEXT_ORIENT_VERT;
width /= 2;
}
DrawGraphicText(panel, DC,
pos, g_DCodesColor, Line,
orient, wxSize(width, width),
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER);
}
}
static void export_vrml_text_module( TEXTE_MODULE* module ) //{{{
{
if( module->IsVisible() )
{
wxSize size = module->m_Size;
if( module->m_Mirror )
NEGATE( size.x ); // Text is mirrored
s_text_layer = module->GetLayer();
s_text_width = module->m_Thickness;
DrawGraphicText( NULL, NULL, module->m_Pos, BLACK,
module->m_Text, module->GetDrawRotation(), size,
module->m_HJustify, module->m_VJustify,
module->m_Thickness, module->m_Italic,
true,
vrml_text_callback );
}
}
static void export_vrml_text_module( TEXTE_MODULE* module )
{
if( module->IsVisible() )
{
wxSize size = module->GetSize();
if( module->IsMirrored() )
NEGATE( size.x ); // Text is mirrored
model_vrml->s_text_layer = module->GetLayer();
model_vrml->s_text_width = module->GetThickness();
DrawGraphicText( NULL, NULL, module->GetTextPosition(), BLACK,
module->GetShownText(), module->GetDrawRotation(), size,
module->GetHorizJustify(), module->GetVertJustify(),
module->GetThickness(), module->IsItalic(),
true,
vrml_text_callback );
}
}
void EDA_TEXT::drawOneLineOfText( EDA_RECT* aClipBox, wxDC* aDC,
const wxPoint& aOffset, EDA_COLOR_T aColor,
GR_DRAWMODE aDrawMode, EDA_DRAW_MODE_T aFillMode,
const wxString& aText, const wxPoint &aPos )
{
int width = m_Thickness;
if( aDrawMode != UNSPECIFIED_DRAWMODE )
GRSetDrawMode( aDC, aDrawMode );
if( aFillMode == SKETCH )
width = -width;
wxSize size = m_Size;
if( m_Mirror )
size.x = -size.x;
DrawGraphicText( aClipBox, aDC, aOffset + aPos, aColor, aText, m_Orient, size,
m_HJustify, m_VJustify, width, m_Italic, m_Bold );
}
void LIB_FIELD::drawGraphic( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aOffset,
void* aData, const TRANSFORM& aTransform )
{
wxPoint text_pos;
COLOR4D color = IsVisible() ? GetDefaultColor() : GetInvisibleItemColor();
int linewidth = GetPenSize();
text_pos = aTransform.TransformCoordinate( GetTextPos() ) + aOffset;
wxString text;
if( aData )
text = *(wxString*)aData;
else
text = m_Text;
EDA_RECT* clipbox = aPanel? aPanel->GetClipBox() : NULL;
DrawGraphicText( clipbox, aDC, text_pos, color, text, GetTextAngle(), GetTextSize(),
GetHorizJustify(), GetVertJustify(), linewidth, IsItalic(), IsBold() );
}
void WinEDA_LibeditFrame::PlaceField(wxDC * DC, LibDrawField *Field)
/*******************************************************************/
{
int color;
if(Field == NULL ) return;
GRSetDrawMode(DC, GR_DEFAULT_DRAWMODE);
switch (Field->m_FieldId)
{
case REFERENCE:
color = ReturnLayerColor(LAYER_REFERENCEPART);
break;
case VALUE:
color = ReturnLayerColor(LAYER_VALUEPART);
break;
default:
color = ReturnLayerColor(LAYER_FIELDS);
break;
}
if( Field->m_Attributs & TEXT_NO_VISIBLE ) color = DARKGRAY;
Field->m_Pos.x = GetScreen()->m_Curseur.x;
Field->m_Pos.y = - GetScreen()->m_Curseur.y;
DrawGraphicText(DrawPanel, DC, wxPoint(Field->m_Pos.x, - Field->m_Pos.y),
color, Field->m_Text,
Field->m_Orient ? TEXT_ORIENT_VERT : TEXT_ORIENT_HORIZ,
Field->m_Size,
Field->m_HJustify, Field->m_VJustify);
Field->m_Flags = 0;
m_CurrentScreen->SetModify();
m_CurrentScreen->ManageCurseur = NULL;
m_CurrentScreen->ForceCloseManageCurseur = NULL;
CurrentDrawItem = NULL;
}
void SCH_FIELD::Draw( EDA_DRAW_PANEL* panel, wxDC* DC,
const wxPoint& offset, GR_DRAWMODE DrawMode, EDA_COLOR_T Color )
{
int orient;
EDA_COLOR_T color;
wxPoint textpos;
SCH_COMPONENT* parentComponent = (SCH_COMPONENT*) m_Parent;
int LineWidth = m_Thickness;
if( LineWidth == 0 ) // Use default values for pen size
{
if( m_Bold )
LineWidth = GetPenSizeForBold( m_Size.x );
else
LineWidth = GetDefaultLineThickness();
}
// Clip pen size for small texts:
LineWidth = Clamp_Text_PenSize( LineWidth, m_Size, m_Bold );
if( ((m_Attributs & TEXT_NO_VISIBLE) && !m_forceVisible) || IsVoid() )
return;
GRSetDrawMode( DC, DrawMode );
// Calculate the text orientation according to the component orientation.
orient = m_Orient;
if( parentComponent->GetTransform().y1 ) // Rotate component 90 degrees.
{
if( orient == TEXT_ORIENT_HORIZ )
orient = TEXT_ORIENT_VERT;
else
orient = TEXT_ORIENT_HORIZ;
}
/* Calculate the text justification, according to the component
* orientation/mirror this is a bit complicated due to cumulative
* calculations:
* - numerous cases (mirrored or not, rotation)
* - the DrawGraphicText function recalculate also H and H justifications
* according to the text orientation.
* - When a component is mirrored, the text is not mirrored and
* justifications are complicated to calculate
* so the more easily way is to use no justifications ( Centered text )
* and use GetBoundaryBox to know the text coordinate considered as centered
*/
EDA_RECT boundaryBox = GetBoundingBox();
textpos = boundaryBox.Centre();
if( m_forceVisible )
{
color = DARKGRAY;
}
else
{
if( m_id == REFERENCE )
color = ReturnLayerColor( LAYER_REFERENCEPART );
else if( m_id == VALUE )
color = ReturnLayerColor( LAYER_VALUEPART );
else
color = ReturnLayerColor( LAYER_FIELDS );
}
DrawGraphicText( panel, DC, textpos, color, GetText(), orient, m_Size,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
LineWidth, m_Italic, m_Bold );
/* Enable this to draw the bounding box around the text field to validate
* the bounding box calculations.
*/
#if 0
// Draw boundary box:
GRRect( panel->GetClipBox(), DC, boundaryBox, 0, BROWN );
// Draw the text anchor point
/* Calculate the text position, according to the component
* orientation/mirror */
textpos = m_Pos - parentComponent->GetPosition();
textpos = parentComponent->GetScreenCoord( textpos );
textpos += parentComponent->GetPosition();
const int len = 10;
GRLine( panel->GetClipBox(), DC,
textpos.x - len, textpos.y, textpos.x + len, textpos.y, 0, BLUE );
GRLine( panel->GetClipBox(), DC,
textpos.x, textpos.y - len, textpos.x, textpos.y + len, 0, BLUE );
#endif
}
/**
* Function Draw
* Draw the text according to the footprint pos and orient
* @param panel = draw panel, Used to know the clip box
* @param DC = Current Device Context
* @param offset = draw offset (usually wxPoint(0,0)
* @param draw_mode = GR_OR, GR_XOR..
*/
void TEXTE_MODULE::Draw( EDA_DRAW_PANEL* panel, wxDC* DC, GR_DRAWMODE draw_mode,
const wxPoint& offset )
{
MODULE* module = (MODULE*) m_Parent;
/* parent must *not* be NULL (a module text without a footprint
parent has no sense) */
wxASSERT( module );
if( panel == NULL )
return;
BOARD* brd = GetBoard( );
EDA_COLOR_T color;
// Determine the element color or suppress it element if hidden
switch( module->GetLayer() )
{
case LAYER_N_BACK:
if( !brd->IsElementVisible( MOD_TEXT_BK_VISIBLE ) )
return;
color = brd->GetVisibleElementColor( MOD_TEXT_BK_VISIBLE );
break;
case LAYER_N_FRONT:
if( !brd->IsElementVisible( MOD_TEXT_FR_VISIBLE ) )
return;
color = brd->GetVisibleElementColor( MOD_TEXT_FR_VISIBLE );
break;
default:
color = brd->GetLayerColor( module->GetLayer() );
}
// 'Ghost' the element if forced show
if( m_NoShow )
{
if( !brd->IsElementVisible( MOD_TEXT_INVISIBLE ) )
return;
color = brd->GetVisibleElementColor( MOD_TEXT_INVISIBLE );
}
// Draw mode compensation for the width
PCB_BASE_FRAME* frame = (PCB_BASE_FRAME*) panel->GetParent();
int width = m_Thickness;
if( ( frame->m_DisplayModText == LINE )
|| ( DC->LogicalToDeviceXRel( width ) <= MIN_DRAW_WIDTH ) )
width = 0;
else if( frame->m_DisplayModText == SKETCH )
width = -width;
GRSetDrawMode( DC, draw_mode );
wxPoint pos( m_Pos.x - offset.x,
m_Pos.y - offset.y);
// Draw the text anchor point
if( brd->IsElementVisible( ANCHOR_VISIBLE ) )
{
EDA_COLOR_T anchor_color = brd->GetVisibleElementColor(ANCHOR_VISIBLE);
GRDrawAnchor( panel->GetClipBox(), DC, pos.x, pos.y,
DIM_ANCRE_TEXTE, anchor_color );
}
// Draw the text proper, with the right attributes
wxSize size = m_Size;
double orient = GetDrawRotation();
// If the text is mirrored : negate size.x (mirror / Y axis)
if( m_Mirror )
size.x = -size.x;
EDA_RECT* clipbox = panel? panel->GetClipBox() : NULL;
DrawGraphicText( clipbox, DC, pos, color, m_Text, orient,
size, m_HJustify, m_VJustify, width, m_Italic, m_Bold );
// 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 LIB_TEXT::drawGraphic( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aOffset,
COLOR4D aColor, GR_DRAWMODE aDrawMode, void* aData,
const TRANSFORM& aTransform )
{
COLOR4D color = GetDefaultColor();
if( aColor == COLOR4D::UNSPECIFIED ) // Used normal color or selected color
{
if( IsSelected() )
color = GetItemSelectedColor();
}
else
{
color = aColor;
}
GRSetDrawMode( aDC, aDrawMode );
/* Calculate the text orientation, according to the component
* orientation/mirror (needed when draw text in schematic)
*/
int orient = GetTextAngle();
if( aTransform.y1 ) // Rotate component 90 degrees.
{
if( orient == TEXT_ANGLE_HORIZ )
orient = TEXT_ANGLE_VERT;
else
orient = TEXT_ANGLE_HORIZ;
}
/* Calculate the text justification, according to the component
* orientation/mirror this is a bit complicated due to cumulative
* calculations:
* - numerous cases (mirrored or not, rotation)
* - the DrawGraphicText function recalculate also H and H justifications
* according to the text orientation.
* - When a component is mirrored, the text is not mirrored and
* justifications are complicated to calculate
* so the more easily way is to use no justifications ( Centered text )
* and use GetBoundaryBox to know the text coordinate considered as centered
*/
EDA_RECT bBox = GetBoundingBox();
// convert coordinates from draw Y axis to libedit Y axis:
bBox.RevertYAxis();
wxPoint txtpos = bBox.Centre();
// Calculate pos according to mirror/rotation.
txtpos = aTransform.TransformCoordinate( txtpos ) + aOffset;
EDA_RECT* clipbox = aPanel? aPanel->GetClipBox() : NULL;
DrawGraphicText( clipbox, aDC, txtpos, color, GetShownText(), orient, GetTextSize(),
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, GetPenSize(),
IsItalic(), IsBold() );
/* Enable this to draw the bounding box around the text field to validate
* the bounding box calculations.
*/
#if 0
// bBox already uses libedit Y axis.
bBox = aTransform.TransformCoordinate( bBox );
bBox.Move( aOffset );
GRRect( clipbox, aDC, bBox, 0, LIGHTMAGENTA );
#endif
}
void WinEDA_DrawFrame::TraceWorkSheet(wxDC * DC, BASE_SCREEN * screen, int marge)
/*********************************************************************************/
/* Trace l'encadrement de la feuille de travail et le cartouche
*/
{
if ( ! m_Draw_Sheet_Ref ) return;
int ii, jj, xg , yg, ipas, gxpas, gypas;
wxPoint pos;
int refx, refy,Color;
char Line[256];
WorkSheet * WsItem;
int scale = m_InternalUnits/1000;
wxSize size(SIZETEXT*scale,SIZETEXT*scale);
wxSize size_ref(SIZETEXT_REF*scale,SIZETEXT_REF*scale);
wxString msg;
Color = RED;
GRSetDrawMode(DC, GR_COPY);
if(screen->m_CurrentSheet == NULL)
{
DisplayError(this,
"WinEDA_DrawFrame::TraceWorkSheet error: m_CurrentSheet NULL");
return;
}
/* trace de la bordure */
refx = refy = marge; /* Start Point */
xg = screen->m_CurrentSheet->m_Size.x - marge;
yg = screen->m_CurrentSheet->m_Size.y - marge;
for ( ii = 0; ii < 2 ; ii++ )
{
GRRect(&DrawPanel->m_ClipBox, DC, refx * scale, refy * scale,
xg * scale, yg * scale, Color);
refx += GRID_REF_W; refy += GRID_REF_W;
xg -= GRID_REF_W; yg -= GRID_REF_W;
}
/* trace des reperes */
refx = refy = marge; /* Start Point */
xg = screen->m_CurrentSheet->m_Size.x - marge;
yg = screen->m_CurrentSheet->m_Size.y - marge;
/* Trace des reperes selon l'axe X */
ipas = (xg - refx) / PAS_REF;
gxpas = ( xg - refx) / ipas;
for ( ii = refx + gxpas, jj = 1; ipas > 0 ; ii += gxpas , jj++, ipas--)
{
sprintf(Line,"%d",jj);
if( ii < xg - PAS_REF/2 )
{
GRLine(&DrawPanel->m_ClipBox, DC, ii * scale, refy * scale,
ii * scale, (refy + GRID_REF_W) * scale, Color);
}
DrawGraphicText(DrawPanel, DC,
wxPoint( (ii - gxpas/2) * scale, (refy + GRID_REF_W/2) * scale),
Color,
Line, TEXT_ORIENT_HORIZ, size_ref,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER);
if( ii < xg - PAS_REF/2 )
{
GRLine(&DrawPanel->m_ClipBox, DC,ii * scale, yg * scale,
ii * scale, (yg - GRID_REF_W) * scale, Color);
}
DrawGraphicText(DrawPanel, DC,
wxPoint( (ii - gxpas/2) * scale, (yg - GRID_REF_W/2) * scale),
Color,
Line, TEXT_ORIENT_HORIZ, size_ref,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER);
}
/* Trace des reperes selon l'axe Y */
ipas = (yg - refy) / PAS_REF;
gypas = ( yg - refy) / ipas;
for ( ii = refy + gypas, jj = 0; ipas > 0 ; ii += gypas , jj++, ipas--)
{
if( jj < 26 ) Line[0] = jj + 'A';
else Line[0] = 'a' + jj - 26;
Line[1] = 0;
if( ii < yg - PAS_REF/2 )
{
GRLine(&DrawPanel->m_ClipBox, DC, refx * scale, ii * scale,
(refx + GRID_REF_W) * scale, ii * scale, Color);
}
DrawGraphicText(DrawPanel, DC,
wxPoint((refx + GRID_REF_W/2) * scale, (ii - gypas/2) * scale),
Color,
Line, TEXT_ORIENT_HORIZ, size_ref,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER);
if( ii < yg - PAS_REF/2 )
{
GRLine(&DrawPanel->m_ClipBox, DC, xg * scale, ii * scale,
(xg - GRID_REF_W) * scale, ii * scale, Color);
}
DrawGraphicText(DrawPanel, DC,
wxPoint((xg - GRID_REF_W/2) * scale, (ii - gxpas/2) * scale),
Color,
Line, TEXT_ORIENT_HORIZ, size_ref,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER);
}
/* Trace du cartouche */
refx = screen->m_CurrentSheet->m_Size.x - GRID_REF_W - marge;
refy = screen->m_CurrentSheet->m_Size.y - GRID_REF_W - marge;
for( WsItem = &WS_Date; WsItem != NULL; WsItem = WsItem->Pnext )
{
pos.x = (refx - WsItem->posx)* scale;
pos.y = (refy - WsItem->posy)* scale;
msg = "";
switch( WsItem->type )
{
case WS_DATE:
if(WsItem->Legende) msg = WsItem->Legende;
msg += screen->m_Date;
DrawGraphicText(DrawPanel, DC, pos, Color,
msg.GetData(), TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
break;
case WS_REV:
if(WsItem->Legende) msg = WsItem->Legende;
msg += screen->m_Revision;
DrawGraphicText(DrawPanel, DC, pos, Color,
msg.GetData(), TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
break;
case WS_LICENCE:
if(WsItem->Legende) msg = WsItem->Legende;
msg += g_ProductName + Main_Title;
DrawGraphicText(DrawPanel, DC, pos, Color,
msg.GetData(), TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
break;
case WS_SIZESHEET:
if(WsItem->Legende) msg = WsItem->Legende;
msg += screen->m_CurrentSheet->m_Name;
DrawGraphicText(DrawPanel, DC, pos, Color,
msg.GetData(), TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
break;
case WS_IDENTSHEET:
if(WsItem->Legende) msg = WsItem->Legende;
msg << screen->m_SheetNumber << "/" <<
screen->m_NumberOfSheet;
DrawGraphicText(DrawPanel, DC, pos, Color,
msg.GetData(), TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
break;
case WS_NAMECOMP:
if(WsItem->Legende) msg = WsItem->Legende;
msg += screen->m_Company;
DrawGraphicText(DrawPanel, DC, pos, Color,
msg.GetData(), TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
break;
case WS_TITLE:
if(WsItem->Legende) msg = WsItem->Legende;
msg += screen->m_Title;
DrawGraphicText(DrawPanel, DC, pos, Color,
msg.GetData(), TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
break;
case WS_COMMENT1:
if(WsItem->Legende) msg = WsItem->Legende;
msg += screen->m_Commentaire1;
DrawGraphicText(DrawPanel, DC, pos, Color,
msg.GetData(), TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
break;
case WS_COMMENT2:
if(WsItem->Legende) msg = WsItem->Legende;
msg += screen->m_Commentaire2;
DrawGraphicText(DrawPanel, DC, pos, Color,
msg.GetData(), TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
break;
case WS_COMMENT3:
if(WsItem->Legende) msg = WsItem->Legende;
msg += screen->m_Commentaire3;
DrawGraphicText(DrawPanel, DC, pos, Color,
msg.GetData(), TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
break;
case WS_COMMENT4:
if(WsItem->Legende) msg = WsItem->Legende;
msg += screen->m_Commentaire4;
DrawGraphicText(DrawPanel, DC, pos, Color,
msg.GetData(), TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER);
break;
case WS_SEGMENT:
xg = screen->m_CurrentSheet->m_Size.x -
GRID_REF_W - marge - WsItem->endx;
yg = screen->m_CurrentSheet->m_Size.y -
GRID_REF_W - marge - WsItem->endy;
GRLine(&DrawPanel->m_ClipBox, DC, pos.x, pos.y,
xg * scale, yg * scale, Color);
break;
}
}
}
void TEXTE_MODULE::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, GR_DRAWMODE aDrawMode,
const wxPoint& aOffset )
{
if( aPanel == NULL )
return;
/* parent must *not* be NULL (a footprint text without a footprint
parent has no sense) */
wxASSERT( m_Parent );
BOARD* brd = GetBoard( );
auto frame = static_cast<PCB_BASE_FRAME*> ( aPanel->GetParent() );
auto color = frame->Settings().Colors().GetLayerColor( GetLayer() );
PCB_LAYER_ID text_layer = GetLayer();
if( !brd->IsLayerVisible( m_Layer )
|| ( IsFrontLayer( text_layer ) && !brd->IsElementVisible( LAYER_MOD_TEXT_FR ) )
|| ( IsBackLayer( text_layer ) && !brd->IsElementVisible( LAYER_MOD_TEXT_BK ) ) )
return;
if( !brd->IsElementVisible( LAYER_MOD_REFERENCES ) && GetText() == wxT( "%R" ) )
return;
if( !brd->IsElementVisible( LAYER_MOD_VALUES ) && GetText() == wxT( "%V" ) )
return;
// Invisible texts are still drawn (not plotted) in LAYER_MOD_TEXT_INVISIBLE
// Just because we must have to edit them (at least to make them visible)
if( !IsVisible() )
{
if( !brd->IsElementVisible( LAYER_MOD_TEXT_INVISIBLE ) )
return;
color = frame->Settings().Colors().GetItemColor( LAYER_MOD_TEXT_INVISIBLE );
}
auto displ_opts = (PCB_DISPLAY_OPTIONS*)( aPanel->GetDisplayOptions() );
// shade text if high contrast mode is active
if( ( aDrawMode & GR_ALLOW_HIGHCONTRAST ) && displ_opts && displ_opts->m_ContrastModeDisplay )
{
PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) aPanel->GetScreen() )->m_Active_Layer;
if( !IsOnLayer( curr_layer ) )
color = COLOR4D( DARKDARKGRAY );
}
// Draw mode compensation for the width
int width = GetThickness();
if( displ_opts && displ_opts->m_DisplayModTextFill == SKETCH )
width = -width;
GRSetDrawMode( aDC, aDrawMode );
wxPoint pos = GetTextPos() - aOffset;
// Draw the text anchor point
if( brd->IsElementVisible( LAYER_ANCHOR ) )
{
COLOR4D anchor_color = frame->Settings().Colors().GetItemColor( LAYER_ANCHOR );
GRDrawAnchor( aPanel->GetClipBox(), aDC, pos.x, pos.y, DIM_ANCRE_TEXTE, anchor_color );
}
// Draw the text proper, with the right attributes
wxSize size = GetTextSize();
double orient = GetDrawRotation();
// If the text is mirrored : negate size.x (mirror / Y axis)
if( IsMirrored() )
size.x = -size.x;
DrawGraphicText( aPanel->GetClipBox(), aDC, pos, color, GetShownText(), orient,
size, GetHorizJustify(), GetVertJustify(),
width, IsItalic(), IsBold() );
// Enable these line to draw the bounding box (debug test purpose only)
#if 0
{
EDA_RECT BoundaryBox = GetBoundingBox();
GRRect( aPanel->GetClipBox(), aDC, BoundaryBox, 0, BROWN );
}
#endif
}
/* generate shapes of graphic items (outlines) on layer aLayer as polygons,
* and adds these polygons to aCornerBuffer
* aCornerBuffer = the buffer to store polygons
* aInflateValue = a value to inflate shapes
* aCircleToSegmentsCount = number of segments to approximate a circle
* aCorrectionFactor = the correction to apply to the circle radius
* to generate the polygon.
* if aCorrectionFactor = 1.0, the polygon is inside the circle
* the radius of circle approximated by segments is
* initial radius * aCorrectionFactor
*/
void MODULE::TransformGraphicShapesWithClearanceToPolygonSet(
LAYER_ID aLayer,
SHAPE_POLY_SET& aCornerBuffer,
int aInflateValue,
int aCircleToSegmentsCount,
double aCorrectionFactor,
int aCircleToSegmentsCountForTexts )
{
std::vector<TEXTE_MODULE *> texts; // List of TEXTE_MODULE to convert
EDGE_MODULE* outline;
for( EDA_ITEM* item = GraphicalItems(); item != NULL; item = item->Next() )
{
switch( item->Type() )
{
case PCB_MODULE_TEXT_T:
{
TEXTE_MODULE* text = static_cast<TEXTE_MODULE*>( item );
if( text->GetLayer() == aLayer && text->IsVisible() )
texts.push_back( text );
break;
}
case PCB_MODULE_EDGE_T:
outline = (EDGE_MODULE*) item;
if( outline->GetLayer() != aLayer )
break;
outline->TransformShapeWithClearanceToPolygon( aCornerBuffer,
0,
aCircleToSegmentsCount,
aCorrectionFactor );
break;
default:
break;
}
}
// Convert texts sur modules
if( Reference().GetLayer() == aLayer && Reference().IsVisible() )
texts.push_back( &Reference() );
if( Value().GetLayer() == aLayer && Value().IsVisible() )
texts.push_back( &Value() );
s_cornerBuffer = &aCornerBuffer;
// To allow optimization of circles approximated by segments,
// aCircleToSegmentsCountForTexts, when not 0, is used.
// if 0 (default value) the aCircleToSegmentsCount is used
s_textCircle2SegmentCount = aCircleToSegmentsCountForTexts ?
aCircleToSegmentsCountForTexts : aCircleToSegmentsCount;
for( unsigned ii = 0; ii < texts.size(); ii++ )
{
TEXTE_MODULE *textmod = texts[ii];
s_textWidth = textmod->GetThickness() + ( 2 * aInflateValue );
wxSize size = textmod->GetSize();
if( textmod->IsMirrored() )
size.x = -size.x;
DrawGraphicText( NULL, NULL, textmod->GetTextPosition(), BLACK,
textmod->GetShownText(), textmod->GetDrawRotation(), size,
textmod->GetHorizJustify(), textmod->GetVertJustify(),
textmod->GetThickness(), textmod->IsItalic(),
true, addTextSegmToPoly );
}
}
void SCH_SHEET::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC,
const wxPoint& aOffset, GR_DRAWMODE aDrawMode, COLOR4D aColor )
{
COLOR4D txtcolor;
wxString Text;
COLOR4D color;
int name_orientation;
wxPoint pos_sheetname,pos_filename;
wxPoint pos = m_pos + aOffset;
int lineWidth = GetPenSize();
EDA_RECT* clipbox = aPanel? aPanel->GetClipBox() : NULL;
if( aColor != COLOR4D::UNSPECIFIED )
color = aColor;
else
color = GetLayerColor( m_Layer );
GRSetDrawMode( aDC, aDrawMode );
GRRect( clipbox, aDC, pos.x, pos.y,
pos.x + m_size.x, pos.y + m_size.y, lineWidth, color );
pos_sheetname = GetSheetNamePosition() + aOffset;
pos_filename = GetFileNamePosition() + aOffset;
if( IsVerticalOrientation() )
name_orientation = TEXT_ANGLE_VERT;
else
name_orientation = TEXT_ANGLE_HORIZ;
/* Draw text : SheetName */
if( aColor != COLOR4D::UNSPECIFIED )
txtcolor = aColor;
else
txtcolor = GetLayerColor( LAYER_SHEETNAME );
Text = wxT( "Sheet: " ) + m_name;
DrawGraphicText( clipbox, aDC, pos_sheetname,
txtcolor, Text, name_orientation,
wxSize( m_sheetNameSize, m_sheetNameSize ),
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_BOTTOM, lineWidth,
false, false );
/* Draw text : FileName */
if( aColor != COLOR4D::UNSPECIFIED )
txtcolor = aColor;
else
txtcolor = GetLayerColor( LAYER_SHEETFILENAME );
Text = wxT( "File: " ) + m_fileName;
DrawGraphicText( clipbox, aDC, pos_filename,
txtcolor, Text, name_orientation,
wxSize( m_fileNameSize, m_fileNameSize ),
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_TOP, lineWidth,
false, false );
/* Draw text : SheetLabel */
for( SCH_SHEET_PIN& sheetPin : m_pins )
{
if( !sheetPin.IsMoving() )
sheetPin.Draw( aPanel, aDC, aOffset, aDrawMode, aColor );
}
#if 0
// Only for testing purposes, draw the component bounding box
EDA_RECT boundingBox = GetBoundingBox();
GRRect( aPanel->GetClipBox(), aDC, boundingBox, 0, BROWN );
GRFilledCircle( aPanel->GetClipBox(), aDC, m_pos.x, m_pos.y, 10, 0, color, color );
#endif
}
void TEXTE_MODULE::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, GR_DRAWMODE aDrawMode,
const wxPoint& aOffset )
{
if( aPanel == NULL )
return;
/* parent must *not* be NULL (a footprint text without a footprint
parent has no sense) */
wxASSERT( m_Parent );
BOARD* brd = GetBoard( );
EDA_COLOR_T color = brd->GetLayerColor( GetLayer() );
LAYER_ID text_layer = GetLayer();
if( !brd->IsLayerVisible( m_Layer )
|| (IsFrontLayer( text_layer ) && !brd->IsElementVisible( MOD_TEXT_FR_VISIBLE ))
|| (IsBackLayer( text_layer ) && !brd->IsElementVisible( MOD_TEXT_BK_VISIBLE )) )
return;
// Invisible texts are still drawn (not plotted) in MOD_TEXT_INVISIBLE
// Just because we must have to edit them (at least to make them visible)
if( m_NoShow )
{
if( !brd->IsElementVisible( MOD_TEXT_INVISIBLE ) )
return;
color = brd->GetVisibleElementColor( MOD_TEXT_INVISIBLE );
}
DISPLAY_OPTIONS* displ_opts = (DISPLAY_OPTIONS*)aPanel->GetDisplayOptions();
// shade text if high contrast mode is active
if( ( aDrawMode & GR_ALLOW_HIGHCONTRAST ) && displ_opts && displ_opts->m_ContrastModeDisplay )
{
LAYER_ID curr_layer = ( (PCB_SCREEN*) aPanel->GetScreen() )->m_Active_Layer;
if( !IsOnLayer( curr_layer ) )
ColorTurnToDarkDarkGray( &color );
}
// Draw mode compensation for the width
int width = m_Thickness;
if( displ_opts && displ_opts->m_DisplayModTextFill == SKETCH )
width = -width;
GRSetDrawMode( aDC, aDrawMode );
wxPoint pos = m_Pos - aOffset;
// Draw the text anchor point
if( brd->IsElementVisible( ANCHOR_VISIBLE ) )
{
EDA_COLOR_T anchor_color = brd->GetVisibleElementColor(ANCHOR_VISIBLE);
GRDrawAnchor( aPanel->GetClipBox(), aDC, pos.x, pos.y, DIM_ANCRE_TEXTE, anchor_color );
}
// Draw the text proper, with the right attributes
wxSize size = m_Size;
double orient = GetDrawRotation();
// If the text is mirrored : negate size.x (mirror / Y axis)
if( m_Mirror )
size.x = -size.x;
DrawGraphicText( aPanel->GetClipBox(), aDC, pos, color, GetShownText(), orient,
size, m_HJustify, m_VJustify, width, m_Italic, m_Bold );
// Enable these line to draw the bounding box (debug test purpose only)
#if 0
{
EDA_RECT BoundaryBox = GetBoundingBox();
GRRect( aPanel->GetClipBox(), aDC, BoundaryBox, 0, BROWN );
}
#endif
}
void LIB_TEXT::drawGraphic( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aOffset,
int aColor, int aDrawMode, void* aData, const TRANSFORM& aTransform )
{
int color = GetDefaultColor();
if( aColor < 0 ) // Used normal color or selected color
{
if( IsSelected() )
color = g_ItemSelectetColor;
}
else
{
color = aColor;
}
GRSetDrawMode( aDC, aDrawMode );
/* Calculate the text orientation, according to the component
* orientation/mirror (needed when draw text in schematic)
*/
int orient = m_Orient;
if( aTransform.y1 ) // Rotate component 90 degrees.
{
if( orient == TEXT_ORIENT_HORIZ )
orient = TEXT_ORIENT_VERT;
else
orient = TEXT_ORIENT_HORIZ;
}
/* Calculate the text justification, according to the component
* orientation/mirror this is a bit complicated due to cumulative
* calculations:
* - numerous cases (mirrored or not, rotation)
* - the DrawGraphicText function recalculate also H and H justifications
* according to the text orientation.
* - When a component is mirrored, the text is not mirrored and
* justifications are complicated to calculate
* so the more easily way is to use no justifications ( Centered text )
* and use GetBoundaryBox to know the text coordinate considered as centered
*/
EDA_RECT bBox = GetBoundingBox();
wxPoint txtpos = bBox.Centre();
// Calculate pos accordint to mirror/rotation.
txtpos = aTransform.TransformCoordinate( txtpos ) + aOffset;
DrawGraphicText( aPanel, aDC, txtpos, (EDA_Colors) color, m_Text, orient, m_Size,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, GetPenSize(),
m_Italic, m_Bold );
/* Enable this to draw the bounding box around the text field to validate
* the bounding box calculations.
*/
#if 0
EDA_RECT grBox;
grBox.SetOrigin( aTransform.TransformCoordinate( bBox.GetOrigin() ) );
grBox.SetEnd( aTransform.TransformCoordinate( bBox.GetEnd() ) );
grBox.Move( aOffset );
GRRect( aPanel->GetClipBox(), aDC, grBox, 0, LIGHTMAGENTA );
#endif
}
void D_PAD::DrawShape( EDA_RECT* aClipBox, wxDC* aDC, PAD_DRAWINFO& aDrawInfo )
{
wxPoint coord[4];
int delta_cx, delta_cy;
int angle = m_Orient;
int seg_width;
GRSetDrawMode( aDC, aDrawInfo.m_DrawMode );
// calculate pad shape position :
wxPoint shape_pos = ReturnShapePos() - aDrawInfo.m_Offset;
wxSize halfsize = m_Size;
halfsize.x >>= 1;
halfsize.y >>= 1;
switch( GetShape() )
{
case PAD_CIRCLE:
if( aDrawInfo.m_ShowPadFilled )
GRFilledCircle( aClipBox, aDC, shape_pos.x, shape_pos.y,
halfsize.x + aDrawInfo.m_Mask_margin.x, 0,
aDrawInfo.m_Color, aDrawInfo.m_Color );
else
GRCircle( aClipBox, aDC, shape_pos.x, shape_pos.y,
halfsize.x + aDrawInfo.m_Mask_margin.x,
m_PadSketchModePenSize, aDrawInfo.m_Color );
if( aDrawInfo.m_PadClearance )
{
GRCircle( aClipBox,
aDC, shape_pos.x, shape_pos.y,
halfsize.x + aDrawInfo.m_PadClearance,
0,
aDrawInfo.m_Color );
}
break;
case PAD_OVAL:
{
wxPoint segStart, segEnd;
seg_width = BuildSegmentFromOvalShape(segStart, segEnd, angle);
segStart += shape_pos;
segEnd += shape_pos;
if( aDrawInfo.m_ShowPadFilled )
{
GRFillCSegm( aClipBox, aDC, segStart.x, segStart.y, segEnd.x, segEnd.y,
seg_width, aDrawInfo.m_Color );
}
else
{
GRCSegm( aClipBox, aDC, segStart.x, segStart.y, segEnd.x, segEnd.y,
seg_width, m_PadSketchModePenSize, aDrawInfo.m_Color );
}
/* Draw the isolation line. */
if( aDrawInfo.m_PadClearance )
{
seg_width += 2 * aDrawInfo.m_PadClearance;
GRCSegm( aClipBox, aDC, segStart.x, segStart.y, segEnd.x, segEnd.y,
seg_width, aDrawInfo.m_Color );
}
}
break;
case PAD_RECT:
case PAD_TRAPEZOID:
BuildPadPolygon( coord, aDrawInfo.m_Mask_margin, angle );
for( int ii = 0; ii < 4; ii++ )
coord[ii] += shape_pos;
GRClosedPoly( aClipBox, aDC, 4, coord, aDrawInfo.m_ShowPadFilled,
aDrawInfo.m_ShowPadFilled ? 0 : m_PadSketchModePenSize,
aDrawInfo.m_Color, aDrawInfo.m_Color );
if( aDrawInfo.m_PadClearance )
{
BuildPadPolygon( coord, wxSize( aDrawInfo.m_PadClearance,
aDrawInfo.m_PadClearance ), angle );
for( int ii = 0; ii < 4; ii++ )
coord[ii] += shape_pos;
GRClosedPoly( aClipBox, aDC, 4, coord, 0, aDrawInfo.m_Color, aDrawInfo.m_Color );
}
break;
default:
break;
}
/* Draw the pad hole */
wxPoint holepos = m_Pos - aDrawInfo.m_Offset;
int hole = m_Drill.x >> 1;
bool drawhole = hole > 0;
if( !aDrawInfo.m_ShowPadFilled && !aDrawInfo. m_ShowNotPlatedHole )
drawhole = false;
if( drawhole )
{
bool blackpenstate = false;
if( aDrawInfo.m_IsPrinting )
{
blackpenstate = GetGRForceBlackPenState();
GRForceBlackPen( false );
aDrawInfo.m_HoleColor = g_DrawBgColor;
}
if( aDrawInfo.m_DrawMode != GR_XOR )
GRSetDrawMode( aDC, GR_COPY );
else
GRSetDrawMode( aDC, GR_XOR );
int hole_color = aDrawInfo.m_HoleColor;
if( aDrawInfo. m_ShowNotPlatedHole ) // Draw a specific hole color
hole_color = aDrawInfo.m_NPHoleColor;
switch( m_DrillShape )
{
case PAD_CIRCLE:
if( aDC->LogicalToDeviceXRel( hole ) > 1 )
GRFilledCircle( aClipBox, aDC, holepos.x, holepos.y, hole, 0,
aDrawInfo.m_Color, hole_color );
break;
case PAD_OVAL:
halfsize.x = m_Drill.x >> 1;
halfsize.y = m_Drill.y >> 1;
if( m_Drill.x > m_Drill.y ) /* horizontal */
{
delta_cx = halfsize.x - halfsize.y;
delta_cy = 0;
seg_width = m_Drill.y;
}
else /* vertical */
{
delta_cx = 0;
delta_cy = halfsize.y - halfsize.x;
seg_width = m_Drill.x;
}
RotatePoint( &delta_cx, &delta_cy, angle );
GRFillCSegm( aClipBox, aDC, holepos.x + delta_cx, holepos.y + delta_cy,
holepos.x - delta_cx, holepos.y - delta_cy, seg_width,
hole_color );
break;
default:
break;
}
if( aDrawInfo.m_IsPrinting )
GRForceBlackPen( blackpenstate );
}
GRSetDrawMode( aDC, aDrawInfo.m_DrawMode );
/* Draw "No connect" ( / or \ or cross X ) if necessary. : */
if( m_Netname.IsEmpty() && aDrawInfo.m_ShowNCMark )
{
int dx0 = MIN( halfsize.x, halfsize.y );
int nc_color = BLUE;
if( m_layerMask & LAYER_FRONT ) /* Draw \ */
GRLine( aClipBox, aDC, holepos.x - dx0, holepos.y - dx0,
holepos.x + dx0, holepos.y + dx0, 0, nc_color );
if( m_layerMask & LAYER_BACK ) /* Draw / */
GRLine( aClipBox, aDC, holepos.x + dx0, holepos.y - dx0,
holepos.x - dx0, holepos.y + dx0, 0, nc_color );
}
/* Draw the pad number */
if( !aDrawInfo.m_Display_padnum && !aDrawInfo.m_Display_netname )
return;
wxPoint tpos0 = shape_pos; // Position of the centre of text
wxPoint tpos = tpos0;
wxSize AreaSize; // size of text area, normalized to AreaSize.y < AreaSize.x
int shortname_len = m_ShortNetname.Len();
if( !aDrawInfo.m_Display_netname )
shortname_len = 0;
if( GetShape() == PAD_CIRCLE )
angle = 0;
AreaSize = m_Size;
if( m_Size.y > m_Size.x )
{
angle += 900;
AreaSize.x = m_Size.y;
AreaSize.y = m_Size.x;
}
if( shortname_len > 0 ) // if there is a netname, provides room to display this netname
{
AreaSize.y /= 2; // Text used only the upper area of the
// pad. The lower area displays the net name
tpos.y -= AreaSize.y / 2;
}
// Calculate the position of text, that is the middle point of the upper
// area of the pad
RotatePoint( &tpos, shape_pos, angle );
/* Draw text with an angle between -90 deg and + 90 deg */
int t_angle = angle;
NORMALIZE_ANGLE_90( t_angle );
/* Note: in next calculations, texte size is calculated for 3 or more
* chars. Of course, pads numbers and nets names can have less than 3
* chars. but after some tries, i found this is gives the best look
*/
#define MIN_CHAR_COUNT 3
wxString buffer;
int tsize;
if( aDrawInfo.m_Display_padnum )
{
ReturnStringPadName( buffer );
int numpad_len = buffer.Len();
numpad_len = MAX( numpad_len, MIN_CHAR_COUNT );
tsize = min( AreaSize.y, AreaSize.x / numpad_len );
#define CHAR_SIZE_MIN 5
if( aDC->LogicalToDeviceXRel( tsize ) >= CHAR_SIZE_MIN ) // Not drawable when size too small.
{
// tsize reserve room for marges and segments thickness
tsize = (int) ( tsize * 0.8 );
DrawGraphicText( aDrawInfo.m_DrawPanel, aDC, tpos, WHITE, buffer, t_angle,
wxSize( tsize, tsize ), GR_TEXT_HJUSTIFY_CENTER,
GR_TEXT_VJUSTIFY_CENTER, tsize / 7, false, false );
}
}
// display the short netname, if exists
if( shortname_len == 0 )
return;
shortname_len = MAX( shortname_len, MIN_CHAR_COUNT );
tsize = min( AreaSize.y, AreaSize.x / shortname_len );
if( aDC->LogicalToDeviceXRel( tsize ) >= CHAR_SIZE_MIN ) // Not drawable in size too small.
{
tpos = tpos0;
if( aDrawInfo.m_Display_padnum )
tpos.y += AreaSize.y / 2;
RotatePoint( &tpos, shape_pos, angle );
// tsize reserve room for marges and segments thickness
tsize = (int) ( tsize * 0.8 );
DrawGraphicText( aDrawInfo.m_DrawPanel, aDC, tpos, WHITE, m_ShortNetname, t_angle,
wxSize( tsize, tsize ), GR_TEXT_HJUSTIFY_CENTER,
GR_TEXT_VJUSTIFY_CENTER, tsize / 7, false, false );
}
}
void SCH_FIELD::Draw( EDA_DRAW_PANEL* aPanel, wxDC* aDC, const wxPoint& aOffset,
GR_DRAWMODE aDrawMode, COLOR4D aColor )
{
int orient;
COLOR4D color;
wxPoint textpos;
SCH_COMPONENT* parentComponent = (SCH_COMPONENT*) m_Parent;
int lineWidth = GetThickness();
if( lineWidth == 0 ) // Use default values for pen size
{
if( IsBold() )
lineWidth = GetPenSizeForBold( GetTextWidth() );
else
lineWidth = GetDefaultLineThickness();
}
// Clip pen size for small texts:
lineWidth = Clamp_Text_PenSize( lineWidth, GetTextSize(), IsBold() );
if( ( !IsVisible() && !m_forceVisible) || IsVoid() )
return;
GRSetDrawMode( aDC, aDrawMode );
// Calculate the text orientation according to the component orientation.
orient = GetTextAngle();
if( parentComponent->GetTransform().y1 ) // Rotate component 90 degrees.
{
if( orient == TEXT_ANGLE_HORIZ )
orient = TEXT_ANGLE_VERT;
else
orient = TEXT_ANGLE_HORIZ;
}
/* Calculate the text justification, according to the component
* orientation/mirror this is a bit complicated due to cumulative
* calculations:
* - numerous cases (mirrored or not, rotation)
* - the DrawGraphicText function recalculate also H and H justifications
* according to the text orientation.
* - When a component is mirrored, the text is not mirrored and
* justifications are complicated to calculate
* so the more easily way is to use no justifications ( Centered text )
* and use GetBoundaryBox to know the text coordinate considered as centered
*/
EDA_RECT boundaryBox = GetBoundingBox();
textpos = boundaryBox.Centre() + aOffset;
if( m_forceVisible )
{
color = COLOR4D( DARKGRAY );
}
else
{
if( m_id == REFERENCE )
color = GetLayerColor( LAYER_REFERENCEPART );
else if( m_id == VALUE )
color = GetLayerColor( LAYER_VALUEPART );
else
color = GetLayerColor( LAYER_FIELDS );
}
EDA_RECT* clipbox = aPanel ? aPanel->GetClipBox() : NULL;
DrawGraphicText( clipbox, aDC, textpos, color, GetFullyQualifiedText(), orient, GetTextSize(),
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
lineWidth, IsItalic(), IsBold() );
// While moving: don't loose visual contact to which component this label belongs.
if ( IsWireImage() )
{
const wxPoint origin = parentComponent->GetPosition();
textpos = GetTextPos() - origin;
textpos = parentComponent->GetScreenCoord( textpos );
textpos += parentComponent->GetPosition();
GRLine( clipbox, aDC, origin, textpos, 2, DARKGRAY );
}
/* Enable this to draw the bounding box around the text field to validate
* the bounding box calculations.
*/
#if 0
// Draw boundary box:
GRRect( aPanel->GetClipBox(), aDC, boundaryBox, 0, BROWN );
// Draw the text anchor point
/* Calculate the text position, according to the component
* orientation/mirror */
textpos = m_Pos - parentComponent->GetPosition();
textpos = parentComponent->GetScreenCoord( textpos );
textpos += parentComponent->GetPosition();
const int len = 10;
GRLine( clipbox, aDC,
textpos.x - len, textpos.y, textpos.x + len, textpos.y, 0, BLUE );
GRLine( clipbox, aDC,
textpos.x, textpos.y - len, textpos.x, textpos.y + len, 0, BLUE );
#endif
}
void EDA_DRAW_FRAME::TraceWorkSheet( wxDC* DC, BASE_SCREEN* screen, int line_width )
{
if( !m_showBorderAndTitleBlock )
return;
const PAGE_INFO& pageInfo = GetPageSettings();
wxSize pageSize = pageInfo.GetSizeMils();
int ii, jj, xg, yg, ipas, gxpas, gypas;
wxPoint pos;
int refx, refy;
EDA_Colors Color;
wxString Line;
Ki_WorkSheetData* WsItem;
int scale = m_internalUnits / 1000;
wxSize size( SIZETEXT * scale, SIZETEXT * scale );
#if defined(KICAD_GOST)
wxSize size2( SIZETEXT * scale * 2, SIZETEXT * scale * 2);
wxSize size3( SIZETEXT * scale * 3, SIZETEXT * scale * 3);
wxSize size1_5( SIZETEXT * scale * 1.5, SIZETEXT * scale * 1.5);
#endif
wxSize size_ref( SIZETEXT_REF * scale, SIZETEXT_REF * scale );
wxString msg;
int UpperLimit = VARIABLE_BLOCK_START_POSITION;
int width = line_width;
Color = RED;
// if not printing, draw the page limits:
if( !screen->m_IsPrinting && g_ShowPageLimits )
{
GRSetDrawMode( DC, GR_COPY );
GRRect( m_canvas->GetClipBox(), DC, 0, 0,
pageSize.x * scale, pageSize.y * scale, width,
g_DrawBgColor == WHITE ? LIGHTGRAY : DARKDARKGRAY );
}
GRSetDrawMode( DC, GR_COPY );
// Draw the border.
// Upper left corner
refx = pageInfo.GetLeftMarginMils();
refy = pageInfo.GetTopMarginMils();
// lower right corner
xg = pageSize.x - pageInfo.GetRightMarginMils();
yg = pageSize.y - pageInfo.GetBottomMarginMils();
#if defined(KICAD_GOST)
GRRect( m_canvas->GetClipBox(), DC, refx * scale, refy * scale,
xg * scale, yg * scale, width, Color );
#else
for( ii = 0; ii < 2; ii++ )
{
GRRect( m_canvas->GetClipBox(), DC, refx * scale, refy * scale,
xg * scale, yg * scale, width, Color );
refx += GRID_REF_W; refy += GRID_REF_W;
xg -= GRID_REF_W; yg -= GRID_REF_W;
}
#endif
// Draw the reference legends.
refx = pageInfo.GetLeftMarginMils();
#if defined(KICAD_GOST)
refy = pageSize.y - pageInfo.GetBottomMarginMils(); // Lower left corner
for( WsItem = &WS_Segm1_LU; WsItem != NULL; WsItem = WsItem->Pnext )
{
pos.x = ( refx - WsItem->m_Posx ) * scale;
pos.y = ( refy - WsItem->m_Posy ) * scale;
msg.Empty();
switch( WsItem->m_Type )
{
case WS_CADRE:
break;
case WS_PODPIS_LU:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_VERT, size,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM,
width, false, false );
break;
case WS_SEGMENT_LU:
xg = pageInfo.GetLeftMarginMils() - WsItem->m_Endx;
yg = pageSize.y - pageInfo.GetBottomMarginMils() - WsItem->m_Endy;
GRLine( m_canvas->GetClipBox(), DC, pos.x, pos.y,
xg * scale, yg * scale, width, Color );
break;
}
}
refy = pageInfo.GetBottomMarginMils(); // Left Top corner
for( WsItem = &WS_Segm1_LT; WsItem != NULL; WsItem = WsItem->Pnext )
{
pos.x = ( refx + WsItem->m_Posx ) * scale;
pos.y = ( refy + WsItem->m_Posy ) * scale;
msg.Empty();
switch( WsItem->m_Type )
{
case WS_SEGMENT_LT:
xg = pageInfo.GetLeftMarginMils() + WsItem->m_Endx;
yg = pageInfo.GetBottomMarginMils() + WsItem->m_Endy;
GRLine( m_canvas->GetClipBox(), DC, pos.x, pos.y,
xg * scale, yg * scale, width, Color );
break;
}
}
#else
// Upper left corner
refy = pageInfo.GetTopMarginMils();
// lower right corner
xg = pageSize.x - pageInfo.GetRightMarginMils();
yg = pageSize.y - pageInfo.GetBottomMarginMils();
ipas = ( xg - refx ) / PAS_REF;
gxpas = ( xg - refx ) / ipas;
for( ii = refx + gxpas, jj = 1; ipas > 0; ii += gxpas, jj++, ipas-- )
{
Line.Printf( wxT( "%d" ), jj );
if( ii < xg - PAS_REF / 2 )
{
GRLine( m_canvas->GetClipBox(), DC, ii * scale, refy * scale,
ii * scale, ( refy + GRID_REF_W ) * scale, width, Color );
}
DrawGraphicText( m_canvas, DC,
wxPoint( ( ii - gxpas / 2 ) * scale,
( refy + GRID_REF_W / 2 ) * scale ),
Color, Line, TEXT_ORIENT_HORIZ, size_ref,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
if( ii < xg - PAS_REF / 2 )
{
GRLine( m_canvas->GetClipBox(), DC, ii * scale, yg * scale,
ii * scale, ( yg - GRID_REF_W ) * scale, width, Color );
}
DrawGraphicText( m_canvas, DC,
wxPoint( ( ii - gxpas / 2 ) * scale,
( yg - GRID_REF_W / 2) * scale ),
Color, Line, TEXT_ORIENT_HORIZ, size_ref,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
}
ipas = ( yg - refy ) / PAS_REF;
gypas = ( yg - refy ) / ipas;
for( ii = refy + gypas, jj = 0; ipas > 0; ii += gypas, jj++, ipas-- )
{
if( jj < 26 )
Line.Printf( wxT( "%c" ), jj + 'A' );
else // I hope 52 identifiers are enought...
Line.Printf( wxT( "%c" ), 'a' + jj - 26 );
if( ii < yg - PAS_REF / 2 )
{
GRLine( m_canvas->GetClipBox(), DC, refx * scale, ii * scale,
( refx + GRID_REF_W ) * scale, ii * scale, width, Color );
}
DrawGraphicText( m_canvas, DC,
wxPoint( ( refx + GRID_REF_W / 2 ) * scale,
( ii - gypas / 2 ) * scale ),
Color, Line, TEXT_ORIENT_HORIZ, size_ref,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
if( ii < yg - PAS_REF / 2 )
{
GRLine( m_canvas->GetClipBox(), DC, xg * scale, ii * scale,
( xg - GRID_REF_W ) * scale, ii * scale, width, Color );
}
DrawGraphicText( m_canvas, DC,
wxPoint( ( xg - GRID_REF_W / 2 ) * scale,
( ii - gxpas / 2 ) * scale ),
Color, Line, TEXT_ORIENT_HORIZ, size_ref,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
}
#endif
#if defined(KICAD_GOST)
// lower right corner
refx = pageSize.x - pageInfo.GetRightMarginMils();
refy = pageSize.y - pageInfo.GetBottomMarginMils();
if( screen->m_ScreenNumber == 1 )
{
for( WsItem = &WS_Date; WsItem != NULL; WsItem = WsItem->Pnext )
{
pos.x = (refx - WsItem->m_Posx) * scale;
pos.y = (refy - WsItem->m_Posy) * scale;
msg.Empty();
switch( WsItem->m_Type )
{
case WS_DATE:
break;
case WS_REV:
break;
case WS_KICAD_VERSION:
break;
case WS_PODPIS:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
break;
case WS_SIZESHEET:
break;
case WS_IDENTSHEET:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
if( screen->m_NumberOfScreen > 1 )
msg << screen->m_ScreenNumber;
DrawGraphicText( m_canvas, DC, pos, Color, msg,
TEXT_ORIENT_HORIZ, size, GR_TEXT_HJUSTIFY_LEFT,
GR_TEXT_VJUSTIFY_CENTER, width, false, false );
break;
case WS_SHEETS:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg << screen->m_NumberOfScreen;
DrawGraphicText( m_canvas, DC, pos, Color, msg,
TEXT_ORIENT_HORIZ, size, GR_TEXT_HJUSTIFY_LEFT,
GR_TEXT_VJUSTIFY_CENTER, width, false, false );
break;
case WS_COMPANY_NAME:
msg = GetTitleBlock().GetCompany();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size1_5,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
width,
false, false );
}
break;
case WS_TITLE:
msg = GetTitleBlock().GetTitle();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size1_5,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
width,
false, false );
}
break;
case WS_COMMENT1:
msg = GetTitleBlock().GetComment1();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size3,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
width,
false, false );
pos.x = (pageInfo.GetLeftMarginMils() + 1260) * scale;
pos.y = (pageInfo.GetTopMarginMils() + 270) * scale;
DrawGraphicText( m_canvas, DC, pos, Color,
msg, 1800, size2,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
width,
false, false );
}
break;
case WS_COMMENT2:
msg = GetTitleBlock().GetComment2();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
}
break;
case WS_COMMENT3:
msg = GetTitleBlock().GetComment3();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
}
break;
case WS_COMMENT4:
msg = GetTitleBlock().GetComment4();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
}
break;
case WS_UPPER_SEGMENT:
case WS_LEFT_SEGMENT:
WS_MostUpperLine.m_Posy = WS_MostUpperLine.m_Endy =
WS_MostLeftLine.m_Posy = STAMP_OY;
pos.y = ( refy - WsItem->m_Posy ) * scale;
case WS_SEGMENT:
xg = pageSize.x -
pageInfo.GetRightMarginMils() - WsItem->m_Endx;
yg = pageSize.y -
pageInfo.GetBottomMarginMils() - WsItem->m_Endy;
GRLine( m_canvas->GetClipBox(), DC, pos.x, pos.y,
xg * scale, yg * scale, width, Color );
break;
}
}
}
else
{
for( WsItem = &WS_CADRE_D; WsItem != NULL; WsItem = WsItem->Pnext )
{
pos.x = ( refx - WsItem->m_Posx ) * scale;
pos.y = ( refy - WsItem->m_Posy ) * scale;
msg.Empty();
switch( WsItem->m_Type )
{
case WS_CADRE:
// Begin list number > 1
msg = GetTitleBlock().GetComment1();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size3,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
width,
false, false );
pos.x = (pageInfo.GetLeftMarginMils() + 1260) * scale;
pos.y = (pageInfo.GetTopMarginMils() + 270) * scale;
DrawGraphicText( m_canvas, DC, pos, Color,
msg, 1800, size2,
GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER,
width,
false, false );
}
break;
case WS_PODPIS_D:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width,
false, false );
break;
case WS_IDENTSHEET_D:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg << screen->m_ScreenNumber;
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
break;
case WS_LEFT_SEGMENT_D:
pos.y = ( refy - WsItem->m_Posy ) * scale;
case WS_SEGMENT_D:
xg = pageSize.x -
pageInfo.GetRightMarginMils() - WsItem->m_Endx;
yg = pageSize.y -
pageInfo.GetBottomMarginMils() - WsItem->m_Endy;
GRLine( m_canvas->GetClipBox(), DC, pos.x, pos.y,
xg * scale, yg * scale, width, Color );
break;
}
}
}
#else
refx = pageSize.x - pageInfo.GetRightMarginMils() - GRID_REF_W;
refy = pageSize.y - pageInfo.GetBottomMarginMils() - GRID_REF_W;
for( WsItem = &WS_Date; WsItem != NULL; WsItem = WsItem->Pnext )
{
pos.x = (refx - WsItem->m_Posx) * scale;
pos.y = (refy - WsItem->m_Posy) * scale;
msg.Empty();
switch( WsItem->m_Type )
{
case WS_DATE:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg += GetTitleBlock().GetDate();
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, true );
break;
case WS_REV:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg += GetTitleBlock().GetRevision();
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
GetPenSizeForBold( MIN( size.x, size.y ) ),
false, true );
break;
case WS_KICAD_VERSION:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg += g_ProductName + wxGetApp().GetAppName();
msg += wxT( " " ) + GetBuildVersion();
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
break;
case WS_SIZESHEET:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg += pageInfo.GetType();
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
break;
case WS_IDENTSHEET:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg << screen->m_ScreenNumber << wxT( "/" ) << screen->m_NumberOfScreen;
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
break;
case WS_FILENAME:
{
wxString fname, fext;
wxFileName::SplitPath( screen->GetFileName(), (wxString*) NULL, &fname, &fext );
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg << fname << wxT( "." ) << fext;
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
}
break;
case WS_FULLSHEETNAME:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg += GetScreenDesc();
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
break;
case WS_COMPANY_NAME:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg += GetTitleBlock().GetCompany();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
GetPenSizeForBold( MIN( size.x, size.y ) ),
false, true );
UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
}
break;
case WS_TITLE:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg += GetTitleBlock().GetTitle();
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
GetPenSizeForBold( MIN( size.x, size.y ) ),
false, true );
break;
case WS_COMMENT1:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg += GetTitleBlock().GetComment1();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
}
break;
case WS_COMMENT2:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg += GetTitleBlock().GetComment2();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
}
break;
case WS_COMMENT3:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg += GetTitleBlock().GetComment3();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
}
break;
case WS_COMMENT4:
if( WsItem->m_Legende )
msg = WsItem->m_Legende;
msg += GetTitleBlock().GetComment4();
if( !msg.IsEmpty() )
{
DrawGraphicText( m_canvas, DC, pos, Color,
msg, TEXT_ORIENT_HORIZ, size,
GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_VJUSTIFY_CENTER,
width, false, false );
UpperLimit = MAX( UpperLimit, WsItem->m_Posy + SIZETEXT );
}
break;
case WS_UPPER_SEGMENT:
if( UpperLimit == 0 )
break;
case WS_LEFT_SEGMENT:
WS_MostUpperLine.m_Posy =
WS_MostUpperLine.m_Endy =
WS_MostLeftLine.m_Posy = UpperLimit;
pos.y = (refy - WsItem->m_Posy) * scale;
case WS_SEGMENT:
xg = pageSize.x -
GRID_REF_W - pageInfo.GetRightMarginMils() - WsItem->m_Endx;
yg = pageSize.y -
GRID_REF_W - pageInfo.GetBottomMarginMils() - WsItem->m_Endy;
GRLine( m_canvas->GetClipBox(), DC, pos.x, pos.y,
xg * scale, yg * scale, width, Color );
break;
}
}
#endif
}
/**
* Function PlotGraphicText
* same as DrawGraphicText, but plot graphic text insteed of draw it
* @param aPos = text position (according to aH_justify, aV_justify)
* @param aColor (enum EDA_COLOR_T) = text color
* @param aText = text to draw
* @param aOrient = angle in 0.1 degree
* @param aSize = text size (size.x or size.y can be < 0 for mirrored texts)
* @param aH_justify = horizontal justification (Left, center, right)
* @param aV_justify = vertical justification (bottom, center, top)
* @param aWidth = line width (pen width) (default = 0)
* if width < 0 : draw segments in sketch mode, width = abs(width)
* Use a value min(aSize.x, aSize.y) / 5 for a bold text
* @param aItalic = true to simulate an italic font
* @param aBold = true to use a bold font Useful only with default width value (aWidth = 0)
* @param aMultilineAllowed = true to plot text as multiline, otherwise single line
*/
void PLOTTER::Text( const wxPoint& aPos,
enum EDA_COLOR_T aColor,
const wxString& aText,
double aOrient,
const wxSize& aSize,
enum EDA_TEXT_HJUSTIFY_T aH_justify,
enum EDA_TEXT_VJUSTIFY_T aV_justify,
int aWidth,
bool aItalic,
bool aBold,
bool aMultilineAllowed )
{
int textPensize = aWidth;
if( textPensize == 0 && aBold ) // Use default values if aWidth == 0
textPensize = GetPenSizeForBold( std::min( aSize.x, aSize.y ) );
if( textPensize >= 0 )
textPensize = Clamp_Text_PenSize( aWidth, aSize, aBold );
else
textPensize = -Clamp_Text_PenSize( -aWidth, aSize, aBold );
SetCurrentLineWidth( textPensize );
if( aColor >= 0 )
SetColor( aColor );
if( aMultilineAllowed )
{
// EDA_TEXT needs for calculations of the position of every
// line according to orientation and justifications
wxArrayString strings;
EDA_TEXT* multilineText = new EDA_TEXT( aText );
multilineText->SetSize( aSize );
multilineText->SetTextPosition( aPos );
multilineText->SetOrientation( aOrient );
multilineText->SetHorizJustify( aH_justify );
multilineText->SetVertJustify( aV_justify );
multilineText->SetThickness( aWidth );
multilineText->SetMultilineAllowed( aMultilineAllowed );
std::vector<wxPoint> positions;
wxStringSplit( aText, strings, '\n' );
positions.reserve( strings.Count() );
multilineText->GetPositionsOfLinesOfMultilineText(
positions, strings.Count() );
for( unsigned ii = 0; ii < strings.Count(); ii++ )
{
wxString& txt = strings.Item( ii );
DrawGraphicText( NULL, NULL, positions[ii], aColor, txt,
aOrient, aSize,
aH_justify, aV_justify,
textPensize, aItalic, aBold, NULL, this );
}
delete multilineText;
}
else
{
DrawGraphicText( NULL, NULL, aPos, aColor, aText,
aOrient, aSize,
aH_justify, aV_justify,
textPensize, aItalic, aBold, NULL, this );
}
if( aWidth != textPensize )
SetCurrentLineWidth( aWidth );
}
