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 
78  // ---------------
79  // Drawing methods
80  // ---------------
81 
90  virtual void DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
91 
101  virtual void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint, double aWidth ) {};
102 
108  virtual void DrawPolyline( const std::deque<VECTOR2D>& aPointList ) {};
109  virtual void DrawPolyline( const VECTOR2D aPointList[], int aListSize ) {};
110  virtual void DrawPolyline( const SHAPE_LINE_CHAIN& aLineChain ) {};
111 
118  virtual void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) {};
119 
128  virtual void
129  DrawArc( const VECTOR2D& aCenterPoint, double aRadius, double aStartAngle, double aEndAngle ) {};
130 
145  virtual void
146  DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, double aStartAngle,
147  double aEndAngle, double aWidth ) {};
148 
155  virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
156 
162  virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) {};
163  virtual void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) {};
164  virtual void DrawPolygon( const SHAPE_POLY_SET& aPolySet ) {};
165 
174  virtual void DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
175  const VECTOR2D& controlPointB, const VECTOR2D& endPoint ) {};
176 
180  virtual void DrawBitmap( const BITMAP_BASE& aBitmap ) {};
181 
182  // --------------
183  // Screen methods
184  // --------------
185 
187  virtual void ResizeScreen( int aWidth, int aHeight ) {};
188 
190  virtual bool Show( bool aShow ) { return true; };
191 
194  {
195  return screenSize;
196  }
197 
199  virtual void Flush() {};
200 
201  void SetClearColor( const COLOR4D& aColor )
202  {
203  m_clearColor = aColor;
204  }
205 
206  const COLOR4D& GetClearColor( ) const
207  {
208  return m_clearColor;
209  }
210 
215  virtual void ClearScreen() {};
216 
217  // -----------------
218  // Attribute setting
219  // -----------------
220 
226  virtual void SetIsFill( bool aIsFillEnabled )
227  {
228  isFillEnabled = aIsFillEnabled;
229  }
230 
236  virtual void SetIsStroke( bool aIsStrokeEnabled )
237  {
238  isStrokeEnabled = aIsStrokeEnabled;
239  }
240 
246  virtual void SetFillColor( const COLOR4D& aColor )
247  {
248  fillColor = aColor;
249  }
250 
256  inline const COLOR4D& GetFillColor() const
257  {
258  return fillColor;
259  }
260 
266  virtual void SetStrokeColor( const COLOR4D& aColor )
267  {
268  strokeColor = aColor;
269  }
270 
276  inline const COLOR4D& GetStrokeColor() const
277  {
278  return strokeColor;
279  }
280 
286  virtual void SetLineWidth( float aLineWidth )
287  {
288  lineWidth = aLineWidth;
289  }
290 
296  inline float GetLineWidth() const
297  {
298  return lineWidth;
299  }
300 
306  virtual void SetLayerDepth( double aLayerDepth )
307  {
308  assert( aLayerDepth <= depthRange.y );
309  assert( aLayerDepth >= depthRange.x );
310 
311  layerDepth = aLayerDepth;
312  }
313 
314  // ----
315  // Text
316  // ----
317 
318  const STROKE_FONT& GetStrokeFont() const
319  {
320  return strokeFont;
321  }
322 
330  virtual void StrokeText( const wxString& aText, const VECTOR2D& aPosition,
331  double aRotationAngle )
332  {
333  strokeFont.Draw( aText, aPosition, aRotationAngle );
334  }
335 
344  virtual void BitmapText( const wxString& aText, const VECTOR2D& aPosition,
345  double aRotationAngle )
346  {
347  // Fallback: use stroke font
348 
349  // Handle flipped view
350  if( globalFlipX )
352 
353  StrokeText( aText, aPosition, aRotationAngle );
354 
355  if( globalFlipX )
357  }
358 
366  VECTOR2D GetTextLineSize( const UTF8& aText ) const;
367 
374  {
376  }
377 
383  virtual void SetTextAttributes( const EDA_TEXT* aText );
384 
391  void ResetTextAttributes();
392 
398  inline void SetGlyphSize( const VECTOR2D aGlyphSize )
399  {
400  textProperties.m_glyphSize = aGlyphSize;
401  }
402 
406  const VECTOR2D& GetGlyphSize() const
407  {
409  }
410 
416  inline void SetFontBold( const bool aBold )
417  {
418  textProperties.m_bold = aBold;
419  }
420 
424  inline bool IsFontBold() const
425  {
426  return textProperties.m_bold;
427  }
428 
434  inline void SetFontItalic( const bool aItalic )
435  {
436  textProperties.m_italic = aItalic;
437  }
438 
442  inline bool IsFontItalic() const
443  {
444  return textProperties.m_italic;
445  }
446 
452  inline void SetTextMirrored( const bool aMirrored )
453  {
454  textProperties.m_mirrored = aMirrored;
455  }
456 
460  inline bool IsTextMirrored() const
461  {
462  return textProperties.m_mirrored;
463  }
464 
470  inline void SetHorizontalJustify( const EDA_TEXT_HJUSTIFY_T aHorizontalJustify )
471  {
472  textProperties.m_horizontalJustify = aHorizontalJustify;
473  }
474 
479  {
481  }
482 
488  inline void SetVerticalJustify( const EDA_TEXT_VJUSTIFY_T aVerticalJustify )
489  {
490  textProperties.m_verticalJustify = aVerticalJustify;
491  }
492 
497  {
499  }
500 
501 
502  // --------------
503  // Transformation
504  // --------------
505 
511  virtual void Transform( const MATRIX3x3D& aTransformation ) {};
512 
518  virtual void Rotate( double aAngle ) {};
519 
525  virtual void Translate( const VECTOR2D& aTranslation ) {};
526 
532  virtual void Scale( const VECTOR2D& aScale ) {};
533 
535  virtual void Save() {};
536 
538  virtual void Restore() {};
539 
540  // --------------------------------------------
541  // Group methods
542  // ---------------------------------------------
543 
552  virtual int BeginGroup() { return 0; };
553 
555  virtual void EndGroup() {};
556 
562  virtual void DrawGroup( int aGroupNumber ) {};
563 
570  virtual void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) {};
571 
578  virtual void ChangeGroupDepth( int aGroupNumber, int aDepth ) {};
579 
585  virtual void DeleteGroup( int aGroupNumber ) {};
586 
590  virtual void ClearCache() {};
591 
592  // --------------------------------------------------------
593  // Handling the world <-> screen transformation
594  // --------------------------------------------------------
595 
597  virtual void ComputeWorldScreenMatrix();
598 
605  {
606  return worldScreenMatrix;
607  }
608 
615  {
616  return screenWorldMatrix;
617  }
618 
624  inline void SetWorldScreenMatrix( const MATRIX3x3D& aMatrix )
625  {
626  worldScreenMatrix = aMatrix;
627  }
628 
638  inline void SetWorldUnitLength( double aWorldUnitLength )
639  {
640  worldUnitLength = aWorldUnitLength;
641  }
642 
643  inline void SetScreenSize( const VECTOR2I& aSize )
644  {
645  screenSize = aSize;
646  }
647 
656  inline void SetScreenDPI( double aScreenDPI )
657  {
658  screenDPI = aScreenDPI;
659  }
660 
668  inline void SetLookAtPoint( const VECTOR2D& aPoint )
669  {
670  lookAtPoint = aPoint;
671  }
672 
678  inline const VECTOR2D& GetLookAtPoint() const
679  {
680  return lookAtPoint;
681  }
682 
688  inline void SetZoomFactor( double aZoomFactor )
689  {
690  zoomFactor = aZoomFactor;
691  }
692 
698  inline double GetZoomFactor() const
699  {
700  return zoomFactor;
701  }
702 
708  void SetRotation( double aRotation )
709  {
710  rotation = aRotation;
711  }
712 
718  double GetRotation() const
719  {
720  return rotation;
721  }
722 
731  inline void SetDepthRange( const VECTOR2D& aDepthRange )
732  {
733  depthRange = aDepthRange;
734  }
735 
739  inline double GetMinDepth() const
740  {
741  return depthRange.x;
742  }
743 
747  inline double GetMaxDepth() const
748  {
749  return depthRange.y;
750  }
751 
757  inline double GetWorldScale() const
758  {
759  return worldScale;
760  }
761 
768  inline void SetFlip( bool xAxis, bool yAxis )
769  {
770  globalFlipX = xAxis;
771  globalFlipY = yAxis;
772  }
773 
777  bool IsFlippedX() const
778  {
779  return globalFlipX;
780  }
781 
785  bool IsFlippedY() const
786  {
787  return globalFlipY;
788  }
789 
790  // ---------------------------
791  // Buffer manipulation methods
792  // ---------------------------
793 
797  virtual void SaveScreen() {};
798 
802  virtual void RestoreScreen() {};
803 
809  virtual void SetTarget( RENDER_TARGET aTarget ) {};
810 
816  virtual RENDER_TARGET GetTarget() const { return TARGET_CACHED; };
817 
823  virtual void ClearTarget( RENDER_TARGET aTarget ) {};
824 
836  virtual void SetNegativeDrawMode( bool aSetting ) {};
837 
838  // -------------
839  // Grid methods
840  // -------------
841 
847  inline void SetGridVisibility( bool aVisibility )
848  {
849  gridVisibility = aVisibility;
850  }
851 
857  inline void SetGridOrigin( const VECTOR2D& aGridOrigin )
858  {
859  gridOrigin = aGridOrigin;
860 
861  if( gridSize.x == 0.0 || gridSize.y == 0.0 )
862  gridOffset = VECTOR2D(0.0, 0.0);
863  else
864  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
865  (long) gridOrigin.y % (long) gridSize.y );
866  }
867 
873  inline void SetGridSize( const VECTOR2D& aGridSize )
874  {
875  gridSize = aGridSize;
876 
877  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
878  (long) gridOrigin.y % (long) gridSize.y );
879  }
880 
886  inline const VECTOR2D& GetGridSize() const
887  {
888  return gridSize;
889  }
890 
896  inline void SetGridColor( const COLOR4D& aGridColor )
897  {
898  gridColor = aGridColor;
899  }
900 
906  inline void SetAxesColor( const COLOR4D& aAxesColor )
907  {
908  axesColor = aAxesColor;
909  }
910 
914  inline void SetAxesEnabled( bool aAxesEnabled )
915  {
916  axesEnabled = aAxesEnabled;
917  }
918 
924  inline void SetCoarseGrid( int aInterval )
925  {
926  gridTick = aInterval;
927  }
928 
934  inline float GetGridLineWidth() const
935  {
936  return gridLineWidth;
937  }
938 
940  virtual void DrawGrid();
941 
949  VECTOR2D GetGridPoint( const VECTOR2D& aPoint ) const;
950 
957  inline VECTOR2D ToWorld( const VECTOR2D& aPoint ) const
958  {
959  return VECTOR2D( screenWorldMatrix * aPoint );
960  }
961 
968  inline VECTOR2D ToScreen( const VECTOR2D& aPoint ) const
969  {
970  return VECTOR2D( worldScreenMatrix * aPoint );
971  }
972 
978  inline void SetCursorEnabled( bool aCursorEnabled )
979  {
980  isCursorEnabled = aCursorEnabled;
981  }
982 
987  bool IsCursorEnabled() const
988  {
990  }
991 
997  inline void SetCursorColor( const COLOR4D& aCursorColor )
998  {
999  cursorColor = aCursorColor;
1000  }
1001 
1007  virtual void DrawCursor( const VECTOR2D& aCursorPosition ) {};
1008 
1013  inline void AdvanceDepth()
1014  {
1015  layerDepth -= 0.05;
1016  }
1017 
1021  inline void PushDepth()
1022  {
1023  depthStack.push( layerDepth );
1024  }
1025 
1029  inline void PopDepth()
1030  {
1031  layerDepth = depthStack.top();
1032  depthStack.pop();
1033  }
1034 
1035  virtual void EnableDepthTest( bool aEnabled = false ) {};
1036 
1037 protected:
1038 
1041 
1042  std::stack<double> depthStack;
1044 
1046  double screenDPI;
1048 
1049  double zoomFactor;
1050  double rotation;
1053  double worldScale;
1054 
1057 
1058  float lineWidth;
1059 
1062 
1066 
1067  double layerDepth;
1069 
1070  // Grid settings
1079  int gridTick;
1082 
1084  // Cursor settings
1090 
1093 
1095  virtual void lockContext( int aClientCookie ) {}
1096 
1097  virtual void unlockContext( int aClientCookie ) {}
1098 
1101  virtual void beginUpdate() {}
1102 
1104  virtual void endUpdate() {}
1105 
1108  virtual void beginDrawing() {};
1109 
1112  virtual void endDrawing() {};
1113 
1115  inline void computeWorldScale()
1116  {
1117  worldScale = screenDPI * worldUnitLength * zoomFactor;
1118  }
1119 
1125  double computeMinGridSpacing() const;
1126 
1133  virtual void drawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
1134 
1136  static const int MIN_DEPTH;
1137  static const int MAX_DEPTH;
1138 
1140  static const int GRID_DEPTH;
1141 
1145  COLOR4D getCursorColor() const;
1146 
1147  // ---------------
1148  // Settings observer interface
1149  // ---------------
1153  void OnGalDisplayOptionsChanged( const GAL_DISPLAY_OPTIONS& aOptions ) override;
1154 
1164  virtual bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions );
1165 
1166 private:
1168  {
1172  bool m_bold;
1173  bool m_italic;
1175  } textProperties;
1176 };
1177 
1178 
1180 {
1181 public:
1183  m_gal( aGal )
1184  {
1185  m_cookie = rand();
1186  m_gal->lockContext( m_cookie );
1187  }
1188 
1190  {
1191  m_gal->unlockContext( m_cookie );
1192  }
1193 
1194 protected:
1197 };
1198 
1199 
1201 {
1202 public:
1204  GAL_CONTEXT_LOCKER( aGal )
1205  {
1206  m_gal->beginUpdate();
1207  }
1208 
1210  {
1211  m_gal->endUpdate();
1212  }
1213 };
1214 
1215 
1217 {
1218 public:
1220  GAL_CONTEXT_LOCKER( aGal )
1221  {
1222  m_gal->beginDrawing();
1223  }
1224 
1226  {
1227  m_gal->endDrawing();
1228  }
1229 };
1230 
1231 
1232 }; // namespace KIGFX
1233 
1234 #endif /* GRAPHICSABSTRACTIONLAYER_H_ */
double computeMinGridSpacing() const
compute minimum grid spacing from the grid settings
static const int GRID_DEPTH
Depth level on which the grid is drawn.
bool IsCursorEnabled() const
Returns information about cursor visibility.
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.
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
EDA_TEXT_HJUSTIFY_T GetHorizontalJustify() const
Returns current text horizontal justification setting.
double zoomFactor
The zoom factor.
STROKE_FONT strokeFont
Instance of object that stores information about how to draw texts.
VECTOR2D cursorPosition
Current cursor position (world coordinates)
const COLOR4D & GetStrokeColor() const
Get the stroke color.
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
EDA_TEXT_VJUSTIFY_T GetVerticalJustify() const
Returns current text vertical justification setting.
GRID_STYLE
GRID_STYLE: Type definition of the grid style.
VECTOR2D gridOffset
The grid offset to compensate cursor position.
double computeOverbarVerticalPosition() const
Compute the vertical position of an overbar, sometimes used in texts.
double layerDepth
The actual layer depth.
Class CAIRO_GAL is the cairo implementation of the graphics abstraction layer.
Definition: class_module.h:58
virtual void DeleteGroup(int aGroupNumber)
Delete the group from the memory.
virtual void BitmapText(const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draws a text using a bitmap font.
double GetWorldScale() const
Get the world scale.
bool isCursorEnabled
Is the cursor enabled?
void SetCursorEnabled(bool aCursorEnabled)
Enable/disable cursor.
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.
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.
const MATRIX3x3D & GetScreenWorldMatrix() const
Get the screen <-> world transformation matrix.
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.
double GetRotation() const
Get the rotation angle.
virtual bool IsVisible() const
Returns true if the GAL canvas is visible on the screen.
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.
virtual bool IsInitialized() const
Returns the initalization status for the canvas.
virtual void ComputeWorldScreenMatrix()
Compute the world <-> screen transformation matrix.
void SetScreenDPI(double aScreenDPI)
Set the dots per inch of the screen.
const VECTOR2D & GetLookAtPoint() const
Get the look at point.
virtual void SetLayerDepth(double aLayerDepth)
Set the depth of the layer (position on the z-axis)
virtual void drawGridLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a grid line (usually a simplified line function).
const MATRIX3x3D & GetWorldScreenMatrix() const
Get the world <-> screen transformation matrix.
VECTOR2D lookAtPoint
Point to be looked at in world space.
VECTOR2D ToScreen(const VECTOR2D &aPoint) const
Compute the point position in screen coordinates from given world coordinates.
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
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.
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.
bool IsFlippedY() const
Return true if flip flag for the Y axis is set.
COLOR4D cursorColor
Cursor color.
bool IsFontBold() const
Returns true if current font has &#39;bold&#39; attribute enabled.
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
COLOR4D getCursorColor() const
Gets the actual cursor color to draw.
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
void PopDepth()
Restores previously stored drawing depth for the depth stack.
float GetGridLineWidth() const
Get the grid line width.
Class SHAPE_POLY_SET.
bool IsFlippedX() const
Return true if flip flag for the X axis is 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.
std::stack< double > depthStack
Stored depth values.
double worldUnitLength
The unit length of the world coordinates [inch].
virtual void DrawCursor(const VECTOR2D &aCursorPosition)
Draw the cursor.
const VECTOR2D & GetGlyphSize() const
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.
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.
void SetWorldUnitLength(double aWorldUnitLength)
Set the unit length.
const COLOR4D & GetFillColor() const
Get the fill color.
const COLOR4D & GetClearColor() const
virtual void Flush()
Force all remaining objects to be drawn.
virtual bool updatedGalDisplayOptions(const GAL_DISPLAY_OPTIONS &aOptions)
Function updatedGalDisplayOptions.
virtual void DrawGrid()
>
virtual void Scale(const VECTOR2D &aScale)
Scale the context.
const VECTOR2D & GetGridSize() const
Returns the grid size.
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.
const VECTOR2I & GetScreenPixelSize() const
Returns GAL canvas size in pixels.
void Draw(const UTF8 &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draw a string.
void computeWorldScale()
Compute the scaling factor for the world->screen matrix.
virtual void ClearScreen()
Clear the screen.
VECTOR2D GetGridPoint(const VECTOR2D &aPoint) const
Function GetGridPoint() For a given point it returns the nearest point belonging to the grid in world...
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:41
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.
Class SHAPE_LINE_CHAIN.
double worldScale
The scale factor world->screen.
double GetOverbarVerticalPosition() const
Compute the vertical position of an overbar, sometimes used in texts.
VECTOR2D gridSize
The grid size.
VECTOR2I screenSize
Screen size in screen coordinates.
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.
double GetZoomFactor() const
Get the zoom factor.
void SetGridVisibility(bool aVisibility)
Sets the visibility setting of the grid.
bool IsFontItalic() const
Returns true if current font has &#39;italic&#39; attribute enabled.
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.
double GetMinDepth() const
Returns the minimum depth in the currently used range (the top).
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.
const STROKE_FONT & GetStrokeFont() const
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:39
virtual RENDER_TARGET GetTarget() const
Gets the currently used target for rendering.
float GetLineWidth() const
Get the line width.
bool IsTextMirrored() const
Returns true if text should displayed mirrored.
VECTOR2D m_glyphSize
Size of the glyphs.
double GetMaxDepth() const
Returns the maximum depth in the currently used range (the bottom).
virtual void Translate(const VECTOR2D &aTranslation)
Translate the context.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
VECTOR2D GetTextLineSize(const UTF8 &aText) const
Compute the X and Y size of a given text.
void SetDepthRange(const VECTOR2D &aDepthRange)
Set the range of the layer depth.
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
VECTOR2D ToWorld(const VECTOR2D &aPoint) const
Compute the point position in world coordinates from given screen coordinates.
bool forceDisplayCursor
Always show cursor.
virtual void ClearCache()
Delete all data created during caching of graphic items.
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