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-2021 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/graphics_abstraction_layer.h>
#include <wx/dcbuffer.h>

#include <memory>

namespace KIGFX
{
class CAIRO_COMPOSITOR;

class 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,
 double aStartAngle, double aEndAngle ) override;

 void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius,
 double aStartAngle, double aEndAngle, double aWidth,
 double aMaxError ) override;

 void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) 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 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 DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
 const VECTOR2D& controlPointB, const VECTOR2D& endPoint,
 double aFilterValue = 0.0 ) override;

 void DrawBitmap( const BITMAP_BASE& aBitmap ) 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:
 const 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

 const double angle_xform( const 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 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 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 ) override;

 void BeginDrawing() override;

 void EndDrawing() override;

 void initSurface();

 void deinitSurface();

 void allocateBitmaps();

 void deleteBitmaps();

 void setCompositor();

 // Event handlers
 void onPaint( wxPaintEvent& aEvent );

 void skipMouseEvent( wxMouseEvent& aEvent );

 void onSetNativeCursor( wxSetCursorEvent& aEvent );

 bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions ) 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; 
 unsigned char* m_wxOutput; 

 // 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_