KiCad PCB EDA Suite
Loading...
Searching...
No Matches
graphics_abstraction_layer.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 *
7 * Graphics Abstraction Layer (GAL) - base class
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, you may find one here:
21 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
22 * or you may search the http://www.gnu.org website for the version 2 license,
23 * or you may write to the Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
25 */
26
27#ifndef GRAPHICSABSTRACTIONLAYER_H_
28#define GRAPHICSABSTRACTIONLAYER_H_
29
30#include <deque>
31#include <stack>
32#include <limits>
33
34#include <math/matrix3x3.h>
35
36#include <gal/gal.h>
37#include <gal/color4d.h>
38#include <gal/cursors.h>
39#include <gal/definitions.h>
41#include <font/stroke_font.h>
42#include <geometry/eda_angle.h>
43
45class SHAPE_POLY_SET;
46class BITMAP_BASE;
47
48namespace KIGFX
49{
61{
62 // These friend declarations allow us to hide routines that should not be called. The
63 // corresponding RAII objects must be used instead.
64 friend class GAL_CONTEXT_LOCKER;
65 friend class GAL_UPDATE_CONTEXT;
66 friend class GAL_DRAWING_CONTEXT;
67
68public:
69 // Constructor / Destructor
70 GAL( GAL_DISPLAY_OPTIONS& aOptions );
71 virtual ~GAL();
72
74 virtual bool IsInitialized() const { return true; }
75
77 virtual bool IsVisible() const { return true; }
78
80 virtual bool IsCairoEngine() { return false; }
81
83 virtual bool IsOpenGlEngine() { return false; }
84
85 // ---------------
86 // Drawing methods
87 // ---------------
88
97 virtual void DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
98
108 virtual void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint,
109 double aWidth ){};
110
117 virtual void DrawSegmentChain( const std::vector<VECTOR2D>& aPointList, double aWidth ){};
118 virtual void DrawSegmentChain( const SHAPE_LINE_CHAIN& aLineChain, double aWidth ){};
119
125 virtual void DrawPolyline( const std::deque<VECTOR2D>& aPointList ) {};
126 virtual void DrawPolyline( const std::vector<VECTOR2D>& aPointList ) {};
127 virtual void DrawPolyline( const VECTOR2D aPointList[], int aListSize ) {};
128 virtual void DrawPolyline( const SHAPE_LINE_CHAIN& aLineChain ) {};
129
135 virtual void DrawPolylines( const std::vector<std::vector<VECTOR2D>>& aPointLists ){};
136
143 virtual void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) {};
144
153 virtual void DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
154 const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle ){};
155
176 virtual void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius,
177 const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle,
178 double aWidth, double aMaxError ){};
179
186 virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
187
188 void DrawRectangle( const BOX2I& aRect )
189 {
190 DrawRectangle( aRect.GetOrigin(), aRect.GetEnd() );
191 }
192
196 virtual void DrawGlyph( const KIFONT::GLYPH& aGlyph, int aNth = 0, int aTotal = 1 ) {};
197
201 virtual void DrawGlyphs( const std::vector<std::unique_ptr<KIFONT::GLYPH>>& aGlyphs )
202 {
203 for( size_t i = 0; i < aGlyphs.size(); i++ )
204 DrawGlyph( *aGlyphs[i], i, aGlyphs.size() );
205 }
206
207
213 virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) {};
214 virtual void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) {};
215 virtual void DrawPolygon( const SHAPE_POLY_SET& aPolySet,
216 bool aStrokeTriangulation = false ) {};
217 virtual void DrawPolygon( const SHAPE_LINE_CHAIN& aPolySet ) {};
218
230 virtual void DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
231 const VECTOR2D& controlPointB, const VECTOR2D& endPoint,
232 double aFilterValue = 0.0 ) {};
233
237 virtual void DrawBitmap( const BITMAP_BASE& aBitmap, double alphaBlend = 1.0 ) {};
238
239 // --------------
240 // Screen methods
241 // --------------
242
244 virtual void ResizeScreen( int aWidth, int aHeight ) {};
245
247 virtual bool Show( bool aShow ) { return true; };
248
251 {
252 return m_screenSize;
253 }
254
256 virtual int GetSwapInterval() const { return 0; };
257
259 virtual void Flush() {};
260
261 void SetClearColor( const COLOR4D& aColor )
262 {
263 m_clearColor = aColor;
264 }
265
266 const COLOR4D& GetClearColor( ) const
267 {
268 return m_clearColor;
269 }
270
276 virtual void ClearScreen() {};
277
278 // -----------------
279 // Attribute setting
280 // -----------------
281
287 virtual void SetIsFill( bool aIsFillEnabled )
288 {
289 m_isFillEnabled = aIsFillEnabled;
290 }
291
297 inline bool GetIsFill() const
298 {
299 return m_isFillEnabled;
300 }
301
307 virtual void SetIsStroke( bool aIsStrokeEnabled )
308 {
309 m_isStrokeEnabled = aIsStrokeEnabled;
310 }
311
317 inline bool GetIsStroke() const
318 {
319 return m_isStrokeEnabled;
320 }
321
327 virtual void SetFillColor( const COLOR4D& aColor )
328 {
329 m_fillColor = aColor;
330 }
331
337 inline const COLOR4D& GetFillColor() const
338 {
339 return m_fillColor;
340 }
341
347 virtual void SetStrokeColor( const COLOR4D& aColor )
348 {
349 m_strokeColor = aColor;
350 }
351
357 inline const COLOR4D& GetStrokeColor() const
358 {
359 return m_strokeColor;
360 }
361
367 virtual void SetLineWidth( float aLineWidth )
368 {
369 m_lineWidth = aLineWidth;
370 }
371
377 inline float GetLineWidth() const
378 {
379 return m_lineWidth;
380 }
381
390 virtual void SetLayerDepth( double aLayerDepth )
391 {
392 wxCHECK_MSG( aLayerDepth <= m_depthRange.y, /*void*/,
393 wxT( "SetLayerDepth: below minimum" ) );
394 wxCHECK_MSG( aLayerDepth >= m_depthRange.x, /*void*/,
395 wxT( "SetLayerDepth: above maximum" ) );
396
397 m_layerDepth = aLayerDepth;
398 }
399
407 inline void AdvanceDepth()
408 {
409 SetLayerDepth( m_layerDepth - 0.1 );
410 }
411
412 // ----
413 // Text
414 // ----
415
424 virtual void BitmapText( const wxString& aText, const VECTOR2I& aPosition,
425 const EDA_ANGLE& aAngle );
426
433 void ResetTextAttributes();
434
435 void SetGlyphSize( const VECTOR2I aSize ) { m_attributes.m_Size = aSize; }
436 const VECTOR2I& GetGlyphSize() const { return m_attributes.m_Size; }
437
438 inline void SetFontBold( const bool aBold ) { m_attributes.m_Bold = aBold; }
439 inline bool IsFontBold() const { return m_attributes.m_Bold; }
440
441 inline void SetFontItalic( bool aItalic ) { m_attributes.m_Italic = aItalic; }
442 inline bool IsFontItalic() const { return m_attributes.m_Italic; }
443
444 inline void SetFontUnderlined( bool aUnderlined ) { m_attributes.m_Underlined = aUnderlined; }
445 inline bool IsFontUnderlined() const { return m_attributes.m_Underlined; }
446
447 void SetTextMirrored( const bool aMirrored ) { m_attributes.m_Mirrored = aMirrored; }
448 bool IsTextMirrored() const { return m_attributes.m_Mirrored; }
449
450 void SetHorizontalJustify( const GR_TEXT_H_ALIGN_T aHorizontalJustify )
451 {
452 m_attributes.m_Halign = aHorizontalJustify;
453 }
454
455 GR_TEXT_H_ALIGN_T GetHorizontalJustify() const { return m_attributes.m_Halign; }
456
457 void SetVerticalJustify( const GR_TEXT_V_ALIGN_T aVerticalJustify )
458 {
459 m_attributes.m_Valign = aVerticalJustify;
460 }
461
462 GR_TEXT_V_ALIGN_T GetVerticalJustify() const { return m_attributes.m_Valign; }
463
464
465 // --------------
466 // Transformation
467 // --------------
468
474 virtual void Transform( const MATRIX3x3D& aTransformation ) {};
475
481 virtual void Rotate( double aAngle ) {};
482
488 virtual void Translate( const VECTOR2D& aTranslation ) {};
489
495 virtual void Scale( const VECTOR2D& aScale ) {};
496
498 virtual void Save() {};
499
501 virtual void Restore() {};
502
503 // --------------------------------------------
504 // Group methods
505 // ---------------------------------------------
506
515 virtual int BeginGroup() { return 0; };
516
518 virtual void EndGroup() {};
519
525 virtual void DrawGroup( int aGroupNumber ) {};
526
533 virtual void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) {};
534
541 virtual void ChangeGroupDepth( int aGroupNumber, int aDepth ) {};
542
548 virtual void DeleteGroup( int aGroupNumber ) {};
549
553 virtual void ClearCache() {};
554
555 // --------------------------------------------------------
556 // Handling the world <-> screen transformation
557 // --------------------------------------------------------
558
560 virtual void ComputeWorldScreenMatrix();
561
568 {
569 return m_worldScreenMatrix;
570 }
571
578 {
579 return m_screenWorldMatrix;
580 }
581
587 inline void SetWorldScreenMatrix( const MATRIX3x3D& aMatrix )
588 {
589 m_worldScreenMatrix = aMatrix;
590 }
591
595 BOX2D GetVisibleWorldExtents() const;
596
604 void SetWorldUnitLength( double aWorldUnitLength ) { m_worldUnitLength = aWorldUnitLength; }
605
606 void SetScreenSize( const VECTOR2I& aSize ) { m_screenSize = aSize; }
607
614 void SetScreenDPI( double aScreenDPI ) { m_screenDPI = aScreenDPI; }
615
621 void SetLookAtPoint( const VECTOR2D& aPoint ) { m_lookAtPoint = aPoint; }
622 const VECTOR2D& GetLookAtPoint() const { return m_lookAtPoint; }
623
624 void SetZoomFactor( double aZoomFactor ) { m_zoomFactor = aZoomFactor; }
625 double GetZoomFactor() const { return m_zoomFactor; }
626
630 void SetRotation( double aRotation ) { m_rotation = aRotation; }
631 double GetRotation() const { return m_rotation; }
632
641 void SetDepthRange( const VECTOR2D& aDepthRange ) { m_depthRange = aDepthRange; }
642 double GetMinDepth() const { return m_depthRange.x; }
643 double GetMaxDepth() const { return m_depthRange.y; }
644
650 double GetWorldScale() const { return m_worldScale; }
651
658 inline void SetFlip( bool xAxis, bool yAxis )
659 {
660 m_globalFlipX = xAxis;
661 m_globalFlipY = yAxis;
662 }
663
664 bool IsFlippedX() const { return m_globalFlipX; }
665 bool IsFlippedY() const { return m_globalFlipY; }
666
667 // ---------------------------
668 // Buffer manipulation methods
669 // ---------------------------
670
676 virtual void SetTarget( RENDER_TARGET aTarget ) {};
677
683 virtual RENDER_TARGET GetTarget() const { return TARGET_CACHED; };
684
690 virtual void ClearTarget( RENDER_TARGET aTarget ) {};
691
697 virtual bool HasTarget( RENDER_TARGET aTarget )
698 {
699 return true;
700 };
701
713 virtual void SetNegativeDrawMode( bool aSetting ) {};
714
722 virtual void StartDiffLayer() {};
723
729 virtual void EndDiffLayer() {};
730
739 virtual void StartNegativesLayer(){};
740
745 virtual void EndNegativesLayer(){};
746
747 // -------------
748 // Grid methods
749 // -------------
750
756 void SetGridVisibility( bool aVisibility ) { m_gridVisibility = aVisibility; }
757
758 bool GetGridVisibility() const { return m_gridVisibility; }
759
760 bool GetGridSnapping() const
761 {
762 return m_options.m_gridSnapping == KIGFX::GRID_SNAPPING::ALWAYS ||
763 ( m_gridVisibility && m_options.m_gridSnapping == KIGFX::GRID_SNAPPING::WITH_GRID );
764 }
765
771 inline void SetGridOrigin( const VECTOR2D& aGridOrigin )
772 {
773 m_gridOrigin = aGridOrigin;
774
775 if( m_gridSize.x == 0.0 || m_gridSize.y == 0.0 )
776 {
777 m_gridOffset = VECTOR2D( 0.0, 0.0);
778 }
779 else
780 {
781 m_gridOffset = VECTOR2D( (long) m_gridOrigin.x % (long) m_gridSize.x,
782 (long) m_gridOrigin.y % (long) m_gridSize.y );
783 }
784 }
785
786 inline const VECTOR2D& GetGridOrigin() const
787 {
788 return m_gridOrigin;
789 }
790
796 inline void SetGridSize( const VECTOR2D& aGridSize )
797 {
798 m_gridSize = aGridSize;
799
800 // Avoid stupid grid size values: a grid size should be >= 1 in internal units
801 m_gridSize.x = std::max( 1.0, m_gridSize.x );
802 m_gridSize.y = std::max( 1.0, m_gridSize.y );
803
804 m_gridOffset = VECTOR2D( (long) m_gridOrigin.x % (long) m_gridSize.x,
805 (long) m_gridOrigin.y % (long) m_gridSize.y );
806 }
807
813 inline const VECTOR2D& GetGridSize() const
814 {
815 return m_gridSize;
816 }
817
824 {
825 VECTOR2D gridScreenSize( m_gridSize );
826 gridScreenSize.x = std::max( 100.0, gridScreenSize.x );
827 gridScreenSize.y = std::max( 100.0, gridScreenSize.y );
828
829 double gridThreshold = computeMinGridSpacing() / m_worldScale;
830
831 if( m_gridStyle == GRID_STYLE::SMALL_CROSS )
832 gridThreshold *= 2.0;
833
834 // If we cannot display the grid density, scale down by a tick size and
835 // try again. Eventually, we get some representation of the grid
836 while( std::min( gridScreenSize.x, gridScreenSize.y ) <= gridThreshold )
837 {
838 gridScreenSize = gridScreenSize * static_cast<double>( m_gridTick );
839 }
840
841 return gridScreenSize;
842 }
843
849 inline void SetGridColor( const COLOR4D& aGridColor )
850 {
851 m_gridColor = aGridColor;
852 }
853
859 inline void SetAxesColor( const COLOR4D& aAxesColor )
860 {
861 m_axesColor = aAxesColor;
862 }
863
867 inline void SetAxesEnabled( bool aAxesEnabled )
868 {
869 m_axesEnabled = aAxesEnabled;
870 }
871
877 inline void SetCoarseGrid( int aInterval )
878 {
879 m_gridTick = aInterval;
880 }
881
887 inline float GetGridLineWidth() const
888 {
889 return m_gridLineWidth;
890 }
891
893 virtual void DrawGrid() {};
894
901 VECTOR2D GetGridPoint( const VECTOR2D& aPoint ) const;
902
909 inline VECTOR2D ToWorld( const VECTOR2D& aPoint ) const
910 {
911 return VECTOR2D( m_screenWorldMatrix * aPoint );
912 }
913
920 inline VECTOR2D ToScreen( const VECTOR2D& aPoint ) const
921 {
922 return VECTOR2D( m_worldScreenMatrix * aPoint );
923 }
924
931 virtual bool SetNativeCursorStyle( KICURSOR aCursor, bool aHiDPI );
932
938 inline void SetCursorEnabled( bool aCursorEnabled )
939 {
940 m_isCursorEnabled = aCursorEnabled;
941 }
942
948 bool IsCursorEnabled() const
949 {
950 return m_isCursorEnabled || m_forceDisplayCursor;
951 }
952
958 inline void SetCursorColor( const COLOR4D& aCursorColor )
959 {
960 m_cursorColor = aCursorColor;
961 }
962
968 virtual void DrawCursor( const VECTOR2D& aCursorPosition ) {};
969
970 virtual void EnableDepthTest( bool aEnabled = false ) {};
971
976 virtual bool IsContextLocked()
977 {
978 return false;
979 }
980
981
983 virtual void LockContext( int aClientCookie ) {}
984
985 virtual void UnlockContext( int aClientCookie ) {}
986
991
994 virtual void BeginDrawing() {};
995
998 virtual void EndDrawing() {};
999protected:
1000
1003 virtual void beginUpdate() {}
1004
1006 virtual void endUpdate() {}
1007
1008
1009
1011 inline void computeWorldScale()
1012 {
1013 m_worldScale = m_screenDPI * m_worldUnitLength * m_zoomFactor;
1014 }
1015
1021 double computeMinGridSpacing() const;
1022
1024 static const int MIN_DEPTH;
1025 static const int MAX_DEPTH;
1026
1028 static const int GRID_DEPTH;
1029
1033 COLOR4D getCursorColor() const;
1034
1035 // ---------------
1036 // Settings observer interface
1037 // ---------------
1041 void OnGalDisplayOptionsChanged( const GAL_DISPLAY_OPTIONS& aOptions ) override;
1042
1051 virtual bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions );
1052
1056 template <typename T>
1057 void normalize( T &a, T &b )
1058 {
1059 if( a > b )
1060 {
1061 T tmp = a;
1062 a = b;
1063 b = tmp;
1064 }
1065 }
1066
1069
1070 std::stack<double> m_depthStack;
1072
1076
1078 double m_rotation;
1082
1085
1087
1090
1094
1097
1098 // Grid settings
1111
1112 // Cursor settings
1118
1120
1121private:
1122
1123 inline double getLayerDepth() const
1124 {
1125 return m_layerDepth;
1126 }
1127
1129
1130 friend class GAL_SCOPED_ATTRS;
1131};
1132
1133
1135{
1136public:
1138 m_gal( aGal )
1139 {
1140 m_cookie = rand();
1142 }
1143
1145 {
1147 }
1148
1149protected:
1152};
1153
1154
1156{
1157public:
1159 GAL_CONTEXT_LOCKER( aGal )
1160 {
1161 m_gal->beginUpdate();
1162 }
1163
1165 {
1166 m_gal->endUpdate();
1167 }
1168};
1169
1170
1172{
1173public:
1175 GAL_CONTEXT_LOCKER( aGal )
1176 {
1178 }
1179
1180 ~GAL_DRAWING_CONTEXT() noexcept( false )
1181 {
1182 m_gal->EndDrawing();
1183 }
1184};
1185
1186
1191{
1192public:
1194 {
1201
1202 // It is not clear to me that GAL needs to save text attributes.
1203 // Only BitmapText uses it, and maybe that should be passed in
1204 // explicitly (like for Draw) - every caller of BitmapText sets
1205 // the text attributes anyway.
1206 // TEXT_ATTRS = 64,
1207
1208 // Convenience flags
1212
1214 };
1215
1221 GAL_SCOPED_ATTRS( KIGFX::GAL& aGal, int aFlags )
1222 : m_gal( aGal ), m_flags( aFlags )
1223 {
1224 // Save what we need to restore later.
1225 // These are all so cheap to copy, it's likely not worth if'ing
1226 m_strokeWidth = aGal.GetLineWidth();
1228 m_isStroke = aGal.GetIsStroke();
1229 m_fillColor = aGal.GetFillColor();
1230 m_isFill = aGal.GetIsFill();
1231 m_layerDepth = aGal.getLayerDepth();
1232 }
1233
1235 {
1236 // Restore the attributes that were saved
1237 // based on the flags that were set.
1238
1239 if( m_flags & STROKE_WIDTH )
1241
1242 if( m_flags & STROKE_COLOR )
1244
1245 if( m_flags & IS_STROKE )
1247
1248 if( m_flags & FILL_COLOR )
1250
1251 if( m_flags & IS_FILL )
1253
1254 if( m_flags & LAYER_DEPTH )
1256 }
1257
1258private:
1261
1265
1268
1270};
1271
1272
1273}; // namespace KIGFX
1274
1275#endif /* GRAPHICSABSTRACTIONLAYER_H_ */
This class handle bitmap images in KiCad.
Definition: bitmap_base.h:49
constexpr const Vec GetEnd() const
Definition: box2.h:212
constexpr const Vec & GetOrigin() const
Definition: box2.h:210
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
Attribute save/restore for GAL attributes.
GAL_SCOPED_ATTRS(KIGFX::GAL &aGal, int aFlags)
Instantiate a GAL_SCOPED_ATTRS object, saving the current attributes of the GAL.
Abstract interface for drawing on a 2D-surface.
const VECTOR2D & GetGridOrigin() const
virtual void ResizeScreen(int aWidth, int aHeight)
Resize the canvas.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
bool IsTextMirrored() const
void SetGridColor(const COLOR4D &aGridColor)
Set the grid color.
float GetGridLineWidth() const
Get the grid line width.
virtual bool Show(bool aShow)
Show/hide the GAL canvas.
virtual void SetLayerDepth(double aLayerDepth)
Set the depth of the layer (position on the z-axis)
const MATRIX3x3D & GetWorldScreenMatrix() const
Get the world <-> screen transformation matrix.
bool IsCursorEnabled() const
Return information about cursor visibility.
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
virtual void EndDrawing()
End the drawing, needs to be called for every new frame.
virtual void StartDiffLayer()
Begins rendering of a differential layer.
bool m_isCursorEnabled
Is the cursor enabled?
virtual void DrawGlyph(const KIFONT::GLYPH &aGlyph, int aNth=0, int aTotal=1)
Draw a polygon representing a font glyph.
virtual void EndDiffLayer()
Ends rendering of a differential layer.
virtual void Rotate(double aAngle)
Rotate the context.
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a rectangle.
MATRIX3x3D m_worldScreenMatrix
World transformation.
VECTOR2D GetVisibleGridSize() const
Return the visible grid size in x and y directions.
double m_layerDepth
The actual layer depth.
void SetVerticalJustify(const GR_TEXT_V_ALIGN_T aVerticalJustify)
bool GetIsFill() const
Get the fill status.
void AdvanceDepth()
Change the current depth to deeper, so it is possible to draw objects right beneath other.
const COLOR4D & GetFillColor() const
Get the fill color.
void SetFontBold(const bool aBold)
MATRIX3x3D m_screenWorldMatrix
Screen transformation.
void SetFontUnderlined(bool aUnderlined)
void SetHorizontalJustify(const GR_TEXT_H_ALIGN_T aHorizontalJustify)
virtual RENDER_TARGET GetTarget() const
Get the currently used target for rendering.
double GetMaxDepth() const
bool m_axesEnabled
Should the axes be drawn.
void SetRotation(double aRotation)
Get/set the rotation angle (in radians).
float m_gridLineWidth
Line width of the grid.
void SetFlip(bool xAxis, bool yAxis)
Sets flipping of the screen.
VECTOR2I m_screenSize
Screen size in screen (wx logical) coordinates.
virtual void Flush()
Force all remaining objects to be drawn.
virtual int GetSwapInterval() const
Return the swap interval. -1 for adaptive, 0 for disabled/unknown.
virtual void DeleteGroup(int aGroupNumber)
Delete the group from the memory.
std::stack< double > m_depthStack
Stored depth values.
GR_TEXT_H_ALIGN_T GetHorizontalJustify() const
void normalize(T &a, T &b)
Ensure that the first element is smaller than the second.
VECTOR2D m_depthRange
Range of the depth.
double GetZoomFactor() const
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
double m_zoomFactor
The zoom factor.
virtual void Translate(const VECTOR2D &aTranslation)
Translate the context.
VECTOR2D ToScreen(const VECTOR2D &aPoint) const
Compute the point position in screen coordinates from given world coordinates.
void SetCursorEnabled(bool aCursorEnabled)
Enable/disable cursor.
void SetAxesEnabled(bool aAxesEnabled)
Enable drawing the axes.
virtual void DrawPolylines(const std::vector< std::vector< VECTOR2D > > &aPointLists)
Draw multiple polylines.
virtual bool HasTarget(RENDER_TARGET aTarget)
Return true if the target exists.
GRID_STYLE m_gridStyle
Grid display style.
void SetCursorColor(const COLOR4D &aCursorColor)
Set the cursor color.
COLOR4D m_cursorColor
Cursor color.
COLOR4D m_axesColor
Color of the axes.
int m_gridMinSpacing
Minimum screen size of the grid (pixels) below which the grid is not drawn.
void SetGridSize(const VECTOR2D &aGridSize)
Set the grid size.
const VECTOR2D & GetLookAtPoint() const
double GetRotation() const
const MATRIX3x3D & GetScreenWorldMatrix() const
Get the screen <-> world transformation matrix.
bool IsFontUnderlined() const
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
virtual void Restore()
Restore the context.
float m_lineWidth
The line width.
const COLOR4D & GetStrokeColor() const
Get the stroke color.
virtual void ClearTarget(RENDER_TARGET aTarget)
Clear the target for rendering.
void SetZoomFactor(double aZoomFactor)
virtual void BeginDrawing()
Start/end drawing functions, draw calls can be only made in between the calls to BeginDrawing()/EndDr...
void computeWorldScale()
Compute the scaling factor for the world->screen matrix.
virtual bool IsOpenGlEngine()
Return true if the GAL engine is a OpenGL based type.
virtual int BeginGroup()
Begin a group.
TEXT_ATTRIBUTES m_attributes
static const int MIN_DEPTH
Possible depth range.
const VECTOR2D & GetGridSize() const
Return the grid size.
virtual void DrawPolygon(const VECTOR2D aPointList[], int aListSize)
virtual void SetLineWidth(float aLineWidth)
Set the line width.
double m_rotation
Rotation transformation (radians)
VECTOR2D m_gridSize
The grid size.
virtual void DrawGrid()
virtual void DrawPolygon(const SHAPE_POLY_SET &aPolySet, bool aStrokeTriangulation=false)
virtual void ChangeGroupDepth(int aGroupNumber, int aDepth)
Change the depth (Z-axis position) of the group.
COLOR4D m_fillColor
The fill color.
virtual void EndNegativesLayer()
Ends rendering of a negatives layer and draws it to the main layer.
void DrawRectangle(const BOX2I &aRect)
double m_worldUnitLength
The unit length of the world coordinates [inch].
virtual void StartNegativesLayer()
Begins rendering in a new layer that will be copied to the main layer in EndNegativesLayer().
void SetTextMirrored(const bool aMirrored)
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
void SetCoarseGrid(int aInterval)
Draw every tick line wider.
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
virtual void ChangeGroupColor(int aGroupNumber, const COLOR4D &aNewColor)
Change the color used to draw the group.
virtual void DrawArcSegment(const VECTOR2D &aCenterPoint, double aRadius, const EDA_ANGLE &aStartAngle, const EDA_ANGLE &aAngle, double aWidth, double aMaxError)
Draw an arc segment.
virtual bool IsContextLocked()
Checks the state of the context lock.
VECTOR2D m_cursorPosition
Current cursor position (world coordinates)
VECTOR2D m_gridOffset
The grid offset to compensate cursor position.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
virtual void beginUpdate()
Enable item update mode.
virtual void DrawGroup(int aGroupNumber)
Draw the stored group.
double getLayerDepth() const
const VECTOR2I & GetGlyphSize() const
int m_gridTick
Every tick line gets the double width.
double m_worldScale
The scale factor world->screen.
void SetLookAtPoint(const VECTOR2D &aPoint)
Get/set the Point in world space to look at.
virtual void DrawPolygon(const SHAPE_LINE_CHAIN &aPolySet)
bool GetGridVisibility() const
void SetGridOrigin(const VECTOR2D &aGridOrigin)
Set the origin point for the grid.
virtual bool IsCairoEngine()
Return true if the GAL engine is a Cairo based type.
virtual void ClearScreen()
Clear the screen.
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
VECTOR2D m_gridOrigin
The grid origin.
virtual void endUpdate()
Disable item update mode.
void SetWorldUnitLength(double aWorldUnitLength)
Set the unit length.
virtual void DrawPolyline(const std::vector< VECTOR2D > &aPointList)
KICURSOR m_currentNativeCursor
Current cursor.
bool m_globalFlipY
Flag for Y axis flipping.
virtual void UnlockContext(int aClientCookie)
void SetClearColor(const COLOR4D &aColor)
void SetScreenSize(const VECTOR2I &aSize)
const COLOR4D & GetClearColor() const
bool m_fullscreenCursor
Shape of the cursor (fullscreen or small cross)
virtual void DrawSegmentChain(const SHAPE_LINE_CHAIN &aLineChain, double aWidth)
static const int GRID_DEPTH
Depth level on which the grid is drawn.
virtual bool IsInitialized() const
Return the initialization status for the canvas.
void SetGlyphSize(const VECTOR2I aSize)
virtual void DrawGlyphs(const std::vector< std::unique_ptr< KIFONT::GLYPH > > &aGlyphs)
Draw polygons representing font glyphs.
virtual void Scale(const VECTOR2D &aScale)
Scale the context.
virtual void DrawCurve(const VECTOR2D &startPoint, const VECTOR2D &controlPointA, const VECTOR2D &controlPointB, const VECTOR2D &endPoint, double aFilterValue=0.0)
Draw a cubic bezier spline.
bool m_isFillEnabled
Is filling of graphic objects enabled ?
bool GetGridSnapping() const
virtual void EndGroup()
End the group.
virtual void DrawArc(const VECTOR2D &aCenterPoint, double aRadius, const EDA_ANGLE &aStartAngle, const EDA_ANGLE &aAngle)
Draw an arc.
virtual void Transform(const MATRIX3x3D &aTransformation)
Transform the context.
virtual void SetNegativeDrawMode(bool aSetting)
Set negative draw mode in the renderer.
COLOR4D m_gridColor
Color of the grid.
VECTOR2D ToWorld(const VECTOR2D &aPoint) const
Compute the point position in world coordinates from given screen coordinates.
COLOR4D m_strokeColor
The color of the outlines.
void SetFontItalic(bool aItalic)
bool m_isStrokeEnabled
Are the outlines stroked ?
virtual void DrawBitmap(const BITMAP_BASE &aBitmap, double alphaBlend=1.0)
Draw a bitmap image.
GAL_DISPLAY_OPTIONS & m_options
bool m_gridVisibility
Should the grid be shown.
double GetMinDepth() const
virtual void ClearCache()
Delete all data created during caching of graphic items.
virtual void SetTarget(RENDER_TARGET aTarget)
Set the target for rendering.
virtual void DrawSegment(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth)
Draw a rounded segment.
double m_screenDPI
The dots per inch of the screen.
virtual void DrawPolyline(const SHAPE_LINE_CHAIN &aLineChain)
const VECTOR2I & GetScreenPixelSize() const
Return GAL canvas size in pixels.
void SetGridVisibility(bool aVisibility)
Set the visibility setting of the grid.
float GetLineWidth() const
Get the line width.
virtual void Save()
Save the context.
bool m_globalFlipX
Flag for X axis flipping.
virtual void LockContext(int aClientCookie)
Use GAL_CONTEXT_LOCKER RAII object unless you know what you're doing.
virtual void DrawSegmentChain(const std::vector< VECTOR2D > &aPointList, double aWidth)
Draw a chain of rounded segments.
void SetWorldScreenMatrix(const MATRIX3x3D &aMatrix)
Set the world <-> screen transformation matrix.
GR_TEXT_V_ALIGN_T GetVerticalJustify() const
bool GetIsStroke() const
Get the stroke status.
virtual void DrawCursor(const VECTOR2D &aCursorPosition)
Draw the cursor.
void SetDepthRange(const VECTOR2D &aDepthRange)
Set the range of the layer depth.
double GetWorldScale() const
Get the world scale.
VECTOR2D m_lookAtPoint
Point to be looked at in world space.
virtual bool IsVisible() const
Return true if the GAL canvas is visible on the screen.
void SetScreenDPI(double aScreenDPI)
Set the dots per inch of the screen.
virtual void DrawPolyline(const VECTOR2D aPointList[], int aListSize)
virtual void EnableDepthTest(bool aEnabled=false)
bool m_forceDisplayCursor
Always show cursor.
static const int MAX_DEPTH
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
#define GAL_API
Definition: gal.h:28
The Cairo implementation of the graphics abstraction layer.
Definition: eda_group.h:33
GRID_STYLE
Type definition of the grid style.
RENDER_TARGET
RENDER_TARGET: Possible rendering targets.
Definition: definitions.h:36
@ TARGET_CACHED
Main rendering target (cached)
Definition: definitions.h:37
GR_TEXT_H_ALIGN_T
This is API surface mapped to common.types.HorizontalAlignment.
GR_TEXT_V_ALIGN_T
This is API surface mapped to common.types.VertialAlignment.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:694