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 VIA *aVia) const override
	Flag deciding whether use the actual hole size or user-specified size for drill marks. More...
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...

Protected Attributes
bool	m_drillMarkReal
	User-specified size for drill marks (expressed in internal units) More...
int	m_drillMarkSize
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

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 290 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 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 KIGFX::PCB_PAINTER::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  )

protectedinherited

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, 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 ARC *  aArc, int  aLayer  )

protectedinherited

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, KIGFX::PCB_PAINTER::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  )

protectedinherited

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 ) );
    }
}

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(), VIA::FlashLayer(), KIGFX::RENDER_SETTINGS::GetActiveLayer(), BOARD_ITEM::GetBoard(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), BOARD::GetDesignSettings(), KIGFX::PCB_RENDER_SETTINGS::GetDrawIndividualViaLayers(), KIGFX::PCB_PAINTER::getDrillSize(), VIA::GetDrillValue(), BOARD_DESIGN_SETTINGS::GetHolePlatingThickness(), BOARD_CONNECTED_ITEM::GetNetname(), BOARD_CONNECTED_ITEM::GetOwnClearance(), BOARD_CONNECTED_ITEM::GetShortNetname(), TRACK::GetStart(), VIA::GetViaType(), TRACK::GetWidth(), IsNetnameLayer(), LAYER_VIA_BBLIND, LAYER_VIA_HOLES, LAYER_VIA_HOLEWALLS, LAYER_VIA_MICROVIA, LAYER_VIA_THROUGH, VIA::LayerPair(), KIGFX::PCB_RENDER_SETTINGS::m_clearanceDisplayFlags, KIGFX::PAINTER::m_gal, 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, NULL, 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 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(), KIGFX::PCB_PAINTER::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, KIGFX::PCB_PAINTER::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  )

protectedinherited

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(), KIGFX::PCB_PAINTER::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, KIGFX::PCB_PAINTER::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  )

protectedinherited

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(), 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 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(), 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 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, 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 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, KIGFX::PCB_PAINTER::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  )

protectedinherited

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

draw() [11/13]

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

protectedinherited

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(), KIGFX::PCB_PAINTER::getLineThickness(), DIMENSION_BASE::GetShapes(), 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_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 )

protectedinherited

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(), 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 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, 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 299 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 305 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 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 313 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 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 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 APPEARANCE_CONTROLS::OnLayerAlphaChanged(), PCBNEW_PRINTOUT::setupPainter(), PANEL_DISPLAY_OPTIONS::TransferDataFromWindow(), PANEL_EDIT_OPTIONS::TransferDataFromWindow(), TRACK::ViewGetLOD(), 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::Draw(), KIGFX::SCH_PAINTER::draw(), KIGFX::GERBVIEW_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::fillIfSelection(), KIGFX::SCH_PAINTER::getShadowWidth(), KIGFX::SCH_PAINTER::setDeviceColors(), KIGFX::PAINTER::SetGAL(), KIGFX::SCH_PAINTER::strokeText(), and KIGFX::SCH_PAINTER::triLine().

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