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

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

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 195 of file pcb_painter.h.

Constructor & Destructor Documentation

PCB_PAINTER::PCB_PAINTER ( GAL aGal)

Definition at line 263 of file pcb_painter.cpp.

263  :
264  PAINTER( aGal )
265 {
266 }
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 201 of file pcb_painter.h.

202  {
203  m_pcbSettings = *static_cast<const PCB_RENDER_SETTINGS*>( aSettings );
204  }
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:216
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 281 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().

282 {
283  const EDA_ITEM* item = dynamic_cast<const EDA_ITEM*>( aItem );
284 
285  if( !item )
286  return false;
287 
288  // the "cast" applied in here clarifies which overloaded draw() is called
289  switch( item->Type() )
290  {
291  case PCB_SEGZONE_T:
292  case PCB_TRACE_T:
293  draw( static_cast<const TRACK*>( item ), aLayer );
294  break;
295 
296  case PCB_VIA_T:
297  draw( static_cast<const VIA*>( item ), aLayer );
298  break;
299 
300  case PCB_PAD_T:
301  draw( static_cast<const D_PAD*>( item ), aLayer );
302  break;
303 
304  case PCB_LINE_T:
305  case PCB_MODULE_EDGE_T:
306  draw( static_cast<const DRAWSEGMENT*>( item ), aLayer );
307  break;
308 
309  case PCB_TEXT_T:
310  draw( static_cast<const TEXTE_PCB*>( item ), aLayer );
311  break;
312 
313  case PCB_MODULE_TEXT_T:
314  draw( static_cast<const TEXTE_MODULE*>( item ), aLayer );
315  break;
316 
317  case PCB_MODULE_T:
318  draw( static_cast<const MODULE*>( item ), aLayer );
319  break;
320 
321  case PCB_ZONE_AREA_T:
322  draw( static_cast<const ZONE_CONTAINER*>( item ), aLayer );
323  break;
324 
325  case PCB_DIMENSION_T:
326  draw( static_cast<const DIMENSION*>( item ), aLayer );
327  break;
328 
329  case PCB_TARGET_T:
330  draw( static_cast<const PCB_TARGET*>( item ) );
331  break;
332 
333  case PCB_MARKER_T:
334  draw( static_cast<const MARKER_PCB*>( item ) );
335  break;
336 
337  default:
338  // Painter does not know how to draw the object
339  return false;
340  }
341 
342  return true;
343 }
KICAD_T Type() const
Function Type()
Definition: base_struct.h:198
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:151
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 346 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().

347 {
348  VECTOR2D start( aTrack->GetStart() );
349  VECTOR2D end( aTrack->GetEnd() );
350  int width = aTrack->GetWidth();
351 
353  {
354  // If there is a net name - display it on the track
355  if( aTrack->GetNetCode() > NETINFO_LIST::UNCONNECTED )
356  {
357  VECTOR2D line = ( end - start );
358  double length = line.EuclideanNorm();
359 
360  // Check if the track is long enough to have a netname displayed
361  if( length < 10 * width )
362  return;
363 
364  const wxString& netName = aTrack->GetShortNetname();
365  VECTOR2D textPosition = start + line / 2.0; // center of the track
366 
367  double textOrientation;
368 
369  if( end.y == start.y ) // horizontal
370  textOrientation = 0;
371  else if( end.x == start.x ) // vertical
372  textOrientation = M_PI / 2;
373  else
374  textOrientation = -atan( line.y / line.x );
375 
376  double textSize = width;
377 
378  m_gal->SetIsStroke( true );
379  m_gal->SetIsFill( false );
380  m_gal->SetStrokeColor( m_pcbSettings.GetColor( NULL, aLayer ) );
381  m_gal->SetLineWidth( width / 10.0 );
382  m_gal->SetFontBold( false );
383  m_gal->SetFontItalic( false );
384  m_gal->SetTextMirrored( false );
385  m_gal->SetGlyphSize( VECTOR2D( textSize * 0.7, textSize * 0.7 ) );
388  m_gal->BitmapText( netName, textPosition, textOrientation );
389  }
390  }
391  else if( IsCopperLayer( aLayer ) )
392  {
393  // Draw a regular track
394  const COLOR4D& color = m_pcbSettings.GetColor( aTrack, aLayer );
395  m_gal->SetStrokeColor( color );
396  m_gal->SetIsStroke( true );
397 
399  {
400  // Outline mode
402  m_gal->SetIsFill( false );
403  }
404  else
405  {
406  // Filled mode
407  m_gal->SetFillColor( color );
408  m_gal->SetIsFill( true );
409  }
410 
411  m_gal->DrawSegment( start, end, width );
412 
413  // Clearance lines
414  constexpr int clearanceFlags = PCB_RENDER_SETTINGS::CL_EXISTING | PCB_RENDER_SETTINGS::CL_TRACKS;
415 
416  if( ( m_pcbSettings.m_clearance & clearanceFlags ) == clearanceFlags )
417  {
419  m_gal->SetIsFill( false );
420  m_gal->SetIsStroke( true );
421  m_gal->SetStrokeColor( color );
422  m_gal->DrawSegment( start, end, width + aTrack->GetClearance() * 2 );
423  }
424  }
425 }
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:272
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:154
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:216
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:345
void SetFontBold(const bool aBold)
Set bold property of current font.
virtual void SetLineWidth(double aLineWidth)
Set the line width.
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:172
int m_clearance
Clearance visibility settings
Definition: pcb_painter.h:184
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 
)
protected

Definition at line 428 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(), 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, 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.

429 {
430  VECTOR2D center( aVia->GetStart() );
431  double radius = 0.0;
432 
433  // Draw description layer
434  if( IsNetnameLayer( aLayer ) )
435  {
436  VECTOR2D position( center );
437 
438  // Is anything that we can display enabled?
440  {
441  bool displayNetname = ( !aVia->GetNetname().empty() );
443  double size = aVia->GetWidth();
444 
445  // Font size limits
446  if( size > maxSize )
447  size = maxSize;
448 
449  m_gal->Save();
450  m_gal->Translate( position );
451 
452  // Default font settings
454  m_gal->SetStrokeColor( m_pcbSettings.GetColor( NULL, aLayer ) );
455 
456  // Set the text position to the pad shape position (the pad position is not the best place)
457  VECTOR2D textpos( 0.0, 0.0 );
458 
459  if( displayNetname )
460  {
461  // calculate the size of net name text:
462  double tsize = 1.5 * size / aVia->GetShortNetname().Length();
463  tsize = std::min( tsize, size );
464  // Use a smaller text size to handle interline, pen size..
465  tsize *= 0.7;
466  VECTOR2D namesize( tsize, tsize );
467 
468  m_gal->SetGlyphSize( namesize );
469  m_gal->SetLineWidth( namesize.x / 12.0 );
470  m_gal->BitmapText( aVia->GetShortNetname(), textpos, 0.0 );
471  }
472 
473 
474  m_gal->Restore();
475  }
476  return;
477  }
478 
479  // Choose drawing settings depending on if we are drawing via's pad or hole
480  if( aLayer == LAYER_VIAS_HOLES )
481  radius = aVia->GetDrillValue() / 2.0;
482  else
483  radius = aVia->GetWidth() / 2.0;
484 
485  bool sketchMode = false;
486  const COLOR4D& color = m_pcbSettings.GetColor( aVia, aLayer );
487 
488  switch( aVia->GetViaType() )
489  {
490  case VIA_THROUGH:
492  break;
493 
494  case VIA_BLIND_BURIED:
496  break;
497 
498  case VIA_MICROVIA:
500  break;
501 
502  default:
503  assert( false );
504  break;
505  }
506 
507  if( aVia->GetViaType() == VIA_BLIND_BURIED )
508  {
509  // Buried vias are drawn in a special way to indicate the top and bottom layers
510  PCB_LAYER_ID layerTop, layerBottom;
511  aVia->LayerPair( &layerTop, &layerBottom );
512 
513  if( aLayer == LAYER_VIAS_HOLES )
514  { // TODO outline mode
515  m_gal->SetIsFill( true );
516  m_gal->SetIsStroke( false );
517  m_gal->SetFillColor( color );
518  m_gal->DrawCircle( center, radius );
519  }
520  else
521  {
522  double width = ( aVia->GetWidth() - aVia->GetDrillValue() ) / 2.0;
523 
524  m_gal->SetLineWidth( width );
525  m_gal->SetIsFill( true );
526  m_gal->SetIsStroke( false );
527  m_gal->SetFillColor( color );
528 
529  if( aLayer == layerTop )
530  {
531  m_gal->DrawArc( center, radius, 0.0, M_PI / 2.0 );
532  }
533  else if( aLayer == layerBottom )
534  {
535  m_gal->DrawArc( center, radius, M_PI, 3.0 * M_PI / 2.0 );
536  }
537  else if( aLayer == LAYER_VIA_BBLIND )
538  {
539  m_gal->DrawArc( center, radius, M_PI / 2.0, M_PI );
540  m_gal->DrawArc( center, radius, 3.0 * M_PI / 2.0, 2.0 * M_PI );
541  }
542  }
543  }
544  else
545  {
546  // Regular vias
547  m_gal->SetIsFill( !sketchMode );
548  m_gal->SetIsStroke( sketchMode );
549 
550  if( sketchMode )
551  {
552  // Outline mode
554  m_gal->SetStrokeColor( color );
555  }
556  else
557  {
558  // Filled mode
559  m_gal->SetFillColor( color );
560  }
561 
562  m_gal->DrawCircle( center, radius );
563  }
564 
565  // Clearance lines
566  constexpr int clearanceFlags = PCB_RENDER_SETTINGS::CL_EXISTING | PCB_RENDER_SETTINGS::CL_VIAS;
567 
568  if( ( m_pcbSettings.m_clearance & clearanceFlags ) == clearanceFlags
569  && aLayer != LAYER_VIAS_HOLES )
570  {
572  m_gal->SetIsFill( false );
573  m_gal->SetIsStroke( true );
574  m_gal->SetStrokeColor( color );
575  m_gal->DrawCircle( center, radius + aVia->GetClearance() );
576  }
577 }
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:272
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:154
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:216
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:345
PCB_LAYER_ID
A quick note on layer IDs:
virtual void SetLineWidth(double aLineWidth)
Set the line width.
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:178
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:184
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
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:175
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 580 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(), D_PAD::GetDrillShape(), D_PAD::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, 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.

581 {
582  PAD_SHAPE_T shape;
583  double m, n;
584  double orientation = aPad->GetOrientation();
585 
586  // Draw description layer
587  if( IsNetnameLayer( aLayer ) )
588  {
589  VECTOR2D position( aPad->ShapePos() );
590 
591  // Is anything that we can display enabled?
593  {
594  bool displayNetname = ( m_pcbSettings.m_netNamesOnPads && !aPad->GetNetname().empty() );
595  VECTOR2D padsize = VECTOR2D( aPad->GetSize() );
597  double size = padsize.y;
598 
599  // Keep the size ratio for the font, but make it smaller
600  if( padsize.x < padsize.y )
601  {
602  orientation += 900.0;
603  size = padsize.x;
604  std::swap( padsize.x, padsize.y );
605  }
606  else if( padsize.x == padsize.y )
607  {
608  // If the text is displayed on a symmetrical pad, do not rotate it
609  orientation = 0.0;
610  }
611 
612  // Font size limits
613  if( size > maxSize )
614  size = maxSize;
615 
616  m_gal->Save();
617  m_gal->Translate( position );
618 
619  // do not display descriptions upside down
620  NORMALIZE_ANGLE_90( orientation );
621  m_gal->Rotate( DECIDEG2RAD( -orientation ) );
622 
623  // Default font settings
626  m_gal->SetFontBold( false );
627  m_gal->SetFontItalic( false );
628  m_gal->SetTextMirrored( false );
629  m_gal->SetStrokeColor( m_pcbSettings.GetColor( NULL, aLayer ) );
630  m_gal->SetIsStroke( true );
631  m_gal->SetIsFill( false );
632 
633  // Set the text position to the pad shape position (the pad position is not the best place)
634  VECTOR2D textpos( 0.0, 0.0 );
635 
636  // Divide the space, to display both pad numbers and netnames
637  // and set the Y text position to display 2 lines
638  if( displayNetname && m_pcbSettings.m_padNumbers )
639  {
640  size = size / 2.0;
641  textpos.y = size / 2.0;
642  }
643 
644  if( displayNetname )
645  {
646  // calculate the size of net name text:
647  double tsize = 1.5 * padsize.x / aPad->GetShortNetname().Length();
648  tsize = std::min( tsize, size );
649  // Use a smaller text size to handle interline, pen size..
650  tsize *= 0.7;
651  VECTOR2D namesize( tsize, tsize );
652 
653  m_gal->SetGlyphSize( namesize );
654  m_gal->SetLineWidth( namesize.x / 12.0 );
655  m_gal->BitmapText( aPad->GetShortNetname(), textpos, 0.0 );
656  }
657 
659  {
660  const wxString& padName = aPad->GetName();
661  textpos.y = -textpos.y;
662  double tsize = 1.5 * padsize.x / padName.Length();
663  tsize = std::min( tsize, size );
664  // Use a smaller text size to handle interline, pen size..
665  tsize *= 0.7;
666  tsize = std::min( tsize, size );
667  VECTOR2D numsize( tsize, tsize );
668 
669  m_gal->SetGlyphSize( numsize );
670  m_gal->SetLineWidth( numsize.x / 12.0 );
671  m_gal->BitmapText( padName, textpos, 0.0 );
672  }
673 
674  m_gal->Restore();
675  }
676  return;
677  }
678 
679  // Pad drawing
680  COLOR4D color = m_pcbSettings.GetColor( aPad, aLayer );
681 
682  // Pad holes color is specific
683  if( aLayer == LAYER_PADS_PLATEDHOLES || aLayer == LAYER_NON_PLATEDHOLES )
684  {
685  // Hole color is the background color for plated holes, but a specific color
686  // for not plated holes (LAYER_NON_PLATEDHOLES color layer )
688  color = m_pcbSettings.GetColor( nullptr, LAYER_NON_PLATEDHOLES );
689  // Don't let pads that *should* be NPTH get lost
690  else if( aPad->PadShouldBeNPTH() )
691  color = m_pcbSettings.GetColor( aPad, aLayer );
692  else
694  }
695 
696  VECTOR2D size;
697 
699  {
700  // Outline mode
701  m_gal->SetIsFill( false );
702  m_gal->SetIsStroke( true );
704  m_gal->SetStrokeColor( color );
705  }
706  else
707  {
708  // Filled mode
709  m_gal->SetIsFill( true );
710  m_gal->SetIsStroke( false );
711  m_gal->SetFillColor( color );
712  }
713 
714  m_gal->Save();
715  m_gal->Translate( VECTOR2D( aPad->GetPosition() ) );
716  m_gal->Rotate( -aPad->GetOrientationRadians() );
717 
718  int custom_margin = 0; // a clearance/margin for custom shape, for solder paste/mask
719 
720  // Choose drawing settings depending on if we are drawing a pad itself or a hole
721  if( aLayer == LAYER_PADS_PLATEDHOLES || aLayer == LAYER_NON_PLATEDHOLES )
722  {
723  // Drawing hole: has same shape as PAD_CIRCLE or PAD_OVAL
724  size = VECTOR2D( aPad->GetDrillSize() ) / 2.0;
726  }
727  else if( aLayer == F_Mask || aLayer == B_Mask )
728  {
729  // Drawing soldermask
730  int soldermaskMargin = aPad->GetSolderMaskMargin();
731  custom_margin = soldermaskMargin;
732 
733  m_gal->Translate( VECTOR2D( aPad->GetOffset() ) );
734  size = VECTOR2D( aPad->GetSize().x / 2.0 + soldermaskMargin,
735  aPad->GetSize().y / 2.0 + soldermaskMargin );
736  shape = aPad->GetShape();
737  }
738  else if( aLayer == F_Paste || aLayer == B_Paste )
739  {
740  // Drawing solderpaste
741  wxSize solderpasteMargin = aPad->GetSolderPasteMargin();
742  // try to find a clearance which can be used for custom shapes
743  custom_margin = solderpasteMargin.x;
744 
745  m_gal->Translate( VECTOR2D( aPad->GetOffset() ) );
746  size = VECTOR2D( aPad->GetSize().x / 2.0 + solderpasteMargin.x,
747  aPad->GetSize().y / 2.0 + solderpasteMargin.y );
748  shape = aPad->GetShape();
749  }
750  else
751  {
752  // Drawing every kind of pad
753  m_gal->Translate( VECTOR2D( aPad->GetOffset() ) );
754  size = VECTOR2D( aPad->GetSize() ) / 2.0;
755  shape = aPad->GetShape();
756  }
757 
758  switch( shape )
759  {
760  case PAD_SHAPE_OVAL:
761  if( size.y >= size.x )
762  {
763  m = ( size.y - size.x );
764  n = size.x;
765 
767  {
768  // Outline mode
769  m_gal->DrawArc( VECTOR2D( 0, -m ), n, -M_PI, 0 );
770  m_gal->DrawArc( VECTOR2D( 0, m ), n, M_PI, 0 );
771  m_gal->DrawLine( VECTOR2D( -n, -m ), VECTOR2D( -n, m ) );
772  m_gal->DrawLine( VECTOR2D( n, -m ), VECTOR2D( n, m ) );
773  }
774  else
775  {
776  // Filled mode
777  m_gal->DrawCircle( VECTOR2D( 0, -m ), n );
778  m_gal->DrawCircle( VECTOR2D( 0, m ), n );
779  m_gal->DrawRectangle( VECTOR2D( -n, -m ), VECTOR2D( n, m ) );
780  }
781  }
782  else
783  {
784  m = ( size.x - size.y );
785  n = size.y;
786 
788  {
789  // Outline mode
790  m_gal->DrawArc( VECTOR2D( -m, 0 ), n, M_PI / 2, 3 * M_PI / 2 );
791  m_gal->DrawArc( VECTOR2D( m, 0 ), n, M_PI / 2, -M_PI / 2 );
792  m_gal->DrawLine( VECTOR2D( -m, -n ), VECTOR2D( m, -n ) );
793  m_gal->DrawLine( VECTOR2D( -m, n ), VECTOR2D( m, n ) );
794  }
795  else
796  {
797  // Filled mode
798  m_gal->DrawCircle( VECTOR2D( -m, 0 ), n );
799  m_gal->DrawCircle( VECTOR2D( m, 0 ), n );
800  m_gal->DrawRectangle( VECTOR2D( -m, -n ), VECTOR2D( m, n ) );
801  }
802  }
803  break;
804 
805  case PAD_SHAPE_RECT:
806  m_gal->DrawRectangle( VECTOR2D( -size.x, -size.y ), VECTOR2D( size.x, size.y ) );
807  break;
808 
809  case PAD_SHAPE_ROUNDRECT:
810  {
811  SHAPE_POLY_SET polySet;
812  wxSize prsize( size.x * 2, size.y * 2 );
813  const int segmentToCircleCount = 64;
814  const int corner_radius = aPad->GetRoundRectCornerRadius( prsize );
815  TransformRoundRectToPolygon( polySet, wxPoint( 0, 0 ), prsize,
816  0.0, corner_radius, segmentToCircleCount );
817  m_gal->DrawPolygon( polySet );
818  break;
819  }
820 
821  case PAD_SHAPE_CUSTOM:
822  { // Draw the complex custom shape
823 
824  // Use solder[Paste/Mask]size or pad size to build pad shape
825  // however, solder[Paste/Mask] size has no actual meaning for a
826  // custom shape, because it is a set of basic shapes
827  // We use the custom_margin (good for solder mask, but approximative
828  // for solder paste).
829  if( custom_margin )
830  {
831  SHAPE_POLY_SET outline;
832  outline.Append( aPad->GetCustomShapeAsPolygon() );
833  const int segmentToCircleCount = 32;
834  outline.Inflate( custom_margin, segmentToCircleCount );
835  m_gal->DrawPolygon( outline );
836  }
837  else
838  {
839  // Draw the polygon: only one polygon is expected
840  // However we provide a multi polygon shape drawing
841  // ( for the future or to show even an incorrect shape
843  }
844  }
845  break;
846 
847  case PAD_SHAPE_TRAPEZOID:
848  {
849  std::deque<VECTOR2D> pointList;
850  wxPoint corners[4];
851 
852  VECTOR2D padSize = VECTOR2D( aPad->GetSize().x, aPad->GetSize().y ) / 2;
853  VECTOR2D deltaPadSize = size - padSize; // = solder[Paste/Mask]Margin or 0
854 
855  aPad->BuildPadPolygon( corners, wxSize( deltaPadSize.x, deltaPadSize.y ), 0.0 );
856  SHAPE_POLY_SET polySet;
857  polySet.NewOutline();
858  polySet.Append( VECTOR2I( corners[0] ) );
859  polySet.Append( VECTOR2I( corners[1] ) );
860  polySet.Append( VECTOR2I( corners[2] ) );
861  polySet.Append( VECTOR2I( corners[3] ) );
862 
863  m_gal->DrawPolygon( polySet );
864  }
865  break;
866 
867  case PAD_SHAPE_CIRCLE:
868  m_gal->DrawCircle( VECTOR2D( 0.0, 0.0 ), size.x );
869  break;
870  }
871 
872  m_gal->Restore();
873 
874  // Clearance lines
875  // It has to be called after GAL::Restore() as TransformShapeWithClearanceToPolygon()
876  // returns already transformed coordinates
877  constexpr int clearanceFlags = /*PCB_RENDER_SETTINGS::CL_EXISTING |*/ PCB_RENDER_SETTINGS::CL_PADS;
878 
879  if( ( m_pcbSettings.m_clearance & clearanceFlags ) == clearanceFlags
880  && ( aLayer == LAYER_PAD_FR
881  || aLayer == LAYER_PAD_BK
882  || aLayer == LAYER_PADS_TH ) )
883  {
884  SHAPE_POLY_SET polySet;
885  constexpr int SEGCOUNT = 64;
886  aPad->TransformShapeWithClearanceToPolygon( polySet, aPad->GetClearance(), SEGCOUNT, 1.0 );
888  m_gal->SetIsStroke( true );
889  m_gal->SetIsFill( false );
890  m_gal->SetStrokeColor( color );
891  m_gal->DrawPolygon( polySet );
892  }
893 }
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.
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:272
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:154
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...
bool m_padNumbers
Flag determining if pad numbers should be visible
Definition: pcb_painter.h:166
PAD_DRILL_SHAPE_T GetDrillShape() const
Definition: class_pad.h:388
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:216
const wxSize & GetDrillSize() const
Definition: class_pad.h:275
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:169
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:345
virtual void Rotate(double aAngle)
Rotate the context.
void SetFontBold(const bool aBold)
Set bold property of current font.
virtual void SetLineWidth(double aLineWidth)
Set the line width.
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:178
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:184
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:146
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
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 
)
protected

Definition at line 896 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(), getLineThickness(), DRAWSEGMENT::GetParentModule(), DRAWSEGMENT::GetRadius(), DRAWSEGMENT::GetShape(), DRAWSEGMENT::GetStart(), DRAWSEGMENT::GetWidth(), KIGFX::PAINTER::m_gal, KIGFX::RENDER_SETTINGS::m_outlineWidth, 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().

897 {
898  const COLOR4D& color = m_pcbSettings.GetColor( aSegment, aSegment->GetLayer() );
899  bool sketch = ( aSegment->Type() == PCB_LINE_T && m_pcbSettings.m_sketchBoardGfx )
900  || ( aSegment->Type() == PCB_MODULE_EDGE_T && m_pcbSettings.m_sketchFpGfx );
901 
902  int thickness = getLineThickness( aSegment->GetWidth() );
903  VECTOR2D start( aSegment->GetStart() );
904  VECTOR2D end( aSegment->GetEnd() );
905 
906  m_gal->SetIsFill( !sketch );
907  m_gal->SetIsStroke( sketch );
908  m_gal->SetFillColor( color );
909  m_gal->SetStrokeColor( color );
911 
912  switch( aSegment->GetShape() )
913  {
914  case S_SEGMENT:
915  m_gal->DrawSegment( start, end, thickness );
916  break;
917 
918  case S_RECT:
919  wxASSERT_MSG( false, "Not tested yet" );
920  m_gal->DrawRectangle( start, end );
921  break;
922 
923  case S_ARC:
924  m_gal->DrawArcSegment( start, aSegment->GetRadius(),
925  DECIDEG2RAD( aSegment->GetArcAngleStart() ),
926  DECIDEG2RAD( aSegment->GetArcAngleStart() + aSegment->GetAngle() ),
927  thickness );
928  break;
929 
930  case S_CIRCLE:
931  if( sketch )
932  {
933  m_gal->DrawCircle( start, aSegment->GetRadius() - thickness / 2 );
934  m_gal->DrawCircle( start, aSegment->GetRadius() + thickness / 2 );
935  }
936  else
937  {
938  m_gal->SetLineWidth( thickness );
939  m_gal->SetIsFill( false );
940  m_gal->SetIsStroke( true );
941  m_gal->DrawCircle( start, aSegment->GetRadius() );
942  }
943  break;
944 
945  case S_POLYGON:
946  {
947  const auto& points = aSegment->BuildPolyPointsList();
948  std::deque<VECTOR2D> pointsList;
949 
950  if( points.empty() )
951  break;
952 
953  m_gal->Save();
954 
955  if( MODULE* module = aSegment->GetParentModule() )
956  {
957  m_gal->Translate( module->GetPosition() );
958  m_gal->Rotate( -module->GetOrientationRadians() );
959  }
960 
961  std::copy( points.begin(), points.end(), std::back_inserter( pointsList ) );
962  pointsList.push_back( points[0] );
963 
964  m_gal->SetLineWidth( thickness );
965  m_gal->SetIsFill( true );
966  m_gal->SetIsStroke( true );
967  m_gal->DrawPolygon( pointsList );
968 
969  m_gal->Restore();
970  break;
971  }
972 
973  case S_CURVE:
974  m_gal->SetIsFill( false );
975  m_gal->SetIsStroke( true );
976  m_gal->SetLineWidth( thickness );
977  m_gal->DrawCurve( VECTOR2D( aSegment->GetStart() ),
978  VECTOR2D( aSegment->GetBezControl1() ),
979  VECTOR2D( aSegment->GetBezControl2() ),
980  VECTOR2D( aSegment->GetEnd() ) );
981  break;
982 
983  case S_LAST:
984  break;
985  }
986 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
KICAD_T Type() const
Function Type()
Definition: base_struct.h:198
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:272
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:157
usual segment : line with rounded ends
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:216
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:345
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 SetLineWidth(double aLineWidth)
Set the line width.
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:160
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 989 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(), KIGFX::GAL::StrokeText(), wxPoint::x, and wxPoint::y.

990 {
991  wxString shownText( aText->GetShownText() );
992  if( shownText.Length() == 0 )
993  return;
994 
995  const COLOR4D& color = m_pcbSettings.GetColor( aText, aText->GetLayer() );
996  VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );
997 
998  if( m_pcbSettings.m_sketchMode[aLayer] )
999  {
1000  // Outline mode
1002  }
1003  else
1004  {
1005  // Filled mode
1007  }
1008 
1009  m_gal->SetStrokeColor( color );
1010  m_gal->SetIsFill( false );
1011  m_gal->SetIsStroke( true );
1012  m_gal->SetTextAttributes( aText );
1013  m_gal->StrokeText( shownText, position, aText->GetTextAngleRadians() );
1014 }
const wxPoint & GetTextPos() const
Definition: eda_text.h:237
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:272
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:154
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:216
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:345
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 SetLineWidth(double aLineWidth)
Set the line width.
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 1017 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(), KIGFX::GAL::StrokeText(), wxPoint::x, and wxPoint::y.

1018 {
1019  wxString shownText( aText->GetShownText() );
1020  if( shownText.Length() == 0 )
1021  return;
1022 
1023  bool sketch = m_pcbSettings.m_sketchFpTxtfx;
1024 
1025  const COLOR4D& color = m_pcbSettings.GetColor( aText, aLayer );
1026  VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );
1027 
1028  // Currently, draw text routines do not know the true outline mode.
1029  // so draw the text in "line" mode (no thickness)
1030  if( sketch )
1031  {
1032  // Outline mode
1034  }
1035  else
1036  {
1037  // Filled mode
1039  }
1040 
1041  m_gal->SetStrokeColor( color );
1042  m_gal->SetIsFill( false );
1043  m_gal->SetIsStroke( true );
1044  m_gal->SetTextAttributes( aText );
1045  m_gal->StrokeText( shownText, position, aText->GetDrawRotationRadians() );
1046 
1047  // Draw the umbilical line
1048  if( aText->IsSelected() )
1049  {
1051  m_gal->SetStrokeColor( COLOR4D( 0.0, 0.0, 1.0, 1.0 ) );
1052  m_gal->DrawLine( position, aText->GetParent()->GetPosition() );
1053  }
1054 }
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:272
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:221
bool m_sketchFpTxtfx
Flag determining if footprint text items should be outlined or stroked
Definition: pcb_painter.h:163
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:216
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:345
int GetThickness() const
Function GetThickness returns pen width.
Definition: eda_text.h:167
virtual void SetLineWidth(double aLineWidth)
Set the line width.
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 1057 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().

1058 {
1059  if( aLayer == LAYER_ANCHOR )
1060  {
1061  const COLOR4D color = m_pcbSettings.GetColor( aModule, LAYER_ANCHOR );
1062 
1063  // Draw anchor
1064  m_gal->SetStrokeColor( color );
1066 
1067  // Keep the size constant, not related to the scale
1068  double anchorSize = 5.0 / m_gal->GetWorldScale();
1069 
1070  VECTOR2D center = aModule->GetPosition();
1071  m_gal->DrawLine( center - VECTOR2D( anchorSize, 0 ), center + VECTOR2D( anchorSize, 0 ) );
1072  m_gal->DrawLine( center - VECTOR2D( 0, anchorSize ), center + VECTOR2D( 0, anchorSize ) );
1073  }
1074 }
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:272
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:216
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:345
virtual void SetLineWidth(double 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 
)
protected

Definition at line 1077 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, ZONE_CONTAINER::Outline(), SHAPE_POLY_SET::OutlineCount(), KIGFX::GAL::SetFillColor(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), and KIGFX::GAL::SetStrokeColor().

1078 {
1079  if( !aZone->IsOnLayer( (PCB_LAYER_ID) aLayer ) )
1080  return;
1081 
1082  const COLOR4D& color = m_pcbSettings.GetColor( aZone, aLayer );
1083  std::deque<VECTOR2D> corners;
1085 
1086  // Draw the outline
1087  const SHAPE_POLY_SET* outline = aZone->Outline();
1088 
1089  if( outline )
1090  {
1091  m_gal->SetStrokeColor( color );
1092  m_gal->SetIsFill( false );
1093  m_gal->SetIsStroke( true );
1095 
1096  // Draw each contour (main contour and holes)
1097 
1098  /* This line:
1099  * m_gal->DrawPolygon( *outline );
1100  * should be enough, but currently does not work to draw holes contours in a complex polygon
1101  * so each contour is draw as a simple polygon
1102  */
1103 
1104  // Draw the main contour
1105  m_gal->DrawPolyline( outline->COutline( 0 ) );
1106 
1107  // Draw holes
1108  int holes_count = outline->HoleCount( 0 );
1109 
1110  for( int ii = 0; ii < holes_count; ++ii )
1111  m_gal->DrawPolyline( outline->CHole( 0, ii ) );
1112 
1113  // Draw hatch lines
1114  for( const SEG& hatchLine : aZone->GetHatchLines() )
1115  m_gal->DrawLine( hatchLine.A, hatchLine.B );
1116  }
1117 
1118  // Draw the filling
1119  if( displayMode != PCB_RENDER_SETTINGS::DZ_HIDE_FILLED )
1120  {
1121  const SHAPE_POLY_SET& polySet = aZone->GetFilledPolysList();
1122 
1123  if( polySet.OutlineCount() == 0 ) // Nothing to draw
1124  return;
1125 
1126  // Set up drawing options
1127  m_gal->SetFillColor( color );
1128  m_gal->SetLineWidth( aZone->GetMinThickness() );
1129 
1130  if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_FILLED )
1131  {
1132  m_gal->SetIsFill( true );
1133  m_gal->SetIsStroke( true );
1134  }
1135  else if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_OUTLINED )
1136  {
1137  m_gal->SetIsFill( false );
1138  m_gal->SetIsStroke( true );
1139  }
1140 
1141  m_gal->DrawPolygon( polySet );
1142  }
1143 
1144 }
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:272
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:181
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:216
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:345
PCB_LAYER_ID
A quick note on layer IDs:
virtual void SetLineWidth(double aLineWidth)
Set the line width.
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.
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 1147 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(), DIMENSION::Text(), wxPoint::x, and wxPoint::y.

1148 {
1149  const COLOR4D& strokeColor = m_pcbSettings.GetColor( aDimension, aLayer );
1150 
1151  m_gal->SetStrokeColor( strokeColor );
1152  m_gal->SetIsFill( false );
1153  m_gal->SetIsStroke( true );
1154  m_gal->SetLineWidth( getLineThickness( aDimension->GetWidth() ) );
1155 
1156  // Draw an arrow
1157  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_crossBarF ) );
1158  m_gal->DrawLine( VECTOR2D( aDimension->m_featureLineGO ),
1159  VECTOR2D( aDimension->m_featureLineGF ) );
1160  m_gal->DrawLine( VECTOR2D( aDimension->m_featureLineDO ),
1161  VECTOR2D( aDimension->m_featureLineDF ) );
1162  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarF ), VECTOR2D( aDimension->m_arrowD1F ) );
1163  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarF ), VECTOR2D( aDimension->m_arrowD2F ) );
1164  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_arrowG1F ) );
1165  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_arrowG2F ) );
1166 
1167  // Draw text
1168  TEXTE_PCB& text = aDimension->Text();
1169  VECTOR2D position( text.GetTextPos().x, text.GetTextPos().y );
1170 
1171  m_gal->SetLineWidth( text.GetThickness() );
1172  m_gal->SetTextAttributes( &text );
1173  m_gal->StrokeText( text.GetShownText(), position, text.GetTextAngleRadians() );
1174 }
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:216
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:345
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
virtual void SetLineWidth(double aLineWidth)
Set the line width.
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 1177 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().

1178 {
1179  const COLOR4D& strokeColor = m_pcbSettings.GetColor( aTarget, aTarget->GetLayer() );
1180  VECTOR2D position( aTarget->GetPosition() );
1181  double size, radius;
1182 
1183  m_gal->SetLineWidth( getLineThickness( aTarget->GetWidth() ) );
1184  m_gal->SetStrokeColor( strokeColor );
1185  m_gal->SetIsFill( false );
1186  m_gal->SetIsStroke( true );
1187 
1188  m_gal->Save();
1189  m_gal->Translate( position );
1190 
1191  if( aTarget->GetShape() )
1192  {
1193  // shape x
1194  m_gal->Rotate( M_PI / 4.0 );
1195  size = 2.0 * aTarget->GetSize() / 3.0;
1196  radius = aTarget->GetSize() / 2.0;
1197  }
1198  else
1199  {
1200  // shape +
1201  size = aTarget->GetSize() / 2.0;
1202  radius = aTarget->GetSize() / 3.0;
1203  }
1204 
1205  m_gal->DrawLine( VECTOR2D( -size, 0.0 ), VECTOR2D( size, 0.0 ) );
1206  m_gal->DrawLine( VECTOR2D( 0.0, -size ), VECTOR2D( 0.0, size ) );
1207  m_gal->DrawCircle( VECTOR2D( 0.0, 0.0 ), radius );
1208 
1209  m_gal->Restore();
1210 }
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:216
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:345
virtual void Rotate(double aAngle)
Rotate the context.
int GetShape() const
virtual void SetLineWidth(double aLineWidth)
Set the line width.
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 1213 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().

1214 {
1215  const int scale = MARKER_PCB::MarkerScale();
1216 
1217  // If you are changing this, update MARKER_PCB::ViewBBox()
1218  const VECTOR2D arrow[] = {
1219  VECTOR2D( 0 * scale, 0 * scale ),
1220  VECTOR2D( 8 * scale, 1 * scale ),
1221  VECTOR2D( 4 * scale, 3 * scale ),
1222  VECTOR2D( 13 * scale, 8 * scale ),
1223  VECTOR2D( 9 * scale, 9 * scale ),
1224  VECTOR2D( 8 * scale, 13 * scale ),
1225  VECTOR2D( 3 * scale, 4 * scale ),
1226  VECTOR2D( 1 * scale, 8 * scale ),
1227  VECTOR2D( 0 * scale, 0 * scale )
1228  };
1229 
1230  auto strokeColor = m_pcbSettings.GetColor( aMarker, LAYER_DRC );
1231 
1232  m_gal->Save();
1233  m_gal->Translate( aMarker->GetPosition() );
1234  m_gal->SetFillColor( strokeColor );
1235  m_gal->SetIsFill( true );
1236  m_gal->SetIsStroke( false );
1237  m_gal->DrawPolygon( arrow, sizeof( arrow ) / sizeof( VECTOR2D ) );
1238  m_gal->Restore();
1239 }
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:216
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:345
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::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 269 of file pcb_painter.cpp.

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

Referenced by draw().

270 {
271  // if items have 0 thickness, draw them with the outline
272  // width, otherwise respect the set value (which, no matter
273  // how small will produce something)
274  if( aActualThickness == 0 )
276 
277  return aActualThickness;
278 }
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:272
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:216
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 207 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().

208  {
209  return &m_pcbSettings;
210  }
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:216
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 313 of file painter.h.

314  {
315  m_gal = aGal;
316  }
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:345

Member Data Documentation

COLOR4D KIGFX::PAINTER::m_brightenedColor
protectedinherited

Color of brightened item frame.

Definition at line 348 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 345 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

Definition at line 216 of file pcb_painter.h.

Referenced by draw(), and getLineThickness().


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