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

#include <pcb_painter.h>

Inheritance diagram for KIGFX::PCB_PAINTER:

Public Member Functions
	PCB_PAINTER (GAL *aGal)

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
void	draw (const TRACK *aTrack, int aLayer)

void	draw (const ARC *aArc, int aLayer)

void	draw (const 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 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...

virtual int	getDrillShape (const PAD *aPad) const
	Return drill shape of a pad. More...

virtual VECTOR2D	getDrillSize (const PAD *aPad) const
	Return drill size for a pad (internal units). More...

virtual int	getDrillSize (const VIA *aVia) const
	Return drill diameter for a via (internal units). More...

Protected Attributes
PCB_RENDER_SETTINGS	m_pcbSettings

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

Detailed Description

Contains methods for drawing PCB-specific items.

Definition at line 241 of file pcb_painter.h.

Constructor & Destructor Documentation

◆ PCB_PAINTER()

PCB_PAINTER::PCB_PAINTER ( GAL * aGal )

Definition at line 368 of file pcb_painter.cpp.

                                     :
     PAINTER( aGal )
 {
 }

Member Function Documentation

◆ Draw()

bool PCB_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 404 of file pcb_painter.cpp.

 {
     const EDA_ITEM* item = dynamic_cast<const EDA_ITEM*>( aItem );
 
     if( !item )
         return false;
 
     // the "cast" applied in here clarifies which overloaded draw() is called
     switch( item->Type() )
     {
     case PCB_TRACE_T:
         draw( static_cast<const TRACK*>( item ), aLayer );
         break;
 
     case PCB_ARC_T:
         draw( static_cast<const ARC*>( item ), aLayer );
         break;
 
     case PCB_VIA_T:
         draw( static_cast<const 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 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;
     }
 
     return true;
 }

References draw(), 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, and EDA_ITEM::Type().

◆ draw() [1/13]

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

protected

Definition at line 483 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(), TRACK::GetEnd(), BOARD_CONNECTED_ITEM::GetNetCode(), BOARD_CONNECTED_ITEM::GetOwnClearance(), BOARD_CONNECTED_ITEM::GetShortNetname(), TRACK::GetStart(), 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, 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 Draw().

◆ draw() [2/13]

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

protected

Definition at line 574 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 );
     }
 
     // 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 );
     }
 }

References PNS::angle(), KIGFX::PCB_RENDER_SETTINGS::CL_EXISTING, KIGFX::PCB_RENDER_SETTINGS::CL_TRACKS, color, DECIDEG2RAD(), KIGFX::GAL::DrawArcSegment(), KIGFX::RENDER_SETTINGS::GetActiveLayer(), ARC::GetAngle(), ARC::GetArcAngleStart(), ARC::GetCenter(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), BOARD_CONNECTED_ITEM::GetOwnClearance(), ARC::GetRadius(), TRACK::GetWidth(), IsCopperLayer(), IsNetnameLayer(), LAYER_TRACKS, KIGFX::PCB_RENDER_SETTINGS::m_clearanceDisplayFlags, KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

◆ draw() [3/13]

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

protected

Definition at line 620 of file pcb_painter.cpp.

 {
     BOARD*                 board = aVia->GetBoard();
     BOARD_DESIGN_SETTINGS& bds = board->GetDesignSettings();
     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( NULL, 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() );
         // calculate the size of net name text:
         double tsize = 1.5 * size / netname.Length();
         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 )
     {
         int platingThickness = bds.GetHolePlatingThickness();
 
         m_gal->SetIsFill( false );
         m_gal->SetIsStroke( true );
         m_gal->SetStrokeColor( color );
         m_gal->SetLineWidth( platingThickness );
 
         m_gal->DrawCircle( center, ( getDrillSize( aVia ) + platingThickness ) / 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 / 2.0, M_PI );
         m_gal->DrawArc( center, radius, 3.0 * M_PI / 2.0, 2.0 * M_PI );
 
         if( sketchMode )
             m_gal->SetStrokeColor( m_pcbSettings.GetColor( aVia, layerTop ) );
         else
             m_gal->SetFillColor( m_pcbSettings.GetColor( aVia, layerTop ) );
 
         m_gal->DrawArc( center, radius, 0.0, M_PI / 2.0 );
 
         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, 3.0 * M_PI / 2.0 );
     }
 
     // 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 + bds.GetHolePlatingThickness();
 
         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 ) );
     }
 }

◆ draw() [4/13]

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

protected

Definition at line 779 of file pcb_painter.cpp.

 {
     BOARD*                 board = aPad->GetBoard();
     BOARD_DESIGN_SETTINGS& bds = board->GetDesignSettings();
     COLOR4D                color = m_pcbSettings.GetColor( aPad, aLayer );
 
     if( IsNetnameLayer( aLayer ) )
     {
         // Is anything that we can display enabled?
         if( m_pcbSettings.m_netNamesOnPads || m_pcbSettings.m_padNumbers )
         {
             bool displayNetname = ( m_pcbSettings.m_netNamesOnPads && !aPad->GetNetname().empty() );
             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( displayNetname && m_pcbSettings.m_padNumbers )
             {
                 size = size / 2.0;
                 textpos.y = size / 2.0;
             }
 
             if( displayNetname )
             {
                 wxString netname = UnescapeString( aPad->GetShortNetname() );
                 wxString pinType = aPad->GetPinType();
 
                 if( pinType == wxT( "no_connect" ) || pinType.EndsWith( wxT( "+no_connect" ) ) )
                     netname = "x";
                 else if( pinType == wxT( "free" ) && isImplicitNet( netname ) )
                     netname = "*";
 
                 // calculate the size of net name text:
                 double tsize = 1.5 * padsize.x / netname.Length();
                 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( m_pcbSettings.m_padNumbers )
             {
                 const wxString& padName = aPad->GetName();
                 textpos.y = -textpos.y;
                 double tsize = 1.5 * padsize.x / padName.Length();
                 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( padName, textpos, 0.0 );
             }
 
             m_gal->Restore();
         }
         return;
     }
     else if( aLayer == LAYER_PAD_HOLEWALLS )
     {
         int platingThickness = bds.GetHolePlatingThickness();
 
         m_gal->SetIsFill( false );
         m_gal->SetIsStroke( true );
         m_gal->SetLineWidth( platingThickness );
         m_gal->SetStrokeColor( color );
 
         const SHAPE_SEGMENT* seg = aPad->GetEffectiveHoleShape();
         int                  holeSize = seg->GetWidth() + platingThickness;
 
         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;
         bool                            simpleShapes = true;
 
         if( margin.x != margin.y && aPad->GetShape() != PAD_SHAPE_CUSTOM )
         {
             // 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() ) );
             dummyPad->SetSize( pad_size + margin + margin );
             shapes = std::dynamic_pointer_cast<SHAPE_COMPOUND>( dummyPad->GetEffectiveShape() );
             margin.x = margin.y = 0;
         }
         else
         {
             shapes = std::dynamic_pointer_cast<SHAPE_COMPOUND>( aPad->GetEffectiveShape() );
         }
 
         for( SHAPE* shape : shapes->Shapes() )
         {
             // Drawing components of compound shapes in outline mode produces a mess.
             if( m_pcbSettings.m_sketchMode[LAYER_PADS_TH] )
                 simpleShapes = false;
 
             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( SHAPE* shape : shapes->Shapes() )
             {
                 switch( shape->Type() )
                 {
                 case SH_SEGMENT:
                 {
                     const SHAPE_SEGMENT* seg = (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 = (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 = (SHAPE_RECT*) shape;
                     VECTOR2I          position = r->GetPosition();
                     VECTOR2I          effectiveSize = r->GetSize() + margin;
 
                     // At this point, if margin.x < 0 the actual rectangle size is
                     // smaller than SHAPE_RECT r (the pad size was not modifed)
                     if( margin.x < 0 )
                     {
                         if( effectiveSize.x > 0 && effectiveSize.y > 0 )
                             m_gal->DrawRectangle( position - margin, position + effectiveSize );
                     }
                     else
                     {
                         m_gal->DrawRectangle( r->GetPosition(), r->GetPosition() + r->GetSize() );
                     }
 
                     // Now add on a rounded margin (using segments) if the margin > 0
                     if( margin.x > 0 )
                     {
                         m_gal->DrawSegment( position,
                                             position + VECTOR2I( r->GetWidth(), 0 ),
                                             margin.x * 2 );
                         m_gal->DrawSegment( position + VECTOR2I( r->GetWidth(), 0 ),
                                             position + r->GetSize(),
                                             margin.x * 2 );
                         m_gal->DrawSegment( position + r->GetSize(),
                                             position + VECTOR2I( 0, r->GetHeight() ),
                                             margin.x * 2 );
                         m_gal->DrawSegment( position + VECTOR2I( 0, r->GetHeight() ),
                                             position,
                                             margin.x * 2 );
                     }
                 }
                     break;
 
                 case SH_SIMPLE:
                 {
                     const SHAPE_SIMPLE* poly = static_cast<const SHAPE_SIMPLE*>( shape );
                     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,
                                                         bds.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 = IsCopperLayer( activeLayer ) ?
                                     aPad->FlashLayer( activeLayer ) : true;
 
         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;
                     aPad->TransformShapeWithClearanceToPolygon( polySet, ToLAYER_ID( aLayer ),
                                                                 clearance,
                                                                 bds.m_MaxError, ERROR_OUTSIDE );
                     m_gal->DrawPolygon( polySet );
                 }
             }
             else if( aPad->GetEffectiveHoleShape() && clearance > 0 )
             {
                 clearance += bds.GetHolePlatingThickness();
 
                 const SHAPE_SEGMENT* seg = aPad->GetEffectiveHoleShape();
                 m_gal->DrawSegment( seg->GetSeg().A, seg->GetSeg().B,
                                     seg->GetWidth() + 2 * clearance );
             }
         }
     }
 }

References SEG::A, SEG::B, B_Mask, B_Paste, KIGFX::GAL::BitmapText(), EDA_RECT::Centre(), KIGFX::PCB_RENDER_SETTINGS::CL_PADS, color, DECIDEG2RAD(), KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawRectangle(), KIGFX::GAL::DrawSegment(), BOARD_ITEM::Duplicate(), ERROR_INSIDE, ERROR_OUTSIDE, F_Mask, F_Paste, PAD::FlashLayer(), KIGFX::RENDER_SETTINGS::GetActiveLayer(), BOARD_ITEM::GetBoard(), PAD::GetBoundingBox(), SHAPE_CIRCLE::GetCenter(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), BOARD::GetDesignSettings(), PAD::GetDrillSize(), getDrillSize(), PAD::GetEffectiveHoleShape(), PAD::GetEffectiveShape(), SHAPE_RECT::GetHeight(), BOARD_DESIGN_SETTINGS::GetHolePlatingThickness(), PAD::GetName(), BOARD_CONNECTED_ITEM::GetNetname(), BOARD_CONNECTED_ITEM::GetOwnClearance(), PAD::GetPinType(), SHAPE_RECT::GetPosition(), SHAPE_CIRCLE::GetRadius(), SHAPE_SEGMENT::GetSeg(), SHAPE_SIMPLE::GetSegment(), SHAPE_SIMPLE::GetSegmentCount(), PAD::GetShape(), BOARD_CONNECTED_ITEM::GetShortNetname(), EDA_RECT::GetSize(), SHAPE_RECT::GetSize(), PAD::GetSize(), PAD::GetSolderMaskMargin(), PAD::GetSolderPasteMargin(), SHAPE_RECT::GetWidth(), SHAPE_SEGMENT::GetWidth(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, IsCopperLayer(), isImplicitNet(), IsNetnameLayer(), 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, BOARD_DESIGN_SETTINGS::m_MaxError, KIGFX::PCB_RENDER_SETTINGS::m_netNamesOnPads, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_RENDER_SETTINGS::m_padNumbers, m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, KIGFX::PCB_RENDER_SETTINGS::MAX_FONT_SIZE, PAD_SHAPE_CUSTOM, KIGFX::GAL::Restore(), KIGFX::GAL::Rotate(), 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
	)

protected

Definition at line 1167 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() );
     VECTOR2D       start( aShape->GetStart() );
     VECTOR2D       end( aShape->GetEnd() );
 
     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 S_SEGMENT:
         if( sketch )
         {
             m_gal->DrawSegment( start, end, thickness );
         }
         else
         {
             m_gal->SetIsFill( true );
             m_gal->SetIsStroke( false );
 
             m_gal->DrawSegment( start, end, thickness );
         }
         break;
 
     case S_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 S_ARC:
         if( sketch )
         {
             m_gal->DrawArcSegment( start, aShape->GetRadius(),
                     DECIDEG2RAD( aShape->GetArcAngleStart() ),
                     DECIDEG2RAD( aShape->GetArcAngleStart() + aShape->GetAngle() ), // Change this
                     thickness );
         }
         else
         {
             m_gal->SetIsFill( true );
             m_gal->SetIsStroke( false );
 
             m_gal->DrawArcSegment( start, aShape->GetRadius(),
                     DECIDEG2RAD( aShape->GetArcAngleStart() ),
                     DECIDEG2RAD( aShape->GetArcAngleStart() + aShape->GetAngle() ), // Change this
                     thickness );
         }
         break;
 
     case S_CIRCLE:
         if( sketch )
         {
             m_gal->DrawCircle( start, aShape->GetRadius() - thickness / 2 );
             m_gal->DrawCircle( start, aShape->GetRadius() + thickness / 2 );
         }
         else
         {
             m_gal->SetIsFill( aShape->IsFilled() );
             m_gal->SetIsStroke( thickness > 0 );
             m_gal->SetLineWidth( thickness );
 
             m_gal->DrawCircle( start, aShape->GetRadius() );
         }
         break;
 
     case S_POLYGON:
     {
         SHAPE_POLY_SET& shape = const_cast<PCB_SHAPE*>( aShape )->GetPolyShape();
         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 tesselation is much slower, so
                 // currently we are using our tesselation.
                 if( m_gal->IsOpenGlEngine() && !shape.IsTriangulationUpToDate() )
                     shape.CacheTriangulation();
 
                 m_gal->DrawPolygon( shape );
             }
         }
 
         if( parentFootprint )
             m_gal->Restore();
     }
         break;
 
     case S_CURVE:
         if( sketch )
         {
             // 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->GetBezControl1() ),
                               VECTOR2D( aShape->GetBezControl2() ),
                               VECTOR2D( aShape->GetEnd() ), 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->GetBezControl1() ),
                               VECTOR2D( aShape->GetBezControl2() ),
                               VECTOR2D( aShape->GetEnd() ), thickness );
         }
         break;
 
     case S_LAST:
         break;
     }
 }

References SEG::A, SHAPE_POLY_SET::Append(), SEG::B, SHAPE_POLY_SET::CacheTriangulation(), color, DECIDEG2RAD(), KIGFX::GAL::DrawArcSegment(), KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawCurve(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawSegment(), PCB_SHAPE::GetAngle(), PCB_SHAPE::GetArcAngleStart(), PCB_SHAPE::GetBezControl1(), PCB_SHAPE::GetBezControl2(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), PCB_SHAPE::GetEnd(), BOARD_ITEM::GetLayer(), getLineThickness(), FOOTPRINT::GetOrientationRadians(), PCB_SHAPE::GetParentFootprint(), FOOTPRINT::GetPosition(), PCB_SHAPE::GetRadius(), PCB_SHAPE::GetRectCorners(), PCB_SHAPE::GetShape(), PCB_SHAPE::GetStart(), PCB_SHAPE::GetWidth(), PCB_SHAPE::IsFilled(), KIGFX::GAL::IsOpenGlEngine(), SHAPE_POLY_SET::IsTriangulationUpToDate(), KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchGraphics, SHAPE_POLY_SET::NewOutline(), SHAPE_POLY_SET::Outline(), SHAPE_POLY_SET::OutlineCount(), KIGFX::GAL::Restore(), KIGFX::GAL::Rotate(), S_ARC, S_CIRCLE, S_CURVE, S_LAST, S_POLYGON, S_RECT, S_SEGMENT, KIGFX::GAL::Save(), 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
	)

protected

Definition at line 1361 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(), getLineThickness(), PCB_TEXT::GetShownText(), EDA_TEXT::GetTextAngleRadians(), EDA_TEXT::GetTextPos(), KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, 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
	)

protected

Definition at line 1390 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(), 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, 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
	)

protected

Definition at line 1427 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 ) );
 
 #if 0   // For debug purpose only: draw the footing bounding box
         double bboxThickness = 1.0 / m_gal->GetWorldScale();
         m_gal->SetLineWidth( bboxThickness );
         EDA_RECT rect = aFootprint->GetBoundingBox();
         m_gal->DrawRectangle( VECTOR2D( rect.GetOrigin() ), VECTOR2D( rect.GetEnd() ) );
 
         double bboxThickness = 3.0 / m_gal->GetWorldScale();
         m_gal->SetLineWidth( bboxThickness );
         SHAPE_POLY_SET convex = aFootprint->GetBoundingHull();
 
         m_gal->DrawPolyline( convex.COutline( 0 ) );
 #endif
     }
 }

References color, SHAPE_POLY_SET::COutline(), KIGFX::GAL::DrawLine(), KIGFX::GAL::DrawPolyline(), KIGFX::GAL::DrawRectangle(), FOOTPRINT::GetBoundingBox(), FOOTPRINT::GetBoundingHull(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), EDA_RECT::GetEnd(), EDA_RECT::GetOrigin(), FOOTPRINT::GetPosition(), KIGFX::GAL::GetWorldScale(), LAYER_ANCHOR, KIGFX::PAINTER::m_gal, 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
	)

protected

Definition at line 1464 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
         {
             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();
 
         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( !name.IsEmpty() && (int) aGroup->GetName().Length() * 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, m_pcbSettings, name, 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
	)

protected

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

Definition at line 1528 of file pcb_painter.cpp.

 {
     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 );
         m_gal->SetIsFill( false );
         m_gal->SetIsStroke( true );
         m_gal->SetLineWidth( m_pcbSettings.m_outlineWidth );
 
         // Draw each contour (main contour and holes)
 
         /* This line:
          * 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_FILLED_OUTLINE )
     {
         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 if( displayMode == ZONE_DISPLAY_MODE::SHOW_FILLED_OUTLINE )
         {
             m_gal->SetIsFill( false );
             m_gal->SetIsStroke( true );
         }
 
         m_gal->DrawPolygon( polySet );
     }
 }

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, 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, and SHOW_FILLED_OUTLINE.

◆ draw() [11/13]

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

protected

Definition at line 1613 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
     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(), EDA_TEXT::GetEffectiveTextPenWidth(), DIMENSION_BASE::GetLineThickness(), getLineThickness(), DIMENSION_BASE::GetShapes(), PCB_TEXT::GetShownText(), EDA_TEXT::GetTextAngleRadians(), EDA_TEXT::GetTextPos(), KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, 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(), and DIMENSION_BASE::Text().

◆ draw() [12/13]

void PCB_PAINTER::draw ( const PCB_TARGET * aTarget )

protected

Definition at line 1676 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(), getLineThickness(), PCB_TARGET::GetPosition(), PCB_TARGET::GetShape(), PCB_TARGET::GetSize(), PCB_TARGET::GetWidth(), KIGFX::PAINTER::m_gal, 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
	)

protected

Definition at line 1712 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;
     }
 
     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(), BOARD::IsElementVisible(), LAYER_MARKER_SHADOWS, KIGFX::PAINTER::m_gal, 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 PCB_PAINTER::getDrillShape ( const PAD * aPad ) const

protectedvirtual

Return drill shape of a pad.

Reimplemented in KIGFX::PCB_PRINT_PAINTER.

Definition at line 386 of file pcb_painter.cpp.

 {
     return aPad->GetDrillShape();
 }

References PAD::GetDrillShape().

Referenced by KIGFX::PCB_PRINT_PAINTER::getDrillShape().

◆ getDrillSize() [1/2]

VECTOR2D PCB_PAINTER::getDrillSize ( const PAD * aPad ) const

protectedvirtual

Return drill size for a pad (internal units).

Reimplemented in KIGFX::PCB_PRINT_PAINTER.

Definition at line 392 of file pcb_painter.cpp.

 {
     return VECTOR2D( aPad->GetDrillSize() );
 }

References PAD::GetDrillSize().

Referenced by draw(), and KIGFX::PCB_PRINT_PAINTER::getDrillSize().

◆ getDrillSize() [2/2]

int PCB_PAINTER::getDrillSize ( const VIA * aVia ) const

protectedvirtual

Return drill diameter for a via (internal units).

Reimplemented in KIGFX::PCB_PRINT_PAINTER.

Definition at line 398 of file pcb_painter.cpp.

 {
     return aVia->GetDrillValue();
 }

References VIA::GetDrillValue().

◆ getLineThickness()

int PCB_PAINTER::getLineThickness ( int aActualThickness ) const

protected

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 374 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 m_pcbSettings.

Referenced by draw().

◆ GetSettings()

virtual PCB_RENDER_SETTINGS* KIGFX::PCB_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 247 of file pcb_painter.h.

     {
         return &m_pcbSettings;
     }

References m_pcbSettings.

Referenced by APPEARANCE_CONTROLS::OnLayerAlphaChanged(), PCBNEW_PRINTOUT::setupPainter(), PANEL_DISPLAY_OPTIONS::TransferDataFromWindow(), PANEL_EDIT_OPTIONS::TransferDataFromWindow(), TRACK::ViewGetLOD(), VIA::ViewGetLOD(), and PAD::ViewGetLOD().

◆ 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_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.

◆ m_pcbSettings

PCB_RENDER_SETTINGS KIGFX::PCB_PAINTER::m_pcbSettings

protected

Definition at line 295 of file pcb_painter.h.

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PCB_PAINTER()

Member Function Documentation

◆ Draw()

◆ draw() [1/13]

◆ draw() [2/13]

◆ draw() [3/13]

◆ draw() [4/13]

◆ draw() [5/13]

◆ draw() [6/13]

◆ draw() [7/13]

◆ draw() [8/13]

◆ draw() [9/13]

◆ draw() [10/13]

◆ draw() [11/13]

◆ draw() [12/13]

◆ draw() [13/13]

◆ getDrillShape()

◆ getDrillSize() [1/2]

◆ getDrillSize() [2/2]

◆ getLineThickness()

◆ GetSettings()

◆ SetGAL()

Member Data Documentation

◆ m_gal

◆ m_pcbSettings