KIGFX::PCB_PRINT_PAINTER Class Reference

Special flavor of PCB_PAINTER that contains modifications to handle printing options. More...

#include <pcbnew_printout.h>

Inheritance diagram for KIGFX::PCB_PRINT_PAINTER:

Public Member Functions
	PCB_PRINT_PAINTER (GAL *aGal)
void	SetDrillMarks (bool aRealSize, unsigned int aSize=0)
	Set drill marks visibility and options. More...
virtual PCB_RENDER_SETTINGS *	GetSettings () override
	Return a pointer to current settings that are going to be used when drawing items. More...
virtual bool	Draw (const VIEW_ITEM *aItem, int aLayer) override
	Takes an instance of VIEW_ITEM and passes it to a function that knows how to draw the item. More...
void	SetGAL (GAL *aGal)
	Changes Graphics Abstraction Layer used for drawing items for a new one. More...

Protected Member Functions
int	getDrillShape (const PAD *aPad) const override
	Return drill shape of a pad. More...
VECTOR2D	getDrillSize (const PAD *aPad) const override
	Return drill size for a pad (internal units). More...
int	getDrillSize (const PCB_VIA *aVia) const override
	Flag deciding whether use the actual hole size or user-specified size for drill marks. More...
void	draw (const PCB_TRACK *aTrack, int aLayer)
void	draw (const PCB_ARC *aArc, int aLayer)
void	draw (const PCB_VIA *aVia, int aLayer)
void	draw (const PAD *aPad, int aLayer)
void	draw (const PCB_SHAPE *aSegment, int aLayer)
void	draw (const PCB_TEXT *aText, int aLayer)
void	draw (const FP_TEXT *aText, int aLayer)
void	draw (const FOOTPRINT *aFootprint, int aLayer)
void	draw (const PCB_GROUP *aGroup, int aLayer)
void	draw (const ZONE *aZone, int aLayer)
void	draw (const PCB_DIMENSION_BASE *aDimension, int aLayer)
void	draw (const PCB_TARGET *aTarget)
void	draw (const PCB_MARKER *aMarker, int aLayer)
int	getLineThickness (int aActualThickness) const
	Get the thickness to draw for a line (e.g. More...

Protected Attributes
bool	m_drillMarkReal
	User-specified size for drill marks (expressed in internal units) More...
int	m_drillMarkSize
PCB_RENDER_SETTINGS	m_pcbSettings
int	m_maxError
int	m_holePlatingThickness
GAL *	m_gal
	Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg. More...

Detailed Description

Special flavor of PCB_PAINTER that contains modifications to handle printing options.

Definition at line 85 of file pcbnew_printout.h.

Constructor & Destructor Documentation

PCB_PRINT_PAINTER()

KIGFX::PCB_PRINT_PAINTER::PCB_PRINT_PAINTER

(

GAL *

aGal

)

Definition at line 288 of file pcbnew_printout.cpp.

 :
 PCB_PAINTER( aGal ),
 m_drillMarkReal( false ),
 m_drillMarkSize( 0 )
{
 m_pcbSettings.EnableZoneOutlines( false );
}

References KIGFX::PCB_RENDER_SETTINGS::EnableZoneOutlines(), and KIGFX::PCB_PAINTER::m_pcbSettings.

Member Function Documentation

Draw()

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

overridevirtualinherited

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 461 of file pcb_painter.cpp.

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

 if( !item )
 return false;

 if( const BOARD* board = item->GetBoard() )
 {
 BOARD_DESIGN_SETTINGS& bds = board->GetDesignSettings();
 m_maxError = bds.m_MaxError;
 m_holePlatingThickness = bds.GetHolePlatingThickness();
 }
 else
 {
 m_maxError = ARC_HIGH_DEF;
 m_holePlatingThickness = 0;
 }

 // the "cast" applied in here clarifies which overloaded draw() is called
 switch( item->Type() )
 {
 case PCB_TRACE_T:
 draw( static_cast<const PCB_TRACK*>( item ), aLayer );
 break;

 case PCB_ARC_T:
 draw( static_cast<const PCB_ARC*>( item ), aLayer );
 break;

 case PCB_VIA_T:
 draw( static_cast<const PCB_VIA*>( item ), aLayer );
 break;

 case PCB_PAD_T:
 draw( static_cast<const PAD*>( item ), aLayer );
 break;

 case PCB_SHAPE_T:
 case PCB_FP_SHAPE_T:
 draw( static_cast<const PCB_SHAPE*>( item ), aLayer );
 break;

 case PCB_TEXT_T:
 draw( static_cast<const PCB_TEXT*>( item ), aLayer );
 break;

 case PCB_FP_TEXT_T:
 draw( static_cast<const FP_TEXT*>( item ), aLayer );
 break;

 case PCB_FOOTPRINT_T:
 draw( static_cast<const FOOTPRINT*>( item ), aLayer );
 break;

 case PCB_GROUP_T:
 draw( static_cast<const PCB_GROUP*>( item ), aLayer );
 break;

 case PCB_ZONE_T:
 draw( static_cast<const ZONE*>( item ), aLayer );
 break;

 case PCB_FP_ZONE_T:
 draw( static_cast<const ZONE*>( item ), aLayer );
 break;

 case PCB_DIM_ALIGNED_T:
 case PCB_DIM_CENTER_T:
 case PCB_DIM_ORTHOGONAL_T:
 case PCB_DIM_LEADER_T:
 draw( static_cast<const PCB_DIMENSION_BASE*>( item ), aLayer );
 break;

 case PCB_TARGET_T:
 draw( static_cast<const PCB_TARGET*>( item ) );
 break;

 case PCB_MARKER_T:
 draw( static_cast<const PCB_MARKER*>( item ), aLayer );
 break;

 default:
 // Painter does not know how to draw the object
 return false;
 }

 // Draw bounding boxes after drawing objects so they can be seen.
 if( ADVANCED_CFG::GetCfg().m_DrawBoundingBoxes )
 {
 // Show bounding boxes of painted objects for debugging.
 EDA_RECT box = item->GetBoundingBox();
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );

 if( item->Type() == PCB_FOOTPRINT_T )
 {
 m_gal->SetStrokeColor( item->IsSelected() ? COLOR4D( 1.0, 0.2, 0.2, 1 ) :
 COLOR4D( MAGENTA ) );
 }
 else
 {
 m_gal->SetStrokeColor( item->IsSelected() ? COLOR4D( 1.0, 0.2, 0.2, 1 ) :
 COLOR4D( 0.4, 0.4, 0.4, 1 ) );
 }

 m_gal->SetLineWidth( 1 );
 m_gal->DrawRectangle( box.GetOrigin(), box.GetEnd() );

 if( item->Type() == PCB_FOOTPRINT_T )
 {
 m_gal->SetStrokeColor( item->IsSelected() ? COLOR4D( 1.0, 0.2, 0.2, 1 ) :
 COLOR4D( CYAN ) );

 const FOOTPRINT* fp = static_cast<const FOOTPRINT*>( item );

 if( fp )
 {
 SHAPE_POLY_SET convex = fp->GetBoundingHull();

 m_gal->DrawPolyline( convex.COutline( 0 ) );
 }
 }
 }

 return true;
}

References SHAPE_POLY_SET::COutline(), CYAN, KIGFX::PCB_PAINTER::draw(), KIGFX::GAL::DrawPolyline(), KIGFX::GAL::DrawRectangle(), BOARD_ITEM::GetBoard(), EDA_ITEM::GetBoundingBox(), FOOTPRINT::GetBoundingHull(), ADVANCED_CFG::GetCfg(), EDA_RECT::GetEnd(), BOARD_DESIGN_SETTINGS::GetHolePlatingThickness(), EDA_RECT::GetOrigin(), EDA_ITEM::IsSelected(), KIGFX::PAINTER::m_gal, KIGFX::PCB_PAINTER::m_holePlatingThickness, KIGFX::PCB_PAINTER::m_maxError, BOARD_DESIGN_SETTINGS::m_MaxError, MAGENTA, PCB_ARC_T, PCB_DIM_ALIGNED_T, PCB_DIM_CENTER_T, PCB_DIM_LEADER_T, PCB_DIM_ORTHOGONAL_T, PCB_FOOTPRINT_T, PCB_FP_SHAPE_T, PCB_FP_TEXT_T, PCB_FP_ZONE_T, PCB_GROUP_T, PCB_MARKER_T, PCB_PAD_T, PCB_SHAPE_T, PCB_TARGET_T, PCB_TEXT_T, PCB_TRACE_T, PCB_VIA_T, PCB_ZONE_T, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), and EDA_ITEM::Type().

draw() [1/13]

void PCB_PAINTER::draw ( const PCB_TRACK *  aTrack, int  aLayer  )

protectedinherited

Definition at line 590 of file pcb_painter.cpp.

{
 VECTOR2D start( aTrack->GetStart() );
 VECTOR2D end( aTrack->GetEnd() );
 int width = aTrack->GetWidth();
 COLOR4D color = m_pcbSettings.GetColor( aTrack, aLayer );

 if( IsNetnameLayer( aLayer ) )
 {
 if( !m_pcbSettings.m_netNamesOnTracks )
 return;

 if( aTrack->GetNetCode() <= NETINFO_LIST::UNCONNECTED )
 return;

 VECTOR2D line = ( end - start );
 double length = line.EuclideanNorm();

 // Check if the track is long enough to have a netname displayed
 if( length < 10 * width )
 return;

 const wxString& netName = UnescapeString( aTrack->GetShortNetname() );
 double textSize = width;
 double penWidth = width / 12.0;
 VECTOR2D textPosition = start + line / 2.0; // center of the track
 double textOrientation;

 if( end.y == start.y ) // horizontal
 {
 textOrientation = 0;
 textPosition.y += penWidth;
 }
 else if( end.x == start.x ) // vertical
 {
 textOrientation = M_PI / 2;
 textPosition.x += penWidth;
 }
 else
 {
 textOrientation = -atan( line.y / line.x );
 textPosition.x += penWidth / 1.4;
 textPosition.y += penWidth / 1.4;
 }


 m_gal->SetIsStroke( true );
 m_gal->SetIsFill( false );
 m_gal->SetStrokeColor( color );
 m_gal->SetLineWidth( penWidth );
 m_gal->SetFontBold( false );
 m_gal->SetFontItalic( false );
 m_gal->SetFontUnderlined( false );
 m_gal->SetTextMirrored( false );
 m_gal->SetGlyphSize( VECTOR2D( textSize * 0.55, textSize * 0.55 ) );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 m_gal->BitmapText( netName, textPosition, textOrientation );

 return;
 }
 else if( IsCopperLayer( aLayer ) )
 {
 // Draw a regular track
 bool outline_mode = m_pcbSettings.m_sketchMode[LAYER_TRACKS];
 m_gal->SetStrokeColor( color );
 m_gal->SetFillColor( color );
 m_gal->SetIsStroke( outline_mode );
 m_gal->SetIsFill( not outline_mode );
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );

 m_gal->DrawSegment( start, end, width );
 }

 // Clearance lines
 constexpr int clearanceFlags = PCB_RENDER_SETTINGS::CL_EXISTING
 | PCB_RENDER_SETTINGS::CL_TRACKS;

 if( ( m_pcbSettings.m_clearanceDisplayFlags & clearanceFlags ) == clearanceFlags )
 {
 int clearance = aTrack->GetOwnClearance( m_pcbSettings.GetActiveLayer() );

 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( color );
 m_gal->DrawSegment( start, end, width + clearance * 2 );
 }
}

References KIGFX::GAL::BitmapText(), KIGFX::PCB_RENDER_SETTINGS::CL_EXISTING, KIGFX::PCB_RENDER_SETTINGS::CL_TRACKS, color, KIGFX::GAL::DrawSegment(), VECTOR2< T >::EuclideanNorm(), KIGFX::RENDER_SETTINGS::GetActiveLayer(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), PCB_TRACK::GetEnd(), BOARD_CONNECTED_ITEM::GetNetCode(), BOARD_CONNECTED_ITEM::GetOwnClearance(), BOARD_CONNECTED_ITEM::GetShortNetname(), PCB_TRACK::GetStart(), PCB_TRACK::GetWidth(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, IsCopperLayer(), IsNetnameLayer(), LAYER_TRACKS, KIGFX::PCB_RENDER_SETTINGS::m_clearanceDisplayFlags, KIGFX::PAINTER::m_gal, KIGFX::PCB_RENDER_SETTINGS::m_netNamesOnTracks, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, 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(), NETINFO_LIST::UNCONNECTED, UnescapeString(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by KIGFX::PCB_PAINTER::Draw().

draw() [2/13]

void PCB_PAINTER::draw ( const PCB_ARC *  aArc, int  aLayer  )

protectedinherited

Definition at line 681 of file pcb_painter.cpp.

{
 VECTOR2D center( aArc->GetCenter() );
 int width = aArc->GetWidth();
 COLOR4D color = m_pcbSettings.GetColor( aArc, aLayer );
 double radius = aArc->GetRadius();
 double start_angle = DECIDEG2RAD( aArc->GetArcAngleStart() );
 double angle = DECIDEG2RAD( aArc->GetAngle() );

 if( IsNetnameLayer( aLayer ) )
 {
 // Ummm, yeah. Anyone fancy implementing text on a path?
 return;
 }
 else if( IsCopperLayer( aLayer ) )
 {
 // Draw a regular track
 bool outline_mode = m_pcbSettings.m_sketchMode[LAYER_TRACKS];
 m_gal->SetStrokeColor( color );
 m_gal->SetFillColor( color );
 m_gal->SetIsStroke( outline_mode );
 m_gal->SetIsFill( not outline_mode );
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );

 m_gal->DrawArcSegment( center, radius, start_angle, start_angle + angle, width, m_maxError );
 }

 // Clearance lines
 constexpr int clearanceFlags = PCB_RENDER_SETTINGS::CL_EXISTING
 | PCB_RENDER_SETTINGS::CL_TRACKS;

 if( ( m_pcbSettings.m_clearanceDisplayFlags & clearanceFlags ) == clearanceFlags )
 {
 int clearance = aArc->GetOwnClearance( m_pcbSettings.GetActiveLayer() );

 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( color );

 m_gal->DrawArcSegment( center, radius, start_angle, start_angle + angle,
 width + clearance * 2, m_maxError );
 }

// Debug only: enable this code only to test the TransformArcToPolygon function
// and display the polygon outline created by it.
// arcs on F_Cu are approximated with ERROR_INSIDE, others with ERROR_OUTSIDE
#if 0
 SHAPE_POLY_SET cornerBuffer;
 ERROR_LOC errorloc = aLayer == F_Cu ? ERROR_LOC::ERROR_INSIDE : ERROR_LOC::ERROR_OUTSIDE;
 TransformArcToPolygon( cornerBuffer, aArc->GetStart(), aArc->GetMid(), aArc->GetEnd(), width,
 m_maxError, errorloc );
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( COLOR4D( 0, 0, 1.0, 1.0 ) );
 m_gal->DrawPolygon( cornerBuffer );
#endif

// Debug only: enable this code only to test the SHAPE_ARC::ConvertToPolyline function
// and display the polyline created by it.
#if 0
 SHAPE_ARC arc( aArc->GetCenter(), aArc->GetStart(), aArc->GetAngle() / 10.0, aArc->GetWidth() );
 SHAPE_LINE_CHAIN arcSpine = arc.ConvertToPolyline( m_maxError );
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( COLOR4D( 0.3, 0.2, 0.5, 1.0 ) );

 for( int idx = 1; idx < arcSpine.PointCount(); idx++ )
 m_gal->DrawSegment( arcSpine.CPoint( idx-1 ), arcSpine.CPoint( idx ), aArc->GetWidth() );
#endif
}

References PNS::angle(), KIGFX::PCB_RENDER_SETTINGS::CL_EXISTING, KIGFX::PCB_RENDER_SETTINGS::CL_TRACKS, color, DECIDEG2RAD(), KIGFX::GAL::DrawArcSegment(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawSegment(), ERROR_INSIDE, ERROR_OUTSIDE, F_Cu, KIGFX::RENDER_SETTINGS::GetActiveLayer(), PCB_ARC::GetAngle(), PCB_ARC::GetArcAngleStart(), PCB_ARC::GetCenter(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), PCB_TRACK::GetEnd(), PCB_ARC::GetMid(), BOARD_CONNECTED_ITEM::GetOwnClearance(), PCB_ARC::GetRadius(), PCB_TRACK::GetStart(), PCB_TRACK::GetWidth(), IsCopperLayer(), IsNetnameLayer(), LAYER_TRACKS, KIGFX::PCB_RENDER_SETTINGS::m_clearanceDisplayFlags, KIGFX::PAINTER::m_gal, KIGFX::PCB_PAINTER::m_maxError, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), and TransformArcToPolygon().

draw() [3/13]

void PCB_PAINTER::draw ( const PCB_VIA *  aVia, int  aLayer  )

protectedinherited

Definition at line 756 of file pcb_painter.cpp.

{
 COLOR4D color = m_pcbSettings.GetColor( aVia, aLayer );
 VECTOR2D center( aVia->GetStart() );

 if( color == COLOR4D::CLEAR )
 return;

 // Draw description layer
 if( IsNetnameLayer( aLayer ) )
 {
 VECTOR2D position( center );

 // Is anything that we can display enabled?
 if( !m_pcbSettings.m_netNamesOnVias || aVia->GetNetname().empty() )
 return;

 double maxSize = PCB_RENDER_SETTINGS::MAX_FONT_SIZE;
 double size = aVia->GetWidth();

 // Font size limits
 if( size > maxSize )
 size = maxSize;

 m_gal->Save();
 m_gal->Translate( position );

 // Default font settings
 m_gal->ResetTextAttributes();
 m_gal->SetStrokeColor( m_pcbSettings.GetColor( nullptr, aLayer ) );

 // Set the text position to the pad shape position (the pad position is not the best place)
 VECTOR2D textpos( 0.0, 0.0 );

 wxString netname = UnescapeString( aVia->GetShortNetname() );

 // approximate the size of net name text:
 double tsize = 1.5 * size / std::max( PrintableCharCount( netname ), 1 );
 tsize = std::min( tsize, size );

 // Use a smaller text size to handle interline, pen size..
 tsize *= 0.7;
 VECTOR2D namesize( tsize, tsize );

 m_gal->SetGlyphSize( namesize );
 m_gal->SetLineWidth( namesize.x / 12.0 );
 m_gal->BitmapText( netname, textpos, 0.0 );

 m_gal->Restore();

 return;
 }
 else if( aLayer == LAYER_VIA_HOLEWALLS )
 {
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( color );
 m_gal->SetLineWidth( m_holePlatingThickness );

 m_gal->DrawCircle( center, ( getDrillSize( aVia ) + m_holePlatingThickness ) / 2.0 );

 return;
 }

 bool sketchMode = false;

 switch( aVia->GetViaType() )
 {
 case VIATYPE::THROUGH: sketchMode = m_pcbSettings.m_sketchMode[LAYER_VIA_THROUGH]; break;
 case VIATYPE::BLIND_BURIED: sketchMode = m_pcbSettings.m_sketchMode[LAYER_VIA_BBLIND]; break;
 case VIATYPE::MICROVIA: sketchMode = m_pcbSettings.m_sketchMode[LAYER_VIA_MICROVIA]; break;
 default: wxASSERT( false ); break;
 }

 if( sketchMode )
 {
 // Outline mode
 m_gal->SetIsStroke( true );
 m_gal->SetIsFill( false );
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 m_gal->SetStrokeColor( color );
 }
 else
 {
 // Filled mode
 m_gal->SetIsFill( true );
 m_gal->SetIsStroke( false );
 m_gal->SetFillColor( color );
 }

 if( aLayer == LAYER_VIA_HOLES )
 {
 m_gal->DrawCircle( center, getDrillSize( aVia ) / 2.0 );
 }
 else if( aLayer == LAYER_VIA_THROUGH || m_pcbSettings.GetDrawIndividualViaLayers() )
 {
 m_gal->DrawCircle( center, aVia->GetWidth() / 2.0 );
 }
 else if( aLayer == LAYER_VIA_BBLIND || aLayer == LAYER_VIA_MICROVIA )
 {
 // Outer circles of blind/buried and micro-vias are drawn in a special way to indicate the
 // top and bottom layers
 PCB_LAYER_ID layerTop, layerBottom;
 aVia->LayerPair( &layerTop, &layerBottom );

 double radius = aVia->GetWidth() / 2.0;

 if( !sketchMode )
 m_gal->SetLineWidth( ( aVia->GetWidth() - aVia->GetDrillValue() ) / 2.0 );

 m_gal->DrawArc( center, radius, M_PI * -0.375, M_PI * 0.375 );
 m_gal->DrawArc( center, radius, M_PI * 0.625, M_PI * 1.375 );

 if( sketchMode )
 m_gal->SetStrokeColor( m_pcbSettings.GetColor( aVia, layerTop ) );
 else
 m_gal->SetFillColor( m_pcbSettings.GetColor( aVia, layerTop ) );

 m_gal->DrawArc( center, radius, M_PI * 1.375, M_PI * 1.625 );

 if( sketchMode )
 m_gal->SetStrokeColor( m_pcbSettings.GetColor( aVia, layerBottom ) );
 else
 m_gal->SetFillColor( m_pcbSettings.GetColor( aVia, layerBottom ) );

 m_gal->DrawArc( center, radius, M_PI * 0.375, M_PI * 0.625 );
 }

 // Clearance lines
 constexpr int clearanceFlags = PCB_RENDER_SETTINGS::CL_EXISTING | PCB_RENDER_SETTINGS::CL_VIAS;

 if( ( m_pcbSettings.m_clearanceDisplayFlags & clearanceFlags ) == clearanceFlags
 && aLayer != LAYER_VIA_HOLES )
 {
 PCB_LAYER_ID activeLayer = m_pcbSettings.GetActiveLayer();
 double radius;

 if( aVia->FlashLayer( activeLayer ) )
 radius = aVia->GetWidth() / 2.0;
 else
 radius = getDrillSize( aVia ) / 2.0 + m_holePlatingThickness;

 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( color );
 m_gal->DrawCircle( center, radius + aVia->GetOwnClearance( activeLayer ) );
 }
}

References KIGFX::GAL::BitmapText(), BLIND_BURIED, KIGFX::PCB_RENDER_SETTINGS::CL_EXISTING, KIGFX::PCB_RENDER_SETTINGS::CL_VIAS, KIGFX::COLOR4D::CLEAR, color, KIGFX::GAL::DrawArc(), KIGFX::GAL::DrawCircle(), PCB_VIA::FlashLayer(), KIGFX::RENDER_SETTINGS::GetActiveLayer(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), KIGFX::PCB_RENDER_SETTINGS::GetDrawIndividualViaLayers(), KIGFX::PCB_PAINTER::getDrillSize(), PCB_VIA::GetDrillValue(), BOARD_CONNECTED_ITEM::GetNetname(), BOARD_CONNECTED_ITEM::GetOwnClearance(), BOARD_CONNECTED_ITEM::GetShortNetname(), PCB_TRACK::GetStart(), PCB_VIA::GetViaType(), PCB_TRACK::GetWidth(), IsNetnameLayer(), LAYER_VIA_BBLIND, LAYER_VIA_HOLES, LAYER_VIA_HOLEWALLS, LAYER_VIA_MICROVIA, LAYER_VIA_THROUGH, PCB_VIA::LayerPair(), KIGFX::PCB_RENDER_SETTINGS::m_clearanceDisplayFlags, KIGFX::PAINTER::m_gal, KIGFX::PCB_PAINTER::m_holePlatingThickness, KIGFX::PCB_RENDER_SETTINGS::m_netNamesOnVias, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, KIGFX::PCB_RENDER_SETTINGS::MAX_FONT_SIZE, MICROVIA, PrintableCharCount(), KIGFX::GAL::ResetTextAttributes(), KIGFX::GAL::Restore(), KIGFX::GAL::Save(), KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), THROUGH, KIGFX::GAL::Translate(), UnescapeString(), and VECTOR2< T >::x.

draw() [4/13]

void PCB_PAINTER::draw ( const PAD *  aPad, int  aLayer  )

protectedinherited

Definition at line 907 of file pcb_painter.cpp.

{
 COLOR4D color = m_pcbSettings.GetColor( aPad, aLayer );

 if( IsNetnameLayer( aLayer ) )
 {
 wxString netname;
 wxString padNumber;

 if( m_pcbSettings.m_padNumbers )
 padNumber = UnescapeString( aPad->GetNumber() );

 if( m_pcbSettings.m_netNamesOnPads )
 netname = UnescapeString( aPad->GetShortNetname() );

 if( aPad->GetBoard()->IsElementVisible( LAYER_NO_CONNECTS )
 && aPad->GetShortNetname().StartsWith( wxT( "unconnected-(" ) ) )
 {
 wxString pinType = aPad->GetPinType();

 if( pinType == wxT( "no_connect" ) || pinType.EndsWith( wxT( "+no_connect" ) ) )
 netname = wxT( "x" );
 else if( pinType == wxT( "free" ) )
 netname = wxT( "*" );
 }

 if( netname.IsEmpty() && padNumber.IsEmpty() )
 return;

 EDA_RECT padBBox = aPad->GetBoundingBox();
 VECTOR2D position = padBBox.Centre();
 VECTOR2D padsize = VECTOR2D( padBBox.GetSize() );

 if( aPad->GetShape() != PAD_SHAPE::CUSTOM )
 {
 // Don't allow a 45° rotation to bloat a pad's bounding box unnecessarily
 double limit = std::min( aPad->GetSize().x, aPad->GetSize().y ) * 1.1;

 if( padsize.x > limit && padsize.y > limit )
 {
 padsize.x = limit;
 padsize.y = limit;
 }
 }

 double maxSize = PCB_RENDER_SETTINGS::MAX_FONT_SIZE;
 double size = padsize.y;

 m_gal->Save();
 m_gal->Translate( position );

 // Keep the size ratio for the font, but make it smaller
 if( padsize.x < padsize.y )
 {
 m_gal->Rotate( DECIDEG2RAD( -900.0 ) );
 size = padsize.x;
 std::swap( padsize.x, padsize.y );
 }

 // Font size limits
 if( size > maxSize )
 size = maxSize;

 // Default font settings
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
 m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_CENTER );
 m_gal->SetFontBold( false );
 m_gal->SetFontItalic( false );
 m_gal->SetFontUnderlined( false );
 m_gal->SetTextMirrored( false );
 m_gal->SetStrokeColor( m_pcbSettings.GetColor( aPad, aLayer ) );
 m_gal->SetIsStroke( true );
 m_gal->SetIsFill( false );

 // We have already translated the GAL to be centered at the center of the pad's
 // bounding box
 VECTOR2D textpos( 0.0, 0.0 );

 // Divide the space, to display both pad numbers and netnames and set the Y text
 // position to display 2 lines
 if( !netname.IsEmpty() && !padNumber.IsEmpty() )
 {
 size = size / 2.5;
 textpos.y = size / 1.7;
 }

 if( !netname.IsEmpty() )
 {
 // approximate the size of net name text:
 double tsize = 1.5 * padsize.x / std::max( PrintableCharCount( netname ), 1 );
 tsize = std::min( tsize, size );

 // Use a smaller text size to handle interline, pen size...
 tsize *= 0.7;
 VECTOR2D namesize( tsize, tsize );

 m_gal->SetGlyphSize( namesize );
 m_gal->SetLineWidth( namesize.x / 12.0 );
 m_gal->BitmapText( netname, textpos, 0.0 );
 }

 if( !padNumber.IsEmpty() )
 {
 textpos.y = -textpos.y;

 // approximate the size of the pad number text:
 double tsize = 1.5 * padsize.x / std::max( PrintableCharCount( padNumber ), 1 );
 tsize = std::min( tsize, size );

 // Use a smaller text size to handle interline, pen size...
 tsize *= 0.7;
 tsize = std::min( tsize, size );
 VECTOR2D numsize( tsize, tsize );

 m_gal->SetGlyphSize( numsize );
 m_gal->SetLineWidth( numsize.x / 12.0 );
 m_gal->BitmapText( padNumber, textpos, 0.0 );
 }

 m_gal->Restore();

 return;
 }
 else if( aLayer == LAYER_PAD_HOLEWALLS )
 {
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( m_holePlatingThickness );
 m_gal->SetStrokeColor( color );

 const SHAPE_SEGMENT* seg = aPad->GetEffectiveHoleShape();
 int holeSize = seg->GetWidth() + m_holePlatingThickness;

 if( seg->GetSeg().A == seg->GetSeg().B ) // Circular hole
 m_gal->DrawCircle( seg->GetSeg().A, holeSize / 2 );
 else
 m_gal->DrawSegment( seg->GetSeg().A, seg->GetSeg().B, holeSize );

 return;
 }

 if( m_pcbSettings.m_sketchMode[LAYER_PADS_TH] )
 {
 // Outline mode
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 m_gal->SetStrokeColor( color );
 }
 else
 {
 // Filled mode
 m_gal->SetIsFill( true );
 m_gal->SetIsStroke( false );
 m_gal->SetFillColor( color );
 }

 if( aLayer == LAYER_PAD_PLATEDHOLES || aLayer == LAYER_NON_PLATEDHOLES )
 {
 const SHAPE_SEGMENT* seg = aPad->GetEffectiveHoleShape();

 if( seg->GetSeg().A == seg->GetSeg().B ) // Circular hole
 m_gal->DrawCircle( seg->GetSeg().A, getDrillSize( aPad ).x / 2 );
 else
 m_gal->DrawSegment( seg->GetSeg().A, seg->GetSeg().B, seg->GetWidth() );
 }
 else
 {
 wxSize pad_size = aPad->GetSize();
 wxSize margin;

 switch( aLayer )
 {
 case F_Mask:
 case B_Mask:
 margin.x = margin.y = aPad->GetSolderMaskMargin();
 break;

 case F_Paste:
 case B_Paste:
 margin = aPad->GetSolderPasteMargin();
 break;

 default:
 margin.x = margin.y = 0;
 break;
 }

 std::unique_ptr<PAD> dummyPad;
 std::shared_ptr<SHAPE_COMPOUND> shapes;

 // Drawing components of compound shapes in outline mode produces a mess.
 bool simpleShapes = !m_pcbSettings.m_sketchMode[LAYER_PADS_TH];

 if( simpleShapes )
 {
 if( ( margin.x != margin.y && aPad->GetShape() != PAD_SHAPE::CUSTOM )
 || ( aPad->GetShape() == PAD_SHAPE::ROUNDRECT && ( margin.x < 0 || margin.y < 0 ) ) )
 {
 // Our algorithms below (polygon inflation in particular) can't handle differential
 // inflation along separate axes. So for those cases we build a dummy pad instead,
 // and inflate it.

 // Margin is added to both sides. If the total margin is larger than the pad
 // then don't display this layer
 if( pad_size.x + 2 * margin.x <= 0 || pad_size.y + 2 * margin.y <= 0 )
 return;

 dummyPad.reset( static_cast<PAD*>( aPad->Duplicate() ) );
 int initial_radius = dummyPad->GetRoundRectCornerRadius();

 dummyPad->SetSize( pad_size + margin + margin );

 if( dummyPad->GetShape() == PAD_SHAPE::ROUNDRECT )
 {
 // To keep the right margin around the corners, we need to modify the corner radius.
 // We must have only one radius correction, so use the smallest absolute margin.
 int radius_margin = std::max( margin.x, margin.y ); // radius_margin is < 0
 dummyPad->SetRoundRectCornerRadius( std::max( initial_radius + radius_margin, 0 ) );
 }

 shapes = std::dynamic_pointer_cast<SHAPE_COMPOUND>( dummyPad->GetEffectiveShape() );
 margin.x = margin.y = 0;
 }
 else
 {
 shapes = std::dynamic_pointer_cast<SHAPE_COMPOUND>( aPad->GetEffectiveShape() );
 }

 if( aPad->GetShape() == PAD_SHAPE::CUSTOM && ( margin.x || margin.y ) )
 {
 // We can't draw as shapes because we don't know which edges are internal and which
 // are external (so we don't know when to apply the margin and when not to).
 simpleShapes = false;
 }

 for( const SHAPE* shape : shapes->Shapes() )
 {
 if( !simpleShapes )
 break;

 switch( shape->Type() )
 {
 case SH_SEGMENT:
 case SH_CIRCLE:
 case SH_RECT:
 case SH_SIMPLE:
 // OK so far
 break;

 default:
 // Not OK
 simpleShapes = false;
 break;
 }
 }
 }

 if( simpleShapes )
 {
 for( const SHAPE* shape : shapes->Shapes() )
 {
 switch( shape->Type() )
 {
 case SH_SEGMENT:
 {
 const SHAPE_SEGMENT* seg = (const SHAPE_SEGMENT*) shape;
 int effectiveWidth = seg->GetWidth() + 2 * margin.x;

 if( effectiveWidth > 0 )
 m_gal->DrawSegment( seg->GetSeg().A, seg->GetSeg().B, effectiveWidth );

 break;
 }

 case SH_CIRCLE:
 {
 const SHAPE_CIRCLE* circle = (const SHAPE_CIRCLE*) shape;
 int effectiveRadius = circle->GetRadius() + margin.x;

 if( effectiveRadius > 0 )
 m_gal->DrawCircle( circle->GetCenter(), effectiveRadius );

 break;
 }

 case SH_RECT:
 {
 const SHAPE_RECT* r = (const SHAPE_RECT*) shape;
 VECTOR2I pos = r->GetPosition();
 VECTOR2I effectiveMargin = margin;

 if( effectiveMargin.x < 0 )
 {
 // A negative margin just produces a smaller rect.
 VECTOR2I effectiveSize = r->GetSize() + effectiveMargin;

 if( effectiveSize.x > 0 && effectiveSize.y > 0 )
 m_gal->DrawRectangle( pos - effectiveMargin, pos + effectiveSize );
 }
 else if( effectiveMargin.x > 0 )
 {
 // A positive margin produces a larger rect, but with rounded corners
 m_gal->DrawRectangle( r->GetPosition(), r->GetPosition() + r->GetSize() );

 // Use segments to produce the margin with rounded corners
 m_gal->DrawSegment( pos,
 pos + VECTOR2I( r->GetWidth(), 0 ),
 effectiveMargin.x * 2 );
 m_gal->DrawSegment( pos + VECTOR2I( r->GetWidth(), 0 ),
 pos + r->GetSize(),
 effectiveMargin.x * 2 );
 m_gal->DrawSegment( pos + r->GetSize(),
 pos + VECTOR2I( 0, r->GetHeight() ),
 effectiveMargin.x * 2 );
 m_gal->DrawSegment( pos + VECTOR2I( 0, r->GetHeight() ),
 pos,
 effectiveMargin.x * 2 );
 }
 else
 {
 m_gal->DrawRectangle( r->GetPosition(), r->GetPosition() + r->GetSize() );
 }

 break;
 }

 case SH_SIMPLE:
 {
 const SHAPE_SIMPLE* poly = static_cast<const SHAPE_SIMPLE*>( shape );

 if( margin.x < 0 ) // The poly shape must be deflated
 {
 int numSegs = GetArcToSegmentCount( -margin.x, m_maxError, 360.0 );
 SHAPE_POLY_SET outline;
 outline.NewOutline();

 for( int ii = 0; ii < poly->PointCount(); ++ii )
 outline.Append( poly->CPoint( ii ) );

 outline.Deflate( -margin.x, numSegs );

 m_gal->DrawPolygon( outline );
 }
 else
 {
 m_gal->DrawPolygon( poly->Vertices() );
 }

 // Now add on a rounded margin (using segments) if the margin > 0
 if( margin.x > 0 )
 {
 for( size_t ii = 0; ii < poly->GetSegmentCount(); ++ii )
 {
 SEG seg = poly->GetSegment( ii );
 m_gal->DrawSegment( seg.A, seg.B, margin.x * 2 );
 }
 }

 break;
 }

 default:
 // Better not get here; we already pre-flighted the shapes...
 break;
 }
 }
 }
 else
 {
 // This is expensive. Avoid if possible.
 SHAPE_POLY_SET polySet;
 aPad->TransformShapeWithClearanceToPolygon( polySet, ToLAYER_ID( aLayer ), margin.x,
 m_maxError, ERROR_INSIDE );
 m_gal->DrawPolygon( polySet );
 }
 }

 constexpr int clearanceFlags = PCB_RENDER_SETTINGS::CL_PADS;

 if( ( m_pcbSettings.m_clearanceDisplayFlags & clearanceFlags ) == clearanceFlags
 && ( aLayer == LAYER_PAD_FR || aLayer == LAYER_PAD_BK || aLayer == LAYER_PADS_TH ) )
 {
 /* Showing the clearance area is not obvious.
 * - A pad can be removed from some copper layers.
 * - For non copper layers, what is the clearance area?
 * So for copper layers, the clearance area is the shape if the pad is flashed on this
 * layer and the hole clearance area for other copper layers.
 * For other layers, use the pad shape, although one can use an other criteria,
 * depending on the non copper layer.
 */
 int activeLayer = m_pcbSettings.GetActiveLayer();
 bool flashActiveLayer = true;

 if( IsCopperLayer( activeLayer ) )
 flashActiveLayer = aPad->FlashLayer( activeLayer );

 if( flashActiveLayer || aPad->GetDrillSize().x )
 {
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 m_gal->SetIsStroke( true );
 m_gal->SetIsFill( false );
 m_gal->SetStrokeColor( color );

 int clearance = aPad->GetOwnClearance( m_pcbSettings.GetActiveLayer() );

 if( flashActiveLayer && clearance > 0 )
 {
 auto shape = std::dynamic_pointer_cast<SHAPE_COMPOUND>( aPad->GetEffectiveShape() );

 if( shape && shape->Size() == 1 && shape->Shapes()[0]->Type() == SH_SEGMENT )
 {
 const SHAPE_SEGMENT* seg = (SHAPE_SEGMENT*) shape->Shapes()[0];
 m_gal->DrawSegment( seg->GetSeg().A, seg->GetSeg().B,
 seg->GetWidth() + 2 * clearance );
 }
 else if( shape && shape->Size() == 1 && shape->Shapes()[0]->Type() == SH_CIRCLE )
 {
 const SHAPE_CIRCLE* circle = (SHAPE_CIRCLE*) shape->Shapes()[0];
 m_gal->DrawCircle( circle->GetCenter(), circle->GetRadius() + clearance );
 }
 else
 {
 SHAPE_POLY_SET polySet;

 // Use ERROR_INSIDE because it avoids Clipper and is therefore much faster.
 aPad->TransformShapeWithClearanceToPolygon( polySet, ToLAYER_ID( aLayer ),
 clearance, m_maxError, ERROR_INSIDE );
 m_gal->DrawPolygon( polySet );
 }
 }
 else if( aPad->GetEffectiveHoleShape() && clearance > 0 )
 {
 clearance += m_holePlatingThickness;

 const SHAPE_SEGMENT* seg = aPad->GetEffectiveHoleShape();
 m_gal->DrawSegment( seg->GetSeg().A, seg->GetSeg().B,
 seg->GetWidth() + 2 * clearance );
 }
 }
 }
}

References SEG::A, SHAPE_POLY_SET::Append(), SEG::B, B_Mask, B_Paste, KIGFX::GAL::BitmapText(), EDA_RECT::Centre(), KIGFX::PCB_RENDER_SETTINGS::CL_PADS, color, SHAPE_SIMPLE::CPoint(), CUSTOM, DECIDEG2RAD(), SHAPE_POLY_SET::Deflate(), KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawRectangle(), KIGFX::GAL::DrawSegment(), BOARD_ITEM::Duplicate(), ERROR_INSIDE, F_Mask, F_Paste, PAD::FlashLayer(), KIGFX::RENDER_SETTINGS::GetActiveLayer(), GetArcToSegmentCount(), BOARD_ITEM::GetBoard(), PAD::GetBoundingBox(), SHAPE_CIRCLE::GetCenter(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), PAD::GetDrillSize(), KIGFX::PCB_PAINTER::getDrillSize(), PAD::GetEffectiveHoleShape(), PAD::GetEffectiveShape(), PAD::GetNumber(), BOARD_CONNECTED_ITEM::GetOwnClearance(), PAD::GetPinType(), SHAPE_CIRCLE::GetRadius(), SHAPE_SEGMENT::GetSeg(), SHAPE_SIMPLE::GetSegment(), SHAPE_SIMPLE::GetSegmentCount(), PAD::GetShape(), BOARD_CONNECTED_ITEM::GetShortNetname(), EDA_RECT::GetSize(), PAD::GetSize(), PAD::GetSolderMaskMargin(), PAD::GetSolderPasteMargin(), SHAPE_SEGMENT::GetWidth(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, IsCopperLayer(), BOARD::IsElementVisible(), IsNetnameLayer(), LAYER_NO_CONNECTS, LAYER_NON_PLATEDHOLES, LAYER_PAD_BK, LAYER_PAD_FR, LAYER_PAD_HOLEWALLS, LAYER_PAD_PLATEDHOLES, LAYER_PADS_TH, KIGFX::PCB_RENDER_SETTINGS::m_clearanceDisplayFlags, KIGFX::PAINTER::m_gal, KIGFX::PCB_PAINTER::m_holePlatingThickness, KIGFX::PCB_PAINTER::m_maxError, KIGFX::PCB_RENDER_SETTINGS::m_netNamesOnPads, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_RENDER_SETTINGS::m_padNumbers, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, KIGFX::PCB_RENDER_SETTINGS::MAX_FONT_SIZE, SHAPE_POLY_SET::NewOutline(), SHAPE_SIMPLE::PointCount(), PrintableCharCount(), r, KIGFX::GAL::Restore(), KIGFX::GAL::Rotate(), ROUNDRECT, KIGFX::GAL::Save(), 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(), SH_CIRCLE, SH_RECT, SH_SEGMENT, SH_SIMPLE, ToLAYER_ID(), PAD::TransformShapeWithClearanceToPolygon(), KIGFX::GAL::Translate(), UnescapeString(), SHAPE_SIMPLE::Vertices(), VECTOR2< T >::x, and VECTOR2< T >::y.

draw() [5/13]

void PCB_PAINTER::draw ( const PCB_SHAPE *  aSegment, int  aLayer  )

protectedinherited

Definition at line 1351 of file pcb_painter.cpp.

{
 const COLOR4D& color = m_pcbSettings.GetColor( aShape, aShape->GetLayer() );
 bool sketch = m_pcbSettings.m_sketchGraphics;
 int thickness = getLineThickness( aShape->GetWidth() );

 if( sketch )
 {
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 }

 m_gal->SetFillColor( color );
 m_gal->SetStrokeColor( color );

 switch( aShape->GetShape() )
 {
 case SHAPE_T::SEGMENT:
 if( sketch )
 {
 m_gal->DrawSegment( aShape->GetStart(), aShape->GetEnd(), thickness );
 }
 else
 {
 m_gal->SetIsFill( true );
 m_gal->SetIsStroke( false );

 m_gal->DrawSegment( aShape->GetStart(), aShape->GetEnd(), thickness );
 }

 break;

 case SHAPE_T::RECT:
 {
 std::vector<wxPoint> pts = aShape->GetRectCorners();

 if( sketch )
 {
 m_gal->DrawSegment( pts[0], pts[1], thickness );
 m_gal->DrawSegment( pts[1], pts[2], thickness );
 m_gal->DrawSegment( pts[2], pts[3], thickness );
 m_gal->DrawSegment( pts[3], pts[0], thickness );
 }
 else
 {
 m_gal->SetIsFill( true );
 m_gal->SetIsStroke( false );

 if( thickness > 0 )
 {
 m_gal->DrawSegment( pts[0], pts[1], thickness );
 m_gal->DrawSegment( pts[1], pts[2], thickness );
 m_gal->DrawSegment( pts[2], pts[3], thickness );
 m_gal->DrawSegment( pts[3], pts[0], thickness );
 }

 if( aShape->IsFilled() )
 {
 SHAPE_POLY_SET poly;
 poly.NewOutline();

 for( const wxPoint& pt : pts )
 poly.Append( pt );

 m_gal->DrawPolygon( poly );
 }
 }

 break;
 }

 case SHAPE_T::ARC:
 {
 double startAngle;
 double endAngle;
 aShape->CalcArcAngles( startAngle, endAngle );

 if( sketch )
 {
 m_gal->DrawArcSegment( aShape->GetCenter(), aShape->GetRadius(),
 DEG2RAD( startAngle ), DEG2RAD( endAngle ), thickness,
 m_maxError );
 }
 else
 {
 m_gal->SetIsFill( true );
 m_gal->SetIsStroke( false );

 m_gal->DrawArcSegment( aShape->GetCenter(), aShape->GetRadius(),
 DEG2RAD( startAngle ), DEG2RAD( endAngle ), thickness,
 m_maxError );
 }
 break;
 }

 case SHAPE_T::CIRCLE:
 if( sketch )
 {
 m_gal->DrawCircle( aShape->GetStart(), aShape->GetRadius() - thickness / 2 );
 m_gal->DrawCircle( aShape->GetStart(), aShape->GetRadius() + thickness / 2 );
 }
 else
 {
 m_gal->SetIsFill( aShape->IsFilled() );
 m_gal->SetIsStroke( thickness > 0 );
 m_gal->SetLineWidth( thickness );

 m_gal->DrawCircle( aShape->GetStart(), aShape->GetRadius() );
 }
 break;

 case SHAPE_T::POLY:
 {
 SHAPE_POLY_SET& shape = const_cast<PCB_SHAPE*>( aShape )->GetPolyShape();
 const FOOTPRINT* parentFootprint = aShape->GetParentFootprint();

 if( shape.OutlineCount() == 0 )
 break;

 if( parentFootprint )
 {
 m_gal->Save();
 m_gal->Translate( parentFootprint->GetPosition() );
 m_gal->Rotate( -parentFootprint->GetOrientationRadians() );
 }

 if( sketch )
 {
 for( int ii = 0; ii < shape.Outline( 0 ).SegmentCount(); ++ii )
 {
 SEG seg = shape.Outline( 0 ).Segment( ii );
 m_gal->DrawSegment( seg.A, seg.B, thickness );
 }
 }
 else
 {
 m_gal->SetIsFill( true );
 m_gal->SetIsStroke( false );

 if( thickness > 0 )
 {
 for( int ii = 0; ii < shape.Outline( 0 ).SegmentCount(); ++ii )
 {
 SEG seg = shape.Outline( 0 ).Segment( ii );
 m_gal->DrawSegment( seg.A, seg.B, thickness );
 }
 }

 if( aShape->IsFilled() )
 {
 // On Opengl, a not convex filled polygon is usually drawn by using triangles
 // as primitives. CacheTriangulation() can create basic triangle primitives to
 // draw the polygon solid shape on Opengl. GLU tessellation is much slower, so
 // currently we are using our tessellation.
 if( m_gal->IsOpenGlEngine() && !shape.IsTriangulationUpToDate() )
 shape.CacheTriangulation();

 m_gal->DrawPolygon( shape );
 }
 }

 if( parentFootprint )
 m_gal->Restore();

 break;
 }

 case SHAPE_T::BEZIER:
 if( sketch )
 {
 std::vector<VECTOR2D> output;
 std::vector<VECTOR2D> pointCtrl;

 pointCtrl.push_back( aShape->GetStart() );
 pointCtrl.push_back( aShape->GetBezierC1() );
 pointCtrl.push_back( aShape->GetBezierC2() );
 pointCtrl.push_back( aShape->GetEnd() );

 BEZIER_POLY converter( pointCtrl );
 converter.GetPoly( output, thickness );

 for( unsigned ii = 0; ii + 1 < output.size(); ++ii )
 m_gal->DrawSegment( output[ii], output[ii+1], thickness );
 }
 else
 {
 m_gal->SetIsFill( aShape->IsFilled() );
 m_gal->SetIsStroke( thickness > 0 );
 m_gal->SetLineWidth( thickness );

 // Use thickness as filter value to convert the curve to polyline when the curve
 // is not supported
 m_gal->DrawCurve( VECTOR2D( aShape->GetStart() ),
 VECTOR2D( aShape->GetBezierC1() ),
 VECTOR2D( aShape->GetBezierC2() ),
 VECTOR2D( aShape->GetEnd() ), thickness );
 }

 break;

 case SHAPE_T::LAST:
 break;
 }
}

References SEG::A, SHAPE_POLY_SET::Append(), ARC, SEG::B, BEZIER, SHAPE_POLY_SET::CacheTriangulation(), EDA_SHAPE::CalcArcAngles(), CIRCLE, color, DEG2RAD(), KIGFX::GAL::DrawArcSegment(), KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawCurve(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawSegment(), EDA_SHAPE::GetBezierC1(), EDA_SHAPE::GetBezierC2(), PCB_SHAPE::GetCenter(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), EDA_SHAPE::GetEnd(), BOARD_ITEM::GetLayer(), KIGFX::PCB_PAINTER::getLineThickness(), FOOTPRINT::GetOrientationRadians(), PCB_SHAPE::GetParentFootprint(), BEZIER_POLY::GetPoly(), FOOTPRINT::GetPosition(), EDA_SHAPE::GetRadius(), EDA_SHAPE::GetRectCorners(), EDA_SHAPE::GetShape(), EDA_SHAPE::GetStart(), EDA_SHAPE::GetWidth(), EDA_SHAPE::IsFilled(), KIGFX::GAL::IsOpenGlEngine(), SHAPE_POLY_SET::IsTriangulationUpToDate(), LAST, KIGFX::PAINTER::m_gal, KIGFX::PCB_PAINTER::m_maxError, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchGraphics, SHAPE_POLY_SET::NewOutline(), SHAPE_POLY_SET::Outline(), SHAPE_POLY_SET::OutlineCount(), POLY, RECT, KIGFX::GAL::Restore(), KIGFX::GAL::Rotate(), KIGFX::GAL::Save(), SEGMENT, SHAPE_LINE_CHAIN::Segment(), SHAPE_LINE_CHAIN::SegmentCount(), KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), and KIGFX::GAL::Translate().

draw() [6/13]

void PCB_PAINTER::draw ( const PCB_TEXT *  aText, int  aLayer  )

protectedinherited

Definition at line 1558 of file pcb_painter.cpp.

{
 wxString shownText( aText->GetShownText() );

 if( shownText.Length() == 0 )
 return;

 const COLOR4D& color = m_pcbSettings.GetColor( aText, aText->GetLayer() );
 VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );

 if( m_pcbSettings.m_sketchText || m_pcbSettings.m_sketchMode[aLayer] )
 {
 // Outline mode
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 }
 else
 {
 // Filled mode
 m_gal->SetLineWidth( getLineThickness( aText->GetEffectiveTextPenWidth() ) );
 }

 m_gal->SetStrokeColor( color );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetTextAttributes( aText );
 m_gal->StrokeText( shownText, position, aText->GetTextAngleRadians() );
}

References color, KIGFX::PCB_RENDER_SETTINGS::GetColor(), EDA_TEXT::GetEffectiveTextPenWidth(), BOARD_ITEM::GetLayer(), KIGFX::PCB_PAINTER::getLineThickness(), PCB_TEXT::GetShownText(), EDA_TEXT::GetTextAngleRadians(), EDA_TEXT::GetTextPos(), KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, KIGFX::PCB_RENDER_SETTINGS::m_sketchText, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextAttributes(), and KIGFX::GAL::StrokeText().

draw() [7/13]

void PCB_PAINTER::draw ( const FP_TEXT *  aText, int  aLayer  )

protectedinherited

Definition at line 1587 of file pcb_painter.cpp.

{
 wxString shownText( aText->GetShownText() );

 if( shownText.Length() == 0 )
 return;

 const COLOR4D& color = m_pcbSettings.GetColor( aText, aLayer );
 VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );

 if( m_pcbSettings.m_sketchText )
 {
 // Outline mode
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 }
 else
 {
 // Filled mode
 m_gal->SetLineWidth( getLineThickness( aText->GetEffectiveTextPenWidth() ) );
 }

 m_gal->SetStrokeColor( color );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetTextAttributes( aText );
 m_gal->StrokeText( shownText, position, aText->GetDrawRotationRadians() );

 // Draw the umbilical line
 if( aText->IsSelected() )
 {
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 m_gal->SetStrokeColor( m_pcbSettings.GetColor( nullptr, LAYER_ANCHOR ) );
 m_gal->DrawLine( position, aText->GetParent()->GetPosition() );
 }
}

References color, KIGFX::GAL::DrawLine(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), FP_TEXT::GetDrawRotationRadians(), EDA_TEXT::GetEffectiveTextPenWidth(), KIGFX::PCB_PAINTER::getLineThickness(), BOARD_ITEM::GetParent(), EDA_ITEM::GetPosition(), FP_TEXT::GetShownText(), EDA_TEXT::GetTextPos(), EDA_ITEM::IsSelected(), LAYER_ANCHOR, KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchText, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextAttributes(), and KIGFX::GAL::StrokeText().

draw() [8/13]

void PCB_PAINTER::draw ( const FOOTPRINT *  aFootprint, int  aLayer  )

protectedinherited

Definition at line 1624 of file pcb_painter.cpp.

{
 if( aLayer == LAYER_ANCHOR )
 {
 const COLOR4D color = m_pcbSettings.GetColor( aFootprint, aLayer );

 // Keep the size and width constant, not related to the scale because the anchor
 // is just a marker on screen
 double anchorSize = 5.0 / m_gal->GetWorldScale(); // 5 pixels size
 double anchorThickness = 1.0 / m_gal->GetWorldScale(); // 1 pixels width

 // Draw anchor
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetStrokeColor( color );
 m_gal->SetLineWidth( anchorThickness );

 VECTOR2D center = aFootprint->GetPosition();
 m_gal->DrawLine( center - VECTOR2D( anchorSize, 0 ), center + VECTOR2D( anchorSize, 0 ) );
 m_gal->DrawLine( center - VECTOR2D( 0, anchorSize ), center + VECTOR2D( 0, anchorSize ) );
 }
}

References color, KIGFX::GAL::DrawLine(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), FOOTPRINT::GetPosition(), KIGFX::GAL::GetWorldScale(), LAYER_ANCHOR, KIGFX::PAINTER::m_gal, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

draw() [9/13]

void PCB_PAINTER::draw ( const PCB_GROUP *  aGroup, int  aLayer  )

protectedinherited

Definition at line 1648 of file pcb_painter.cpp.

{
 if( aLayer == LAYER_ANCHOR )
 {
 if( aGroup->IsSelected() && !( aGroup->GetParent() && aGroup->GetParent()->IsSelected() ) )
 {
 // Selected on our own; draw enclosing box
 }
 else if( aGroup->IsEntered() )
 {
 // Entered group; draw enclosing box
 }
 else
 {
 // Neither selected nor entered; draw nothing at the group level (ie: only draw
 // its members)
 return;
 }

 const COLOR4D color = m_pcbSettings.GetColor( aGroup, LAYER_ANCHOR );

 EDA_RECT bbox = aGroup->GetBoundingBox();
 m_gal->SetStrokeColor( color );
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth * 2.0f );
 wxPoint topLeft = bbox.GetPosition();
 wxPoint width = wxPoint( bbox.GetWidth(), 0 );
 wxPoint height = wxPoint( 0, bbox.GetHeight() );

 m_gal->DrawLine( topLeft, topLeft + width );
 m_gal->DrawLine( topLeft + width, topLeft + width + height );
 m_gal->DrawLine( topLeft + width + height, topLeft + height );
 m_gal->DrawLine( topLeft + height, topLeft );

 wxString name = aGroup->GetName();

 if( name.IsEmpty() )
 return;

 int ptSize = 12;
 int scaledSize = abs( KiROUND( m_gal->GetScreenWorldMatrix().GetScale().x * ptSize ) );
 int unscaledSize = Mils2iu( ptSize );

 // Scale by zoom a bit, but not too much
 int textSize = ( scaledSize + ( unscaledSize * 2 ) ) / 3;
 int penWidth = textSize / 10;
 wxPoint textOffset = wxPoint( width.x / 2, - KiROUND( textSize * 0.5 ) );
 wxPoint titleHeight = wxPoint( 0, KiROUND( textSize * 2.0 ) );

 if( PrintableCharCount( name ) * textSize < bbox.GetWidth() )
 {
 m_gal->DrawLine( topLeft, topLeft - titleHeight );
 m_gal->DrawLine( topLeft - titleHeight, topLeft + width - titleHeight );
 m_gal->DrawLine( topLeft + width - titleHeight, topLeft + width );

 m_gal->SetFontBold( false );
 m_gal->SetFontItalic( true );
 m_gal->SetFontUnderlined( false );
 m_gal->SetTextMirrored( m_gal->IsFlippedX() );
 m_gal->SetHorizontalJustify( GR_TEXT_HJUSTIFY_CENTER );
  m_gal->SetVerticalJustify( GR_TEXT_VJUSTIFY_BOTTOM );
 m_gal->SetIsFill( false );
 m_gal->SetGlyphSize( VECTOR2D( textSize, textSize ) );
 m_gal->SetLineWidth( penWidth );
 m_gal->StrokeText( aGroup->GetName(), topLeft + textOffset, 0.0 );
 }
 }
}

References color, KIGFX::GAL::DrawLine(), PCB_GROUP::GetBoundingBox(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), EDA_RECT::GetHeight(), PCB_GROUP::GetName(), BOARD_ITEM::GetParent(), EDA_RECT::GetPosition(), MATRIX3x3< T >::GetScale(), KIGFX::GAL::GetScreenWorldMatrix(), EDA_RECT::GetWidth(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_BOTTOM, EDA_ITEM::IsEntered(), KIGFX::GAL::IsFlippedX(), EDA_ITEM::IsSelected(), KiROUND(), LAYER_ANCHOR, KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_PAINTER::m_pcbSettings, name, PrintableCharCount(), KIGFX::GAL::SetFontBold(), KIGFX::GAL::SetFontItalic(), KIGFX::GAL::SetFontUnderlined(), KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetHorizontalJustify(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextMirrored(), KIGFX::GAL::SetVerticalJustify(), KIGFX::GAL::StrokeText(), and VECTOR2< T >::x.

draw() [10/13]

void PCB_PAINTER::draw ( const ZONE *  aZone, int  aLayer  )

protectedinherited

Definition at line 1717 of file pcb_painter.cpp.

{
 /*
 * aLayer will be the virtual zone layer (LAYER_ZONE_START, ... in GAL_LAYER_ID)
 * This is used for draw ordering in the GAL.
 * The color for the zone comes from the associated copper layer ( aLayer - LAYER_ZONE_START )
 * and the visibility comes from the combination of that copper layer and LAYER_ZONES
 */
 wxASSERT( IsZoneLayer( aLayer ) );
 PCB_LAYER_ID layer = static_cast<PCB_LAYER_ID>( aLayer - LAYER_ZONE_START );

 if( !aZone->IsOnLayer( layer ) )
 return;

 COLOR4D color = m_pcbSettings.GetColor( aZone, layer );
 std::deque<VECTOR2D> corners;
 ZONE_DISPLAY_MODE displayMode = m_pcbSettings.m_zoneDisplayMode;

 // Draw the outline
 const SHAPE_POLY_SET* outline = aZone->Outline();

 if( m_pcbSettings.m_zoneOutlines && outline && outline->OutlineCount() > 0 )
 {
 m_gal->SetStrokeColor( color.a > 0.0 ? color.WithAlpha( 1.0 ) : color );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );

 // Draw each contour (main contour and holes)

 /*
 * m_gal->DrawPolygon( *outline );
 * should be enough, but currently does not work to draw holes contours in a complex
 * polygon so each contour is draw as a simple polygon
 */

 // Draw the main contour
 m_gal->DrawPolyline( outline->COutline( 0 ) );

 // Draw holes
 int holes_count = outline->HoleCount( 0 );

 for( int ii = 0; ii < holes_count; ++ii )
 m_gal->DrawPolyline( outline->CHole( 0, ii ) );

 // Draw hatch lines
 for( const SEG& hatchLine : aZone->GetHatchLines() )
 m_gal->DrawLine( hatchLine.A, hatchLine.B );
 }

 // Draw the filling
 if( displayMode == ZONE_DISPLAY_MODE::SHOW_FILLED
 || displayMode == ZONE_DISPLAY_MODE::SHOW_FRACTURE_BORDERS
 || displayMode == ZONE_DISPLAY_MODE::SHOW_TRIANGULATION )
 {
 const SHAPE_POLY_SET& polySet = aZone->GetFilledPolysList( layer );

 if( polySet.OutlineCount() == 0 ) // Nothing to draw
 return;

 // Set up drawing options
 int outline_thickness = 0;

 if( aZone->GetFilledPolysUseThickness( layer ) )
 outline_thickness = aZone->GetMinThickness();

 m_gal->SetStrokeColor( color );
 m_gal->SetFillColor( color );
 m_gal->SetLineWidth( outline_thickness );

 if( displayMode == ZONE_DISPLAY_MODE::SHOW_FILLED )
 {
 m_gal->SetIsFill( true );
 m_gal->SetIsStroke( outline_thickness > 0 );
 }
 else
 {
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );
 }

 m_gal->DrawPolygon( polySet, displayMode == ZONE_DISPLAY_MODE::SHOW_TRIANGULATION );
 }
}

References SHAPE_POLY_SET::CHole(), color, SHAPE_POLY_SET::COutline(), KIGFX::GAL::DrawLine(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawPolyline(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), ZONE::GetFilledPolysList(), ZONE::GetFilledPolysUseThickness(), ZONE::GetHatchLines(), ZONE::GetMinThickness(), SHAPE_POLY_SET::HoleCount(), ZONE::IsOnLayer(), IsZoneLayer(), LAYER_ZONE_START, KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_zoneDisplayMode, KIGFX::PCB_RENDER_SETTINGS::m_zoneOutlines, ZONE::Outline(), SHAPE_POLY_SET::OutlineCount(), KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), SHOW_FILLED, SHOW_FRACTURE_BORDERS, and SHOW_TRIANGULATION.

draw() [11/13]

void PCB_PAINTER::draw ( const PCB_DIMENSION_BASE *  aDimension, int  aLayer  )

protectedinherited

Definition at line 1803 of file pcb_painter.cpp.

{
 const COLOR4D& strokeColor = m_pcbSettings.GetColor( aDimension, aLayer );

 m_gal->SetStrokeColor( strokeColor );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );

 if( m_pcbSettings.m_sketchGraphics )
 {
 // Outline mode
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 }
 else
 {
 // Filled mode
 m_gal->SetLineWidth( getLineThickness( aDimension->GetLineThickness() ) );
 }

 // Draw dimension shapes
 // TODO(JE) lift this out
 for( const std::shared_ptr<SHAPE>& shape : aDimension->GetShapes() )
 {
 switch( shape->Type() )
 {
 case SH_SEGMENT:
 {
 const SEG& seg = static_cast<const SHAPE_SEGMENT*>( shape.get() )->GetSeg();
 m_gal->DrawLine( seg.A, seg.B );
 break;
 }

 case SH_CIRCLE:
 {
 int radius = static_cast<const SHAPE_CIRCLE*>( shape.get() )->GetRadius();
 m_gal->DrawCircle( shape->Centre(), radius );
 break;
 }

 default:
 break;
 }
 }

 // Draw text
 const PCB_TEXT& text = aDimension->Text();
 VECTOR2D position( text.GetTextPos().x, text.GetTextPos().y );

 if( m_pcbSettings.m_sketchText )
 {
 // Outline mode
 m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 }
 else
 {
 // Filled mode
 m_gal->SetLineWidth( getLineThickness( text.GetEffectiveTextPenWidth() ) );
 }

 m_gal->SetTextAttributes( &text );
 m_gal->StrokeText( text.GetShownText(), position, text.GetTextAngleRadians() );
}

References SEG::A, SEG::B, KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawLine(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), PCB_DIMENSION_BASE::GetLineThickness(), KIGFX::PCB_PAINTER::getLineThickness(), PCB_DIMENSION_BASE::GetShapes(), KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchGraphics, KIGFX::PCB_RENDER_SETTINGS::m_sketchText, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextAttributes(), SH_CIRCLE, SH_SEGMENT, KIGFX::GAL::StrokeText(), PCB_DIMENSION_BASE::Text(), and text.

draw() [12/13]

void PCB_PAINTER::draw ( const PCB_TARGET *  aTarget )

protectedinherited

Definition at line 1867 of file pcb_painter.cpp.

{
 const COLOR4D& strokeColor = m_pcbSettings.GetColor( aTarget, aTarget->GetLayer() );
 VECTOR2D position( aTarget->GetPosition() );
 double size, radius;

 m_gal->SetLineWidth( getLineThickness( aTarget->GetWidth() ) );
 m_gal->SetStrokeColor( strokeColor );
 m_gal->SetIsFill( false );
 m_gal->SetIsStroke( true );

 m_gal->Save();
 m_gal->Translate( position );

 if( aTarget->GetShape() )
 {
 // shape x
 m_gal->Rotate( M_PI / 4.0 );
 size = 2.0 * aTarget->GetSize() / 3.0;
 radius = aTarget->GetSize() / 2.0;
 }
 else
 {
 // shape +
 size = aTarget->GetSize() / 2.0;
 radius = aTarget->GetSize() / 3.0;
 }

 m_gal->DrawLine( VECTOR2D( -size, 0.0 ), VECTOR2D( size, 0.0 ) );
 m_gal->DrawLine( VECTOR2D( 0.0, -size ), VECTOR2D( 0.0, size ) );
 m_gal->DrawCircle( VECTOR2D( 0.0, 0.0 ), radius );

 m_gal->Restore();
}

References KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawLine(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), BOARD_ITEM::GetLayer(), KIGFX::PCB_PAINTER::getLineThickness(), PCB_TARGET::GetPosition(), PCB_TARGET::GetShape(), PCB_TARGET::GetSize(), PCB_TARGET::GetWidth(), KIGFX::PAINTER::m_gal, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::GAL::Restore(), KIGFX::GAL::Rotate(), KIGFX::GAL::Save(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), and KIGFX::GAL::Translate().

draw() [13/13]

void PCB_PAINTER::draw ( const PCB_MARKER *  aMarker, int  aLayer  )

protectedinherited

Definition at line 1903 of file pcb_painter.cpp.

{
 bool isShadow = aLayer == LAYER_MARKER_SHADOWS;

 // Don't paint shadows for invisible markers.
 // It would be nice to do this through layer dependencies but we can't do an "or" there today
 if( isShadow && aMarker->GetBoard()
 && !aMarker->GetBoard()->IsElementVisible( aMarker->GetColorLayer() ) )
 {
 return;
 }

 const_cast<PCB_MARKER*>( aMarker )->SetZoom( 1.0 / sqrt( m_gal->GetZoomFactor() ) );

 SHAPE_LINE_CHAIN polygon;
 aMarker->ShapeToPolygon( polygon );

 COLOR4D color = m_pcbSettings.GetColor( aMarker, isShadow ? LAYER_MARKER_SHADOWS
 : aMarker->GetColorLayer() );

 m_gal->Save();
 m_gal->Translate( aMarker->GetPosition() );

 if( isShadow )
 {
 m_gal->SetStrokeColor( color );
 m_gal->SetIsStroke( true );
 m_gal->SetLineWidth( aMarker->MarkerScale() );
 }
 else
 {
 m_gal->SetFillColor( color );
 m_gal->SetIsFill( true );
 }

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

References color, KIGFX::GAL::DrawPolygon(), BOARD_ITEM::GetBoard(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), PCB_MARKER::GetColorLayer(), PCB_MARKER::GetPosition(), KIGFX::GAL::GetZoomFactor(), BOARD::IsElementVisible(), LAYER_MARKER_SHADOWS, KIGFX::PAINTER::m_gal, KIGFX::PCB_PAINTER::m_pcbSettings, MARKER_BASE::MarkerScale(), 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().

getDrillShape()

int KIGFX::PCB_PRINT_PAINTER::getDrillShape ( const PAD *  aPad ) const

overrideprotectedvirtual

Return drill shape of a pad.

Reimplemented from KIGFX::PCB_PAINTER.

Definition at line 297 of file pcbnew_printout.cpp.

{
 return m_drillMarkReal ? KIGFX::PCB_PAINTER::getDrillShape( aPad ) : PAD_DRILL_SHAPE_CIRCLE;
}

References KIGFX::PCB_PAINTER::getDrillShape(), and PAD_DRILL_SHAPE_CIRCLE.

getDrillSize() [1/2]

VECTOR2D KIGFX::PCB_PRINT_PAINTER::getDrillSize ( const PAD *  aPad ) const

overrideprotectedvirtual

Return drill size for a pad (internal units).

Reimplemented from KIGFX::PCB_PAINTER.

Definition at line 303 of file pcbnew_printout.cpp.

{
 // TODO should it depend on the pad size?
 return m_drillMarkReal ? KIGFX::PCB_PAINTER::getDrillSize( aPad ) :
 VECTOR2D( m_drillMarkSize, m_drillMarkSize );
}

References KIGFX::PCB_PAINTER::getDrillSize().

getDrillSize() [2/2]

int KIGFX::PCB_PRINT_PAINTER::getDrillSize ( const PCB_VIA *  aVia ) const

overrideprotectedvirtual

Flag deciding whether use the actual hole size or user-specified size for drill marks.

Reimplemented from KIGFX::PCB_PAINTER.

Definition at line 311 of file pcbnew_printout.cpp.

{
 // TODO should it depend on the via size?
 return m_drillMarkReal ? KIGFX::PCB_PAINTER::getDrillSize( aVia ) : m_drillMarkSize;
}

References KIGFX::PCB_PAINTER::getDrillSize().

getLineThickness()

int PCB_PAINTER::getLineThickness ( int  aActualThickness ) const

protectedinherited

Get the thickness to draw for a line (e.g.

0 thickness lines get a minimum value).

Parameters

aActualThickness

line own thickness

Returns

the thickness to draw

Definition at line 431 of file pcb_painter.cpp.

{
 // if items have 0 thickness, draw them with the outline
 // width, otherwise respect the set value (which, no matter
 // how small will produce something)
 if( aActualThickness == 0 )
 return m_pcbSettings.m_outlineWidth;

 return aActualThickness;
}

References KIGFX::RENDER_SETTINGS::m_outlineWidth, and KIGFX::PCB_PAINTER::m_pcbSettings.

Referenced by KIGFX::PCB_PAINTER::draw().

GetSettings()

virtual PCB_RENDER_SETTINGS* KIGFX::PCB_PAINTER::GetSettings ( )

inlineoverridevirtualinherited

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 247 of file pcb_painter.h.

 {
 return &m_pcbSettings;
 }

References KIGFX::PCB_PAINTER::m_pcbSettings.

Referenced by PCB_BASE_FRAME::ActivateGalCanvas(), APPEARANCE_CONTROLS::OnLayerAlphaChanged(), PCBNEW_PRINTOUT::setupPainter(), PANEL_DISPLAY_OPTIONS::TransferDataFromWindow(), PANEL_EDIT_OPTIONS::TransferDataFromWindow(), PCB_TRACK::ViewGetLOD(), PCB_VIA::ViewGetLOD(), and PAD::ViewGetLOD().

SetDrillMarks()

void KIGFX::PCB_PRINT_PAINTER::SetDrillMarks ( bool  aRealSize, unsigned int  aSize = 0  )

inline

Set drill marks visibility and options.

Parameters

aRealSize	when enabled, drill marks represent actual holes. Otherwise aSize parameter is used.
aSize	is drill mark size (internal units), valid only when aRealSize == false.

Definition at line 97 of file pcbnew_printout.h.

 {
 m_drillMarkReal = aRealSize;
 m_drillMarkSize = aSize;
 }

References m_drillMarkReal, and m_drillMarkSize.

Referenced by PCBNEW_PRINTOUT::setupPainter().

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.

Member Data Documentation

m_drillMarkReal

bool KIGFX::PCB_PRINT_PAINTER::m_drillMarkReal

protected

User-specified size for drill marks (expressed in internal units)

Definition at line 111 of file pcbnew_printout.h.

Referenced by SetDrillMarks().

m_drillMarkSize

int KIGFX::PCB_PRINT_PAINTER::m_drillMarkSize

protected

Definition at line 114 of file pcbnew_printout.h.

Referenced by SetDrillMarks().

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 KIGFX::SCH_PAINTER::boxText(), KIGFX::SCH_PAINTER::Draw(), KIGFX::SCH_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::Draw(), KIGFX::PCB_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::drawApertureMacro(), KIGFX::SCH_PAINTER::drawDanglingSymbol(), KIGFX::GERBVIEW_PAINTER::drawFlashedShape(), KIGFX::SCH_PAINTER::drawPinDanglingSymbol(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), KIGFX::SCH_PAINTER::getShadowWidth(), KIGFX::SCH_PAINTER::setDeviceColors(), KIGFX::PAINTER::SetGAL(), KIGFX::SCH_PAINTER::strokeText(), and KIGFX::SCH_PAINTER::triLine().

m_holePlatingThickness

int KIGFX::PCB_PAINTER::m_holePlatingThickness

protectedinherited

Definition at line 298 of file pcb_painter.h.

Referenced by KIGFX::PCB_PAINTER::Draw(), and KIGFX::PCB_PAINTER::draw().

m_maxError

int KIGFX::PCB_PAINTER::m_maxError

protectedinherited

Definition at line 297 of file pcb_painter.h.

Referenced by KIGFX::PCB_PAINTER::Draw(), and KIGFX::PCB_PAINTER::draw().

m_pcbSettings

PCB_RENDER_SETTINGS KIGFX::PCB_PAINTER::m_pcbSettings

protectedinherited

Definition at line 295 of file pcb_painter.h.

Referenced by KIGFX::PCB_PAINTER::draw(), KIGFX::PCB_PAINTER::getLineThickness(), KIGFX::PCB_PAINTER::GetSettings(), and PCB_PRINT_PAINTER().

---

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

• pcbnew_printout.h
• pcbnew_printout.cpp