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 The 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 DrawHoleWall( const VECTOR2D& aCenterPoint, double aHoleRadius,
                       double aWallWidth ) 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 DrawEllipse( const VECTOR2D& aCenterPoint, double aMajorRadius, double aMinorRadius,
                      const EDA_ANGLE& aRotation ) override;

    void DrawEllipseArc( const VECTOR2D& aCenterPoint, double aMajorRadius, double aMinorRadius,
                         const EDA_ANGLE& aRotation, const EDA_ANGLE& aStartAngle,
                         const EDA_ANGLE& aEndAngle ) 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

    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;

    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;
 
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;     
 
    WX_CURSOR_TYPE      m_currentwxCursor;     
};
 
} // namespace KIGFX
 
#endif  // CAIROGAL_H_