KIGFX::SCH_PAINTER Class Reference

Contains methods for drawing schematic-specific items. More...

#include <sch_painter.h>

Inheritance diagram for KIGFX::SCH_PAINTER:

Public Member Functions
	SCH_PAINTER (GAL *aGal)
virtual bool	Draw (const VIEW_ITEM *, int) override
	Takes an instance of VIEW_ITEM and passes it to a function that knows how to draw the item. More...
virtual SCH_RENDER_SETTINGS *	GetSettings () override
	Return a pointer to current settings that are going to be used when drawing items. More...
void	SetSchematic (SCHEMATIC *aSchematic)
void	SetGAL (GAL *aGal)
	Changes Graphics Abstraction Layer used for drawing items for a new one. More...

Protected Attributes
GAL *	m_gal
	Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg. More...

Private Member Functions
void	draw (LIB_PIN *aPin, int aLayer)
void	draw (const LIB_SHAPE *aCircle, int aLayer)
void	draw (const LIB_SYMBOL *aSymbol, int, bool aDrawFields=true, int aUnit=0, int aConvert=0)
void	draw (const LIB_FIELD *aField, int aLayer)
void	draw (const LIB_TEXT *aText, int aLayer)
void	draw (SCH_SYMBOL *aSymbol, int aLayer)
void	draw (const SCH_JUNCTION *aJct, int aLayer)
void	draw (const SCH_FIELD *aField, int aLayer)
void	draw (const SCH_TEXT *aText, int aLayer)
void	draw (SCH_HIERLABEL *aLabel, int aLayer)
void	draw (SCH_GLOBALLABEL *aLabel, int aLayer)
void	draw (const SCH_SHEET *aSheet, int aLayer)
void	draw (const SCH_NO_CONNECT *aNC, int aLayer)
void	draw (const SCH_MARKER *aMarker, int aLayer)
void	draw (const SCH_BITMAP *aBitmap, int aLayer)
void	draw (const SCH_LINE *aLine, int aLayer)
void	draw (const SCH_BUS_ENTRY_BASE *aEntry, int aLayer)
void	drawPinDanglingSymbol (const VECTOR2I &aPos, const COLOR4D &aColor, bool aDrawingShadows)
void	drawDanglingSymbol (const wxPoint &aPos, const COLOR4D &aColor, int aWidth, bool aDrawingShadows)
int	internalPinDecoSize (const LIB_PIN &aPin)
int	externalPinDecoSize (const LIB_PIN &aPin)
bool	isUnitAndConversionShown (const LIB_ITEM *aItem) const
float	getShadowWidth () const
COLOR4D	getRenderColor (const EDA_ITEM *aItem, int aLayer, bool aDrawingShadows) const
float	getLineWidth (const LIB_ITEM *aItem, bool aDrawingShadows) const
float	getLineWidth (const SCH_ITEM *aItem, bool aDrawingShadows) const
float	getTextThickness (const SCH_TEXT *aItem, bool aDrawingShadows) const
float	getTextThickness (const SCH_FIELD *aItem, bool aDrawingShadows) const
float	getTextThickness (const LIB_FIELD *aItem, bool aDrawingShadows) const
float	getTextThickness (const LIB_TEXT *aItem, bool aDrawingShadows) const
bool	setDeviceColors (const LIB_ITEM *aItem, int aLayer)
void	triLine (const VECTOR2D &a, const VECTOR2D &b, const VECTOR2D &c)
void	strokeText (const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
void	boxText (const wxString &aText, const VECTOR2D &aPosition, double aAngle)

Private Attributes
SCH_RENDER_SETTINGS	m_schSettings
SCHEMATIC *	m_schematic

Detailed Description

Contains methods for drawing schematic-specific items.

Definition at line 130 of file sch_painter.h.

Constructor & Destructor Documentation

SCH_PAINTER()

KIGFX::SCH_PAINTER::SCH_PAINTER

(

GAL *

aGal

)

Definition at line 157 of file sch_painter.cpp.

 :
 KIGFX::PAINTER( aGal ),
 m_schematic( nullptr )
{ }

Member Function Documentation

boxText()

void KIGFX::SCH_PAINTER::boxText ( const wxString &  aText, const VECTOR2D &  aPosition, double  aAngle  )

private

Definition at line 415 of file sch_painter.cpp.

{
 const STROKE_FONT& font = m_gal->GetStrokeFont();
 VECTOR2D extents = font.ComputeStringBoundaryLimits( aText, m_gal->GetGlyphSize(),
 m_gal->GetLineWidth() );
 EDA_RECT box( (wxPoint) aPosition, wxSize( extents.x, extents.y ) );

 if( m_gal->GetHorizontalJustify() == GR_TEXT_HJUSTIFY_CENTER )
 box.SetX( box.GetX() - ( box.GetWidth() / 2) );
 else if( m_gal->GetHorizontalJustify() == GR_TEXT_HJUSTIFY_RIGHT )
 box.SetX( box.GetX() - box.GetWidth() );

 if( m_gal->GetVerticalJustify() == GR_TEXT_VJUSTIFY_CENTER )
 box.SetY( box.GetY() - ( box.GetHeight() / 2) );
 else if( m_gal->GetVerticalJustify() == GR_TEXT_VJUSTIFY_BOTTOM )
 box.SetY( box.GetY() - box.GetHeight() );

 box.Normalize(); // Make h and v sizes always >= 0
 box = box.GetBoundingBoxRotated((wxPoint) aPosition, RAD2DECIDEG( aAngle ) );
 box.RevertYAxis();
 m_gal->DrawRectangle( mapCoords( box.GetOrigin() ), mapCoords( box.GetEnd() ) );
}

References KIGFX::STROKE_FONT::ComputeStringBoundaryLimits(), KIGFX::GAL::DrawRectangle(), EDA_RECT::GetBoundingBoxRotated(), EDA_RECT::GetEnd(), KIGFX::GAL::GetGlyphSize(), EDA_RECT::GetHeight(), KIGFX::GAL::GetHorizontalJustify(), KIGFX::GAL::GetLineWidth(), EDA_RECT::GetOrigin(), KIGFX::GAL::GetStrokeFont(), KIGFX::GAL::GetVerticalJustify(), EDA_RECT::GetWidth(), EDA_RECT::GetX(), EDA_RECT::GetY(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_CENTER, KIGFX::PAINTER::m_gal, KIGFX::mapCoords(), EDA_RECT::Normalize(), RAD2DECIDEG(), EDA_RECT::RevertYAxis(), EDA_RECT::SetX(), EDA_RECT::SetY(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by draw().

Draw()

bool KIGFX::SCH_PAINTER::Draw ( const VIEW_ITEM *  aItem, int  aLayer  )

overridevirtual

Takes an instance of VIEW_ITEM and passes it to a function that knows how to draw the item.

Parameters

aItem	is an item to be drawn.
aLayer	tells which layer is currently rendered so that draw functions may know what to draw (eg. for pads there are separate layers for holes, because they have other dimensions then the pad itself.

Implements KIGFX::PAINTER.

Definition at line 167 of file sch_painter.cpp.

{
 const auto item = dynamic_cast<const EDA_ITEM*>( aItem );

 if( !item )
 return false;

#ifdef CONNECTIVITY_DEBUG

 auto sch_item = dynamic_cast<const SCH_ITEM*>( item );
 auto conn = sch_item ? sch_item->Connection( *g_CurrentSheet ) : nullptr;

 if( conn )
 {
 auto pos = item->GetBoundingBox().Centre();
 auto label = conn->Name( true );

 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 m_gal->SetStrokeColor( COLOR4D( LIGHTRED ) );
 m_gal->SetLineWidth( Mils2ui( 2 ) );
 m_gal->SetGlyphSize( VECTOR2D( Mils2ui( 20 ), Mils2ui( 20 ) ) );
 m_gal->StrokeText( conn->Name( true ), pos, 0.0, 0 );
 }

#endif

 if( ADVANCED_CFG::GetCfg().m_DrawBoundingBoxes )
 {
 BOX2I box = item->GetBoundingBox();

 if( item->Type() == SCH_SYMBOL_T )
 box = static_cast<const SCH_SYMBOL*>( item )->GetBodyBoundingBox();

 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( item->IsSelected() ? COLOR4D( 1.0, 0.2, 0.2, 1 )
 : COLOR4D( 0.2, 0.2, 0.2, 1 ) );
 m_gal->SetLineWidth( Mils2iu( 3 ) );
 m_gal->DrawRectangle( box.GetOrigin(), box.GetEnd() );
 }

 switch( item->Type() )
 {
 HANDLE_ITEM( LIB_SYMBOL_T, LIB_SYMBOL );
 HANDLE_ITEM( LIB_SHAPE_T, LIB_SHAPE );
 HANDLE_ITEM( LIB_PIN_T, LIB_PIN );
 HANDLE_ITEM( LIB_FIELD_T, LIB_FIELD );
 HANDLE_ITEM( LIB_TEXT_T, LIB_TEXT );
 HANDLE_ITEM( SCH_SYMBOL_T, SCH_SYMBOL );
 HANDLE_ITEM( SCH_JUNCTION_T, SCH_JUNCTION );
 HANDLE_ITEM( SCH_LINE_T, SCH_LINE );
 HANDLE_ITEM( SCH_TEXT_T, SCH_TEXT );
 HANDLE_ITEM( SCH_LABEL_T, SCH_TEXT );
 HANDLE_ITEM( SCH_FIELD_T, SCH_FIELD );
 HANDLE_ITEM( SCH_HIER_LABEL_T, SCH_HIERLABEL );
 HANDLE_ITEM( SCH_GLOBAL_LABEL_T, SCH_GLOBALLABEL );
 HANDLE_ITEM( SCH_SHEET_T, SCH_SHEET );
 HANDLE_ITEM( SCH_SHEET_PIN_T, SCH_HIERLABEL );
 HANDLE_ITEM( SCH_NO_CONNECT_T, SCH_NO_CONNECT );
 HANDLE_ITEM( SCH_BUS_WIRE_ENTRY_T, SCH_BUS_ENTRY_BASE );
 HANDLE_ITEM( SCH_BUS_BUS_ENTRY_T, SCH_BUS_ENTRY_BASE );
 HANDLE_ITEM( SCH_BITMAP_T, SCH_BITMAP );
 HANDLE_ITEM( SCH_MARKER_T, SCH_MARKER );

 default: return false;
 }

 return false;
}

References KIGFX::GAL::DrawRectangle(), ADVANCED_CFG::GetCfg(), BOX2< Vec >::GetEnd(), BOX2< Vec >::GetOrigin(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, HANDLE_ITEM, LIB_FIELD_T, LIB_PIN_T, LIB_SHAPE_T, LIB_SYMBOL_T, LIB_TEXT_T, LIGHTRED, ADVANCED_CFG::m_DrawBoundingBoxes, KIGFX::PAINTER::m_gal, SCH_BITMAP_T, SCH_BUS_BUS_ENTRY_T, SCH_BUS_WIRE_ENTRY_T, SCH_FIELD_T, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_JUNCTION_T, SCH_LABEL_T, SCH_LINE_T, SCH_MARKER_T, SCH_NO_CONNECT_T, SCH_SHEET_PIN_T, SCH_SHEET_T, SCH_SYMBOL_T, SCH_TEXT_T, KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetHorizontalJustify(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetVerticalJustify(), and KIGFX::GAL::StrokeText().

Referenced by draw().

draw() [1/17]

void KIGFX::SCH_PAINTER::draw ( LIB_PIN *  aPin, int  aLayer  )

private

Definition at line 756 of file sch_painter.cpp.

{
 if( !isUnitAndConversionShown( aPin ) )
 return;

 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;
 bool drawingDangling = aLayer == LAYER_DANGLING;
 bool isDangling = m_schSettings.m_IsSymbolEditor || aPin->HasFlag( IS_DANGLING );

 if( drawingShadows && !aPin->IsSelected() )
 return;

 VECTOR2I pos = mapCoords( aPin->GetPosition() );
 COLOR4D color = getRenderColor( aPin, LAYER_PIN, drawingShadows );

 if( !aPin->IsVisible() )
 {
 if( m_schSettings.m_ShowHiddenPins )
 {
 color = getRenderColor( aPin, LAYER_HIDDEN, drawingShadows );
 }
 else
 {
 if( drawingDangling && isDangling && aPin->IsPowerConnection() )
 drawPinDanglingSymbol( pos, color, drawingShadows );

 return;
 }
 }

 if( drawingDangling )
 {
 if( isDangling )
 drawPinDanglingSymbol( pos, color, drawingShadows );

 return;
 }

 VECTOR2I p0;
 VECTOR2I dir;
 int len = aPin->GetLength();
 int orient = aPin->GetOrientation();

 switch( orient )
 {
 case PIN_UP:
 p0 = VECTOR2I( pos.x, pos.y - len );
 dir = VECTOR2I( 0, 1 );
 break;

 case PIN_DOWN:
 p0 = VECTOR2I( pos.x, pos.y + len );
 dir = VECTOR2I( 0, -1 );
 break;

 case PIN_LEFT:
 p0 = VECTOR2I( pos.x - len, pos.y );
 dir = VECTOR2I( 1, 0 );
 break;

 default:
 case PIN_RIGHT:
 p0 = VECTOR2I( pos.x + len, pos.y );
 dir = VECTOR2I( -1, 0 );
 break;
 }

 VECTOR2D pc;

 m_gal->SetIsStroke( true );
 m_gal->SetIsFill( false );
 m_gal->SetLineWidth( getLineWidth( aPin, drawingShadows ) );
 m_gal->SetStrokeColor( color );
 m_gal->SetFontBold( false );
 m_gal->SetFontUnderlined( false );
 m_gal->SetFontItalic( false );

 const int radius = externalPinDecoSize( *aPin );
 const int diam = radius*2;
 const int clock_size = internalPinDecoSize( *aPin );

 if( aPin->GetType() == ELECTRICAL_PINTYPE::PT_NC ) // Draw a N.C. symbol
 {
 m_gal->DrawLine( p0, pos );

 m_gal->DrawLine( pos + VECTOR2D( -1, -1 ) * TARGET_PIN_RADIUS,
 pos + VECTOR2D( 1, 1 ) * TARGET_PIN_RADIUS );
 m_gal->DrawLine( pos + VECTOR2D( 1, -1 ) * TARGET_PIN_RADIUS ,
 pos + VECTOR2D( -1, 1 ) * TARGET_PIN_RADIUS );
 }
 else
 {
 switch( aPin->GetShape() )
 {
 case GRAPHIC_PINSHAPE::LINE:
 m_gal->DrawLine( p0, pos );
 break;

 case GRAPHIC_PINSHAPE::INVERTED:
 m_gal->DrawCircle( p0 + dir * radius, radius );
 m_gal->DrawLine( p0 + dir * ( diam ), pos );
 break;

 case GRAPHIC_PINSHAPE::INVERTED_CLOCK:
 pc = p0 - dir * clock_size ;

 triLine( p0 + VECTOR2D( dir.y, -dir.x) * clock_size,
 pc,
 p0 + VECTOR2D( -dir.y, dir.x) * clock_size );

 m_gal->DrawCircle( p0 + dir * radius, radius );
 m_gal->DrawLine( p0 + dir * ( diam ), pos );
 break;

 case GRAPHIC_PINSHAPE::CLOCK_LOW:
 case GRAPHIC_PINSHAPE::FALLING_EDGE_CLOCK:
 pc = p0 - dir * clock_size ;

 triLine( p0 + VECTOR2D( dir.y, -dir.x) * clock_size,
 pc,
 p0 + VECTOR2D( -dir.y, dir.x) * clock_size );

 if( !dir.y )
 {
 triLine( p0 + VECTOR2D(dir.x, 0) * diam,
 p0 + VECTOR2D(dir.x, -1) * diam,
 p0 );
 }
 else /* MapX1 = 0 */
 {
 triLine( p0 + VECTOR2D( 0, dir.y) * diam,
 p0 + VECTOR2D(-1, dir.y) * diam,
 p0 );
 }

 m_gal->DrawLine( p0, pos );
 break;

 case GRAPHIC_PINSHAPE::CLOCK:
 m_gal->DrawLine( p0, pos );

 if( !dir.y )
 {
 triLine( p0 + VECTOR2D( 0, clock_size ),
 p0 + VECTOR2D( -dir.x * clock_size, 0 ),
 p0 + VECTOR2D( 0, -clock_size ) );
 }
 else
 {
 triLine( p0 + VECTOR2D( clock_size, 0 ),
 p0 + VECTOR2D( 0, -dir.y * clock_size ),
 p0 + VECTOR2D( -clock_size, 0 ) );
 }
 break;

 case GRAPHIC_PINSHAPE::INPUT_LOW:
 m_gal->DrawLine( p0, pos );

 if( !dir.y )
 {
 triLine( p0 + VECTOR2D(dir.x, 0) * diam,
 p0 + VECTOR2D(dir.x, -1) * diam,
 p0 );
 }
 else /* MapX1 = 0 */
 {
 triLine( p0 + VECTOR2D( 0, dir.y) * diam,
 p0 + VECTOR2D(-1, dir.y) * diam,
 p0 );
 }
 break;

 case GRAPHIC_PINSHAPE::OUTPUT_LOW: // IEEE symbol "Active Low Output"
 m_gal->DrawLine( p0, pos );

 if( !dir.y ) // Horizontal pin
 m_gal->DrawLine( p0 - VECTOR2D( 0, diam ), p0 + VECTOR2D( dir.x, 0 ) * diam );
 else // Vertical pin
 m_gal->DrawLine( p0 - VECTOR2D( diam, 0 ), p0 + VECTOR2D( 0, dir.y ) * diam );
 break;

 case GRAPHIC_PINSHAPE::NONLOGIC: // NonLogic pin symbol
 m_gal->DrawLine( p0, pos );

 m_gal->DrawLine( p0 - VECTOR2D( dir.x + dir.y, dir.y - dir.x ) * radius,
 p0 + VECTOR2D( dir.x + dir.y, dir.y - dir.x ) * radius );
 m_gal->DrawLine( p0 - VECTOR2D( dir.x - dir.y, dir.x + dir.y ) * radius,
 p0 + VECTOR2D( dir.x - dir.y, dir.x + dir.y ) * radius );
 break;
 }
 }

 LIB_SYMBOL* libEntry = aPin->GetParent();

 // Draw the labels
 if( drawingShadows
 && ( libEntry->Type() == LIB_SYMBOL_T || libEntry->IsSelected() )
 && !eeconfig()->m_Selection.draw_selected_children )
 {
 return;
 }

 float penWidth = (float) m_schSettings.GetDefaultPenWidth();
 int textOffset = libEntry->GetPinNameOffset();
 float nameStrokeWidth = getLineWidth( aPin, drawingShadows );
 float numStrokeWidth = getLineWidth( aPin, drawingShadows );

 nameStrokeWidth = Clamp_Text_PenSize( nameStrokeWidth, aPin->GetNameTextSize(), false );
 numStrokeWidth = Clamp_Text_PenSize( numStrokeWidth, aPin->GetNumberTextSize(), false );

 int PIN_TEXT_MARGIN = KiROUND( 24 * m_schSettings.m_TextOffsetRatio );

 // Four locations around a pin where text can be drawn
 enum { INSIDE = 0, OUTSIDE, ABOVE, BELOW };
 int size[4] = { 0, 0, 0, 0 };
 float thickness[4] = { numStrokeWidth, numStrokeWidth, numStrokeWidth, numStrokeWidth };
 COLOR4D colour[4];
 wxString text[4];

 // TextOffset > 0 means pin NAMES on inside, pin NUMBERS above and nothing below
 if( textOffset )
 {
 size [INSIDE] = libEntry->ShowPinNames() ? aPin->GetNameTextSize() : 0;
 thickness[INSIDE] = nameStrokeWidth;
 colour [INSIDE] = getRenderColor( aPin, LAYER_PINNAM, drawingShadows );
 text [INSIDE] = aPin->GetShownName();

 size [ABOVE] = libEntry->ShowPinNumbers() ? aPin->GetNumberTextSize() : 0;
 thickness[ABOVE] = numStrokeWidth;
 colour [ABOVE] = getRenderColor( aPin, LAYER_PINNUM, drawingShadows );
 text [ABOVE] = aPin->GetShownNumber();
 }
 // Otherwise pin NAMES go above and pin NUMBERS go below
 else
 {
 size [ABOVE] = libEntry->ShowPinNames() ? aPin->GetNameTextSize() : 0;
 thickness[ABOVE] = nameStrokeWidth;
 colour [ABOVE] = getRenderColor( aPin, LAYER_PINNAM, drawingShadows );
 text [ABOVE] = aPin->GetShownName();

 size [BELOW] = libEntry->ShowPinNumbers() ? aPin->GetNumberTextSize() : 0;
 thickness[BELOW] = numStrokeWidth;
 colour [BELOW] = getRenderColor( aPin, LAYER_PINNUM, drawingShadows );
 text [BELOW] = aPin->GetShownNumber();
 }

 if( m_schSettings.m_ShowPinsElectricalType )
 {
 size [OUTSIDE] = std::max( aPin->GetNameTextSize() * 3 / 4, Millimeter2iu( 0.7 ) );
 thickness[OUTSIDE] = float( size[OUTSIDE] ) / 6.0F;
 colour [OUTSIDE] = getRenderColor( aPin, LAYER_NOTES, drawingShadows );
 text [OUTSIDE] = aPin->GetElectricalTypeName();
 }

 if( !aPin->IsVisible() )
 {
 for( COLOR4D& c : colour )
 c = getRenderColor( aPin, LAYER_HIDDEN, drawingShadows );
 }

 float insideOffset = textOffset - thickness[INSIDE] / 2.0;
 float outsideOffset = Mils2iu( PIN_TEXT_MARGIN ) + TARGET_PIN_RADIUS - thickness[OUTSIDE] / 2.0;
 float aboveOffset = Mils2iu( PIN_TEXT_MARGIN ) + penWidth / 2.0 + thickness[ABOVE] / 2.0;
 float belowOffset = Mils2iu( PIN_TEXT_MARGIN ) + penWidth / 2.0 + thickness[BELOW] / 2.0;

 if( isDangling )
 outsideOffset += TARGET_PIN_RADIUS / 2.0;

 if( drawingShadows )
 {
 float shadowWidth = getShadowWidth();

 if( eeconfig()->m_Selection.text_as_box )
 {
 insideOffset -= thickness[INSIDE] / 2.0;
 outsideOffset -= thickness[OUTSIDE] / 2.0;
 aboveOffset -= thickness[ABOVE] + penWidth;
 belowOffset -= thickness[BELOW] + penWidth;
 }

 for( float& t : thickness )
 t += shadowWidth;

 insideOffset -= shadowWidth / 2.0;
 outsideOffset -= shadowWidth / 2.0;
 }

 auto setupDC =
 [&]( int i )
 {
 m_gal->SetGlyphSize( VECTOR2D( size[i], size[i] ) );
 m_gal->SetIsStroke( !( drawingShadows && eeconfig()->m_Selection.text_as_box ) );
 m_gal->SetLineWidth( thickness[i] );
 m_gal->SetStrokeColor( colour[i] );
 m_gal->SetIsFill( drawingShadows && eeconfig()->m_Selection.text_as_box );
 m_gal->SetFillColor( colour[i] );
 };

 auto drawText =
 [&]( const wxString& aText, const VECTOR2D& aPos, double aAngle )
 {
 if( aText.IsEmpty() )
 return;

 if( drawingShadows && eeconfig()->m_Selection.text_as_box )
 boxText( aText, aPos, aAngle );
 else
 strokeText( aText, aPos, aAngle );
 };

 switch( orient )
 {
 case PIN_LEFT:
 if( size[INSIDE] )
 {
 setupDC( INSIDE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_RIGHT );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 drawText( text[INSIDE], pos + VECTOR2D( -insideOffset - len, 0 ), 0 );
 }
 if( size[OUTSIDE] )
 {
 setupDC( OUTSIDE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_LEFT );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 drawText( text[OUTSIDE], pos + VECTOR2D( outsideOffset, 0 ), 0 );
 }
 if( size[ABOVE] )
 {
 setupDC( ABOVE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_BOTTOM );
 drawText( text[ABOVE], pos + VECTOR2D( -len / 2.0, -aboveOffset ), 0 );
 }
 if( size[BELOW] )
 {
 setupDC( BELOW );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_TOP );
 drawText( text[BELOW], pos + VECTOR2D( -len / 2.0, belowOffset ), 0 );
 }
 break;

 case PIN_RIGHT:
 if( size[INSIDE] )
 {
 setupDC( INSIDE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_LEFT );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_LEFT );
 drawText( text[INSIDE], pos + VECTOR2D( insideOffset + len, 0 ), 0 );
 }
 if( size[OUTSIDE] )
 {
 setupDC( OUTSIDE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_RIGHT );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 drawText( text[OUTSIDE], pos + VECTOR2D( -outsideOffset, 0 ), 0 );
 }
 if( size[ABOVE] )
 {
 setupDC( ABOVE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_BOTTOM );
 drawText( text[ABOVE], pos + VECTOR2D( len / 2.0, -aboveOffset ), 0 );
 }
 if( size[BELOW] )
 {
 setupDC( BELOW );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_TOP );
 drawText( text[BELOW], pos + VECTOR2D( len / 2.0, belowOffset ), 0 );
 }
 break;

 case PIN_DOWN:
 if( size[INSIDE] )
 {
 setupDC( INSIDE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_RIGHT );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 drawText( text[INSIDE], pos + VECTOR2D( 0, insideOffset + len ), M_PI / 2 );
 }
 if( size[OUTSIDE] )
 {
 setupDC( OUTSIDE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_LEFT );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 drawText( text[OUTSIDE], pos + VECTOR2D( 0, -outsideOffset ), M_PI / 2 );
 }
 if( size[ABOVE] )
 {
 setupDC( ABOVE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_BOTTOM );
 drawText( text[ABOVE], pos + VECTOR2D( -aboveOffset, len / 2.0 ), M_PI / 2 );
 }
 if( size[BELOW] )
 {
 setupDC( BELOW );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_TOP );
 drawText( text[BELOW], pos + VECTOR2D( belowOffset, len / 2.0 ), M_PI / 2 );
 }
 break;

 case PIN_UP:
 if( size[INSIDE] )
 {
 setupDC( INSIDE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_LEFT );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 drawText( text[INSIDE], pos + VECTOR2D( 0, -insideOffset - len ), M_PI / 2 );
 }
 if( size[OUTSIDE] )
 {
 setupDC( OUTSIDE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_RIGHT );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 drawText( text[OUTSIDE], pos + VECTOR2D( 0, outsideOffset ), M_PI / 2 );
 }
 if( size[ABOVE] )
 {
 setupDC( ABOVE );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_BOTTOM );
 drawText( text[ABOVE], pos + VECTOR2D( -aboveOffset, -len / 2.0 ), M_PI / 2 );
 }
 if( size[BELOW] )
 {
 setupDC( BELOW );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_TOP );
 drawText( text[BELOW], pos + VECTOR2D( belowOffset, -len / 2.0 ), M_PI / 2 );
 }
 break;

 default:
 wxFAIL_MSG( wxT( "Unknown pin orientation" ) );
 }
}

References boxText(), Clamp_Text_PenSize(), CLOCK, CLOCK_LOW, color, EESCHEMA_SETTINGS::SELECTION::draw_selected_children, KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawLine(), drawPinDanglingSymbol(), KIGFX::eeconfig(), externalPinDecoSize(), FALLING_EDGE_CLOCK, KIGFX::RENDER_SETTINGS::GetDefaultPenWidth(), LIB_PIN::GetElectricalTypeName(), LIB_PIN::GetLength(), getLineWidth(), LIB_PIN::GetNameTextSize(), LIB_PIN::GetNumberTextSize(), LIB_PIN::GetOrientation(), LIB_ITEM::GetParent(), LIB_SYMBOL::GetPinNameOffset(), LIB_PIN::GetPosition(), getRenderColor(), getShadowWidth(), LIB_PIN::GetShape(), LIB_PIN::GetShownName(), LIB_PIN::GetShownNumber(), LIB_PIN::GetType(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP, EDA_ITEM::HasFlag(), INPUT_LOW, internalPinDecoSize(), INVERTED, INVERTED_CLOCK, IS_DANGLING, LIB_PIN::IsPowerConnection(), EDA_ITEM::IsSelected(), isUnitAndConversionShown(), LIB_PIN::IsVisible(), KiROUND(), LAYER_DANGLING, LAYER_HIDDEN, LAYER_NOTES, LAYER_PIN, LAYER_PINNAM, LAYER_PINNUM, LAYER_SELECTION_SHADOWS, LIB_SYMBOL_T, LINE, KIGFX::PAINTER::m_gal, KIGFX::SCH_RENDER_SETTINGS::m_IsSymbolEditor, m_schSettings, EESCHEMA_SETTINGS::m_Selection, KIGFX::SCH_RENDER_SETTINGS::m_ShowHiddenPins, KIGFX::SCH_RENDER_SETTINGS::m_ShowPinsElectricalType, KIGFX::SCH_RENDER_SETTINGS::m_TextOffsetRatio, KIGFX::mapCoords(), Millimeter2iu(), NONLOGIC, OUTPUT_LOW, OUTSIDE, PIN_DOWN, PIN_LEFT, PIN_RIGHT, PIN_TEXT_MARGIN, PIN_UP, PT_NC, KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetFontBold(), KIGFX::GAL::SetFontItalic(), KIGFX::GAL::SetFontUnderlined(), KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetHorizontalJustify(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetVerticalJustify(), LIB_SYMBOL::ShowPinNames(), LIB_SYMBOL::ShowPinNumbers(), strokeText(), TARGET_PIN_RADIUS, text, EESCHEMA_SETTINGS::SELECTION::text_as_box, triLine(), EDA_ITEM::Type(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by draw().

draw() [2/17]

void KIGFX::SCH_PAINTER::draw ( const LIB_SHAPE *  aCircle, int  aLayer  )

private

Definition at line 534 of file sch_painter.cpp.

{
 if( !isUnitAndConversionShown( aShape ) )
 return;

 if( setDeviceColors( aShape, aLayer ) )
 {
 if( aLayer == LAYER_SELECTION_SHADOWS && eeconfig()->m_Selection.fill_shapes )
 {
 // Consider a NAND gate. We have no idea which side of the arc is "inside" so
 // we can't reliably fill.

 if( aShape->GetShape() == SHAPE_T::ARC )
 m_gal->SetIsFill( aShape->IsFilled() );
 else
 m_gal->SetIsFill( true );
 }

 switch( aShape->GetShape() )
 {
 case SHAPE_T::ARC:
 {
 int startAngle;
 int endAngle;
 aShape->CalcArcAngles( startAngle, endAngle );

 TRANSFORM().MapAngles( &startAngle, &endAngle );

 m_gal->DrawArc( mapCoords( aShape->GetCenter() ), aShape->GetRadius(),
 DECIDEG2RAD( startAngle ), DECIDEG2RAD( endAngle ) );
 }
 break;

 case SHAPE_T::CIRCLE:
 m_gal->DrawCircle( mapCoords( aShape->GetPosition() ), aShape->GetRadius() );
 break;

 case SHAPE_T::RECT:
 m_gal->DrawRectangle( mapCoords( aShape->GetPosition() ),
 mapCoords( aShape->GetEnd() ) );
 break;

 case SHAPE_T::POLY:
 {
 const SHAPE_LINE_CHAIN poly = aShape->GetPolyShape().Outline( 0 );
 std::deque<VECTOR2D> mappedPts;

 for( const VECTOR2I& pt : poly.CPoints() )
 mappedPts.push_back( mapCoords( (wxPoint) pt ) );

 m_gal->DrawPolygon( mappedPts );
 }
 break;

 case SHAPE_T::BEZIER:
 {
 std::deque<VECTOR2D> mappedPts;

 for( const wxPoint& p : aShape->GetBezierPoints() )
 mappedPts.push_back( mapCoords( p ) );

 m_gal->DrawPolygon( mappedPts );
 }
 break;

 default:
 wxFAIL_MSG( wxT( "SCH_PAINTER::draw not implemented for " ) + aShape->SHAPE_T_asString() );
 }
 }
}

References ARC, BEZIER, LIB_SHAPE::CalcArcAngles(), CIRCLE, SHAPE_LINE_CHAIN::CPoints(), DECIDEG2RAD(), KIGFX::GAL::DrawArc(), KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawRectangle(), KIGFX::eeconfig(), EDA_SHAPE::GetBezierPoints(), LIB_SHAPE::GetCenter(), EDA_SHAPE::GetEnd(), EDA_SHAPE::GetPolyShape(), LIB_SHAPE::GetPosition(), EDA_SHAPE::GetRadius(), EDA_SHAPE::GetShape(), EDA_SHAPE::IsFilled(), isUnitAndConversionShown(), LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, TRANSFORM::MapAngles(), KIGFX::mapCoords(), SHAPE_POLY_SET::Outline(), POLY, RECT, setDeviceColors(), KIGFX::GAL::SetIsFill(), and EDA_SHAPE::SHAPE_T_asString().

draw() [3/17]

void KIGFX::SCH_PAINTER::draw ( const LIB_SYMBOL *  aSymbol, int  aLayer, bool  aDrawFields = true, int  aUnit = 0, int  aConvert = 0  )

private

Definition at line 446 of file sch_painter.cpp.

{
 if( !aUnit )
 aUnit = m_schSettings.m_ShowUnit;

 if( !aConvert )
 aConvert = m_schSettings.m_ShowConvert;

 std::unique_ptr< LIB_SYMBOL > tmpSymbol;
 const LIB_SYMBOL* drawnSymbol = aSymbol;

 if( aSymbol->IsAlias() )
 {
 tmpSymbol = aSymbol->Flatten();
 drawnSymbol = tmpSymbol.get();
 }

 for( const LIB_ITEM& item : drawnSymbol->GetDrawItems() )
 {
 if( !aDrawFields && item.Type() == LIB_FIELD_T )
 continue;

 if( aUnit && item.GetUnit() && aUnit != item.GetUnit() )
 continue;

 if( aConvert && item.GetConvert() && aConvert != item.GetConvert() )
 continue;

 Draw( &item, aLayer );
 }
}

References Draw(), LIB_SYMBOL::Flatten(), LIB_SYMBOL::GetDrawItems(), LIB_SYMBOL::IsAlias(), LIB_FIELD_T, m_schSettings, KIGFX::SCH_RENDER_SETTINGS::m_ShowConvert, and KIGFX::SCH_RENDER_SETTINGS::m_ShowUnit.

draw() [4/17]

void KIGFX::SCH_PAINTER::draw ( const LIB_FIELD *  aField, int  aLayer  )

private

Definition at line 606 of file sch_painter.cpp.

{
 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;

 if( drawingShadows && !aField->IsSelected() )
 return;

 if( !isUnitAndConversionShown( aField ) )
 return;

 // Must check layer as fields are sometimes drawn by their parent rather than
 // directly from the view.
 int layers[KIGFX::VIEW::VIEW_MAX_LAYERS];
 int layers_count;
 bool foundLayer = false;

 aField->ViewGetLayers( layers, layers_count );

 for( int i = 0; i < layers_count; ++i )
 {
 if( layers[i] == aLayer )
 foundLayer = true;
 }

 if( !foundLayer )
 return;

 COLOR4D color = getRenderColor( aField, aLayer, drawingShadows );

 if( !( aField->IsVisible() || aField->IsForceVisible() ) )
 {
 if( m_schSettings.m_ShowHiddenText )
 color = getRenderColor( aField, LAYER_HIDDEN, drawingShadows );
 else
 return;
 }

 m_gal->SetLineWidth( getTextThickness( aField, drawingShadows ) );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( color );

 EDA_RECT bbox = aField->GetBoundingBox();
 wxPoint textpos = bbox.Centre();

 if( drawingShadows && eeconfig()->m_Selection.text_as_box )
 {
 m_gal->SetIsFill( true );
 m_gal->SetFillColor( color );
 m_gal->SetLineWidth( m_gal->GetLineWidth() * 0.5 );
 bbox.RevertYAxis();

 m_gal->DrawRectangle( mapCoords( bbox.GetPosition() ), mapCoords( bbox.GetEnd() ) );
 }
 else
 {
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 m_gal->SetGlyphSize( VECTOR2D( aField->GetTextSize() ) );
 m_gal->SetFontItalic( aField->IsItalic() );

 strokeText( UnescapeString( aField->GetText() ), textpos, aField->GetTextAngleRadians() );
 }

 // Draw the umbilical line
 if( aField->IsMoving() && m_schSettings.m_ShowUmbilicals )
 {
 m_gal->SetLineWidth( m_schSettings.m_outlineWidth );
 m_gal->SetStrokeColor( getRenderColor( aField, LAYER_SCHEMATIC_ANCHOR, drawingShadows ) );
 m_gal->DrawLine( textpos, wxPoint( 0, 0 ) );
 }
}

References EDA_RECT::Centre(), color, KIGFX::GAL::DrawLine(), KIGFX::GAL::DrawRectangle(), KIGFX::eeconfig(), LIB_FIELD::GetBoundingBox(), EDA_RECT::GetEnd(), KIGFX::GAL::GetLineWidth(), EDA_RECT::GetPosition(), getRenderColor(), EDA_TEXT::GetText(), EDA_TEXT::GetTextAngleRadians(), EDA_TEXT::GetTextSize(), getTextThickness(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, EDA_ITEM::IsForceVisible(), EDA_TEXT::IsItalic(), EDA_ITEM::IsMoving(), EDA_ITEM::IsSelected(), isUnitAndConversionShown(), EDA_TEXT::IsVisible(), LAYER_HIDDEN, LAYER_SCHEMATIC_ANCHOR, LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, m_schSettings, KIGFX::SCH_RENDER_SETTINGS::m_ShowHiddenText, KIGFX::SCH_RENDER_SETTINGS::m_ShowUmbilicals, KIGFX::mapCoords(), EDA_RECT::RevertYAxis(), KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetFontItalic(), KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetHorizontalJustify(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetVerticalJustify(), strokeText(), UnescapeString(), KIGFX::VIEW::VIEW_MAX_LAYERS, and LIB_FIELD::ViewGetLayers().

draw() [5/17]

void KIGFX::SCH_PAINTER::draw ( const LIB_TEXT *  aText, int  aLayer  )

private

Definition at line 680 of file sch_painter.cpp.

{
 if( !isUnitAndConversionShown( aText ) )
 return;

 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;

 if( drawingShadows && !aText->IsSelected() )
 return;

 COLOR4D color = getRenderColor( aText, LAYER_DEVICE, drawingShadows );

 if( !aText->IsVisible() )
 {
 if( m_schSettings.m_ShowHiddenText )
 color = getRenderColor( aText, LAYER_HIDDEN, drawingShadows );
 else
 return;
 }

 EDA_RECT bBox = aText->GetBoundingBox();
 bBox.RevertYAxis();
 VECTOR2D pos = mapCoords( bBox.Centre() );
 double orient = aText->GetTextAngleRadians();

 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 m_gal->SetLineWidth( getTextThickness( aText, drawingShadows ) );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( color );
 m_gal->SetGlyphSize( VECTOR2D( aText->GetTextSize() ) );
 m_gal->SetFontBold( aText->IsBold() );
 m_gal->SetFontItalic( aText->IsItalic() );
 m_gal->SetFontUnderlined( false );
 strokeText( aText->GetText(), pos, orient );
}

References EDA_RECT::Centre(), color, LIB_TEXT::GetBoundingBox(), getRenderColor(), EDA_TEXT::GetText(), EDA_TEXT::GetTextAngleRadians(), EDA_TEXT::GetTextSize(), getTextThickness(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, EDA_TEXT::IsBold(), EDA_TEXT::IsItalic(), EDA_ITEM::IsSelected(), isUnitAndConversionShown(), EDA_TEXT::IsVisible(), LAYER_DEVICE, LAYER_HIDDEN, LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, m_schSettings, KIGFX::SCH_RENDER_SETTINGS::m_ShowHiddenText, KIGFX::mapCoords(), EDA_RECT::RevertYAxis(), KIGFX::GAL::SetFontBold(), KIGFX::GAL::SetFontItalic(), KIGFX::GAL::SetFontUnderlined(), KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetHorizontalJustify(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetVerticalJustify(), and strokeText().

draw() [6/17]

void KIGFX::SCH_PAINTER::draw ( SCH_SYMBOL *  aSymbol, int  aLayer  )

private

Definition at line 1469 of file sch_painter.cpp.

{
 int unit = aSymbol->GetUnitSelection( &m_schematic->CurrentSheet() );
 int convert = aSymbol->GetConvert();

 // Use dummy symbol if the actual couldn't be found (or couldn't be locked).
 LIB_SYMBOL* originalSymbol = aSymbol->GetLibSymbolRef() ?
 aSymbol->GetLibSymbolRef().get() : dummy();
 LIB_PINS originalPins;
 originalSymbol->GetPins( originalPins, unit, convert );

 // Copy the source so we can re-orient and translate it.
 LIB_SYMBOL tempSymbol( *originalSymbol );
 LIB_PINS tempPins;
 tempSymbol.GetPins( tempPins, unit, convert );

 tempSymbol.SetFlags( aSymbol->GetFlags() );

 orientSymbol( &tempSymbol, aSymbol->GetOrientation() );

 for( auto& tempItem : tempSymbol.GetDrawItems() )
 {
 tempItem.SetFlags( aSymbol->GetFlags() ); // SELECTED, HIGHLIGHTED, BRIGHTENED
 tempItem.MoveTo( tempItem.GetPosition() + (wxPoint) mapCoords( aSymbol->GetPosition() ) );
 }

 // Copy the pin info from the symbol to the temp pins
 for( unsigned i = 0; i < tempPins.size(); ++ i )
 {
 SCH_PIN* symbolPin = aSymbol->GetPin( originalPins[ i ] );
 LIB_PIN* tempPin = tempPins[ i ];

 tempPin->ClearFlags();
 tempPin->SetFlags( symbolPin->GetFlags() ); // SELECTED, HIGHLIGHTED, BRIGHTENED

 tempPin->SetName( symbolPin->GetShownName() );
 tempPin->SetType( symbolPin->GetType() );
 tempPin->SetShape( symbolPin->GetShape() );

 if( symbolPin->IsDangling() )
 tempPin->SetFlags( IS_DANGLING );
 }

 draw( &tempSymbol, aLayer, false, aSymbol->GetUnit(), aSymbol->GetConvert() );

 // The fields are SCH_SYMBOL-specific so don't need to be copied/oriented/translated
 for( const SCH_FIELD& field : aSymbol->GetFields() )
 draw( &field, aLayer );
}

References EDA_ITEM::ClearFlags(), convert, SCHEMATIC::CurrentSheet(), draw(), KIGFX::dummy(), SCH_SYMBOL::GetConvert(), LIB_SYMBOL::GetDrawItems(), SCH_SYMBOL::GetFields(), EDA_ITEM::GetFlags(), SCH_SYMBOL::GetLibSymbolRef(), SCH_SYMBOL::GetOrientation(), SCH_SYMBOL::GetPin(), LIB_SYMBOL::GetPins(), SCH_SYMBOL::GetPosition(), SCH_PIN::GetShape(), SCH_PIN::GetShownName(), SCH_PIN::GetType(), SCH_SYMBOL::GetUnit(), SCH_SYMBOL::GetUnitSelection(), IS_DANGLING, SCH_PIN::IsDangling(), m_schematic, KIGFX::mapCoords(), KIGFX::orientSymbol(), EDA_ITEM::SetFlags(), LIB_PIN::SetName(), LIB_PIN::SetShape(), and LIB_PIN::SetType().

draw() [7/17]

void KIGFX::SCH_PAINTER::draw ( const SCH_JUNCTION *  aJct, int  aLayer  )

private

Definition at line 1219 of file sch_painter.cpp.

{
 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;

 if( drawingShadows && !aJct->IsSelected() )
 return;

 COLOR4D color = getRenderColor( aJct, aJct->GetLayer(), drawingShadows );

 int junctionSize = aJct->GetEffectiveDiameter() / 2;

 if( junctionSize > 1 )
 {
 m_gal->SetIsStroke( drawingShadows );
 m_gal->SetLineWidth( getLineWidth( aJct, drawingShadows ) );
 m_gal->SetStrokeColor( color );
 m_gal->SetIsFill( !drawingShadows );
 m_gal->SetFillColor( color );
 m_gal->DrawCircle( aJct->GetPosition(), junctionSize );
 }
}

References color, KIGFX::GAL::DrawCircle(), SCH_JUNCTION::GetEffectiveDiameter(), SCH_ITEM::GetLayer(), getLineWidth(), SCH_JUNCTION::GetPosition(), getRenderColor(), EDA_ITEM::IsSelected(), LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

draw() [8/17]

void KIGFX::SCH_PAINTER::draw ( const SCH_FIELD *  aField, int  aLayer  )

private

Definition at line 1520 of file sch_painter.cpp.

{
 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;

 if( drawingShadows && !aField->IsSelected() )
 return;

 aLayer = aField->GetLayer();

 COLOR4D color = getRenderColor( aField, aLayer, drawingShadows );

 if( !( aField->IsVisible() || aField->IsForceVisible() ) )
 {
 if( m_schSettings.m_ShowHiddenText )
 color = getRenderColor( aField, LAYER_HIDDEN, drawingShadows );
 else
 return;
 }

 if( aField->IsVoid() )
 return;

 if( drawingShadows && aField->GetParent()->IsSelected()
 && !eeconfig()->m_Selection.draw_selected_children )
 {
 return;
 }

 bool underline = false;

 if( aField->IsHypertext() && ( aField->GetFlags() & IS_ROLLOVER ) > 0
 && !drawingShadows && !aField->IsMoving() )
 {
 color = PUREBLUE;
 underline = true;
 }

 // Calculate the text orientation according to the parent orientation.
 int orient = (int) aField->GetTextAngle();

 if( aField->GetParent() && aField->GetParent()->Type() == SCH_SYMBOL_T )
 {
 if( static_cast<SCH_SYMBOL*>( aField->GetParent() )->GetTransform().y1 )
 {
 // Rotate symbol 90 degrees.
 if( orient == TEXT_ANGLE_HORIZ )
 orient = TEXT_ANGLE_VERT;
 else
 orient = TEXT_ANGLE_HORIZ;
 }
 }

 /*
 * Calculate the text justification, according to the symbol 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 symbol is mirrored, the text is not mirrored and justifications are complicated
 * to calculate so the easier way is to use no justifications (centered text) and use
 * GetBoundingBox to know the text coordinate considered as centered
 */
 EDA_RECT bbox = aField->GetBoundingBox();
 wxPoint textpos = bbox.Centre();

 m_gal->SetStrokeColor( color );
 m_gal->SetIsStroke( true );

 if( drawingShadows && eeconfig()->m_Selection.text_as_box )
 {
 m_gal->SetIsFill( true );
 m_gal->SetFillColor( color );
 m_gal->SetLineWidth( m_gal->GetLineWidth() * 0.5 );
 bbox.RevertYAxis();

 m_gal->DrawRectangle( mapCoords( bbox.GetPosition() ), mapCoords( bbox.GetEnd() ) );
 }
 else
 {
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 m_gal->SetIsFill( false );
 m_gal->SetGlyphSize( VECTOR2D( aField->GetTextSize() ) );
 m_gal->SetFontBold( aField->IsBold() );
 m_gal->SetFontItalic( aField->IsItalic() );
 m_gal->SetFontUnderlined( underline );
 m_gal->SetTextMirrored( aField->IsMirrored() );
 m_gal->SetLineWidth( getTextThickness( aField, drawingShadows ) );

 strokeText( aField->GetShownText(), textpos, orient == TEXT_ANGLE_VERT ? M_PI / 2 : 0 );
 }

 // Draw the umbilical line
 if( aField->IsMoving() )
 {
 wxPoint parentPos = aField->GetParentPosition();

 m_gal->SetLineWidth( m_schSettings.m_outlineWidth );
 m_gal->SetStrokeColor( getRenderColor( aField, LAYER_SCHEMATIC_ANCHOR, drawingShadows ) );
 m_gal->DrawLine( textpos, parentPos );
 }
}

References EDA_RECT::Centre(), color, EESCHEMA_SETTINGS::SELECTION::draw_selected_children, KIGFX::GAL::DrawLine(), KIGFX::GAL::DrawRectangle(), KIGFX::eeconfig(), SCH_FIELD::GetBoundingBox(), EDA_RECT::GetEnd(), EDA_ITEM::GetFlags(), SCH_ITEM::GetLayer(), KIGFX::GAL::GetLineWidth(), EDA_ITEM::GetParent(), SCH_FIELD::GetParentPosition(), EDA_RECT::GetPosition(), getRenderColor(), SCH_FIELD::GetShownText(), EDA_TEXT::GetTextAngle(), EDA_TEXT::GetTextSize(), getTextThickness(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, IS_ROLLOVER, EDA_TEXT::IsBold(), EDA_ITEM::IsForceVisible(), SCH_FIELD::IsHypertext(), EDA_TEXT::IsItalic(), EDA_TEXT::IsMirrored(), EDA_ITEM::IsMoving(), EDA_ITEM::IsSelected(), EDA_TEXT::IsVisible(), SCH_FIELD::IsVoid(), LAYER_HIDDEN, LAYER_SCHEMATIC_ANCHOR, LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, m_schSettings, EESCHEMA_SETTINGS::m_Selection, KIGFX::SCH_RENDER_SETTINGS::m_ShowHiddenText, KIGFX::mapCoords(), PUREBLUE, EDA_RECT::RevertYAxis(), SCH_SYMBOL_T, KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetFontBold(), KIGFX::GAL::SetFontItalic(), KIGFX::GAL::SetFontUnderlined(), KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetHorizontalJustify(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextMirrored(), KIGFX::GAL::SetVerticalJustify(), strokeText(), TEXT_ANGLE_HORIZ, TEXT_ANGLE_VERT, and EDA_ITEM::Type().

draw() [9/17]

void KIGFX::SCH_PAINTER::draw ( const SCH_TEXT *  aText, int  aLayer  )

private

Definition at line 1328 of file sch_painter.cpp.

{
 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;
 bool drawingDangling = aLayer == LAYER_DANGLING;

 if( drawingShadows && !aText->IsSelected() )
 return;

 switch( aText->Type() )
 {
 case SCH_SHEET_PIN_T: aLayer = LAYER_SHEETLABEL; break;
 case SCH_HIER_LABEL_T: aLayer = LAYER_HIERLABEL; break;
 case SCH_GLOBAL_LABEL_T: aLayer = LAYER_GLOBLABEL; break;
 case SCH_LABEL_T: aLayer = LAYER_LOCLABEL; break;
 default: aLayer = LAYER_NOTES; break;
 }

 COLOR4D color = getRenderColor( aText, aLayer, drawingShadows );

 if( m_schematic )
 {
 SCH_CONNECTION* conn = nullptr;

 if( !aText->IsConnectivityDirty() )
 conn = aText->Connection();

 if( conn && conn->IsBus() )
 color = getRenderColor( aText, LAYER_BUS, drawingShadows );
 }

 if( !( aText->IsVisible() || aText->IsForceVisible() ) )
 {
 if( m_schSettings.m_ShowHiddenText )
 color = getRenderColor( aText, LAYER_HIDDEN, drawingShadows );
 else
 return;
 }

 if( drawingDangling )
 {
 if( aText->IsDangling() )
 {
 drawDanglingSymbol( aText->GetTextPos(), color, Mils2iu( DANGLING_SYMBOL_SIZE / 2 ),
 drawingShadows );
 }

 return;
 }

 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( getTextThickness( aText, drawingShadows ) );
 m_gal->SetStrokeColor( color );

 VECTOR2D text_offset = aText->GetTextPos() + aText->GetSchematicTextOffset( &m_schSettings );
 wxString shownText( aText->GetShownText() );

 if( drawingShadows )
 {
 if( eeconfig()->m_Selection.text_as_box )
 {
 EDA_RECT bBox = aText->GetBoundingBox();

 m_gal->SetIsFill( true );
 m_gal->SetFillColor( color );
 m_gal->SetLineWidth( m_gal->GetLineWidth() * 0.5 );
 bBox.RevertYAxis();

 m_gal->DrawRectangle( mapCoords( bBox.GetPosition() ), mapCoords( bBox.GetEnd() ) );
 return;
 }

 switch( aText->GetLabelSpinStyle() )
 {
 case LABEL_SPIN_STYLE::LEFT: text_offset.x += getShadowWidth() / 2; break;
 case LABEL_SPIN_STYLE::UP: text_offset.y += getShadowWidth() / 2; break;
 case LABEL_SPIN_STYLE::RIGHT: text_offset.x -= getShadowWidth() / 2; break;
 case LABEL_SPIN_STYLE::BOTTOM: text_offset.y -= getShadowWidth() / 2; break;
 }
 }

 if( !shownText.IsEmpty() )
 {
 m_gal->SetTextAttributes( aText );
 m_gal->SetFontUnderlined( false );

 strokeText( shownText, text_offset, aText->GetTextAngleRadians() );
 }
}

References LABEL_SPIN_STYLE::BOTTOM, color, SCH_ITEM::Connection(), DANGLING_SYMBOL_SIZE, drawDanglingSymbol(), KIGFX::GAL::DrawRectangle(), KIGFX::eeconfig(), SCH_TEXT::GetBoundingBox(), EDA_RECT::GetEnd(), SCH_TEXT::GetLabelSpinStyle(), KIGFX::GAL::GetLineWidth(), EDA_RECT::GetPosition(), getRenderColor(), SCH_TEXT::GetSchematicTextOffset(), getShadowWidth(), SCH_TEXT::GetShownText(), EDA_TEXT::GetTextAngleRadians(), EDA_TEXT::GetTextPos(), getTextThickness(), SCH_CONNECTION::IsBus(), SCH_ITEM::IsConnectivityDirty(), SCH_TEXT::IsDangling(), EDA_ITEM::IsForceVisible(), EDA_ITEM::IsSelected(), EDA_TEXT::IsVisible(), LAYER_BUS, LAYER_DANGLING, LAYER_GLOBLABEL, LAYER_HIDDEN, LAYER_HIERLABEL, LAYER_LOCLABEL, LAYER_NOTES, LAYER_SELECTION_SHADOWS, LAYER_SHEETLABEL, LABEL_SPIN_STYLE::LEFT, KIGFX::PAINTER::m_gal, m_schematic, m_schSettings, EESCHEMA_SETTINGS::m_Selection, KIGFX::SCH_RENDER_SETTINGS::m_ShowHiddenText, KIGFX::mapCoords(), EDA_RECT::RevertYAxis(), LABEL_SPIN_STYLE::RIGHT, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_LABEL_T, SCH_SHEET_PIN_T, KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetFontUnderlined(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextAttributes(), strokeText(), EESCHEMA_SETTINGS::SELECTION::text_as_box, EDA_ITEM::Type(), LABEL_SPIN_STYLE::UP, VECTOR2< T >::x, and VECTOR2< T >::y.

draw() [10/17]

void KIGFX::SCH_PAINTER::draw ( SCH_HIERLABEL *  aLabel, int  aLayer  )

private

Definition at line 1663 of file sch_painter.cpp.

{
 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;

 if( drawingShadows && !aLabel->IsSelected() )
 return;

 COLOR4D color = getRenderColor( aLabel, LAYER_HIERLABEL, drawingShadows );

 if( m_schematic )
 {
 SCH_CONNECTION* conn = nullptr;

 if( !aLabel->IsConnectivityDirty() )
 conn = aLabel->Connection();

 if( conn && conn->IsBus() )
 color = getRenderColor( aLabel, LAYER_BUS, drawingShadows );
 }

 std::vector<wxPoint> pts;
 std::deque<VECTOR2D> pts2;

 aLabel->CreateGraphicShape( &m_schSettings, pts, aLabel->GetTextPos() );

 for( const wxPoint& p : pts )
 pts2.emplace_back( VECTOR2D( p.x, p.y ) );

 m_gal->SetIsFill( true );
 m_gal->SetFillColor( m_schSettings.GetLayerColor( LAYER_SCHEMATIC_BACKGROUND ) );
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( getTextThickness( aLabel, drawingShadows ) );
 m_gal->SetStrokeColor( color );
 m_gal->DrawPolyline( pts2 );

 draw( static_cast<const SCH_TEXT*>( aLabel ), aLayer );
}

References color, SCH_ITEM::Connection(), SCH_HIERLABEL::CreateGraphicShape(), draw(), KIGFX::GAL::DrawPolyline(), KIGFX::RENDER_SETTINGS::GetLayerColor(), getRenderColor(), EDA_TEXT::GetTextPos(), getTextThickness(), SCH_CONNECTION::IsBus(), SCH_ITEM::IsConnectivityDirty(), EDA_ITEM::IsSelected(), LAYER_BUS, LAYER_HIERLABEL, LAYER_SCHEMATIC_BACKGROUND, LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, m_schematic, m_schSettings, KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

draw() [11/17]

void KIGFX::SCH_PAINTER::draw ( SCH_GLOBALLABEL *  aLabel, int  aLayer  )

private

Definition at line 1624 of file sch_painter.cpp.

{
 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;

 if( !drawingShadows || aLabel->IsSelected() )
 {
 COLOR4D color = getRenderColor( aLabel, LAYER_GLOBLABEL, drawingShadows );

 std::vector<wxPoint> pts;
 std::deque<VECTOR2D> pts2;

 aLabel->CreateGraphicShape( &m_schSettings, pts, aLabel->GetTextPos() );

 for( const wxPoint& p : pts )
 pts2.emplace_back( VECTOR2D( p.x, p.y ) );

 // The text is drawn inside the graphic shape.
 // On Cairo the graphic shape is filled by the background before drawing the text.
 // However if the text is selected, it is draw twice: first on LAYER_SELECTION_SHADOWS
 // and second on the text layer. The second must not erase the first drawing.
 bool fillBg = ( ( aLayer == LAYER_SELECTION_SHADOWS ) || !aLabel->IsSelected() )
 && aLayer != LAYER_DANGLING;
 m_gal->SetIsFill( fillBg );
 m_gal->SetFillColor( m_schSettings.GetLayerColor( LAYER_SCHEMATIC_BACKGROUND ) );
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( getTextThickness( aLabel, drawingShadows ) );
 m_gal->SetStrokeColor( color );
 m_gal->DrawPolyline( pts2 );

 draw( static_cast<SCH_TEXT*>( aLabel ), aLayer );
 }

 if( !drawingShadows || eeconfig()->m_Selection.draw_selected_children || !aLabel->IsSelected() )
 {
 draw( aLabel->GetIntersheetRefs(), aLayer );
 }
}

References color, SCH_GLOBALLABEL::CreateGraphicShape(), draw(), KIGFX::GAL::DrawPolyline(), KIGFX::eeconfig(), SCH_GLOBALLABEL::GetIntersheetRefs(), KIGFX::RENDER_SETTINGS::GetLayerColor(), getRenderColor(), EDA_TEXT::GetTextPos(), getTextThickness(), EDA_ITEM::IsSelected(), LAYER_DANGLING, LAYER_GLOBLABEL, LAYER_SCHEMATIC_BACKGROUND, LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, m_schSettings, KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

draw() [12/17]

void KIGFX::SCH_PAINTER::draw ( const SCH_SHEET *  aSheet, int  aLayer  )

private

Definition at line 1702 of file sch_painter.cpp.

{
 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;

 if( aLayer == LAYER_HIERLABEL || aLayer == LAYER_SELECTION_SHADOWS )
 {
 for( SCH_SHEET_PIN* sheetPin : aSheet->GetPins() )
 {
 if( drawingShadows && !aSheet->IsSelected() && !sheetPin->IsSelected() )
 continue;

 if( drawingShadows && aSheet->IsSelected()
 && !eeconfig()->m_Selection.draw_selected_children )
 {
 break;
 }

 int width = std::max( aSheet->GetPenWidth(), m_schSettings.GetDefaultPenWidth() );
 wxPoint initial_pos = sheetPin->GetTextPos();
 wxPoint offset_pos = initial_pos;

 // For aesthetic reasons, the SHEET_PIN is drawn with a small offset of width / 2
 switch( sheetPin->GetSide() )
 {
 case SHEET_SIDE::TOP: offset_pos.y += KiROUND( width / 2.0 ); break;
 case SHEET_SIDE::BOTTOM: offset_pos.y -= KiROUND( width / 2.0 ); break;
 case SHEET_SIDE::RIGHT: offset_pos.x -= KiROUND( width / 2.0 ); break;
 case SHEET_SIDE::LEFT: offset_pos.x += KiROUND( width / 2.0 ); break;
 default: break;
 }

 sheetPin->SetTextPos( offset_pos );
 draw( static_cast<SCH_HIERLABEL*>( sheetPin ), aLayer );
 m_gal->DrawLine( offset_pos, initial_pos );
 sheetPin->SetTextPos( initial_pos );
 }
 }

 VECTOR2D pos = aSheet->GetPosition();
 VECTOR2D size = aSheet->GetSize();

 if( aLayer == LAYER_SHEET_BACKGROUND )
 {
 m_gal->SetFillColor( getRenderColor( aSheet, LAYER_SHEET_BACKGROUND, true ) );
 m_gal->SetIsFill( true );
 m_gal->SetIsStroke( false );

 m_gal->DrawRectangle( pos, pos + size );
 }

 if( aLayer == LAYER_SHEET || aLayer == LAYER_SELECTION_SHADOWS )
 {
 m_gal->SetStrokeColor( getRenderColor( aSheet, LAYER_SHEET, drawingShadows ) );
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( getLineWidth( aSheet, drawingShadows ) );
 m_gal->SetIsFill( false );

 m_gal->DrawRectangle( pos, pos + size );

 if( drawingShadows && !eeconfig()->m_Selection.draw_selected_children && aSheet->IsSelected() )
 return;

 for( const SCH_FIELD& field : aSheet->GetFields() )
 draw( &field, aLayer );
 }
}

References BOTTOM, draw(), EESCHEMA_SETTINGS::SELECTION::draw_selected_children, KIGFX::GAL::DrawLine(), KIGFX::GAL::DrawRectangle(), KIGFX::eeconfig(), KIGFX::RENDER_SETTINGS::GetDefaultPenWidth(), SCH_SHEET::GetFields(), getLineWidth(), SCH_SHEET::GetPenWidth(), SCH_SHEET::GetPins(), SCH_SHEET::GetPosition(), getRenderColor(), SCH_SHEET::GetSize(), EDA_ITEM::IsSelected(), KiROUND(), LAYER_HIERLABEL, LAYER_SELECTION_SHADOWS, LAYER_SHEET, LAYER_SHEET_BACKGROUND, LEFT, KIGFX::PAINTER::m_gal, m_schSettings, EESCHEMA_SETTINGS::m_Selection, RIGHT, KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), and TOP.

draw() [13/17]

void KIGFX::SCH_PAINTER::draw ( const SCH_NO_CONNECT *  aNC, int  aLayer  )

private

Definition at line 1770 of file sch_painter.cpp.

{
 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;

 if( drawingShadows && !aNC->IsSelected() )
 return;

 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( getLineWidth( aNC, drawingShadows ) );
 m_gal->SetStrokeColor( getRenderColor( aNC, LAYER_NOCONNECT, drawingShadows ) );
 m_gal->SetIsFill( false );

 VECTOR2D p = aNC->GetPosition();
 int delta = std::max( aNC->GetSize(), m_schSettings.GetDefaultPenWidth() * 3 ) / 2;

 m_gal->DrawLine( p + VECTOR2D( -delta, -delta ), p + VECTOR2D( delta, delta ) );
 m_gal->DrawLine( p + VECTOR2D( -delta, delta ), p + VECTOR2D( delta, -delta ) );
}

References delta, KIGFX::GAL::DrawLine(), KIGFX::RENDER_SETTINGS::GetDefaultPenWidth(), getLineWidth(), SCH_NO_CONNECT::GetPosition(), getRenderColor(), SCH_NO_CONNECT::GetSize(), EDA_ITEM::IsSelected(), LAYER_NOCONNECT, LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, m_schSettings, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

draw() [14/17]

void KIGFX::SCH_PAINTER::draw ( const SCH_MARKER *  aMarker, int  aLayer  )

private

Definition at line 1889 of file sch_painter.cpp.

{
 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;

 if( drawingShadows && !aMarker->IsSelected() )
 return;

 COLOR4D color = getRenderColor( aMarker, aMarker->GetColorLayer(), drawingShadows );

 m_gal->Save();
 m_gal->Translate( aMarker->GetPosition() );
 m_gal->SetIsFill( !drawingShadows );
 m_gal->SetFillColor( color );
 m_gal->SetIsStroke( drawingShadows );
 m_gal->SetLineWidth( getLineWidth( aMarker, drawingShadows ) );
 m_gal->SetStrokeColor( color );

 SHAPE_LINE_CHAIN polygon;
 aMarker->ShapeToPolygon( polygon );

 m_gal->DrawPolygon( polygon );
 m_gal->Restore();
}

References color, KIGFX::GAL::DrawPolygon(), SCH_MARKER::GetColorLayer(), getLineWidth(), SCH_MARKER::GetPosition(), getRenderColor(), EDA_ITEM::IsSelected(), LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, KIGFX::GAL::Restore(), KIGFX::GAL::Save(), KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), MARKER_BASE::ShapeToPolygon(), and KIGFX::GAL::Translate().

draw() [15/17]

void KIGFX::SCH_PAINTER::draw ( const SCH_BITMAP *  aBitmap, int  aLayer  )

private

Definition at line 1844 of file sch_painter.cpp.

{
 m_gal->Save();
 m_gal->Translate( aBitmap->GetPosition() );

 // When the image scale factor is not 1.0, we need to modify the actual as the image scale
 // factor is similar to a local zoom
 double img_scale = aBitmap->GetImageScale();

 if( img_scale != 1.0 )
 m_gal->Scale( VECTOR2D( img_scale, img_scale ) );

 if( aLayer == LAYER_DRAW_BITMAPS )
 {
 m_gal->DrawBitmap( *aBitmap->GetImage() );
 }

 if( aLayer == LAYER_SELECTION_SHADOWS )
 {
 if( aBitmap->IsSelected() || aBitmap->IsBrightened() )
 {
 COLOR4D color = getRenderColor( aBitmap, LAYER_DRAW_BITMAPS, true );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( color );
 m_gal->SetLineWidth ( getShadowWidth() );
 m_gal->SetIsFill( false );

 // Draws a bounding box.
 VECTOR2D bm_size( aBitmap->GetSize() );
 // bm_size is the actual image size in UI.
 // but m_gal scale was previously set to img_scale
 // so recalculate size relative to this image size.
 bm_size.x /= img_scale;
 bm_size.y /= img_scale;
 VECTOR2D origin( -bm_size.x / 2.0, -bm_size.y / 2.0 );
 VECTOR2D end = origin + bm_size;

 m_gal->DrawRectangle( origin, end );
 }
 }

 m_gal->Restore();
}

References color, KIGFX::GAL::DrawBitmap(), KIGFX::GAL::DrawRectangle(), SCH_BITMAP::GetImage(), SCH_BITMAP::GetImageScale(), SCH_BITMAP::GetPosition(), getRenderColor(), getShadowWidth(), SCH_BITMAP::GetSize(), EDA_ITEM::IsBrightened(), EDA_ITEM::IsSelected(), LAYER_DRAW_BITMAPS, LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, KIGFX::GAL::Restore(), KIGFX::GAL::Save(), KIGFX::GAL::Scale(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::Translate(), and VECTOR2< T >::x.

draw() [16/17]

void KIGFX::SCH_PAINTER::draw ( const SCH_LINE *  aLine, int  aLayer  )

private

Definition at line 1242 of file sch_painter.cpp.

{
 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;
 bool drawingDangling = aLayer == LAYER_DANGLING;

 if( drawingShadows && !aLine->IsSelected() )
 return;

 COLOR4D color = getRenderColor( aLine, aLine->GetLayer(), drawingShadows );
 float width = getLineWidth( aLine, drawingShadows );
 PLOT_DASH_TYPE lineStyle = aLine->GetEffectiveLineStyle();

 if( drawingDangling || drawingShadows )
 {
 if( aLine->IsStartDangling() && aLine->IsWire() )
 {
 drawDanglingSymbol( aLine->GetStartPoint(), color,
 getLineWidth( aLine, drawingShadows ), drawingShadows );
 }

 if( aLine->IsEndDangling() && aLine->IsWire() )
 {
 drawDanglingSymbol( aLine->GetEndPoint(), color,
 getLineWidth( aLine, drawingShadows ), drawingShadows );
 }

 if( drawingDangling )
 return;
 }

 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( color );
 m_gal->SetLineWidth( width );

 if( lineStyle <= PLOT_DASH_TYPE::FIRST_TYPE || drawingShadows )
 {
 m_gal->DrawLine( aLine->GetStartPoint(), aLine->GetEndPoint() );
 }
 else
 {
 VECTOR2D start = aLine->GetStartPoint();
 VECTOR2D end = aLine->GetEndPoint();

 EDA_RECT clip( (wxPoint)start, wxSize( end.x - start.x, end.y - start.y ) );
 clip.Normalize();

 double theta = atan2( end.y - start.y, end.x - start.x );
 double strokes[] = { 1.0, dash_gap_len( width ), 1.0, dash_gap_len( width ) };

 switch( lineStyle )
 {
 default:
 case PLOT_DASH_TYPE::DASH:
 strokes[0] = strokes[2] = dash_mark_len( width );
 break;
 case PLOT_DASH_TYPE::DOT:
 strokes[0] = strokes[2] = dot_mark_len( width );
 break;
 case PLOT_DASH_TYPE::DASHDOT:
 strokes[0] = dash_mark_len( width );
 strokes[2] = dot_mark_len( width );
 break;
 }

 for( size_t i = 0; i < 10000; ++i )
 {
 // Calculations MUST be done in doubles to keep from accumulating rounding
 // errors as we go.
 VECTOR2D next( start.x + strokes[ i % 4 ] * cos( theta ),
 start.y + strokes[ i % 4 ] * sin( theta ) );

 // Drawing each segment can be done rounded to ints.
 wxPoint segStart( KiROUND( start.x ), KiROUND( start.y ) );
 wxPoint segEnd( KiROUND( next.x ), KiROUND( next.y ) );

 if( ClipLine( &clip, segStart.x, segStart.y, segEnd.x, segEnd.y ) )
 break;
 else if( i % 2 == 0 )
 m_gal->DrawLine( segStart, segEnd );

 start = next;
 }
 }
}

References ClipLine(), color, DASH, dash_gap_len(), dash_mark_len(), DASHDOT, DOT, dot_mark_len(), drawDanglingSymbol(), KIGFX::GAL::DrawLine(), FIRST_TYPE, SCH_LINE::GetEffectiveLineStyle(), SCH_LINE::GetEndPoint(), SCH_ITEM::GetLayer(), getLineWidth(), getRenderColor(), SCH_LINE::GetStartPoint(), SCH_LINE::IsEndDangling(), EDA_ITEM::IsSelected(), SCH_LINE::IsStartDangling(), SCH_LINE::IsWire(), KiROUND(), LAYER_DANGLING, LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, next(), EDA_RECT::Normalize(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), VECTOR2< T >::x, and VECTOR2< T >::y.

draw() [17/17]

void KIGFX::SCH_PAINTER::draw ( const SCH_BUS_ENTRY_BASE *  aEntry, int  aLayer  )

private

Definition at line 1790 of file sch_painter.cpp.

{
 SCH_LAYER_ID layer = aEntry->Type() == SCH_BUS_WIRE_ENTRY_T ? LAYER_WIRE : LAYER_BUS;
 SCH_LINE line( wxPoint(), layer );
 bool drawingShadows = aLayer == LAYER_SELECTION_SHADOWS;
 bool drawingDangling = aLayer == LAYER_DANGLING;

 if( drawingShadows && !aEntry->IsSelected() )
 return;

 if( aEntry->IsSelected() )
 line.SetSelected();
 else if( aEntry->IsBrightened() )
 line.SetBrightened();

 line.SetStartPoint( aEntry->GetPosition() );
 line.SetEndPoint( aEntry->GetEnd() );
 line.SetStroke( aEntry->GetStroke() );
 line.SetLineWidth( getLineWidth( aEntry, drawingShadows ) );

 COLOR4D color = getRenderColor( aEntry, LAYER_WIRE, drawingShadows );

 if( aEntry->Type() == SCH_BUS_BUS_ENTRY_T )
 color = getRenderColor( aEntry, LAYER_BUS, drawingShadows );

 if( drawingDangling )
 {
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( color.Brightened( 0.3 ) );
 m_gal->SetLineWidth( m_schSettings.GetDanglineSymbolThickness() );

 if( aEntry->IsDanglingStart() )
 {
 m_gal->DrawCircle( aEntry->GetPosition(),
 aEntry->GetPenWidth() + ( TARGET_BUSENTRY_RADIUS / 2 ) );
 }

 if( aEntry->IsDanglingEnd() )
 {
 m_gal->DrawCircle( aEntry->GetEnd(),
 aEntry->GetPenWidth() + ( TARGET_BUSENTRY_RADIUS / 2 ) );
 }
 }
 else
 {
 line.SetLineColor( color );
 line.SetLineStyle( aEntry->GetStrokeStyle() );

 draw( &line, aLayer );
 }
}

References color, draw(), KIGFX::GAL::DrawCircle(), KIGFX::SCH_RENDER_SETTINGS::GetDanglineSymbolThickness(), SCH_BUS_ENTRY_BASE::GetEnd(), getLineWidth(), SCH_ITEM::GetPenWidth(), SCH_BUS_ENTRY_BASE::GetPosition(), getRenderColor(), SCH_BUS_ENTRY_BASE::GetStroke(), SCH_BUS_ENTRY_BASE::GetStrokeStyle(), EDA_ITEM::IsBrightened(), SCH_BUS_ENTRY_BASE::IsDanglingEnd(), SCH_BUS_ENTRY_BASE::IsDanglingStart(), EDA_ITEM::IsSelected(), LAYER_BUS, LAYER_DANGLING, LAYER_SELECTION_SHADOWS, LAYER_WIRE, KIGFX::PAINTER::m_gal, m_schSettings, SCH_BUS_BUS_ENTRY_T, SCH_BUS_WIRE_ENTRY_T, EDA_ITEM::SetBrightened(), SCH_LINE::SetEndPoint(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), SCH_LINE::SetLineColor(), SCH_LINE::SetLineStyle(), SCH_LINE::SetLineWidth(), KIGFX::GAL::SetLineWidth(), EDA_ITEM::SetSelected(), SCH_LINE::SetStartPoint(), SCH_LINE::SetStroke(), KIGFX::GAL::SetStrokeColor(), TARGET_BUSENTRY_RADIUS, and EDA_ITEM::Type().

drawDanglingSymbol()

void KIGFX::SCH_PAINTER::drawDanglingSymbol ( const wxPoint &  aPos, const COLOR4D &  aColor, int  aWidth, bool  aDrawingShadows  )

private

Definition at line 1201 of file sch_painter.cpp.

{
 wxPoint radius( aWidth + Mils2iu( DANGLING_SYMBOL_SIZE / 2 ),
 aWidth + Mils2iu( DANGLING_SYMBOL_SIZE / 2 ) );

 // Dangling symbols must be drawn in a slightly different colour so they can be seen when
 // they overlap with a junction dot.
 m_gal->SetStrokeColor( aColor.Brightened( 0.3 ) );
 m_gal->SetIsStroke( true );
 m_gal->SetIsFill( false );
 m_gal->SetLineWidth( aDrawingShadows ? getShadowWidth()
 : m_schSettings.GetDanglineSymbolThickness() );

 m_gal->DrawRectangle( aPos - radius, aPos + radius );
}

References KIGFX::COLOR4D::Brightened(), DANGLING_SYMBOL_SIZE, KIGFX::GAL::DrawRectangle(), KIGFX::SCH_RENDER_SETTINGS::GetDanglineSymbolThickness(), getShadowWidth(), KIGFX::PAINTER::m_gal, m_schSettings, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

Referenced by draw().

drawPinDanglingSymbol()

void KIGFX::SCH_PAINTER::drawPinDanglingSymbol ( const VECTOR2I &  aPos, const COLOR4D &  aColor, bool  aDrawingShadows  )

private

Definition at line 740 of file sch_painter.cpp.

{
 // Dangling symbols must be drawn in a slightly different colour so they can be seen when
 // they overlap with a junction dot.
 m_gal->SetStrokeColor( aColor.Brightened( 0.3 ) );

 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( aDrawingShadows ? getShadowWidth()
 : m_schSettings.GetDanglineSymbolThickness() );

 m_gal->DrawCircle( aPos, TARGET_PIN_RADIUS );
}

References KIGFX::COLOR4D::Brightened(), KIGFX::GAL::DrawCircle(), KIGFX::SCH_RENDER_SETTINGS::GetDanglineSymbolThickness(), getShadowWidth(), KIGFX::PAINTER::m_gal, m_schSettings, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), and TARGET_PIN_RADIUS.

Referenced by draw().

externalPinDecoSize()

int KIGFX::SCH_PAINTER::externalPinDecoSize ( const LIB_PIN &  aPin )

private

Definition at line 730 of file sch_painter.cpp.

{
 if( m_schSettings.m_PinSymbolSize > 0 )
 return m_schSettings.m_PinSymbolSize;

 return aPin.GetNumberTextSize() / 2;
}

References LIB_PIN::GetNumberTextSize(), KIGFX::SCH_RENDER_SETTINGS::m_PinSymbolSize, and m_schSettings.

Referenced by draw().

getLineWidth() [1/2]

float KIGFX::SCH_PAINTER::getLineWidth ( const LIB_ITEM *  aItem, bool  aDrawingShadows  ) const

private

Definition at line 333 of file sch_painter.cpp.

{
 float width = (float) aItem->GetEffectivePenWidth( &m_schSettings );

 if( aItem->IsSelected() && aDrawingShadows )
 width += getShadowWidth();

 return width;
}

References LIB_ITEM::GetEffectivePenWidth(), getShadowWidth(), EDA_ITEM::IsSelected(), and m_schSettings.

Referenced by draw(), and setDeviceColors().

getLineWidth() [2/2]

float KIGFX::SCH_PAINTER::getLineWidth ( const SCH_ITEM *  aItem, bool  aDrawingShadows  ) const

private

Definition at line 344 of file sch_painter.cpp.

{
 wxCHECK( aItem, static_cast<float>( Mils2iu( DEFAULT_WIRE_WIDTH_MILS ) ) );

 float width = (float) aItem->GetPenWidth();

 if( aItem->IsSelected() && aDrawingShadows )
 width += getShadowWidth();

 return std::max( width, 1.0f );
}

References DEFAULT_WIRE_WIDTH_MILS, SCH_ITEM::GetPenWidth(), getShadowWidth(), and EDA_ITEM::IsSelected().

getRenderColor()

COLOR4D KIGFX::SCH_PAINTER::getRenderColor ( const EDA_ITEM *  aItem, int  aLayer, bool  aDrawingShadows  ) const

private

Definition at line 270 of file sch_painter.cpp.

{
 COLOR4D color = m_schSettings.GetLayerColor( aLayer );

 if( aItem->Type() == SCH_LINE_T )
 {
 COLOR4D lineColor = static_cast<const SCH_LINE*>( aItem )->GetLineColor();

 if( lineColor != COLOR4D::UNSPECIFIED )
 color = lineColor;
 }
 else if( aItem->Type() == SCH_BUS_WIRE_ENTRY_T )
 {
 COLOR4D busEntryColor = static_cast<const SCH_BUS_WIRE_ENTRY*>( aItem )->GetStrokeColor();

 if( busEntryColor != COLOR4D::UNSPECIFIED )
 color = busEntryColor;
 }
 else if( aItem->Type() == SCH_JUNCTION_T )
 {
 COLOR4D junctionColor = static_cast<const SCH_JUNCTION*>( aItem )->GetJunctionColor();

 if( junctionColor != COLOR4D::UNSPECIFIED )
 color = junctionColor;
 }
 else if( aItem->Type() == SCH_SHEET_T )
 {
 SCH_SHEET* sheet = (SCH_SHEET*) aItem;

 if( m_schSettings.m_OverrideItemColors )
 color = m_schSettings.GetLayerColor( aLayer );
 else if( aLayer == LAYER_SHEET )
 color = sheet->GetBorderColor();
 else if( aLayer == LAYER_SHEET_BACKGROUND )
 color = sheet->GetBackgroundColor();

 if( color == COLOR4D::UNSPECIFIED )
 color = m_schSettings.GetLayerColor( aLayer );
 }

 if( aItem->IsBrightened() && !aDrawingShadows ) // Selection disambiguation, etc.
 {
 color = m_schSettings.GetLayerColor( LAYER_BRIGHTENED );

 if( aLayer == LAYER_DEVICE_BACKGROUND || aLayer == LAYER_SHEET_BACKGROUND )
 color = color.WithAlpha( 0.2 );
 }
 else if( aItem->IsSelected() )
 {
 if( aDrawingShadows )
 color = m_schSettings.GetLayerColor( LAYER_SELECTION_SHADOWS );
 }

 if( m_schSettings.m_ShowDisabled
 || ( m_schSettings.m_ShowGraphicsDisabled && aItem->Type() != LIB_FIELD_T ) )
 {
 color = color.Darken( 0.5f );
 }

 return color;
}

References color, SCH_SHEET::GetBackgroundColor(), SCH_SHEET::GetBorderColor(), KIGFX::RENDER_SETTINGS::GetLayerColor(), EDA_ITEM::IsBrightened(), EDA_ITEM::IsSelected(), LAYER_BRIGHTENED, LAYER_DEVICE_BACKGROUND, LAYER_SELECTION_SHADOWS, LAYER_SHEET, LAYER_SHEET_BACKGROUND, LIB_FIELD_T, KIGFX::SCH_RENDER_SETTINGS::m_OverrideItemColors, m_schSettings, KIGFX::SCH_RENDER_SETTINGS::m_ShowDisabled, KIGFX::SCH_RENDER_SETTINGS::m_ShowGraphicsDisabled, SCH_BUS_WIRE_ENTRY_T, SCH_JUNCTION_T, SCH_LINE_T, SCH_SHEET_T, EDA_ITEM::Type(), and KIGFX::COLOR4D::UNSPECIFIED.

Referenced by draw(), and setDeviceColors().

GetSettings()

virtual SCH_RENDER_SETTINGS* KIGFX::SCH_PAINTER::GetSettings ( )

inlineoverridevirtual

Return a pointer to current settings that are going to be used when drawing items.

Returns

Current rendering settings.

Implements KIGFX::PAINTER.

Definition at line 139 of file sch_painter.h.

 {
 return &m_schSettings;
 }

References m_schSettings.

Referenced by SCH_EDITOR_CONTROL::ToggleHiddenFields(), and SCH_EDITOR_CONTROL::ToggleHiddenPins().

getShadowWidth()

float KIGFX::SCH_PAINTER::getShadowWidth ( ) const

private

Definition at line 259 of file sch_painter.cpp.

{
 const MATRIX3x3D& matrix = m_gal->GetScreenWorldMatrix();

 // For best visuals the selection width must be a cross between the zoom level and the
 // default line width.
 return (float) std::fabs( matrix.GetScale().x * 2.75 ) +
 Mils2iu( eeconfig()->m_Selection.thickness );
}

References KIGFX::eeconfig(), MATRIX3x3< T >::GetScale(), KIGFX::GAL::GetScreenWorldMatrix(), KIGFX::PAINTER::m_gal, EESCHEMA_SETTINGS::m_Selection, EESCHEMA_SETTINGS::SELECTION::thickness, and VECTOR2< T >::x.

Referenced by draw(), drawDanglingSymbol(), drawPinDanglingSymbol(), getLineWidth(), and getTextThickness().

getTextThickness() [1/4]

float KIGFX::SCH_PAINTER::getTextThickness ( const SCH_TEXT *  aItem, bool  aDrawingShadows  ) const

private

Definition at line 357 of file sch_painter.cpp.

{
 float width = (float) aItem->GetEffectiveTextPenWidth( m_schSettings.GetDefaultPenWidth() );

 if( aItem->IsSelected() && aDrawingShadows )
 width += getShadowWidth();

 return width;
}

References KIGFX::RENDER_SETTINGS::GetDefaultPenWidth(), EDA_TEXT::GetEffectiveTextPenWidth(), getShadowWidth(), EDA_ITEM::IsSelected(), and m_schSettings.

Referenced by draw().

getTextThickness() [2/4]

float KIGFX::SCH_PAINTER::getTextThickness ( const SCH_FIELD *  aItem, bool  aDrawingShadows  ) const

private

Definition at line 368 of file sch_painter.cpp.

{
 float width = (float) aItem->GetEffectiveTextPenWidth( m_schSettings.GetDefaultPenWidth() );

 if( aItem->IsSelected() && aDrawingShadows )
 width += getShadowWidth();

 return width;
}

References KIGFX::RENDER_SETTINGS::GetDefaultPenWidth(), EDA_TEXT::GetEffectiveTextPenWidth(), getShadowWidth(), EDA_ITEM::IsSelected(), and m_schSettings.

getTextThickness() [3/4]

float KIGFX::SCH_PAINTER::getTextThickness ( const LIB_FIELD *  aItem, bool  aDrawingShadows  ) const

private

Definition at line 379 of file sch_painter.cpp.

{
 float width = (float) std::max( aItem->GetEffectiveTextPenWidth(),
 m_schSettings.GetDefaultPenWidth() );

 if( aItem->IsSelected() && aDrawingShadows )
 width += getShadowWidth();

 return width;
}

References KIGFX::RENDER_SETTINGS::GetDefaultPenWidth(), EDA_TEXT::GetEffectiveTextPenWidth(), getShadowWidth(), EDA_ITEM::IsSelected(), and m_schSettings.

getTextThickness() [4/4]

float KIGFX::SCH_PAINTER::getTextThickness ( const LIB_TEXT *  aItem, bool  aDrawingShadows  ) const

private

Definition at line 391 of file sch_painter.cpp.

{
 float width = (float) std::max( aItem->GetEffectiveTextPenWidth(),
 m_schSettings.GetDefaultPenWidth() );

 if( aItem->IsSelected() && aDrawingShadows )
 width += getShadowWidth();

 return width;
}

References KIGFX::RENDER_SETTINGS::GetDefaultPenWidth(), EDA_TEXT::GetEffectiveTextPenWidth(), getShadowWidth(), EDA_ITEM::IsSelected(), and m_schSettings.

internalPinDecoSize()

int KIGFX::SCH_PAINTER::internalPinDecoSize ( const LIB_PIN &  aPin )

private

Definition at line 719 of file sch_painter.cpp.

{
 if( m_schSettings.m_PinSymbolSize > 0 )
 return m_schSettings.m_PinSymbolSize;

 return aPin.GetNameTextSize() != 0 ? aPin.GetNameTextSize() / 2 : aPin.GetNumberTextSize() / 2;
}

References LIB_PIN::GetNameTextSize(), LIB_PIN::GetNumberTextSize(), KIGFX::SCH_RENDER_SETTINGS::m_PinSymbolSize, and m_schSettings.

Referenced by draw().

isUnitAndConversionShown()

bool KIGFX::SCH_PAINTER::isUnitAndConversionShown ( const LIB_ITEM *  aItem ) const

private

Definition at line 239 of file sch_painter.cpp.

{
 if( m_schSettings.m_ShowUnit // showing a specific unit
 && aItem->GetUnit() // item is unit-specific
 && aItem->GetUnit() != m_schSettings.m_ShowUnit )
 {
 return false;
 }

 if( m_schSettings.m_ShowConvert // showing a specific conversion
 && aItem->GetConvert() // item is conversion-specific
 && aItem->GetConvert() != m_schSettings.m_ShowConvert )
 {
 return false;
  }

 return true;
}

References LIB_ITEM::GetConvert(), LIB_ITEM::GetUnit(), m_schSettings, KIGFX::SCH_RENDER_SETTINGS::m_ShowConvert, and KIGFX::SCH_RENDER_SETTINGS::m_ShowUnit.

Referenced by draw().

setDeviceColors()

bool KIGFX::SCH_PAINTER::setDeviceColors ( const LIB_ITEM *  aItem, int  aLayer  )

private

Definition at line 479 of file sch_painter.cpp.

{
 const EDA_SHAPE* shape = dynamic_cast<const EDA_SHAPE*>( aItem );

 switch( aLayer )
 {
 case LAYER_SELECTION_SHADOWS:
 if( aItem->IsSelected() )
 {
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( getLineWidth( aItem, true ) );
 m_gal->SetStrokeColor( getRenderColor( aItem, LAYER_DEVICE, true ) );
 m_gal->SetFillColor( getRenderColor( aItem, LAYER_DEVICE, true ) );
 return true;
 }

 return false;

 case LAYER_DEVICE_BACKGROUND:
 if( shape && shape->GetFillType() == FILL_T::FILLED_WITH_BG_BODYCOLOR )
 {
 COLOR4D fillColor = getRenderColor( aItem, LAYER_DEVICE_BACKGROUND, false );

 m_gal->SetIsFill( shape->GetFillType() == FILL_T::FILLED_WITH_BG_BODYCOLOR );
 m_gal->SetFillColor( fillColor );
 m_gal->SetIsStroke( false );
 return true;
 }

 return false;

 case LAYER_DEVICE:
 m_gal->SetIsFill( shape && shape->GetFillType() == FILL_T::FILLED_SHAPE );
 m_gal->SetFillColor( getRenderColor( aItem, LAYER_DEVICE, false ) );

 if( aItem->GetPenWidth() >= 0 || !shape || !shape->IsFilled() )
 {
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( getLineWidth( aItem, false ) );
 m_gal->SetStrokeColor( getRenderColor( aItem, LAYER_DEVICE, false ) );
 }
 else
 {
 m_gal->SetIsStroke( false );
 }

 return true;

 default:
 return false;
 }
}

References FILLED_SHAPE, FILLED_WITH_BG_BODYCOLOR, EDA_SHAPE::GetFillType(), getLineWidth(), LIB_ITEM::GetPenWidth(), getRenderColor(), EDA_SHAPE::IsFilled(), EDA_ITEM::IsSelected(), LAYER_DEVICE, LAYER_DEVICE_BACKGROUND, LAYER_SELECTION_SHADOWS, KIGFX::PAINTER::m_gal, KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

Referenced by draw().

SetGAL()

void KIGFX::PAINTER::SetGAL ( GAL *  aGal )

inlineinherited

Changes Graphics Abstraction Layer used for drawing items for a new one.

Parameters

aGal	is the new GAL instance.

Definition at line 75 of file painter.h.

 {
 m_gal = aGal;
 }

References KIGFX::PAINTER::m_gal.

SetSchematic()

void KIGFX::SCH_PAINTER::SetSchematic ( SCHEMATIC *  aSchematic )

inline

Definition at line 144 of file sch_painter.h.

 {
 m_schematic = aSchematic;
 }

References m_schematic.

strokeText()

void KIGFX::SCH_PAINTER::strokeText ( const wxString &  aText, const VECTOR2D &  aPosition, double  aRotationAngle  )

private

Definition at line 409 of file sch_painter.cpp.

{
 m_gal->StrokeText( aText, VECTOR2D( aPosition.x, aPosition.y ), aAngle );
}

References KIGFX::PAINTER::m_gal, KIGFX::GAL::StrokeText(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by draw().

triLine()

void KIGFX::SCH_PAINTER::triLine ( const VECTOR2D &  a, const VECTOR2D &  b, const VECTOR2D &  c  )

private

Definition at line 439 of file sch_painter.cpp.

{
 m_gal->DrawLine( a, b );
 m_gal->DrawLine( b, c );
}

References KIGFX::GAL::DrawLine(), and KIGFX::PAINTER::m_gal.

Referenced by draw().

Member Data Documentation

m_gal

GAL* KIGFX::PAINTER::m_gal

protectedinherited

Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.

DrawLine, DrawCircle, etc.)

Definition at line 101 of file painter.h.

Referenced by boxText(), Draw(), draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::Draw(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::drawApertureMacro(), drawDanglingSymbol(), KIGFX::GERBVIEW_PAINTER::drawFlashedShape(), drawPinDanglingSymbol(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), getShadowWidth(), setDeviceColors(), KIGFX::PAINTER::SetGAL(), strokeText(), and triLine().

m_schematic

SCHEMATIC* KIGFX::SCH_PAINTER::m_schematic

private

Definition at line 197 of file sch_painter.h.

Referenced by draw(), and SetSchematic().

m_schSettings

SCH_RENDER_SETTINGS KIGFX::SCH_PAINTER::m_schSettings

private

Definition at line 195 of file sch_painter.h.

Referenced by draw(), drawDanglingSymbol(), drawPinDanglingSymbol(), externalPinDecoSize(), getLineWidth(), getRenderColor(), GetSettings(), getTextThickness(), internalPinDecoSize(), and isUnitAndConversionShown().

---

The documentation for this class was generated from the following files:

• sch_painter.h
• sch_painter.cpp