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 
186  virtual void DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
187  const VECTOR2D& controlPointB, const VECTOR2D& endPoint,
188  double aFilterValue = 0.0 ) {};
189 
193  virtual void DrawBitmap( const BITMAP_BASE& aBitmap ) {};
194 
195  // --------------
196  // Screen methods
197  // --------------
198 
200  virtual void ResizeScreen( int aWidth, int aHeight ) {};
201 
203  virtual bool Show( bool aShow ) { return true; };
204 
207  {
208  return screenSize;
209  }
210 
212  virtual void Flush() {};
213 
214  void SetClearColor( const COLOR4D& aColor )
215  {
216  m_clearColor = aColor;
217  }
218 
219  const COLOR4D& GetClearColor( ) const
220  {
221  return m_clearColor;
222  }
223 
228  virtual void ClearScreen() {};
229 
230  // -----------------
231  // Attribute setting
232  // -----------------
233 
239  virtual void SetIsFill( bool aIsFillEnabled )
240  {
241  isFillEnabled = aIsFillEnabled;
242  }
243 
249  virtual void SetIsStroke( bool aIsStrokeEnabled )
250  {
251  isStrokeEnabled = aIsStrokeEnabled;
252  }
253 
259  virtual void SetFillColor( const COLOR4D& aColor )
260  {
261  fillColor = aColor;
262  }
263 
269  inline const COLOR4D& GetFillColor() const
270  {
271  return fillColor;
272  }
273 
279  virtual void SetStrokeColor( const COLOR4D& aColor )
280  {
281  strokeColor = aColor;
282  }
283 
289  inline const COLOR4D& GetStrokeColor() const
290  {
291  return strokeColor;
292  }
293 
299  virtual void SetLineWidth( float aLineWidth )
300  {
301  lineWidth = aLineWidth;
302  }
303 
309  inline float GetLineWidth() const
310  {
311  return lineWidth;
312  }
313 
319  virtual void SetLayerDepth( double aLayerDepth )
320  {
321  assert( aLayerDepth <= depthRange.y );
322  assert( aLayerDepth >= depthRange.x );
323 
324  layerDepth = aLayerDepth;
325  }
326 
327  // ----
328  // Text
329  // ----
330 
331  const STROKE_FONT& GetStrokeFont() const
332  {
333  return strokeFont;
334  }
335 
343  virtual void StrokeText( const wxString& aText, const VECTOR2D& aPosition,
344  double aRotationAngle )
345  {
346  strokeFont.Draw( aText, aPosition, aRotationAngle );
347  }
348 
357  virtual void BitmapText( const wxString& aText, const VECTOR2D& aPosition,
358  double aRotationAngle )
359  {
360  // Fallback: use stroke font
361 
362  // Handle flipped view
363  if( globalFlipX )
365 
366  StrokeText( aText, aPosition, aRotationAngle );
367 
368  if( globalFlipX )
370  }
371 
379  VECTOR2D GetTextLineSize( const UTF8& aText ) const;
380 
386  virtual void SetTextAttributes( const EDA_TEXT* aText );
387 
394  void ResetTextAttributes();
395 
401  inline void SetGlyphSize( const VECTOR2D aSize ) { textProperties.m_glyphSize = aSize; }
402  const VECTOR2D& GetGlyphSize() const { return textProperties.m_glyphSize; }
403 
409  inline void SetFontBold( const bool aBold ) { textProperties.m_bold = aBold; }
410  inline bool IsFontBold() const { return textProperties.m_bold; }
411 
417  inline void SetFontItalic( bool aItalic ) { textProperties.m_italic = aItalic; }
418  inline bool IsFontItalic() const { return textProperties.m_italic; }
419 
420  inline void SetFontUnderlined( bool aUnderlined ) { textProperties.m_underlined = aUnderlined; }
421  inline bool IsFontUnderlined() const { return textProperties.m_underlined; }
422 
428  inline void SetTextMirrored( const bool aMirrored ) { textProperties.m_mirrored = aMirrored; }
429  inline bool IsTextMirrored() const { return textProperties.m_mirrored; }
430 
436  inline void SetHorizontalJustify( const EDA_TEXT_HJUSTIFY_T aHorizontalJustify )
437  {
438  textProperties.m_horizontalJustify = aHorizontalJustify;
439  }
440 
445  {
447  }
448 
454  inline void SetVerticalJustify( const EDA_TEXT_VJUSTIFY_T aVerticalJustify )
455  {
456  textProperties.m_verticalJustify = aVerticalJustify;
457  }
458 
463  {
465  }
466 
467 
468  // --------------
469  // Transformation
470  // --------------
471 
477  virtual void Transform( const MATRIX3x3D& aTransformation ) {};
478 
484  virtual void Rotate( double aAngle ) {};
485 
491  virtual void Translate( const VECTOR2D& aTranslation ) {};
492 
498  virtual void Scale( const VECTOR2D& aScale ) {};
499 
501  virtual void Save() {};
502 
504  virtual void Restore() {};
505 
506  // --------------------------------------------
507  // Group methods
508  // ---------------------------------------------
509 
518  virtual int BeginGroup() { return 0; };
519 
521  virtual void EndGroup() {};
522 
528  virtual void DrawGroup( int aGroupNumber ) {};
529 
536  virtual void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) {};
537 
544  virtual void ChangeGroupDepth( int aGroupNumber, int aDepth ) {};
545 
551  virtual void DeleteGroup( int aGroupNumber ) {};
552 
556  virtual void ClearCache() {};
557 
558  // --------------------------------------------------------
559  // Handling the world <-> screen transformation
560  // --------------------------------------------------------
561 
563  virtual void ComputeWorldScreenMatrix();
564 
571  {
572  return worldScreenMatrix;
573  }
574 
581  {
582  return screenWorldMatrix;
583  }
584 
590  inline void SetWorldScreenMatrix( const MATRIX3x3D& aMatrix )
591  {
592  worldScreenMatrix = aMatrix;
593  }
594 
604  inline void SetWorldUnitLength( double aWorldUnitLength )
605  {
606  worldUnitLength = aWorldUnitLength;
607  }
608 
609  inline void SetScreenSize( const VECTOR2I& aSize )
610  {
611  screenSize = aSize;
612  }
613 
622  inline void SetScreenDPI( double aScreenDPI )
623  {
624  screenDPI = aScreenDPI;
625  }
626 
634  inline void SetLookAtPoint( const VECTOR2D& aPoint )
635  {
636  lookAtPoint = aPoint;
637  }
638 
644  inline const VECTOR2D& GetLookAtPoint() const
645  {
646  return lookAtPoint;
647  }
648 
654  inline void SetZoomFactor( double aZoomFactor )
655  {
656  zoomFactor = aZoomFactor;
657  }
658 
664  inline double GetZoomFactor() const
665  {
666  return zoomFactor;
667  }
668 
674  void SetRotation( double aRotation )
675  {
676  rotation = aRotation;
677  }
678 
684  double GetRotation() const
685  {
686  return rotation;
687  }
688 
697  inline void SetDepthRange( const VECTOR2D& aDepthRange )
698  {
699  depthRange = aDepthRange;
700  }
701 
705  inline double GetMinDepth() const
706  {
707  return depthRange.x;
708  }
709 
713  inline double GetMaxDepth() const
714  {
715  return depthRange.y;
716  }
717 
723  inline double GetWorldScale() const
724  {
725  return worldScale;
726  }
727 
734  inline void SetFlip( bool xAxis, bool yAxis )
735  {
736  globalFlipX = xAxis;
737  globalFlipY = yAxis;
738  }
739 
743  bool IsFlippedX() const
744  {
745  return globalFlipX;
746  }
747 
751  bool IsFlippedY() const
752  {
753  return globalFlipY;
754  }
755 
756  // ---------------------------
757  // Buffer manipulation methods
758  // ---------------------------
759 
765  virtual void SetTarget( RENDER_TARGET aTarget ) {};
766 
772  virtual RENDER_TARGET GetTarget() const { return TARGET_CACHED; };
773 
779  virtual void ClearTarget( RENDER_TARGET aTarget ) {};
780 
786  virtual bool HasTarget( RENDER_TARGET aTarget )
787  {
788  return true;
789  };
790 
802  virtual void SetNegativeDrawMode( bool aSetting ) {};
803 
804  // -------------
805  // Grid methods
806  // -------------
807 
813  void SetGridVisibility( bool aVisibility ) { gridVisibility = aVisibility; }
814 
815  bool GetGridVisibility() const { return gridVisibility; }
816 
817  bool GetGridSnapping() const
818  {
821  }
827  inline void SetGridOrigin( const VECTOR2D& aGridOrigin )
828  {
829  gridOrigin = aGridOrigin;
830 
831  if( gridSize.x == 0.0 || gridSize.y == 0.0 )
832  gridOffset = VECTOR2D(0.0, 0.0);
833  else
834  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
835  (long) gridOrigin.y % (long) gridSize.y );
836  }
837 
838  inline const VECTOR2D& GetGridOrigin() const
839  {
840  return gridOrigin;
841  }
842 
848  inline void SetGridSize( const VECTOR2D& aGridSize )
849  {
850  gridSize = aGridSize;
851 
852  // Avoid stupid grid size values: a grid size should be >= 1 in internal units
853  gridSize.x = std::max( 1.0, gridSize.x );
854  gridSize.y = std::max( 1.0, gridSize.y );
855 
856  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
857  (long) gridOrigin.y % (long) gridSize.y );
858  }
859 
865  inline const VECTOR2D& GetGridSize() const
866  {
867  return gridSize;
868  }
869 
875  inline void SetGridColor( const COLOR4D& aGridColor )
876  {
877  gridColor = aGridColor;
878  }
879 
885  inline void SetAxesColor( const COLOR4D& aAxesColor )
886  {
887  axesColor = aAxesColor;
888  }
889 
893  inline void SetAxesEnabled( bool aAxesEnabled )
894  {
895  axesEnabled = aAxesEnabled;
896  }
897 
903  inline void SetCoarseGrid( int aInterval )
904  {
905  gridTick = aInterval;
906  }
907 
913  inline float GetGridLineWidth() const
914  {
915  return gridLineWidth;
916  }
917 
919  virtual void DrawGrid() {};
920 
928  VECTOR2D GetGridPoint( const VECTOR2D& aPoint ) const;
929 
936  inline VECTOR2D ToWorld( const VECTOR2D& aPoint ) const
937  {
938  return VECTOR2D( screenWorldMatrix * aPoint );
939  }
940 
947  inline VECTOR2D ToScreen( const VECTOR2D& aPoint ) const
948  {
949  return VECTOR2D( worldScreenMatrix * aPoint );
950  }
951 
957  inline void SetCursorEnabled( bool aCursorEnabled )
958  {
959  isCursorEnabled = aCursorEnabled;
960  }
961 
966  bool IsCursorEnabled() const
967  {
969  }
970 
976  inline void SetCursorColor( const COLOR4D& aCursorColor )
977  {
978  cursorColor = aCursorColor;
979  }
980 
986  virtual void DrawCursor( const VECTOR2D& aCursorPosition ) {};
987 
992  inline void AdvanceDepth()
993  {
994  layerDepth -= 0.05;
995  }
996 
1000  inline void PushDepth()
1001  {
1002  depthStack.push( layerDepth );
1003  }
1004 
1008  inline void PopDepth()
1009  {
1010  layerDepth = depthStack.top();
1011  depthStack.pop();
1012  }
1013 
1014  virtual void EnableDepthTest( bool aEnabled = false ) {};
1015 
1016 protected:
1017 
1020 
1021  std::stack<double> depthStack;
1023 
1025  double screenDPI;
1027 
1028  double zoomFactor;
1029  double rotation;
1032  double worldScale;
1033 
1036 
1037  float lineWidth;
1038 
1041 
1045 
1046  double layerDepth;
1048 
1049  // Grid settings
1058  int gridTick;
1061 
1063  // Cursor settings
1069 
1072 
1074  virtual void lockContext( int aClientCookie ) {}
1075 
1076  virtual void unlockContext( int aClientCookie ) {}
1077 
1080  virtual void beginUpdate() {}
1081 
1083  virtual void endUpdate() {}
1084 
1087  virtual void beginDrawing() {};
1088 
1091  virtual void endDrawing() {};
1092 
1094  inline void computeWorldScale()
1095  {
1097  }
1098 
1104  double computeMinGridSpacing() const;
1105 
1107  static const int MIN_DEPTH;
1108  static const int MAX_DEPTH;
1109 
1111  static const int GRID_DEPTH;
1112 
1116  COLOR4D getCursorColor() const;
1117 
1118  // ---------------
1119  // Settings observer interface
1120  // ---------------
1124  void OnGalDisplayOptionsChanged( const GAL_DISPLAY_OPTIONS& aOptions ) override;
1125 
1135  virtual bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions );
1136 
1137 private:
1139  {
1143  bool m_bold;
1144  bool m_italic;
1147  } textProperties;
1148 };
1149 
1150 
1152 {
1153 public:
1155  m_gal( aGal )
1156  {
1157  m_cookie = rand();
1159  }
1160 
1162  {
1164  }
1165 
1166 protected:
1169 };
1170 
1171 
1173 {
1174 public:
1176  GAL_CONTEXT_LOCKER( aGal )
1177  {
1178  m_gal->beginUpdate();
1179  }
1180 
1182  {
1183  m_gal->endUpdate();
1184  }
1185 };
1186 
1187 
1189 {
1190 public:
1192  GAL_CONTEXT_LOCKER( aGal )
1193  {
1194  m_gal->beginDrawing();
1195  }
1196 
1198  {
1199  m_gal->endDrawing();
1200  }
1201 };
1202 
1203 
1204 }; // namespace KIGFX
1205 
1206 #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.
UTF8 is an 8 bit string that is assuredly encoded in UTF8, and supplies special conversion support to...
Definition: utf8.h:73
virtual void DrawGroup(int aGroupNumber)
Draw the stored group.
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:61
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: color4d.cpp:175
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
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.
virtual bool HasTarget(RENDER_TARGET aTarget)
Returns true if the target exists.
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.
This class handle bitmap images in KiCad.
Definition: bitmap_base.h:51
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...
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
Definition: eda_text.h:119
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.
bool GetGridSnapping() const
GRID_SNAPPING m_gridSnapping
Snapping options for the grid
bool IsFontUnderlined() const
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:593
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.
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.
void SetFontItalic(bool aItalic)
Set italic property of current font.
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.
EDA_TEXT_VJUSTIFY_T
Definition: eda_text.h:68
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.
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.
void SetGlyphSize(const VECTOR2D aSize)
Set the font glyph size.
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.
void SetFontUnderlined(bool aUnderlined)
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.
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.
const VECTOR2D & GetGridOrigin() const
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.
bool GetGridVisibility() const
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 DrawCurve(const VECTOR2D &startPoint, const VECTOR2D &controlPointA, const VECTOR2D &controlPointB, const VECTOR2D &endPoint, double aFilterValue=0.0)
Draw a cubic bezier spline.
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.
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)
COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:100