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 
45 namespace KIGFX
46 {
47 
59 {
60 public:
61  // Constructor / Destructor
62  GAL( GAL_DISPLAY_OPTIONS& aOptions );
63  virtual ~GAL();
64 
66  virtual bool IsInitialized() const { return true; }
67 
69  virtual bool IsVisible() const { return true; }
70 
71  // ---------------
72  // Drawing methods
73  // ---------------
74 
76  virtual void BeginDrawing() {};
77 
79  virtual void EndDrawing() {};
80 
82  virtual void BeginUpdate() {}
83 
85  virtual void EndUpdate() {}
86 
95  virtual void DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
96 
106  virtual void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint, double aWidth ) {};
107 
113  virtual void DrawPolyline( const std::deque<VECTOR2D>& aPointList ) {};
114  virtual void DrawPolyline( const VECTOR2D aPointList[], int aListSize ) {};
115  virtual void DrawPolyline( const SHAPE_LINE_CHAIN& aLineChain ) {};
116 
123  virtual void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) {};
124 
133  virtual void
134  DrawArc( const VECTOR2D& aCenterPoint, double aRadius, double aStartAngle, double aEndAngle ) {};
135 
150  virtual void
151  DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius, double aStartAngle,
152  double aEndAngle, double aWidth ) {};
153 
160  virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
161 
167  virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) {};
168  virtual void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) {};
169  virtual void DrawPolygon( const SHAPE_POLY_SET& aPolySet ) {};
170 
179  virtual void DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
180  const VECTOR2D& controlPointB, const VECTOR2D& endPoint ) {};
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  virtual void SetStrokeColor( const COLOR4D& aColor )
257  {
258  strokeColor = aColor;
259  }
260 
266  inline const COLOR4D& GetStrokeColor() const
267  {
268  return strokeColor;
269  }
270 
276  virtual void SetLineWidth( double aLineWidth )
277  {
278  lineWidth = aLineWidth;
279  }
280 
286  inline double GetLineWidth() const
287  {
288  return lineWidth;
289  }
290 
296  virtual void SetLayerDepth( double aLayerDepth )
297  {
298  assert( aLayerDepth <= depthRange.y );
299  assert( aLayerDepth >= depthRange.x );
300 
301  layerDepth = aLayerDepth;
302  }
303 
304  // ----
305  // Text
306  // ----
307 
308  const STROKE_FONT& GetStrokeFont() const
309  {
310  return strokeFont;
311  }
312 
320  virtual void StrokeText( const wxString& aText, const VECTOR2D& aPosition,
321  double aRotationAngle )
322  {
323  strokeFont.Draw( aText, aPosition, aRotationAngle );
324  }
325 
334  virtual void BitmapText( const wxString& aText, const VECTOR2D& aPosition,
335  double aRotationAngle )
336  {
337  // Fallback: use stroke font
338 
339  // Handle flipped view
340  if( globalFlipX )
342 
343  StrokeText( aText, aPosition, aRotationAngle );
344 
345  if( globalFlipX )
347  }
348 
356  VECTOR2D GetTextLineSize( const UTF8& aText ) const;
357 
364  {
366  }
367 
373  virtual void SetTextAttributes( const EDA_TEXT* aText );
374 
381  void ResetTextAttributes();
382 
388  inline void SetGlyphSize( const VECTOR2D aGlyphSize )
389  {
390  textProperties.m_glyphSize = aGlyphSize;
391  }
392 
396  const VECTOR2D& GetGlyphSize() const
397  {
399  }
400 
406  inline void SetFontBold( const bool aBold )
407  {
408  textProperties.m_bold = aBold;
409  }
410 
414  inline bool IsFontBold() const
415  {
416  return textProperties.m_bold;
417  }
418 
424  inline void SetFontItalic( const bool aItalic )
425  {
426  textProperties.m_italic = aItalic;
427  }
428 
432  inline bool IsFontItalic() const
433  {
434  return textProperties.m_italic;
435  }
436 
442  inline void SetTextMirrored( const bool aMirrored )
443  {
444  textProperties.m_mirrored = aMirrored;
445  }
446 
450  inline bool IsTextMirrored() const
451  {
452  return textProperties.m_mirrored;
453  }
454 
460  inline void SetHorizontalJustify( const EDA_TEXT_HJUSTIFY_T aHorizontalJustify )
461  {
462  textProperties.m_horizontalJustify = aHorizontalJustify;
463  }
464 
469  {
471  }
472 
478  inline void SetVerticalJustify( const EDA_TEXT_VJUSTIFY_T aVerticalJustify )
479  {
480  textProperties.m_verticalJustify = aVerticalJustify;
481  }
482 
487  {
489  }
490 
491 
492  // --------------
493  // Transformation
494  // --------------
495 
501  virtual void Transform( const MATRIX3x3D& aTransformation ) {};
502 
508  virtual void Rotate( double aAngle ) {};
509 
515  virtual void Translate( const VECTOR2D& aTranslation ) {};
516 
522  virtual void Scale( const VECTOR2D& aScale ) {};
523 
525  virtual void Save() {};
526 
528  virtual void Restore() {};
529 
530  // --------------------------------------------
531  // Group methods
532  // ---------------------------------------------
533 
542  virtual int BeginGroup() { return 0; };
543 
545  virtual void EndGroup() {};
546 
552  virtual void DrawGroup( int aGroupNumber ) {};
553 
560  virtual void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) {};
561 
568  virtual void ChangeGroupDepth( int aGroupNumber, int aDepth ) {};
569 
575  virtual void DeleteGroup( int aGroupNumber ) {};
576 
580  virtual void ClearCache() {};
581 
582  // --------------------------------------------------------
583  // Handling the world <-> screen transformation
584  // --------------------------------------------------------
585 
587  virtual void ComputeWorldScreenMatrix();
588 
595  {
596  return worldScreenMatrix;
597  }
598 
605  {
606  return screenWorldMatrix;
607  }
608 
614  inline void SetWorldScreenMatrix( const MATRIX3x3D& aMatrix )
615  {
616  worldScreenMatrix = aMatrix;
617  }
618 
628  inline void SetWorldUnitLength( double aWorldUnitLength )
629  {
630  worldUnitLength = aWorldUnitLength;
631  }
632 
641  inline void SetScreenDPI( double aScreenDPI )
642  {
643  screenDPI = aScreenDPI;
644  }
645 
653  inline void SetLookAtPoint( const VECTOR2D& aPoint )
654  {
655  lookAtPoint = aPoint;
656  }
657 
663  inline const VECTOR2D& GetLookAtPoint() const
664  {
665  return lookAtPoint;
666  }
667 
673  inline void SetZoomFactor( double aZoomFactor )
674  {
675  zoomFactor = aZoomFactor;
676  }
677 
683  inline double GetZoomFactor() const
684  {
685  return zoomFactor;
686  }
687 
696  inline void SetDepthRange( const VECTOR2D& aDepthRange )
697  {
698  depthRange = aDepthRange;
699  }
700 
704  inline double GetMinDepth() const
705  {
706  return depthRange.x;
707  }
708 
712  inline double GetMaxDepth() const
713  {
714  return depthRange.y;
715  }
716 
722  inline double GetWorldScale() const
723  {
724  return worldScale;
725  }
726 
733  inline void SetFlip( bool xAxis, bool yAxis )
734  {
735  globalFlipX = xAxis;
736  globalFlipY = yAxis;
737  }
738 
739 
740  // ---------------------------
741  // Buffer manipulation methods
742  // ---------------------------
743 
747  virtual void SaveScreen() {};
748 
752  virtual void RestoreScreen() {};
753 
759  virtual void SetTarget( RENDER_TARGET aTarget ) {};
760 
766  virtual RENDER_TARGET GetTarget() const { return TARGET_CACHED; };
767 
773  virtual void ClearTarget( RENDER_TARGET aTarget ) {};
774 
786  virtual void SetNegativeDrawMode( bool aSetting ) {};
787 
788  // -------------
789  // Grid methods
790  // -------------
791 
797  inline void SetGridVisibility( bool aVisibility )
798  {
799  gridVisibility = aVisibility;
800  }
801 
807  inline void SetGridOrigin( const VECTOR2D& aGridOrigin )
808  {
809  gridOrigin = aGridOrigin;
810 
811  if( gridSize.x == 0.0 || gridSize.y == 0.0 )
812  gridOffset = VECTOR2D(0.0, 0.0);
813  else
814  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
815  (long) gridOrigin.y % (long) gridSize.y );
816  }
817 
823  inline void SetGridSize( const VECTOR2D& aGridSize )
824  {
825  gridSize = aGridSize;
826 
827  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
828  (long) gridOrigin.y % (long) gridSize.y );
829  }
830 
836  inline const VECTOR2D& GetGridSize() const
837  {
838  return gridSize;
839  }
840 
846  inline void SetGridColor( const COLOR4D& aGridColor )
847  {
848  gridColor = aGridColor;
849  }
850 
856  inline void SetAxesColor( const COLOR4D& aAxesColor )
857  {
858  axesColor = aAxesColor;
859  }
860 
864  inline void SetAxesEnabled( bool aAxesEnabled )
865  {
866  axesEnabled = aAxesEnabled;
867  }
868 
874  inline void SetCoarseGrid( int aInterval )
875  {
876  gridTick = aInterval;
877  }
878 
884  inline double GetGridLineWidth() const
885  {
886  return gridLineWidth;
887  }
888 
890  virtual void DrawGrid();
891 
899  VECTOR2D GetGridPoint( const VECTOR2D& aPoint ) const;
900 
907  inline VECTOR2D ToWorld( const VECTOR2D& aPoint ) const
908  {
909  return VECTOR2D( screenWorldMatrix * aPoint );
910  }
911 
918  inline VECTOR2D ToScreen( const VECTOR2D& aPoint ) const
919  {
920  return VECTOR2D( worldScreenMatrix * aPoint );
921  }
922 
928  inline void SetCursorEnabled( bool aCursorEnabled )
929  {
930  isCursorEnabled = aCursorEnabled;
931  }
932 
937  bool IsCursorEnabled() const
938  {
940  }
941 
947  inline void SetCursorColor( const COLOR4D& aCursorColor )
948  {
949  cursorColor = aCursorColor;
950  }
951 
957  virtual void DrawCursor( const VECTOR2D& aCursorPosition ) {};
958 
963  inline void AdvanceDepth()
964  {
965  layerDepth -= 0.05;
966  }
967 
971  inline void PushDepth()
972  {
973  depthStack.push( layerDepth );
974  }
975 
979  inline void PopDepth()
980  {
981  layerDepth = depthStack.top();
982  depthStack.pop();
983  }
984 
985  static const double METRIC_UNIT_LENGTH;
986 
987 protected:
988 
991 
992  std::stack<double> depthStack;
994 
996  double screenDPI;
998 
999  double zoomFactor;
1002  double worldScale;
1003 
1006 
1007  double lineWidth;
1008 
1011 
1015 
1016  double layerDepth;
1018 
1019  // Grid settings
1028  int gridTick;
1029  double gridLineWidth;
1031 
1033  // Cursor settings
1039 
1042 
1044  inline void computeWorldScale()
1045  {
1046  worldScale = screenDPI * worldUnitLength * zoomFactor;
1047  }
1048 
1054  double computeMinGridSpacing() const;
1055 
1062  virtual void drawGridLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) {};
1063 
1065  static const int MIN_DEPTH;
1066  static const int MAX_DEPTH;
1067 
1069  static const int GRID_DEPTH;
1070 
1074  COLOR4D getCursorColor() const;
1075 
1076  // ---------------
1077  // Settings observer interface
1078  // ---------------
1082  void OnGalDisplayOptionsChanged( const GAL_DISPLAY_OPTIONS& aOptions ) override;
1083 
1093  virtual bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions );
1094 
1095 private:
1097  {
1101  bool m_bold;
1102  bool m_italic;
1104  } textProperties;
1105 };
1106 } // namespace KIGFX
1107 
1108 #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:47
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:57
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
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 EndUpdate()
Disables item update mode.
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 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 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.
Class EDA_TEXT is a mix-in class (via multiple inheritance) that handles texts such as labels...
Definition: eda_text.h:114
virtual void ChangeGroupColor(int aGroupNumber, const COLOR4D &aNewColor)
Changes the color used to draw the group.
static const int MIN_DEPTH
Possible depth range.
double lineWidth
The line width.
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.
virtual void SetLineWidth(double aLineWidth)
Set the line width.
COLOR4D cursorColor
Cursor color.
bool IsFontBold() const
Returns true if current font has 'bold' 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:588
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.
Class SHAPE_POLY_SET.
static const double METRIC_UNIT_LENGTH
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.
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
virtual void ClearTarget(RENDER_TARGET aTarget)
Clears the target for rendering.
COLOR4D strokeColor
The color of the outlines.
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.
virtual void BeginUpdate()
Enables item update mode.
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 & 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:54
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.
bool globalFlipY
Flag for Y axis flipping.
double GetGridLineWidth() const
Get the grid line width.
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 GetLineWidth() const
Get the line width.
double GetZoomFactor() const
Get the zoom factor.
void SetGridVisibility(bool aVisibility)
Sets the visibility setting of the grid.
virtual void BeginDrawing()
Begin the drawing, needs to be called for every new frame.
bool IsFontItalic() const
Returns true if current font has 'italic' 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.
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.
bool IsTextMirrored() const
Returns true if text should displayed mirrored.
VECTOR2D m_glyphSize
Size of the glyphs.
virtual void EndDrawing()
End the drawing, needs to be called for every new frame.
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 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.
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
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
double gridLineWidth
Line width of the grid.