KiCad PCB EDA Suite
KIGFX::PCB_PRINT_PAINTER Class Reference

Special flavor of PCB_PAINTER that contains modifications to handle printing options. More...

#include <pcbnew_printout.h>

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

Public Member Functions

 PCB_PRINT_PAINTER (GAL *aGal)
 
void SetDrillMarks (bool aRealSize, unsigned int aSize=0)
 Set drill marks visibility and options. More...
 
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

int getDrillShape (const D_PAD *aPad) const override
 Return drill shape of a pad. More...
 
VECTOR2D getDrillSize (const D_PAD *aPad) const override
 Return drill size for a pad (internal units). More...
 
int getDrillSize (const VIA *aVia) const override
 Return drill diameter for a via (internal units). More...
 
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...
 

Protected Attributes

bool m_drillMarkReal
 

Flag deciding whether use the actual hole size or user-specified size for drill marks

More...
 
int m_drillMarkSize
 

User-specified size for drill marks (expressed in internal units)

More...
 
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

Special flavor of PCB_PAINTER that contains modifications to handle printing options.

Definition at line 83 of file pcbnew_printout.h.

Constructor & Destructor Documentation

KIGFX::PCB_PRINT_PAINTER::PCB_PRINT_PAINTER ( GAL aGal)

Definition at line 213 of file pcbnew_printout.cpp.

References KIGFX::PCB_RENDER_SETTINGS::EnableZoneOutlines(), and KIGFX::PCB_PAINTER::m_pcbSettings.

214  : PCB_PAINTER( aGal ), m_drillMarkReal( false ), m_drillMarkSize( 0 )
215 {
217 }
void EnableZoneOutlines(bool aEnabled)
Turns on/off drawing outline and hatched lines for zones.
Definition: pcb_painter.h:142
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
bool m_drillMarkReal
Flag deciding whether use the actual hole size or user-specified size for drill marks ...
int m_drillMarkSize
User-specified size for drill marks (expressed in internal units)
PCB_PAINTER(GAL *aGal)

Member Function Documentation

virtual void KIGFX::PCB_PAINTER::ApplySettings ( const RENDER_SETTINGS aSettings)
inlineoverridevirtualinherited

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 
)
overridevirtualinherited

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 KIGFX::PCB_PAINTER::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 
)
protectedinherited

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, KIGFX::PCB_PAINTER::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 KIGFX::PCB_PAINTER::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...
Class VECTOR2 defines a general 2D-vector/point.
Definition: vector2d.h:61
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
const wxPoint & GetEnd() const
Definition: class_track.h:119
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:122
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:116
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 
)
protectedinherited

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(), KIGFX::PCB_PAINTER::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, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, KIGFX::PCB_RENDER_SETTINGS::MAX_FONT_SIZE, maxSize, 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() );
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...
Class VECTOR2 defines a general 2D-vector/point.
Definition: vector2d.h:61
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:454
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 int maxSize
const wxPoint & GetStart() const
Definition: class_track.h:122
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:116
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 
)
protectedinherited

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(), KIGFX::PCB_PAINTER::getDrillShape(), KIGFX::PCB_PAINTER::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, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchMode, KIGFX::PCB_RENDER_SETTINGS::MAX_FONT_SIZE, maxSize, 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() );
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:528
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...
Class VECTOR2 defines a general 2D-vector/point.
Definition: vector2d.h:61
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 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.
const int maxSize
Class SHAPE_POLY_SET.
int GetSolderMaskMargin() const
Function GetSolderMaskMargin.
Definition: class_pad.cpp:594
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 TransformShapeWithClearanceToPolygon(SHAPE_POLY_SET &aCornerBuffer, int aClearanceValue, int aCircleToSegmentsCount, double aCorrectionFactor) const override
Function TransformShapeWithClearanceToPolygon Convert the pad shape to a closed polygon Used in filli...
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:637
int GetClearance(BOARD_CONNECTED_ITEM *aItem=NULL) const override
Function GetClearance returns the clearance in internal units.
Definition: class_pad.cpp:563
wxPoint ShapePos() const
Definition: class_pad.cpp:517
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:1250
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 
)
protectedinherited

Definition at line 920 of file pcb_painter.cpp.

References DRAWSEGMENT::BuildPolyPointsList(), 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(), KIGFX::PCB_PAINTER::getLineThickness(), DRAWSEGMENT::GetParentModule(), DRAWSEGMENT::GetRadius(), DRAWSEGMENT::GetShape(), DRAWSEGMENT::GetStart(), DRAWSEGMENT::GetWidth(), KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchBoardGfx, KIGFX::PCB_RENDER_SETTINGS::m_sketchFpGfx, 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  const auto& points = aSegment->BuildPolyPointsList();
972  std::deque<VECTOR2D> pointsList;
973 
974  if( points.empty() )
975  break;
976 
977  m_gal->Save();
978 
979  if( MODULE* module = aSegment->GetParentModule() )
980  {
981  m_gal->Translate( module->GetPosition() );
982  m_gal->Rotate( -module->GetOrientationRadians() );
983  }
984 
985  std::copy( points.begin(), points.end(), std::back_inserter( pointsList ) );
986  pointsList.push_back( points[0] );
987 
988  m_gal->SetLineWidth( thickness );
989  m_gal->SetIsFill( true );
990  m_gal->SetIsStroke( true );
991  m_gal->DrawPolygon( pointsList );
992 
993  m_gal->Restore();
994  break;
995  }
996 
997  case S_CURVE:
998  m_gal->SetIsFill( false );
999  m_gal->SetIsStroke( true );
1000  m_gal->SetLineWidth( thickness );
1001  m_gal->DrawCurve( VECTOR2D( aSegment->GetStart() ),
1002  VECTOR2D( aSegment->GetBezControl1() ),
1003  VECTOR2D( aSegment->GetBezControl2() ),
1004  VECTOR2D( aSegment->GetEnd() ) );
1005  break;
1006 
1007  case S_LAST:
1008  break;
1009  }
1010 }
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
const std::vector< wxPoint > BuildPolyPointsList() const
Build and return the list of corners in a std::vector<wxPoint> It must be used only to convert the SH...
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()
Class VECTOR2 defines a general 2D-vector/point.
Definition: vector2d.h:61
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
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:232
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.
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 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 
)
protectedinherited

Definition at line 1013 of file pcb_painter.cpp.

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

1014 {
1015  wxString shownText( aText->GetShownText() );
1016  if( shownText.Length() == 0 )
1017  return;
1018 
1019  const COLOR4D& color = m_pcbSettings.GetColor( aText, aText->GetLayer() );
1020  VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );
1021 
1022  if( m_pcbSettings.m_sketchMode[aLayer] )
1023  {
1024  // Outline mode
1026  }
1027  else
1028  {
1029  // Filled mode
1031  }
1032 
1033  m_gal->SetStrokeColor( color );
1034  m_gal->SetIsFill( false );
1035  m_gal->SetIsStroke( true );
1036  m_gal->SetTextAttributes( aText );
1037  m_gal->StrokeText( shownText, position, aText->GetTextAngleRadians() );
1038 }
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...
Class VECTOR2 defines a general 2D-vector/point.
Definition: vector2d.h:61
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 
)
protectedinherited

Definition at line 1041 of file pcb_painter.cpp.

References color, KIGFX::GAL::DrawLine(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), TEXTE_MODULE::GetDrawRotationRadians(), KIGFX::PCB_PAINTER::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, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::PCB_RENDER_SETTINGS::m_sketchFpTxtfx, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextAttributes(), KIGFX::GAL::StrokeText(), wxPoint::x, and wxPoint::y.

1042 {
1043  wxString shownText( aText->GetShownText() );
1044  if( shownText.Length() == 0 )
1045  return;
1046 
1047  bool sketch = m_pcbSettings.m_sketchFpTxtfx;
1048 
1049  const COLOR4D& color = m_pcbSettings.GetColor( aText, aLayer );
1050  VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );
1051 
1052  // Currently, draw text routines do not know the true outline mode.
1053  // so draw the text in "line" mode (no thickness)
1054  if( sketch )
1055  {
1056  // Outline mode
1058  }
1059  else
1060  {
1061  // Filled mode
1063  }
1064 
1065  m_gal->SetStrokeColor( color );
1066  m_gal->SetIsFill( false );
1067  m_gal->SetIsStroke( true );
1068  m_gal->SetTextAttributes( aText );
1069  m_gal->StrokeText( shownText, position, aText->GetDrawRotationRadians() );
1070 
1071  // Draw the umbilical line
1072  if( aText->IsSelected() )
1073  {
1075  m_gal->SetStrokeColor( COLOR4D( 0.0, 0.0, 1.0, 1.0 ) );
1076  m_gal->DrawLine( position, aText->GetParent()->GetPosition() );
1077  }
1078 }
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...
Class VECTOR2 defines a general 2D-vector/point.
Definition: vector2d.h:61
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 
)
protectedinherited

Definition at line 1081 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, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

1082 {
1083  if( aLayer == LAYER_ANCHOR )
1084  {
1085  const COLOR4D color = m_pcbSettings.GetColor( aModule, LAYER_ANCHOR );
1086 
1087  // Draw anchor
1088  m_gal->SetStrokeColor( color );
1090 
1091  // Keep the size constant, not related to the scale
1092  double anchorSize = 5.0 / m_gal->GetWorldScale();
1093 
1094  VECTOR2D center = aModule->GetPosition();
1095  m_gal->DrawLine( center - VECTOR2D( anchorSize, 0 ), center + VECTOR2D( anchorSize, 0 ) );
1096  m_gal->DrawLine( center - VECTOR2D( 0, anchorSize ), center + VECTOR2D( 0, anchorSize ) );
1097  }
1098 }
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...
Class VECTOR2 defines a general 2D-vector/point.
Definition: vector2d.h:61
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:184
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 
)
protectedinherited

Definition at line 1101 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, KIGFX::PCB_PAINTER::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().

1102 {
1103  if( !aZone->IsOnLayer( (PCB_LAYER_ID) aLayer ) )
1104  return;
1105 
1106  const COLOR4D& color = m_pcbSettings.GetColor( aZone, aLayer );
1107  std::deque<VECTOR2D> corners;
1109 
1110  // Draw the outline
1111  const SHAPE_POLY_SET* outline = aZone->Outline();
1112 
1113  if( m_pcbSettings.m_zoneOutlines && outline )
1114  {
1115  m_gal->SetStrokeColor( color );
1116  m_gal->SetIsFill( false );
1117  m_gal->SetIsStroke( true );
1119 
1120  // Draw each contour (main contour and holes)
1121 
1122  /* This line:
1123  * m_gal->DrawPolygon( *outline );
1124  * should be enough, but currently does not work to draw holes contours in a complex polygon
1125  * so each contour is draw as a simple polygon
1126  */
1127 
1128  // Draw the main contour
1129  m_gal->DrawPolyline( outline->COutline( 0 ) );
1130 
1131  // Draw holes
1132  int holes_count = outline->HoleCount( 0 );
1133 
1134  for( int ii = 0; ii < holes_count; ++ii )
1135  m_gal->DrawPolyline( outline->CHole( 0, ii ) );
1136 
1137  // Draw hatch lines
1138  for( const SEG& hatchLine : aZone->GetHatchLines() )
1139  m_gal->DrawLine( hatchLine.A, hatchLine.B );
1140  }
1141 
1142  // Draw the filling
1143  if( displayMode != PCB_RENDER_SETTINGS::DZ_HIDE_FILLED )
1144  {
1145  const SHAPE_POLY_SET& polySet = aZone->GetFilledPolysList();
1146 
1147  if( polySet.OutlineCount() == 0 ) // Nothing to draw
1148  return;
1149 
1150  // Set up drawing options
1151  m_gal->SetFillColor( color );
1152  m_gal->SetLineWidth( aZone->GetMinThickness() );
1153 
1154  if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_FILLED )
1155  {
1156  m_gal->SetIsFill( true );
1157  m_gal->SetIsStroke( true );
1158  }
1159  else if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_OUTLINED )
1160  {
1161  m_gal->SetIsFill( false );
1162  m_gal->SetIsStroke( true );
1163  }
1164 
1165  m_gal->DrawPolygon( polySet );
1166  }
1167 
1168 }
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:204
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:242
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:665
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:540
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 
)
protectedinherited

Definition at line 1171 of file pcb_painter.cpp.

References KIGFX::GAL::DrawLine(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), KIGFX::PCB_PAINTER::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, KIGFX::PCB_PAINTER::m_pcbSettings, KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), KIGFX::GAL::SetTextAttributes(), KIGFX::GAL::StrokeText(), DIMENSION::Text(), wxPoint::x, and wxPoint::y.

1172 {
1173  const COLOR4D& strokeColor = m_pcbSettings.GetColor( aDimension, aLayer );
1174 
1175  m_gal->SetStrokeColor( strokeColor );
1176  m_gal->SetIsFill( false );
1177  m_gal->SetIsStroke( true );
1178  m_gal->SetLineWidth( getLineThickness( aDimension->GetWidth() ) );
1179 
1180  // Draw an arrow
1181  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_crossBarF ) );
1182  m_gal->DrawLine( VECTOR2D( aDimension->m_featureLineGO ),
1183  VECTOR2D( aDimension->m_featureLineGF ) );
1184  m_gal->DrawLine( VECTOR2D( aDimension->m_featureLineDO ),
1185  VECTOR2D( aDimension->m_featureLineDF ) );
1186  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarF ), VECTOR2D( aDimension->m_arrowD1F ) );
1187  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarF ), VECTOR2D( aDimension->m_arrowD2F ) );
1188  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_arrowG1F ) );
1189  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_arrowG2F ) );
1190 
1191  // Draw text
1192  TEXTE_PCB& text = aDimension->Text();
1193  VECTOR2D position( text.GetTextPos().x, text.GetTextPos().y );
1194 
1195  m_gal->SetLineWidth( text.GetThickness() );
1196  m_gal->SetTextAttributes( &text );
1197  m_gal->StrokeText( text.GetShownText(), position, text.GetTextAngleRadians() );
1198 }
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...
Class VECTOR2 defines a general 2D-vector/point.
Definition: vector2d.h:61
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)
protectedinherited

Definition at line 1201 of file pcb_painter.cpp.

References KIGFX::GAL::DrawCircle(), KIGFX::GAL::DrawLine(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), BOARD_ITEM::GetLayer(), KIGFX::PCB_PAINTER::getLineThickness(), PCB_TARGET::GetPosition(), PCB_TARGET::GetShape(), PCB_TARGET::GetSize(), PCB_TARGET::GetWidth(), KIGFX::PAINTER::m_gal, KIGFX::PCB_PAINTER::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().

1202 {
1203  const COLOR4D& strokeColor = m_pcbSettings.GetColor( aTarget, aTarget->GetLayer() );
1204  VECTOR2D position( aTarget->GetPosition() );
1205  double size, radius;
1206 
1207  m_gal->SetLineWidth( getLineThickness( aTarget->GetWidth() ) );
1208  m_gal->SetStrokeColor( strokeColor );
1209  m_gal->SetIsFill( false );
1210  m_gal->SetIsStroke( true );
1211 
1212  m_gal->Save();
1213  m_gal->Translate( position );
1214 
1215  if( aTarget->GetShape() )
1216  {
1217  // shape x
1218  m_gal->Rotate( M_PI / 4.0 );
1219  size = 2.0 * aTarget->GetSize() / 3.0;
1220  radius = aTarget->GetSize() / 2.0;
1221  }
1222  else
1223  {
1224  // shape +
1225  size = aTarget->GetSize() / 2.0;
1226  radius = aTarget->GetSize() / 3.0;
1227  }
1228 
1229  m_gal->DrawLine( VECTOR2D( -size, 0.0 ), VECTOR2D( size, 0.0 ) );
1230  m_gal->DrawLine( VECTOR2D( 0.0, -size ), VECTOR2D( 0.0, size ) );
1231  m_gal->DrawCircle( VECTOR2D( 0.0, 0.0 ), radius );
1232 
1233  m_gal->Restore();
1234 }
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...
Class VECTOR2 defines a general 2D-vector/point.
Definition: vector2d.h:61
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)
protectedinherited

Definition at line 1237 of file pcb_painter.cpp.

References KIGFX::GAL::DrawPolygon(), KIGFX::PCB_RENDER_SETTINGS::GetColor(), MARKER_PCB::GetPosition(), LAYER_DRC, KIGFX::PAINTER::m_gal, KIGFX::PCB_PAINTER::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().

1238 {
1239  const int scale = MARKER_PCB::MarkerScale();
1240 
1241  // If you are changing this, update MARKER_PCB::ViewBBox()
1242  const VECTOR2D arrow[] = {
1243  VECTOR2D( 0 * scale, 0 * scale ),
1244  VECTOR2D( 8 * scale, 1 * scale ),
1245  VECTOR2D( 4 * scale, 3 * scale ),
1246  VECTOR2D( 13 * scale, 8 * scale ),
1247  VECTOR2D( 9 * scale, 9 * scale ),
1248  VECTOR2D( 8 * scale, 13 * scale ),
1249  VECTOR2D( 3 * scale, 4 * scale ),
1250  VECTOR2D( 1 * scale, 8 * scale ),
1251  VECTOR2D( 0 * scale, 0 * scale )
1252  };
1253 
1254  auto strokeColor = m_pcbSettings.GetColor( aMarker, LAYER_DRC );
1255 
1256  m_gal->Save();
1257  m_gal->Translate( aMarker->GetPosition() );
1258  m_gal->SetFillColor( strokeColor );
1259  m_gal->SetIsFill( true );
1260  m_gal->SetIsStroke( false );
1261  m_gal->DrawPolygon( arrow, sizeof( arrow ) / sizeof( VECTOR2D ) );
1262  m_gal->Restore();
1263 }
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...
Class VECTOR2 defines a general 2D-vector/point.
Definition: vector2d.h:61
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 KIGFX::PCB_PRINT_PAINTER::getDrillShape ( const D_PAD aPad) const
overrideprotectedvirtual

Return drill shape of a pad.

Reimplemented from KIGFX::PCB_PAINTER.

Definition at line 220 of file pcbnew_printout.cpp.

References KIGFX::PCB_PAINTER::getDrillShape(), m_drillMarkReal, and PAD_DRILL_SHAPE_CIRCLE.

221 {
223 }
virtual int getDrillShape(const D_PAD *aPad) const
Return drill shape of a pad.
bool m_drillMarkReal
Flag deciding whether use the actual hole size or user-specified size for drill marks ...
VECTOR2D KIGFX::PCB_PRINT_PAINTER::getDrillSize ( const D_PAD aPad) const
overrideprotectedvirtual

Return drill size for a pad (internal units).

Reimplemented from KIGFX::PCB_PAINTER.

Definition at line 226 of file pcbnew_printout.cpp.

References KIGFX::PCB_PAINTER::getDrillSize(), m_drillMarkReal, and m_drillMarkSize.

227 {
228  // TODO should it depend on the pad size?
231 }
bool m_drillMarkReal
Flag deciding whether use the actual hole size or user-specified size for drill marks ...
int m_drillMarkSize
User-specified size for drill marks (expressed in internal units)
virtual VECTOR2D getDrillSize(const D_PAD *aPad) const
Return drill size for a pad (internal units).
int KIGFX::PCB_PRINT_PAINTER::getDrillSize ( const VIA aVia) const
overrideprotectedvirtual

Return drill diameter for a via (internal units).

Reimplemented from KIGFX::PCB_PAINTER.

Definition at line 234 of file pcbnew_printout.cpp.

References KIGFX::PCB_PAINTER::getDrillSize(), m_drillMarkReal, and m_drillMarkSize.

235 {
236  // TODO should it depend on the via size?
238 }
bool m_drillMarkReal
Flag deciding whether use the actual hole size or user-specified size for drill marks ...
int m_drillMarkSize
User-specified size for drill marks (expressed in internal units)
virtual VECTOR2D getDrillSize(const D_PAD *aPad) const
Return drill size for a pad (internal units).
int PCB_PAINTER::getLineThickness ( int  aActualThickness) const
protectedinherited

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 KIGFX::PCB_PAINTER::m_pcbSettings.

Referenced by KIGFX::PCB_PAINTER::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 ( )
inlineoverridevirtualinherited

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::PCB_PRINT_PAINTER::SetDrillMarks ( bool  aRealSize,
unsigned int  aSize = 0 
)
inline

Set drill marks visibility and options.

Parameters
aRealSizewhen enabled, drill marks represent actual holes. Otherwise aSize parameter is used.
aSizeis drill mark size (internal units), valid only when aRealSize == false.

Definition at line 94 of file pcbnew_printout.h.

95  {
96  m_drillMarkReal = aRealSize;
97  m_drillMarkSize = aSize;
98  }
bool m_drillMarkReal
Flag deciding whether use the actual hole size or user-specified size for drill marks ...
int m_drillMarkSize
User-specified size for drill marks (expressed in internal units)
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.

bool KIGFX::PCB_PRINT_PAINTER::m_drillMarkReal
protected

Flag deciding whether use the actual hole size or user-specified size for drill marks

Definition at line 108 of file pcbnew_printout.h.

Referenced by getDrillShape(), and getDrillSize().

int KIGFX::PCB_PRINT_PAINTER::m_drillMarkSize
protected

User-specified size for drill marks (expressed in internal units)

Definition at line 111 of file pcbnew_printout.h.

Referenced by getDrillSize().

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(), KIGFX::PCB_PAINTER::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
protectedinherited

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