KiCad PCB EDA Suite
class_edge_mod.cpp
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) 2015 Jean-Pierre Charras, jean-pierre.charras@ujf-grenoble.fr
5  * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
6  * Copyright (C) 2012 Wayne Stambaugh <stambaughw@verizon.net>
7  * Copyright (C) 1992-2015 KiCad Developers, see AUTHORS.txt for contributors.
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 
32 #include <fctsys.h>
33 #include <gr_basic.h>
34 #include <trigo.h>
35 #include <class_drawpanel.h>
36 #include <pcb_screen.h>
37 #include <confirm.h>
38 #include <kicad_string.h>
39 #include <richio.h>
40 #include <macros.h>
41 #include <math_for_graphics.h>
42 #include <pcb_base_frame.h>
43 #include <msgpanel.h>
44 #include <base_units.h>
45 #include <bitmaps.h>
46 
47 #include <pcb_edit_frame.h>
48 #include <class_board.h>
49 #include <class_module.h>
50 #include <class_edge_mod.h>
51 
52 #include <view/view.h>
53 
54 #include <stdio.h>
55 
58 {
59  m_Shape = aShape;
60  m_Angle = 0;
61  m_Layer = F_SilkS;
62 }
63 
64 
66 {
67 }
68 
69 
71 {
72  MODULE* module = (MODULE*) m_Parent;
73 
74  if( module == NULL )
75  {
76  m_Start0 = m_Start;
77  m_End0 = m_End;
80  return;
81  }
82 
83  m_Start0 = m_Start - module->GetPosition();
84  m_End0 = m_End - module->GetPosition();
85  m_Bezier0_C1 = m_BezierC1 - module->GetPosition();
86  m_Bezier0_C2 = m_BezierC2 - module->GetPosition();
87  double angle = module->GetOrientation();
88  RotatePoint( &m_Start0.x, &m_Start0.y, -angle );
89  RotatePoint( &m_End0.x, &m_End0.y, -angle );
90  RotatePoint( &m_Bezier0_C1.x, &m_Bezier0_C1.y, -angle );
91  RotatePoint( &m_Bezier0_C2.x, &m_Bezier0_C2.y, -angle );
92 }
93 
94 
96 {
97  MODULE* module = (MODULE*) m_Parent;
98 
99  m_Start = m_Start0;
100  m_End = m_End0;
103 
104  if( module )
105  {
106  RotatePoint( &m_Start.x, &m_Start.y, module->GetOrientation() );
107  RotatePoint( &m_End.x, &m_End.y, module->GetOrientation() );
110 
111  m_Start += module->GetPosition();
112  m_End += module->GetPosition();
113  m_BezierC1 += module->GetPosition();
114  m_BezierC2 += module->GetPosition();
115  }
116 
118 }
119 
120 
121 void EDGE_MODULE::Draw( EDA_DRAW_PANEL* panel, wxDC* DC, GR_DRAWMODE draw_mode,
122  const wxPoint& offset )
123 {
124  int ux0, uy0, dx, dy, radius, StAngle, EndAngle;
125  PCB_LAYER_ID curr_layer = ( (PCB_SCREEN*) panel->GetScreen() )->m_Active_Layer;
126 
127  MODULE* module = (MODULE*) m_Parent;
128 
129  if( !module )
130  return;
131 
132  BOARD* brd = GetBoard( );
133 
134  if( brd->IsLayerVisible( m_Layer ) == false )
135  return;
136 
137 
138  auto frame = static_cast<PCB_BASE_FRAME*> ( panel->GetParent() );
139  auto color = frame->Settings().Colors().GetLayerColor( m_Layer );
140 
141  auto displ_opts = (PCB_DISPLAY_OPTIONS*)( panel->GetDisplayOptions() );
142 
143  if(( draw_mode & GR_ALLOW_HIGHCONTRAST ) && displ_opts && displ_opts->m_ContrastModeDisplay )
144  {
145  if( !IsOnLayer( curr_layer ) )
147  }
148 
149  ux0 = m_Start.x - offset.x;
150  uy0 = m_Start.y - offset.y;
151 
152  dx = m_End.x - offset.x;
153  dy = m_End.y - offset.y;
154 
155  GRSetDrawMode( DC, draw_mode );
156  bool filled = displ_opts ? displ_opts->m_DisplayModEdgeFill : FILLED;
157 
158  if( IsCopperLayer( m_Layer ) )
159  filled = displ_opts ? displ_opts->m_DisplayPcbTrackFill : FILLED;
160 
161  switch( m_Shape )
162  {
163  case S_SEGMENT:
164  if( filled )
165  GRLine( panel->GetClipBox(), DC, ux0, uy0, dx, dy, m_Width, color );
166  else
167  // SKETCH Mode
168  GRCSegm( panel->GetClipBox(), DC, ux0, uy0, dx, dy, m_Width, color );
169 
170  break;
171 
172  case S_CIRCLE:
173  radius = KiROUND( Distance( ux0, uy0, dx, dy ) );
174 
175  if( filled )
176  {
177  GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius, m_Width, color );
178  }
179  else // SKETCH Mode
180  {
181  GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius + (m_Width / 2), color );
182  GRCircle( panel->GetClipBox(), DC, ux0, uy0, radius - (m_Width / 2), color );
183  }
184 
185  break;
186 
187  case S_ARC:
188  radius = KiROUND( Distance( ux0, uy0, dx, dy ) );
189  StAngle = ArcTangente( dy - uy0, dx - ux0 );
190  EndAngle = StAngle + m_Angle;
191 
192  if( !panel->GetPrintMirrored() )
193  {
194  if( StAngle > EndAngle )
195  std::swap( StAngle, EndAngle );
196  }
197  else // Mirrored mode: arc orientation is reversed
198  {
199  if( StAngle < EndAngle )
200  std::swap( StAngle, EndAngle );
201  }
202 
203  if( filled )
204  {
205  GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle, radius, m_Width, color );
206  }
207  else // SKETCH Mode
208  {
209  GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle,
210  radius + (m_Width / 2), color );
211  GRArc( panel->GetClipBox(), DC, ux0, uy0, StAngle, EndAngle,
212  radius - (m_Width / 2), color );
213  }
214  break;
215 
216  case S_POLYGON:
217  if( m_Poly.IsEmpty() )
218  break;
219 
220  {
221  // We must compute absolute coordinates from m_PolyPoints
222  // which are relative to module position, orientation 0
223  std::vector<wxPoint> points;
224 
225  for( auto iter = m_Poly.CIterate(); iter; iter++ )
226  {
227  points.push_back( wxPoint( iter->x,iter->y ) );
228  }
229 
230  for( unsigned ii = 0; ii < points.size(); ii++ )
231  {
232  wxPoint& pt = points[ii];
233 
234  RotatePoint( &pt.x, &pt.y, module->GetOrientation() );
235  pt += module->GetPosition() - offset;
236  }
237 
238  GRPoly( panel->GetClipBox(), DC, points.size(), &points[0], true, m_Width, color, color );
239  }
240  break;
241 
242  case S_CURVE:
243  {
245 
246  wxPoint& startp = m_BezierPoints[0];
247 
248  for( unsigned int i = 1; i < m_BezierPoints.size(); i++ )
249  {
250  wxPoint& endp = m_BezierPoints[i];
251 
252  if( filled )
253  GRFilledSegment( panel->GetClipBox(), DC,
254  startp-offset, endp-offset, m_Width, color );
255  else
256  GRCSegm( panel->GetClipBox(), DC,
257  startp-offset, endp-offset, m_Width, color );
258 
259  startp = m_BezierPoints[i];
260  }
261  }
262  break;
263 
264  default:
265  break;
266  }
267 }
268 
269 
270 // see class_edge_mod.h
271 void EDGE_MODULE::GetMsgPanelInfo( EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM >& aList )
272 {
273  wxString msg;
274 
275  MODULE* module = (MODULE*) m_Parent;
276 
277  if( !module )
278  return;
279 
280  BOARD* board = (BOARD*) module->GetParent();
281 
282  if( !board )
283  return;
284 
285  aList.push_back( MSG_PANEL_ITEM( _( "Footprint" ), module->GetReference(), DARKCYAN ) );
286  aList.push_back( MSG_PANEL_ITEM( _( "Value" ), module->GetValue(), BLUE ) );
287  msg.Printf( wxT( "%8.8lX" ), module->GetTimeStamp() );
288  aList.push_back( MSG_PANEL_ITEM( _( "TimeStamp" ), msg, BROWN ) );
289  aList.push_back( MSG_PANEL_ITEM( _( "Footprint Layer" ), module->GetLayerName(), RED ) );
290 
291  // append the features shared with the base class
292  DRAWSEGMENT::GetMsgPanelInfo( aUnits, aList );
293 }
294 
295 
296 
298 {
299  return wxString::Format( _( "Graphic %s of %s on %s" ),
300  ShowShape( m_Shape ),
301  ((MODULE*) GetParent())->GetReference(),
302  GetLayerName() );
303 }
304 
305 
307 {
308  return show_mod_edge_xpm;
309 }
310 
311 
313 {
314  return new EDGE_MODULE( *this );
315 }
316 
317 
318 void EDGE_MODULE::Flip( const wxPoint& aCentre )
319 {
320  wxPoint pt;
321 
322  switch( GetShape() )
323  {
324  case S_ARC:
325  SetAngle( -GetAngle() );
326  //Fall through
327  default:
328  case S_SEGMENT:
329  case S_CURVE:
330  pt = GetStart();
331  MIRROR( pt.y, aCentre.y );
332  SetStart( pt );
333 
334  pt = GetEnd();
335  MIRROR( pt.y, aCentre.y );
336  SetEnd( pt );
337 
338  MIRROR( m_BezierC1.y, aCentre.y );
339  MIRROR( m_BezierC2.y, aCentre.y );
340 
341  MIRROR( m_Start0.y, 0 );
342  MIRROR( m_End0.y, 0 );
343  MIRROR( m_Bezier0_C1.y, 0 );
344  MIRROR( m_Bezier0_C2.y, 0 );
346  break;
347 
348  case S_POLYGON:
349  // polygon corners coordinates are always relative to the
350  // footprint position, orientation 0
351  for( auto iter = m_Poly.Iterate(); iter; iter++ )
352  {
353  MIRROR( iter->y, 0 );
354  }
355  break;
356  }
357 
358  // DRAWSEGMENT items are not usually on copper layers, but
359  // it can happen in microwave apps.
360  // However, currently, only on Front or Back layers.
361  // So the copper layers count is not taken in account
362  SetLayer( FlipLayer( GetLayer() ) );
363 }
364 
366 {
367  if( GetParent() && GetParent()->GetLayer() == B_Cu )
368  return true;
369  return false;
370 }
371 
372 void EDGE_MODULE::Mirror( wxPoint aCentre, bool aMirrorAroundXAxis )
373 {
374  // Mirror an edge of the footprint. the layer is not modified
375  // This is a footprint shape modification.
376  switch( GetShape() )
377  {
378  case S_ARC:
379  SetAngle( -GetAngle() );
380  //Fall through
381  default:
382  case S_CURVE:
383  case S_SEGMENT:
384  if( aMirrorAroundXAxis )
385  {
386  MIRROR( m_Start0.y, aCentre.y );
387  MIRROR( m_End0.y, aCentre.y );
388  MIRROR( m_Bezier0_C1.y, aCentre.y );
389  MIRROR( m_Bezier0_C2.y, aCentre.y );
390  }
391  else
392  {
393  MIRROR( m_Start0.x, aCentre.x );
394  MIRROR( m_End0.x, aCentre.x );
395  MIRROR( m_Bezier0_C1.x, aCentre.x );
396  MIRROR( m_Bezier0_C2.x, aCentre.x );
397  }
398 
399  for( unsigned ii = 0; ii < m_BezierPoints.size(); ii++ )
400  {
401  if( aMirrorAroundXAxis )
402  MIRROR( m_BezierPoints[ii].y, aCentre.y );
403  else
404  MIRROR( m_BezierPoints[ii].x, aCentre.x );
405  }
406 
407  break;
408 
409  case S_POLYGON:
410  // polygon corners coordinates are always relative to the
411  // footprint position, orientation 0
412  for( auto iter = m_Poly.Iterate(); iter; iter++ )
413  {
414  if( aMirrorAroundXAxis )
415  MIRROR( iter->y, aCentre.y );
416  else
417  MIRROR( iter->x, aCentre.x );
418  }
419  }
420 
421  SetDrawCoord();
422 }
423 
424 void EDGE_MODULE::Rotate( const wxPoint& aRotCentre, double aAngle )
425 {
426  // We should rotate the relative coordinates, but to avoid duplicate code,
427  // do the base class rotation of draw coordinates, which is acceptable
428  // because in module editor, m_Pos0 = m_Pos
429  DRAWSEGMENT::Rotate( aRotCentre, aAngle );
430 
431  // and now update the relative coordinates, which are
432  // the reference in most transforms.
433  SetLocalCoord();
434 }
435 
436 
437 void EDGE_MODULE::Move( const wxPoint& aMoveVector )
438 {
439  // Move an edge of the footprint.
440  // This is a footprint shape modification.
441  m_Start0 += aMoveVector;
442  m_End0 += aMoveVector;
443  m_Bezier0_C1 += aMoveVector;
444  m_Bezier0_C2 += aMoveVector;
445 
446  switch( GetShape() )
447  {
448  default:
449  break;
450 
451  case S_POLYGON:
452  // polygon corners coordinates are always relative to the
453  // footprint position, orientation 0
454  for( auto iter = m_Poly.Iterate(); iter; iter++ )
455  *iter += VECTOR2I( aMoveVector );
456 
457  break;
458  }
459 
460  SetDrawCoord();
461 }
462 
463 unsigned int EDGE_MODULE::ViewGetLOD( int aLayer, KIGFX::VIEW* aView ) const
464 {
465  const int HIDE = std::numeric_limits<unsigned int>::max();
466 
467  if( !aView )
468  return 0;
469 
470  // Handle Render tab switches
471  if( !IsParentFlipped() && !aView->IsLayerVisible( LAYER_MOD_FR ) )
472  return HIDE;
473 
474  if( IsParentFlipped() && !aView->IsLayerVisible( LAYER_MOD_BK ) )
475  return HIDE;
476 
477  // Other layers are shown without any conditions
478  return 0;
479 }
virtual BASE_SCREEN * GetScreen()=0
Definition: colors.h:57
wxPoint m_Bezier0_C2
Bezier Control Point 2, relative to module origin, orient 0.
BOARD_ITEM_CONTAINER * GetParent() const
static wxString ShowShape(STROKE_T aShape)
Function ShowShape converts the enum STROKE_T integer value to a wxString.
void GRPoly(EDA_RECT *ClipBox, wxDC *DC, int n, wxPoint Points[], bool Fill, int width, COLOR4D Color, COLOR4D BgColor)
Definition: gr_basic.cpp:701
EDA_ITEM * m_Parent
Linked list: Link (parent struct)
Definition: base_struct.h:168
PNG memory record (file in memory).
Definition: bitmap_types.h:41
virtual unsigned int ViewGetLOD(int aLayer, KIGFX::VIEW *aView) const override
Function ViewGetLOD() Returns the level of detail (LOD) of the item.
void GRSetDrawMode(wxDC *DC, GR_DRAWMODE draw_mode)
Definition: gr_basic.cpp:223
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:120
bool IsLayerVisible(int aLayer) const
Function IsLayerVisible() Returns information about visibility of a particular layer.
Definition: view.h:429
virtual bool IsOnLayer(PCB_LAYER_ID aLayer) const
Function IsOnLayer tests to see if this object is on the given layer.
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
Implementation of conversion functions that require both schematic and board internal units...
This file is part of the common library.
virtual PCB_LAYER_ID GetLayer() const
Function GetLayer returns the primary layer this item is on.
Class BOARD to handle a board.
SHAPE_POLY_SET m_Poly
Stores the S_POLYGON shape.
int color
Definition: DXF_plotter.cpp:62
polygon (not yet used for tracks, but could be in microwave apps)
PCB_LAYER_ID FlipLayer(PCB_LAYER_ID aLayerId, int aCopperLayersCount)
Function FlippedLayerNumber.
Definition: lset.cpp:472
void RebuildBezierToSegmentsPointsList(int aMinSegLen)
Rebuild the m_BezierPoints vertex list that approximate the Bezier curve by a list of segments Has me...
CONST_ITERATOR CIterate(int aFirst, int aLast, bool aIterateHoles=false) const
show modules on back
void GRCSegm(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, int aPenSize, COLOR4D Color)
Definition: gr_basic.cpp:415
const wxString & GetValue() const
Function GetValue.
Definition: class_module.h:494
usual segment : line with rounded ends
virtual EDA_RECT * GetClipBox()
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:216
double m_Angle
Used only for Arcs: Arc angle in 1/10 deg.
ITERATOR Iterate(int aFirst, int aLast, bool aIterateHoles=false)
Function Iterate returns an object to iterate through the points of the polygons between aFirst and a...
VECTOR2< int > VECTOR2I
Definition: vector2d.h:587
wxString GetLayerName() const
Function GetLayerName returns the name of the PCB layer on which the item resides.
class EDGE_MODULE, a footprint edge
Definition: typeinfo.h:94
wxPoint m_End0
End point, relative to module origin, orient 0.
This file contains miscellaneous commonly used macros and functions.
wxPoint m_BezierC1
Bezier Control Point 1.
wxPoint m_Bezier0_C1
Bezier Control Point 1, relative to module origin, orient 0.
Classes used in Pcbnew, CvPcb and GerbView.
show modules on front
void Rotate(const wxPoint &aRotCentre, double aAngle) override
Rotate an edge of the footprint.
virtual EDA_DRAW_FRAME * GetParent() const =0
PCB_LAYER_ID m_Layer
void MIRROR(T &aPoint, const T &aMirrorRef)
Definition: macros.h:111
void Mirror(const wxPoint aCentre, bool aMirrorAroundXAxis)
Mirror an edge of the footprint.
Class PCB_DISPLAY_OPTIONS handles display options like enable/disable some optional drawings...
PCB_LAYER_ID
A quick note on layer IDs:
STROKE_T GetShape() const
wxPoint m_Start
Line start point or Circle and Arc center.
const wxPoint & GetEnd() const
Function GetEnd returns the ending point of the graphic.
double ArcTangente(int dy, int dx)
Definition: trigo.cpp:170
EDA_ITEM * Clone() const override
Function Clone creates a duplicate of this item with linked list members set to NULL.
wxPoint m_End
Line end point or circle and arc start point.
double GetOrientation() const
Definition: class_module.h:189
GR_DRAWMODE
Drawmode. Compositing mode plus a flag or two.
Definition: gr_basic.h:37
Arcs (with rounded ends)
void GRArc(EDA_RECT *ClipBox, wxDC *DC, int xc, int yc, double StAngle, double EndAngle, int r, COLOR4D Color)
Definition: gr_basic.cpp:908
STROKE_T
Enum STROKE_T is the set of shapes for segments (graphic segments and tracks) which are often in the ...
STROKE_T m_Shape
Shape: line, Circle, Arc.
Definition: colors.h:60
wxString GetSelectMenuText(EDA_UNITS_T aUnits) const override
Function GetSelectMenuText returns the text to display to be used in the selection clarification cont...
void Draw(EDA_DRAW_PANEL *panel, wxDC *DC, GR_DRAWMODE aDrawMode, const wxPoint &offset=ZeroOffset) override
Function Draw BOARD_ITEMs have their own color information.
Bezier Curve.
void GRLine(EDA_RECT *ClipBox, wxDC *DC, int x1, int y1, int x2, int y2, int width, COLOR4D Color, wxPenStyle aStyle)
Definition: gr_basic.cpp:285
void Flip(const wxPoint &aCentre) override
Flip entity relative to aCentre.
void SetStart(const wxPoint &aStart)
void SetLocalCoord()
Set relative coordinates from draw coordinates.
BITMAP_DEF GetMenuImage() const override
Function GetMenuImage returns a pointer to an image to be used in menus.
virtual void Rotate(const wxPoint &aRotCentre, double aAngle) override
Function Rotate Rotate this object.
double GetAngle() const
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
#define max(a, b)
Definition: auxiliary.h:86
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:170
const wxString & GetReference() const
Function GetReference.
Definition: class_module.h:460
void GRFilledSegment(EDA_RECT *aClipBox, wxDC *aDC, wxPoint aStart, wxPoint aEnd, int aWidth, COLOR4D aColor)
Definition: gr_basic.cpp:526
void Move(const wxPoint &aMoveVector) override
Move an edge of the footprint.
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
void GRCircle(EDA_RECT *ClipBox, wxDC *DC, int xc, int yc, int r, int width, COLOR4D Color)
Definition: gr_basic.cpp:755
size_t i
Definition: json11.cpp:597
EDGE_MODULE(MODULE *parent, STROKE_T aShape=S_SEGMENT)
bool IsParentFlipped() const
void SetDrawCoord()
Set draw coordinates (absolute values ) from relative coordinates.
wxPoint m_BezierC2
Bezier Control Point 2.
Class EDA_ITEM is a base class for most all the KiCad significant classes, used in schematics and boa...
Definition: base_struct.h:151
void GetMsgPanelInfo(EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM > &aList) override
Function GetMsgPanelInfo populates aList of MSG_PANEL_ITEM objects with it&#39;s internal state for displ...
void SetEnd(const wxPoint &aEnd)
void SetAngle(double aAngle)
Function SetAngle sets the angle for arcs, and normalizes it within the range 0 - 360 degrees...
virtual BOARD * GetBoard() const
Function GetBoard returns the BOARD in which this BOARD_ITEM resides, or NULL if none.
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
virtual void GetMsgPanelInfo(EDA_UNITS_T aUnits, std::vector< MSG_PANEL_ITEM > &aList) override
Function GetMsgPanelInfo populates aList of MSG_PANEL_ITEM objects with it&#39;s internal state for displ...
int m_Width
thickness of lines ...
Module description (excepted pads)
bool IsEmpty() const
Returns true if the set is empty (no polygons at all)
wxPoint m_Start0
Start point or center, relative to module origin, orient 0.
virtual void * GetDisplayOptions()
Function GetDisplayOptions A way to pass info to draw functions.
Class EDA_MSG_ITEM is used EDA_MSG_PANEL as the item type for displaying messages.
Definition: msgpanel.h:53
Class VIEW.
Definition: view.h:61
double Distance(double x1, double y1, double x2, double y2)
EDGE_MODULE class definition.
Message panel definition file.
const wxPoint & GetStart() const
Function GetStart returns the starting point of the graphic.
const wxPoint GetPosition() const override
Definition: class_module.h:184
class PCB_BASE_FRAME basic PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer...
EDA_UNITS_T
Definition: common.h:159
timestamp_t GetTimeStamp() const
Definition: base_struct.h:204
bool IsLayerVisible(PCB_LAYER_ID aLayer) const
Function IsLayerVisible is a proxy function that calls the correspondent function in m_BoardSettings ...
Definition: class_board.h:457
std::vector< wxPoint > m_BezierPoints
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
Definition: colors.h:62