KiCad PCB EDA Suite
KIGFX::GERBVIEW_PAINTER Class Reference

GERBVIEW_PAINTER Contains methods for drawing GerbView-specific items. More...

#include <gerbview_painter.h>

Inheritance diagram for KIGFX::GERBVIEW_PAINTER:
KIGFX::PAINTER

Public Member Functions

 GERBVIEW_PAINTER (GAL *aGal)
 
virtual void ApplySettings (const RENDER_SETTINGS *aSettings) override
 Function ApplySettings Loads colors and display modes settings that are going to be used when drawing items. More...
 
virtual GERBVIEW_RENDER_SETTINGSGetSettings () override
 
virtual bool Draw (const VIEW_ITEM *aItem, int aLayer) override
 Function Draw Takes an instance of VIEW_ITEM and passes it to a function that know how to draw the item. More...
 
void SetGAL (GAL *aGal)
 Function SetGAL Changes Graphics Abstraction Layer used for drawing items for a new one. More...
 

Protected Member Functions

void draw (GERBER_DRAW_ITEM *aVia, int aLayer)
 
void drawPolygon (GERBER_DRAW_ITEM *aParent, const SHAPE_POLY_SET &aPolygon, bool aFilled, bool aShift=false)
 Helper routine to draw a polygon. More...
 
void drawFlashedShape (GERBER_DRAW_ITEM *aItem, bool aFilled)
 Helper to draw a flashed shape (aka spot) More...
 
void drawApertureMacro (GERBER_DRAW_ITEM *aParent, bool aFilled)
 Helper to draw an aperture macro shape. More...
 
int getLineThickness (int aActualThickness) const
 Function getLineThickness() Get the thickness to draw for a line (e.g. More...
 

Protected Attributes

GERBVIEW_RENDER_SETTINGS m_gerbviewSettings
 
GALm_gal
 Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg. More...
 
COLOR4D m_brightenedColor
 Color of brightened item frame. More...
 

Detailed Description

GERBVIEW_PAINTER Contains methods for drawing GerbView-specific items.

Definition at line 167 of file gerbview_painter.h.

Constructor & Destructor Documentation

◆ GERBVIEW_PAINTER()

GERBVIEW_PAINTER::GERBVIEW_PAINTER ( GAL aGal)

Definition at line 151 of file gerbview_painter.cpp.

151  :
152  PAINTER( aGal )
153 {
154 }
PAINTER(GAL *aGal)
Constructor PAINTER( GAL* ) initializes this object for painting on any of the polymorphic GRAPHICS_A...
Definition: painter.cpp:32

Member Function Documentation

◆ ApplySettings()

virtual void KIGFX::GERBVIEW_PAINTER::ApplySettings ( const RENDER_SETTINGS aSettings)
inlineoverridevirtual

Function ApplySettings Loads colors and display modes settings that are going to be used when drawing items.

Parameters
aSettingsare settings to be applied.

Implements KIGFX::PAINTER.

Definition at line 173 of file gerbview_painter.h.

174  {
175  m_gerbviewSettings = *static_cast<const GERBVIEW_RENDER_SETTINGS*>( aSettings );
176  }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings

References m_gerbviewSettings.

◆ Draw()

bool GERBVIEW_PAINTER::Draw ( const VIEW_ITEM aItem,
int  aLayer 
)
overridevirtual

Function Draw Takes an instance of VIEW_ITEM and passes it to a function that know how to draw the item.

Parameters
aItemis an item to be drawn.
aLayertells which layer is currently rendered so that draw functions may know what to draw (eg. for pads there are separate layers for holes, because they have other dimensions then the pad itself.

Implements KIGFX::PAINTER.

Definition at line 170 of file gerbview_painter.cpp.

171 {
172  const EDA_ITEM* item = static_cast<const EDA_ITEM*>( aItem );
173 
174  // the "cast" applied in here clarifies which overloaded draw() is called
175  switch( item->Type() )
176  {
177  case GERBER_DRAW_ITEM_T:
178  draw( static_cast<GERBER_DRAW_ITEM*>( const_cast<EDA_ITEM*>( item ) ), aLayer );
179  break;
180 
181  default:
182  // Painter does not know how to draw the object
183  return false;
184  }
185 
186  return true;
187 }
void draw(GERBER_DRAW_ITEM *aVia, int aLayer)
EDA_ITEM is a base class for most all the KiCad significant classes, used in schematics and boards.
Definition: base_struct.h:163
KICAD_T Type() const
Function Type()
Definition: base_struct.h:197

References draw(), GERBER_DRAW_ITEM_T, and EDA_ITEM::Type().

◆ draw()

void GERBVIEW_PAINTER::draw ( GERBER_DRAW_ITEM aVia,
int  aLayer 
)
protected

Definition at line 192 of file gerbview_painter.cpp.

193 {
194  VECTOR2D start( aItem->GetABPosition( aItem->m_Start ) ); // TODO(JE) Getter
195  VECTOR2D end( aItem->GetABPosition( aItem->m_End ) ); // TODO(JE) Getter
196  int width = aItem->m_Size.x; // TODO(JE) Getter
197  bool isFilled = true;
198  COLOR4D color;
199  // TODO(JE) This doesn't actually work properly for ImageNegative
200  bool isNegative = ( aItem->GetLayerPolarity() ^ aItem->m_GerberImageFile->m_ImageNegative );
201 
202  // Draw DCODE overlay text
203  if( IsDCodeLayer( aLayer ) )
204  {
205  wxString codeText;
206  VECTOR2D textPosition;
207  double textSize;
208  double orient;
209 
210  if( !aItem->GetTextD_CodePrms( textSize, textPosition, orient ) )
211  return;
212 
213  color = m_gerbviewSettings.GetColor( aItem, aLayer );
214  codeText.Printf( "D%d", aItem->m_DCode );
215 
216  m_gal->SetIsStroke( true );
217  m_gal->SetIsFill( false );
219  m_gal->SetFillColor( COLOR4D( 0, 0, 0, 0 ) );
220  m_gal->SetLineWidth( textSize/10 );
221  m_gal->SetFontBold( false );
222  m_gal->SetFontItalic( false );
223  m_gal->SetTextMirrored( false );
224  m_gal->SetGlyphSize( VECTOR2D( textSize, textSize) );
227  m_gal->BitmapText( codeText, textPosition, orient );
228 
229  return;
230  }
231 
232  color = m_gerbviewSettings.GetColor( aItem, aLayer );
233 
234  // TODO: Should brightened color be a preference?
235  if( aItem->IsBrightened() )
236  color = COLOR4D( 0.0, 1.0, 0.0, 0.75 );
237 
238  m_gal->SetNegativeDrawMode( isNegative );
241  m_gal->SetIsFill( isFilled );
242  m_gal->SetIsStroke( !isFilled );
243 
244  switch( aItem->m_Shape )
245  {
246  case GBR_POLYGON:
247  {
249  m_gal->SetIsFill( isFilled );
250  m_gal->SetIsStroke( !isFilled );
251 
252  if( isNegative && !isFilled )
253  {
254  m_gal->SetNegativeDrawMode( false );
255  m_gal->SetStrokeColor( GetSettings()->GetColor( aItem, aLayer ) );
256  }
257 
258  if( !isFilled )
260 
261  std::vector<VECTOR2I> pts = aItem->m_Polygon.COutline( 0 ).CPoints();
262 
263  for( auto& pt : pts )
264  pt = aItem->GetABPosition( pt );
265 
266 
267  SHAPE_POLY_SET absolutePolygon;
268  SHAPE_LINE_CHAIN chain( pts );
269  chain.SetClosed( true );
270  absolutePolygon.AddOutline( chain );
271 
272  // Degenerated polygons (having < 3 points) are drawn as lines
273  // to avoid issues in draw polygon functions
274  if( !isFilled || absolutePolygon.COutline( 0 ).PointCount() < 3 )
275  m_gal->DrawPolyline( absolutePolygon.COutline( 0 ) );
276  else
277  {
278  // On Opengl, a not convex filled polygon is usually drawn by using triangles as primitives.
279  // CacheTriangulation() can create basic triangle primitives to draw the polygon solid shape
280  // on Opengl
281  if( m_gal->IsOpenGlEngine() )
282  absolutePolygon.CacheTriangulation();
283 
284  m_gal->DrawPolygon( absolutePolygon );
285  }
286 
287  break;
288  }
289 
290  case GBR_CIRCLE:
291  {
292  isFilled = m_gerbviewSettings.m_lineFill;
293  double radius = GetLineLength( aItem->m_Start, aItem->m_End );
294  m_gal->DrawCircle( start, radius );
295  break;
296  }
297 
298  case GBR_ARC:
299  {
300  isFilled = m_gerbviewSettings.m_lineFill;
301 
302  // These are swapped because wxDC fills arcs counterclockwise and GAL
303  // fills them clockwise.
304  wxPoint arcStart = aItem->m_End;
305  wxPoint arcEnd = aItem->m_Start;
306 
307  // Gerber arcs are 3-point (start, center, end)
308  // GAL needs center, radius, start angle, end angle
309  double radius = GetLineLength( arcStart, aItem->m_ArcCentre );
310  VECTOR2D center = aItem->GetABPosition( aItem->m_ArcCentre );
311  VECTOR2D startVec = VECTOR2D( aItem->GetABPosition( arcStart ) ) - center;
312  VECTOR2D endVec = VECTOR2D( aItem->GetABPosition( arcEnd ) ) - center;
313 
314  m_gal->SetIsFill( isFilled );
315  m_gal->SetIsStroke( !isFilled );
316  m_gal->SetLineWidth( isFilled ? width : m_gerbviewSettings.m_outlineWidth );
317 
318  double startAngle = startVec.Angle();
319  double endAngle = endVec.Angle();
320 
321  // GAL fills in direction of increasing angle, so we have to convert
322  // the angle from the -PI to PI domain of atan2() to ensure that
323  // the arc goes in the right direction
324  if( startAngle > endAngle )
325  endAngle += (2 * M_PI);
326 
327  // In Gerber, 360-degree arcs are stored in the file with start equal to end
328  if( arcStart == arcEnd )
329  {
330  endAngle = startAngle + 2*M_PI;
331  }
332 
333  m_gal->DrawArcSegment( center, radius, startAngle, endAngle, width );
334 
335 #if 0 // Arc Debugging only
336  m_gal->SetIsFill( false );
337  m_gal->SetIsStroke( true );
338  m_gal->SetLineWidth( 5 );
339  m_gal->SetStrokeColor( COLOR4D( 0.1, 0.5, 0.0, 0.5 ) );
340  m_gal->DrawLine( center, aItem->GetABPosition( arcStart ) );
341  m_gal->SetStrokeColor( COLOR4D( 0.6, 0.1, 0.0, 0.5 ) );
342  m_gal->DrawLine( center, aItem->GetABPosition( arcEnd ) );
343 #endif
344 
345 #if 0 // Bbox arc Debugging only
346  m_gal->SetIsFill( false );
347  m_gal->SetIsStroke( true );
348  EDA_RECT box = aItem->GetBoundingBox();
349  m_gal->SetLineWidth( 5 );
350  m_gal->SetStrokeColor( COLOR4D(0.9, 0.9, 0, 0.4) );
351  // box coordinates are already in AB position.
352  m_gal->DrawRectangle( box.GetOrigin(), box.GetEnd() );
353 #endif
354  break;
355  }
356 
357  case GBR_SPOT_CIRCLE:
358  case GBR_SPOT_RECT:
359  case GBR_SPOT_OVAL:
360  case GBR_SPOT_POLY:
361  case GBR_SPOT_MACRO:
362  {
363  isFilled = m_gerbviewSettings.m_spotFill;
364  drawFlashedShape( aItem, isFilled );
365  break;
366  }
367 
368  case GBR_SEGMENT:
369  {
370  /* Plot a line from m_Start to m_End.
371  * Usually, a round pen is used, but some gerber files use a rectangular pen
372  * In fact, any aperture can be used to plot a line.
373  * currently: only a square pen is handled (I believe using a polygon gives a strange plot).
374  */
375  isFilled = m_gerbviewSettings.m_lineFill;
376  m_gal->SetIsFill( isFilled );
377  m_gal->SetIsStroke( !isFilled );
378 
379  if( isNegative && !isFilled )
380  m_gal->SetStrokeColor( GetSettings()->GetColor( aItem, aLayer ) );
381 
382  // TODO(JE) Refactor this to allow const aItem
383  D_CODE* code = aItem->GetDcodeDescr();
384  if( code && code->m_Shape == APT_RECT )
385  {
386  if( aItem->m_Polygon.OutlineCount() == 0 )
387  aItem->ConvertSegmentToPolygon();
388 
389  drawPolygon( aItem, aItem->m_Polygon, isFilled );
390  }
391  else
392  {
393  if( !isFilled )
395 
396  m_gal->DrawSegment( start, end, width );
397  }
398  break;
399  }
400 
401  default:
402  wxASSERT_MSG( false, "GERBER_DRAW_ITEM shape is unknown!" );
403  break;
404  }
405 
406  // Enable for bounding box debugging
407  #if 0
408  const BOX2I& bb = aItem->ViewBBox();
409  m_gal->SetIsStroke( true );
410  m_gal->SetIsFill( true );
411  m_gal->SetLineWidth( 3 );
412  m_gal->SetStrokeColor( COLOR4D(0.9, 0.9, 0, 0.4) );
413  m_gal->SetFillColor( COLOR4D(0.9, 0.9, 0, 0.1) );
414  m_gal->DrawRectangle( bb.GetOrigin(), bb.GetEnd() );
415  #endif
416 }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
void SetFontItalic(const bool aItalic)
Set italic property of current font.
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
virtual const COLOR4D & GetColor(const VIEW_ITEM *aItem, int aLayer) const override
Function GetColor Returns the color that should be used to draw the specific VIEW_ITEM on the specifi...
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a rectangle.
bool IsDCodeLayer(int aLayer)
double GetLineLength(const wxPoint &aPointA, const wxPoint &aPointB)
Return the length of a line segment defined by aPointA and aPointB.
Definition: trigo.h:206
const Vec GetEnd() const
Definition: box2.h:194
virtual void BitmapText(const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draws a text using a bitmap font.
APERTURE_T m_Shape
shape ( Line, rectangle, circle , oval .. )
Definition: dcode.h:95
int color
Definition: DXF_plotter.cpp:61
bool m_lineFill
Flag determining if lines should be drawn with fill.
void drawFlashedShape(GERBER_DRAW_ITEM *aItem, bool aFilled)
Helper to draw a flashed shape (aka spot)
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
int PointCount() const
Function PointCount()
bool m_spotFill
Flag determining if spots should be drawn with fill.
Definition: dcode.h:52
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.
Definition: painter.h:110
virtual void SetLineWidth(float aLineWidth)
Set the line width.
const wxPoint GetEnd() const
Definition: eda_rect.h:116
void SetFontBold(const bool aBold)
Set bold property of current font.
virtual void DrawSegment(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth)
Draw a rounded segment.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:593
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
SHAPE_POLY_SET.
const wxPoint GetOrigin() const
Definition: eda_rect.h:114
virtual bool IsOpenGlEngine()
Returns true if the GAL engine is a opengl based type.
void SetTextMirrored(const bool aMirrored)
Set a mirrored property of text.
void SetVerticalJustify(const EDA_TEXT_VJUSTIFY_T aVerticalJustify)
Set the vertical justify for text drawing.
double Angle() const
Function Angle computes the angle of the vector.
Definition: vector2d.h:313
int AddOutline(const SHAPE_LINE_CHAIN &aOutline)
Adds a new outline to the set and returns its index
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
virtual GERBVIEW_RENDER_SETTINGS * GetSettings() override
bool m_polygonFill
Flag determining if polygons should be drawn with fill.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
D_CODE holds a gerber DCODE (also called Aperture) definition.
Definition: dcode.h:82
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
SHAPE_LINE_CHAIN.
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44
void drawPolygon(GERBER_DRAW_ITEM *aParent, const SHAPE_POLY_SET &aPolygon, bool aFilled, bool aShift=false)
Helper routine to draw a polygon.
void SetGlyphSize(const VECTOR2D aGlyphSize)
Set the font glyph size.
virtual void DrawArcSegment(const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle, double aWidth)
Draw an arc segment.
void SetHorizontalJustify(const EDA_TEXT_HJUSTIFY_T aHorizontalJustify)
Set the horizontal justify for text drawing.
const Vec & GetOrigin() const
Definition: box2.h:192
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
virtual void SetNegativeDrawMode(bool aSetting)
Sets negative draw mode in the renderer.
COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:40

References SHAPE_POLY_SET::AddOutline(), VECTOR2< T >::Angle(), APT_RECT, KIGFX::GAL::BitmapText(), SHAPE_POLY_SET::CacheTriangulation(), color, GERBER_DRAW_ITEM::ConvertSegmentToPolygon(), SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoints(), KIGFX::GAL::DrawArcSegment(), KIGFX::GAL::DrawCircle(), drawFlashedShape(), KIGFX::GAL::DrawLine(), KIGFX::GAL::DrawPolygon(), drawPolygon(), KIGFX::GAL::DrawPolyline(), KIGFX::GAL::DrawRectangle(), KIGFX::GAL::DrawSegment(), GBR_ARC, GBR_CIRCLE, GBR_POLYGON, GBR_SEGMENT, GBR_SPOT_CIRCLE, GBR_SPOT_MACRO, GBR_SPOT_OVAL, GBR_SPOT_POLY, GBR_SPOT_RECT, GERBER_DRAW_ITEM::GetABPosition(), GERBER_DRAW_ITEM::GetBoundingBox(), KIGFX::GERBVIEW_RENDER_SETTINGS::GetColor(), GERBER_DRAW_ITEM::GetDcodeDescr(), EDA_RECT::GetEnd(), BOX2< Vec >::GetEnd(), GERBER_DRAW_ITEM::GetLayerPolarity(), GetLineLength(), EDA_RECT::GetOrigin(), BOX2< Vec >::GetOrigin(), GetSettings(), GERBER_DRAW_ITEM::GetTextD_CodePrms(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, EDA_ITEM::IsBrightened(), IsDCodeLayer(), KIGFX::GAL::IsOpenGlEngine(), GERBER_DRAW_ITEM::m_ArcCentre, GERBER_DRAW_ITEM::m_DCode, GERBER_DRAW_ITEM::m_End, KIGFX::PAINTER::m_gal, GERBER_DRAW_ITEM::m_GerberImageFile, m_gerbviewSettings, GERBER_FILE_IMAGE::m_ImageNegative, KIGFX::GERBVIEW_RENDER_SETTINGS::m_lineFill, KIGFX::RENDER_SETTINGS::m_outlineWidth, GERBER_DRAW_ITEM::m_Polygon, KIGFX::GERBVIEW_RENDER_SETTINGS::m_polygonFill, GERBER_DRAW_ITEM::m_Shape, D_CODE::m_Shape, GERBER_DRAW_ITEM::m_Size, KIGFX::GERBVIEW_RENDER_SETTINGS::m_spotFill, GERBER_DRAW_ITEM::m_Start, SHAPE_POLY_SET::OutlineCount(), SHAPE_LINE_CHAIN::PointCount(), SHAPE_LINE_CHAIN::SetClosed(), KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetFontBold(), KIGFX::GAL::SetFontItalic(), KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetHorizontalJustify(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetNegativeDrawMode(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextMirrored(), KIGFX::GAL::SetVerticalJustify(), and GERBER_DRAW_ITEM::ViewBBox().

Referenced by Draw().

◆ drawApertureMacro()

void GERBVIEW_PAINTER::drawApertureMacro ( GERBER_DRAW_ITEM aParent,
bool  aFilled 
)
protected

Helper to draw an aperture macro shape.

Definition at line 565 of file gerbview_painter.cpp.

566 {
567  D_CODE* code = aParent->GetDcodeDescr();
568  APERTURE_MACRO* macro = code->GetMacro();
569 
570  SHAPE_POLY_SET* macroShape = macro->GetApertureMacroShape( aParent, aParent->m_Start );
571 
574 
575  if( !aFilled )
576  {
577  for( int i = 0; i < macroShape->OutlineCount(); i++ )
578  m_gal->DrawPolyline( macroShape->COutline( i ) );
579  }
580  else
581  m_gal->DrawPolygon( *macroShape );
582 }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
D_CODE * GetDcodeDescr() const
Function GetDcodeDescr returns the GetDcodeDescr of this object, or NULL.
int OutlineCount() const
Returns the number of outlines in the set
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.
Definition: painter.h:110
virtual void SetLineWidth(float aLineWidth)
Set the line width.
SHAPE_POLY_SET * GetApertureMacroShape(const GERBER_DRAW_ITEM *aParent, wxPoint aShapePos)
Function GetApertureMacroShape Calculate the primitive shape for flashed items.
SHAPE_POLY_SET.
bool m_polygonFill
Flag determining if polygons should be drawn with fill.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
D_CODE holds a gerber DCODE (also called Aperture) definition.
Definition: dcode.h:82
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
APERTURE_MACRO * GetMacro() const
Definition: dcode.h:157
Struct APERTURE_MACRO helps support the "aperture macro" defined within standard RS274X.
Definition: am_primitive.h:163

References SHAPE_POLY_SET::COutline(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawPolyline(), APERTURE_MACRO::GetApertureMacroShape(), GERBER_DRAW_ITEM::GetDcodeDescr(), D_CODE::GetMacro(), KIGFX::PAINTER::m_gal, m_gerbviewSettings, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::GERBVIEW_RENDER_SETTINGS::m_polygonFill, GERBER_DRAW_ITEM::m_Start, SHAPE_POLY_SET::OutlineCount(), and KIGFX::GAL::SetLineWidth().

Referenced by drawFlashedShape().

◆ drawFlashedShape()

void GERBVIEW_PAINTER::drawFlashedShape ( GERBER_DRAW_ITEM aItem,
bool  aFilled 
)
protected

Helper to draw a flashed shape (aka spot)

Definition at line 447 of file gerbview_painter.cpp.

448 {
449  D_CODE* code = aItem->GetDcodeDescr();
450 
451  wxASSERT_MSG( code, "drawFlashedShape: Item has no D_CODE!" );
452 
453  if( !code )
454  return;
455 
456  m_gal->SetIsFill( aFilled );
457  m_gal->SetIsStroke( !aFilled );
459 
460  switch( aItem->m_Shape )
461  {
462  case GBR_SPOT_CIRCLE:
463  {
464  int radius = code->m_Size.x >> 1;
465  VECTOR2D start( aItem->GetABPosition( aItem->m_Start ) );
466 
467  if( !aFilled || code->m_DrillShape == APT_DEF_NO_HOLE )
468  {
469  m_gal->DrawCircle( start, radius );
470  }
471  else // rectangular hole
472  {
473  if( code->m_Polygon.OutlineCount() == 0 )
474  code->ConvertShapeToPolygon();
475 
476  drawPolygon( aItem, code->m_Polygon, aFilled, true );
477  }
478 
479  break;
480  }
481 
482  case GBR_SPOT_RECT:
483  {
484  wxPoint codeStart;
485  wxPoint aShapePos = aItem->m_Start;
486  codeStart.x = aShapePos.x - code->m_Size.x / 2;
487  codeStart.y = aShapePos.y - code->m_Size.y / 2;
488  wxPoint codeEnd = codeStart + code->m_Size;
489  codeStart = aItem->GetABPosition( codeStart );
490  codeEnd = aItem->GetABPosition( codeEnd );
491 
492  if( !aFilled || code->m_DrillShape == APT_DEF_NO_HOLE )
493  {
494  m_gal->DrawRectangle( VECTOR2D( codeStart ), VECTOR2D( codeEnd ) );
495  }
496  else
497  {
498  if( code->m_Polygon.OutlineCount() == 0 )
499  code->ConvertShapeToPolygon();
500 
501  drawPolygon( aItem, code->m_Polygon, aFilled, true );
502  }
503  break;
504  }
505 
506  case GBR_SPOT_OVAL:
507  {
508  int radius = 0;
509 
510  wxPoint codeStart = aItem->m_Start;
511  wxPoint codeEnd = aItem->m_Start;
512 
513  if( code->m_Size.x > code->m_Size.y ) // horizontal oval
514  {
515  int delta = (code->m_Size.x - code->m_Size.y) / 2;
516  codeStart.x -= delta;
517  codeEnd.x += delta;
518  radius = code->m_Size.y;
519  }
520  else // horizontal oval
521  {
522  int delta = (code->m_Size.y - code->m_Size.x) / 2;
523  codeStart.y -= delta;
524  codeEnd.y += delta;
525  radius = code->m_Size.x;
526  }
527 
528  codeStart = aItem->GetABPosition( codeStart );
529  codeEnd = aItem->GetABPosition( codeEnd );
530 
531  if( !aFilled || code->m_DrillShape == APT_DEF_NO_HOLE )
532  {
533  m_gal->DrawSegment( codeStart, codeEnd, radius );
534  }
535  else
536  {
537  if( code->m_Polygon.OutlineCount() == 0 )
538  code->ConvertShapeToPolygon();
539 
540  drawPolygon( aItem, code->m_Polygon, aFilled, true );
541  }
542  break;
543  }
544 
545  case GBR_SPOT_POLY:
546  {
547  if( code->m_Polygon.OutlineCount() == 0 )
548  code->ConvertShapeToPolygon();
549 
550  drawPolygon( aItem, code->m_Polygon, aFilled, true );
551  break;
552  }
553 
554  case GBR_SPOT_MACRO:
555  drawApertureMacro( aItem, aFilled );
556  break;
557 
558  default:
559  wxASSERT_MSG( false, wxT( "Unknown Gerber flashed shape!" ) );
560  break;
561  }
562 }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a rectangle.
D_CODE * GetDcodeDescr() const
Function GetDcodeDescr returns the GetDcodeDescr of this object, or NULL.
int OutlineCount() const
Returns the number of outlines in the set
wxSize m_Size
Horizontal and vertical dimensions.
Definition: dcode.h:94
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.
Definition: painter.h:110
virtual void SetLineWidth(float aLineWidth)
Set the line width.
void drawApertureMacro(GERBER_DRAW_ITEM *aParent, bool aFilled)
Helper to draw an aperture macro shape.
wxPoint GetABPosition(const wxPoint &aXYPosition) const
Function GetABPosition returns the image position of aPosition for this object.
virtual void DrawSegment(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth)
Draw a rounded segment.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:593
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
APERTURE_DEF_HOLETYPE m_DrillShape
shape of the hole (0 = no hole, round = 1, rect = 2) */
Definition: dcode.h:98
D_CODE holds a gerber DCODE (also called Aperture) definition.
Definition: dcode.h:82
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
SHAPE_POLY_SET m_Polygon
Definition: dcode.h:107
void drawPolygon(GERBER_DRAW_ITEM *aParent, const SHAPE_POLY_SET &aPolygon, bool aFilled, bool aShift=false)
Helper routine to draw a polygon.
void ConvertShapeToPolygon()
Function ConvertShapeToPolygon convert a shape to an equivalent polygon.
Definition: dcode.cpp:301
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.

References APT_DEF_NO_HOLE, D_CODE::ConvertShapeToPolygon(), drawApertureMacro(), KIGFX::GAL::DrawCircle(), drawPolygon(), KIGFX::GAL::DrawRectangle(), KIGFX::GAL::DrawSegment(), GBR_SPOT_CIRCLE, GBR_SPOT_MACRO, GBR_SPOT_OVAL, GBR_SPOT_POLY, GBR_SPOT_RECT, GERBER_DRAW_ITEM::GetABPosition(), GERBER_DRAW_ITEM::GetDcodeDescr(), D_CODE::m_DrillShape, KIGFX::PAINTER::m_gal, m_gerbviewSettings, KIGFX::RENDER_SETTINGS::m_outlineWidth, D_CODE::m_Polygon, GERBER_DRAW_ITEM::m_Shape, D_CODE::m_Size, GERBER_DRAW_ITEM::m_Start, SHAPE_POLY_SET::OutlineCount(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), wxPoint::x, and wxPoint::y.

Referenced by draw().

◆ drawPolygon()

void GERBVIEW_PAINTER::drawPolygon ( GERBER_DRAW_ITEM aParent,
const SHAPE_POLY_SET aPolygon,
bool  aFilled,
bool  aShift = false 
)
protected

Helper routine to draw a polygon.

Parameters
aParentPointer to the draw item for AB Position calculation
aPolygonthe polygon to draw
aFilledIf true, draw the polygon as filled, otherwise only outline
aShiftIf true, draw the polygon relative to the parent item position

Definition at line 419 of file gerbview_painter.cpp.

421 {
422  wxASSERT( aPolygon.OutlineCount() == 1 );
423 
424  if( aPolygon.OutlineCount() == 0 )
425  return;
426 
427  SHAPE_POLY_SET poly;
428  poly.NewOutline();
429  const std::vector<VECTOR2I> pts = aPolygon.COutline( 0 ).CPoints();
430  VECTOR2I offset = aShift ? VECTOR2I( aParent->m_Start ) : VECTOR2I( 0, 0 );
431 
432  for( auto& pt : pts )
433  poly.Append( aParent->GetABPosition( pt + offset ) );
434 
437 
438  if( !aFilled )
439  {
440  m_gal->DrawPolyline( poly.COutline( 0 ) );
441  }
442  else
443  m_gal->DrawPolygon( poly );
444 }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
int OutlineCount() const
Returns the number of outlines in the set
VECTOR2< int > VECTOR2I
Definition: vector2d.h:594
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.
Definition: painter.h:110
virtual void SetLineWidth(float aLineWidth)
Set the line width.
wxPoint GetABPosition(const wxPoint &aXYPosition) const
Function GetABPosition returns the image position of aPosition for this object.
const std::vector< VECTOR2I > & CPoints() const
SHAPE_POLY_SET.
int NewOutline()
Creates a new empty polygon in the set and returns its index
bool m_polygonFill
Flag determining if polygons should be drawn with fill.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Appends a vertex at the end of the given outline/hole (default: the last outline)

References SHAPE_POLY_SET::Append(), SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoints(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawPolyline(), GERBER_DRAW_ITEM::GetABPosition(), KIGFX::PAINTER::m_gal, m_gerbviewSettings, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::GERBVIEW_RENDER_SETTINGS::m_polygonFill, GERBER_DRAW_ITEM::m_Start, SHAPE_POLY_SET::NewOutline(), SHAPE_POLY_SET::OutlineCount(), and KIGFX::GAL::SetLineWidth().

Referenced by draw(), and drawFlashedShape().

◆ getLineThickness()

int GERBVIEW_PAINTER::getLineThickness ( int  aActualThickness) const
protected

Function getLineThickness() Get the thickness to draw for a line (e.g.

0 thickness lines get a minimum value).

Parameters
aActualThicknessline own thickness
Returns
the thickness to draw

Definition at line 158 of file gerbview_painter.cpp.

159 {
160  // if items have 0 thickness, draw them with the outline
161  // width, otherwise respect the set value (which, no matter
162  // how small will produce something)
163  if( aActualThickness == 0 )
165 
166  return aActualThickness;
167 }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings

References m_gerbviewSettings, and KIGFX::RENDER_SETTINGS::m_outlineWidth.

◆ GetSettings()

virtual GERBVIEW_RENDER_SETTINGS* KIGFX::GERBVIEW_PAINTER::GetSettings ( )
inlineoverridevirtual

Implements KIGFX::PAINTER.

Definition at line 179 of file gerbview_painter.h.

180  {
181  return &m_gerbviewSettings;
182  }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings

References m_gerbviewSettings.

Referenced by draw().

◆ SetGAL()

void KIGFX::PAINTER::SetGAL ( GAL aGal)
inlineinherited

Function SetGAL Changes Graphics Abstraction Layer used for drawing items for a new one.

Parameters
aGalis the new GAL instance.

Definition at line 78 of file painter.h.

79  {
80  m_gal = aGal;
81  }
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.
Definition: painter.h:110

References KIGFX::PAINTER::m_gal.

Member Data Documentation

◆ m_brightenedColor

COLOR4D KIGFX::PAINTER::m_brightenedColor
protectedinherited

Color of brightened item frame.

Definition at line 113 of file painter.h.

◆ m_gal

◆ m_gerbviewSettings

GERBVIEW_RENDER_SETTINGS KIGFX::GERBVIEW_PAINTER::m_gerbviewSettings
protected

The documentation for this class was generated from the following files: