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-2021 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/cursors.h>
#include <gal/definitions.h>
#include <gal/gal_display_options.h>
#include <newstroke_font.h>
#include <font/stroke_font.h>
#include <geometry/eda_angle.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 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 DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
 const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle ) {};
 
 virtual void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius,
 const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle,
 double aWidth, double aMaxError ) {};
 
 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 )
 {
 for( size_t i = 0; i < aGlyphs.size(); i++ )
 DrawGlyph( *aGlyphs[i], i, aGlyphs.size() );
 }
 
 
 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 int GetSwapInterval() const { return 0; };
 
 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 )
 {
 m_isFillEnabled = aIsFillEnabled;
 }
 
 virtual void SetIsStroke( bool aIsStrokeEnabled )
 {
 m_isStrokeEnabled = aIsStrokeEnabled;
 }
 
 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;
 }
 
 inline const COLOR4D& GetStrokeColor() const
 {
 return m_strokeColor;
 }
 
 virtual void SetLineWidth( float aLineWidth )
 {
 m_lineWidth = aLineWidth;
 }
 
 inline float GetLineWidth() const
 {
 return m_lineWidth;
 }
 
 virtual void SetLayerDepth( double aLayerDepth )
 {
 assert( aLayerDepth <= m_depthRange.y );
 assert( aLayerDepth >= m_depthRange.x );
 
 m_layerDepth = aLayerDepth;
 }
 
 // ----
 // 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 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 m_worldScreenMatrix;
 }
 
 const MATRIX3x3D& GetScreenWorldMatrix() const
 {
 return m_screenWorldMatrix;
 }
 
 inline void SetWorldScreenMatrix( const MATRIX3x3D& aMatrix )
 {
 m_worldScreenMatrix = aMatrix;
 }
 
 BOX2D GetVisibleWorldExtents() const;
 
 void SetWorldUnitLength( double aWorldUnitLength ) { m_worldUnitLength = aWorldUnitLength; }
 
 void SetScreenSize( const VECTOR2I& aSize ) { m_screenSize = aSize; }
 
 void SetScreenDPI( double aScreenDPI ) { m_screenDPI = aScreenDPI; }
 
 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 { return m_worldScale; }
 
 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 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 );
 
 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
 while( std::min( gridScreenSize.x, gridScreenSize.y ) <= gridThreshold )
 {
 gridScreenSize = gridScreenSize * static_cast<double>( m_gridTick );
 }
 
 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;
 }
 
 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 );
 
 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 ) {};
 
 inline void AdvanceDepth()
 {
 m_layerDepth -= 0.05;
 }
 
 inline void PushDepth()
 {
 m_depthStack.push( m_layerDepth );
 }
 
 inline void PopDepth()
 {
 m_layerDepth = m_depthStack.top();
 m_depthStack.pop();
 }
 
 virtual void EnableDepthTest( bool aEnabled = false ) {};
 
 virtual bool IsContextLocked()
 {
 return false;
 }
 
 
 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;
 }
 
 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& 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; 
 
 bool m_globalFlipX; 
 bool m_globalFlipY; 
 
 float m_lineWidth; 
 
 bool m_isFillEnabled; 
 bool m_isStrokeEnabled; 
 
 COLOR4D m_fillColor; 
 COLOR4D m_strokeColor; 
 COLOR4D m_clearColor;
 
 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; 
 
 // Cursor settings
 bool m_isCursorEnabled; 
 bool m_forceDisplayCursor; 
 COLOR4D m_cursorColor; 
 bool m_fullscreenCursor; 
 VECTOR2D m_cursorPosition; 
 
 KICURSOR m_currentNativeCursor; 
 
private:
 TEXT_ATTRIBUTES m_attributes;
};
 
 
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() noexcept( false )
 {
 m_gal->EndDrawing();
 }
};
 
 
}; // namespace KIGFX
 
#endif /* GRAPHICSABSTRACTIONLAYER_H_ */