KiCad PCB EDA Suite
KIGFX::PCB_PAINTER Class Reference

Class PCB_PAINTER Contains methods for drawing PCB-specific items. More...

#include <pcb_painter.h>

Inheritance diagram for KIGFX::PCB_PAINTER:
KIGFX::PAINTER KIGFX::PCB_PRINT_PAINTER

Public Member Functions

 PCB_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 PCB_RENDER_SETTINGSGetSettings () override
 Function GetSettings Returns pointer to current settings that are going to be used when drawing items. More...
 
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 (const TRACK *aTrack, int aLayer)
 
void draw (const VIA *aVia, int aLayer)
 
void draw (const D_PAD *aPad, int aLayer)
 
void draw (const DRAWSEGMENT *aSegment, int aLayer)
 
void draw (const TEXTE_PCB *aText, int aLayer)
 
void draw (const TEXTE_MODULE *aText, int aLayer)
 
void draw (const MODULE *aModule, int aLayer)
 
void draw (const ZONE_CONTAINER *aZone, int aLayer)
 
void draw (const DIMENSION *aDimension, int aLayer)
 
void draw (const PCB_TARGET *aTarget)
 
void draw (const MARKER_PCB *aMarker)
 
int getLineThickness (int aActualThickness) const
 Function getLineThickness() Get the thickness to draw for a line (e.g. More...
 
virtual int getDrillShape (const D_PAD *aPad) const
 Return drill shape of a pad. More...
 
virtual VECTOR2D getDrillSize (const D_PAD *aPad) const
 Return drill size for a pad (internal units). More...
 
virtual int getDrillSize (const VIA *aVia) const
 Return drill diameter for a via (internal units). More...
 

Protected Attributes

PCB_RENDER_SETTINGS m_pcbSettings
 
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

Class PCB_PAINTER Contains methods for drawing PCB-specific items.

Definition at line 211 of file pcb_painter.h.

Constructor & Destructor Documentation

PCB_PAINTER::PCB_PAINTER ( GAL aGal)

Definition at line 265 of file pcb_painter.cpp.

265  :
266  PAINTER( aGal )
267 {
268 }
PAINTER(GAL *aGal)
Constructor PAINTER( GAL* ) initializes this object for painting on any of the polymorphic GRAPHICS_A...
Definition: painter.cpp:68

Member Function Documentation

virtual void KIGFX::PCB_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 217 of file pcb_painter.h.

218  {
219  m_pcbSettings = *static_cast<const PCB_RENDER_SETTINGS*>( aSettings );
220  }
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
bool PCB_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 301 of file pcb_painter.cpp.

References draw(), PCB_DIMENSION_T, PCB_LINE_T, PCB_MARKER_T, PCB_MODULE_EDGE_T, PCB_MODULE_T, PCB_MODULE_TEXT_T, PCB_PAD_T, PCB_SEGZONE_T, PCB_TARGET_T, PCB_TEXT_T, PCB_TRACE_T, PCB_VIA_T, PCB_ZONE_AREA_T, and EDA_ITEM::Type().

302 {
303  const EDA_ITEM* item = dynamic_cast<const EDA_ITEM*>( aItem );
304 
305  if( !item )
306  return false;
307 
308  // the "cast" applied in here clarifies which overloaded draw() is called
309  switch( item->Type() )
310  {
311  case PCB_SEGZONE_T:
312  case PCB_TRACE_T:
313  draw( static_cast<const TRACK*>( item ), aLayer );
314  break;
315 
316  case PCB_VIA_T:
317  draw( static_cast<const VIA*>( item ), aLayer );
318  break;
319 
320  case PCB_PAD_T:
321  draw( static_cast<const D_PAD*>( item ), aLayer );
322  break;
323 
324  case PCB_LINE_T:
325  case PCB_MODULE_EDGE_T:
326  draw( static_cast<const DRAWSEGMENT*>( item ), aLayer );
327  break;
328 
329  case PCB_TEXT_T:
330  draw( static_cast<const TEXTE_PCB*>( item ), aLayer );
331  break;
332 
333  case PCB_MODULE_TEXT_T:
334  draw( static_cast<const TEXTE_MODULE*>( item ), aLayer );
335  break;
336 
337  case PCB_MODULE_T:
338  draw( static_cast<const MODULE*>( item ), aLayer );
339  break;
340 
341  case PCB_ZONE_AREA_T:
342  draw( static_cast<const ZONE_CONTAINER*>( item ), aLayer );
343  break;
344 
345  case PCB_DIMENSION_T:
346  draw( static_cast<const DIMENSION*>( item ), aLayer );
347  break;
348 
349  case PCB_TARGET_T:
350  draw( static_cast<const PCB_TARGET*>( item ) );
351  break;
352 
353  case PCB_MARKER_T:
354  draw( static_cast<const MARKER_PCB*>( item ) );
355  break;
356 
357  default:
358  // Painter does not know how to draw the object
359  return false;
360  }
361 
362  return true;
363 }
KICAD_T Type() const
Function Type()
Definition: base_struct.h:201
class ZONE_CONTAINER, a zone area
Definition: typeinfo.h:102
class TEXTE_PCB, text on a layer
Definition: typeinfo.h:92
class D_PAD, a pad in a footprint
Definition: typeinfo.h:90
class EDGE_MODULE, a footprint edge
Definition: typeinfo.h:94
class TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
class MODULE, a footprint
Definition: typeinfo.h:89
class DIMENSION, a dimension (graphic item)
Definition: typeinfo.h:100
class PCB_TARGET, a target (graphic item)
Definition: typeinfo.h:101
class TEXTE_MODULE, text in a footprint
Definition: typeinfo.h:93
class MARKER_PCB, a marker used to show something
Definition: typeinfo.h:99
Class EDA_ITEM is a base class for most all the KiCad significant classes, used in schematics and boa...
Definition: base_struct.h:154
class VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
class DRAWSEGMENT, a segment not on copper layers
Definition: typeinfo.h:91
void draw(const TRACK *aTrack, int aLayer)
class SEGZONE, a segment used to fill a zone area (segment on a
Definition: typeinfo.h:97
void PCB_PAINTER::draw ( const TRACK aTrack,
int  aLayer 
)
protected

Definition at line 366 of file pcb_painter.cpp.

References KIGFX::GAL::BitmapText(), KIGFX::PCB_RENDER_SETTINGS::CL_EXISTING, KIGFX::PCB_RENDER_SETTINGS::CL_TRACKS, color, KIGFX::GAL::DrawSegment(), VECTOR2< T >::EuclideanNorm(), TRACK::GetClearance(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), TRACK::GetEnd(), BOARD_CONNECTED_ITEM::GetNetCode(), BOARD_CONNECTED_ITEM::GetShortNetname(), TRACK::GetStart(), TRACK::GetWidth(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, IsCopperLayer(), IsNetnameLayer(), LAYER_TRACKS, KIGFX::PCB_RENDER_SETTINGS::m_clearance, KIGFX::PAINTER::m_gal, KIGFX::PCB_RENDER_SETTINGS::m_netNamesOnTracks, KIGFX::RENDER_SETTINGS::m_outlineWidth, m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, 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::SetStrokeColor(), KIGFX::GAL::SetTextMirrored(), KIGFX::GAL::SetVerticalJustify(), NETINFO_LIST::UNCONNECTED, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Draw().

367 {
368  VECTOR2D start( aTrack->GetStart() );
369  VECTOR2D end( aTrack->GetEnd() );
370  int width = aTrack->GetWidth();
371 
373  {
374  // If there is a net name - display it on the track
375  if( aTrack->GetNetCode() > NETINFO_LIST::UNCONNECTED )
376  {
377  VECTOR2D line = ( end - start );
378  double length = line.EuclideanNorm();
379 
380  // Check if the track is long enough to have a netname displayed
381  if( length < 10 * width )
382  return;
383 
384  const wxString& netName = aTrack->GetShortNetname();
385  VECTOR2D textPosition = start + line / 2.0; // center of the track
386 
387  double textOrientation;
388 
389  if( end.y == start.y ) // horizontal
390  textOrientation = 0;
391  else if( end.x == start.x ) // vertical
392  textOrientation = M_PI / 2;
393  else
394  textOrientation = -atan( line.y / line.x );
395 
396  double textSize = width;
397 
398  m_gal->SetIsStroke( true );
399  m_gal->SetIsFill( false );
400  m_gal->SetStrokeColor( m_pcbSettings.GetColor( NULL, aLayer ) );
401  m_gal->SetLineWidth( width / 10.0 );
402  m_gal->SetFontBold( false );
403  m_gal->SetFontItalic( false );
404  m_gal->SetTextMirrored( false );
405  m_gal->SetGlyphSize( VECTOR2D( textSize * 0.7, textSize * 0.7 ) );
408  m_gal->BitmapText( netName, textPosition, textOrientation );
409  }
410  }
411  else if( IsCopperLayer( aLayer ) )
412  {
413  // Draw a regular track
414  const COLOR4D& color = m_pcbSettings.GetColor( aTrack, aLayer );
415  m_gal->SetStrokeColor( color );
416  m_gal->SetIsStroke( true );
417 
419  {
420  // Outline mode
422  m_gal->SetIsFill( false );
423  }
424  else
425  {
426  // Filled mode
427  m_gal->SetFillColor( color );
428  m_gal->SetIsFill( true );
429  }
430 
431  m_gal->DrawSegment( start, end, width );
432 
433  // Clearance lines
434  constexpr int clearanceFlags = PCB_RENDER_SETTINGS::CL_EXISTING | PCB_RENDER_SETTINGS::CL_TRACKS;
435 
436  if( ( m_pcbSettings.m_clearance & clearanceFlags ) == clearanceFlags )
437  {
439  m_gal->SetIsFill( false );
440  m_gal->SetIsStroke( true );
441  m_gal->SetStrokeColor( color );
442  m_gal->DrawSegment( start, end, width + aTrack->GetClearance() * 2 );
443  }
444  }
445 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
void SetFontItalic(const bool aItalic)
Set italic property of current font.
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:287
virtual void BitmapText(const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draws a text using a bitmap font.
bool m_sketchMode[GAL_LAYER_ID_END]
Flag determining if items on a given layer should be drawn as an outline or a filled item ...
Definition: pcb_painter.h:167
int color
Definition: DXF_plotter.cpp:62
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...
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
const wxPoint & GetEnd() const
Definition: class_track.h:123
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360
virtual void SetLineWidth(float aLineWidth)
Set the line width.
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.
T EuclideanNorm() const
Destructor.
Definition: vector2d.h:292
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
const wxPoint & GetStart() const
Definition: class_track.h:126
void SetTextMirrored(const bool aMirrored)
Set a mirrored property of text.
virtual int GetClearance(BOARD_CONNECTED_ITEM *aItem=NULL) const override
Function GetClearance returns the clearance in internal units.
void SetVerticalJustify(const EDA_TEXT_VJUSTIFY_T aVerticalJustify)
Set the vertical justify for text drawing.
int GetNetCode() const
Function GetNetCode.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
bool m_netNamesOnTracks
Flag determining if net names should be visible for tracks
Definition: pcb_painter.h:185
int m_clearance
Clearance visibility settings
Definition: pcb_painter.h:200
int GetWidth() const
Definition: class_track.h:120
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
void SetGlyphSize(const VECTOR2D aGlyphSize)
Set the font glyph size.
void SetHorizontalJustify(const EDA_TEXT_HJUSTIFY_T aHorizontalJustify)
Set the horizontal justify for text drawing.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
Definition: netinfo.h:469
bool IsNetnameLayer(LAYER_NUM aLayer)
Function IsNetnameLayer tests whether a layer is a netname layer.
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
const wxString & GetShortNetname() const
Function GetShortNetname.
void PCB_PAINTER::draw ( const VIA aVia,
int  aLayer 
)
protected

Definition at line 448 of file pcb_painter.cpp.

References KIGFX::GAL::BitmapText(), KIGFX::PCB_RENDER_SETTINGS::CL_EXISTING, KIGFX::PCB_RENDER_SETTINGS::CL_VIAS, color, KIGFX::GAL::DrawArc(), KIGFX::GAL::DrawCircle(), TRACK::GetClearance(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), getDrillSize(), VIA::GetDrillValue(), BOARD_CONNECTED_ITEM::GetNetname(), BOARD_CONNECTED_ITEM::GetShortNetname(), TRACK::GetStart(), VIA::GetViaType(), TRACK::GetWidth(), IsNetnameLayer(), LAYER_VIA_BBLIND, LAYER_VIA_MICROVIA, LAYER_VIA_THROUGH, LAYER_VIAS_HOLES, VIA::LayerPair(), KIGFX::PCB_RENDER_SETTINGS::m_clearance, KIGFX::PAINTER::m_gal, KIGFX::PCB_RENDER_SETTINGS::m_netNamesOnVias, KIGFX::RENDER_SETTINGS::m_outlineWidth, m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, KIGFX::PCB_RENDER_SETTINGS::MAX_FONT_SIZE, min, KIGFX::GAL::ResetTextAttributes(), KIGFX::GAL::Restore(), KIGFX::GAL::Save(), KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::Translate(), VIA_BLIND_BURIED, VIA_MICROVIA, VIA_THROUGH, and VECTOR2< T >::x.

449 {
450  VECTOR2D center( aVia->GetStart() );
451  double radius = 0.0;
452 
453  // Draw description layer
454  if( IsNetnameLayer( aLayer ) )
455  {
456  VECTOR2D position( center );
457 
458  // Is anything that we can display enabled?
460  {
461  bool displayNetname = ( !aVia->GetNetname().empty() );
462  double maxSize = PCB_RENDER_SETTINGS::MAX_FONT_SIZE;
463  double size = aVia->GetWidth();
464 
465  // Font size limits
466  if( size > maxSize )
467  size = maxSize;
468 
469  m_gal->Save();
470  m_gal->Translate( position );
471 
472  // Default font settings
474  m_gal->SetStrokeColor( m_pcbSettings.GetColor( NULL, aLayer ) );
475 
476  // Set the text position to the pad shape position (the pad position is not the best place)
477  VECTOR2D textpos( 0.0, 0.0 );
478 
479  if( displayNetname )
480  {
481  // calculate the size of net name text:
482  double tsize = 1.5 * size / aVia->GetShortNetname().Length();
483  tsize = std::min( tsize, size );
484  // Use a smaller text size to handle interline, pen size..
485  tsize *= 0.7;
486  VECTOR2D namesize( tsize, tsize );
487 
488  m_gal->SetGlyphSize( namesize );
489  m_gal->SetLineWidth( namesize.x / 12.0 );
490  m_gal->BitmapText( aVia->GetShortNetname(), textpos, 0.0 );
491  }
492 
493 
494  m_gal->Restore();
495  }
496  return;
497  }
498 
499  // Choose drawing settings depending on if we are drawing via's pad or hole
500  if( aLayer == LAYER_VIAS_HOLES )
501  radius = getDrillSize( aVia ) / 2.0;
502  else
503  radius = aVia->GetWidth() / 2.0;
504 
505  bool sketchMode = false;
506  const COLOR4D& color = m_pcbSettings.GetColor( aVia, aLayer );
507 
508  switch( aVia->GetViaType() )
509  {
510  case VIA_THROUGH:
512  break;
513 
514  case VIA_BLIND_BURIED:
516  break;
517 
518  case VIA_MICROVIA:
520  break;
521 
522  default:
523  assert( false );
524  break;
525  }
526 
527  if( aVia->GetViaType() == VIA_BLIND_BURIED )
528  {
529  // Buried vias are drawn in a special way to indicate the top and bottom layers
530  PCB_LAYER_ID layerTop, layerBottom;
531  aVia->LayerPair( &layerTop, &layerBottom );
532 
533  if( aLayer == LAYER_VIAS_HOLES )
534  { // TODO outline mode
535  m_gal->SetIsFill( true );
536  m_gal->SetIsStroke( false );
537  m_gal->SetFillColor( color );
538  m_gal->DrawCircle( center, radius );
539  }
540  else
541  {
542  double width = ( aVia->GetWidth() - aVia->GetDrillValue() ) / 2.0;
543 
544  m_gal->SetLineWidth( width );
545  m_gal->SetIsFill( true );
546  m_gal->SetIsStroke( false );
547  m_gal->SetFillColor( color );
548 
549  if( aLayer == layerTop )
550  {
551  m_gal->DrawArc( center, radius, 0.0, M_PI / 2.0 );
552  }
553  else if( aLayer == layerBottom )
554  {
555  m_gal->DrawArc( center, radius, M_PI, 3.0 * M_PI / 2.0 );
556  }
557  else if( aLayer == LAYER_VIA_BBLIND )
558  {
559  m_gal->DrawArc( center, radius, M_PI / 2.0, M_PI );
560  m_gal->DrawArc( center, radius, 3.0 * M_PI / 2.0, 2.0 * M_PI );
561  }
562  }
563  }
564  else
565  {
566  // Regular vias
567  m_gal->SetIsFill( !sketchMode );
568  m_gal->SetIsStroke( sketchMode );
569 
570  if( sketchMode )
571  {
572  // Outline mode
574  m_gal->SetStrokeColor( color );
575  }
576  else
577  {
578  // Filled mode
579  m_gal->SetFillColor( color );
580  }
581 
582  m_gal->DrawCircle( center, radius );
583  }
584 
585  // Clearance lines
586  constexpr int clearanceFlags = PCB_RENDER_SETTINGS::CL_EXISTING | PCB_RENDER_SETTINGS::CL_VIAS;
587 
588  if( ( m_pcbSettings.m_clearance & clearanceFlags ) == clearanceFlags
589  && aLayer != LAYER_VIAS_HOLES )
590  {
592  m_gal->SetIsFill( false );
593  m_gal->SetIsStroke( true );
594  m_gal->SetStrokeColor( color );
595  m_gal->DrawCircle( center, radius + aVia->GetClearance() );
596  }
597 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
to draw blind/buried vias
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:287
virtual void BitmapText(const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draws a text using a bitmap font.
virtual void DrawArc(const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle)
Draw an arc.
bool m_sketchMode[GAL_LAYER_ID_END]
Flag determining if items on a given layer should be drawn as an outline or a filled item ...
Definition: pcb_painter.h:167
int color
Definition: DXF_plotter.cpp:62
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...
to draw via holes (pad holes do not use this layer)
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360
virtual void SetLineWidth(float aLineWidth)
Set the line width.
PCB_LAYER_ID
A quick note on layer IDs:
void ResetTextAttributes()
Reset text attributes to default styling.
VIATYPE_T GetViaType() const
Definition: class_track.h:461
static const double MAX_FONT_SIZE
Maximum font size for netnames (and other dynamically shown strings)
Definition: pcb_painter.h:194
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
const wxPoint & GetStart() const
Definition: class_track.h:126
to draw usual through hole vias
virtual int GetClearance(BOARD_CONNECTED_ITEM *aItem=NULL) const override
Function GetClearance returns the clearance in internal units.
void LayerPair(PCB_LAYER_ID *top_layer, PCB_LAYER_ID *bottom_layer) const
Function LayerPair Return the 2 layers used by the via (the via actually uses all layers between thes...
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
virtual void Restore()
Restore the context.
const wxString & GetNetname() const
Function GetNetname.
int m_clearance
Clearance visibility settings
Definition: pcb_painter.h:200
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
int GetDrillValue() const
Function GetDrillValue "calculates" the drill value for vias (m-Drill if > 0, or default drill value ...
int GetWidth() const
Definition: class_track.h:120
virtual VECTOR2D getDrillSize(const D_PAD *aPad) const
Return drill size for a pad (internal units).
void SetGlyphSize(const VECTOR2D aGlyphSize)
Set the font glyph size.
virtual void Save()
Save the context.
virtual void Translate(const VECTOR2D &aTranslation)
Translate the context.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
bool m_netNamesOnVias
Flag determining if net names should be visible for vias
Definition: pcb_painter.h:188
bool IsNetnameLayer(LAYER_NUM aLayer)
Function IsNetnameLayer tests whether a layer is a netname layer.
#define min(a, b)
Definition: auxiliary.h:85
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
const wxString & GetShortNetname() const
Function GetShortNetname.
void PCB_PAINTER::draw ( const D_PAD aPad,
int  aLayer 
)
protected

Definition at line 600 of file pcb_painter.cpp.

References SHAPE_POLY_SET::Append(), B_Mask, B_Paste, KIGFX::GAL::BitmapText(), D_PAD::BuildPadPolygon(), KIGFX::PCB_RENDER_SETTINGS::CL_PADS, color, DECIDEG2RAD(), KIGFX::GAL::DrawArc(), KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawLine(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawRectangle(), F_Mask, F_Paste, D_PAD::GetAttribute(), KIGFX::PCB_RENDER_SETTINGS::GetBackgroundColor(), D_PAD::GetClearance(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), D_PAD::GetCustomShapeAsPolygon(), getDrillShape(), getDrillSize(), D_PAD::GetName(), BOARD_CONNECTED_ITEM::GetNetname(), D_PAD::GetOffset(), D_PAD::GetOrientation(), D_PAD::GetOrientationRadians(), D_PAD::GetPosition(), D_PAD::GetRoundRectCornerRadius(), D_PAD::GetShape(), BOARD_CONNECTED_ITEM::GetShortNetname(), D_PAD::GetSize(), D_PAD::GetSolderMaskMargin(), D_PAD::GetSolderPasteMargin(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, SHAPE_POLY_SET::Inflate(), IsNetnameLayer(), LAYER_NON_PLATEDHOLES, LAYER_PAD_BK, LAYER_PAD_FR, LAYER_PADS_PLATEDHOLES, LAYER_PADS_TH, KIGFX::PCB_RENDER_SETTINGS::m_clearance, KIGFX::PAINTER::m_gal, KIGFX::PCB_RENDER_SETTINGS::m_netNamesOnPads, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_RENDER_SETTINGS::m_padNumbers, m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, KIGFX::PCB_RENDER_SETTINGS::MAX_FONT_SIZE, min, SHAPE_POLY_SET::NewOutline(), NORMALIZE_ANGLE_90(), PAD_ATTRIB_HOLE_NOT_PLATED, PAD_DRILL_SHAPE_OBLONG, PAD_SHAPE_CIRCLE, PAD_SHAPE_CUSTOM, PAD_SHAPE_OVAL, PAD_SHAPE_RECT, PAD_SHAPE_ROUNDRECT, PAD_SHAPE_TRAPEZOID, D_PAD::PadShouldBeNPTH(), KIGFX::GAL::Restore(), KIGFX::GAL::Rotate(), KIGFX::GAL::Save(), SEGCOUNT, 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::SetStrokeColor(), KIGFX::GAL::SetTextMirrored(), KIGFX::GAL::SetVerticalJustify(), D_PAD::ShapePos(), TransformRoundRectToPolygon(), D_PAD::TransformShapeWithClearanceToPolygon(), KIGFX::GAL::Translate(), VECTOR2< T >::x, and VECTOR2< T >::y.

601 {
602  PAD_SHAPE_T shape;
603  double m, n;
604  double orientation = aPad->GetOrientation();
605 
606  // Draw description layer
607  if( IsNetnameLayer( aLayer ) )
608  {
609  VECTOR2D position( aPad->ShapePos() );
610 
611  // Is anything that we can display enabled?
613  {
614  bool displayNetname = ( m_pcbSettings.m_netNamesOnPads && !aPad->GetNetname().empty() );
615  VECTOR2D padsize = VECTOR2D( aPad->GetSize() );
616  double maxSize = PCB_RENDER_SETTINGS::MAX_FONT_SIZE;
617  double size = padsize.y;
618 
619  // Keep the size ratio for the font, but make it smaller
620  if( padsize.x < padsize.y )
621  {
622  orientation += 900.0;
623  size = padsize.x;
624  std::swap( padsize.x, padsize.y );
625  }
626  else if( padsize.x == padsize.y )
627  {
628  // If the text is displayed on a symmetrical pad, do not rotate it
629  orientation = 0.0;
630  }
631 
632  // Font size limits
633  if( size > maxSize )
634  size = maxSize;
635 
636  m_gal->Save();
637  m_gal->Translate( position );
638 
639  // do not display descriptions upside down
640  NORMALIZE_ANGLE_90( orientation );
641  m_gal->Rotate( DECIDEG2RAD( -orientation ) );
642 
643  // Default font settings
646  m_gal->SetFontBold( false );
647  m_gal->SetFontItalic( false );
648  m_gal->SetTextMirrored( false );
649  m_gal->SetStrokeColor( m_pcbSettings.GetColor( NULL, aLayer ) );
650  m_gal->SetIsStroke( true );
651  m_gal->SetIsFill( false );
652 
653  // Set the text position to the pad shape position (the pad position is not the best place)
654  VECTOR2D textpos( 0.0, 0.0 );
655 
656  // Divide the space, to display both pad numbers and netnames
657  // and set the Y text position to display 2 lines
658  if( displayNetname && m_pcbSettings.m_padNumbers )
659  {
660  size = size / 2.0;
661  textpos.y = size / 2.0;
662  }
663 
664  if( displayNetname )
665  {
666  // calculate the size of net name text:
667  double tsize = 1.5 * padsize.x / aPad->GetShortNetname().Length();
668  tsize = std::min( tsize, size );
669  // Use a smaller text size to handle interline, pen size..
670  tsize *= 0.7;
671  VECTOR2D namesize( tsize, tsize );
672 
673  m_gal->SetGlyphSize( namesize );
674  m_gal->SetLineWidth( namesize.x / 12.0 );
675  m_gal->BitmapText( aPad->GetShortNetname(), textpos, 0.0 );
676  }
677 
679  {
680  const wxString& padName = aPad->GetName();
681  textpos.y = -textpos.y;
682  double tsize = 1.5 * padsize.x / padName.Length();
683  tsize = std::min( tsize, size );
684  // Use a smaller text size to handle interline, pen size..
685  tsize *= 0.7;
686  tsize = std::min( tsize, size );
687  VECTOR2D numsize( tsize, tsize );
688 
689  m_gal->SetGlyphSize( numsize );
690  m_gal->SetLineWidth( numsize.x / 12.0 );
691  m_gal->BitmapText( padName, textpos, 0.0 );
692  }
693 
694  m_gal->Restore();
695  }
696  return;
697  }
698 
699  // Pad drawing
700  COLOR4D color;
701 
702  // Pad holes color is type specific
703  if( aLayer == LAYER_PADS_PLATEDHOLES || aLayer == LAYER_NON_PLATEDHOLES )
704  {
705  // Hole color is the background color for plated holes, but a specific color
706  // for not plated holes (LAYER_NON_PLATEDHOLES color layer )
708  color = m_pcbSettings.GetColor( nullptr, LAYER_NON_PLATEDHOLES );
709  // Don't let pads that *should* be NPTH get lost
710  else if( aPad->PadShouldBeNPTH() )
711  color = m_pcbSettings.GetColor( aPad, aLayer );
712  else
714  }
715  else
716  {
717  color = m_pcbSettings.GetColor( aPad, aLayer );
718  }
719 
720  VECTOR2D size;
721 
723  {
724  // Outline mode
725  m_gal->SetIsFill( false );
726  m_gal->SetIsStroke( true );
728  m_gal->SetStrokeColor( color );
729  }
730  else
731  {
732  // Filled mode
733  m_gal->SetIsFill( true );
734  m_gal->SetIsStroke( false );
735  m_gal->SetFillColor( color );
736  }
737 
738  m_gal->Save();
739  m_gal->Translate( VECTOR2D( aPad->GetPosition() ) );
740  m_gal->Rotate( -aPad->GetOrientationRadians() );
741 
742  int custom_margin = 0; // a clearance/margin for custom shape, for solder paste/mask
743 
744  // Choose drawing settings depending on if we are drawing a pad itself or a hole
745  if( aLayer == LAYER_PADS_PLATEDHOLES || aLayer == LAYER_NON_PLATEDHOLES )
746  {
747  // Drawing hole: has same shape as PAD_CIRCLE or PAD_OVAL
748  size = getDrillSize( aPad ) / 2.0;
750  }
751  else if( aLayer == F_Mask || aLayer == B_Mask )
752  {
753  // Drawing soldermask
754  int soldermaskMargin = aPad->GetSolderMaskMargin();
755  custom_margin = soldermaskMargin;
756 
757  m_gal->Translate( VECTOR2D( aPad->GetOffset() ) );
758  size = VECTOR2D( aPad->GetSize().x / 2.0 + soldermaskMargin,
759  aPad->GetSize().y / 2.0 + soldermaskMargin );
760  shape = aPad->GetShape();
761  }
762  else if( aLayer == F_Paste || aLayer == B_Paste )
763  {
764  // Drawing solderpaste
765  wxSize solderpasteMargin = aPad->GetSolderPasteMargin();
766  // try to find a clearance which can be used for custom shapes
767  custom_margin = solderpasteMargin.x;
768 
769  m_gal->Translate( VECTOR2D( aPad->GetOffset() ) );
770  size = VECTOR2D( aPad->GetSize().x / 2.0 + solderpasteMargin.x,
771  aPad->GetSize().y / 2.0 + solderpasteMargin.y );
772  shape = aPad->GetShape();
773  }
774  else
775  {
776  // Drawing every kind of pad
777  m_gal->Translate( VECTOR2D( aPad->GetOffset() ) );
778  size = VECTOR2D( aPad->GetSize() ) / 2.0;
779  shape = aPad->GetShape();
780  }
781 
782  switch( shape )
783  {
784  case PAD_SHAPE_OVAL:
785  if( size.y >= size.x )
786  {
787  m = ( size.y - size.x );
788  n = size.x;
789 
791  {
792  // Outline mode
793  m_gal->DrawArc( VECTOR2D( 0, -m ), n, -M_PI, 0 );
794  m_gal->DrawArc( VECTOR2D( 0, m ), n, M_PI, 0 );
795  m_gal->DrawLine( VECTOR2D( -n, -m ), VECTOR2D( -n, m ) );
796  m_gal->DrawLine( VECTOR2D( n, -m ), VECTOR2D( n, m ) );
797  }
798  else
799  {
800  // Filled mode
801  m_gal->DrawCircle( VECTOR2D( 0, -m ), n );
802  m_gal->DrawCircle( VECTOR2D( 0, m ), n );
803  m_gal->DrawRectangle( VECTOR2D( -n, -m ), VECTOR2D( n, m ) );
804  }
805  }
806  else
807  {
808  m = ( size.x - size.y );
809  n = size.y;
810 
812  {
813  // Outline mode
814  m_gal->DrawArc( VECTOR2D( -m, 0 ), n, M_PI / 2, 3 * M_PI / 2 );
815  m_gal->DrawArc( VECTOR2D( m, 0 ), n, M_PI / 2, -M_PI / 2 );
816  m_gal->DrawLine( VECTOR2D( -m, -n ), VECTOR2D( m, -n ) );
817  m_gal->DrawLine( VECTOR2D( -m, n ), VECTOR2D( m, n ) );
818  }
819  else
820  {
821  // Filled mode
822  m_gal->DrawCircle( VECTOR2D( -m, 0 ), n );
823  m_gal->DrawCircle( VECTOR2D( m, 0 ), n );
824  m_gal->DrawRectangle( VECTOR2D( -m, -n ), VECTOR2D( m, n ) );
825  }
826  }
827  break;
828 
829  case PAD_SHAPE_RECT:
830  m_gal->DrawRectangle( VECTOR2D( -size.x, -size.y ), VECTOR2D( size.x, size.y ) );
831  break;
832 
833  case PAD_SHAPE_ROUNDRECT:
834  {
835  SHAPE_POLY_SET polySet;
836  wxSize prsize( size.x * 2, size.y * 2 );
837  const int segmentToCircleCount = 64;
838  const int corner_radius = aPad->GetRoundRectCornerRadius( prsize );
839  TransformRoundRectToPolygon( polySet, wxPoint( 0, 0 ), prsize,
840  0.0, corner_radius, segmentToCircleCount );
841  m_gal->DrawPolygon( polySet );
842  break;
843  }
844 
845  case PAD_SHAPE_CUSTOM:
846  { // Draw the complex custom shape
847 
848  // Use solder[Paste/Mask]size or pad size to build pad shape
849  // however, solder[Paste/Mask] size has no actual meaning for a
850  // custom shape, because it is a set of basic shapes
851  // We use the custom_margin (good for solder mask, but approximative
852  // for solder paste).
853  if( custom_margin )
854  {
855  SHAPE_POLY_SET outline;
856  outline.Append( aPad->GetCustomShapeAsPolygon() );
857  const int segmentToCircleCount = 32;
858  outline.Inflate( custom_margin, segmentToCircleCount );
859  m_gal->DrawPolygon( outline );
860  }
861  else
862  {
863  // Draw the polygon: only one polygon is expected
864  // However we provide a multi polygon shape drawing
865  // ( for the future or to show even an incorrect shape
867  }
868  }
869  break;
870 
871  case PAD_SHAPE_TRAPEZOID:
872  {
873  std::deque<VECTOR2D> pointList;
874  wxPoint corners[4];
875 
876  VECTOR2D padSize = VECTOR2D( aPad->GetSize().x, aPad->GetSize().y ) / 2;
877  VECTOR2D deltaPadSize = size - padSize; // = solder[Paste/Mask]Margin or 0
878 
879  aPad->BuildPadPolygon( corners, wxSize( deltaPadSize.x, deltaPadSize.y ), 0.0 );
880  SHAPE_POLY_SET polySet;
881  polySet.NewOutline();
882  polySet.Append( VECTOR2I( corners[0] ) );
883  polySet.Append( VECTOR2I( corners[1] ) );
884  polySet.Append( VECTOR2I( corners[2] ) );
885  polySet.Append( VECTOR2I( corners[3] ) );
886 
887  m_gal->DrawPolygon( polySet );
888  }
889  break;
890 
891  case PAD_SHAPE_CIRCLE:
892  m_gal->DrawCircle( VECTOR2D( 0.0, 0.0 ), size.x );
893  break;
894  }
895 
896  m_gal->Restore();
897 
898  // Clearance lines
899  // It has to be called after GAL::Restore() as TransformShapeWithClearanceToPolygon()
900  // returns already transformed coordinates
901  constexpr int clearanceFlags = /*PCB_RENDER_SETTINGS::CL_EXISTING |*/ PCB_RENDER_SETTINGS::CL_PADS;
902 
903  if( ( m_pcbSettings.m_clearance & clearanceFlags ) == clearanceFlags
904  && ( aLayer == LAYER_PAD_FR
905  || aLayer == LAYER_PAD_BK
906  || aLayer == LAYER_PADS_TH ) )
907  {
908  SHAPE_POLY_SET polySet;
909  constexpr int SEGCOUNT = 64;
910  aPad->TransformShapeWithClearanceToPolygon( polySet, aPad->GetClearance(), SEGCOUNT, 1.0 );
912  m_gal->SetIsStroke( true );
913  m_gal->SetIsFill( false );
914  m_gal->SetStrokeColor( color );
915  m_gal->DrawPolygon( polySet );
916  }
917 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
void SetFontItalic(const bool aItalic)
Set italic property of current font.
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a rectangle.
virtual int getDrillShape(const D_PAD *aPad) const
Return drill shape of a pad.
PAD_ATTR_T GetAttribute() const
Definition: class_pad.h:405
like PAD_STANDARD, but not plated mechanical use only, no connection allowed
Definition: pad_shapes.h:65
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:287
multilayer pads, usually with holes
virtual void BitmapText(const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draws a text using a bitmap font.
const SHAPE_POLY_SET & GetCustomShapeAsPolygon() const
Accessor to the custom shape as one polygon.
Definition: class_pad.h:341
void BuildPadPolygon(wxPoint aCoord[4], wxSize aInflateValue, double aRotation) const
Function BuildPadPolygon Has meaning only for polygonal pads (trapezoid and rectangular) Build the Co...
handle color for not plated holes (holes, not pads)
virtual void DrawArc(const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle)
Draw an arc.
bool m_sketchMode[GAL_LAYER_ID_END]
Flag determining if items on a given layer should be drawn as an outline or a filled item ...
Definition: pcb_painter.h:167
void TransformRoundRectToPolygon(SHAPE_POLY_SET &aCornerBuffer, const wxPoint &aPosition, const wxSize &aSize, double aRotation, int aCornerRadius, int aCircleToSegmentsCount)
Function TransformRoundRectToPolygon convert a rectangle with rounded corners to a polygon Convert ar...
int GetRoundRectCornerRadius() const
Function GetRoundRectCornerRadius Has meaning only for rounded rect pads.
Definition: class_pad.h:531
int color
Definition: DXF_plotter.cpp:62
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...
bool m_padNumbers
Flag determining if pad numbers should be visible
Definition: pcb_painter.h:179
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
VECTOR2< int > VECTOR2I
Definition: vector2d.h:587
PAD_SHAPE_T GetShape() const
Function GetShape.
Definition: class_pad.h:216
smd pads, back layer
void NORMALIZE_ANGLE_90(T &Angle)
Definition: trigo.h:320
bool m_netNamesOnPads
Flag determining if net names should be visible for pads
Definition: pcb_painter.h:182
PAD_SHAPE_T
Enum PAD_SHAPE_T is the set of pad shapes, used with D_PAD::{Set,Get}Shape()
Definition: pad_shapes.h:31
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360
virtual void SetLineWidth(float aLineWidth)
Set the line width.
virtual void Rotate(double aAngle)
Rotate the context.
void TransformShapeWithClearanceToPolygon(SHAPE_POLY_SET &aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor, bool ignoreLineWidth=false) const override
Function TransformShapeWithClearanceToPolygon Convert the pad shape to a closed polygon Used in filli...
void SetFontBold(const bool aBold)
Set bold property of current font.
void Inflate(int aFactor, int aCircleSegmentsCount)
Performs outline inflation/deflation, using round corners.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
static const double MAX_FONT_SIZE
Maximum font size for netnames (and other dynamically shown strings)
Definition: pcb_painter.h:194
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
Class SHAPE_POLY_SET.
int GetSolderMaskMargin() const
Function GetSolderMaskMargin.
Definition: class_pad.cpp:593
double GetOrientationRadians() const
Definition: class_pad.h:384
const wxSize & GetSize() const
Definition: class_pad.h:269
const wxString & GetName() const
Definition: class_pad.h:190
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.
int NewOutline()
Creates a new empty polygon in the set and returns its index
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
smd pads, front layer
virtual void Restore()
Restore the context.
const wxString & GetNetname() const
Function GetNetname.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
int m_clearance
Clearance visibility settings
Definition: pcb_painter.h:200
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
double GetOrientation() const
Function GetOrientation returns the rotation angle of the pad in tenths of degrees, but soon degrees.
Definition: class_pad.h:382
const COLOR4D & GetBackgroundColor() override
Function GetBackgroundColor Returns current background color settings.
Definition: pcb_painter.h:154
double DECIDEG2RAD(double deg)
Definition: trigo.h:203
wxSize GetSolderPasteMargin() const
Function GetSolderPasteMargin.
Definition: class_pad.cpp:636
int GetClearance(BOARD_CONNECTED_ITEM *aItem=NULL) const override
Function GetClearance returns the clearance in internal units.
Definition: class_pad.cpp:562
wxPoint ShapePos() const
Definition: class_pad.cpp:516
virtual VECTOR2D getDrillSize(const D_PAD *aPad) const
Return drill size for a pad (internal units).
void SetGlyphSize(const VECTOR2D aGlyphSize)
Set the font glyph size.
virtual void Save()
Save the context.
void SetHorizontalJustify(const EDA_TEXT_HJUSTIFY_T aHorizontalJustify)
Set the horizontal justify for text drawing.
const wxPoint GetPosition() const override
Definition: class_pad.h:220
virtual void Translate(const VECTOR2D &aTranslation)
Translate the context.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
bool PadShouldBeNPTH() const
A pad whose hole is the same size as the pad is a NPTH.
Definition: class_pad.cpp:1249
const wxPoint & GetOffset() const
Definition: class_pad.h:278
bool IsNetnameLayer(LAYER_NUM aLayer)
Function IsNetnameLayer tests whether a layer is a netname layer.
#define min(a, b)
Definition: auxiliary.h:85
#define SEGCOUNT
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) ...
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
const wxString & GetShortNetname() const
Function GetShortNetname.
void PCB_PAINTER::draw ( const DRAWSEGMENT aSegment,
int  aLayer 
)
protected

Definition at line 920 of file pcb_painter.cpp.

References SHAPE_POLY_SET::CacheTriangulation(), color, DECIDEG2RAD(), KIGFX::GAL::DrawArcSegment(), KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawCurve(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawRectangle(), KIGFX::GAL::DrawSegment(), DRAWSEGMENT::GetAngle(), DRAWSEGMENT::GetArcAngleStart(), DRAWSEGMENT::GetBezControl1(), DRAWSEGMENT::GetBezControl2(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), DRAWSEGMENT::GetEnd(), BOARD_ITEM::GetLayer(), getLineThickness(), DRAWSEGMENT::GetParentModule(), DRAWSEGMENT::GetRadius(), DRAWSEGMENT::GetShape(), DRAWSEGMENT::GetStart(), DRAWSEGMENT::GetWidth(), DRAWSEGMENT::IsPolygonFilled(), SHAPE_POLY_SET::IsTriangulationUpToDate(), KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchBoardGfx, KIGFX::PCB_RENDER_SETTINGS::m_sketchFpGfx, SHAPE_POLY_SET::OutlineCount(), PCB_LINE_T, PCB_MODULE_EDGE_T, KIGFX::GAL::Restore(), KIGFX::GAL::Rotate(), S_ARC, S_CIRCLE, S_CURVE, S_LAST, S_POLYGON, S_RECT, S_SEGMENT, KIGFX::GAL::Save(), KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::Translate(), and EDA_ITEM::Type().

921 {
922  const COLOR4D& color = m_pcbSettings.GetColor( aSegment, aSegment->GetLayer() );
923  bool sketch = ( aSegment->Type() == PCB_LINE_T && m_pcbSettings.m_sketchBoardGfx )
924  || ( aSegment->Type() == PCB_MODULE_EDGE_T && m_pcbSettings.m_sketchFpGfx );
925 
926  int thickness = getLineThickness( aSegment->GetWidth() );
927  VECTOR2D start( aSegment->GetStart() );
928  VECTOR2D end( aSegment->GetEnd() );
929 
930  m_gal->SetIsFill( !sketch );
931  m_gal->SetIsStroke( sketch );
932  m_gal->SetFillColor( color );
933  m_gal->SetStrokeColor( color );
935 
936  switch( aSegment->GetShape() )
937  {
938  case S_SEGMENT:
939  m_gal->DrawSegment( start, end, thickness );
940  break;
941 
942  case S_RECT:
943  wxASSERT_MSG( false, "Not tested yet" );
944  m_gal->DrawRectangle( start, end );
945  break;
946 
947  case S_ARC:
948  m_gal->DrawArcSegment( start, aSegment->GetRadius(),
949  DECIDEG2RAD( aSegment->GetArcAngleStart() ),
950  DECIDEG2RAD( aSegment->GetArcAngleStart() + aSegment->GetAngle() ),
951  thickness );
952  break;
953 
954  case S_CIRCLE:
955  if( sketch )
956  {
957  m_gal->DrawCircle( start, aSegment->GetRadius() - thickness / 2 );
958  m_gal->DrawCircle( start, aSegment->GetRadius() + thickness / 2 );
959  }
960  else
961  {
962  m_gal->SetLineWidth( thickness );
963  m_gal->SetIsFill( false );
964  m_gal->SetIsStroke( true );
965  m_gal->DrawCircle( start, aSegment->GetRadius() );
966  }
967  break;
968 
969  case S_POLYGON:
970  {
971  SHAPE_POLY_SET& shape = ((DRAWSEGMENT*)aSegment)->GetPolyShape();
972 
973  if( shape.OutlineCount() == 0 )
974  break;
975 
976 #if 0
977  // On Opengl, a not convex filled polygon is usually drawn by using triangles as primitives.
978  // Although CacheTriangulation() can create basic triangle primitives
979  // to draw the polygon solid shape on Opengl, it is not used because it does not work fine
980  // with any polygon. It must be a simple polygon.
981  // And unfortunately, calling shape.Simplify( PM_FAST) is very slow.
982  // So for now we just use GLU tesselation (much slower, but works with any polygon)
983  // This section is left until a better way is found
984  if( !shape.IsTriangulationUpToDate() )
985  {
986  shape.CacheTriangulation();
987  }
988 #endif
989  m_gal->Save();
990 
991  if( MODULE* module = aSegment->GetParentModule() )
992  {
993  m_gal->Translate( module->GetPosition() );
994  m_gal->Rotate( -module->GetOrientationRadians() );
995  }
996 
997  m_gal->SetLineWidth( thickness );
998 
999  m_gal->SetIsFill( aSegment->IsPolygonFilled() );
1000 
1001  m_gal->SetIsStroke( true );
1002  m_gal->DrawPolygon( shape );
1003 
1004  m_gal->Restore();
1005  break;
1006  }
1007 
1008  case S_CURVE:
1009  m_gal->SetIsFill( false );
1010  m_gal->SetIsStroke( true );
1011  m_gal->SetLineWidth( thickness );
1012  m_gal->DrawCurve( VECTOR2D( aSegment->GetStart() ),
1013  VECTOR2D( aSegment->GetBezControl1() ),
1014  VECTOR2D( aSegment->GetBezControl2() ),
1015  VECTOR2D( aSegment->GetEnd() ) );
1016  break;
1017 
1018  case S_LAST:
1019  break;
1020  }
1021 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
KICAD_T Type() const
Function Type()
Definition: base_struct.h:201
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a rectangle.
const wxPoint & GetBezControl2() const
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:287
virtual PCB_LAYER_ID GetLayer() const
Function GetLayer returns the primary layer this item is on.
int color
Definition: DXF_plotter.cpp:62
polygon (not yet used for tracks, but could be in microwave apps)
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...
double GetArcAngleStart() const
function GetArcAngleStart()
bool m_sketchBoardGfx
Flag determining if board graphic items should be outlined or stroked
Definition: pcb_painter.h:170
usual segment : line with rounded ends
bool IsTriangulationUpToDate() const
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
int OutlineCount() const
Returns the number of outlines in the set
class EDGE_MODULE, a footprint edge
Definition: typeinfo.h:94
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360
virtual void SetLineWidth(float aLineWidth)
Set the line width.
virtual void Rotate(double aAngle)
Rotate the context.
virtual void DrawCurve(const VECTOR2D &startPoint, const VECTOR2D &controlPointA, const VECTOR2D &controlPointB, const VECTOR2D &endPoint)
Draw a cubic bezier spline.
segment with non rounded ends
STROKE_T GetShape() const
const wxPoint & GetEnd() const
Function GetEnd returns the ending point of the graphic.
virtual void DrawSegment(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth)
Draw a rounded segment.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
Class SHAPE_POLY_SET.
Arcs (with rounded ends)
last value for this list
int getLineThickness(int aActualThickness) const
Function getLineThickness() Get the thickness to draw for a line (e.g.
const wxPoint & GetBezControl1() const
Bezier Curve.
bool IsPolygonFilled() const
Polygonal shape is not always filled.
bool m_sketchFpGfx
Flag determining if footprint graphic items should be outlined or stroked
Definition: pcb_painter.h:173
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
double GetAngle() const
virtual void Restore()
Restore the context.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
double DECIDEG2RAD(double deg)
Definition: trigo.h:203
int GetWidth() const
MODULE * GetParentModule() const
Function GetParentModule returns a pointer to the parent module, or NULL if DRAWSEGMENT does not belo...
virtual void DrawArcSegment(const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle, double aWidth)
Draw an arc segment.
virtual void Save()
Save the context.
class DRAWSEGMENT, a segment not on copper layers
Definition: typeinfo.h:91
const wxPoint & GetStart() const
Function GetStart returns the starting point of the graphic.
int GetRadius() const
Function GetRadius returns the radius of this item Has meaning only for arc and circle.
virtual void Translate(const VECTOR2D &aTranslation)
Translate the context.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
void PCB_PAINTER::draw ( const TEXTE_PCB aText,
int  aLayer 
)
protected

Definition at line 1024 of file pcb_painter.cpp.

References color, KIGFX::PCB_RENDER_SETTINGS::GetColor(), BOARD_ITEM::GetLayer(), getLineThickness(), EDA_TEXT::GetShownText(), EDA_TEXT::GetTextAngleRadians(), EDA_TEXT::GetTextPos(), EDA_TEXT::GetThickness(), KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextAttributes(), and KIGFX::GAL::StrokeText().

1025 {
1026  wxString shownText( aText->GetShownText() );
1027  if( shownText.Length() == 0 )
1028  return;
1029 
1030  const COLOR4D& color = m_pcbSettings.GetColor( aText, aText->GetLayer() );
1031  VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );
1032 
1033  if( m_pcbSettings.m_sketchMode[aLayer] )
1034  {
1035  // Outline mode
1037  }
1038  else
1039  {
1040  // Filled mode
1042  }
1043 
1044  m_gal->SetStrokeColor( color );
1045  m_gal->SetIsFill( false );
1046  m_gal->SetIsStroke( true );
1047  m_gal->SetTextAttributes( aText );
1048  m_gal->StrokeText( shownText, position, aText->GetTextAngleRadians() );
1049 }
const wxPoint & GetTextPos() const
Definition: eda_text.h:237
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:287
virtual PCB_LAYER_ID GetLayer() const
Function GetLayer returns the primary layer this item is on.
virtual void SetTextAttributes(const EDA_TEXT *aText)
Loads attributes of the given text (bold/italic/underline/mirrored and so on).
bool m_sketchMode[GAL_LAYER_ID_END]
Flag determining if items on a given layer should be drawn as an outline or a filled item ...
Definition: pcb_painter.h:167
int color
Definition: DXF_plotter.cpp:62
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...
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360
virtual void SetLineWidth(float aLineWidth)
Set the line width.
int GetThickness() const
Function GetThickness returns pen width.
Definition: eda_text.h:167
virtual wxString GetShownText() const
Returns the string actually shown after processing of the base text.
Definition: eda_text.h:148
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
virtual void StrokeText(const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draws a vector type text using preloaded Newstroke font.
int getLineThickness(int aActualThickness) const
Function getLineThickness() Get the thickness to draw for a line (e.g.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
double GetTextAngleRadians() const
Definition: eda_text.h:180
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
void PCB_PAINTER::draw ( const TEXTE_MODULE aText,
int  aLayer 
)
protected

Definition at line 1052 of file pcb_painter.cpp.

References color, KIGFX::GAL::DrawLine(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), TEXTE_MODULE::GetDrawRotationRadians(), getLineThickness(), BOARD_ITEM::GetParent(), BOARD_ITEM::GetPosition(), TEXTE_MODULE::GetShownText(), EDA_TEXT::GetTextPos(), EDA_TEXT::GetThickness(), EDA_ITEM::IsSelected(), KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchFpTxtfx, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextAttributes(), and KIGFX::GAL::StrokeText().

1053 {
1054  wxString shownText( aText->GetShownText() );
1055  if( shownText.Length() == 0 )
1056  return;
1057 
1058  bool sketch = m_pcbSettings.m_sketchFpTxtfx;
1059 
1060  const COLOR4D& color = m_pcbSettings.GetColor( aText, aLayer );
1061  VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );
1062 
1063  // Currently, draw text routines do not know the true outline mode.
1064  // so draw the text in "line" mode (no thickness)
1065  if( sketch )
1066  {
1067  // Outline mode
1069  }
1070  else
1071  {
1072  // Filled mode
1074  }
1075 
1076  m_gal->SetStrokeColor( color );
1077  m_gal->SetIsFill( false );
1078  m_gal->SetIsStroke( true );
1079  m_gal->SetTextAttributes( aText );
1080  m_gal->StrokeText( shownText, position, aText->GetDrawRotationRadians() );
1081 
1082  // Draw the umbilical line
1083  if( aText->IsSelected() )
1084  {
1086  m_gal->SetStrokeColor( COLOR4D( 0.0, 0.0, 1.0, 1.0 ) );
1087  m_gal->DrawLine( position, aText->GetParent()->GetPosition() );
1088  }
1089 }
BOARD_ITEM_CONTAINER * GetParent() const
const wxPoint & GetTextPos() const
Definition: eda_text.h:237
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:287
virtual void SetTextAttributes(const EDA_TEXT *aText)
Loads attributes of the given text (bold/italic/underline/mirrored and so on).
int color
Definition: DXF_plotter.cpp:62
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...
bool IsSelected() const
Definition: base_struct.h:224
bool m_sketchFpTxtfx
Flag determining if footprint text items should be outlined or stroked
Definition: pcb_painter.h:176
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
virtual wxString GetShownText() const override
Returns the string actually shown after processing of the base text.
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360
virtual void SetLineWidth(float aLineWidth)
Set the line width.
int GetThickness() const
Function GetThickness returns pen width.
Definition: eda_text.h:167
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
virtual void StrokeText(const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draws a vector type text using preloaded Newstroke font.
int getLineThickness(int aActualThickness) const
Function getLineThickness() Get the thickness to draw for a line (e.g.
virtual const wxPoint GetPosition() const =0
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
double GetDrawRotationRadians() const
void PCB_PAINTER::draw ( const MODULE aModule,
int  aLayer 
)
protected

Definition at line 1092 of file pcb_painter.cpp.

References color, KIGFX::GAL::DrawLine(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), MODULE::GetPosition(), KIGFX::GAL::GetWorldScale(), LAYER_ANCHOR, KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, m_pcbSettings, KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

1093 {
1094  if( aLayer == LAYER_ANCHOR )
1095  {
1096  const COLOR4D color = m_pcbSettings.GetColor( aModule, LAYER_ANCHOR );
1097 
1098  // Draw anchor
1099  m_gal->SetStrokeColor( color );
1101 
1102  // Keep the size constant, not related to the scale
1103  double anchorSize = 5.0 / m_gal->GetWorldScale();
1104 
1105  VECTOR2D center = aModule->GetPosition();
1106  m_gal->DrawLine( center - VECTOR2D( anchorSize, 0 ), center + VECTOR2D( anchorSize, 0 ) );
1107  m_gal->DrawLine( center - VECTOR2D( 0, anchorSize ), center + VECTOR2D( 0, anchorSize ) );
1108  }
1109 }
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:287
double GetWorldScale() const
Get the world scale.
anchor of items having an anchor point (texts, footprints)
int color
Definition: DXF_plotter.cpp:62
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...
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360
virtual void SetLineWidth(float aLineWidth)
Set the line width.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
const wxPoint GetPosition() const override
Definition: class_module.h:183
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
void PCB_PAINTER::draw ( const ZONE_CONTAINER aZone,
int  aLayer 
)
protected

Definition at line 1112 of file pcb_painter.cpp.

References SHAPE_POLY_SET::CHole(), color, SHAPE_POLY_SET::COutline(), KIGFX::GAL::DrawLine(), KIGFX::GAL::DrawPolygon(), KIGFX::GAL::DrawPolyline(), KIGFX::PCB_RENDER_SETTINGS::DZ_HIDE_FILLED, KIGFX::PCB_RENDER_SETTINGS::DZ_SHOW_FILLED, KIGFX::PCB_RENDER_SETTINGS::DZ_SHOW_OUTLINED, KIGFX::PCB_RENDER_SETTINGS::GetColor(), ZONE_CONTAINER::GetFilledPolysList(), ZONE_CONTAINER::GetHatchLines(), ZONE_CONTAINER::GetMinThickness(), SHAPE_POLY_SET::HoleCount(), ZONE_CONTAINER::IsOnLayer(), KIGFX::PCB_RENDER_SETTINGS::m_displayZone, KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_zoneOutlines, ZONE_CONTAINER::Outline(), SHAPE_POLY_SET::OutlineCount(), KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

1113 {
1114  if( !aZone->IsOnLayer( (PCB_LAYER_ID) aLayer ) )
1115  return;
1116 
1117  const COLOR4D& color = m_pcbSettings.GetColor( aZone, aLayer );
1118  std::deque<VECTOR2D> corners;
1120 
1121  // Draw the outline
1122  const SHAPE_POLY_SET* outline = aZone->Outline();
1123 
1124  if( m_pcbSettings.m_zoneOutlines && outline )
1125  {
1126  m_gal->SetStrokeColor( color );
1127  m_gal->SetIsFill( false );
1128  m_gal->SetIsStroke( true );
1130 
1131  // Draw each contour (main contour and holes)
1132 
1133  /* This line:
1134  * m_gal->DrawPolygon( *outline );
1135  * should be enough, but currently does not work to draw holes contours in a complex polygon
1136  * so each contour is draw as a simple polygon
1137  */
1138 
1139  // Draw the main contour
1140  m_gal->DrawPolyline( outline->COutline( 0 ) );
1141 
1142  // Draw holes
1143  int holes_count = outline->HoleCount( 0 );
1144 
1145  for( int ii = 0; ii < holes_count; ++ii )
1146  m_gal->DrawPolyline( outline->CHole( 0, ii ) );
1147 
1148  // Draw hatch lines
1149  for( const SEG& hatchLine : aZone->GetHatchLines() )
1150  m_gal->DrawLine( hatchLine.A, hatchLine.B );
1151  }
1152 
1153  // Draw the filling
1154  if( displayMode != PCB_RENDER_SETTINGS::DZ_HIDE_FILLED )
1155  {
1156  const SHAPE_POLY_SET& polySet = aZone->GetFilledPolysList();
1157 
1158  if( polySet.OutlineCount() == 0 ) // Nothing to draw
1159  return;
1160 
1161  // Set up drawing options
1162  m_gal->SetFillColor( color );
1163  m_gal->SetLineWidth( aZone->GetMinThickness() );
1164 
1165  if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_FILLED )
1166  {
1167  m_gal->SetIsFill( true );
1168  m_gal->SetIsStroke( true );
1169  }
1170  else if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_OUTLINED )
1171  {
1172  m_gal->SetIsFill( false );
1173  m_gal->SetIsStroke( true );
1174  }
1175 
1176  m_gal->DrawPolygon( polySet );
1177  }
1178 
1179 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:287
int GetMinThickness() const
Definition: class_zone.h:203
virtual bool IsOnLayer(PCB_LAYER_ID) const override
Function IsOnLayer tests to see if this object is on the given layer.
Definition: class_zone.cpp:265
int color
Definition: DXF_plotter.cpp:62
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...
int HoleCount(int aOutline) const
Returns the number of holes in a given outline
SHAPE_POLY_SET * Outline()
Definition: class_zone.h:241
DISPLAY_ZONE_MODE m_displayZone
Option for different display modes for zones
Definition: pcb_painter.h:197
const SHAPE_LINE_CHAIN & CHole(int aOutline, int aHole) const
DISPLAY_ZONE_MODE
Determines how zones should be displayed
Definition: pcb_painter.h:84
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
int OutlineCount() const
Returns the number of outlines in the set
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
const std::vector< SEG > & GetHatchLines() const
Definition: class_zone.h:685
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360
virtual void SetLineWidth(float aLineWidth)
Set the line width.
PCB_LAYER_ID
A quick note on layer IDs:
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
Class SHAPE_POLY_SET.
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
const SHAPE_POLY_SET & GetFilledPolysList() const
Function GetFilledPolysList returns a reference to the list of filled polygons.
Definition: class_zone.h:557
Definition: seg.h:36
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
bool m_zoneOutlines
Flag determining if zones should have outlines drawn
Definition: pcb_painter.h:191
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
void PCB_PAINTER::draw ( const DIMENSION aDimension,
int  aLayer 
)
protected

Definition at line 1182 of file pcb_painter.cpp.

References KIGFX::GAL::DrawLine(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), getLineThickness(), EDA_TEXT::GetShownText(), EDA_TEXT::GetTextAngleRadians(), EDA_TEXT::GetTextPos(), EDA_TEXT::GetThickness(), DIMENSION::GetWidth(), DIMENSION::m_arrowD1F, DIMENSION::m_arrowD2F, DIMENSION::m_arrowG1F, DIMENSION::m_arrowG2F, DIMENSION::m_crossBarF, DIMENSION::m_crossBarO, DIMENSION::m_featureLineDF, DIMENSION::m_featureLineDO, DIMENSION::m_featureLineGF, DIMENSION::m_featureLineGO, KIGFX::PAINTER::m_gal, m_pcbSettings, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextAttributes(), KIGFX::GAL::StrokeText(), and DIMENSION::Text().

1183 {
1184  const COLOR4D& strokeColor = m_pcbSettings.GetColor( aDimension, aLayer );
1185 
1186  m_gal->SetStrokeColor( strokeColor );
1187  m_gal->SetIsFill( false );
1188  m_gal->SetIsStroke( true );
1189  m_gal->SetLineWidth( getLineThickness( aDimension->GetWidth() ) );
1190 
1191  // Draw an arrow
1192  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_crossBarF ) );
1193  m_gal->DrawLine( VECTOR2D( aDimension->m_featureLineGO ),
1194  VECTOR2D( aDimension->m_featureLineGF ) );
1195  m_gal->DrawLine( VECTOR2D( aDimension->m_featureLineDO ),
1196  VECTOR2D( aDimension->m_featureLineDF ) );
1197  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarF ), VECTOR2D( aDimension->m_arrowD1F ) );
1198  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarF ), VECTOR2D( aDimension->m_arrowD2F ) );
1199  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_arrowG1F ) );
1200  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_arrowG2F ) );
1201 
1202  // Draw text
1203  TEXTE_PCB& text = aDimension->Text();
1204  VECTOR2D position( text.GetTextPos().x, text.GetTextPos().y );
1205 
1206  m_gal->SetLineWidth( text.GetThickness() );
1207  m_gal->SetTextAttributes( &text );
1208  m_gal->StrokeText( text.GetShownText(), position, text.GetTextAngleRadians() );
1209 }
const wxPoint & GetTextPos() const
Definition: eda_text.h:237
wxPoint m_crossBarF
wxPoint m_arrowD1F
virtual void SetTextAttributes(const EDA_TEXT *aText)
Loads attributes of the given text (bold/italic/underline/mirrored and so on).
int GetWidth() const
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...
wxPoint m_featureLineDF
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360
virtual void SetLineWidth(float aLineWidth)
Set the line width.
int GetThickness() const
Function GetThickness returns pen width.
Definition: eda_text.h:167
wxPoint m_featureLineGO
virtual wxString GetShownText() const
Returns the string actually shown after processing of the base text.
Definition: eda_text.h:148
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
virtual void StrokeText(const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draws a vector type text using preloaded Newstroke font.
wxPoint m_arrowG1F
wxPoint m_arrowD2F
wxPoint m_arrowG2F
int getLineThickness(int aActualThickness) const
Function getLineThickness() Get the thickness to draw for a line (e.g.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
TEXTE_PCB & Text()
wxPoint m_crossBarO
double GetTextAngleRadians() const
Definition: eda_text.h:180
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
wxPoint m_featureLineDO
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
wxPoint m_featureLineGF
void PCB_PAINTER::draw ( const PCB_TARGET aTarget)
protected

Definition at line 1212 of file pcb_painter.cpp.

References KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawLine(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), BOARD_ITEM::GetLayer(), getLineThickness(), PCB_TARGET::GetPosition(), PCB_TARGET::GetShape(), PCB_TARGET::GetSize(), PCB_TARGET::GetWidth(), KIGFX::PAINTER::m_gal, m_pcbSettings, KIGFX::GAL::Restore(), KIGFX::GAL::Rotate(), KIGFX::GAL::Save(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), and KIGFX::GAL::Translate().

1213 {
1214  const COLOR4D& strokeColor = m_pcbSettings.GetColor( aTarget, aTarget->GetLayer() );
1215  VECTOR2D position( aTarget->GetPosition() );
1216  double size, radius;
1217 
1218  m_gal->SetLineWidth( getLineThickness( aTarget->GetWidth() ) );
1219  m_gal->SetStrokeColor( strokeColor );
1220  m_gal->SetIsFill( false );
1221  m_gal->SetIsStroke( true );
1222 
1223  m_gal->Save();
1224  m_gal->Translate( position );
1225 
1226  if( aTarget->GetShape() )
1227  {
1228  // shape x
1229  m_gal->Rotate( M_PI / 4.0 );
1230  size = 2.0 * aTarget->GetSize() / 3.0;
1231  radius = aTarget->GetSize() / 2.0;
1232  }
1233  else
1234  {
1235  // shape +
1236  size = aTarget->GetSize() / 2.0;
1237  radius = aTarget->GetSize() / 3.0;
1238  }
1239 
1240  m_gal->DrawLine( VECTOR2D( -size, 0.0 ), VECTOR2D( size, 0.0 ) );
1241  m_gal->DrawLine( VECTOR2D( 0.0, -size ), VECTOR2D( 0.0, size ) );
1242  m_gal->DrawCircle( VECTOR2D( 0.0, 0.0 ), radius );
1243 
1244  m_gal->Restore();
1245 }
int GetWidth() const
virtual PCB_LAYER_ID GetLayer() const
Function GetLayer returns the primary layer this item is on.
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...
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360
virtual void SetLineWidth(float aLineWidth)
Set the line width.
virtual void Rotate(double aAngle)
Rotate the context.
int GetShape() const
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
int getLineThickness(int aActualThickness) const
Function getLineThickness() Get the thickness to draw for a line (e.g.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
virtual void Restore()
Restore the context.
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
int GetSize() const
virtual void Save()
Save the context.
virtual void Translate(const VECTOR2D &aTranslation)
Translate the context.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
const wxPoint GetPosition() const override
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
void PCB_PAINTER::draw ( const MARKER_PCB aMarker)
protected

Definition at line 1248 of file pcb_painter.cpp.

References KIGFX::GAL::DrawPolygon(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), MARKER_PCB::GetPosition(), LAYER_DRC, KIGFX::PAINTER::m_gal, m_pcbSettings, MARKER_PCB::MarkerScale(), KIGFX::PCB_RENDER_SETTINGS::MAX_FONT_SIZE, KIGFX::GAL::Restore(), KIGFX::GAL::Save(), scale, KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), and KIGFX::GAL::Translate().

1249 {
1250  const int scale = MARKER_PCB::MarkerScale();
1251 
1252  // If you are changing this, update MARKER_PCB::ViewBBox()
1253  const VECTOR2D arrow[] = {
1254  VECTOR2D( 0 * scale, 0 * scale ),
1255  VECTOR2D( 8 * scale, 1 * scale ),
1256  VECTOR2D( 4 * scale, 3 * scale ),
1257  VECTOR2D( 13 * scale, 8 * scale ),
1258  VECTOR2D( 9 * scale, 9 * scale ),
1259  VECTOR2D( 8 * scale, 13 * scale ),
1260  VECTOR2D( 3 * scale, 4 * scale ),
1261  VECTOR2D( 1 * scale, 8 * scale ),
1262  VECTOR2D( 0 * scale, 0 * scale )
1263  };
1264 
1265  auto strokeColor = m_pcbSettings.GetColor( aMarker, LAYER_DRC );
1266 
1267  m_gal->Save();
1268  m_gal->Translate( aMarker->GetPosition() );
1269  m_gal->SetFillColor( strokeColor );
1270  m_gal->SetIsFill( true );
1271  m_gal->SetIsStroke( false );
1272  m_gal->DrawPolygon( arrow, sizeof( arrow ) / sizeof( VECTOR2D ) );
1273  m_gal->Restore();
1274 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
const wxPoint GetPosition() const override
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...
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
static int MarkerScale()
A scaling factor to create the marker symbol.
const int scale
virtual void Restore()
Restore the context.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
virtual void Save()
Save the context.
virtual void Translate(const VECTOR2D &aTranslation)
Translate the context.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
int PCB_PAINTER::getDrillShape ( const D_PAD aPad) const
protectedvirtual

Return drill shape of a pad.

Reimplemented in KIGFX::PCB_PRINT_PAINTER.

Definition at line 283 of file pcb_painter.cpp.

References D_PAD::GetDrillShape().

Referenced by draw(), and KIGFX::PCB_PRINT_PAINTER::getDrillShape().

284 {
285  return aPad->GetDrillShape();
286 }
PAD_DRILL_SHAPE_T GetDrillShape() const
Definition: class_pad.h:388
VECTOR2D PCB_PAINTER::getDrillSize ( const D_PAD aPad) const
protectedvirtual

Return drill size for a pad (internal units).

Reimplemented in KIGFX::PCB_PRINT_PAINTER.

Definition at line 289 of file pcb_painter.cpp.

References D_PAD::GetDrillSize().

Referenced by draw(), and KIGFX::PCB_PRINT_PAINTER::getDrillSize().

290 {
291  return VECTOR2D( aPad->GetDrillSize() );
292 }
const wxSize & GetDrillSize() const
Definition: class_pad.h:275
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
int PCB_PAINTER::getDrillSize ( const VIA aVia) const
protectedvirtual

Return drill diameter for a via (internal units).

Reimplemented in KIGFX::PCB_PRINT_PAINTER.

Definition at line 295 of file pcb_painter.cpp.

References VIA::GetDrillValue().

296 {
297  return aVia->GetDrillValue();
298 }
int GetDrillValue() const
Function GetDrillValue "calculates" the drill value for vias (m-Drill if > 0, or default drill value ...
int PCB_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 271 of file pcb_painter.cpp.

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

Referenced by draw().

272 {
273  // if items have 0 thickness, draw them with the outline
274  // width, otherwise respect the set value (which, no matter
275  // how small will produce something)
276  if( aActualThickness == 0 )
278 
279  return aActualThickness;
280 }
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:287
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
virtual PCB_RENDER_SETTINGS* KIGFX::PCB_PAINTER::GetSettings ( )
inlineoverridevirtual

Function GetSettings Returns pointer to current settings that are going to be used when drawing items.

Returns
Current rendering settings.

Implements KIGFX::PAINTER.

Definition at line 223 of file pcb_painter.h.

Referenced by PCBNEW_CONTROL::LayerAlphaDec(), PCBNEW_CONTROL::LayerAlphaInc(), PCB_LAYER_WIDGET::SyncLayerAlphaIndicators(), PANEL_PCBNEW_DISPLAY_OPTIONS::TransferDataFromWindow(), PANEL_PCBNEW_SETTINGS::TransferDataFromWindow(), and PCB_BASE_FRAME::UseGalCanvas().

224  {
225  return &m_pcbSettings;
226  }
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
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 328 of file painter.h.

329  {
330  m_gal = aGal;
331  }
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:360

Member Data Documentation

COLOR4D KIGFX::PAINTER::m_brightenedColor
protectedinherited

Color of brightened item frame.

Definition at line 363 of file painter.h.

GAL* KIGFX::PAINTER::m_gal
protectedinherited

Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.

DrawLine, DrawCircle, etc.)

Definition at line 360 of file painter.h.

Referenced by KIGFX::SCH_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), draw(), KIGFX::GERBVIEW_PAINTER::drawApertureMacro(), KIGFX::GERBVIEW_PAINTER::drawFlashedShape(), KIGFX::GERBVIEW_PAINTER::drawPolygon(), KIGFX::SCH_PAINTER::setColors(), and KIGFX::SCH_PAINTER::triLine().

PCB_RENDER_SETTINGS KIGFX::PCB_PAINTER::m_pcbSettings
protected

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