cairo_gal.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) 2012-2024 KiCad Developers, see AUTHORS.txt for contributors.
 * Copyright (C) 2017-2018 CERN
 * @author Maciej Suminski <[email protected]>
 *
 * CairoGal - Graphics Abstraction Layer for Cairo
 *
 * 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 CAIROGAL_H_
#define CAIROGAL_H_
 
#include <map>
#include <iterator>
 
#include <cairo.h>
 
#include <gal/gal.h>
#include <gal/graphics_abstraction_layer.h>
#include <wx/dcbuffer.h>
 
#include <memory>
 
namespace KIGFX
{
class CAIRO_COMPOSITOR;
 
class GAL_API CAIRO_GAL_BASE : public GAL
{
public:
 CAIRO_GAL_BASE( GAL_DISPLAY_OPTIONS& aDisplayOptions );
 
 ~CAIRO_GAL_BASE();
 
 bool IsCairoEngine() override { return true; }
 
 // ---------------
 // Drawing methods
 // ---------------
 
 void DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;
 
 void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint,
 double aWidth ) override;
 
 void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) override;
 
 void DrawArc( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle,
 const EDA_ANGLE& aAngle ) override;
 
 void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle,
 const EDA_ANGLE& aAngle, double aWidth, double aMaxError ) override;
 
 void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;
 
 void DrawSegmentChain( const std::vector<VECTOR2D>& aPointList, double aWidth ) override;
 void DrawSegmentChain( const SHAPE_LINE_CHAIN& aLineChain, double aWidth ) override;
 
 void DrawPolyline( const std::deque<VECTOR2D>& aPointList ) override { drawPoly( aPointList ); }
 void DrawPolyline( const VECTOR2D aPointList[], int aListSize ) override
 {
 drawPoly( aPointList, aListSize );
 }
 
 void DrawPolyline( const SHAPE_LINE_CHAIN& aLineChain ) override { drawPoly( aLineChain ); }
 
 void DrawPolylines( const std::vector<std::vector<VECTOR2D>>& aPointLists ) override
 {
 for( const std::vector<VECTOR2D>& points : aPointLists )
 drawPoly( points );
 }
 
 void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) override { drawPoly( aPointList ); }
 void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) override
 {
 drawPoly( aPointList, aListSize );
 }
 
 void DrawPolygon( const SHAPE_POLY_SET& aPolySet, bool aStrokeTriangulation = false ) override;
 void DrawPolygon( const SHAPE_LINE_CHAIN& aPolySet ) override;
 
 void DrawGlyph( const KIFONT::GLYPH& aPolySet, int aNth, int aTotal ) override;
 
 void DrawGlyphs( const std::vector<std::unique_ptr<KIFONT::GLYPH>>& aGlyphs ) override
 {
 for( size_t i = 0; i < aGlyphs.size(); i++ )
 DrawGlyph( *aGlyphs[i], i, aGlyphs.size() );
 }
 
 void DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
 const VECTOR2D& controlPointB, const VECTOR2D& endPoint,
 double aFilterValue = 0.0 ) override;
 
 void DrawBitmap( const BITMAP_BASE& aBitmap, double alphaBlend = 1.0 ) override;
 
 // --------------
 // Screen methods
 // --------------
 
 void ResizeScreen( int aWidth, int aHeight ) override;
 
 void Flush() override;
 
 void ClearScreen() override;
 
 // -----------------
 // Attribute setting
 // -----------------
 
 void SetIsFill( bool aIsFillEnabled ) override;
 
 void SetIsStroke( bool aIsStrokeEnabled ) override;
 
 void SetStrokeColor( const COLOR4D& aColor ) override;
 
 void SetFillColor( const COLOR4D& aColor ) override;
 
 void SetLineWidth( float aLineWidth ) override;
 
 void SetLayerDepth( double aLayerDepth ) override;
 
 // --------------
 // Transformation
 // --------------
 
 void Transform( const MATRIX3x3D& aTransformation ) override;
 
 void Rotate( double aAngle ) override;
 
 void Translate( const VECTOR2D& aTranslation ) override;
 
 void Scale( const VECTOR2D& aScale ) override;
 
 void Save() override;
 
 void Restore() override;
 
 // --------------------------------------------
 // Group methods
 // ---------------------------------------------
 
 int BeginGroup() override;
 
 void EndGroup() override;
 
 void DrawGroup( int aGroupNumber ) override;
 
 void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) override;
 
 void ChangeGroupDepth( int aGroupNumber, int aDepth ) override;
 
 void DeleteGroup( int aGroupNumber ) override;
 
 void ClearCache() override;
 
 // --------------------------------------------------------
 // Handling the world <-> screen transformation
 // --------------------------------------------------------
 
 void SetNegativeDrawMode( bool aSetting ) override;
 
 // -------
 // Cursor
 // -------
 
 void DrawCursor( const VECTOR2D& aCursorPosition ) override;
 
 void EnableDepthTest( bool aEnabled = false ) override;
 
 void DrawGrid() override;
 
 void BeginDrawing() override;
 
 void EndDrawing() override;
 
 
protected:
 // Geometric transforms according to the m_currentWorld2Screen transform matrix:
 double xform( double x ); // scale
 const VECTOR2D xform( double x, double y ); // rotation, scale and offset
 const VECTOR2D xform( const VECTOR2D& aP ); // rotation, scale and offset
 
 // Return the scaling factor for current window.
 virtual double getScalingFactor() { return 1.0; }
 
 double angle_xform( double aAngle );
 
 void arc_angles_xform_and_normalize( double& aStartAngle, double& aEndAngle );
 
 void resetContext();
 
 void drawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
 void drawGridCross( const VECTOR2D& aPoint );
 void drawGridPoint( const VECTOR2D& aPoint, double aWidth, double aHeight );
 void drawAxes( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
 
 
 void flushPath();
 void storePath(); 
 
 void blitCursor( wxMemoryDC& clientDC );
 
 void drawPoly( const std::deque<VECTOR2D>& aPointList );
 void drawPoly( const std::vector<VECTOR2D>& aPointList );
 void drawPoly( const VECTOR2D aPointList[], int aListSize );
 void drawPoly( const SHAPE_LINE_CHAIN& aLineChain );
 
 unsigned int getNewGroupNumber();
 
 void syncLineWidth( bool aForceWidth = false, double aWidth = 0.0 );
 void updateWorldScreenMatrix();
 const VECTOR2D roundp( const VECTOR2D& v );
 
 typedef GAL super;
 
 static const int MAX_CAIRO_ARGUMENTS = 4;
 
 enum GRAPHICS_COMMAND
 {
 CMD_SET_FILL, 
 CMD_SET_STROKE, 
 CMD_SET_FILLCOLOR, 
 CMD_SET_STROKECOLOR, 
 CMD_SET_LINE_WIDTH, 
 CMD_STROKE_PATH, 
 CMD_FILL_PATH, 
 //CMD_TRANSFORM, ///< Transform the actual context
 CMD_ROTATE, 
 CMD_TRANSLATE, 
 CMD_SCALE, 
 CMD_SAVE, 
 CMD_RESTORE, 
 CMD_CALL_GROUP 
 };
 
 struct GROUP_ELEMENT
 {
 GRAPHICS_COMMAND m_Command; 
 union {
 double DblArg[MAX_CAIRO_ARGUMENTS]; 
 bool BoolArg; 
 int IntArg = 0; 
 } m_Argument;
 cairo_path_t* m_CairoPath = nullptr; 
 };
 
 typedef std::deque<GROUP_ELEMENT> GROUP; 
 
 // Variables for the grouping function
 bool m_isGrouping; 
 bool m_isElementAdded; 
 std::map<int, GROUP> m_groups; 
 unsigned int m_groupCounter; 
 GROUP* m_currentGroup; 
 
 double m_lineWidthInPixels;
 bool m_lineWidthIsOdd;
 
 cairo_matrix_t m_cairoWorldScreenMatrix; 
 cairo_matrix_t m_currentXform;
 cairo_matrix_t m_currentWorld2Screen;
 cairo_t* m_currentContext; 
 cairo_t* m_context; 
 cairo_surface_t* m_surface; 
 
 std::vector<cairo_surface_t*> m_imageSurfaces;
 
 std::vector<cairo_matrix_t> m_xformStack;
 static constexpr cairo_format_t GAL_FORMAT = CAIRO_FORMAT_ARGB32;
};
 
 
class GAL_API CAIRO_GAL : public CAIRO_GAL_BASE, public wxWindow
{
public:
 CAIRO_GAL( GAL_DISPLAY_OPTIONS& aDisplayOptions, wxWindow* aParent,
 wxEvtHandler* aMouseListener = nullptr, wxEvtHandler* aPaintListener = nullptr,
 const wxString& aName = wxT( "CairoCanvas" ) );
 
 ~CAIRO_GAL();
 
 bool IsVisible() const override
 {
 return IsShownOnScreen() && !GetClientRect().IsEmpty();
 }
 
 void ResizeScreen( int aWidth, int aHeight ) override;
 
 bool Show( bool aShow ) override;
 
 int BeginGroup() override;
 
 void EndGroup() override;
 
 void SetTarget( RENDER_TARGET aTarget ) override;
 
 RENDER_TARGET GetTarget() const override;
 
 void ClearTarget( RENDER_TARGET aTarget ) override;
 
 void StartDiffLayer() override;
 
 void EndDiffLayer() override;
 
 void StartNegativesLayer() override;
 
 void EndNegativesLayer() override;
 
 void PostPaint( wxPaintEvent& aEvent );
 
 void SetMouseListener( wxEvtHandler* aMouseListener )
 {
 m_mouseListener = aMouseListener;
 }
 
 void SetPaintListener( wxEvtHandler* aPaintListener )
 {
 m_paintListener = aPaintListener;
 }
 
 bool SetNativeCursorStyle( KICURSOR aCursor, bool aHiDPI ) override;
 
 void BeginDrawing() override;
 
 void EndDrawing() override;
 
protected:
 
 void initSurface();
 
 void deinitSurface();
 
 void allocateBitmaps();
 
 void deleteBitmaps();
 
 void setCompositor();
 
 // Event handlers
 void onPaint( wxPaintEvent& aEvent );
 
 void skipMouseEvent( wxMouseEvent& aEvent );
 
 void skipGestureEvent( wxGestureEvent& aEvent );
 
 void onSetNativeCursor( wxSetCursorEvent& aEvent );
 
 bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions ) override;
 
 double getScalingFactor() override;
 
protected:
 // Compositor related variables
 std::shared_ptr<CAIRO_COMPOSITOR> m_compositor; 
 unsigned int m_mainBuffer; 
 unsigned int m_overlayBuffer; 
 unsigned int m_tempBuffer; 
 unsigned int m_savedBuffer; 
 RENDER_TARGET m_currentTarget; 
 bool m_validCompositor; 
 
 // Variables related to wxWidgets
 wxWindow* m_parentWindow; 
 wxEvtHandler* m_mouseListener; 
 wxEvtHandler* m_paintListener; 
 unsigned int m_bufferSize; 
 wxBitmap* m_wxBitmap; 
 
 // Variables related to Cairo <-> wxWidgets
 unsigned char* m_bitmapBuffer; 
 int m_stride; 
 int m_wxBufferWidth;
 bool m_isInitialized; 
 COLOR4D m_backgroundColor; 
 wxCursor m_currentwxCursor; 
};
 
} // namespace KIGFX
 
#endif // CAIROGAL_H_