graphics_abstraction_layer.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KICAD, a free EDA CAD application.
 *
 * Copyright (C) 2012 Torsten Hueter, torstenhtr <at> gmx.de
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * Graphics Abstraction Layer (GAL) - base class
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <wx/log.h>
#include <advanced_config.h>
#include <gal/graphics_abstraction_layer.h>
#include <gal/definitions.h>
#include <font/font.h>
 
#include <geometry/shape_ellipse.h>
#include <geometry/shape_line_chain.h>
 
#include <math/util.h>      // for KiROUND
 
#include <algorithm>
#include <deque>
#include <cmath>
#include <limits>
 
using namespace KIGFX;
 
 
GAL::GAL( GAL_DISPLAY_OPTIONS& aDisplayOptions ) :
        m_options( aDisplayOptions ),
 
        // m_currentNativeCursor is initialized with KICURSOR::DEFAULT value to avoid
        // if comparison with uninitialized value on SetNativeCursorStyle method.
        // Some classes inheriting from GAL has different SetNativeCursorStyle method
        // implementation and therefore it's called also on constructor
        // to change the value from DEFAULT to KICURSOR::ARROW
        m_currentNativeCursor( KICURSOR::DEFAULT )
{
    // Set the default values for the internal variables
    SetIsFill( false );
    SetIsStroke( true );
    SetFillColor( COLOR4D( 0.0, 0.0, 0.0, 0.0 ) );
    SetStrokeColor( COLOR4D( 1.0, 1.0, 1.0, 1.0 ) );
    SetLookAtPoint( VECTOR2D( 0, 0 ) );
    SetZoomFactor( 1.0 );
    SetRotation( 0.0 );
 
    // this value for SetWorldUnitLength is only suitable for Pcbnew.
    // Other editors/viewer must call SetWorldUnitLength with their internal units
    SetWorldUnitLength( 1e-9 /* 1 nm */ / 0.0254 /* 1 inch in meters */ );
 
    // wxDC::GetPPI() reports 96 DPI, but somehow this value
    // is the closest match to the legacy renderer
    SetScreenDPI( ADVANCED_CFG::GetCfg().m_ScreenDPI );
    SetDepthRange( VECTOR2D( GAL::MIN_DEPTH, GAL::MAX_DEPTH ) );
    SetLayerDepth( 0.0 );
    SetFlip( false, false );
    SetLineWidth( 1.0f );
    SetMinLineWidth( 1.0f );
    computeWorldScale();
    SetAxesEnabled( false );
 
    // Set grid defaults
    SetGridVisibility( true );
    SetCoarseGrid( 10 );
    m_gridLineWidth = 0.5f;
    m_gridStyle = GRID_STYLE::LINES;
    m_gridMinSpacing = 10;
 
    // Initialize the cursor shape
    SetCursorColor( COLOR4D( 1.0, 1.0, 1.0, 1.0 ) );
    m_crossHairMode = CROSS_HAIR_MODE::SMALL_CROSS;
    m_forceDisplayCursor = false;
    SetCursorEnabled( false );
 
    // Initialize the native widget to an arrow cursor
    SetNativeCursorStyle( KICURSOR::ARROW, false );
 
    // Initialize text properties
    ResetTextAttributes();
 
    // subscribe for settings updates
    m_observerLink = m_options.Subscribe( this );
}
 
 
GAL::~GAL()
{
}
 
 
void GAL::OnGalDisplayOptionsChanged( const GAL_DISPLAY_OPTIONS& aOptions )
{
    // defer to the child class first
    updatedGalDisplayOptions( aOptions );
 
    // there is no refresh to do at this level
}
 
 
void GAL::DrawEllipse( const VECTOR2D& aCenterPoint, double aMajorRadius, double aMinorRadius,
                       const EDA_ANGLE& aRotation )
{
    const VECTOR2I intCenter( KiROUND( aCenterPoint.x ), KiROUND( aCenterPoint.y ) );
 
    SHAPE_ELLIPSE e( intCenter, KiROUND( aMajorRadius ), KiROUND( aMinorRadius ), aRotation );
 
    SHAPE_LINE_CHAIN chain = e.ConvertToPolyline( std::max( 1, KiROUND( aMajorRadius / 500.0 ) ) );
    DrawPolyline( chain );
}
 
 
void GAL::DrawEllipseArc( const VECTOR2D& aCenterPoint, double aMajorRadius, double aMinorRadius,
                          const EDA_ANGLE& aRotation, const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle )
{
    const VECTOR2I intCenter( KiROUND( aCenterPoint.x ), KiROUND( aCenterPoint.y ) );
 
    SHAPE_ELLIPSE e( intCenter, KiROUND( aMajorRadius ), KiROUND( aMinorRadius ), aRotation, aStartAngle, aEndAngle );
 
    SHAPE_LINE_CHAIN chain = e.ConvertToPolyline( std::max( 1, KiROUND( aMajorRadius / 500.0 ) ) );
    DrawPolyline( chain );
}
 
 
bool GAL::updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions )
{
    bool refresh = false;
 
    if( m_options.m_gridStyle != m_gridStyle )
    {
        m_gridStyle = m_options.m_gridStyle;
        refresh = true;
    }
 
    if( m_options.m_gridLineWidth != m_gridLineWidth )
    {
        m_gridLineWidth = m_options.m_scaleFactor * m_options.m_gridLineWidth + 0.25;
        refresh = true;
    }
 
    if( m_options.m_gridMinSpacing != m_gridMinSpacing )
    {
        m_gridMinSpacing = m_options.m_gridMinSpacing;
        refresh = true;
    }
 
    {
        // For now we only allow 10 or none, but it could be made adjustable (e.g. 5?)
        const int newInterval = m_options.m_gridShowMajor ? 10 : 0;
        if( m_gridTick != newInterval )
        {
            m_gridTick = newInterval;
            refresh = true;
        }
    }
 
    if( m_options.m_axesEnabled != m_axesEnabled )
    {
        m_axesEnabled = m_options.m_axesEnabled;
        refresh = true;
    }
 
    if( m_options.m_forceDisplayCursor != m_forceDisplayCursor )
    {
        m_forceDisplayCursor = m_options.m_forceDisplayCursor;
        refresh = true;
    }
 
    if( m_options.GetCursorMode() != m_crossHairMode )
    {
        m_crossHairMode = m_options.GetCursorMode();
        refresh = true;
    }
 
    // tell the derived class if the base class needs an update or not
    return refresh;
}
 
 
void GAL::DrawTrack( const VECTOR2D& aStart, const VECTOR2D& aEnd,
                     double aWidth, const COLOR4D& aColor )
{
    SetFillColor( aColor );
    SetStrokeColor( aColor );
    SetIsFill( true );
    SetIsStroke( false );
    DrawSegment( aStart, aEnd, aWidth );
}
 
 
void GAL::ResetTextAttributes()
{
     // Tiny but non-zero - this will always need setting
     // there is no built-in default
    SetGlyphSize( { 1, 1 } );
 
    SetHorizontalJustify( GR_TEXT_H_ALIGN_CENTER );
    SetVerticalJustify( GR_TEXT_V_ALIGN_CENTER );
 
    SetFontBold( false );
    SetFontItalic( false );
    SetFontUnderlined( false );
    SetTextMirrored( false );
}
 
 
void GAL::ComputeWorldScreenMatrix()
{
    computeWorldScale();
 
    MATRIX3x3D translation;
    translation.SetIdentity();
    // We're deliberately dividing integers to avoid fractional pixel offsets.
    const VECTOR2I layoutSize = GetLayoutPixelSize();
    translation.SetTranslation( VECTOR2D( layoutSize.x / 2, layoutSize.y / 2 ) );
 
    MATRIX3x3D rotate;
    rotate.SetIdentity();
    rotate.SetRotation( m_rotation );
 
    MATRIX3x3D scale;
    scale.SetIdentity();
    scale.SetScale( VECTOR2D( m_worldScale, m_worldScale ) );
 
    MATRIX3x3D flip;
    flip.SetIdentity();
    flip.SetScale( VECTOR2D( m_globalFlipX ? -1.0 : 1.0, m_globalFlipY ? -1.0 : 1.0 ) );
 
    MATRIX3x3D lookat;
    lookat.SetIdentity();
    lookat.SetTranslation( -m_lookAtPoint );
 
    m_worldScreenMatrix = translation * rotate * flip * scale * lookat;
    m_screenWorldMatrix = m_worldScreenMatrix.Inverse();
}
 
 
BOX2D GAL::GetVisibleWorldExtents() const
{
    const MATRIX3x3D& matrix = GetScreenWorldMatrix();
 
    VECTOR2D halfSize = VECTOR2D( matrix.GetScale().x * m_screenSize.x * 0.5,
                                  matrix.GetScale().y * m_screenSize.y * 0.5 );
 
    BOX2D extents;
    extents.SetOrigin( GetLookAtPoint() - halfSize );
    extents.SetSize( halfSize * 2 );
 
    return extents;
}
 
 
double GAL::computeMinGridSpacing() const
{
    // just return the current value. This could be cleverer and take
    // into account other settings in future
    return m_gridMinSpacing;
}
 
 
void GAL::SetGridSources( std::vector<GRID_SOURCE> aSources )
{
    std::stable_sort( aSources.begin(), aSources.end(),
                      []( const GRID_SOURCE& a, const GRID_SOURCE& b )
                      {
                          return a.TakesPrecedenceOver( b );
                      } );
 
    m_gridSources = std::move( aSources );
}
 
 
BOX2D GAL::gridScreenBBox( const GRID_SOURCE& aSrc ) const
{
    const VECTOR2D corners[4] = { m_screenWorldMatrix * VECTOR2D( 0, 0 ),
                                  m_screenWorldMatrix * VECTOR2D( m_screenSize.x, 0 ),
                                  m_screenWorldMatrix * VECTOR2D( 0, m_screenSize.y ),
                                  m_screenWorldMatrix * VECTOR2D( m_screenSize ) };
 
    const double co = std::cos( aSrc.orientation );
    const double so = std::sin( aSrc.orientation );
 
    BOX2D bbox;
 
    for( const VECTOR2D& w : corners )
    {
        const VECTOR2D off = w - aSrc.origin;
        bbox.Merge( VECTOR2D( co * off.x - so * off.y, so * off.x + co * off.y ) );
    }
 
    return bbox;
}
 
 
GAL::GRID_LATTICE GAL::gridLattice( const GRID_SOURCE& aSrc ) const
{
    GRID_LATTICE lattice;
    lattice.tick = aSrc.tick > 0 ? aSrc.tick : static_cast<unsigned>( m_gridTick );
    lattice.extent = aSrc.extent;
 
    const double threshold =
            computeMinGridSpacing() / m_worldScale * ( aSrc.style == GRID_STYLE::SMALL_CROSS ? 2.0 : 1.0 );
 
    if( aSrc.kind == GRID_SOURCE::KIND::POLAR )
    {
        if( aSrc.unbounded )
        {
            const BOX2D  screen = gridScreenBBox( aSrc );
            const double farX = std::max( std::abs( screen.GetLeft() ), std::abs( screen.GetRight() ) );
            const double farY = std::max( std::abs( screen.GetTop() ), std::abs( screen.GetBottom() ) );
 
            // Bleed past the farthest corner
            lattice.extent = VECTOR2D( std::hypot( farX, farY ) * 1.01, 2 * M_PI );
        }
 
        lattice.pitch.x = AutoSparsePitch( aSrc.pitch.x, lattice.tick, threshold );
        lattice.pitch.y = aSrc.pitch.y;
 
        if( lattice.extent.x > 0.0 )
            lattice.pitch.y = AutoSparsePitch( aSrc.pitch.y, lattice.tick, threshold / lattice.extent.x );
    }
    else
    {
        // Both axes thin out by the same factor, which keeps the cells' shape
        const double minPitch = std::min( aSrc.pitch.x, aSrc.pitch.y );
        const double sparse = AutoSparsePitch( minPitch, lattice.tick, threshold ) / minPitch;
 
        lattice.pitch = VECTOR2D( aSrc.pitch.x * sparse, aSrc.pitch.y * sparse );
    }
 
    return lattice;
}
 
 
COLOR4D GAL::gridSourceColor( const GRID_SOURCE& aSrc ) const
{
    COLOR4D color = aSrc.color.a > 0 ? aSrc.color : m_gridColor;
 
    if( aSrc.highlighted )
        color.Brighten( GRID_SELECTED_BRIGHTEN );
 
    return color;
}
 
 
void GAL::drawGridCoverageShape( const GRID_SOURCE& aSrc )
{
    Save();
    Translate( aSrc.origin );
 
    // GAL rotation is counterclockwise and grid orientation clockwise on the screen
    Rotate( -aSrc.orientation );
 
    const double rMax = aSrc.extent.x;
    const double phiMax = aSrc.extent.y;
 
    if( aSrc.unbounded )
    {
        const BOX2D screen = gridScreenBBox( aSrc );
 
        DrawRectangle( screen.GetOrigin(), screen.GetEnd() );
    }
    else if( aSrc.kind == GRID_SOURCE::KIND::CARTESIAN )
    {
        DrawRectangle( -aSrc.extent, aSrc.extent );
    }
    else if( rMax > 0.0 && phiMax >= 2 * M_PI - 1e-6 )
    {
        DrawCircle( VECTOR2D( 0, 0 ), rMax );
    }
    else if( rMax > 0.0 && phiMax > 0.0 )
    {
        const int            segments = std::max( 16, static_cast<int>( phiMax / ( M_PI / 16 ) ) );
        std::deque<VECTOR2D> sector;
 
        sector.emplace_back( 0.0, 0.0 );
 
        for( int ii = 0; ii <= segments; ++ii )
        {
            const double phi = phiMax * ii / segments;
            sector.emplace_back( rMax * std::cos( phi ), rMax * std::sin( phi ) );
        }
 
        sector.emplace_back( 0.0, 0.0 );
        DrawPolygon( sector );
    }
 
    Restore();
}
 
 
VECTOR2D GAL::GetGridPoint( const VECTOR2D& aPoint ) const
{
    // m_gridSources is precedence-ordered by SetGridSources, so the first cursor-snap
    // source covering aPoint is the one that owns it.
    for( const GRID_SOURCE& src : m_gridSources )
    {
        if( src.snapCursor && src.Contains( aPoint ) )
            return src.Snap( aPoint );
    }
 
    // Display-grid fallback.  Grid size 0 = no grid, return aPoint unchanged.
    double cx = m_gridSize.x > 0.0 ? KiROUND( ( aPoint.x - m_gridOffset.x ) / m_gridSize.x ) *
                m_gridSize.x + m_gridOffset.x
                                   : aPoint.x;
    double cy = m_gridSize.y > 0.0 ? KiROUND( ( aPoint.y - m_gridOffset.y ) / m_gridSize.y ) *
                                     m_gridSize.y + m_gridOffset.y
                                   : aPoint.y;
 
    return VECTOR2D( cx, cy );
}
 
 
// MIN_DEPTH must be set to be - (VIEW::VIEW_MAX_LAYERS + abs(VIEW::TOP_LAYER_MODIFIER))
// MAX_DEPTH must be set to be VIEW::VIEW_MAX_LAYERS + abs(VIEW::TOP_LAYER_MODIFIER) -1
// VIEW_MAX_LAYERS and TOP_LAYER_MODIFIER are defined in view.h.
// TOP_LAYER_MODIFIER is set as -VIEW_MAX_LAYERS
// Currently KIGFX::VIEW::VIEW_MAX_LAYERS = MAX_LAYERS_FOR_VIEW
const int GAL::MIN_DEPTH = -2*MAX_LAYERS_FOR_VIEW;
const int GAL::MAX_DEPTH = 2*MAX_LAYERS_FOR_VIEW - 1;
const int GAL::GRID_DEPTH = MAX_DEPTH - 1;
 
 
COLOR4D GAL::getCursorColor() const
{
    COLOR4D color = m_cursorColor;
 
    // dim the cursor if it's only on because it was forced
    // (this helps to provide a hint for active tools)
    if( !m_isCursorEnabled )
        color.a = color.a * 0.5;
 
    return color;
}
 
 
void GAL::BitmapText( const wxString& aText, const VECTOR2I& aPosition, const EDA_ANGLE& aAngle )
{
    KIFONT::FONT* font = KIFONT::FONT::GetFont();
 
    if( aText.IsEmpty() )
        return;
 
    TEXT_ATTRIBUTES attrs = m_attributes;
    attrs.m_Angle = aAngle;
    attrs.m_Mirrored = m_globalFlipX;    // Prevent text flipping when view is flipped
 
    // Bitmap font has different metrics than the stroke font so we compensate a bit before
    // stroking
    attrs.m_Size = VECTOR2I( m_attributes.m_Size.x, m_attributes.m_Size.y * 0.95 );
    attrs.m_StrokeWidth = GetLineWidth() * 0.74;
 
    font->Draw( this, aText, aPosition, attrs, KIFONT::METRICS::Default() );
}
 
 
bool GAL::SetNativeCursorStyle( KICURSOR aCursor, bool aHiDPI )
{
    if( m_currentNativeCursor == aCursor )
        return false;
 
    m_currentNativeCursor = aCursor;
 
    return true;
}