KiCad PCB EDA Suite
KIGFX::GERBVIEW_PAINTER Class Reference

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 GERBVIEW_RENDER_SETTINGSGetSettings () override
 Return a pointer to current settings that are going to be used when drawing items. More...
 
virtual bool Draw (const VIEW_ITEM *aItem, int aLayer) override
 Takes an instance of VIEW_ITEM and passes it to a function that knows how to draw the item. More...
 
void SetGAL (GAL *aGal)
 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
 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...
 

Detailed Description

Methods for drawing GerbView specific items.

Definition at line 175 of file gerbview_painter.h.

Constructor & Destructor Documentation

◆ GERBVIEW_PAINTER()

GERBVIEW_PAINTER::GERBVIEW_PAINTER ( GAL aGal)

Definition at line 167 of file gerbview_painter.cpp.

167  :
168  PAINTER( aGal )
169 {
170 }
PAINTER(GAL *aGal)
Initialize this object for painting on any of the polymorphic GRAPHICS_ABSTRACTION_LAYER* derivatives...
Definition: painter.cpp:32

Member Function Documentation

◆ Draw()

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

Takes an instance of VIEW_ITEM and passes it to a function that knows 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 186 of file gerbview_painter.cpp.

187 {
188  const EDA_ITEM* item = dynamic_cast<const EDA_ITEM*>( aItem );
189 
190  if( !item )
191  return false;
192 
193  // the "cast" applied in here clarifies which overloaded draw() is called
194  switch( item->Type() )
195  {
196  case GERBER_DRAW_ITEM_T:
197  draw( static_cast<GERBER_DRAW_ITEM*>( const_cast<EDA_ITEM*>( item ) ), aLayer );
198  break;
199 
200  default:
201  // Painter does not know how to draw the object
202  return false;
203  }
204 
205  return true;
206 }
void draw(GERBER_DRAW_ITEM *aVia, int aLayer)
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:100
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:113

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 211 of file gerbview_painter.cpp.

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

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(), KIGFX::GERBVIEW_RENDER_SETTINGS::IsShowNegativeItems(), SHAPE_POLY_SET::IsTriangulationUpToDate(), GERBER_DRAW_ITEM::m_AbsolutePolygon, 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, D_CODE::m_Shape, GERBER_DRAW_ITEM::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::SetFontUnderlined(), 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 587 of file gerbview_painter.cpp.

588 {
589  D_CODE* code = aParent->GetDcodeDescr();
590  APERTURE_MACRO* macro = code->GetMacro();
591 
592  SHAPE_POLY_SET* macroShape = macro->GetApertureMacroShape( aParent, aParent->m_Start );
593 
596 
597  if( !aFilled )
598  {
599  for( int i = 0; i < macroShape->OutlineCount(); i++ )
600  m_gal->DrawPolyline( macroShape->COutline( i ) );
601  }
602  else
603  m_gal->DrawPolygon( *macroShape );
604 }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
D_CODE * GetDcodeDescr() const
Return the GetDcodeDescr of this object, or NULL.
int OutlineCount() const
Return the number of vertices in a given outline/hole.
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.
Definition: painter.h:101
virtual void SetLineWidth(float aLineWidth)
Set the line width.
Represent a set of closed polygons.
bool m_polygonFill
Flag determining if polygons should be drawn with fill.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
A gerber DCODE (also called Aperture) definition.
Definition: dcode.h:80
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
APERTURE_MACRO * GetMacro() const
Definition: dcode.h:125
Support the "aperture macro" defined within standard RS274X.
Definition: am_primitive.h:167
SHAPE_POLY_SET * GetApertureMacroShape(const GERBER_DRAW_ITEM *aParent, const wxPoint &aShapePos)
Calculate the primitive shape for flashed items.

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 469 of file gerbview_painter.cpp.

470 {
471  D_CODE* code = aItem->GetDcodeDescr();
472 
473  wxASSERT_MSG( code, "drawFlashedShape: Item has no D_CODE!" );
474 
475  if( !code )
476  return;
477 
478  m_gal->SetIsFill( aFilled );
479  m_gal->SetIsStroke( !aFilled );
481 
482  switch( aItem->m_Shape )
483  {
484  case GBR_SPOT_CIRCLE:
485  {
486  int radius = code->m_Size.x >> 1;
487  VECTOR2D start( aItem->GetABPosition( aItem->m_Start ) );
488 
489  if( !aFilled || code->m_DrillShape == APT_DEF_NO_HOLE )
490  {
491  m_gal->DrawCircle( start, radius );
492  }
493  else // rectangular hole
494  {
495  if( code->m_Polygon.OutlineCount() == 0 )
496  code->ConvertShapeToPolygon();
497 
498  drawPolygon( aItem, code->m_Polygon, aFilled, true );
499  }
500 
501  break;
502  }
503 
504  case GBR_SPOT_RECT:
505  {
506  wxPoint codeStart;
507  wxPoint aShapePos = aItem->m_Start;
508  codeStart.x = aShapePos.x - code->m_Size.x / 2;
509  codeStart.y = aShapePos.y - code->m_Size.y / 2;
510  wxPoint codeEnd = codeStart + code->m_Size;
511  codeStart = aItem->GetABPosition( codeStart );
512  codeEnd = aItem->GetABPosition( codeEnd );
513 
514  if( !aFilled || code->m_DrillShape == APT_DEF_NO_HOLE )
515  {
516  m_gal->DrawRectangle( VECTOR2D( codeStart ), VECTOR2D( codeEnd ) );
517  }
518  else
519  {
520  if( code->m_Polygon.OutlineCount() == 0 )
521  code->ConvertShapeToPolygon();
522 
523  drawPolygon( aItem, code->m_Polygon, aFilled, true );
524  }
525  break;
526  }
527 
528  case GBR_SPOT_OVAL:
529  {
530  int radius = 0;
531 
532  wxPoint codeStart = aItem->m_Start;
533  wxPoint codeEnd = aItem->m_Start;
534 
535  if( code->m_Size.x > code->m_Size.y ) // horizontal oval
536  {
537  int delta = (code->m_Size.x - code->m_Size.y) / 2;
538  codeStart.x -= delta;
539  codeEnd.x += delta;
540  radius = code->m_Size.y;
541  }
542  else // horizontal oval
543  {
544  int delta = (code->m_Size.y - code->m_Size.x) / 2;
545  codeStart.y -= delta;
546  codeEnd.y += delta;
547  radius = code->m_Size.x;
548  }
549 
550  codeStart = aItem->GetABPosition( codeStart );
551  codeEnd = aItem->GetABPosition( codeEnd );
552 
553  if( !aFilled || code->m_DrillShape == APT_DEF_NO_HOLE )
554  {
555  m_gal->DrawSegment( codeStart, codeEnd, radius );
556  }
557  else
558  {
559  if( code->m_Polygon.OutlineCount() == 0 )
560  code->ConvertShapeToPolygon();
561 
562  drawPolygon( aItem, code->m_Polygon, aFilled, true );
563  }
564  break;
565  }
566 
567  case GBR_SPOT_POLY:
568  {
569  if( code->m_Polygon.OutlineCount() == 0 )
570  code->ConvertShapeToPolygon();
571 
572  drawPolygon( aItem, code->m_Polygon, aFilled, true );
573  break;
574  }
575 
576  case GBR_SPOT_MACRO:
577  drawApertureMacro( aItem, aFilled );
578  break;
579 
580  default:
581  wxASSERT_MSG( false, wxT( "Unknown Gerber flashed shape!" ) );
582  break;
583  }
584 }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a rectangle.
D_CODE * GetDcodeDescr() const
Return the GetDcodeDescr of this object, or NULL.
int OutlineCount() const
Return the number of vertices in a given outline/hole.
wxSize m_Size
Horizontal and vertical dimensions.
Definition: dcode.h:188
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.
Definition: painter.h:101
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
Return 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:622
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:192
A gerber DCODE (also called Aperture) definition.
Definition: dcode.h:80
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
SHAPE_POLY_SET m_Polygon
Definition: dcode.h:203
void drawPolygon(GERBER_DRAW_ITEM *aParent, const SHAPE_POLY_SET &aPolygon, bool aFilled, bool aShift=false)
Helper routine to draw a polygon.
constexpr int delta
void ConvertShapeToPolygon()
Convert a shape to an equivalent polygon.
Definition: dcode.cpp:298
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.

References APT_DEF_NO_HOLE, D_CODE::ConvertShapeToPolygon(), delta, 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(), and KIGFX::GAL::SetLineWidth().

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 441 of file gerbview_painter.cpp.

443 {
444  wxASSERT( aPolygon.OutlineCount() == 1 );
445 
446  if( aPolygon.OutlineCount() == 0 )
447  return;
448 
449  SHAPE_POLY_SET poly;
450  poly.NewOutline();
451  const std::vector<VECTOR2I> pts = aPolygon.COutline( 0 ).CPoints();
452  VECTOR2I offset = aShift ? VECTOR2I( aParent->m_Start ) : VECTOR2I( 0, 0 );
453 
454  for( auto& pt : pts )
455  poly.Append( aParent->GetABPosition( pt + offset ) );
456 
459 
460  if( !aFilled )
461  {
462  m_gal->DrawPolyline( poly.COutline( 0 ) );
463  }
464  else
465  m_gal->DrawPolygon( poly );
466 }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
int OutlineCount() const
Return the number of vertices in a given outline/hole.
VECTOR2< int > VECTOR2I
Definition: vector2d.h:623
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.
Definition: painter.h:101
virtual void SetLineWidth(float aLineWidth)
Set the line width.
wxPoint GetABPosition(const wxPoint &aXYPosition) const
Return the image position of aPosition for this object.
const std::vector< VECTOR2I > & CPoints() const
Represent a set of closed polygons.
int NewOutline()
Creates a new hole in a given outline.
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)
Add a new vertex to the contour indexed by aOutline and aHole (defaults to the outline of the last po...

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

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 174 of file gerbview_painter.cpp.

175 {
176  // if items have 0 thickness, draw them with the outline
177  // width, otherwise respect the set value (which, no matter
178  // how small will produce something)
179  if( aActualThickness == 0 )
181 
182  return aActualThickness;
183 }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings

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

◆ GetSettings()

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

Return a pointer to current settings that are going to be used when drawing items.

Returns
Current rendering settings.

Implements KIGFX::PAINTER.

Definition at line 181 of file gerbview_painter.h.

182  {
183  return &m_gerbviewSettings;
184  }
GERBVIEW_RENDER_SETTINGS m_gerbviewSettings

References m_gerbviewSettings.

Referenced by draw().

◆ SetGAL()

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

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

Parameters
aGalis the new GAL instance.

Definition at line 75 of file painter.h.

76  {
77  m_gal = aGal;
78  }
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.
Definition: painter.h:101

References KIGFX::PAINTER::m_gal.

Member Data Documentation

◆ m_gal

◆ m_gerbviewSettings

GERBVIEW_RENDER_SETTINGS KIGFX::GERBVIEW_PAINTER::m_gerbviewSettings
protected

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