graphics_abstraction_layer.h

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/>.
 */
 
#ifndef GRAPHICSABSTRACTIONLAYER_H_
#define GRAPHICSABSTRACTIONLAYER_H_
 
#include <array>
#include <cstdint>
#include <deque>
#include <stack>
#include <limits>
#include <tuple>
 
#include <math/matrix3x3.h>
#include <math/box2.h>
#include <geometry/grid_geometry.h>
 
#include <gal/gal.h>
#include <gal/color4d.h>
#include <gal/cursors.h>
#include <gal/definitions.h>
#include <gal/gal_display_options.h>
#include <font/stroke_font.h>
#include <geometry/eda_angle.h>
#include <pgm_base.h>
#include <settings/common_settings.h>
 
class SHAPE_LINE_CHAIN;
class SHAPE_POLY_SET;
class BITMAP_BASE;
 
namespace KIGFX
{
 
struct RETAINED_GROUP_ORDER
{
    int64_t                  priority = 0;
    std::array<int, 4>       bbox{};
    wxString                 className;
    double                   lodScale = 0.0;
    std::array<uint64_t, 2>  contentHash{};
    bool                     contentTie = false;
 
    bool SamePrefix( const RETAINED_GROUP_ORDER& aOther ) const
    {
        return std::tie( priority, bbox, className, lodScale )
               == std::tie( aOther.priority, aOther.bbox, aOther.className, aOther.lodScale );
    }
 
    bool operator<( const RETAINED_GROUP_ORDER& aOther ) const
    {
        return std::tie( priority, bbox, className, lodScale, contentHash )
               < std::tie( aOther.priority, aOther.bbox, aOther.className, aOther.lodScale, aOther.contentHash );
    }
};

inline double AutoSparsePitch( double aPitch, unsigned aTick, double aThreshold )
{
    const unsigned mult = ( aTick > 1 ) ? aTick : 2u;
 
    while( aPitch > 0.0 && aPitch <= aThreshold )
        aPitch *= mult;
 
    return aPitch;
}
 

struct GRID_SOURCE : public GRID_GEOMETRY
{
    bool unbounded = false;   
    bool axesEnabled = false; 
    bool snapCursor = false;  
    bool highlighted = false; 
 
    unsigned tick = 0;        
 
    COLOR4D    color;
    GRID_STYLE style = GRID_STYLE::LINES;
};
 

constexpr double GRID_DIM_ALPHA = 0.4;

constexpr double GRID_EDGE_DARKEN = 0.75;

constexpr double GRID_SELECTED_BRIGHTEN = 0.5;
 

enum class GAL_CONTEXT_LOSS
{
    NONE,         
    RECOVERABLE,  
    REPEATED      
};
 

class GAL_API GAL : GAL_DISPLAY_OPTIONS_OBSERVER
{
    // These friend declarations allow us to hide routines that should not be called.  The
    // corresponding RAII objects must be used instead.
    friend class GAL_CONTEXT_LOCKER;
    friend class GAL_UPDATE_CONTEXT;
    friend class GAL_DRAWING_CONTEXT;
 
public:
    // Constructor / Destructor
    GAL( GAL_DISPLAY_OPTIONS& aOptions );
    virtual ~GAL();

    virtual bool IsInitialized() const { return true; }

    virtual bool IsVisible() const { return true; }

    virtual bool IsCairoEngine() { return false; }

    virtual bool IsOpenGlEngine() { return false; }

    virtual bool RefillsNonCachedTargets() const { return false; }

    virtual bool HasStaticRebuildPending() const { return false; }

    virtual bool HasRetainedScene() const { return false; }

    virtual void BeginSceneLayer( int aLayer ) {}

    virtual void SetSceneLayerState( int aLayer, int aOrder, bool aVisible, bool aHasNegatives ) {}

    virtual void SetSceneLayerDim( int aLayer, const COLOR4D& aToward, double aKeep ) {}

    virtual void SetSceneLayerOverlayAlpha( int aLayer ) {}

    virtual void SetSceneDrawOrdered( bool aOrdered ) {}

    virtual void SetGroupPlacement( int aGroup, int aLayer, double aLodScale, bool aShown,
                                    const RETAINED_GROUP_ORDER& aOrder ) {}

    virtual void SetSceneScale( double aScale ) {}

    virtual bool IsDrawingMode() const { return false; }

    virtual bool SupportsTypedPads() const { return false; }

    virtual bool UsesPolygonTriangulationCache() const { return false; }
 
    // ---------------
    // Drawing methods
    // ---------------

    virtual void DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};

    virtual void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint,
                              double aWidth ){};

    virtual void DrawTrack( const VECTOR2D& aStart, const VECTOR2D& aEnd,
                            double aWidth, const COLOR4D& aColor );

    virtual void DrawPad( const VECTOR2D& aCenter, double aHalfWidth, double aHalfHeight,
                          double aCornerRadius, float aShapeType, double aRotation,
                          const COLOR4D& aColor ) {}

    virtual void DrawSegmentChain( const std::vector<VECTOR2D>& aPointList, double aWidth ){};
    virtual void DrawSegmentChain( const SHAPE_LINE_CHAIN& aLineChain, double aWidth ){};

    virtual void DrawPolyline( const std::deque<VECTOR2D>& aPointList ) {};
    virtual void DrawPolyline( const std::vector<VECTOR2D>& aPointList ) {};
    virtual void DrawPolyline( const VECTOR2D aPointList[], int aListSize ) {};
    virtual void DrawPolyline( const SHAPE_LINE_CHAIN& aLineChain ) {};

    virtual void DrawPolylines( const std::vector<std::vector<VECTOR2D>>& aPointLists ){};

    virtual void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) {};

    virtual void DrawHoleWall( const VECTOR2D& aCenterPoint, double aHoleRadius,
                               double aWallWidth ) {};

    virtual void DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
                          const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle ){};

    virtual void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius,
                                 const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle,
                                 double aWidth, double aMaxError ){};

    virtual void DrawEllipse( const VECTOR2D& aCenterPoint, double aMajorRadius, double aMinorRadius,
                              const EDA_ANGLE& aRotation );

    virtual void DrawEllipseArc( const VECTOR2D& aCenterPoint, double aMajorRadius, double aMinorRadius,
                                 const EDA_ANGLE& aRotation, const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle );

    virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
 
    void DrawRectangle( const BOX2I& aRect )
    {
        DrawRectangle( aRect.GetOrigin(), aRect.GetEnd() );
    }

    virtual void DrawGlyph( const KIFONT::GLYPH& aGlyph, int aNth = 0, int aTotal = 1 ) {};

    virtual void DrawGlyphs( const std::vector<std::unique_ptr<KIFONT::GLYPH>>& aGlyphs )
    {
        COLOR4D fillColor = GetFillColor();
        COLOR4D strokeColor = GetStrokeColor();
 
        for( size_t i = 0; i < aGlyphs.size(); i++ )
        {
            if( aGlyphs[i]->IsHover() )
            {
                SetFillColor( m_hoverColor );
                SetStrokeColor( m_hoverColor );
            }
 
            DrawGlyph( *aGlyphs[i], i, aGlyphs.size() );
 
            if( aGlyphs[i]->IsHover() )
            {
                SetFillColor( fillColor );
                SetStrokeColor( strokeColor );
            }
        }
    }
 

    virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) {};
    virtual void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) {};
    virtual void DrawPolygon( const SHAPE_POLY_SET& aPolySet,
                              bool aStrokeTriangulation = false ) {};
    virtual void DrawPolygon( const SHAPE_LINE_CHAIN& aPolySet ) {};

    virtual void DrawCurve( const VECTOR2D& startPoint,    const VECTOR2D& controlPointA,
                            const VECTOR2D& controlPointB, const VECTOR2D& endPoint,
                            double aFilterValue = 0.0 ) {};

    virtual void DrawBitmap( const BITMAP_BASE& aBitmap, double alphaBlend = 1.0 ) {};
 
    // --------------
    // Screen methods
    // --------------

    virtual void ResizeScreen( int aWidth, int aHeight ) {};

    virtual bool Show( bool aShow ) { return true; };

    const VECTOR2I& GetScreenPixelSize() const
    {
        return m_screenSize;
    }

    virtual VECTOR2I GetLayoutPixelSize() const { return m_screenSize; }

    virtual int GetSwapInterval() const { return 0; };

    virtual void Flush() {};

    virtual void MarkStaticDirty() {};
 
    void SetClearColor( const COLOR4D& aColor )
    {
        m_clearColor = aColor;
    }
 
    const COLOR4D& GetClearColor( ) const
    {
        return m_clearColor;
    }

    virtual void ClearScreen() {};
 
    // -----------------
    // Attribute setting
    // -----------------

    virtual void SetIsFill( bool aIsFillEnabled )
    {
        m_isFillEnabled = aIsFillEnabled;
    }

    inline bool GetIsFill() const
    {
        return m_isFillEnabled;
    }

    virtual void SetIsStroke( bool aIsStrokeEnabled )
    {
        m_isStrokeEnabled = aIsStrokeEnabled;
    }

    inline bool GetIsStroke() const
    {
        return m_isStrokeEnabled;
    }

    virtual void SetFillColor( const COLOR4D& aColor )
    {
        m_fillColor = aColor;
    }

    inline const COLOR4D& GetFillColor() const
    {
        return m_fillColor;
    }

    virtual void SetStrokeColor( const COLOR4D& aColor )
    {
        m_strokeColor = aColor;
    }
 
    virtual void SetHoverColor( const COLOR4D& aColor )
    {
        m_hoverColor = aColor;
    }

    inline const COLOR4D& GetStrokeColor() const
    {
        return m_strokeColor;
    }

    virtual void SetLineWidth( float aLineWidth )
    {
        m_lineWidth = aLineWidth;
    }

    virtual void SetMinLineWidth( float aLineWidth )
    {
        m_minLineWidth = aLineWidth;
    }

    inline float GetLineWidth() const
    {
        return m_lineWidth;
    }

    inline float GetMinLineWidth() const
    {
        return m_minLineWidth;
    }

    virtual void SetLayerDepth( double aLayerDepth )
    {
        wxCHECK_MSG( aLayerDepth <= m_depthRange.y, /*void*/,
                     wxT( "SetLayerDepth: below minimum" ) );
        wxCHECK_MSG( aLayerDepth >= m_depthRange.x, /*void*/,
                     wxT( "SetLayerDepth: above maximum" ) );
 
        m_layerDepth = aLayerDepth;
    }

    inline void AdvanceDepth()
    {
        SetLayerDepth( m_layerDepth - 0.1 );
    }
 
    // ----
    // Text
    // ----

    virtual void BitmapText( const wxString& aText, const VECTOR2I& aPosition,
                             const EDA_ANGLE& aAngle );

    void ResetTextAttributes();
 
    void SetGlyphSize( const VECTOR2I aSize )         { m_attributes.m_Size = aSize; }
    const VECTOR2I& GetGlyphSize() const              { return m_attributes.m_Size; }
 
    inline void SetFontBold( const bool aBold )       { m_attributes.m_Bold = aBold; }
    inline bool IsFontBold() const                    { return m_attributes.m_Bold; }
 
    inline void SetFontItalic( bool aItalic )         { m_attributes.m_Italic = aItalic; }
    inline bool IsFontItalic() const                  { return m_attributes.m_Italic; }
 
    inline void SetFontUnderlined( bool aUnderlined ) { m_attributes.m_Underlined = aUnderlined; }
    inline bool IsFontUnderlined() const              { return m_attributes.m_Underlined; }
 
    void SetTextMirrored( const bool aMirrored )      { m_attributes.m_Mirrored = aMirrored; }
    bool IsTextMirrored() const                       { return m_attributes.m_Mirrored; }
 
    void SetHorizontalJustify( const GR_TEXT_H_ALIGN_T aHorizontalJustify )
    {
        m_attributes.m_Halign = aHorizontalJustify;
    }
 
    GR_TEXT_H_ALIGN_T GetHorizontalJustify() const { return m_attributes.m_Halign; }
 
    void SetVerticalJustify( const GR_TEXT_V_ALIGN_T aVerticalJustify )
    {
        m_attributes.m_Valign = aVerticalJustify;
    }
 
    GR_TEXT_V_ALIGN_T GetVerticalJustify() const { return m_attributes.m_Valign; }
 
 
    // --------------
    // Transformation
    // --------------

    virtual void Transform( const MATRIX3x3D& aTransformation ) {};

    virtual void Rotate( double aAngle ) {};

    virtual void Translate( const VECTOR2D& aTranslation ) {};

    virtual void Scale( const VECTOR2D& aScale ) {};

    virtual void Save() {};

    virtual void Restore() {};
 
    // --------------------------------------------
    // Group methods
    // ---------------------------------------------

    virtual int BeginGroup() { return 0; };

    virtual void EndGroup() {};
 
    virtual std::array<uint64_t, 2> GroupContentFingerprint( int aGroupNumber ) const { return {}; }

    virtual void DrawGroup( int aGroupNumber ) {};

    virtual void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) {};

    virtual void ChangeGroupDepth( int aGroupNumber, int aDepth ) {};

    virtual void ChangeGroupUndimmed( int aGroupNumber, bool aUndimmed ) {};

    virtual void DeleteGroup( int aGroupNumber ) {};

    virtual void ClearCache() {};
 
    // --------------------------------------------------------
    // Handling the world <-> screen transformation
    // --------------------------------------------------------

    virtual void ComputeWorldScreenMatrix();

    const MATRIX3x3D& GetWorldScreenMatrix() const
    {
        m_worldScaleRead = true;
        return m_worldScreenMatrix;
    }

    const MATRIX3x3D& GetScreenWorldMatrix() const
    {
        m_worldScaleRead = true;
        return m_screenWorldMatrix;
    }

    inline void SetWorldScreenMatrix( const MATRIX3x3D& aMatrix )
    {
        m_worldScreenMatrix = aMatrix;
    }

    BOX2D GetVisibleWorldExtents() const;

    void SetWorldUnitLength( double aWorldUnitLength ) { m_worldUnitLength = aWorldUnitLength; }
 
    double GetWorldUnitLength() const { return m_worldUnitLength; }
 
    void SetScreenSize( const VECTOR2I& aSize ) { m_screenSize = aSize; }

    void SetScreenDPI( double aScreenDPI ) { m_screenDPI = aScreenDPI; }
    double GetScreenDPI() const            { return m_screenDPI; }

    void SetLookAtPoint( const VECTOR2D& aPoint ) { m_lookAtPoint = aPoint; }
    const VECTOR2D& GetLookAtPoint() const        { return m_lookAtPoint; }
 
    void SetZoomFactor( double aZoomFactor )      { m_zoomFactor = aZoomFactor; }
    double GetZoomFactor() const                  { return m_zoomFactor; }

    void SetRotation( double aRotation )          { m_rotation = aRotation; }
    double GetRotation() const                    { return m_rotation; }

    void SetDepthRange( const VECTOR2D& aDepthRange ) { m_depthRange = aDepthRange; }
    double GetMinDepth() const                        { return m_depthRange.x; }
    double GetMaxDepth() const                        { return m_depthRange.y; }

    double GetWorldScale() const
    {
        m_worldScaleRead = true;
        return m_worldScale;
    }

    double GetWorldScaleForScreenSpace() const { return m_worldScale; }

    bool WorldScaleBelow( double aLimit ) const
    {
        const bool below = m_worldScale < aLimit;
 
        if( below )
            m_scaleLimitAbove = std::min( m_scaleLimitAbove, aLimit );
        else
            m_scaleLimitBelow = std::max( m_scaleLimitBelow, aLimit );
 
        return below;
    }

    void TakeWorldScaleLimits( double& aBelow, double& aAbove ) const
    {
        aBelow = m_scaleLimitBelow;
        aAbove = m_scaleLimitAbove;
        m_scaleLimitBelow = 0.0;
        m_scaleLimitAbove = std::numeric_limits<double>::max();
    }

    bool TakeWorldScaleRead() const
    {
        const bool read = m_worldScaleRead;
 
        m_worldScaleRead = false;
        return read;
    }

    inline void SetFlip( bool xAxis, bool yAxis )
    {
        m_globalFlipX = xAxis;
        m_globalFlipY = yAxis;
    }
 
    bool IsFlippedX() const { return m_globalFlipX; }
    bool IsFlippedY() const { return m_globalFlipY; }
 
    // ---------------------------
    // Buffer manipulation methods
    // ---------------------------

    virtual void SetTarget( RENDER_TARGET aTarget ) {};

    virtual RENDER_TARGET GetTarget() const { return TARGET_CACHED; };

    virtual void ClearTarget( RENDER_TARGET aTarget ) {};

    virtual bool HasTarget( RENDER_TARGET aTarget )
    {
        return true;
    };

    virtual void SetNegativeDrawMode( bool aSetting ) {};

    virtual void SetScreenSpaceMode( bool aEnabled ) {}

    virtual bool SupportsStrokePixelPad() const { return false; }

    virtual bool SupportsStrokeLengthPad() const { return false; }

    virtual void SetStrokeLengthPad( double aPixels ) {}

    virtual void SetStrokePixelPad( double aPixels ) {}

    virtual bool SupportsStrokeLevelOfDetail() const { return false; }

    virtual void SetStrokeLevelOfDetail( double aLod ) {}

    virtual void StartDiffLayer() {};

    virtual void EndDiffLayer() {};

    virtual void StartNegativesLayer(){};

    virtual void EndNegativesLayer(){};
 
    // -------------
    // Grid methods
    // -------------

    void SetGridVisibility( bool aVisibility ) { m_gridVisibility = aVisibility; }
 
    bool GetGridVisibility() const { return m_gridVisibility; }
 
    bool GetGridSnapping() const
    {
        return m_options.m_gridSnapping == KIGFX::GRID_SNAPPING::ALWAYS ||
                 ( m_gridVisibility && m_options.m_gridSnapping == KIGFX::GRID_SNAPPING::WITH_GRID );
    }

    inline void SetGridOrigin( const VECTOR2D& aGridOrigin )
    {
        m_gridOrigin = aGridOrigin;
 
        if( m_gridSize.x == 0.0 || m_gridSize.y == 0.0 )
        {
            m_gridOffset = VECTOR2D( 0.0, 0.0);
        }
        else
        {
            m_gridOffset = VECTOR2D( (long) m_gridOrigin.x % (long) m_gridSize.x,
                                     (long) m_gridOrigin.y % (long) m_gridSize.y );
        }
    }
 
    inline const VECTOR2D& GetGridOrigin() const
    {
        return m_gridOrigin;
    }

    inline void SetGridSize( const VECTOR2D& aGridSize )
    {
        m_gridSize = aGridSize;
 
        // Avoid stupid grid size values: a grid size  should be >= 1 in internal units
        m_gridSize.x = std::max( 1.0, m_gridSize.x );
        m_gridSize.y = std::max( 1.0, m_gridSize.y );
 
        m_gridOffset = VECTOR2D( (long) m_gridOrigin.x % (long) m_gridSize.x,
                                 (long) m_gridOrigin.y % (long) m_gridSize.y );
    }

    inline const VECTOR2D& GetGridSize() const
    {
        return m_gridSize;
    }

    inline VECTOR2D GetVisibleGridSize() const
    {
        VECTOR2D gridScreenSize( m_gridSize );
        gridScreenSize.x = std::max( 100.0, gridScreenSize.x );
        gridScreenSize.y = std::max( 100.0, gridScreenSize.y );
 
        double gridThreshold = computeMinGridSpacing() / m_worldScale;
 
        if( m_gridStyle == GRID_STYLE::SMALL_CROSS )
            gridThreshold *= 2.0;
 
        // If we cannot display the grid density, scale down by a tick size and
        // try again.  Eventually, we get some representation of the grid
        const double minSize = std::min( gridScreenSize.x, gridScreenSize.y );
        const double sparsed = AutoSparsePitch( minSize, m_gridTick, gridThreshold );
 
        if( minSize > 0.0 && sparsed != minSize )
            gridScreenSize *= sparsed / minSize;
 
        return gridScreenSize;
    }

    inline void SetGridColor( const COLOR4D& aGridColor )
    {
        m_gridColor = aGridColor;
    }

    inline void SetAxesColor( const COLOR4D& aAxesColor )
    {
        m_axesColor = aAxesColor;
    }

    inline void SetAxesEnabled( bool aAxesEnabled )
    {
        m_axesEnabled = aAxesEnabled;
    }

    inline void SetCoarseGrid( int aInterval )
    {
        m_gridTick = aInterval;
    }

    inline float GetGridLineWidth() const
    {
        return m_gridLineWidth;
    }

    void SetGridSources( std::vector<GRID_SOURCE> aSources );
 
    const std::vector<GRID_SOURCE>& GetGridSources() const { return m_gridSources; }
 
    GRID_STYLE     GetGridStyle() const { return m_gridStyle; }
    int            GetCoarseGrid() const { return m_gridTick; }
    const COLOR4D& GetGridColor() const { return m_gridColor; }

    virtual void DrawGrid() {};

    VECTOR2D GetGridPoint( const VECTOR2D& aPoint ) const;

    inline VECTOR2D ToWorld( const VECTOR2D& aPoint ) const
    {
        return VECTOR2D( m_screenWorldMatrix * aPoint );
    }

    inline VECTOR2D ToScreen( const VECTOR2D& aPoint ) const
    {
        return VECTOR2D( m_worldScreenMatrix * aPoint );
    }

    virtual bool SetNativeCursorStyle( KICURSOR aCursor, bool aHiDPI );

    inline void SetCursorEnabled( bool aCursorEnabled )
    {
        m_isCursorEnabled = aCursorEnabled;
    }

    bool IsCursorEnabled() const
    {
        return m_isCursorEnabled || m_forceDisplayCursor;
    }

    inline void SetCursorColor( const COLOR4D& aCursorColor )
    {
        m_cursorColor = aCursorColor;
    }

    virtual void DrawCursor( const VECTOR2D& aCursorPosition ) {};
 
    virtual void EnableDepthTest( bool aEnabled = false ) {};

    virtual bool IsContextLocked()
    {
        return false;
    }

    virtual bool IsContextValid() const
    {
        return true;
    }

    virtual GAL_CONTEXT_LOSS GetContextLoss() const
    {
        return GAL_CONTEXT_LOSS::NONE;
    }

    virtual bool IsResetSettled()
    {
        return true;
    }
 

    virtual void LockContext( int aClientCookie ) {}
 
    virtual void UnlockContext( int aClientCookie ) {}


    virtual void BeginDrawing() {};

    virtual void EndDrawing() {};
protected:

    virtual void beginUpdate() {}

    virtual void endUpdate() {}
 
 

    inline void computeWorldScale()
    {
        m_worldScale = m_screenDPI * m_worldUnitLength * m_zoomFactor;
 
        PGM_BASE* pgm = PgmOrNull();
 
        if( pgm && pgm->GetCommonSettings() )
            m_worldScale *= pgm->GetCommonSettings()->m_Appearance.zoom_correction_factor;
    }

    double computeMinGridSpacing() const;

    float gridMinorLineWidth( double aWorldPixelSize, double aScaleFactor ) const
    {
        return std::fmax( 1.0f, m_gridLineWidth ) * aWorldPixelSize / aScaleFactor;
    }

    static constexpr int SEG_PER_CIRCLE_COUNT = 64;

    static double calcAngleStep( double aRadius )
    {
        return std::min( 1e6 / aRadius, 2.0 * M_PI / SEG_PER_CIRCLE_COUNT );
    }

    BOX2D gridScreenBBox( const GRID_SOURCE& aSrc ) const;

    struct GRID_LATTICE
    {
        VECTOR2D pitch;     
        VECTOR2D extent;    
        unsigned tick = 0;  
 
        bool IsMajor( int aIndex ) const { return tick > 0 && aIndex % static_cast<int>( tick ) == 0; }
    };

    GRID_LATTICE gridLattice( const GRID_SOURCE& aSrc ) const;

    COLOR4D gridSourceColor( const GRID_SOURCE& aSrc ) const;

    void drawGridCoverageShape( const GRID_SOURCE& aSrc );

    static const int MIN_DEPTH;
    static const int MAX_DEPTH;

    static const int GRID_DEPTH;

    COLOR4D getCursorColor() const;
 
    // ---------------
    // Settings observer interface
    // ---------------
    void OnGalDisplayOptionsChanged( const GAL_DISPLAY_OPTIONS& aOptions ) override;

    virtual bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions );

    template <typename T>
    void normalize( T &a, T &b )
    {
        if( a > b )
        {
            T tmp = a;
            a = b;
            b = tmp;
        }
    }
 
    GAL_DISPLAY_OPTIONS& m_options;
    UTIL::LINK           m_observerLink;
 
    std::stack<double>   m_depthStack;         
    VECTOR2I             m_screenSize;         
 
    double               m_worldUnitLength;    
    double               m_screenDPI;          
    VECTOR2D             m_lookAtPoint;        
 
    double               m_zoomFactor;         
    double               m_rotation;           
    MATRIX3x3D           m_worldScreenMatrix;  
    MATRIX3x3D           m_screenWorldMatrix;  
    double               m_worldScale;         
    mutable bool         m_worldScaleRead = false; 
    mutable double       m_scaleLimitBelow = 0.0;  
    mutable double       m_scaleLimitAbove = std::numeric_limits<double>::max();
 
    bool                 m_globalFlipX;        
    bool                 m_globalFlipY;        
 
    float                m_lineWidth;          
    float                m_minLineWidth;       
 
    bool                 m_isFillEnabled;      
    bool                 m_isStrokeEnabled;    
 
    COLOR4D              m_fillColor;          
    COLOR4D              m_strokeColor;        
    COLOR4D              m_clearColor;
    COLOR4D              m_hoverColor;         
 
    double               m_layerDepth;         
    VECTOR2D             m_depthRange;         
 
    // Grid settings
    bool                 m_gridVisibility;     
    GRID_STYLE           m_gridStyle;          
    VECTOR2D             m_gridSize;           
    VECTOR2D             m_gridOrigin;         
    VECTOR2D             m_gridOffset;         
    COLOR4D              m_gridColor;          
    COLOR4D              m_axesColor;          
    bool                 m_axesEnabled;        
    int                  m_gridTick;           
    float                m_gridLineWidth;      
    int                  m_gridMinSpacing;     
 
    std::vector<GRID_SOURCE> m_gridSources;    
 
    // Cursor settings
    bool                 m_isCursorEnabled;    
    bool                 m_forceDisplayCursor; 
    COLOR4D              m_cursorColor;        
    KIGFX::CROSS_HAIR_MODE m_crossHairMode;    
    VECTOR2D             m_cursorPosition;     
 
    KICURSOR             m_currentNativeCursor; 
 
private:
 
    inline double getLayerDepth() const
    {
        return m_layerDepth;
    }
 
    TEXT_ATTRIBUTES      m_attributes;
 
    friend class GAL_SCOPED_ATTRS;
};
 
 
class GAL_CONTEXT_LOCKER
{
public:
    GAL_CONTEXT_LOCKER( GAL* aGal ) :
        m_gal( aGal )
    {
        m_cookie = rand();
        m_gal->LockContext( m_cookie );
    }
 
    ~GAL_CONTEXT_LOCKER()
    {
        m_gal->UnlockContext( m_cookie );
    }
 
protected:
    GAL* m_gal;
    int  m_cookie;
};
 
 
class GAL_UPDATE_CONTEXT : public GAL_CONTEXT_LOCKER
{
public:
    GAL_UPDATE_CONTEXT( GAL* aGal ) :
            GAL_CONTEXT_LOCKER( aGal ),
            m_updating( aGal->IsContextValid() )
    {
        if( m_updating )
            m_gal->beginUpdate();
    }
 
    ~GAL_UPDATE_CONTEXT()
    {
        if( m_updating )
            m_gal->endUpdate();
    }

    bool IsUpdating() const
    {
        return m_updating;
    }
 
private:
    bool m_updating;
};
 
 
class GAL_DRAWING_CONTEXT : public GAL_CONTEXT_LOCKER
{
public:
    GAL_DRAWING_CONTEXT( GAL* aGal ) :
            GAL_CONTEXT_LOCKER( aGal ),
            m_drawing( aGal->IsContextValid() )
    {
        if( m_drawing )
            m_gal->BeginDrawing();
    }
 
    ~GAL_DRAWING_CONTEXT() noexcept( false )
    {
        if( m_drawing )
            m_gal->EndDrawing();
    }

    bool IsDrawing() const
    {
        return m_drawing;
    }
 
private:
    bool m_drawing;
};
 

class GAL_SCOPED_ATTRS
{
public:
    enum FLAGS
    {
        STROKE_WIDTH = 1,
        STROKE_COLOR = 2,
        IS_STROKE = 4,
        FILL_COLOR = 8,
        IS_FILL = 16,
        LAYER_DEPTH = 32,
 
        // It is not clear to me that GAL needs to save text attributes.
        // Only BitmapText uses it, and maybe that should be passed in
        // explicitly (like for Draw) - every caller of BitmapText sets
        // the text attributes anyway.
        // TEXT_ATTRS = 64,
 
        // Convenience flags
        STROKE = STROKE_WIDTH | STROKE_COLOR | IS_STROKE,
        FILL = FILL_COLOR | IS_FILL,
        STROKE_FILL = STROKE | FILL,
 
        ALL_ATTRS = STROKE | FILL | LAYER_DEPTH,
    };

    GAL_SCOPED_ATTRS( KIGFX::GAL& aGal, int aFlags ) :
            m_gal( aGal ),
            m_flags( aFlags ),
            // Save what we need to restore later.
            // These are all so cheap to copy, it's likely not worth if'ing
            m_strokeColor( aGal.GetStrokeColor() ),
            m_strokeWidth( aGal.GetLineWidth() ),
            m_isStroke( aGal.GetIsStroke() ),
            m_fillColor( aGal.GetFillColor() ),
            m_isFill( aGal.GetIsFill() ),
            m_layerDepth( aGal.getLayerDepth() )
    {
    }
 
    ~GAL_SCOPED_ATTRS()
    {
        // Restore the attributes that were saved
        // based on the flags that were set.
 
        if( m_flags & STROKE_WIDTH )
            m_gal.SetLineWidth( m_strokeWidth );
 
        if( m_flags & STROKE_COLOR )
            m_gal.SetStrokeColor( m_strokeColor );
 
        if( m_flags & IS_STROKE )
            m_gal.SetIsStroke( m_isStroke );
 
        if( m_flags & FILL_COLOR )
            m_gal.SetFillColor( m_fillColor );
 
        if( m_flags & IS_FILL )
            m_gal.SetIsFill( m_isFill );
 
        if( m_flags & LAYER_DEPTH )
            m_gal.SetLayerDepth( m_layerDepth );
    }
 
    // No copying or it can lead to double-restoring of the GAL attributes.
    GAL_SCOPED_ATTRS( const GAL_SCOPED_ATTRS& ) = delete;
    GAL_SCOPED_ATTRS& operator=( const GAL_SCOPED_ATTRS& ) = delete;
 
private:
    GAL& m_gal;
    int  m_flags;
 
    COLOR4D m_strokeColor;
    float   m_strokeWidth;
    bool    m_isStroke;
 
    COLOR4D m_fillColor;
    bool    m_isFill;
 
    double m_layerDepth;
};
 
 
};    // namespace KIGFX
 
#endif /* GRAPHICSABSTRACTIONLAYER_H_ */