KiCad PCB EDA Suite
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 (C) 2016-2021 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/color4d.h>
37#include <gal/cursors.h>
38#include <gal/definitions.h>
40#include <newstroke_font.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& aEndAngle ) {};
155
174 virtual void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius,
175 const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aEndAngle,
176 double aWidth, double aMaxError ) {};
177
184 virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
185
186 void DrawRectangle( const BOX2I& aRect )
187 {
188 DrawRectangle( aRect.GetOrigin(), aRect.GetEnd() );
189 }
190
194 virtual void DrawGlyph( const KIFONT::GLYPH& aGlyph, int aNth = 0, int aTotal = 1 ) {};
195
199 virtual void DrawGlyphs( const std::vector<std::unique_ptr<KIFONT::GLYPH>>& aGlyphs )
200 {
201 for( size_t i = 0; i < aGlyphs.size(); i++ )
202 DrawGlyph( *aGlyphs[i], i, aGlyphs.size() );
203 }
204
205
211 virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) {};
212 virtual void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) {};
213 virtual void DrawPolygon( const SHAPE_POLY_SET& aPolySet, bool aStrokeTriangulation = false ) {};
214 virtual void DrawPolygon( const SHAPE_LINE_CHAIN& aPolySet ) {};
215
227 virtual void DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
228 const VECTOR2D& controlPointB, const VECTOR2D& endPoint,
229 double aFilterValue = 0.0 ) {};
230
234 virtual void DrawBitmap( const BITMAP_BASE& aBitmap, double alphaBlend = 1.0 ) {};
235
236 // --------------
237 // Screen methods
238 // --------------
239
241 virtual void ResizeScreen( int aWidth, int aHeight ) {};
242
244 virtual bool Show( bool aShow ) { return true; };
245
248 {
249 return m_screenSize;
250 }
251
253 virtual int GetSwapInterval() const { return 0; };
254
256 virtual void Flush() {};
257
258 void SetClearColor( const COLOR4D& aColor )
259 {
260 m_clearColor = aColor;
261 }
262
263 const COLOR4D& GetClearColor( ) const
264 {
265 return m_clearColor;
266 }
267
273 virtual void ClearScreen() {};
274
275 // -----------------
276 // Attribute setting
277 // -----------------
278
284 virtual void SetIsFill( bool aIsFillEnabled )
285 {
286 m_isFillEnabled = aIsFillEnabled;
287 }
288
294 virtual void SetIsStroke( bool aIsStrokeEnabled )
295 {
296 m_isStrokeEnabled = aIsStrokeEnabled;
297 }
298
304 virtual void SetFillColor( const COLOR4D& aColor )
305 {
306 m_fillColor = aColor;
307 }
308
314 inline const COLOR4D& GetFillColor() const
315 {
316 return m_fillColor;
317 }
318
324 virtual void SetStrokeColor( const COLOR4D& aColor )
325 {
326 m_strokeColor = aColor;
327 }
328
334 inline const COLOR4D& GetStrokeColor() const
335 {
336 return m_strokeColor;
337 }
338
344 virtual void SetLineWidth( float aLineWidth )
345 {
346 m_lineWidth = aLineWidth;
347 }
348
354 inline float GetLineWidth() const
355 {
356 return m_lineWidth;
357 }
358
364 virtual void SetLayerDepth( double aLayerDepth )
365 {
366 assert( aLayerDepth <= m_depthRange.y );
367 assert( aLayerDepth >= m_depthRange.x );
368
369 m_layerDepth = aLayerDepth;
370 }
371
372 // ----
373 // Text
374 // ----
375
384 virtual void BitmapText( const wxString& aText, const VECTOR2I& aPosition,
385 const EDA_ANGLE& aAngle );
386
393 void ResetTextAttributes();
394
395 void SetGlyphSize( const VECTOR2I aSize ) { m_attributes.m_Size = aSize; }
396 const VECTOR2I& GetGlyphSize() const { return m_attributes.m_Size; }
397
398 inline void SetFontBold( const bool aBold ) { m_attributes.m_Bold = aBold; }
399 inline bool IsFontBold() const { return m_attributes.m_Bold; }
400
401 inline void SetFontItalic( bool aItalic ) { m_attributes.m_Italic = aItalic; }
402 inline bool IsFontItalic() const { return m_attributes.m_Italic; }
403
404 inline void SetFontUnderlined( bool aUnderlined ) { m_attributes.m_Underlined = aUnderlined; }
405 inline bool IsFontUnderlined() const { return m_attributes.m_Underlined; }
406
407 void SetTextMirrored( const bool aMirrored ) { m_attributes.m_Mirrored = aMirrored; }
408 bool IsTextMirrored() const { return m_attributes.m_Mirrored; }
409
410 void SetHorizontalJustify( const GR_TEXT_H_ALIGN_T aHorizontalJustify )
411 {
412 m_attributes.m_Halign = aHorizontalJustify;
413 }
414
416
417 void SetVerticalJustify( const GR_TEXT_V_ALIGN_T aVerticalJustify )
418 {
419 m_attributes.m_Valign = aVerticalJustify;
420 }
421
423
424
425 // --------------
426 // Transformation
427 // --------------
428
434 virtual void Transform( const MATRIX3x3D& aTransformation ) {};
435
441 virtual void Rotate( double aAngle ) {};
442
448 virtual void Translate( const VECTOR2D& aTranslation ) {};
449
455 virtual void Scale( const VECTOR2D& aScale ) {};
456
458 virtual void Save() {};
459
461 virtual void Restore() {};
462
463 // --------------------------------------------
464 // Group methods
465 // ---------------------------------------------
466
475 virtual int BeginGroup() { return 0; };
476
478 virtual void EndGroup() {};
479
485 virtual void DrawGroup( int aGroupNumber ) {};
486
493 virtual void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) {};
494
501 virtual void ChangeGroupDepth( int aGroupNumber, int aDepth ) {};
502
508 virtual void DeleteGroup( int aGroupNumber ) {};
509
513 virtual void ClearCache() {};
514
515 // --------------------------------------------------------
516 // Handling the world <-> screen transformation
517 // --------------------------------------------------------
518
520 virtual void ComputeWorldScreenMatrix();
521
528 {
529 return m_worldScreenMatrix;
530 }
531
538 {
539 return m_screenWorldMatrix;
540 }
541
547 inline void SetWorldScreenMatrix( const MATRIX3x3D& aMatrix )
548 {
549 m_worldScreenMatrix = aMatrix;
550 }
551
556
564 void SetWorldUnitLength( double aWorldUnitLength ) { m_worldUnitLength = aWorldUnitLength; }
565
566 void SetScreenSize( const VECTOR2I& aSize ) { m_screenSize = aSize; }
567
574 void SetScreenDPI( double aScreenDPI ) { m_screenDPI = aScreenDPI; }
575
581 void SetLookAtPoint( const VECTOR2D& aPoint ) { m_lookAtPoint = aPoint; }
582 const VECTOR2D& GetLookAtPoint() const { return m_lookAtPoint; }
583
584 void SetZoomFactor( double aZoomFactor ) { m_zoomFactor = aZoomFactor; }
585 double GetZoomFactor() const { return m_zoomFactor; }
586
590 void SetRotation( double aRotation ) { m_rotation = aRotation; }
591 double GetRotation() const { return m_rotation; }
592
601 void SetDepthRange( const VECTOR2D& aDepthRange ) { m_depthRange = aDepthRange; }
602 double GetMinDepth() const { return m_depthRange.x; }
603 double GetMaxDepth() const { return m_depthRange.y; }
604
610 double GetWorldScale() const { return m_worldScale; }
611
618 inline void SetFlip( bool xAxis, bool yAxis )
619 {
620 m_globalFlipX = xAxis;
621 m_globalFlipY = yAxis;
622 }
623
624 bool IsFlippedX() const { return m_globalFlipX; }
625 bool IsFlippedY() const { return m_globalFlipY; }
626
627 // ---------------------------
628 // Buffer manipulation methods
629 // ---------------------------
630
636 virtual void SetTarget( RENDER_TARGET aTarget ) {};
637
643 virtual RENDER_TARGET GetTarget() const { return TARGET_CACHED; };
644
650 virtual void ClearTarget( RENDER_TARGET aTarget ) {};
651
657 virtual bool HasTarget( RENDER_TARGET aTarget )
658 {
659 return true;
660 };
661
673 virtual void SetNegativeDrawMode( bool aSetting ) {};
674
682 virtual void StartDiffLayer() {};
683
689 virtual void EndDiffLayer() {};
690
699 virtual void StartNegativesLayer(){};
700
705 virtual void EndNegativesLayer(){};
706
707 // -------------
708 // Grid methods
709 // -------------
710
716 void SetGridVisibility( bool aVisibility ) { m_gridVisibility = aVisibility; }
717
718 bool GetGridVisibility() const { return m_gridVisibility; }
719
720 bool GetGridSnapping() const
721 {
724 }
725
731 inline void SetGridOrigin( const VECTOR2D& aGridOrigin )
732 {
733 m_gridOrigin = aGridOrigin;
734
735 if( m_gridSize.x == 0.0 || m_gridSize.y == 0.0 )
736 {
737 m_gridOffset = VECTOR2D( 0.0, 0.0);
738 }
739 else
740 {
741 m_gridOffset = VECTOR2D( (long) m_gridOrigin.x % (long) m_gridSize.x,
742 (long) m_gridOrigin.y % (long) m_gridSize.y );
743 }
744 }
745
746 inline const VECTOR2D& GetGridOrigin() const
747 {
748 return m_gridOrigin;
749 }
750
756 inline void SetGridSize( const VECTOR2D& aGridSize )
757 {
758 m_gridSize = aGridSize;
759
760 // Avoid stupid grid size values: a grid size should be >= 1 in internal units
761 m_gridSize.x = std::max( 1.0, m_gridSize.x );
762 m_gridSize.y = std::max( 1.0, m_gridSize.y );
763
764 m_gridOffset = VECTOR2D( (long) m_gridOrigin.x % (long) m_gridSize.x,
765 (long) m_gridOrigin.y % (long) m_gridSize.y );
766 }
767
773 inline const VECTOR2D& GetGridSize() const
774 {
775 return m_gridSize;
776 }
777
783 inline void SetGridColor( const COLOR4D& aGridColor )
784 {
785 m_gridColor = aGridColor;
786 }
787
793 inline void SetAxesColor( const COLOR4D& aAxesColor )
794 {
795 m_axesColor = aAxesColor;
796 }
797
801 inline void SetAxesEnabled( bool aAxesEnabled )
802 {
803 m_axesEnabled = aAxesEnabled;
804 }
805
811 inline void SetCoarseGrid( int aInterval )
812 {
813 m_gridTick = aInterval;
814 }
815
821 inline float GetGridLineWidth() const
822 {
823 return m_gridLineWidth;
824 }
825
827 virtual void DrawGrid() {};
828
835 VECTOR2D GetGridPoint( const VECTOR2D& aPoint ) const;
836
843 inline VECTOR2D ToWorld( const VECTOR2D& aPoint ) const
844 {
845 return VECTOR2D( m_screenWorldMatrix * aPoint );
846 }
847
854 inline VECTOR2D ToScreen( const VECTOR2D& aPoint ) const
855 {
856 return VECTOR2D( m_worldScreenMatrix * aPoint );
857 }
858
865 virtual bool SetNativeCursorStyle( KICURSOR aCursor );
866
872 inline void SetCursorEnabled( bool aCursorEnabled )
873 {
874 m_isCursorEnabled = aCursorEnabled;
875 }
876
882 bool IsCursorEnabled() const
883 {
885 }
886
892 inline void SetCursorColor( const COLOR4D& aCursorColor )
893 {
894 m_cursorColor = aCursorColor;
895 }
896
902 virtual void DrawCursor( const VECTOR2D& aCursorPosition ) {};
903
908 inline void AdvanceDepth()
909 {
910 m_layerDepth -= 0.05;
911 }
912
916 inline void PushDepth()
917 {
919 }
920
924 inline void PopDepth()
925 {
927 m_depthStack.pop();
928 }
929
930 virtual void EnableDepthTest( bool aEnabled = false ) {};
931
936 virtual bool IsContextLocked()
937 {
938 return false;
939 }
940
941
943 virtual void LockContext( int aClientCookie ) {}
944
945 virtual void UnlockContext( int aClientCookie ) {}
946
951
954 virtual void BeginDrawing() {};
955
958 virtual void EndDrawing() {};
959protected:
960
963 virtual void beginUpdate() {}
964
966 virtual void endUpdate() {}
967
968
969
971 inline void computeWorldScale()
972 {
974 }
975
981 double computeMinGridSpacing() const;
982
984 static const int MIN_DEPTH;
985 static const int MAX_DEPTH;
986
988 static const int GRID_DEPTH;
989
993 COLOR4D getCursorColor() const;
994
995 // ---------------
996 // Settings observer interface
997 // ---------------
1001 void OnGalDisplayOptionsChanged( const GAL_DISPLAY_OPTIONS& aOptions ) override;
1002
1011 virtual bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions );
1012
1015
1016 std::stack<double> m_depthStack;
1018
1022
1024 double m_rotation;
1028
1031
1033
1036
1040
1043
1044 // Grid settings
1057
1058 // Cursor settings
1064
1066
1067private:
1069};
1070
1071
1073{
1074public:
1076 m_gal( aGal )
1077 {
1078 m_cookie = rand();
1080 }
1081
1083 {
1085 }
1086
1087protected:
1090};
1091
1092
1094{
1095public:
1097 GAL_CONTEXT_LOCKER( aGal )
1098 {
1099 m_gal->beginUpdate();
1100 }
1101
1103 {
1104 m_gal->endUpdate();
1105 }
1106};
1107
1108
1110{
1111public:
1113 GAL_CONTEXT_LOCKER( aGal )
1114 {
1116 }
1117
1118 ~GAL_DRAWING_CONTEXT() noexcept( false )
1119 {
1120 m_gal->EndDrawing();
1121 }
1122};
1123
1124
1125}; // namespace KIGFX
1126
1127#endif /* GRAPHICSABSTRACTIONLAYER_H_ */
This class handle bitmap images in KiCad.
Definition: bitmap_base.h:51
const Vec & GetOrigin() const
Definition: box2.h:183
const Vec GetEnd() const
Definition: box2.h:185
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
GRID_SNAPPING m_gridSnapping
Thickness to render grid lines/dots.
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.
BOX2D GetVisibleWorldExtents() const
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a rectangle.
MATRIX3x3D m_worldScreenMatrix
World transformation.
double m_layerDepth
The actual layer depth.
void SetVerticalJustify(const GR_TEXT_V_ALIGN_T aVerticalJustify)
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 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
VECTOR2D m_depthRange
Range of the depth.
double GetZoomFactor() const
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
void OnGalDisplayOptionsChanged(const GAL_DISPLAY_OPTIONS &aOptions) override
Handler for observer settings changes.
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.
void PushDepth()
Store current drawing depth on the depth stack.
virtual int BeginGroup()
Begin a group.
TEXT_ATTRIBUTES m_attributes
void ResetTextAttributes()
Reset text attributes to default styling.
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)
COLOR4D getCursorColor() const
Get the actual cursor color to draw.
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.
virtual bool updatedGalDisplayOptions(const GAL_DISPLAY_OPTIONS &aOptions)
Handle updating display options.
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 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.
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.
VECTOR2D GetGridPoint(const VECTOR2D &aPoint) const
For a given point it returns the nearest point belonging to the grid in world coordinates.
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.
virtual bool SetNativeCursorStyle(KICURSOR aCursor)
Set the cursor in the native panel.
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 ?
virtual void ComputeWorldScreenMatrix()
Compute the world <-> screen transformation matrix.
bool GetGridSnapping() const
virtual void EndGroup()
End the group.
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.
double computeMinGridSpacing() const
compute minimum grid spacing from the grid settings
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.
virtual void BitmapText(const wxString &aText, const VECTOR2I &aPosition, const EDA_ANGLE &aAngle)
Draw a text using a bitmap font.
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 PopDepth()
Restore previously stored drawing depth for the depth stack.
void SetWorldScreenMatrix(const MATRIX3x3D &aMatrix)
Set the world <-> screen transformation matrix.
GR_TEXT_V_ALIGN_T GetVerticalJustify() const
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.
GAL(GAL_DISPLAY_OPTIONS &aOptions)
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
virtual void DrawArcSegment(const VECTOR2D &aCenterPoint, double aRadius, const EDA_ANGLE &aStartAngle, const EDA_ANGLE &aEndAngle, double aWidth, double aMaxError)
Draw an arc segment.
virtual void DrawArc(const VECTOR2D &aCenterPoint, double aRadius, const EDA_ANGLE &aStartAngle, const EDA_ANGLE &aEndAngle)
Draw an arc.
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.
GR_TEXT_H_ALIGN_T m_Halign
GR_TEXT_V_ALIGN_T m_Valign
KICURSOR
Definition: cursors.h:34
The Cairo implementation of the graphics abstraction layer.
Definition: color4d.cpp:266
GRID_STYLE
GRID_STYLE: Type definition of the grid style.
RENDER_TARGET
RENDER_TARGET: Possible rendering targets.
Definition: definitions.h:47
@ TARGET_CACHED
Main rendering target (cached)
Definition: definitions.h:48
GR_TEXT_H_ALIGN_T
GR_TEXT_V_ALIGN_T
VECTOR2< double > VECTOR2D
Definition: vector2d.h:617