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

Constructor & Destructor Documentation

PCB_PAINTER::PCB_PAINTER ( GAL aGal)

Definition at line 260 of file pcb_painter.cpp.

260  :
261  PAINTER( aGal )
262 {
263 }
PAINTER(GAL *aGal)
Constructor PAINTER( GAL* ) initializes this object for painting on any of the polymorphic GRAPHICS_A...
Definition: painter.cpp:67

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

193  {
194  m_pcbSettings = *static_cast<const PCB_RENDER_SETTINGS*>( aSettings );
195  }
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:207
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 278 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_TARGET_T, PCB_TEXT_T, PCB_TRACE_T, PCB_VIA_T, PCB_ZONE_AREA_T, PCB_ZONE_T, and EDA_ITEM::Type().

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

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

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

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

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

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

984 {
985  wxString shownText( aText->GetShownText() );
986  if( shownText.Length() == 0 )
987  return;
988 
989  const COLOR4D& color = m_pcbSettings.GetColor( aText, aText->GetLayer() );
990  VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );
991 
992  if( m_pcbSettings.m_sketchMode[aLayer] )
993  {
994  // Outline mode
996  }
997  else
998  {
999  // Filled mode
1001  }
1002 
1003  m_gal->SetStrokeColor( color );
1004  m_gal->SetIsFill( false );
1005  m_gal->SetIsStroke( true );
1006  m_gal->SetTextAttributes( aText );
1007  m_gal->StrokeText( shownText, position, aText->GetTextAngleRadians() );
1008 }
const wxPoint & GetTextPos() const
Definition: eda_text.h:222
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:259
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:148
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:207
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:330
int GetThickness() const
Function GetThickness returns pen width.
Definition: eda_text.h:152
virtual wxString GetShownText() const
Returns the string actually shown after processing of the base text.
Definition: eda_text.h:133
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:165
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 1011 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(), TEXTE_MODULE::GetType(), EDA_ITEM::IsSelected(), 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(), TEXTE_MODULE::TEXT_is_DIVERS, wxPoint::x, and wxPoint::y.

1012 {
1013  wxString shownText( aText->GetShownText() );
1014  if( shownText.Length() == 0 )
1015  return;
1016 
1017  const COLOR4D& color = m_pcbSettings.GetColor( aText, aLayer );
1018  VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );
1019 
1020  if( m_pcbSettings.m_sketchMode[aLayer] )
1021  {
1022  // Outline mode
1024  }
1025  else
1026  {
1027  // Filled mode
1029  }
1030 
1031  m_gal->SetStrokeColor( color );
1032  m_gal->SetIsFill( false );
1033  m_gal->SetIsStroke( true );
1034  m_gal->SetTextAttributes( aText );
1035  m_gal->StrokeText( shownText, position, aText->GetDrawRotationRadians() );
1036 
1037  // Draw the umbilical line
1038  if( aText->IsSelected() && aText->GetType() != TEXTE_MODULE::TEXT_is_DIVERS )
1039  {
1041  m_gal->SetStrokeColor( COLOR4D( 0.0, 0.0, 1.0, 1.0 ) );
1042  m_gal->DrawLine( position, aText->GetParent()->GetPosition() );
1043  }
1044 }
BOARD_ITEM_CONTAINER * GetParent() const
const wxPoint & GetTextPos() const
Definition: eda_text.h:222
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:259
TEXT_TYPE GetType() const
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:148
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:232
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:207
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:330
int GetThickness() const
Function GetThickness returns pen width.
Definition: eda_text.h:152
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 1047 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().

1048 {
1049  if( aLayer == LAYER_ANCHOR )
1050  {
1051  const COLOR4D color = m_pcbSettings.GetColor( aModule, LAYER_ANCHOR );
1052 
1053  // Draw anchor
1054  m_gal->SetStrokeColor( color );
1056 
1057  // Keep the size constant, not related to the scale
1058  double anchorSize = 5.0 / m_gal->GetWorldScale();
1059 
1060  VECTOR2D center = aModule->GetPosition();
1061  m_gal->DrawLine( center - VECTOR2D( anchorSize, 0 ), center + VECTOR2D( anchorSize, 0 ) );
1062  m_gal->DrawLine( center - VECTOR2D( 0, anchorSize ), center + VECTOR2D( 0, anchorSize ) );
1063  }
1064 }
float m_outlineWidth
Line width used when drawing outlines.
Definition: painter.h:259
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:207
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:330
virtual void SetLineWidth(double aLineWidth)
Set the line width.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:588
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
const wxPoint GetPosition() const override
Definition: class_module.h:182
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 1067 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().

1068 {
1069  if( !aZone->IsOnLayer( (PCB_LAYER_ID) aLayer ) )
1070  return;
1071 
1072  const COLOR4D& color = m_pcbSettings.GetColor( aZone, aLayer );
1073  std::deque<VECTOR2D> corners;
1075 
1076  // Draw the outline
1077  const SHAPE_POLY_SET* outline = aZone->Outline();
1078 
1079  if( outline )
1080  {
1081  m_gal->SetStrokeColor( color );
1082  m_gal->SetIsFill( false );
1083  m_gal->SetIsStroke( true );
1085 
1086  // Draw each contour (main contour and holes)
1087 
1088  /* This line:
1089  * m_gal->DrawPolygon( *outline );
1090  * should be enough, but currently does not work to draw holes contours in a complex polygon
1091  * so each contour is draw as a simple polygon
1092  */
1093 
1094  // Draw the main contour
1095  m_gal->DrawPolyline( outline->COutline( 0 ) );
1096 
1097  // Draw holes
1098  int holes_count = outline->HoleCount( 0 );
1099 
1100  for( int ii = 0; ii < holes_count; ++ii )
1101  m_gal->DrawPolyline( outline->CHole( 0, ii ) );
1102 
1103  // Draw hatch lines
1104  for( const SEG& hatchLine : aZone->GetHatchLines() )
1105  m_gal->DrawLine( hatchLine.A, hatchLine.B );
1106  }
1107 
1108  // Draw the filling
1109  if( displayMode != PCB_RENDER_SETTINGS::DZ_HIDE_FILLED )
1110  {
1111  const SHAPE_POLY_SET& polySet = aZone->GetFilledPolysList();
1112 
1113  if( polySet.OutlineCount() == 0 ) // Nothing to draw
1114  return;
1115 
1116  // Set up drawing options
1117  m_gal->SetFillColor( color );
1118  m_gal->SetLineWidth( aZone->GetMinThickness() );
1119 
1120  if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_FILLED )
1121  {
1122  m_gal->SetIsFill( true );
1123  m_gal->SetIsStroke( true );
1124  }
1125  else if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_OUTLINED )
1126  {
1127  m_gal->SetIsFill( false );
1128  m_gal->SetIsStroke( true );
1129  }
1130 
1131  m_gal->DrawPolygon( polySet );
1132  }
1133 
1134 }
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:259
int GetMinThickness() const
Definition: class_zone.h:198
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:236
DISPLAY_ZONE_MODE m_displayZone
Option for different display modes for zones
Definition: pcb_painter.h:172
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:207
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:659
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:330
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:534
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 1137 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.

1138 {
1139  const COLOR4D& strokeColor = m_pcbSettings.GetColor( aDimension, aLayer );
1140 
1141  m_gal->SetStrokeColor( strokeColor );
1142  m_gal->SetIsFill( false );
1143  m_gal->SetIsStroke( true );
1144  m_gal->SetLineWidth( getLineThickness( aDimension->GetWidth() ) );
1145 
1146  // Draw an arrow
1147  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_crossBarF ) );
1148  m_gal->DrawLine( VECTOR2D( aDimension->m_featureLineGO ),
1149  VECTOR2D( aDimension->m_featureLineGF ) );
1150  m_gal->DrawLine( VECTOR2D( aDimension->m_featureLineDO ),
1151  VECTOR2D( aDimension->m_featureLineDF ) );
1152  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarF ), VECTOR2D( aDimension->m_arrowD1F ) );
1153  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarF ), VECTOR2D( aDimension->m_arrowD2F ) );
1154  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_arrowG1F ) );
1155  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_arrowG2F ) );
1156 
1157  // Draw text
1158  TEXTE_PCB& text = aDimension->Text();
1159  VECTOR2D position( text.GetTextPos().x, text.GetTextPos().y );
1160 
1161  m_gal->SetLineWidth( text.GetThickness() );
1162  m_gal->SetTextAttributes( &text );
1163  m_gal->StrokeText( text.GetShownText(), position, text.GetTextAngleRadians() );
1164 }
const wxPoint & GetTextPos() const
Definition: eda_text.h:222
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:207
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:330
int GetThickness() const
Function GetThickness returns pen width.
Definition: eda_text.h:152
wxPoint m_featureLineGO
virtual wxString GetShownText() const
Returns the string actually shown after processing of the base text.
Definition: eda_text.h:133
virtual void SetLineWidth(double aLineWidth)
Set the line width.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:588
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:165
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 1167 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().

1168 {
1169  const COLOR4D& strokeColor = m_pcbSettings.GetColor( aTarget, aTarget->GetLayer() );
1170  VECTOR2D position( aTarget->GetPosition() );
1171  double size, radius;
1172 
1173  m_gal->SetLineWidth( getLineThickness( aTarget->GetWidth() ) );
1174  m_gal->SetStrokeColor( strokeColor );
1175  m_gal->SetIsFill( false );
1176  m_gal->SetIsStroke( true );
1177 
1178  m_gal->Save();
1179  m_gal->Translate( position );
1180 
1181  if( aTarget->GetShape() )
1182  {
1183  // shape x
1184  m_gal->Rotate( M_PI / 4.0 );
1185  size = 2.0 * aTarget->GetSize() / 3.0;
1186  radius = aTarget->GetSize() / 2.0;
1187  }
1188  else
1189  {
1190  // shape +
1191  size = aTarget->GetSize() / 2.0;
1192  radius = aTarget->GetSize() / 3.0;
1193  }
1194 
1195  m_gal->DrawLine( VECTOR2D( -size, 0.0 ), VECTOR2D( size, 0.0 ) );
1196  m_gal->DrawLine( VECTOR2D( 0.0, -size ), VECTOR2D( 0.0, size ) );
1197  m_gal->DrawCircle( VECTOR2D( 0.0, 0.0 ), radius );
1198 
1199  m_gal->Restore();
1200 }
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:207
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:330
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:588
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 1203 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, 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().

1204 {
1205  // If you are changing this, update MARKER_PCB::ViewBBox()
1206  const int scale = 100000;
1207 
1208  const VECTOR2D arrow[] = {
1209  VECTOR2D( 0 * scale, 0 * scale ),
1210  VECTOR2D( 8 * scale, 1 * scale ),
1211  VECTOR2D( 4 * scale, 3 * scale ),
1212  VECTOR2D( 13 * scale, 8 * scale ),
1213  VECTOR2D( 9 * scale, 9 * scale ),
1214  VECTOR2D( 8 * scale, 13 * scale ),
1215  VECTOR2D( 3 * scale, 4 * scale ),
1216  VECTOR2D( 1 * scale, 8 * scale ),
1217  VECTOR2D( 0 * scale, 0 * scale )
1218  };
1219 
1220  auto strokeColor = m_pcbSettings.GetColor( aMarker, LAYER_DRC );
1221 
1222  m_gal->Save();
1223  m_gal->Translate( aMarker->GetPosition() );
1224  m_gal->SetFillColor( strokeColor );
1225  m_gal->SetIsFill( true );
1226  m_gal->SetIsStroke( false );
1227  m_gal->DrawPolygon( arrow, sizeof( arrow ) / sizeof( VECTOR2D ) );
1228  m_gal->Restore();
1229 }
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:207
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg...
Definition: painter.h:330
VECTOR2< double > VECTOR2D
Definition: vector2d.h:588
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
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 266 of file pcb_painter.cpp.

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

Referenced by draw().

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

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

199  {
200  return &m_pcbSettings;
201  }
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:207
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 298 of file painter.h.

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

Member Data Documentation

COLOR4D KIGFX::PAINTER::m_brightenedColor
protectedinherited

Color of brightened item frame.

Definition at line 333 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 330 of file painter.h.

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

PCB_RENDER_SETTINGS KIGFX::PCB_PAINTER::m_pcbSettings
protected

Definition at line 207 of file pcb_painter.h.

Referenced by draw(), and getLineThickness().


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