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 (C) 2016-2020 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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

#ifndef GRAPHICSABSTRACTIONLAYER_H_
#define GRAPHICSABSTRACTIONLAYER_H_

#include <deque>
#include <stack>
#include <limits>

#include <math/matrix3x3.h>

#include <gal/color4d.h>
#include <gal/definitions.h>
#include <gal/stroke_font.h>
#include <gal/gal_display_options.h>
#include <newstroke_font.h>

class SHAPE_LINE_CHAIN;
class SHAPE_POLY_SET;
class BITMAP_BASE;

namespace KIGFX
{

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

    // ---------------
    // Drawing methods
    // ---------------

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

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

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

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

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

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

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

    virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) {};
    virtual void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) {};
    virtual void DrawPolygon( const SHAPE_POLY_SET& aPolySet ) {};
    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 ) {};

    // --------------
    // Screen methods
    // --------------

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

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

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

    virtual void Flush() {};

    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 )
    {
        isFillEnabled = aIsFillEnabled;
    }

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

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

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

    virtual void SetStrokeColor( const COLOR4D& aColor )
    {
        strokeColor = aColor;
    }

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

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

    inline float GetLineWidth() const
    {
        return lineWidth;
    }

    virtual void SetLayerDepth( double aLayerDepth )
    {
        assert( aLayerDepth <= depthRange.y );
        assert( aLayerDepth >= depthRange.x );

        layerDepth = aLayerDepth;
    }

    // ----
    // Text
    // ----

    const STROKE_FONT& GetStrokeFont() const
    {
        return strokeFont;
    }

    virtual void StrokeText( const wxString& aText, const VECTOR2D& aPosition,
                             double aRotationAngle )
    {
        strokeFont.Draw( aText, aPosition, aRotationAngle );
    }

    virtual void BitmapText( const wxString& aText, const VECTOR2D& aPosition,
                             double aRotationAngle )
    {
        // Fallback: use stroke font

        // Handle flipped view
        if( globalFlipX )
            textProperties.m_mirrored = !textProperties.m_mirrored;

        StrokeText( aText, aPosition, aRotationAngle );

        if( globalFlipX )
            textProperties.m_mirrored = !textProperties.m_mirrored;
    }

    VECTOR2D GetTextLineSize( const UTF8& aText ) const;

    virtual void SetTextAttributes( const EDA_TEXT* aText );

    void ResetTextAttributes();

    inline void SetGlyphSize( const VECTOR2D aSize ) { textProperties.m_glyphSize = aSize; }
    const VECTOR2D& GetGlyphSize() const { return textProperties.m_glyphSize; }

    inline void SetFontBold( const bool aBold ) { textProperties.m_bold = aBold;  }
    inline bool IsFontBold() const { return textProperties.m_bold; }

    inline void SetFontItalic( bool aItalic ) { textProperties.m_italic = aItalic; }
    inline bool IsFontItalic() const { return textProperties.m_italic; }

    inline void SetFontUnderlined( bool aUnderlined ) { textProperties.m_underlined = aUnderlined; }
    inline bool IsFontUnderlined() const { return textProperties.m_underlined; }

    inline void SetTextMirrored( const bool aMirrored ) { textProperties.m_mirrored = aMirrored; }
    inline bool IsTextMirrored() const { return textProperties.m_mirrored; }

    inline void SetHorizontalJustify( const EDA_TEXT_HJUSTIFY_T aHorizontalJustify )
    {
        textProperties.m_horizontalJustify = aHorizontalJustify;
    }

    inline EDA_TEXT_HJUSTIFY_T GetHorizontalJustify() const
    {
        return textProperties.m_horizontalJustify;
    }

    inline void SetVerticalJustify( const EDA_TEXT_VJUSTIFY_T aVerticalJustify )
    {
        textProperties.m_verticalJustify = aVerticalJustify;
    }

    inline EDA_TEXT_VJUSTIFY_T GetVerticalJustify() const
    {
        return textProperties.m_verticalJustify;
    }


    // --------------
    // 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 void DrawGroup( int aGroupNumber ) {};

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

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

    virtual void DeleteGroup( int aGroupNumber ) {};

    virtual void ClearCache() {};

    // --------------------------------------------------------
    // Handling the world <-> screen transformation
    // --------------------------------------------------------

    virtual void ComputeWorldScreenMatrix();

    const MATRIX3x3D& GetWorldScreenMatrix() const
    {
        return worldScreenMatrix;
    }

    const MATRIX3x3D& GetScreenWorldMatrix() const
    {
        return screenWorldMatrix;
    }

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

    inline void SetWorldUnitLength( double aWorldUnitLength )
    {
        worldUnitLength = aWorldUnitLength;
    }

    inline void SetScreenSize( const VECTOR2I& aSize )
    {
        screenSize = aSize;
    }

    inline void SetScreenDPI( double aScreenDPI )
    {
        screenDPI = aScreenDPI;
    }

    inline void SetLookAtPoint( const VECTOR2D& aPoint )
    {
        lookAtPoint = aPoint;
    }

    inline const VECTOR2D& GetLookAtPoint() const
    {
        return lookAtPoint;
    }

    inline void SetZoomFactor( double aZoomFactor )
    {
        zoomFactor = aZoomFactor;
    }

    inline double GetZoomFactor() const
    {
        return zoomFactor;
    }

    void SetRotation( double aRotation )
    {
        rotation = aRotation;
    }

    double GetRotation() const
    {
        return rotation;
    }

    inline void SetDepthRange( const VECTOR2D& aDepthRange )
    {
        depthRange = aDepthRange;
    }

    inline double GetMinDepth() const
    {
        return depthRange.x;
    }

    inline double GetMaxDepth() const
    {
        return depthRange.y;
    }

    inline double GetWorldScale() const
    {
        return worldScale;
    }

    inline void SetFlip( bool xAxis, bool yAxis )
    {
        globalFlipX = xAxis;
        globalFlipY = yAxis;
    }

    bool IsFlippedX() const
    {
        return globalFlipX;
    }

    bool IsFlippedY() const
    {
        return 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 ) {};

    // -------------
    // Grid methods
    // -------------

    void SetGridVisibility( bool aVisibility ) { gridVisibility = aVisibility; }

    bool GetGridVisibility() const { return gridVisibility; }

    bool GetGridSnapping() const
    {
        return ( options.m_gridSnapping == KIGFX::GRID_SNAPPING::ALWAYS ||
                ( gridVisibility && options.m_gridSnapping == KIGFX::GRID_SNAPPING::WITH_GRID ) );
    }
    inline void SetGridOrigin( const VECTOR2D& aGridOrigin )
    {
        gridOrigin = aGridOrigin;

        if( gridSize.x == 0.0 || gridSize.y == 0.0 )
            gridOffset = VECTOR2D(0.0, 0.0);
        else
            gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
                                   (long) gridOrigin.y % (long) gridSize.y );
    }

    inline const VECTOR2D& GetGridOrigin() const
    {
        return gridOrigin;
    }

    inline void SetGridSize( const VECTOR2D& aGridSize )
    {
        gridSize = aGridSize;

        // Avoid stupid grid size values: a grid size  should be >= 1 in internal units
        gridSize.x = std::max( 1.0, gridSize.x );
        gridSize.y = std::max( 1.0, gridSize.y );

        gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
                               (long) gridOrigin.y % (long) gridSize.y );
    }

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

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

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

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

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

    inline float GetGridLineWidth() const
    {
        return gridLineWidth;
    }

    virtual void DrawGrid() {};

    VECTOR2D GetGridPoint( const VECTOR2D& aPoint ) const;

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

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

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

    bool IsCursorEnabled() const
    {
        return isCursorEnabled || forceDisplayCursor;
    }

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

    virtual void DrawCursor( const VECTOR2D& aCursorPosition ) {};

    inline void AdvanceDepth()
    {
        layerDepth -= 0.05;
    }

    inline void PushDepth()
    {
        depthStack.push( layerDepth );
    }

    inline void PopDepth()
    {
        layerDepth = depthStack.top();
        depthStack.pop();
    }

    virtual void EnableDepthTest( bool aEnabled = false ) {};

    virtual bool IsContextLocked()
    {
        return false;
    }

protected:
    virtual void lockContext( int aClientCookie ) {}

    virtual void unlockContext( int aClientCookie ) {}

    virtual void beginUpdate() {}

    virtual void endUpdate() {}

    virtual void beginDrawing() {};

    virtual void endDrawing() {};

    inline void computeWorldScale()
    {
        worldScale = screenDPI * worldUnitLength * zoomFactor;
    }

    double computeMinGridSpacing() const;

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

    GAL_DISPLAY_OPTIONS&    options;
    UTIL::LINK              observerLink;

    std::stack<double> depthStack;             
    VECTOR2I           screenSize;             

    double             worldUnitLength;        
    double             screenDPI;              
    VECTOR2D           lookAtPoint;            

    double             zoomFactor;             
    double             rotation;               
    MATRIX3x3D         worldScreenMatrix;      
    MATRIX3x3D         screenWorldMatrix;      
    double             worldScale;             

    bool globalFlipX;                          
    bool globalFlipY;                          

    float              lineWidth;              

    bool               isFillEnabled;          
    bool               isStrokeEnabled;        

    COLOR4D            fillColor;              
    COLOR4D            strokeColor;            
    COLOR4D            m_clearColor;

    double             layerDepth;             
    VECTOR2D           depthRange;             

    // Grid settings
    bool               gridVisibility;         
    GRID_STYLE         gridStyle;              
    VECTOR2D           gridSize;               
    VECTOR2D           gridOrigin;             
    VECTOR2D           gridOffset;             
    COLOR4D            gridColor;              
    COLOR4D            axesColor;              
    bool               axesEnabled;            
    int                gridTick;               
    float              gridLineWidth;          
    int                gridMinSpacing;         

    // Cursor settings
    bool               isCursorEnabled;        
    bool               forceDisplayCursor;     
    COLOR4D            cursorColor;            
    bool               fullscreenCursor;       
    VECTOR2D           cursorPosition;         

    STROKE_FONT        strokeFont;

private:
    struct TEXT_PROPERTIES
    {
        VECTOR2D            m_glyphSize;            
        EDA_TEXT_HJUSTIFY_T m_horizontalJustify;    
        EDA_TEXT_VJUSTIFY_T m_verticalJustify;      
        bool                m_bold;
        bool                m_italic;
        bool                m_underlined;
        bool                m_mirrored;
    } textProperties;
};


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_gal->beginUpdate();
    }

    ~GAL_UPDATE_CONTEXT()
    {
        m_gal->endUpdate();
    }
};


class GAL_DRAWING_CONTEXT : public GAL_CONTEXT_LOCKER
{
public:
    GAL_DRAWING_CONTEXT( GAL* aGal ) :
            GAL_CONTEXT_LOCKER( aGal )
    {
        m_gal->beginDrawing();
    }

    ~GAL_DRAWING_CONTEXT()
    {
        m_gal->endDrawing();
    }
};


};    // namespace KIGFX

#endif /* GRAPHICSABSTRACTIONLAYER_H_ */