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-2017 Kicad Developers, see change_log.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/definitions.h>
38 #include <gal/stroke_font.h>
40 #include <newstroke_font.h>
41 
42 class SHAPE_LINE_CHAIN;
43 class SHAPE_POLY_SET;
44 class BITMAP_BASE;
45 
46 namespace KIGFX
47 {
48 
60 {
61  // These friend declarations allow us to hide routines that should not be called. The
62  // corresponding RAII objects must be used instead.
63  friend class GAL_CONTEXT_LOCKER;
64  friend class GAL_UPDATE_CONTEXT;
65  friend class GAL_DRAWING_CONTEXT;
66 
67 public:
68  // Constructor / Destructor
69  GAL( GAL_DISPLAY_OPTIONS& aOptions );
70  virtual ~GAL();
71 
73  virtual bool IsInitialized() const { return true; }
74 
76  virtual bool IsVisible() const { return true; }
77 
79  virtual bool IsCairoEngine() { return false; }
80 
82  virtual bool IsOpenGlEngine() { return false; }
83 
84  // ---------------
85  // Drawing methods
86  // ---------------
87 
96  virtual void DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
97 
107  virtual void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint, double aWidth ) {};
108 
114  virtual void DrawPolyline( const std::deque<VECTOR2D>& aPointList ) {};
115  virtual void DrawPolyline( const VECTOR2D aPointList[], int aListSize ) {};
116  virtual void DrawPolyline( const SHAPE_LINE_CHAIN& aLineChain ) {};
117 
124  virtual void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) {};
125 
134  virtual void
135  DrawArc( const VECTOR2D& aCenterPoint, double aRadius, double aStartAngle, double aEndAngle ) {};
136 
153  virtual void
154  DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, double aStartAngle,
155  double aEndAngle, double aWidth ) {};
156 
163  virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
164 
170  virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) {};
171  virtual void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) {};
172  virtual void DrawPolygon( const SHAPE_POLY_SET& aPolySet ) {};
173  virtual void DrawPolygon( const SHAPE_LINE_CHAIN& aPolySet ) {};
174 
183  virtual void DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
184  const VECTOR2D& controlPointB, const VECTOR2D& endPoint ) {};
185 
189  virtual void DrawBitmap( const BITMAP_BASE& aBitmap ) {};
190 
191  // --------------
192  // Screen methods
193  // --------------
194 
196  virtual void ResizeScreen( int aWidth, int aHeight ) {};
197 
199  virtual bool Show( bool aShow ) { return true; };
200 
203  {
204  return screenSize;
205  }
206 
208  virtual void Flush() {};
209 
210  void SetClearColor( const COLOR4D& aColor )
211  {
212  m_clearColor = aColor;
213  }
214 
215  const COLOR4D& GetClearColor( ) const
216  {
217  return m_clearColor;
218  }
219 
224  virtual void ClearScreen() {};
225 
226  // -----------------
227  // Attribute setting
228  // -----------------
229 
235  virtual void SetIsFill( bool aIsFillEnabled )
236  {
237  isFillEnabled = aIsFillEnabled;
238  }
239 
245  virtual void SetIsStroke( bool aIsStrokeEnabled )
246  {
247  isStrokeEnabled = aIsStrokeEnabled;
248  }
249 
255  virtual void SetFillColor( const COLOR4D& aColor )
256  {
257  fillColor = aColor;
258  }
259 
265  inline const COLOR4D& GetFillColor() const
266  {
267  return fillColor;
268  }
269 
275  virtual void SetStrokeColor( const COLOR4D& aColor )
276  {
277  strokeColor = aColor;
278  }
279 
285  inline const COLOR4D& GetStrokeColor() const
286  {
287  return strokeColor;
288  }
289 
295  virtual void SetLineWidth( float aLineWidth )
296  {
297  lineWidth = aLineWidth;
298  }
299 
305  inline float GetLineWidth() const
306  {
307  return lineWidth;
308  }
309 
315  virtual void SetLayerDepth( double aLayerDepth )
316  {
317  assert( aLayerDepth <= depthRange.y );
318  assert( aLayerDepth >= depthRange.x );
319 
320  layerDepth = aLayerDepth;
321  }
322 
323  // ----
324  // Text
325  // ----
326 
327  const STROKE_FONT& GetStrokeFont() const
328  {
329  return strokeFont;
330  }
331 
339  virtual void StrokeText( const wxString& aText, const VECTOR2D& aPosition,
340  double aRotationAngle )
341  {
342  strokeFont.Draw( aText, aPosition, aRotationAngle );
343  }
344 
353  virtual void BitmapText( const wxString& aText, const VECTOR2D& aPosition,
354  double aRotationAngle )
355  {
356  // Fallback: use stroke font
357 
358  // Handle flipped view
359  if( globalFlipX )
361 
362  StrokeText( aText, aPosition, aRotationAngle );
363 
364  if( globalFlipX )
366  }
367 
375  VECTOR2D GetTextLineSize( const UTF8& aText ) const;
376 
383  {
385  }
386 
392  virtual void SetTextAttributes( const EDA_TEXT* aText );
393 
400  void ResetTextAttributes();
401 
407  inline void SetGlyphSize( const VECTOR2D aGlyphSize )
408  {
409  textProperties.m_glyphSize = aGlyphSize;
410  }
411 
415  const VECTOR2D& GetGlyphSize() const
416  {
418  }
419 
425  inline void SetFontBold( const bool aBold )
426  {
427  textProperties.m_bold = aBold;
428  }
429 
433  inline bool IsFontBold() const
434  {
435  return textProperties.m_bold;
436  }
437 
443  inline void SetFontItalic( const bool aItalic )
444  {
445  textProperties.m_italic = aItalic;
446  }
447 
451  inline bool IsFontItalic() const
452  {
453  return textProperties.m_italic;
454  }
455 
461  inline void SetTextMirrored( const bool aMirrored )
462  {
463  textProperties.m_mirrored = aMirrored;
464  }
465 
469  inline bool IsTextMirrored() const
470  {
471  return textProperties.m_mirrored;
472  }
473 
479  inline void SetHorizontalJustify( const EDA_TEXT_HJUSTIFY_T aHorizontalJustify )
480  {
481  textProperties.m_horizontalJustify = aHorizontalJustify;
482  }
483 
488  {
490  }
491 
497  inline void SetVerticalJustify( const EDA_TEXT_VJUSTIFY_T aVerticalJustify )
498  {
499  textProperties.m_verticalJustify = aVerticalJustify;
500  }
501 
506  {
508  }
509 
510 
511  // --------------
512  // Transformation
513  // --------------
514 
520  virtual void Transform( const MATRIX3x3D& aTransformation ) {};
521 
527  virtual void Rotate( double aAngle ) {};
528 
534  virtual void Translate( const VECTOR2D& aTranslation ) {};
535 
541  virtual void Scale( const VECTOR2D& aScale ) {};
542 
544  virtual void Save() {};
545 
547  virtual void Restore() {};
548 
549  // --------------------------------------------
550  // Group methods
551  // ---------------------------------------------
552 
561  virtual int BeginGroup() { return 0; };
562 
564  virtual void EndGroup() {};
565 
571  virtual void DrawGroup( int aGroupNumber ) {};
572 
579  virtual void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) {};
580 
587  virtual void ChangeGroupDepth( int aGroupNumber, int aDepth ) {};
588 
594  virtual void DeleteGroup( int aGroupNumber ) {};
595 
599  virtual void ClearCache() {};
600 
601  // --------------------------------------------------------
602  // Handling the world <-> screen transformation
603  // --------------------------------------------------------
604 
606  virtual void ComputeWorldScreenMatrix();
607 
614  {
615  return worldScreenMatrix;
616  }
617 
624  {
625  return screenWorldMatrix;
626  }
627 
633  inline void SetWorldScreenMatrix( const MATRIX3x3D& aMatrix )
634  {
635  worldScreenMatrix = aMatrix;
636  }
637 
647  inline void SetWorldUnitLength( double aWorldUnitLength )
648  {
649  worldUnitLength = aWorldUnitLength;
650  }
651 
652  inline void SetScreenSize( const VECTOR2I& aSize )
653  {
654  screenSize = aSize;
655  }
656 
665  inline void SetScreenDPI( double aScreenDPI )
666  {
667  screenDPI = aScreenDPI;
668  }
669 
677  inline void SetLookAtPoint( const VECTOR2D& aPoint )
678  {
679  lookAtPoint = aPoint;
680  }
681 
687  inline const VECTOR2D& GetLookAtPoint() const
688  {
689  return lookAtPoint;
690  }
691 
697  inline void SetZoomFactor( double aZoomFactor )
698  {
699  zoomFactor = aZoomFactor;
700  }
701 
707  inline double GetZoomFactor() const
708  {
709  return zoomFactor;
710  }
711 
717  void SetRotation( double aRotation )
718  {
719  rotation = aRotation;
720  }
721 
727  double GetRotation() const
728  {
729  return rotation;
730  }
731 
740  inline void SetDepthRange( const VECTOR2D& aDepthRange )
741  {
742  depthRange = aDepthRange;
743  }
744 
748  inline double GetMinDepth() const
749  {
750  return depthRange.x;
751  }
752 
756  inline double GetMaxDepth() const
757  {
758  return depthRange.y;
759  }
760 
766  inline double GetWorldScale() const
767  {
768  return worldScale;
769  }
770 
777  inline void SetFlip( bool xAxis, bool yAxis )
778  {
779  globalFlipX = xAxis;
780  globalFlipY = yAxis;
781  }
782 
786  bool IsFlippedX() const
787  {
788  return globalFlipX;
789  }
790 
794  bool IsFlippedY() const
795  {
796  return globalFlipY;
797  }
798 
799  // ---------------------------
800  // Buffer manipulation methods
801  // ---------------------------
802 
806  virtual void SaveScreen() {};
807 
811  virtual void RestoreScreen() {};
812 
818  virtual void SetTarget( RENDER_TARGET aTarget ) {};
819 
825  virtual RENDER_TARGET GetTarget() const { return TARGET_CACHED; };
826 
832  virtual void ClearTarget( RENDER_TARGET aTarget ) {};
833 
845  virtual void SetNegativeDrawMode( bool aSetting ) {};
846 
847  // -------------
848  // Grid methods
849  // -------------
850 
856  inline void SetGridVisibility( bool aVisibility )
857  {
858  gridVisibility = aVisibility;
859  }
860 
866  inline void SetGridOrigin( const VECTOR2D& aGridOrigin )
867  {
868  gridOrigin = aGridOrigin;
869 
870  if( gridSize.x == 0.0 || gridSize.y == 0.0 )
871  gridOffset = VECTOR2D(0.0, 0.0);
872  else
873  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
874  (long) gridOrigin.y % (long) gridSize.y );
875  }
876 
882  inline void SetGridSize( const VECTOR2D& aGridSize )
883  {
884  gridSize = aGridSize;
885 
886  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
887  (long) gridOrigin.y % (long) gridSize.y );
888  }
889 
895  inline const VECTOR2D& GetGridSize() const
896  {
897  return gridSize;
898  }
899 
905  inline void SetGridColor( const COLOR4D& aGridColor )
906  {
907  gridColor = aGridColor;
908  }
909 
915  inline void SetAxesColor( const COLOR4D& aAxesColor )
916  {
917  axesColor = aAxesColor;
918  }
919 
923  inline void SetAxesEnabled( bool aAxesEnabled )
924  {
925  axesEnabled = aAxesEnabled;
926  }
927 
933  inline void SetCoarseGrid( int aInterval )
934  {
935  gridTick = aInterval;
936  }
937 
943  inline float GetGridLineWidth() const
944  {
945  return gridLineWidth;
946  }
947 
949  virtual void DrawGrid() {};
950 
958  VECTOR2D GetGridPoint( const VECTOR2D& aPoint ) const;
959 
966  inline VECTOR2D ToWorld( const VECTOR2D& aPoint ) const
967  {
968  return VECTOR2D( screenWorldMatrix * aPoint );
969  }
970 
977  inline VECTOR2D ToScreen( const VECTOR2D& aPoint ) const
978  {
979  return VECTOR2D( worldScreenMatrix * aPoint );
980  }
981 
987  inline void SetCursorEnabled( bool aCursorEnabled )
988  {
989  isCursorEnabled = aCursorEnabled;
990  }
991 
996  bool IsCursorEnabled() const
997  {
999  }
1000 
1006  inline void SetCursorColor( const COLOR4D& aCursorColor )
1007  {
1008  cursorColor = aCursorColor;
1009  }
1010 
1016  virtual void DrawCursor( const VECTOR2D& aCursorPosition ) {};
1017 
1022  inline void AdvanceDepth()
1023  {
1024  layerDepth -= 0.05;
1025  }
1026 
1030  inline void PushDepth()
1031  {
1032  depthStack.push( layerDepth );
1033  }
1034 
1038  inline void PopDepth()
1039  {
1040  layerDepth = depthStack.top();
1041  depthStack.pop();
1042  }
1043 
1044  virtual void EnableDepthTest( bool aEnabled = false ) {};
1045 
1046 protected:
1047 
1050 
1051  std::stack<double> depthStack;
1053 
1055  double screenDPI;
1057 
1058  double zoomFactor;
1059  double rotation;
1062  double worldScale;
1063 
1066 
1067  float lineWidth;
1068 
1071 
1075 
1076  double layerDepth;
1078 
1079  // Grid settings
1088  int gridTick;
1091 
1093  // Cursor settings
1099 
1102 
1104  virtual void lockContext( int aClientCookie ) {}
1105 
1106  virtual void unlockContext( int aClientCookie ) {}
1107 
1110  virtual void beginUpdate() {}
1111 
1113  virtual void endUpdate() {}
1114 
1117  virtual void beginDrawing() {};
1118 
1121  virtual void endDrawing() {};
1122 
1124  inline void computeWorldScale()
1125  {
1127  }
1128 
1134  double computeMinGridSpacing() const;
1135 
1137  static const int MIN_DEPTH;
1138  static const int MAX_DEPTH;
1139 
1141  static const int GRID_DEPTH;
1142 
1146  COLOR4D getCursorColor() const;
1147 
1148  // ---------------
1149  // Settings observer interface
1150  // ---------------
1154  void OnGalDisplayOptionsChanged( const GAL_DISPLAY_OPTIONS& aOptions ) override;
1155 
1165  virtual bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions );
1166 
1167 private:
1169  {
1173  bool m_bold;
1174  bool m_italic;
1176  } textProperties;
1177 };
1178 
1179 
1181 {
1182 public:
1184  m_gal( aGal )
1185  {
1186  m_cookie = rand();
1188  }
1189 
1191  {
1193  }
1194 
1195 protected:
1198 };
1199 
1200 
1202 {
1203 public:
1205  GAL_CONTEXT_LOCKER( aGal )
1206  {
1207  m_gal->beginUpdate();
1208  }
1209 
1211  {
1212  m_gal->endUpdate();
1213  }
1214 };
1215 
1216 
1218 {
1219 public:
1221  GAL_CONTEXT_LOCKER( aGal )
1222  {
1223  m_gal->beginDrawing();
1224  }
1225 
1227  {
1228  m_gal->endDrawing();
1229  }
1230 };
1231 
1232 
1233 }; // namespace KIGFX
1234 
1235 #endif /* GRAPHICSABSTRACTIONLAYER_H_ */
const STROKE_FONT & GetStrokeFont() const
static const int GRID_DEPTH
Depth level on which the grid is drawn.
int gridTick
Every tick line gets the double width.
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
Class UTF8 is an 8 bit string that is assuredly encoded in UTF8, and supplies special conversion supp...
Definition: utf8.h:73
virtual void DrawGroup(int aGroupNumber)
Draw the stored group.
void SetFontItalic(const bool aItalic)
Set italic property of current font.
double GetMinDepth() const
Returns the minimum depth in the currently used range (the top).
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
double zoomFactor
The zoom factor.
STROKE_FONT strokeFont
Instance of object that stores information about how to draw texts.
float GetLineWidth() const
Get the line width.
VECTOR2D cursorPosition
Current cursor position (world coordinates)
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a rectangle.
void SetClearColor(const COLOR4D &aColor)
bool axesEnabled
Should the axes be drawn.
EDA_TEXT_HJUSTIFY_T
Definition: eda_text.h:62
GRID_STYLE
GRID_STYLE: Type definition of the grid style.
VECTOR2D gridOffset
The grid offset to compensate cursor position.
double layerDepth
The actual layer depth.
Class CAIRO_GAL is the cairo implementation of the graphics abstraction layer.
Definition: class_module.h:57
virtual void DeleteGroup(int aGroupNumber)
Delete the group from the memory.
double GetMaxDepth() const
Returns the maximum depth in the currently used range (the bottom).
const MATRIX3x3D & GetScreenWorldMatrix() const
Get the screen <-> world transformation matrix.
virtual void BitmapText(const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draws a text using a bitmap font.
bool IsTextMirrored() const
Returns true if text should displayed mirrored.
double computeMinGridSpacing() const
compute minimum grid spacing from the grid settings
bool isCursorEnabled
Is the cursor enabled?
void SetCursorEnabled(bool aCursorEnabled)
Enable/disable cursor.
const COLOR4D & GetFillColor() const
Get the fill color.
bool IsFlippedX() const
Return true if flip flag for the X axis is set.
virtual void SetTextAttributes(const EDA_TEXT *aText)
Loads attributes of the given text (bold/italic/underline/mirrored and so on).
int gridMinSpacing
Minimum screen size of the grid (pixels) below which the grid is not drawn.
VECTOR2D ToScreen(const VECTOR2D &aPoint) const
Compute the point position in screen coordinates from given world coordinates.
GRID_STYLE gridStyle
Grid display style.
virtual void DrawArc(const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle)
Draw an arc.
GAL_DISPLAY_OPTIONS & options
double rotation
Rotation transformation (radians)
EDA_TEXT_VJUSTIFY_T m_verticalJustify
Vertical justification.
virtual void DrawPolygon(const SHAPE_POLY_SET &aPolySet)
void SetFlip(bool xAxis, bool yAxis)
Sets flipping of the screen.
virtual void DrawBitmap(const BITMAP_BASE &aBitmap)
Draw a bitmap image.
COLOR4D fillColor
The fill color.
VECTOR2D depthRange
Range of the depth.
virtual void endUpdate()
Disables item update mode.
virtual void Transform(const MATRIX3x3D &aTransformation)
Transform the context.
MATRIX3x3D screenWorldMatrix
Screen transformation.
bool globalFlipX
Flag for X axis flipping.
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
void SetGridOrigin(const VECTOR2D &aGridOrigin)
Set the origin point for the grid.
VECTOR2D GetTextLineSize(const UTF8 &aText) const
Compute the X and Y size of a given text.
virtual void ComputeWorldScreenMatrix()
Compute the world <-> screen transformation matrix.
EDA_TEXT_HJUSTIFY_T GetHorizontalJustify() const
Returns current text horizontal justification setting.
void SetScreenDPI(double aScreenDPI)
Set the dots per inch of the screen.
virtual void SetLayerDepth(double aLayerDepth)
Set the depth of the layer (position on the z-axis)
VECTOR2D lookAtPoint
Point to be looked at in world space.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
virtual void EndGroup()
End the group.
virtual void Rotate(double aAngle)
Rotate the context.
virtual void DrawCurve(const VECTOR2D &startPoint, const VECTOR2D &controlPointA, const VECTOR2D &controlPointB, const VECTOR2D &endPoint)
Draw a cubic bezier spline.
This class handle bitmap images in KiCad.
Definition: bitmap_base.h:46
const VECTOR2D & GetGlyphSize() const
VECTOR2D GetGridPoint(const VECTOR2D &aPoint) const
Function GetGridPoint() For a given point it returns the nearest point belonging to the grid in world...
bool IsFontBold() const
Returns true if current font has 'bold' attribute enabled.
Class EDA_TEXT is a mix-in class (via multiple inheritance) that handles texts such as labels,...
Definition: eda_text.h:127
virtual void ChangeGroupColor(int aGroupNumber, const COLOR4D &aNewColor)
Changes the color used to draw the group.
static const int MIN_DEPTH
Possible depth range.
virtual RENDER_TARGET GetTarget() const
Gets the currently used target for rendering.
const VECTOR2I & GetScreenPixelSize() const
Returns GAL canvas size in pixels.
GAL(GAL_DISPLAY_OPTIONS &aOptions)
void SetFontBold(const bool aBold)
Set bold property of current font.
void SetGridColor(const COLOR4D &aGridColor)
Set the grid color.
virtual void SaveScreen()
Save the screen contents.
const COLOR4D & GetStrokeColor() const
Get the stroke color.
COLOR4D cursorColor
Cursor color.
virtual void DrawSegment(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth)
Draw a rounded segment.
bool fullscreenCursor
Shape of the cursor (fullscreen or small cross)
void OnGalDisplayOptionsChanged(const GAL_DISPLAY_OPTIONS &aOptions) override
Handler for observer settings changes.
void ResetTextAttributes()
Reset text attributes to default styling.
bool isStrokeEnabled
Are the outlines stroked ?
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
float GetGridLineWidth() const
Get the grid line width.
void PopDepth()
Restores previously stored drawing depth for the depth stack.
Class SHAPE_POLY_SET.
COLOR4D axesColor
Color of the axes.
virtual void StrokeText(const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draws a vector type text using preloaded Newstroke font.
virtual int BeginGroup()
Begin a group.
virtual void beginUpdate()
Enables item update mode.
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
virtual void ClearTarget(RENDER_TARGET aTarget)
Clears the target for rendering.
virtual void unlockContext(int aClientCookie)
void SetScreenSize(const VECTOR2I &aSize)
COLOR4D strokeColor
The color of the outlines.
float gridLineWidth
Line width of the grid.
virtual void DrawGrid()
std::stack< double > depthStack
Stored depth values.
virtual bool IsCairoEngine()
Returns true if the GAL engine is a cairo based type.
double worldUnitLength
The unit length of the world coordinates [inch].
virtual void DrawCursor(const VECTOR2D &aCursorPosition)
Draw the cursor.
double GetZoomFactor() const
Get the zoom factor.
virtual bool IsOpenGlEngine()
Returns true if the GAL engine is a opengl based type.
bool IsFlippedY() const
Return true if flip flag for the Y axis is set.
VECTOR2D gridOrigin
The grid origin.
void SetTextMirrored(const bool aMirrored)
Set a mirrored property of text.
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
void SetCursorColor(const COLOR4D &aCursorColor)
Set the cursor color.
void SetVerticalJustify(const EDA_TEXT_VJUSTIFY_T aVerticalJustify)
Set the vertical justify for text drawing.
const COLOR4D & GetClearColor() const
MATRIX3x3D worldScreenMatrix
World transformation.
virtual void DrawPolyline(const SHAPE_LINE_CHAIN &aLineChain)
void SetAxesEnabled(bool aAxesEnabled)
Enables drawing the axes.
virtual void ResizeScreen(int aWidth, int aHeight)
Resizes the canvas.
void SetGridSize(const VECTOR2D &aGridSize)
Set the grid size.
virtual void DrawPolygon(const SHAPE_LINE_CHAIN &aPolySet)
void SetWorldUnitLength(double aWorldUnitLength)
Set the unit length.
COLOR4D getCursorColor() const
Gets the actual cursor color to draw.
virtual void Flush()
Force all remaining objects to be drawn.
virtual bool updatedGalDisplayOptions(const GAL_DISPLAY_OPTIONS &aOptions)
Function updatedGalDisplayOptions.
virtual void Scale(const VECTOR2D &aScale)
Scale the context.
bool IsFontItalic() const
Returns true if current font has 'italic' attribute enabled.
EDA_TEXT_VJUSTIFY_T
Definition: eda_text.h:69
float lineWidth
The line width.
bool isFillEnabled
Is filling of graphic objects enabled ?
virtual bool Show(bool aShow)
Shows/hides the GAL canvas.
void Draw(const UTF8 &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draw a string.
const VECTOR2D & GetGridSize() const
Returns the grid size.
void computeWorldScale()
Compute the scaling factor for the world->screen matrix.
virtual void ClearScreen()
Clear the screen.
VECTOR2D ToWorld(const VECTOR2D &aPoint) const
Compute the point position in world coordinates from given screen coordinates.
double computeOverbarVerticalPosition() const
Compute the vertical position of an overbar, sometimes used in texts.
const VECTOR2D & GetLookAtPoint() const
Get the look at point.
void SetWorldScreenMatrix(const MATRIX3x3D &aMatrix)
Set the world <-> screen transformation matrix.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
virtual void DrawPolyline(const VECTOR2D aPointList[], int aListSize)
void SetCoarseGrid(int aInterval)
Draw every tick line wider.
virtual void RestoreScreen()
Restore the screen contents.
void PushDepth()
Stores current drawing depth on the depth stack.
COLOR4D gridColor
Color of the grid.
bool gridVisibility
Should the grid be shown.
virtual void Restore()
Restore the context.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
Main rendering target (cached)
Definition: definitions.h:48
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
void SetRotation(double aRotation)
Set the rotation angle.
bool globalFlipY
Flag for Y axis flipping.
EDA_TEXT_VJUSTIFY_T GetVerticalJustify() const
Returns current text vertical justification setting.
Class SHAPE_LINE_CHAIN.
double worldScale
The scale factor world->screen.
VECTOR2D gridSize
The grid size.
VECTOR2I screenSize
Screen size in screen coordinates.
virtual bool IsVisible() const
Returns true if the GAL canvas is visible on the screen.
void SetZoomFactor(double aZoomFactor)
Set the zoom factor of the scene.
virtual void ChangeGroupDepth(int aGroupNumber, int aDepth)
Changes the depth (Z-axis position) of the group.
void SetGridVisibility(bool aVisibility)
Sets the visibility setting of the grid.
void SetGlyphSize(const VECTOR2D aGlyphSize)
Set the font glyph size.
virtual void DrawArcSegment(const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle, double aWidth)
Draw an arc segment.
void SetLookAtPoint(const VECTOR2D &aPoint)
Set the Point in world space to look at.
virtual void lockContext(int aClientCookie)
Private: use GAL_CONTEXT_LOCKER RAII object.
virtual void Save()
Save the context.
void SetHorizontalJustify(const EDA_TEXT_HJUSTIFY_T aHorizontalJustify)
Set the horizontal justify for text drawing.
RENDER_TARGET
RENDER_TARGET: Possible rendering targets.
Definition: definitions.h:46
const MATRIX3x3D & GetWorldScreenMatrix() const
Get the world <-> screen transformation matrix.
VECTOR2D m_glyphSize
Size of the glyphs.
double GetRotation() const
Get the rotation angle.
double GetWorldScale() const
Get the world scale.
virtual void Translate(const VECTOR2D &aTranslation)
Translate the context.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
void SetDepthRange(const VECTOR2D &aDepthRange)
Set the range of the layer depth.
bool IsCursorEnabled() const
Returns information about cursor visibility.
void AdvanceDepth()
Changes the current depth to deeper, so it is possible to draw objects right beneath other.
virtual void beginDrawing()
Begin the drawing, needs to be called for every new frame.
virtual void SetNegativeDrawMode(bool aSetting)
Sets negative draw mode in the renderer.
virtual void DrawPolygon(const VECTOR2D aPointList[], int aListSize)
Class STROKE_FONT implements stroke font drawing.
Definition: stroke_font.h:53
bool forceDisplayCursor
Always show cursor.
virtual void ClearCache()
Delete all data created during caching of graphic items.
double GetOverbarVerticalPosition() const
Compute the vertical position of an overbar, sometimes used in texts.
virtual bool IsInitialized() const
Returns the initalization status for the canvas.
virtual void endDrawing()
End the drawing, needs to be called for every new frame.
EDA_TEXT_HJUSTIFY_T m_horizontalJustify
Horizontal justification.
virtual void SetTarget(RENDER_TARGET aTarget)
Sets the target for rendering.
Class GAL is the abstract interface for drawing on a 2D-surface.
double screenDPI
The dots per inch of the screen.
static const int MAX_DEPTH
virtual void EnableDepthTest(bool aEnabled=false)
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39