KiCad PCB EDA Suite
Loading...
Searching...
No Matches
cairo_gal.h
Go to the documentation of this file.
1/*
2 * This program source code file is part of KICAD, a free EDA CAD application.
3 *
4 * Copyright (C) 2012 Torsten Hueter, torstenhtr <at> gmx.de
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 * Copyright (C) 2017-2018 CERN
7 * @author Maciej Suminski <[email protected]>
8 *
9 * CairoGal - Graphics Abstraction Layer for Cairo
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version 2
14 * of the License, or (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, you may find one here:
23 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
24 * or you may search the http://www.gnu.org website for the version 2 license,
25 * or you may write to the Free Software Foundation, Inc.,
26 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
27 */
28
29#ifndef CAIROGAL_H_
30#define CAIROGAL_H_
31
32#include <map>
33#include <iterator>
34
35#include <cairo.h>
36
37#include <gal/gal.h>
39#include <wx/dcbuffer.h>
40
41#include <memory>
42
54namespace KIGFX
55{
57
59{
60public:
61 CAIRO_GAL_BASE( GAL_DISPLAY_OPTIONS& aDisplayOptions );
62
64
65 bool IsCairoEngine() override { return true; }
66
67 // ---------------
68 // Drawing methods
69 // ---------------
70
72 void DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;
73
75 void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint,
76 double aWidth ) override;
77
79 void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) override;
80
82 void DrawHoleWall( const VECTOR2D& aCenterPoint, double aHoleRadius,
83 double aWallWidth ) override;
84
86 void DrawArc( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle,
87 const EDA_ANGLE& aAngle ) override;
88
91 void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, const EDA_ANGLE& aStartAngle,
92 const EDA_ANGLE& aAngle, double aWidth, double aMaxError ) override;
93
95 void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;
96
98 void DrawSegmentChain( const std::vector<VECTOR2D>& aPointList, double aWidth ) override;
99 void DrawSegmentChain( const SHAPE_LINE_CHAIN& aLineChain, double aWidth ) override;
100
102 void DrawPolyline( const std::deque<VECTOR2D>& aPointList ) override { drawPoly( aPointList ); }
103 void DrawPolyline( const VECTOR2D aPointList[], int aListSize ) override
104 {
105 drawPoly( aPointList, aListSize );
106 }
107
108 void DrawPolyline( const SHAPE_LINE_CHAIN& aLineChain ) override { drawPoly( aLineChain ); }
109
111 void DrawPolylines( const std::vector<std::vector<VECTOR2D>>& aPointLists ) override
112 {
113 for( const std::vector<VECTOR2D>& points : aPointLists )
114 drawPoly( points );
115 }
116
118 void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) override { drawPoly( aPointList ); }
119 void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) override
120 {
121 drawPoly( aPointList, aListSize );
122 }
123
124 void DrawPolygon( const SHAPE_POLY_SET& aPolySet, bool aStrokeTriangulation = false ) override;
125 void DrawPolygon( const SHAPE_LINE_CHAIN& aPolySet ) override;
126
128 void DrawGlyph( const KIFONT::GLYPH& aPolySet, int aNth, int aTotal ) override;
129
131 void DrawGlyphs( const std::vector<std::unique_ptr<KIFONT::GLYPH>>& aGlyphs ) override
132 {
133 for( size_t i = 0; i < aGlyphs.size(); i++ )
134 DrawGlyph( *aGlyphs[i], i, aGlyphs.size() );
135 }
136
138 void DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
139 const VECTOR2D& controlPointB, const VECTOR2D& endPoint,
140 double aFilterValue = 0.0 ) override;
141
143 void DrawBitmap( const BITMAP_BASE& aBitmap, double alphaBlend = 1.0 ) override;
144
145 // --------------
146 // Screen methods
147 // --------------
148
150 void ResizeScreen( int aWidth, int aHeight ) override;
151
153 void Flush() override;
154
156 void ClearScreen() override;
157
158 // -----------------
159 // Attribute setting
160 // -----------------
161
163 void SetIsFill( bool aIsFillEnabled ) override;
164
166 void SetIsStroke( bool aIsStrokeEnabled ) override;
167
169 void SetStrokeColor( const COLOR4D& aColor ) override;
170
172 void SetFillColor( const COLOR4D& aColor ) override;
173
175 void SetLineWidth( float aLineWidth ) override;
176
178 void SetLayerDepth( double aLayerDepth ) override;
179
180 // --------------
181 // Transformation
182 // --------------
183
185 void Transform( const MATRIX3x3D& aTransformation ) override;
186
188 void Rotate( double aAngle ) override;
189
191 void Translate( const VECTOR2D& aTranslation ) override;
192
194 void Scale( const VECTOR2D& aScale ) override;
195
197 void Save() override;
198
200 void Restore() override;
201
202 // --------------------------------------------
203 // Group methods
204 // ---------------------------------------------
205
207 int BeginGroup() override;
208
210 void EndGroup() override;
211
213 void DrawGroup( int aGroupNumber ) override;
214
216 void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) override;
217
219 void ChangeGroupDepth( int aGroupNumber, int aDepth ) override;
220
222 void DeleteGroup( int aGroupNumber ) override;
223
225 void ClearCache() override;
226
227 // --------------------------------------------------------
228 // Handling the world <-> screen transformation
229 // --------------------------------------------------------
230
232 void SetNegativeDrawMode( bool aSetting ) override;
233
234 // -------
235 // Cursor
236 // -------
237
239 void DrawCursor( const VECTOR2D& aCursorPosition ) override;
240
241 void EnableDepthTest( bool aEnabled = false ) override;
242
244 void DrawGrid() override;
245
247 void BeginDrawing() override;
248
250 void EndDrawing() override;
251
252
253protected:
254 // Geometric transforms according to the m_currentWorld2Screen transform matrix:
255 double xform( double x ); // scale
256 const VECTOR2D xform( double x, double y ); // rotation, scale and offset
257 const VECTOR2D xform( const VECTOR2D& aP ); // rotation, scale and offset
258
265 double angle_xform( double aAngle );
266
274 void arc_angles_xform_and_normalize( double& aStartAngle, double& aEndAngle );
275
276 void resetContext();
277
284 void drawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
285 void drawGridCross( const VECTOR2D& aPoint );
286 void drawGridPoint( const VECTOR2D& aPoint, double aWidth, double aHeight );
287 void drawAxes( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
288
289
290 void flushPath();
291 void storePath();
292
296 void blitCursor( wxMemoryDC& clientDC );
297
299 void drawPoly( const std::deque<VECTOR2D>& aPointList );
300 void drawPoly( const std::vector<VECTOR2D>& aPointList );
301 void drawPoly( const VECTOR2D aPointList[], int aListSize );
302 void drawPoly( const SHAPE_LINE_CHAIN& aLineChain );
303
309 unsigned int getNewGroupNumber();
310
311 void syncLineWidth( bool aForceWidth = false, double aWidth = 0.0 );
312 void updateWorldScreenMatrix();
313 const VECTOR2D roundp( const VECTOR2D& v );
314
316 typedef GAL super;
317
319 static const int MAX_CAIRO_ARGUMENTS = 4;
320
339
342 {
344 union {
346 bool BoolArg;
347 int IntArg = 0;
348 } m_Argument;
349 cairo_path_t* m_CairoPath = nullptr;
350 };
351
352 typedef std::deque<GROUP_ELEMENT> GROUP;
353
354 // Variables for the grouping function
357 std::map<int, GROUP> m_groups;
358 unsigned int m_groupCounter;
360
363
365 cairo_matrix_t m_currentXform;
366 cairo_matrix_t m_currentWorld2Screen;
368 cairo_t* m_context;
369 cairo_surface_t* m_surface;
370
372 std::vector<cairo_surface_t*> m_imageSurfaces;
373
374 std::vector<cairo_matrix_t> m_xformStack;
376 static constexpr cairo_format_t GAL_FORMAT = CAIRO_FORMAT_ARGB32;
377};
378
379
380class GAL_API CAIRO_GAL : public CAIRO_GAL_BASE, public wxWindow
381{
382public:
394 CAIRO_GAL( GAL_DISPLAY_OPTIONS& aDisplayOptions, wxWindow* aParent,
395 wxEvtHandler* aMouseListener = nullptr, wxEvtHandler* aPaintListener = nullptr,
396 const wxString& aName = wxT( "CairoCanvas" ) );
397
398 ~CAIRO_GAL();
399
401 bool IsVisible() const override
402 {
403 return IsShownOnScreen() && !GetClientRect().IsEmpty();
404 }
405
406 void ResizeScreen( int aWidth, int aHeight ) override;
407
408 bool Show( bool aShow ) override;
409
410 int BeginGroup() override;
411
412 void EndGroup() override;
413
414 void SetTarget( RENDER_TARGET aTarget ) override;
415
416 RENDER_TARGET GetTarget() const override;
417
418 void ClearTarget( RENDER_TARGET aTarget ) override;
419
421 void StartDiffLayer() override;
422
424 void EndDiffLayer() override;
425
427 void StartNegativesLayer() override;
428
430 void EndNegativesLayer() override;
431
438 void PostPaint( wxPaintEvent& aEvent );
439
440 void SetMouseListener( wxEvtHandler* aMouseListener )
441 {
442 m_mouseListener = aMouseListener;
443 }
444
445 void SetPaintListener( wxEvtHandler* aPaintListener )
446 {
447 m_paintListener = aPaintListener;
448 }
449
451 bool SetNativeCursorStyle( KICURSOR aCursor, bool aHiDPI ) override;
452
454 void BeginDrawing() override;
455
457 void EndDrawing() override;
458
460 void initSurface();
461
463 void deinitSurface();
464
466 void allocateBitmaps();
467
469 void deleteBitmaps();
470
472 void setCompositor();
473
474 // Event handlers
480 void onPaint( wxPaintEvent& aEvent );
481
487 void skipMouseEvent( wxMouseEvent& aEvent );
488
494 void skipGestureEvent( wxGestureEvent& aEvent );
495
501 void onSetNativeCursor( wxSetCursorEvent& aEvent );
502
504 bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions ) override;
505
506protected:
507 // Compositor related variables
508 std::shared_ptr<CAIRO_COMPOSITOR> m_compositor;
509 unsigned int m_mainBuffer;
510 unsigned int m_overlayBuffer;
511 unsigned int m_tempBuffer;
512 unsigned int m_savedBuffer;
515
516 // Variables related to wxWidgets
517 wxWindow* m_parentWindow;
518 wxEvtHandler* m_mouseListener;
519 wxEvtHandler* m_paintListener;
520 unsigned int m_bufferSize;
521 unsigned char* m_wxOutput;
522
523 // Variables related to Cairo <-> wxWidgets
524 unsigned char* m_bitmapBuffer;
529
531};
532
533} // namespace KIGFX
534
535#endif // CAIROGAL_H_
static double roundp(double x)
This class handle bitmap images in KiCad.
Definition bitmap_base.h:49
void DrawGlyph(const KIFONT::GLYPH &aPolySet, int aNth, int aTotal) override
Draw a polygon representing a font glyph.
cairo_surface_t * m_surface
Cairo surface.
Definition cairo_gal.h:369
void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition cairo_gal.h:102
GAL super
Super class definition.
Definition cairo_gal.h:316
cairo_matrix_t m_cairoWorldScreenMatrix
Cairo world to screen transform matrix.
Definition cairo_gal.h:364
unsigned int m_groupCounter
Counter used for generating group keys.
Definition cairo_gal.h:358
bool m_isElementAdded
Was an graphic element added ?
Definition cairo_gal.h:356
std::deque< GROUP_ELEMENT > GROUP
A graphic group type definition.
Definition cairo_gal.h:352
bool IsCairoEngine() override
Return true if the GAL engine is a Cairo based type.
Definition cairo_gal.h:65
void DrawGlyphs(const std::vector< std::unique_ptr< KIFONT::GLYPH > > &aGlyphs) override
Draw polygons representing font glyphs.
Definition cairo_gal.h:131
CAIRO_GAL_BASE(GAL_DISPLAY_OPTIONS &aDisplayOptions)
Definition cairo_gal.cpp:51
std::vector< cairo_surface_t * > m_imageSurfaces
List of surfaces that were created by painting images, to be cleaned up later.
Definition cairo_gal.h:372
GROUP * m_currentGroup
Currently used group.
Definition cairo_gal.h:359
bool m_isGrouping
Is grouping enabled ?
Definition cairo_gal.h:355
static constexpr cairo_format_t GAL_FORMAT
Format used to store pixels.
Definition cairo_gal.h:376
cairo_matrix_t m_currentXform
Definition cairo_gal.h:365
static const int MAX_CAIRO_ARGUMENTS
Maximum number of arguments for one command.
Definition cairo_gal.h:319
void drawPoly(const std::deque< VECTOR2D > &aPointList)
Drawing polygons & polylines is the same in Cairo, so here is the common code.
void DrawPolygon(const VECTOR2D aPointList[], int aListSize) override
Definition cairo_gal.h:119
std::map< int, GROUP > m_groups
List of graphic groups.
Definition cairo_gal.h:357
cairo_t * m_context
Cairo image.
Definition cairo_gal.h:368
void DrawPolylines(const std::vector< std::vector< VECTOR2D > > &aPointLists) override
Draw multiple polylines.
Definition cairo_gal.h:111
void DrawPolyline(const SHAPE_LINE_CHAIN &aLineChain) override
Definition cairo_gal.h:108
std::vector< cairo_matrix_t > m_xformStack
Definition cairo_gal.h:374
void DrawPolyline(const VECTOR2D aPointList[], int aListSize) override
Definition cairo_gal.h:103
void DrawPolygon(const std::deque< VECTOR2D > &aPointList) override
Draw a polygon.
Definition cairo_gal.h:118
cairo_matrix_t m_currentWorld2Screen
Definition cairo_gal.h:366
cairo_t * m_currentContext
Currently used Cairo context for drawing.
Definition cairo_gal.h:367
GRAPHICS_COMMAND
Definitions for the command recorder.
Definition cairo_gal.h:323
@ CMD_SET_STROKE
Enable/disable stroking.
Definition cairo_gal.h:325
@ CMD_SAVE
Save the transformation matrix.
Definition cairo_gal.h:335
@ CMD_SCALE
Scale the context.
Definition cairo_gal.h:334
@ CMD_SET_LINE_WIDTH
Set the line width.
Definition cairo_gal.h:328
@ CMD_SET_FILL
Enable/disable filling.
Definition cairo_gal.h:324
@ CMD_CALL_GROUP
Call a group.
Definition cairo_gal.h:337
@ CMD_ROTATE
Rotate the context.
Definition cairo_gal.h:332
@ CMD_STROKE_PATH
Set the stroke path.
Definition cairo_gal.h:329
@ CMD_TRANSLATE
Translate the context.
Definition cairo_gal.h:333
@ CMD_SET_FILLCOLOR
Set the fill color.
Definition cairo_gal.h:326
@ CMD_FILL_PATH
Set the fill path.
Definition cairo_gal.h:330
@ CMD_RESTORE
Restore the transformation matrix.
Definition cairo_gal.h:336
@ CMD_SET_STROKECOLOR
Set the stroke color.
Definition cairo_gal.h:327
unsigned int m_overlayBuffer
Handle to the overlay buffer.
Definition cairo_gal.h:510
unsigned int m_bufferSize
Size of buffers cairoOutput, bitmapBuffers.
Definition cairo_gal.h:520
CAIRO_GAL(GAL_DISPLAY_OPTIONS &aDisplayOptions, wxWindow *aParent, wxEvtHandler *aMouseListener=nullptr, wxEvtHandler *aPaintListener=nullptr, const wxString &aName=wxT("CairoCanvas"))
void SetPaintListener(wxEvtHandler *aPaintListener)
Definition cairo_gal.h:445
void SetMouseListener(wxEvtHandler *aMouseListener)
Definition cairo_gal.h:440
unsigned char * m_wxOutput
wxImage compatible buffer
Definition cairo_gal.h:521
bool m_isInitialized
Are Cairo image & surface ready to use.
Definition cairo_gal.h:527
bool m_validCompositor
Compositor initialization flag.
Definition cairo_gal.h:514
unsigned int m_mainBuffer
Handle to the main buffer.
Definition cairo_gal.h:509
int m_stride
Stride value for Cairo.
Definition cairo_gal.h:525
COLOR4D m_backgroundColor
Background color.
Definition cairo_gal.h:528
unsigned char * m_bitmapBuffer
Storage of the Cairo image.
Definition cairo_gal.h:524
wxEvtHandler * m_mouseListener
Mouse listener.
Definition cairo_gal.h:518
wxEvtHandler * m_paintListener
Paint listener.
Definition cairo_gal.h:519
bool IsVisible() const override
Return true if the GAL canvas is visible on the screen.
Definition cairo_gal.h:401
unsigned int m_tempBuffer
Handle to the temp buffer.
Definition cairo_gal.h:511
RENDER_TARGET m_currentTarget
Current rendering target.
Definition cairo_gal.h:513
wxWindow * m_parentWindow
Parent window.
Definition cairo_gal.h:517
std::shared_ptr< CAIRO_COMPOSITOR > m_compositor
Object for layers compositing.
Definition cairo_gal.h:508
WX_CURSOR_TYPE m_currentwxCursor
wx cursor showing the current native cursor
Definition cairo_gal.h:530
unsigned int m_savedBuffer
Handle to buffer to restore after rendering to temp buffer.
Definition cairo_gal.h:512
A color representation with 4 components: red, green, blue, alpha.
Definition color4d.h:104
GAL(GAL_DISPLAY_OPTIONS &aOptions)
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
Represent a set of closed polygons.
KICURSOR
Definition cursors.h:44
wxCursor WX_CURSOR_TYPE
Represents either a wxCursorBundle for wx 3.3+ or a wxCursor for older versions.
Definition cursors.h:39
#define GAL_API
Definition gal.h:28
MATRIX3x3< double > MATRIX3x3D
Definition matrix3x3.h:473
The Cairo implementation of the graphics abstraction layer.
Definition eda_group.h:33
RENDER_TARGET
RENDER_TARGET: Possible rendering targets.
Definition definitions.h:36
void DrawSegment(const ROUND_SEGMENT_2D &aSegment, unsigned int aNrSidesPerCircle)
Draw a thick line segment with rounded ends.
Type definition for an graphics group element.
Definition cairo_gal.h:342
GRAPHICS_COMMAND m_Command
Command to execute.
Definition cairo_gal.h:343
cairo_path_t * m_CairoPath
Pointer to a Cairo path.
Definition cairo_gal.h:349
double DblArg[MAX_CAIRO_ARGUMENTS]
Arguments for Cairo commands.
Definition cairo_gal.h:345
VECTOR2< double > VECTOR2D
Definition vector2d.h:694