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

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

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

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

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

981 {
982  wxString shownText( aText->GetShownText() );
983  if( shownText.Length() == 0 )
984  return;
985 
986  const COLOR4D& color = m_pcbSettings.GetColor( aText, aText->GetLayer() );
987  VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );
988 
989  if( m_pcbSettings.m_sketchMode[aLayer] )
990  {
991  // Outline mode
993  }
994  else
995  {
996  // Filled mode
998  }
999 
1000  m_gal->SetStrokeColor( color );
1001  m_gal->SetIsFill( false );
1002  m_gal->SetIsStroke( true );
1003  m_gal->SetTextAttributes( aText );
1004  m_gal->StrokeText( shownText, position, aText->GetTextAngleRadians() );
1005 }
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 1008 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.

1009 {
1010  wxString shownText( aText->GetShownText() );
1011  if( shownText.Length() == 0 )
1012  return;
1013 
1014  const COLOR4D& color = m_pcbSettings.GetColor( aText, aLayer );
1015  VECTOR2D position( aText->GetTextPos().x, aText->GetTextPos().y );
1016 
1017  if( m_pcbSettings.m_sketchMode[aLayer] )
1018  {
1019  // Outline mode
1021  }
1022  else
1023  {
1024  // Filled mode
1026  }
1027 
1028  m_gal->SetStrokeColor( color );
1029  m_gal->SetIsFill( false );
1030  m_gal->SetIsStroke( true );
1031  m_gal->SetTextAttributes( aText );
1032  m_gal->StrokeText( shownText, position, aText->GetDrawRotationRadians() );
1033 
1034  // Draw the umbilical line
1035  if( aText->IsSelected() && aText->GetType() != TEXTE_MODULE::TEXT_is_DIVERS )
1036  {
1038  m_gal->SetStrokeColor( COLOR4D( 0.0, 0.0, 1.0, 1.0 ) );
1039  m_gal->DrawLine( position, aText->GetParent()->GetPosition() );
1040  }
1041 }
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:250
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 1044 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().

1045 {
1046  if( aLayer == LAYER_ANCHOR )
1047  {
1048  const COLOR4D color = m_pcbSettings.GetColor( aModule, LAYER_ANCHOR );
1049 
1050  // Draw anchor
1051  m_gal->SetStrokeColor( color );
1053 
1054  // Keep the size constant, not related to the scale
1055  double anchorSize = 5.0 / m_gal->GetWorldScale();
1056 
1057  VECTOR2D center = aModule->GetPosition();
1058  m_gal->DrawLine( center - VECTOR2D( anchorSize, 0 ), center + VECTOR2D( anchorSize, 0 ) );
1059  m_gal->DrawLine( center - VECTOR2D( 0, anchorSize ), center + VECTOR2D( 0, anchorSize ) );
1060  }
1061 }
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:175
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 1064 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().

1065 {
1066  if( !aZone->IsOnLayer( (PCB_LAYER_ID) aLayer ) )
1067  return;
1068 
1069  const COLOR4D& color = m_pcbSettings.GetColor( aZone, aLayer );
1070  std::deque<VECTOR2D> corners;
1072 
1073  // Draw the outline
1074  const SHAPE_POLY_SET* outline = aZone->Outline();
1075 
1076  if( outline )
1077  {
1078  m_gal->SetStrokeColor( color );
1079  m_gal->SetIsFill( false );
1080  m_gal->SetIsStroke( true );
1082 
1083  // Draw each contour (main contour and holes)
1084 
1085  /* This line:
1086  * m_gal->DrawPolygon( *outline );
1087  * should be enough, but currently does not work to draw holes contours in a complex polygon
1088  * so each contour is draw as a simple polygon
1089  */
1090 
1091  // Draw the main contour
1092  m_gal->DrawPolyline( outline->COutline( 0 ) );
1093 
1094  // Draw holes
1095  int holes_count = outline->HoleCount( 0 );
1096 
1097  for( int ii = 0; ii < holes_count; ++ii )
1098  m_gal->DrawPolyline( outline->CHole( 0, ii ) );
1099 
1100  // Draw hatch lines
1101  for( const SEG& hatchLine : aZone->GetHatchLines() )
1102  m_gal->DrawLine( hatchLine.A, hatchLine.B );
1103  }
1104 
1105  // Draw the filling
1106  if( displayMode != PCB_RENDER_SETTINGS::DZ_HIDE_FILLED )
1107  {
1108  const SHAPE_POLY_SET& polySet = aZone->GetFilledPolysList();
1109 
1110  if( polySet.OutlineCount() == 0 ) // Nothing to draw
1111  return;
1112 
1113  // Set up drawing options
1114  m_gal->SetFillColor( color );
1115  m_gal->SetLineWidth( aZone->GetMinThickness() );
1116 
1117  if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_FILLED )
1118  {
1119  m_gal->SetIsFill( true );
1120  m_gal->SetIsStroke( true );
1121  }
1122  else if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_OUTLINED )
1123  {
1124  m_gal->SetIsFill( false );
1125  m_gal->SetIsStroke( true );
1126  }
1127 
1128  m_gal->DrawPolygon( polySet );
1129  }
1130 
1131 }
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:261
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 1134 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.

1135 {
1136  const COLOR4D& strokeColor = m_pcbSettings.GetColor( aDimension, aLayer );
1137 
1138  m_gal->SetStrokeColor( strokeColor );
1139  m_gal->SetIsFill( false );
1140  m_gal->SetIsStroke( true );
1141  m_gal->SetLineWidth( getLineThickness( aDimension->GetWidth() ) );
1142 
1143  // Draw an arrow
1144  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_crossBarF ) );
1145  m_gal->DrawLine( VECTOR2D( aDimension->m_featureLineGO ),
1146  VECTOR2D( aDimension->m_featureLineGF ) );
1147  m_gal->DrawLine( VECTOR2D( aDimension->m_featureLineDO ),
1148  VECTOR2D( aDimension->m_featureLineDF ) );
1149  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarF ), VECTOR2D( aDimension->m_arrowD1F ) );
1150  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarF ), VECTOR2D( aDimension->m_arrowD2F ) );
1151  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_arrowG1F ) );
1152  m_gal->DrawLine( VECTOR2D( aDimension->m_crossBarO ), VECTOR2D( aDimension->m_arrowG2F ) );
1153 
1154  // Draw text
1155  TEXTE_PCB& text = aDimension->Text();
1156  VECTOR2D position( text.GetTextPos().x, text.GetTextPos().y );
1157 
1158  m_gal->SetLineWidth( text.GetThickness() );
1159  m_gal->SetTextAttributes( &text );
1160  m_gal->StrokeText( text.GetShownText(), position, text.GetTextAngleRadians() );
1161 }
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 1164 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().

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

1201 {
1202  // If you are changing this, update MARKER_PCB::ViewBBox()
1203  const int scale = 100000;
1204 
1205  const VECTOR2D arrow[] = {
1206  VECTOR2D( 0 * scale, 0 * scale ),
1207  VECTOR2D( 8 * scale, 1 * scale ),
1208  VECTOR2D( 4 * scale, 3 * scale ),
1209  VECTOR2D( 13 * scale, 8 * scale ),
1210  VECTOR2D( 9 * scale, 9 * scale ),
1211  VECTOR2D( 8 * scale, 13 * scale ),
1212  VECTOR2D( 3 * scale, 4 * scale ),
1213  VECTOR2D( 1 * scale, 8 * scale ),
1214  VECTOR2D( 0 * scale, 0 * scale )
1215  };
1216 
1217  auto strokeColor = m_pcbSettings.GetColor( aMarker, LAYER_DRC );
1218 
1219  m_gal->Save();
1220  m_gal->Translate( aMarker->GetPosition() );
1221  m_gal->SetFillColor( strokeColor );
1222  m_gal->SetIsFill( true );
1223  m_gal->SetIsStroke( false );
1224  m_gal->DrawPolygon( arrow, sizeof( arrow ) / sizeof( VECTOR2D ) );
1225  m_gal->Restore();
1226 }
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(), 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: