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:99
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:112

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( wxT( "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  // We use the fastest CacheTriangulation calculation mode: no partition created because
303  // the partition is useless in Gerbview, and very time consumming (optimized only
304  // for pcbnew that has different internal unit)
305  if( m_gal->IsOpenGlEngine() && !aItem->m_AbsolutePolygon.IsTriangulationUpToDate() )
306  aItem->m_AbsolutePolygon.CacheTriangulation( false /* fastest triangulation calculation mode */ );
307 
308  m_gal->DrawPolygon( aItem->m_AbsolutePolygon );
309  }
310 
311  break;
312  }
313 
314  case GBR_CIRCLE:
315  {
316  isFilled = m_gerbviewSettings.m_lineFill;
317  double radius = GetLineLength( aItem->m_Start, aItem->m_End );
318  m_gal->DrawCircle( start, radius );
319  break;
320  }
321 
322  case GBR_ARC:
323  {
324  isFilled = m_gerbviewSettings.m_lineFill;
325 
326  // These are swapped because wxDC fills arcs counterclockwise and GAL
327  // fills them clockwise.
328  wxPoint arcStart = aItem->m_End;
329  wxPoint arcEnd = aItem->m_Start;
330 
331  // Gerber arcs are 3-point (start, center, end)
332  // GAL needs center, radius, start angle, end angle
333  double radius = GetLineLength( arcStart, aItem->m_ArcCentre );
334  VECTOR2D center = aItem->GetABPosition( aItem->m_ArcCentre );
335  VECTOR2D startVec = VECTOR2D( aItem->GetABPosition( arcStart ) ) - center;
336  VECTOR2D endVec = VECTOR2D( aItem->GetABPosition( arcEnd ) ) - center;
337 
338  m_gal->SetIsFill( isFilled );
339  m_gal->SetIsStroke( !isFilled );
340  m_gal->SetLineWidth( isFilled ? width : m_gerbviewSettings.m_outlineWidth );
341 
342  double startAngle = startVec.Angle();
343  double endAngle = endVec.Angle();
344 
345  // GAL fills in direction of increasing angle, so we have to convert
346  // the angle from the -PI to PI domain of atan2() to ensure that
347  // the arc goes in the right direction
348  if( startAngle > endAngle )
349  endAngle += (2 * M_PI);
350 
351  // In Gerber, 360-degree arcs are stored in the file with start equal to end
352  if( arcStart == arcEnd )
353  {
354  endAngle = startAngle + 2*M_PI;
355  }
356 
357  m_gal->DrawArcSegment( center, radius, startAngle, endAngle, width, ARC_HIGH_DEF );
358 
359 #if 0 // Arc Debugging only
360  m_gal->SetIsFill( false );
361  m_gal->SetIsStroke( true );
362  m_gal->SetLineWidth( 5 );
363  m_gal->SetStrokeColor( COLOR4D( 0.1, 0.5, 0.0, 0.5 ) );
364  m_gal->DrawLine( center, aItem->GetABPosition( arcStart ) );
365  m_gal->SetStrokeColor( COLOR4D( 0.6, 0.1, 0.0, 0.5 ) );
366  m_gal->DrawLine( center, aItem->GetABPosition( arcEnd ) );
367 #endif
368 
369 #if 0 // Bbox arc Debugging only
370  m_gal->SetIsFill( false );
371  m_gal->SetIsStroke( true );
372  EDA_RECT box = aItem->GetBoundingBox();
373  m_gal->SetLineWidth( 5 );
374  m_gal->SetStrokeColor( COLOR4D(0.9, 0.9, 0, 0.4) );
375  // box coordinates are already in AB position.
376  m_gal->DrawRectangle( box.GetOrigin(), box.GetEnd() );
377 #endif
378  break;
379  }
380 
381  case GBR_SPOT_CIRCLE:
382  case GBR_SPOT_RECT:
383  case GBR_SPOT_OVAL:
384  case GBR_SPOT_POLY:
385  case GBR_SPOT_MACRO:
386  {
387  isFilled = m_gerbviewSettings.m_spotFill;
388  drawFlashedShape( aItem, isFilled );
389  break;
390  }
391 
392  case GBR_SEGMENT:
393  {
394  /* Plot a line from m_Start to m_End.
395  * Usually, a round pen is used, but some gerber files use a rectangular pen
396  * In fact, any aperture can be used to plot a line.
397  * currently: only a square pen is handled (I believe using a polygon gives a strange plot).
398  */
399  isFilled = m_gerbviewSettings.m_lineFill;
400  m_gal->SetIsFill( isFilled );
401  m_gal->SetIsStroke( !isFilled );
402 
403  if( isNegative && !isFilled )
404  m_gal->SetStrokeColor( GetSettings()->GetColor( aItem, aLayer ) );
405 
406  // TODO(JE) Refactor this to allow const aItem
407  D_CODE* code = aItem->GetDcodeDescr();
408  if( code && code->m_Shape == APT_RECT )
409  {
410  if( aItem->m_Polygon.OutlineCount() == 0 )
411  aItem->ConvertSegmentToPolygon();
412 
413  drawPolygon( aItem, aItem->m_Polygon, isFilled );
414  }
415  else
416  {
417  if( !isFilled )
419 
420  m_gal->DrawSegment( start, end, width );
421  }
422  break;
423  }
424 
425  default:
426  wxASSERT_MSG( false, wxT( "GERBER_DRAW_ITEM shape is unknown!" ) );
427  break;
428  }
429  m_gal->SetNegativeDrawMode( false );
430 
431  // Enable for bounding box debugging
432  #if 0
433  const BOX2I& bb = aItem->ViewBBox();
434  m_gal->SetIsStroke( true );
435  m_gal->SetIsFill( true );
436  m_gal->SetLineWidth( 3 );
437  m_gal->SetStrokeColor( COLOR4D(0.9, 0.9, 0, 0.4) );
438  m_gal->SetFillColor( COLOR4D(0.9, 0.9, 0, 0.1) );
439  m_gal->DrawRectangle( bb.GetOrigin(), bb.GetEnd() );
440  #endif
441 }
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:989
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:112
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:621
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
const wxPoint GetOrigin() const
Definition: eda_rect.h:110
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 containing arcs as well as line segments: A chain of connected line and/or arc s...
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 590 of file gerbview_painter.cpp.

591 {
592  D_CODE* code = aParent->GetDcodeDescr();
593  APERTURE_MACRO* macro = code->GetMacro();
594 
595  SHAPE_POLY_SET* macroShape = macro->GetApertureMacroShape( aParent, aParent->m_Start );
596 
599 
600  if( !aFilled )
601  {
602  for( int i = 0; i < macroShape->OutlineCount(); i++ )
603  m_gal->DrawPolyline( macroShape->COutline( i ) );
604  }
605  else
606  m_gal->DrawPolygon( *macroShape );
607 }
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 472 of file gerbview_painter.cpp.

473 {
474  D_CODE* code = aItem->GetDcodeDescr();
475 
476  wxASSERT_MSG( code, wxT( "drawFlashedShape: Item has no D_CODE!" ) );
477 
478  if( !code )
479  return;
480 
481  m_gal->SetIsFill( aFilled );
482  m_gal->SetIsStroke( !aFilled );
484 
485  switch( aItem->m_Shape )
486  {
487  case GBR_SPOT_CIRCLE:
488  {
489  int radius = code->m_Size.x >> 1;
490  VECTOR2D start( aItem->GetABPosition( aItem->m_Start ) );
491 
492  if( !aFilled || code->m_DrillShape == APT_DEF_NO_HOLE )
493  {
494  m_gal->DrawCircle( start, radius );
495  }
496  else // rectangular hole
497  {
498  if( code->m_Polygon.OutlineCount() == 0 )
499  code->ConvertShapeToPolygon();
500 
501  drawPolygon( aItem, code->m_Polygon, aFilled, true );
502  }
503 
504  break;
505  }
506 
507  case GBR_SPOT_RECT:
508  {
509  wxPoint codeStart;
510  wxPoint aShapePos = aItem->m_Start;
511  codeStart.x = aShapePos.x - code->m_Size.x / 2;
512  codeStart.y = aShapePos.y - code->m_Size.y / 2;
513  wxPoint codeEnd = codeStart + code->m_Size;
514  codeStart = aItem->GetABPosition( codeStart );
515  codeEnd = aItem->GetABPosition( codeEnd );
516 
517  if( !aFilled || code->m_DrillShape == APT_DEF_NO_HOLE )
518  {
519  m_gal->DrawRectangle( VECTOR2D( codeStart ), VECTOR2D( codeEnd ) );
520  }
521  else
522  {
523  if( code->m_Polygon.OutlineCount() == 0 )
524  code->ConvertShapeToPolygon();
525 
526  drawPolygon( aItem, code->m_Polygon, aFilled, true );
527  }
528  break;
529  }
530 
531  case GBR_SPOT_OVAL:
532  {
533  int radius = 0;
534 
535  wxPoint codeStart = aItem->m_Start;
536  wxPoint codeEnd = aItem->m_Start;
537 
538  if( code->m_Size.x > code->m_Size.y ) // horizontal oval
539  {
540  int delta = (code->m_Size.x - code->m_Size.y) / 2;
541  codeStart.x -= delta;
542  codeEnd.x += delta;
543  radius = code->m_Size.y;
544  }
545  else // horizontal oval
546  {
547  int delta = (code->m_Size.y - code->m_Size.x) / 2;
548  codeStart.y -= delta;
549  codeEnd.y += delta;
550  radius = code->m_Size.x;
551  }
552 
553  codeStart = aItem->GetABPosition( codeStart );
554  codeEnd = aItem->GetABPosition( codeEnd );
555 
556  if( !aFilled || code->m_DrillShape == APT_DEF_NO_HOLE )
557  {
558  m_gal->DrawSegment( codeStart, codeEnd, radius );
559  }
560  else
561  {
562  if( code->m_Polygon.OutlineCount() == 0 )
563  code->ConvertShapeToPolygon();
564 
565  drawPolygon( aItem, code->m_Polygon, aFilled, true );
566  }
567  break;
568  }
569 
570  case GBR_SPOT_POLY:
571  {
572  if( code->m_Polygon.OutlineCount() == 0 )
573  code->ConvertShapeToPolygon();
574 
575  drawPolygon( aItem, code->m_Polygon, aFilled, true );
576  break;
577  }
578 
579  case GBR_SPOT_MACRO:
580  drawApertureMacro( aItem, aFilled );
581  break;
582 
583  default:
584  wxASSERT_MSG( false, wxT( "Unknown Gerber flashed shape!" ) );
585  break;
586  }
587 }
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:621
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 444 of file gerbview_painter.cpp.

446 {
447  wxASSERT( aPolygon.OutlineCount() == 1 );
448 
449  if( aPolygon.OutlineCount() == 0 )
450  return;
451 
452  SHAPE_POLY_SET poly;
453  poly.NewOutline();
454  const std::vector<VECTOR2I> pts = aPolygon.COutline( 0 ).CPoints();
455  VECTOR2I offset = aShift ? VECTOR2I( aParent->m_Start ) : VECTOR2I( 0, 0 );
456 
457  for( auto& pt : pts )
458  poly.Append( aParent->GetABPosition( pt + offset ) );
459 
462 
463  if( !aFilled )
464  {
465  m_gal->DrawPolyline( poly.COutline( 0 ) );
466  }
467  else
468  m_gal->DrawPolygon( poly );
469 }
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:622
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: