KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pcb_painter.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2013-2019 CERN
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * @author Tomasz Wlostowski <[email protected]>
8 * @author Maciej Suminski <[email protected]>
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version 2
13 * of the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, you may find one here:
22 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
23 * or you may search the http://www.gnu.org website for the version 2 license,
24 * or you may write to the Free Software Foundation, Inc.,
25 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
26 */
27
28#include <advanced_config.h>
29#include <board.h>
31#include <pcb_track.h>
32#include <pcb_group.h>
33#include <footprint.h>
34#include <pad.h>
35#include <pcb_shape.h>
36#include <string_utils.h>
37#include <zone.h>
38#include <pcb_reference_image.h>
39#include <pcb_text.h>
40#include <pcb_textbox.h>
41#include <pcb_table.h>
42#include <pcb_tablecell.h>
43#include <pcb_marker.h>
44#include <pcb_dimension.h>
45#include <pcb_target.h>
46
47#include <layer_ids.h>
48#include <lset.h>
49#include <pcb_painter.h>
50#include <pcb_display_options.h>
56#include <pcbnew_settings.h>
58
61#include <callback_gal.h>
64#include <geometry/shape_rect.h>
68#include <bezier_curves.h>
69#include <kiface_base.h>
70#include <gr_text.h>
71#include <pgm_base.h>
72
73using namespace KIGFX;
74
75
77{
78 return dynamic_cast<PCBNEW_SETTINGS*>( Kiface().KifaceSettings() );
79}
80
81// Helpers for display options existing in Cvpcb and Pcbnew
82// Note, when running Cvpcb, pcbconfig() returns nullptr and viewer_settings()
83// returns the viewer options existing to Cvpcb and Pcbnew
85{
86 switch( m_frameType )
87 {
90 default:
92
96
100 case FRAME_CVPCB:
103 }
104}
105
106
108{
109 m_backgroundColor = COLOR4D( 0.0, 0.0, 0.0, 1.0 );
110 m_ZoneDisplayMode = ZONE_DISPLAY_MODE::SHOW_FILLED;
111 m_netColorMode = NET_COLOR_MODE::RATSNEST;
112 m_ContrastModeDisplay = HIGH_CONTRAST_MODE::NORMAL;
113
114 m_trackOpacity = 1.0;
115 m_viaOpacity = 1.0;
116 m_padOpacity = 1.0;
117 m_zoneOpacity = 1.0;
118 m_imageOpacity = 1.0;
120
122
123 m_PadEditModePad = nullptr;
124
125 SetDashLengthRatio( 12 ); // From ISO 128-2
126 SetGapLengthRatio( 3 ); // From ISO 128-2
127
129
130 update();
131}
132
133
135{
137
138 // Init board layers colors:
139 for( int i = 0; i < PCB_LAYER_ID_COUNT; i++ )
140 {
141 m_layerColors[i] = aSettings->GetColor( i );
142
143 // Guard: if the alpha channel is too small, the layer is not visible.
144 if( m_layerColors[i].a < 0.2 )
145 m_layerColors[i].a = 0.2;
146 }
147
148 // Init specific graphic layers colors:
149 for( int i = GAL_LAYER_ID_START; i < GAL_LAYER_ID_END; i++ )
150 m_layerColors[i] = aSettings->GetColor( i );
151
152 // Colors for layers that aren't theme-able
155
156 // Netnames for copper layers
157 const COLOR4D lightLabel = aSettings->GetColor( NETNAMES_LAYER_ID_START );
158 const COLOR4D darkLabel = lightLabel.Inverted();
159
160 for( PCB_LAYER_ID layer : LSET::AllCuMask().CuStack() )
161 {
162 if( m_layerColors[layer].GetBrightness() > 0.5 )
163 m_layerColors[GetNetnameLayer( layer )] = darkLabel;
164 else
165 m_layerColors[GetNetnameLayer( layer )] = lightLabel;
166 }
167
168 if( PgmOrNull() ) // can be null if used without project (i.e. from python script)
170 else
171 m_hiContrastFactor = 1.0f - 0.8f; // default value
172
173 update();
174}
175
176
178{
179 m_hiContrastEnabled = aOptions.m_ContrastModeDisplay != HIGH_CONTRAST_MODE::NORMAL;
183
185 m_viaOpacity = aOptions.m_ViaOpacity;
186 m_padOpacity = aOptions.m_PadOpacity;
187 m_zoneOpacity = aOptions.m_ZoneOpacity;
190}
191
192
193COLOR4D PCB_RENDER_SETTINGS::GetColor( const VIEW_ITEM* aItem, int aLayer ) const
194{
195 return GetColor( dynamic_cast<const BOARD_ITEM*>( aItem ), aLayer );
196}
197
198
199COLOR4D PCB_RENDER_SETTINGS::GetColor( const BOARD_ITEM* aItem, int aLayer ) const
200{
201 int netCode = -1;
202 int originalLayer = aLayer;
203
204 if( aLayer == LAYER_MARKER_SHADOWS )
205 return m_backgroundColor.WithAlpha( 0.6 );
206
207 if( aLayer == LAYER_LOCKED_ITEM_SHADOW )
208 return m_layerColors.at( aLayer );
209
210 // SMD pads use the copper netname layer
211 if( aLayer == LAYER_PAD_FR_NETNAMES )
212 aLayer = GetNetnameLayer( F_Cu );
213 else if( aLayer == LAYER_PAD_BK_NETNAMES )
214 aLayer = GetNetnameLayer( B_Cu );
215
216 if( IsHoleLayer( aLayer ) && m_isPrinting )
217 {
218 // Careful that we don't end up with the same colour for the annular ring and the hole
219 // when printing in B&W.
220 const PAD* pad = dynamic_cast<const PAD*>( aItem );
221 const PCB_VIA* via = dynamic_cast<const PCB_VIA*>( aItem );
222 int holeLayer = aLayer;
223 int annularRingLayer = UNDEFINED_LAYER;
224
225 // TODO(JE) padstacks -- this won't work, we don't know what the annular ring layer is
226 // Inserting F_Cu here for now.
227 if( pad && pad->GetAttribute() == PAD_ATTRIB::PTH )
228 annularRingLayer = F_Cu;
229 else if( via )
230 annularRingLayer = F_Cu;
231
232 if( annularRingLayer != UNDEFINED_LAYER )
233 {
234 auto it = m_layerColors.find( holeLayer );
235 auto it2 = m_layerColors.find( annularRingLayer );
236
237 if( it != m_layerColors.end() && it2 != m_layerColors.end() && it->second == it2->second )
238 aLayer = LAYER_PCB_BACKGROUND;
239 }
240 }
241
242 // Zones should pull from the copper layer
243 if( aItem && aItem->Type() == PCB_ZONE_T )
244 {
245 if( IsZoneFillLayer( aLayer ) )
246 aLayer = aLayer - LAYER_ZONE_START;
247 }
248
249 // Pad and via copper and clearance outlines take their color from the copper layer
250 if( IsPadCopperLayer( aLayer ) )
251 aLayer = aLayer - LAYER_PAD_COPPER_START;
252 else if( IsViaCopperLayer( aLayer ) )
253 aLayer = aLayer - LAYER_VIA_COPPER_START;
254 else if( IsClearanceLayer( aLayer ) )
255 aLayer = aLayer - LAYER_CLEARANCE_START;
256
257 // Use via "golden copper" hole color for pad hole walls for contrast
258 else if( aLayer == LAYER_PAD_HOLEWALLS )
259 aLayer = LAYER_VIA_HOLES;
260
261 // Show via mask layers if appropriate
262 if( aLayer == LAYER_VIA_THROUGH && !m_isPrinting )
263 {
264 if( aItem && aItem->GetBoard() )
265 {
266 LSET visibleLayers = aItem->GetBoard()->GetVisibleLayers()
267 & aItem->GetBoard()->GetEnabledLayers()
268 & aItem->GetLayerSet();
269
270 if( GetActiveLayer() == F_Mask && visibleLayers.test( F_Mask ) )
271 aLayer = F_Mask;
272 else if( GetActiveLayer() == B_Mask && visibleLayers.test( B_Mask ) )
273 aLayer = B_Mask;
274 else if( ( visibleLayers & LSET::AllCuMask() ).none() )
275 {
276 if( visibleLayers.any() )
277 aLayer = visibleLayers.Seq().back();
278 }
279 }
280 }
281
282 // Normal path: get the layer base color
283 auto it = m_layerColors.find( aLayer );
284 COLOR4D color = it == m_layerColors.end() ? COLOR4D::WHITE : it->second;
285
286 if( !aItem )
287 return color;
288
289 // Selection disambiguation
290 if( aItem->IsBrightened() )
291 return color.Brightened( m_selectFactor ).WithAlpha( 0.8 );
292
293 // Normal selection
294 if( aItem->IsSelected() )
295 {
296 // Selection for tables is done with a background wash, so pass in nullptr to GetColor()
297 // so we just get the "normal" (un-selected/un-brightened) color for the borders.
298 if( aItem->Type() != PCB_TABLE_T && aItem->Type() != PCB_TABLECELL_T )
299 {
300 auto it_selected = m_layerColorsSel.find( aLayer );
301 color = it_selected == m_layerColorsSel.end() ? color.Brightened( 0.8 ) : it_selected->second;
302 }
303 }
304
305 // Some graphic objects are BOARD_CONNECTED_ITEM, but they are seen here as
306 // actually board connected objects only if on a copper layer
307 const BOARD_CONNECTED_ITEM* conItem = nullptr;
308
309 if( aItem->IsConnected() && aItem->IsOnCopperLayer() )
310 conItem = static_cast<const BOARD_CONNECTED_ITEM*>( aItem );
311
312 // Try to obtain the netcode for the aItem
313 if( conItem )
314 netCode = conItem->GetNetCode();
315
316 bool highlighted = m_highlightEnabled && m_highlightNetcodes.count( netCode );
317 bool selected = aItem->IsSelected();
318
319 // Apply net color overrides
320 if( conItem && m_netColorMode == NET_COLOR_MODE::ALL && IsCopperLayer( aLayer ) )
321 {
322 COLOR4D netColor = COLOR4D::UNSPECIFIED;
323
324 auto ii = m_netColors.find( netCode );
325
326 if( ii != m_netColors.end() )
327 netColor = ii->second;
328
329 if( netColor == COLOR4D::UNSPECIFIED )
330 {
331 const NETCLASS* nc = conItem->GetEffectiveNetClass();
332
333 if( nc->HasPcbColor() )
334 netColor = nc->GetPcbColor();
335 }
336
337 if( netColor == COLOR4D::UNSPECIFIED )
338 netColor = color;
339
340 if( selected )
341 {
342 // Selection brightening overrides highlighting
343 netColor.Brighten( m_selectFactor );
344 }
345 else if( m_highlightEnabled )
346 {
347 // Highlight brightens objects on all layers and darkens everything else for contrast
348 if( highlighted )
349 netColor.Brighten( m_highlightFactor );
350 else
351 netColor.Darken( 1.0 - m_highlightFactor );
352 }
353
354 color = netColor;
355 }
356 else if( !selected && m_highlightEnabled )
357 {
358 // Single net highlight mode
359 if( m_highlightNetcodes.contains( netCode ) )
360 {
361 auto it_hi = m_layerColorsHi.find( aLayer );
362 color = it_hi == m_layerColorsHi.end() ? color.Brightened( m_highlightFactor ) : it_hi->second;
363 }
364 else
365 {
366 auto it_dark = m_layerColorsDark.find( aLayer );
367 color = it_dark == m_layerColorsDark.end() ? color.Darkened( 1.0 - m_highlightFactor ) : it_dark->second;
368 }
369 }
370
371 // Apply high-contrast dimming
372 if( m_hiContrastEnabled && m_highContrastLayers.size() && !highlighted && !selected )
373 {
375 bool isActive = m_highContrastLayers.count( aLayer );
376 bool hide = false;
377
378 switch( originalLayer )
379 {
380 // TODO(JE) not sure if this is needed
381 case LAYER_PADS:
382 {
383 const PAD* pad = static_cast<const PAD*>( aItem );
384
385 if( pad->IsOnLayer( primary ) && !pad->FlashLayer( primary ) )
386 {
387 isActive = false;
388
389 if( IsCopperLayer( primary ) )
390 hide = true;
391 }
392
394 isActive = false;
395
396 break;
397 }
398
399 case LAYER_VIA_BBLIND:
401 {
402 const PCB_VIA* via = static_cast<const PCB_VIA*>( aItem );
403
404 // Target graphic is active if the via crosses the primary layer
405 if( via->GetLayerSet().test( primary ) == 0 )
406 {
407 isActive = false;
408 hide = true;
409 }
410
411 break;
412 }
413
415 {
416 const PCB_VIA* via = static_cast<const PCB_VIA*>( aItem );
417
418 if( !via->FlashLayer( primary ) )
419 {
420 isActive = false;
421
422 if( IsCopperLayer( primary ) )
423 hide = true;
424 }
425
426 break;
427 }
428
432 // Pad holes are active is any physical layer is active
433 if( LSET::PhysicalLayersMask().test( primary ) == 0 )
434 isActive = false;
435
436 break;
437
438 case LAYER_VIA_HOLES:
440 {
441 const PCB_VIA* via = static_cast<const PCB_VIA*>( aItem );
442
443 if( via->GetViaType() == VIATYPE::THROUGH )
444 {
445 // A through via's hole is active if any physical layer is active
446 if( LSET::PhysicalLayersMask().test( primary ) == 0 )
447 isActive = false;
448 }
449 else
450 {
451 // A blind/buried or micro via's hole is active if it crosses the primary layer
452 if( via->GetLayerSet().test( primary ) == 0 )
453 isActive = false;
454 }
455
456 break;
457 }
458
459 case LAYER_DRC_ERROR:
462 isActive = true;
463 break;
464
465 default:
466 break;
467 }
468
469 if( !isActive )
470 {
471 // Graphics on Edge_Cuts layer are not fully dimmed or hidden because they are
472 // useful when working on another layer
473 // We could use a dim factor = m_hiContrastFactor, but to have a sufficient
474 // contrast whenever m_hiContrastFactor value, we clamp the factor to 0.3f
475 // (arbitray choice after tests)
476 float dim_factor_Edge_Cuts = std::max( m_hiContrastFactor, 0.3f );
477
478 if( m_ContrastModeDisplay == HIGH_CONTRAST_MODE::HIDDEN
479 || IsNetnameLayer( aLayer )
480 || hide )
481 {
482 if( originalLayer == Edge_Cuts )
483 {
485
486 if( it != m_layerColors.end() )
487 color = color.Mix( it->second, dim_factor_Edge_Cuts );
488 else
489 color = color.Mix( COLOR4D::BLACK, dim_factor_Edge_Cuts );
490 }
491 else
493 }
494 else
495 {
497 COLOR4D backgroundColor = it == m_layerColors.end() ? COLOR4D::BLACK : it->second;
498
499 if( originalLayer == Edge_Cuts )
500 color = color.Mix( backgroundColor, dim_factor_Edge_Cuts );
501 else
502 color = color.Mix( backgroundColor, m_hiContrastFactor );
503
504 // Reference images can't have their color mixed so just reduce the opacity a bit
505 // so they show through less
506 if( aItem->Type() == PCB_REFERENCE_IMAGE_T )
508 }
509 }
510 }
511 else if( originalLayer == LAYER_VIA_BBLIND || originalLayer == LAYER_VIA_MICROVIA )
512 {
513 const PCB_VIA* via = static_cast<const PCB_VIA*>( aItem );
514 const BOARD* board = via->GetBoard();
515 LSET visibleLayers = board->GetVisibleLayers() & board->GetEnabledLayers();
516
517 // Target graphic is visible if the via crosses a visible layer
518 if( ( via->GetLayerSet() & visibleLayers ).none() )
520 }
521
522 // Apply per-type opacity overrides
523 if( aItem->Type() == PCB_TRACE_T || aItem->Type() == PCB_ARC_T )
525 else if( aItem->Type() == PCB_VIA_T )
526 color.a *= m_viaOpacity;
527 else if( aItem->Type() == PCB_PAD_T )
528 color.a *= m_padOpacity;
529 else if( aItem->Type() == PCB_ZONE_T && static_cast<const ZONE*>( aItem )->IsTeardropArea() )
531 else if( aItem->Type() == PCB_ZONE_T )
532 color.a *= m_zoneOpacity;
533 else if( aItem->Type() == PCB_REFERENCE_IMAGE_T )
535 else if( aItem->Type() == PCB_SHAPE_T && static_cast<const PCB_SHAPE*>( aItem )->IsAnyFill() )
537 else if( aItem->Type() == PCB_SHAPE_T && aItem->IsOnCopperLayer() )
539
540 if( aItem->GetForcedTransparency() > 0.0 )
541 color = color.WithAlpha( color.a * ( 1.0 - aItem->GetForcedTransparency() ) );
542
543 // No special modifiers enabled
544 return color;
545}
546
547
549{
550 return pcbconfig() && pcbconfig()->m_ShowPageLimits;
551}
552
553
555 PAINTER( aGal ),
556 m_frameType( aFrameType ),
557 m_maxError( ARC_HIGH_DEF ),
558 m_holePlatingThickness( 0 ),
559 m_lockedShadowMargin( 0 )
560{
561}
562
563
564int PCB_PAINTER::getLineThickness( int aActualThickness ) const
565{
566 // if items have 0 thickness, draw them with the outline
567 // width, otherwise respect the set value (which, no matter
568 // how small will produce something)
569 if( aActualThickness == 0 )
571
572 return aActualThickness;
573}
574
575
577{
578 return aPad->GetDrillShape();
579}
580
581
583{
584 SHAPE_SEGMENT segm = *aPad->GetEffectiveHoleShape().get();
585 return segm;
586}
587
588
589int PCB_PAINTER::getViaDrillSize( const PCB_VIA* aVia ) const
590{
591 return aVia->GetDrillValue();
592}
593
594
595bool PCB_PAINTER::Draw( const VIEW_ITEM* aItem, int aLayer )
596{
597 if( !aItem->IsBOARD_ITEM() )
598 return false;
599
600 const BOARD_ITEM* item = static_cast<const BOARD_ITEM*>( aItem );
601
602 if( const BOARD* board = item->GetBoard() )
603 {
604 BOARD_DESIGN_SETTINGS& bds = board->GetDesignSettings();
608
609 if( item->GetParentFootprint() && !board->IsFootprintHolder() )
610 {
611 FOOTPRINT* parentFP = item->GetParentFootprint();
612
613 // Never draw footprint reference images on board
614 if( item->Type() == PCB_REFERENCE_IMAGE_T )
615 {
616 return false;
617 }
618 else if( item->GetLayerSet().count() > 1 )
619 {
620 // For multi-layer objects, exclude only those layers that are private
621 if( IsPcbLayer( aLayer ) && parentFP->GetPrivateLayers().test( aLayer ) )
622 return false;
623 }
624 else if( item->GetLayerSet().count() == 1 )
625 {
626 // For single-layer objects, exclude all layers including ancillary layers
627 // such as holes, netnames, etc.
628 PCB_LAYER_ID singleLayer = item->GetLayerSet().ExtractLayer();
629
630 if( parentFP->GetPrivateLayers().test( singleLayer ) )
631 return false;
632 }
633 }
634 }
635 else
636 {
639 }
640
641 // the "cast" applied in here clarifies which overloaded draw() is called
642 switch( item->Type() )
643 {
644 case PCB_TRACE_T:
645 draw( static_cast<const PCB_TRACK*>( item ), aLayer );
646 break;
647
648 case PCB_ARC_T:
649 draw( static_cast<const PCB_ARC*>( item ), aLayer );
650 break;
651
652 case PCB_VIA_T:
653 draw( static_cast<const PCB_VIA*>( item ), aLayer );
654 break;
655
656 case PCB_PAD_T:
657 draw( static_cast<const PAD*>( item ), aLayer );
658 break;
659
660 case PCB_SHAPE_T:
661 draw( static_cast<const PCB_SHAPE*>( item ), aLayer );
662 break;
663
665 draw( static_cast<const PCB_REFERENCE_IMAGE*>( item ), aLayer );
666 break;
667
668 case PCB_FIELD_T:
669 draw( static_cast<const PCB_FIELD*>( item ), aLayer );
670 break;
671
672 case PCB_TEXT_T:
673 draw( static_cast<const PCB_TEXT*>( item ), aLayer );
674 break;
675
676 case PCB_TEXTBOX_T:
677 draw( static_cast<const PCB_TEXTBOX*>( item ), aLayer );
678 break;
679
680 case PCB_TABLE_T:
681 draw( static_cast<const PCB_TABLE*>( item ), aLayer );
682 break;
683
684 case PCB_FOOTPRINT_T:
685 draw( static_cast<const FOOTPRINT*>( item ), aLayer );
686 break;
687
688 case PCB_GROUP_T:
689 draw( static_cast<const PCB_GROUP*>( item ), aLayer );
690 break;
691
692 case PCB_ZONE_T:
693 draw( static_cast<const ZONE*>( item ), aLayer );
694 break;
695
697 case PCB_DIM_CENTER_T:
698 case PCB_DIM_RADIAL_T:
700 case PCB_DIM_LEADER_T:
701 draw( static_cast<const PCB_DIMENSION_BASE*>( item ), aLayer );
702 break;
703
704 case PCB_TARGET_T:
705 draw( static_cast<const PCB_TARGET*>( item ) );
706 break;
707
708 case PCB_MARKER_T:
709 draw( static_cast<const PCB_MARKER*>( item ), aLayer );
710 break;
711
712 default:
713 // Painter does not know how to draw the object
714 return false;
715 }
716
717 // Draw bounding boxes after drawing objects so they can be seen.
719 {
720 // Show bounding boxes of painted objects for debugging.
721 BOX2I box = item->GetBoundingBox();
722
723 m_gal->SetIsFill( false );
724 m_gal->SetIsStroke( true );
725
726 if( item->Type() == PCB_FOOTPRINT_T )
727 {
728 m_gal->SetStrokeColor( item->IsSelected() ? COLOR4D( 1.0, 0.2, 0.2, 1 ) :
729 COLOR4D( MAGENTA ) );
730 }
731 else
732 {
733 m_gal->SetStrokeColor( item->IsSelected() ? COLOR4D( 1.0, 0.2, 0.2, 1 ) :
734 COLOR4D( 0.4, 0.4, 0.4, 1 ) );
735 }
736
737 m_gal->SetLineWidth( 1 );
738 m_gal->DrawRectangle( box.GetOrigin(), box.GetEnd() );
739
740 if( item->Type() == PCB_FOOTPRINT_T )
741 {
742 m_gal->SetStrokeColor( item->IsSelected() ? COLOR4D( 1.0, 0.2, 0.2, 1 ) :
743 COLOR4D( CYAN ) );
744
745 const FOOTPRINT* fp = static_cast<const FOOTPRINT*>( item );
746
747 if( fp )
748 {
749 const SHAPE_POLY_SET& convex = fp->GetBoundingHull();
750
751 m_gal->DrawPolyline( convex.COutline( 0 ) );
752 }
753 }
754 }
755
756 return true;
757}
758
759
760void PCB_PAINTER::draw( const PCB_TRACK* aTrack, int aLayer )
761{
762 VECTOR2I start( aTrack->GetStart() );
763 VECTOR2I end( aTrack->GetEnd() );
764 int track_width = aTrack->GetWidth();
765 COLOR4D color = m_pcbSettings.GetColor( aTrack, aLayer );
766
767 if( IsNetnameLayer( aLayer ) )
768 {
769 if( !pcbconfig() || pcbconfig()->m_Display.m_NetNames < 2 )
770 return;
771
772 if( aTrack->GetNetCode() <= NETINFO_LIST::UNCONNECTED )
773 return;
774
775 SHAPE_SEGMENT trackShape( { aTrack->GetStart(), aTrack->GetEnd() }, aTrack->GetWidth() );
776 renderNetNameForSegment( trackShape, color, aTrack->GetDisplayNetname() );
777 return;
778 }
779 else if( IsCopperLayer( aLayer ) || IsSolderMaskLayer( aLayer )
780 || aLayer == LAYER_LOCKED_ITEM_SHADOW )
781 {
782 // Draw a regular track
783 bool outline_mode = pcbconfig()
785 && aLayer != LAYER_LOCKED_ITEM_SHADOW;
788 m_gal->SetIsStroke( outline_mode );
789 m_gal->SetIsFill( not outline_mode );
791
792 if( IsSolderMaskLayer( aLayer ) )
793 track_width = track_width + aTrack->GetSolderMaskExpansion() * 2;
794
795 if( aLayer == LAYER_LOCKED_ITEM_SHADOW )
796 track_width = track_width + m_lockedShadowMargin;
797
798 m_gal->DrawSegment( start, end, track_width );
799 }
800
801 // Clearance lines
802 if( IsClearanceLayer( aLayer ) && pcbconfig()
803 && pcbconfig()->m_Display.m_TrackClearance == SHOW_WITH_VIA_ALWAYS
805 {
806 const PCB_LAYER_ID copperLayerForClearance = ToLAYER_ID( aLayer - LAYER_CLEARANCE_START );
807
808 int clearance = aTrack->GetOwnClearance( copperLayerForClearance );
809
811 m_gal->SetIsFill( false );
812 m_gal->SetIsStroke( true );
814 m_gal->DrawSegment( start, end, track_width + clearance * 2 );
815 }
816}
817
818
820 const wxString& aNetName ) const
821{
822 // When drawing netnames, clip the track to the viewport
823 BOX2D viewport;
824 VECTOR2D screenSize = m_gal->GetScreenPixelSize();
825 const MATRIX3x3D& matrix = m_gal->GetScreenWorldMatrix();
826
827 viewport.SetOrigin( VECTOR2D( matrix * VECTOR2D( 0, 0 ) ) );
828 viewport.SetEnd( VECTOR2D( matrix * screenSize ) );
829 viewport.Normalize();
830
831 int num_char = aNetName.size();
832
833 // Check if the track is long enough to have a netname displayed
834 int seg_minlength = aSeg.GetWidth() * num_char;
835 SEG::ecoord seg_minlength_sq = (SEG::ecoord)seg_minlength * seg_minlength;
836
837 if( aSeg.GetSeg().SquaredLength() < seg_minlength_sq )
838 return;
839
840 double textSize = aSeg.GetWidth();
841 double penWidth = textSize / 12.0;
842 EDA_ANGLE textOrientation;
843 int num_names = 1;
844
845 VECTOR2I start = aSeg.GetSeg().A;
846 VECTOR2I end = aSeg.GetSeg().B;
847 VECTOR2D segV = end - start;
848
849 if( end.y == start.y ) // horizontal
850 {
851 textOrientation = ANGLE_HORIZONTAL;
852 num_names = std::max( num_names, KiROUND( aSeg.GetSeg().Length() / viewport.GetWidth() ) );
853 }
854 else if( end.x == start.x ) // vertical
855 {
856 textOrientation = ANGLE_VERTICAL;
857 num_names = std::max( num_names, KiROUND( aSeg.GetSeg().Length() / viewport.GetHeight() ) );
858 }
859 else
860 {
861 textOrientation = -EDA_ANGLE( segV );
862 textOrientation.Normalize90();
863
864 double min_size = std::min( viewport.GetWidth(), viewport.GetHeight() );
865 num_names = std::max( num_names, KiROUND( aSeg.GetSeg().Length() / ( M_SQRT2 * min_size ) ) );
866 }
867
868 m_gal->SetIsStroke( true );
869 m_gal->SetIsFill( false );
870 m_gal->SetStrokeColor( aColor );
871 m_gal->SetLineWidth( penWidth );
872 m_gal->SetFontBold( false );
873 m_gal->SetFontItalic( false );
874 m_gal->SetFontUnderlined( false );
875 m_gal->SetTextMirrored( false );
876 m_gal->SetGlyphSize( VECTOR2D( textSize * 0.55, textSize * 0.55 ) );
879
880 int divisions = num_names + 1;
881
882 for( int ii = 1; ii < divisions; ++ii )
883 {
884 VECTOR2I textPosition = start + segV * ( (double) ii / divisions );
885
886 if( viewport.Contains( textPosition ) )
887 m_gal->BitmapText( aNetName, textPosition, textOrientation );
888 }
889}
890
891
892void PCB_PAINTER::draw( const PCB_ARC* aArc, int aLayer )
893{
894 VECTOR2D center( aArc->GetCenter() );
895 int width = aArc->GetWidth();
896 COLOR4D color = m_pcbSettings.GetColor( aArc, aLayer );
897 double radius = aArc->GetRadius();
898 EDA_ANGLE start_angle = aArc->GetArcAngleStart();
899 EDA_ANGLE angle = aArc->GetAngle();
900
901 if( IsNetnameLayer( aLayer ) )
902 {
903 // Ummm, yeah. Anyone fancy implementing text on a path?
904 return;
905 }
906 else if( IsCopperLayer( aLayer ) || IsSolderMaskLayer( aLayer )
907 || aLayer == LAYER_LOCKED_ITEM_SHADOW )
908 {
909 // Draw a regular track
910 bool outline_mode = pcbconfig()
912 && aLayer != LAYER_LOCKED_ITEM_SHADOW;
915 m_gal->SetIsStroke( outline_mode );
916 m_gal->SetIsFill( not outline_mode );
918
919 if( IsSolderMaskLayer( aLayer ) )
920 width = width + aArc->GetSolderMaskExpansion() * 2;
921
922 if( aLayer == LAYER_LOCKED_ITEM_SHADOW )
923 width = width + m_lockedShadowMargin;
924
925 m_gal->DrawArcSegment( center, radius, start_angle, angle, width, m_maxError );
926 }
927
928 // Clearance lines
929 if( IsClearanceLayer( aLayer ) && pcbconfig()
930 && pcbconfig()->m_Display.m_TrackClearance == SHOW_WITH_VIA_ALWAYS
932 {
933 /*
934 * Showing the clearance area is not obvious for optionally-flashed pads and vias, so we
935 * choose to not display clearance lines at all on non-copper active layers. We follow
936 * the same rule for tracks to be consistent (even though they don't have the same issue).
937 */
938 const PCB_LAYER_ID activeLayer = m_pcbSettings.GetActiveLayer();
939 const BOARD& board = *aArc->GetBoard();
940
941 if( IsCopperLayer( activeLayer ) && board.GetVisibleLayers().test( activeLayer ) )
942 {
943 int clearance = aArc->GetOwnClearance( activeLayer );
944
946 m_gal->SetIsFill( false );
947 m_gal->SetIsStroke( true );
949
950 m_gal->DrawArcSegment( center, radius, start_angle, angle, width + clearance * 2,
951 m_maxError );
952 }
953 }
954
955// Debug only: enable this code only to test the TransformArcToPolygon function
956// and display the polygon outline created by it.
957// arcs on F_Cu are approximated with ERROR_INSIDE, others with ERROR_OUTSIDE
958#if 0
959 SHAPE_POLY_SET cornerBuffer;
960 ERROR_LOC errorloc = aLayer == F_Cu ? ERROR_LOC::ERROR_INSIDE : ERROR_LOC::ERROR_OUTSIDE;
961 TransformArcToPolygon( cornerBuffer, aArc->GetStart(), aArc->GetMid(), aArc->GetEnd(), width,
962 m_maxError, errorloc );
964 m_gal->SetIsFill( false );
965 m_gal->SetIsStroke( true );
966 m_gal->SetStrokeColor( COLOR4D( 0, 0, 1.0, 1.0 ) );
967 m_gal->DrawPolygon( cornerBuffer );
968#endif
969
970// Debug only: enable this code only to test the SHAPE_ARC::ConvertToPolyline function
971// and display the polyline created by it.
972#if 0
973 SHAPE_ARC arc( aArc->GetCenter(), aArc->GetStart(), aArc->GetAngle(), aArc->GetWidth() );
976 m_gal->SetIsFill( false );
977 m_gal->SetIsStroke( true );
978 m_gal->SetStrokeColor( COLOR4D( 0.3, 0.2, 0.5, 1.0 ) );
979
980 for( int idx = 1; idx < arcSpine.PointCount(); idx++ )
981 m_gal->DrawSegment( arcSpine.CPoint( idx-1 ), arcSpine.CPoint( idx ), aArc->GetWidth() );
982#endif
983}
984
985
986void PCB_PAINTER::draw( const PCB_VIA* aVia, int aLayer )
987{
988 const BOARD* board = aVia->GetBoard();
989 COLOR4D color = m_pcbSettings.GetColor( aVia, aLayer );
990 VECTOR2D center( aVia->GetStart() );
991
992 if( color == COLOR4D::CLEAR )
993 return;
994
995 const int copperLayer = IsViaCopperLayer( aLayer ) ? aLayer - LAYER_VIA_COPPER_START : aLayer;
996
997 PCB_LAYER_ID currentLayer = ToLAYER_ID( copperLayer );
998 PCB_LAYER_ID layerTop, layerBottom;
999 aVia->LayerPair( &layerTop, &layerBottom );
1000
1001 // Blind/buried vias (and microvias) will use different hole and label rendering
1002 bool isBlindBuried = aVia->GetViaType() == VIATYPE::BLIND_BURIED
1003 || ( aVia->GetViaType() == VIATYPE::MICROVIA
1004 && ( layerTop != F_Cu || layerBottom != B_Cu ) );
1005
1006 // Draw description layer
1007 if( IsNetnameLayer( aLayer ) )
1008 {
1009 VECTOR2D position( center );
1010
1011 // Is anything that we can display enabled (netname and/or layers ids)?
1012 bool showNets = pcbconfig() && pcbconfig()->m_Display.m_NetNames != 0
1013 && !aVia->GetNetname().empty();
1014 bool showLayers = aVia->GetViaType() != VIATYPE::THROUGH;
1015
1016 if( !showNets && !showLayers )
1017 return;
1018
1019 double maxSize = PCB_RENDER_SETTINGS::MAX_FONT_SIZE;
1020 double size = aVia->GetWidth( currentLayer );
1021
1022 // Font size limits
1023 if( size > maxSize )
1024 size = maxSize;
1025
1026 m_gal->Save();
1027 m_gal->Translate( position );
1028
1029 // Default font settings
1033 m_gal->SetFontBold( false );
1034 m_gal->SetFontItalic( false );
1035 m_gal->SetFontUnderlined( false );
1036 m_gal->SetTextMirrored( false );
1037 m_gal->SetStrokeColor( m_pcbSettings.GetColor( aVia, aLayer ) );
1038 m_gal->SetIsStroke( true );
1039 m_gal->SetIsFill( false );
1040
1041 // Set the text position via position. if only one text, it is on the via position
1042 // For 2 lines, the netname is slightly below the center, and the layer IDs above
1043 // the netname
1044 VECTOR2D textpos( 0.0, 0.0 );
1045
1046 wxString netname = aVia->GetDisplayNetname();
1047
1048 PCB_LAYER_ID topLayerId = aVia->TopLayer();
1049 PCB_LAYER_ID bottomLayerId = aVia->BottomLayer();
1050 int topLayer; // The via top layer number (from 1 to copper layer count)
1051 int bottomLayer; // The via bottom layer number (from 1 to copper layer count)
1052
1053 switch( topLayerId )
1054 {
1055 case F_Cu: topLayer = 1; break;
1056 case B_Cu: topLayer = board->GetCopperLayerCount(); break;
1057 default: topLayer = (topLayerId - B_Cu)/2 + 1; break;
1058 }
1059
1060 switch( bottomLayerId )
1061 {
1062 case F_Cu: bottomLayer = 1; break;
1063 case B_Cu: bottomLayer = board->GetCopperLayerCount(); break;
1064 default: bottomLayer = (bottomLayerId - B_Cu)/2 + 1; break;
1065 }
1066
1067 wxString layerIds;
1068#if wxUSE_UNICODE_WCHAR
1069 layerIds << std::to_wstring( topLayer ) << L'-' << std::to_wstring( bottomLayer );
1070#else
1071 layerIds << std::to_string( topLayer ) << '-' << std::to_string( bottomLayer );
1072#endif
1073
1074 // a good size is set room for at least 6 chars, to be able to print 2 lines of text,
1075 // or at least 3 chars for only the netname
1076 // (The layerIds string has 5 chars max)
1077 int minCharCnt = showLayers ? 6 : 3;
1078
1079 // approximate the size of netname and layerIds text:
1080 double tsize = 1.5 * size / std::max( PrintableCharCount( netname ), minCharCnt );
1081 tsize = std::min( tsize, size );
1082
1083 // Use a smaller text size to handle interline, pen size..
1084 tsize *= 0.75;
1085 VECTOR2D namesize( tsize, tsize );
1086
1087 // For 2 lines, adjust the text pos (move it a small amount to the bottom)
1088 if( showLayers && showNets )
1089 textpos.y += ( tsize * 1.3 )/ 2;
1090
1091 m_gal->SetGlyphSize( namesize );
1092 m_gal->SetLineWidth( namesize.x / 10.0 );
1093
1094 if( showNets )
1095 m_gal->BitmapText( netname, textpos, ANGLE_HORIZONTAL );
1096
1097 if( showLayers )
1098 {
1099 if( showNets )
1100 textpos.y -= tsize * 1.3;
1101
1102 m_gal->BitmapText( layerIds, textpos, ANGLE_HORIZONTAL );
1103 }
1104
1105 m_gal->Restore();
1106
1107 return;
1108 }
1109
1110 bool outline_mode = pcbconfig() && !pcbconfig()->m_Display.m_DisplayViaFill;
1111
1114 m_gal->SetIsStroke( true );
1115 m_gal->SetIsFill( false );
1116
1117 if( outline_mode )
1119
1120 if( aLayer == LAYER_VIA_HOLEWALLS )
1121 {
1122 double thickness =
1124 double radius = ( getViaDrillSize( aVia ) / 2.0 ) + thickness;
1125
1126 if( !outline_mode )
1127 {
1128 m_gal->SetLineWidth( thickness );
1129 radius -= thickness / 2.0;
1130 }
1131
1132 // Underpaint the hole so that there aren't artifacts at its edge
1133 m_gal->SetIsFill( true );
1134
1136 }
1137 else if( aLayer == LAYER_VIA_HOLES )
1138 {
1139 double radius = getViaDrillSize( aVia ) / 2.0;
1140
1141 m_gal->SetIsStroke( false );
1142 m_gal->SetIsFill( true );
1143
1144 if( isBlindBuried && !m_pcbSettings.IsPrinting() )
1145 {
1146 m_gal->SetIsStroke( false );
1147 m_gal->SetIsFill( true );
1148
1149 m_gal->SetFillColor( m_pcbSettings.GetColor( aVia, layerTop ) );
1151 EDA_ANGLE( 180, DEGREES_T ) );
1152
1153 m_gal->SetFillColor( m_pcbSettings.GetColor( aVia, layerBottom ) );
1155 EDA_ANGLE( 180, DEGREES_T ) );
1156 }
1157 else
1158 {
1160 }
1161 }
1162 else if( ( aLayer == F_Mask && aVia->IsOnLayer( F_Mask ) )
1163 || ( aLayer == B_Mask && aVia->IsOnLayer( B_Mask ) ) )
1164 {
1165 int margin = board->GetDesignSettings().m_SolderMaskExpansion;
1166
1167 m_gal->SetIsFill( true );
1168 m_gal->SetIsStroke( false );
1169
1170 m_gal->SetLineWidth( margin );
1171 m_gal->DrawCircle( center, aVia->GetWidth( currentLayer ) / 2.0 + margin );
1172 }
1173 else if( m_pcbSettings.IsPrinting() || IsCopperLayer( currentLayer ) )
1174 {
1175 int annular_width = ( aVia->GetWidth( currentLayer ) - getViaDrillSize( aVia ) ) / 2.0;
1176 double radius = aVia->GetWidth( currentLayer ) / 2.0;
1177 bool draw = false;
1178
1180 {
1182 }
1183 else if( aVia->IsSelected() )
1184 {
1185 draw = true;
1186 }
1187 else if( aVia->FlashLayer( board->GetVisibleLayers() & board->GetEnabledLayers() ) )
1188 {
1189 draw = true;
1190 }
1191
1192 if( !aVia->FlashLayer( currentLayer ) )
1193 draw = false;
1194
1195 if( !outline_mode )
1196 {
1197 m_gal->SetLineWidth( annular_width );
1198 radius -= annular_width / 2.0;
1199 }
1200
1201 if( draw )
1203 }
1204 else if( aLayer == LAYER_LOCKED_ITEM_SHADOW ) // draw a ring around the via
1205 {
1207
1209 ( aVia->GetWidth( currentLayer ) + m_lockedShadowMargin ) / 2.0 );
1210 }
1211
1212 // Clearance lines
1213 if( IsClearanceLayer( aLayer ) && pcbconfig()
1216 {
1217 const PCB_LAYER_ID copperLayerForClearance = ToLAYER_ID( aLayer - LAYER_CLEARANCE_START );
1218
1219 double radius;
1220
1221 if( aVia->FlashLayer( copperLayerForClearance ) )
1222 radius = aVia->GetWidth( copperLayerForClearance ) / 2.0;
1223 else
1225
1227 m_gal->SetIsFill( false );
1228 m_gal->SetIsStroke( true );
1230 m_gal->DrawCircle( center, radius + aVia->GetOwnClearance( copperLayerForClearance ) );
1231 }
1232}
1233
1234
1235void PCB_PAINTER::draw( const PAD* aPad, int aLayer )
1236{
1237 COLOR4D color = m_pcbSettings.GetColor( aPad, aLayer );
1238 const int copperLayer = IsPadCopperLayer( aLayer ) ? aLayer - LAYER_PAD_COPPER_START : aLayer;
1239 PCB_LAYER_ID pcbLayer = static_cast<PCB_LAYER_ID>( copperLayer );
1240
1241 if( IsNetnameLayer( aLayer ) )
1242 {
1243 PCBNEW_SETTINGS::DISPLAY_OPTIONS* displayOpts = pcbconfig() ? &pcbconfig()->m_Display : nullptr;
1244 wxString netname;
1245 wxString padNumber;
1246
1247 if( viewer_settings()->m_ViewersDisplay.m_DisplayPadNumbers )
1248 {
1249 padNumber = UnescapeString( aPad->GetNumber() );
1250
1251 if( dynamic_cast<CVPCB_SETTINGS*>( viewer_settings() ) )
1252 netname = aPad->GetPinFunction();
1253 }
1254
1255 if( displayOpts && !dynamic_cast<CVPCB_SETTINGS*>( viewer_settings() ) )
1256 {
1257 if( displayOpts->m_NetNames == 1 || displayOpts->m_NetNames == 3 )
1258 netname = aPad->GetDisplayNetname();
1259
1260 if( aPad->IsNoConnectPad() )
1261 netname = wxT( "x" );
1262 else if( aPad->IsFreePad() )
1263 netname = wxT( "*" );
1264 }
1265
1266 if( netname.IsEmpty() && padNumber.IsEmpty() )
1267 return;
1268
1269 BOX2I padBBox = aPad->GetBoundingBox();
1270 VECTOR2D position = padBBox.Centre();
1271 VECTOR2D padsize = VECTOR2D( padBBox.GetSize() );
1272
1273 if( aPad->IsEntered() )
1274 {
1275 FOOTPRINT* fp = aPad->GetParentFootprint();
1276
1277 // Find the number box
1278 for( const BOARD_ITEM* aItem : fp->GraphicalItems() )
1279 {
1280 if( aItem->Type() == PCB_SHAPE_T )
1281 {
1282 const PCB_SHAPE* shape = static_cast<const PCB_SHAPE*>( aItem );
1283
1284 if( shape->IsProxyItem() && shape->GetShape() == SHAPE_T::RECTANGLE )
1285 {
1286 position = shape->GetCenter();
1287 padsize = shape->GetBotRight() - shape->GetTopLeft();
1288
1289 // We normally draw a bit outside the pad, but this will be somewhat
1290 // unexpected when the user has drawn a box.
1291 padsize *= 0.9;
1292
1293 break;
1294 }
1295 }
1296 }
1297 }
1298 else if( aPad->GetShape( pcbLayer ) == PAD_SHAPE::CUSTOM )
1299 {
1300 // See if we have a number box
1301 for( const std::shared_ptr<PCB_SHAPE>& primitive : aPad->GetPrimitives( pcbLayer ) )
1302 {
1303 if( primitive->IsProxyItem() && primitive->GetShape() == SHAPE_T::RECTANGLE )
1304 {
1305 position = primitive->GetCenter();
1306 RotatePoint( position, aPad->GetOrientation() );
1307 position += aPad->ShapePos( pcbLayer );
1308
1309 padsize.x = abs( primitive->GetBotRight().x - primitive->GetTopLeft().x );
1310 padsize.y = abs( primitive->GetBotRight().y - primitive->GetTopLeft().y );
1311
1312 // We normally draw a bit outside the pad, but this will be somewhat
1313 // unexpected when the user has drawn a box.
1314 padsize *= 0.9;
1315
1316 break;
1317 }
1318 }
1319 }
1320
1321 if( aPad->GetShape( pcbLayer ) != PAD_SHAPE::CUSTOM )
1322 {
1323 // Don't allow a 45° rotation to bloat a pad's bounding box unnecessarily
1324 double limit = std::min( aPad->GetSize( pcbLayer ).x,
1325 aPad->GetSize( pcbLayer ).y ) * 1.1;
1326
1327 if( padsize.x > limit && padsize.y > limit )
1328 {
1329 padsize.x = limit;
1330 padsize.y = limit;
1331 }
1332 }
1333
1334 double maxSize = PCB_RENDER_SETTINGS::MAX_FONT_SIZE;
1335 double size = padsize.y;
1336
1337 m_gal->Save();
1338 m_gal->Translate( position );
1339
1340 // Keep the size ratio for the font, but make it smaller
1341 if( padsize.x < ( padsize.y * 0.95 ) )
1342 {
1344 size = padsize.x;
1345 std::swap( padsize.x, padsize.y );
1346 }
1347
1348 // Font size limits
1349 if( size > maxSize )
1350 size = maxSize;
1351
1352 // Default font settings
1356 m_gal->SetFontBold( false );
1357 m_gal->SetFontItalic( false );
1358 m_gal->SetFontUnderlined( false );
1359 m_gal->SetTextMirrored( false );
1360 m_gal->SetStrokeColor( m_pcbSettings.GetColor( aPad, aLayer ) );
1361 m_gal->SetIsStroke( true );
1362 m_gal->SetIsFill( false );
1363
1364 // We have already translated the GAL to be centered at the center of the pad's
1365 // bounding box
1366 VECTOR2I textpos( 0, 0 );
1367
1368 // Divide the space, to display both pad numbers and netnames and set the Y text
1369 // offset position to display 2 lines
1370 int Y_offset_numpad = 0;
1371 int Y_offset_netname = 0;
1372
1373 if( !netname.IsEmpty() && !padNumber.IsEmpty() )
1374 {
1375 // The magic numbers are defined experimentally for a better look.
1376 size = size / 2.5;
1377 Y_offset_netname = size / 1.4; // netname size is usually smaller than num pad
1378 // so the offset can be smaller
1379 Y_offset_numpad = size / 1.7;
1380 }
1381
1382 // We are using different fonts to display names, depending on the graphic
1383 // engine (OpenGL or Cairo).
1384 // Xscale_for_stroked_font adjust the text X size for cairo (stroke fonts) engine
1385 const double Xscale_for_stroked_font = 0.9;
1386
1387 if( !netname.IsEmpty() )
1388 {
1389 // approximate the size of net name text:
1390 // We use a size for at least 5 chars, to give a good look even for short names
1391 // (like VCC, GND...)
1392 double tsize = 1.5 * padsize.x / std::max( PrintableCharCount( netname )+1, 5 );
1393 tsize = std::min( tsize, size );
1394
1395 // Use a smaller text size to handle interline, pen size...
1396 tsize *= 0.85;
1397
1398 // Round and oval pads have less room to display the net name than other
1399 // (i.e RECT) shapes, so reduce the text size for these shapes
1400 if( aPad->GetShape( pcbLayer ) == PAD_SHAPE::CIRCLE
1401 || aPad->GetShape( pcbLayer ) == PAD_SHAPE::OVAL )
1402 {
1403 tsize *= 0.9;
1404 }
1405
1406 VECTOR2D namesize( tsize*Xscale_for_stroked_font, tsize );
1407 textpos.y = std::min( tsize * 1.4, double( Y_offset_netname ) );
1408
1409 m_gal->SetGlyphSize( namesize );
1410 m_gal->SetLineWidth( namesize.x / 6.0 );
1411 m_gal->SetFontBold( true );
1412 m_gal->BitmapText( netname, textpos, ANGLE_HORIZONTAL );
1413 }
1414
1415 if( !padNumber.IsEmpty() )
1416 {
1417 // approximate the size of the pad number text:
1418 // We use a size for at least 3 chars, to give a good look even for short numbers
1419 double tsize = 1.5 * padsize.x / std::max( PrintableCharCount( padNumber ), 3 );
1420 tsize = std::min( tsize, size );
1421
1422 // Use a smaller text size to handle interline, pen size...
1423 tsize *= 0.85;
1424 tsize = std::min( tsize, size );
1425 VECTOR2D numsize( tsize*Xscale_for_stroked_font, tsize );
1426 textpos.y = -Y_offset_numpad;
1427
1428 m_gal->SetGlyphSize( numsize );
1429 m_gal->SetLineWidth( numsize.x / 6.0 );
1430 m_gal->SetFontBold( true );
1431 m_gal->BitmapText( padNumber, textpos, ANGLE_HORIZONTAL );
1432 }
1433
1434 m_gal->Restore();
1435
1436 return;
1437 }
1438 else if( aLayer == LAYER_PAD_HOLEWALLS )
1439 {
1440 m_gal->SetIsFill( true );
1441 m_gal->SetIsStroke( false );
1443 double lineWidth = widthFactor * m_holePlatingThickness;
1444
1445 // Prevent the hole wall from being drawn too thin (at least two pixels)
1446 // or too thick (cap at the size of the pad )
1447 lineWidth = std::max( lineWidth, 2.0 / m_gal->GetWorldScale() );
1448 lineWidth = std::min( lineWidth, aPad->GetSizeX() / 2.0 );
1449 lineWidth = std::min( lineWidth, aPad->GetSizeY() / 2.0 );
1450
1452
1453 std::shared_ptr<SHAPE_SEGMENT> slot = aPad->GetEffectiveHoleShape();
1454 int holeSize = slot->GetWidth() + ( 2 * lineWidth );
1455
1456 if( slot->GetSeg().A == slot->GetSeg().B ) // Circular hole
1457 m_gal->DrawCircle( slot->GetSeg().A, KiROUND( holeSize / 2.0 ) );
1458 else
1459 m_gal->DrawSegment( slot->GetSeg().A, slot->GetSeg().B, holeSize );
1460
1461 return;
1462 }
1463
1464 bool outline_mode = !viewer_settings()->m_ViewersDisplay.m_DisplayPadFill;
1465
1467 outline_mode = true;
1468
1469 bool drawShape = false;
1470
1472 {
1473 drawShape = aPad->FlashLayer( m_pcbSettings.GetPrintLayers() );
1474 }
1475 else if( ( aLayer < PCB_LAYER_ID_COUNT || IsPadCopperLayer( aLayer ) )
1476 && aPad->FlashLayer( pcbLayer ) )
1477 {
1478 drawShape = true;
1479 }
1480 else if( aPad->IsSelected() )
1481 {
1482 drawShape = true;
1483 outline_mode = true;
1484 }
1485 else if( aLayer == LAYER_LOCKED_ITEM_SHADOW )
1486 {
1487 drawShape = true;
1488 outline_mode = false;
1489 }
1490
1491 if( outline_mode )
1492 {
1493 // Outline mode
1494 m_gal->SetIsFill( false );
1495 m_gal->SetIsStroke( true );
1498 }
1499 else
1500 {
1501 // Filled mode
1502 m_gal->SetIsFill( true );
1503 m_gal->SetIsStroke( false );
1505 }
1506
1507 if( aLayer == LAYER_PAD_PLATEDHOLES || aLayer == LAYER_NON_PLATEDHOLES )
1508 {
1509 SHAPE_SEGMENT slot = getPadHoleShape( aPad );
1510
1511 if( slot.GetSeg().A == slot.GetSeg().B ) // Circular hole
1512 m_gal->DrawCircle( slot.GetSeg().A, slot.GetWidth() / 2.0 );
1513 else
1514 m_gal->DrawSegment( slot.GetSeg().A, slot.GetSeg().B, slot.GetWidth() );
1515 }
1516 else if( drawShape )
1517 {
1518 VECTOR2I pad_size = aPad->GetSize( pcbLayer );
1519 VECTOR2I margin;
1520
1521 auto getExpansion =
1522 [&]( PCB_LAYER_ID layer )
1523 {
1524 VECTOR2I expansion;
1525
1526 switch( aLayer )
1527 {
1528 case F_Mask:
1529 case B_Mask:
1530 expansion.x = expansion.y = aPad->GetSolderMaskExpansion( layer );
1531 break;
1532
1533 case F_Paste:
1534 case B_Paste:
1535 expansion = aPad->GetSolderPasteMargin( layer );
1536 break;
1537
1538 default:
1539 expansion.x = expansion.y = 0;
1540 break;
1541 }
1542
1543 return expansion;
1544 };
1545
1546 if( aLayer == LAYER_LOCKED_ITEM_SHADOW )
1547 {
1548 LSET visibleLayers = aPad->GetBoard()->GetVisibleLayers()
1549 & aPad->GetBoard()->GetEnabledLayers()
1550 & aPad->GetLayerSet();
1551
1552 for( PCB_LAYER_ID layer : visibleLayers )
1553 margin = std::max( margin, getExpansion( layer ) );
1554
1555 margin.x += m_lockedShadowMargin / 2;
1556 margin.y += m_lockedShadowMargin / 2;
1557 }
1558 else
1559 {
1560 margin = getExpansion( pcbLayer );
1561 }
1562
1563 std::unique_ptr<PAD> dummyPad;
1564 std::shared_ptr<SHAPE_COMPOUND> shapes;
1565
1566 // Drawing components of compound shapes in outline mode produces a mess.
1567 bool simpleShapes = !outline_mode;
1568
1569 if( simpleShapes )
1570 {
1571 if( ( margin.x != margin.y && aPad->GetShape( pcbLayer ) != PAD_SHAPE::CUSTOM )
1572 || ( aPad->GetShape( pcbLayer ) == PAD_SHAPE::ROUNDRECT
1573 && ( margin.x < 0 || margin.y < 0 ) ) )
1574 {
1575 // Our algorithms below (polygon inflation in particular) can't handle differential
1576 // inflation along separate axes. So for those cases we build a dummy pad instead,
1577 // and inflate it.
1578
1579 // Margin is added to both sides. If the total margin is larger than the pad
1580 // then don't display this layer
1581 if( pad_size.x + 2 * margin.x <= 0 || pad_size.y + 2 * margin.y <= 0 )
1582 return;
1583
1584 dummyPad.reset( static_cast<PAD*>( aPad->Duplicate( IGNORE_PARENT_GROUP ) ) );
1585
1586 int initial_radius = dummyPad->GetRoundRectCornerRadius( pcbLayer );
1587
1588 dummyPad->SetSize( pcbLayer, pad_size + margin + margin );
1589
1590 if( dummyPad->GetShape( pcbLayer ) == PAD_SHAPE::ROUNDRECT )
1591 {
1592 // To keep the right margin around the corners, we need to modify the corner radius.
1593 // We must have only one radius correction, so use the smallest absolute margin.
1594 int radius_margin = std::max( margin.x, margin.y ); // radius_margin is < 0
1595 dummyPad->SetRoundRectCornerRadius(
1596 pcbLayer, std::max( initial_radius + radius_margin, 0 ) );
1597 }
1598
1599 shapes = std::dynamic_pointer_cast<SHAPE_COMPOUND>(
1600 dummyPad->GetEffectiveShape( pcbLayer ) );
1601 margin.x = margin.y = 0;
1602 }
1603 else
1604 {
1605 shapes = std::dynamic_pointer_cast<SHAPE_COMPOUND>(
1606 aPad->GetEffectiveShape( pcbLayer ) );
1607 }
1608
1609 // The dynamic cast above will fail if the pad returned the hole shape or a null shape
1610 // instead of a SHAPE_COMPOUND, which happens if we're on a copper layer and the pad has
1611 // no shape on that layer.
1612 if( !shapes )
1613 return;
1614
1615 if( aPad->GetShape( pcbLayer ) == PAD_SHAPE::CUSTOM && ( margin.x || margin.y ) )
1616 {
1617 // We can't draw as shapes because we don't know which edges are internal and which
1618 // are external (so we don't know when to apply the margin and when not to).
1619 simpleShapes = false;
1620 }
1621
1622 for( const SHAPE* shape : shapes->Shapes() )
1623 {
1624 if( !simpleShapes )
1625 break;
1626
1627 switch( shape->Type() )
1628 {
1629 case SH_SEGMENT:
1630 case SH_CIRCLE:
1631 case SH_RECT:
1632 case SH_SIMPLE:
1633 // OK so far
1634 break;
1635
1636 default:
1637 // Not OK
1638 simpleShapes = false;
1639 break;
1640 }
1641 }
1642 }
1643
1644 const auto drawOneSimpleShape = [&]( const SHAPE& aShape )
1645 {
1646 switch( aShape.Type() )
1647 {
1648 case SH_SEGMENT:
1649 {
1650 const SHAPE_SEGMENT& seg = (const SHAPE_SEGMENT&) aShape;
1651 int effectiveWidth = seg.GetWidth() + 2 * margin.x;
1652
1653 if( effectiveWidth > 0 )
1654 m_gal->DrawSegment( seg.GetSeg().A, seg.GetSeg().B, effectiveWidth );
1655
1656 break;
1657 }
1658
1659 case SH_CIRCLE:
1660 {
1661 const SHAPE_CIRCLE& circle = (const SHAPE_CIRCLE&) aShape;
1662 int effectiveRadius = circle.GetRadius() + margin.x;
1663
1664 if( effectiveRadius > 0 )
1665 m_gal->DrawCircle( circle.GetCenter(), effectiveRadius );
1666
1667 break;
1668 }
1669
1670 case SH_RECT:
1671 {
1672 const SHAPE_RECT& r = (const SHAPE_RECT&) aShape;
1673 VECTOR2I pos = r.GetPosition();
1674 VECTOR2I effectiveMargin = margin;
1675
1676 if( effectiveMargin.x < 0 )
1677 {
1678 // A negative margin just produces a smaller rect.
1679 VECTOR2I effectiveSize = r.GetSize() + effectiveMargin;
1680
1681 if( effectiveSize.x > 0 && effectiveSize.y > 0 )
1682 m_gal->DrawRectangle( pos - effectiveMargin, pos + effectiveSize );
1683 }
1684 else if( effectiveMargin.x > 0 )
1685 {
1686 // A positive margin produces a larger rect, but with rounded corners
1688
1689 // Use segments to produce the margin with rounded corners
1690 m_gal->DrawSegment( pos,
1691 pos + VECTOR2I( r.GetWidth(), 0 ),
1692 effectiveMargin.x * 2 );
1693 m_gal->DrawSegment( pos + VECTOR2I( r.GetWidth(), 0 ),
1694 pos + r.GetSize(),
1695 effectiveMargin.x * 2 );
1696 m_gal->DrawSegment( pos + r.GetSize(),
1697 pos + VECTOR2I( 0, r.GetHeight() ),
1698 effectiveMargin.x * 2 );
1699 m_gal->DrawSegment( pos + VECTOR2I( 0, r.GetHeight() ),
1700 pos,
1701 effectiveMargin.x * 2 );
1702 }
1703 else
1704 {
1706 }
1707
1708 break;
1709 }
1710
1711 case SH_SIMPLE:
1712 {
1713 const SHAPE_SIMPLE& poly = static_cast<const SHAPE_SIMPLE&>( aShape );
1714
1715 if( poly.PointCount() < 2 ) // Careful of empty pads
1716 break;
1717
1718 if( margin.x < 0 ) // The poly shape must be deflated
1719 {
1720 SHAPE_POLY_SET outline;
1721 outline.NewOutline();
1722
1723 for( int ii = 0; ii < poly.PointCount(); ++ii )
1724 outline.Append( poly.CPoint( ii ) );
1725
1726 outline.Deflate( -margin.x, CORNER_STRATEGY::CHAMFER_ALL_CORNERS, m_maxError );
1727
1728 m_gal->DrawPolygon( outline );
1729 }
1730 else
1731 {
1732 m_gal->DrawPolygon( poly.Vertices() );
1733 }
1734
1735 // Now add on a rounded margin (using segments) if the margin > 0
1736 if( margin.x > 0 )
1737 {
1738 for( size_t ii = 0; ii < poly.GetSegmentCount(); ++ii )
1739 {
1740 SEG seg = poly.GetSegment( ii );
1741 m_gal->DrawSegment( seg.A, seg.B, margin.x * 2 );
1742 }
1743 }
1744
1745 break;
1746 }
1747
1748 default:
1749 // Better not get here; we already pre-flighted the shapes...
1750 break;
1751 }
1752 };
1753
1754 if( simpleShapes )
1755 {
1756 for( const SHAPE* shape : shapes->Shapes() )
1757 {
1758 drawOneSimpleShape( *shape );
1759 }
1760 }
1761 else
1762 {
1763 // This is expensive. Avoid if possible.
1764 SHAPE_POLY_SET polySet;
1765 aPad->TransformShapeToPolygon( polySet, ToLAYER_ID( aLayer ), margin.x, m_maxError,
1766 ERROR_INSIDE );
1767 m_gal->DrawPolygon( polySet );
1768 }
1769 }
1770
1771 if( IsClearanceLayer( aLayer )
1772 && ( ( pcbconfig() && pcbconfig()->m_Display.m_PadClearance ) || !pcbconfig() )
1774 {
1775 const PCB_LAYER_ID copperLayerForClearance = ToLAYER_ID( aLayer - LAYER_CLEARANCE_START );
1776
1777 if( aPad->GetAttribute() == PAD_ATTRIB::NPTH )
1779
1781 m_gal->SetIsStroke( true );
1782 m_gal->SetIsFill( false );
1784
1785 const int clearance = aPad->GetOwnClearance( copperLayerForClearance );
1786
1787 if( aPad->FlashLayer( copperLayerForClearance ) && clearance > 0 )
1788 {
1789 auto shape = std::dynamic_pointer_cast<SHAPE_COMPOUND>(
1790 aPad->GetEffectiveShape( pcbLayer ) );
1791
1792 if( shape && shape->Size() == 1 && shape->Shapes()[0]->Type() == SH_SEGMENT )
1793 {
1794 const SHAPE_SEGMENT* seg = (SHAPE_SEGMENT*) shape->Shapes()[0];
1795 m_gal->DrawSegment( seg->GetSeg().A, seg->GetSeg().B,
1796 seg->GetWidth() + 2 * clearance );
1797 }
1798 else if( shape && shape->Size() == 1 && shape->Shapes()[0]->Type() == SH_CIRCLE )
1799 {
1800 const SHAPE_CIRCLE* circle = (SHAPE_CIRCLE*) shape->Shapes()[0];
1802 }
1803 else
1804 {
1805 SHAPE_POLY_SET polySet;
1806
1807 // Use ERROR_INSIDE because it avoids Clipper and is therefore much faster.
1808 aPad->TransformShapeToPolygon( polySet, copperLayerForClearance, clearance,
1810
1811 if( polySet.Outline( 0 ).PointCount() > 2 ) // Careful of empty pads
1812 m_gal->DrawPolygon( polySet );
1813 }
1814 }
1815 else if( aPad->GetEffectiveHoleShape() && clearance > 0 )
1816 {
1817 std::shared_ptr<SHAPE_SEGMENT> slot = aPad->GetEffectiveHoleShape();
1818 m_gal->DrawSegment( slot->GetSeg().A, slot->GetSeg().B,
1819 slot->GetWidth() + 2 * clearance );
1820 }
1821 }
1822}
1823
1824
1825void PCB_PAINTER::draw( const PCB_SHAPE* aShape, int aLayer )
1826{
1827 COLOR4D color = m_pcbSettings.GetColor( aShape, aLayer );
1829 int thickness = getLineThickness( aShape->GetWidth() );
1830 LINE_STYLE lineStyle = aShape->GetStroke().GetLineStyle();
1831 bool isSolidFill = aShape->IsSolidFill();
1832 bool isHatchedFill = aShape->IsHatchedFill();
1833
1834 if( lineStyle == LINE_STYLE::DEFAULT )
1835 lineStyle = LINE_STYLE::SOLID;
1836
1837 if( IsSolderMaskLayer( aLayer )
1838 && aShape->HasSolderMask()
1839 && IsExternalCopperLayer( aShape->GetLayer() ) )
1840 {
1841 lineStyle = LINE_STYLE::SOLID;
1842 thickness += aShape->GetSolderMaskExpansion() * 2;
1843
1844 if( isHatchedFill )
1845 {
1846 isSolidFill = true;
1847 isHatchedFill = false;
1848 }
1849 }
1850
1851 if( IsNetnameLayer( aLayer ) )
1852 {
1853 // Net names are shown only in board editor:
1854 if( m_frameType != FRAME_T::FRAME_PCB_EDITOR )
1855 return;
1856
1857 if( !pcbconfig() || pcbconfig()->m_Display.m_NetNames < 2 )
1858 return;
1859
1860 if( aShape->GetNetCode() <= NETINFO_LIST::UNCONNECTED )
1861 return;
1862
1863 const wxString& netname = aShape->GetDisplayNetname();
1864
1865 if( netname.IsEmpty() )
1866 return;
1867
1868 if( aShape->GetShape() == SHAPE_T::SEGMENT )
1869 {
1870 SHAPE_SEGMENT seg( { aShape->GetStart(), aShape->GetEnd() }, aShape->GetWidth() );
1871 renderNetNameForSegment( seg, color, netname );
1872 return;
1873 }
1874
1875 // TODO: Maybe use some of the pad code?
1876
1877 return;
1878 }
1879
1880 if( aLayer == LAYER_LOCKED_ITEM_SHADOW )
1881 {
1882 color = m_pcbSettings.GetColor( aShape, aLayer );
1883 thickness = thickness + m_lockedShadowMargin;
1884
1885 // Note: on LAYER_LOCKED_ITEM_SHADOW always draw shadow shapes as continuous lines
1886 // otherwise the look is very strange and ugly
1887 lineStyle = LINE_STYLE::SOLID;
1888 }
1889
1890 if( outline_mode )
1891 {
1892 m_gal->SetIsFill( false );
1893 m_gal->SetIsStroke( true );
1895 }
1896
1899
1900 if( lineStyle == LINE_STYLE::SOLID || aShape->IsSolidFill() )
1901 {
1902 switch( aShape->GetShape() )
1903 {
1904 case SHAPE_T::SEGMENT:
1905 if( aShape->IsProxyItem() )
1906 {
1907 std::vector<VECTOR2I> pts;
1908 VECTOR2I offset = ( aShape->GetEnd() - aShape->GetStart() ).Perpendicular();
1909 offset = offset.Resize( thickness / 2 );
1910
1911 pts.push_back( aShape->GetStart() + offset );
1912 pts.push_back( aShape->GetStart() - offset );
1913 pts.push_back( aShape->GetEnd() - offset );
1914 pts.push_back( aShape->GetEnd() + offset );
1915
1917 m_gal->DrawLine( pts[0], pts[1] );
1918 m_gal->DrawLine( pts[1], pts[2] );
1919 m_gal->DrawLine( pts[2], pts[3] );
1920 m_gal->DrawLine( pts[3], pts[0] );
1921 m_gal->DrawLine( ( pts[0] + pts[1] ) / 2, ( pts[1] + pts[2] ) / 2 );
1922 m_gal->DrawLine( ( pts[1] + pts[2] ) / 2, ( pts[2] + pts[3] ) / 2 );
1923 m_gal->DrawLine( ( pts[2] + pts[3] ) / 2, ( pts[3] + pts[0] ) / 2 );
1924 m_gal->DrawLine( ( pts[3] + pts[0] ) / 2, ( pts[0] + pts[1] ) / 2 );
1925 }
1926 else if( outline_mode )
1927 {
1928 m_gal->DrawSegment( aShape->GetStart(), aShape->GetEnd(), thickness );
1929 }
1930 else if( lineStyle == LINE_STYLE::SOLID )
1931 {
1932 m_gal->SetIsFill( true );
1933 m_gal->SetIsStroke( false );
1934
1935 m_gal->DrawSegment( aShape->GetStart(), aShape->GetEnd(), thickness );
1936 }
1937
1938 break;
1939
1940 case SHAPE_T::RECTANGLE:
1941 {
1942 std::vector<VECTOR2I> pts = aShape->GetRectCorners();
1943
1944 if( aShape->IsProxyItem() )
1945 {
1947 m_gal->DrawLine( pts[0], pts[1] );
1948 m_gal->DrawLine( pts[1], pts[2] );
1949 m_gal->DrawLine( pts[2], pts[3] );
1950 m_gal->DrawLine( pts[3], pts[0] );
1951 m_gal->DrawLine( pts[0], pts[2] );
1952 m_gal->DrawLine( pts[1], pts[3] );
1953 }
1954 else if( outline_mode )
1955 {
1956 m_gal->DrawSegment( pts[0], pts[1], thickness );
1957 m_gal->DrawSegment( pts[1], pts[2], thickness );
1958 m_gal->DrawSegment( pts[2], pts[3], thickness );
1959 m_gal->DrawSegment( pts[3], pts[0], thickness );
1960 }
1961 else
1962 {
1963 m_gal->SetIsFill( true );
1964 m_gal->SetIsStroke( false );
1965
1966 if( lineStyle == LINE_STYLE::SOLID && thickness > 0 )
1967 {
1968 m_gal->DrawSegment( pts[0], pts[1], thickness );
1969 m_gal->DrawSegment( pts[1], pts[2], thickness );
1970 m_gal->DrawSegment( pts[2], pts[3], thickness );
1971 m_gal->DrawSegment( pts[3], pts[0], thickness );
1972 }
1973
1974 if( isSolidFill )
1975 {
1976 SHAPE_POLY_SET poly;
1977 poly.NewOutline();
1978
1979 for( const VECTOR2I& pt : pts )
1980 poly.Append( pt );
1981
1982 if( thickness < 0 )
1983 poly.Inflate( thickness / 2, CORNER_STRATEGY::ROUND_ALL_CORNERS, m_maxError );
1984
1985 m_gal->DrawPolygon( poly );
1986 }
1987 }
1988
1989 break;
1990 }
1991
1992 case SHAPE_T::ARC:
1993 {
1994 EDA_ANGLE startAngle;
1995 EDA_ANGLE endAngle;
1996 aShape->CalcArcAngles( startAngle, endAngle );
1997
1998 if( outline_mode )
1999 {
2000 m_gal->DrawArcSegment( aShape->GetCenter(), aShape->GetRadius(), startAngle,
2001 endAngle - startAngle, thickness, m_maxError );
2002 }
2003 else if( lineStyle == LINE_STYLE::SOLID )
2004 {
2005 m_gal->SetIsFill( true );
2006 m_gal->SetIsStroke( false );
2007
2008 m_gal->DrawArcSegment( aShape->GetCenter(), aShape->GetRadius(), startAngle,
2009 endAngle - startAngle, thickness, m_maxError );
2010 }
2011 break;
2012 }
2013
2014 case SHAPE_T::CIRCLE:
2015 if( outline_mode )
2016 {
2017 m_gal->DrawCircle( aShape->GetStart(), aShape->GetRadius() - thickness / 2 );
2018 m_gal->DrawCircle( aShape->GetStart(), aShape->GetRadius() + thickness / 2 );
2019 }
2020 else
2021 {
2022 m_gal->SetIsFill( aShape->IsSolidFill() );
2023 m_gal->SetIsStroke( lineStyle == LINE_STYLE::SOLID && thickness > 0 );
2024 m_gal->SetLineWidth( thickness );
2025
2026 int radius = aShape->GetRadius();
2027
2028 if( lineStyle == LINE_STYLE::SOLID && thickness > 0 )
2029 {
2030 m_gal->DrawCircle( aShape->GetStart(), radius );
2031 }
2032 else if( isSolidFill )
2033 {
2034 if( thickness < 0 )
2035 {
2036 radius += thickness / 2;
2037 radius = std::max( radius, 0 );
2038 }
2039
2040 m_gal->DrawCircle( aShape->GetStart(), radius );
2041 }
2042 }
2043 break;
2044
2045 case SHAPE_T::POLY:
2046 {
2047 SHAPE_POLY_SET& shape = const_cast<PCB_SHAPE*>( aShape )->GetPolyShape();
2048
2049 if( shape.OutlineCount() == 0 )
2050 break;
2051
2052 if( outline_mode )
2053 {
2054 for( int ii = 0; ii < shape.OutlineCount(); ++ii )
2055 m_gal->DrawSegmentChain( shape.Outline( ii ), thickness );
2056 }
2057 else
2058 {
2059 m_gal->SetIsFill( true );
2060 m_gal->SetIsStroke( false );
2061
2062 if( lineStyle == LINE_STYLE::SOLID && thickness > 0 )
2063 {
2064 for( int ii = 0; ii < shape.OutlineCount(); ++ii )
2065 m_gal->DrawSegmentChain( shape.Outline( ii ), thickness );
2066 }
2067
2068 if( isSolidFill )
2069 {
2070 if( thickness < 0 )
2071 {
2072 SHAPE_POLY_SET deflated_shape = shape;
2073 deflated_shape.Inflate( thickness / 2, CORNER_STRATEGY::ROUND_ALL_CORNERS,
2074 m_maxError );
2075 m_gal->DrawPolygon( deflated_shape );
2076 }
2077 else
2078 {
2079 // On Opengl, a not convex filled polygon is usually drawn by using
2080 // triangles as primitives. CacheTriangulation() can create basic triangle
2081 // primitives to draw the polygon solid shape on Opengl. GLU tessellation
2082 // is much slower, so currently we are using our tessellation.
2083 if( m_gal->IsOpenGlEngine() && !shape.IsTriangulationUpToDate() )
2084 shape.CacheTriangulation( true, true );
2085
2086 m_gal->DrawPolygon( shape );
2087 }
2088 }
2089 }
2090
2091 break;
2092 }
2093
2094 case SHAPE_T::BEZIER:
2095 if( outline_mode )
2096 {
2097 std::vector<VECTOR2D> output;
2098 std::vector<VECTOR2D> pointCtrl;
2099
2100 pointCtrl.push_back( aShape->GetStart() );
2101 pointCtrl.push_back( aShape->GetBezierC1() );
2102 pointCtrl.push_back( aShape->GetBezierC2() );
2103 pointCtrl.push_back( aShape->GetEnd() );
2104
2105 BEZIER_POLY converter( pointCtrl );
2106 converter.GetPoly( output, m_maxError );
2107
2108 m_gal->DrawSegmentChain( aShape->GetBezierPoints(), thickness );
2109 }
2110 else
2111 {
2112 m_gal->SetIsFill( aShape->IsSolidFill() );
2113 m_gal->SetIsStroke( lineStyle == LINE_STYLE::SOLID && thickness > 0 );
2114 m_gal->SetLineWidth( thickness );
2115
2116 if( aShape->GetBezierPoints().size() > 2 )
2117 {
2118 m_gal->DrawPolygon( aShape->GetBezierPoints() );
2119 }
2120 else
2121 {
2122 m_gal->DrawCurve( VECTOR2D( aShape->GetStart() ),
2123 VECTOR2D( aShape->GetBezierC1() ),
2124 VECTOR2D( aShape->GetBezierC2() ),
2125 VECTOR2D( aShape->GetEnd() ), m_maxError );
2126 }
2127 }
2128
2129 break;
2130
2131 case SHAPE_T::UNDEFINED:
2132 break;
2133 }
2134 }
2135
2136 if( lineStyle != LINE_STYLE::SOLID )
2137 {
2138 if( !outline_mode )
2139 {
2140 m_gal->SetIsFill( true );
2141 m_gal->SetIsStroke( false );
2142 }
2143
2144 std::vector<SHAPE*> shapes = aShape->MakeEffectiveShapes( true );
2145
2146 for( SHAPE* shape : shapes )
2147 {
2148 STROKE_PARAMS::Stroke( shape, lineStyle, getLineThickness( aShape->GetWidth() ),
2150 [&]( const VECTOR2I& a, const VECTOR2I& b )
2151 {
2152 m_gal->DrawSegment( a, b, thickness );
2153 } );
2154 }
2155
2156 for( SHAPE* shape : shapes )
2157 delete shape;
2158 }
2159
2160 if( isHatchedFill )
2161 {
2162 m_gal->SetIsStroke( false );
2163 m_gal->SetIsFill( true );
2164 m_gal->DrawPolygon( aShape->GetHatching() );
2165 }
2166}
2167
2168
2169void PCB_PAINTER::strokeText( const wxString& aText, const VECTOR2I& aPosition,
2170 const TEXT_ATTRIBUTES& aAttrs, const KIFONT::METRICS& aFontMetrics )
2171{
2172 KIFONT::FONT* font = aAttrs.m_Font;
2173
2174 if( !font )
2175 font = KIFONT::FONT::GetFont( wxEmptyString, aAttrs.m_Bold, aAttrs.m_Italic );
2176
2177 m_gal->SetIsFill( font->IsOutline() );
2178 m_gal->SetIsStroke( font->IsStroke() );
2179
2180 VECTOR2I pos( aPosition );
2181 VECTOR2I fudge( KiROUND( 0.16 * aAttrs.m_StrokeWidth ), 0 );
2182
2183 RotatePoint( fudge, aAttrs.m_Angle );
2184
2185 if( ( aAttrs.m_Halign == GR_TEXT_H_ALIGN_LEFT && !aAttrs.m_Mirrored )
2186 || ( aAttrs.m_Halign == GR_TEXT_H_ALIGN_RIGHT && aAttrs.m_Mirrored ) )
2187 {
2188 pos -= fudge;
2189 }
2190 else if( ( aAttrs.m_Halign == GR_TEXT_H_ALIGN_RIGHT && !aAttrs.m_Mirrored )
2191 || ( aAttrs.m_Halign == GR_TEXT_H_ALIGN_LEFT && aAttrs.m_Mirrored ) )
2192 {
2193 pos += fudge;
2194 }
2195
2196 font->Draw( m_gal, aText, pos, aAttrs, aFontMetrics );
2197}
2198
2199
2200void PCB_PAINTER::draw( const PCB_REFERENCE_IMAGE* aBitmap, int aLayer )
2201{
2202 m_gal->Save();
2203
2204 const REFERENCE_IMAGE& refImg = aBitmap->GetReferenceImage();
2205 m_gal->Translate( refImg.GetPosition() );
2206
2207 // When the image scale factor is not 1.0, we need to modify the actual as the image scale
2208 // factor is similar to a local zoom
2209 const double img_scale = refImg.GetImageScale();
2210
2211 if( img_scale != 1.0 )
2212 m_gal->Scale( VECTOR2D( img_scale, img_scale ) );
2213
2214 if( aBitmap->IsSelected() || aBitmap->IsBrightened() )
2215 {
2217 m_gal->SetIsStroke( true );
2220 m_gal->SetIsFill( false );
2221
2222 // Draws a bounding box.
2223 VECTOR2D bm_size( refImg.GetSize() );
2224 // bm_size is the actual image size in UI.
2225 // but m_gal scale was previously set to img_scale
2226 // so recalculate size relative to this image size.
2227 bm_size.x /= img_scale;
2228 bm_size.y /= img_scale;
2229 VECTOR2D origin( -bm_size.x / 2.0, -bm_size.y / 2.0 );
2230 VECTOR2D end = origin + bm_size;
2231
2232 m_gal->DrawRectangle( origin, end );
2233
2234 // Hard code reference images as opaque when selected. Otherwise cached layers will
2235 // not be rendered under the selected image because cached layers are rendered after
2236 // non-cached layers (e.g. bitmaps), which will have a closer Z order.
2237 m_gal->DrawBitmap( refImg.GetImage(), 1.0 );
2238 }
2239 else
2240 m_gal->DrawBitmap( refImg.GetImage(),
2241 m_pcbSettings.GetColor( aBitmap, aBitmap->GetLayer() ).a );
2242
2243 m_gal->Restore();
2244}
2245
2246
2247void PCB_PAINTER::draw( const PCB_FIELD* aField, int aLayer )
2248{
2249 if( aField->IsVisible() )
2250 draw( static_cast<const PCB_TEXT*>( aField ), aLayer );
2251}
2252
2253
2254void PCB_PAINTER::draw( const PCB_TEXT* aText, int aLayer )
2255{
2256 wxString resolvedText( aText->GetShownText( true ) );
2257
2258 if( resolvedText.Length() == 0 )
2259 return;
2260
2261 if( aLayer == LAYER_LOCKED_ITEM_SHADOW ) // happens only if locked
2262 {
2263 const COLOR4D color = m_pcbSettings.GetColor( aText, aLayer );
2264
2265 m_gal->SetIsFill( true );
2266 m_gal->SetIsStroke( true );
2270
2271 SHAPE_POLY_SET poly;
2272 aText->TransformShapeToPolygon( poly, aText->GetLayer(), 0, m_maxError, ERROR_OUTSIDE );
2273 m_gal->DrawPolygon( poly );
2274
2275 return;
2276 }
2277
2278 const KIFONT::METRICS& metrics = aText->GetFontMetrics();
2279 TEXT_ATTRIBUTES attrs = aText->GetAttributes();
2280 const COLOR4D& color = m_pcbSettings.GetColor( aText, aLayer );
2281 bool outline_mode = !viewer_settings()->m_ViewersDisplay.m_DisplayTextFill;
2282
2283 KIFONT::FONT* font = aText->GetFont();
2284
2285 if( !font )
2286 {
2288 aText->IsItalic() );
2289 }
2290
2293 attrs.m_Angle = aText->GetDrawRotation();
2294
2295 if( aText->IsKnockout() )
2296 {
2297 SHAPE_POLY_SET finalPoly = aText->GetKnockoutCache( font, resolvedText, m_maxError );
2298
2299 m_gal->SetIsStroke( false );
2300 m_gal->SetIsFill( true );
2301 m_gal->DrawPolygon( finalPoly );
2302 }
2303 else
2304 {
2305 if( outline_mode )
2307 else
2309
2310 if( m_gal->IsFlippedX() && !aText->IsSideSpecific() )
2311 {
2312 // We do not want to change the mirroring for this kind of text
2313 // on the mirrored canvas
2314 // (not mirrored is draw not mirrored and mirrored is draw mirrored)
2315 // So we need to recalculate the text position to keep it at the same position
2316 // on the canvas
2317 VECTOR2I textPos = aText->GetTextPos();
2318 VECTOR2I textWidth = VECTOR2I( aText->GetTextBox().GetWidth(), 0 );
2319
2320 if( aText->GetHorizJustify() == GR_TEXT_H_ALIGN_RIGHT )
2321 textWidth.x = -textWidth.x;
2322 else if( aText->GetHorizJustify() == GR_TEXT_H_ALIGN_CENTER )
2323 textWidth.x = 0;
2324
2325 RotatePoint( textWidth, VECTOR2I( 0, 0 ), aText->GetDrawRotation() );
2326
2327 if( attrs.m_Mirrored )
2328 textPos -= textWidth;
2329 else
2330 textPos += textWidth;
2331
2332 attrs.m_Mirrored = !attrs.m_Mirrored;
2333 strokeText( resolvedText, textPos, attrs, metrics );
2334 return;
2335 }
2336
2337 std::vector<std::unique_ptr<KIFONT::GLYPH>>* cache = nullptr;
2338
2339 if( font->IsOutline() )
2340 cache = aText->GetRenderCache( font, resolvedText );
2341
2342 if( cache )
2343 {
2345 m_gal->DrawGlyphs( *cache );
2346 }
2347 else
2348 {
2349 strokeText( resolvedText, aText->GetTextPos(), attrs, metrics );
2350 }
2351 }
2352
2353 // Draw the umbilical line for texts in footprints
2354 FOOTPRINT* fp_parent = aText->GetParentFootprint();
2355
2356 if( fp_parent && aText->IsSelected() )
2357 {
2360 m_gal->DrawLine( aText->GetTextPos(), fp_parent->GetPosition() );
2361 }
2362}
2363
2364
2365void PCB_PAINTER::draw( const PCB_TEXTBOX* aTextBox, int aLayer )
2366{
2367 if( aTextBox->Type() == PCB_TABLECELL_T )
2368 {
2369 const PCB_TABLECELL* cell = static_cast<const PCB_TABLECELL*>( aTextBox );
2370
2371 if( cell->GetColSpan() == 0 || cell->GetRowSpan() == 0 )
2372 return;
2373 }
2374
2375 COLOR4D color = m_pcbSettings.GetColor( aTextBox, aLayer );
2376 int thickness = getLineThickness( aTextBox->GetWidth() );
2377 LINE_STYLE lineStyle = aTextBox->GetStroke().GetLineStyle();
2378 wxString resolvedText( aTextBox->GetShownText( true ) );
2379
2380 KIFONT::FONT* font = aTextBox->GetFont();
2381
2382 if( !font )
2383 {
2385 aTextBox->IsItalic() );
2386 }
2387
2388 if( aLayer == LAYER_LOCKED_ITEM_SHADOW ) // happens only if locked
2389 {
2390 const COLOR4D sh_color = m_pcbSettings.GetColor( aTextBox, aLayer );
2391
2392 m_gal->SetIsFill( true );
2393 m_gal->SetIsStroke( false );
2394 m_gal->SetFillColor( sh_color );
2395 m_gal->SetStrokeColor( sh_color );
2396
2397 // Draw the box with a larger thickness than box thickness to show
2398 // the shadow mask
2399 std::vector<VECTOR2I> pts = aTextBox->GetCorners();
2400 int line_thickness = std::max( thickness*3, pcbIUScale.mmToIU( 0.2 ) );
2401
2402 std::deque<VECTOR2D> dpts;
2403
2404 for( const VECTOR2I& pt : pts )
2405 dpts.push_back( VECTOR2D( pt ) );
2406
2407 dpts.push_back( VECTOR2D( pts[0] ) );
2408
2409 m_gal->SetIsStroke( true );
2410 m_gal->SetLineWidth( line_thickness );
2411 m_gal->DrawPolygon( dpts );
2412 }
2413
2416 m_gal->SetIsFill( true );
2417 m_gal->SetIsStroke( false );
2418
2419 if( aTextBox->Type() != PCB_TABLECELL_T && aTextBox->IsBorderEnabled() )
2420 {
2421 if( lineStyle <= LINE_STYLE::FIRST_TYPE )
2422 {
2423 if( thickness > 0 )
2424 {
2425 std::vector<VECTOR2I> pts = aTextBox->GetCorners();
2426
2427 for( size_t ii = 0; ii < pts.size(); ++ii )
2428 m_gal->DrawSegment( pts[ii], pts[( ii + 1 ) % pts.size()], thickness );
2429 }
2430 }
2431 else
2432 {
2433 std::vector<SHAPE*> shapes = aTextBox->MakeEffectiveShapes( true );
2434
2435 for( SHAPE* shape : shapes )
2436 {
2437 STROKE_PARAMS::Stroke( shape, lineStyle, thickness, &m_pcbSettings,
2438 [&]( const VECTOR2I& a, const VECTOR2I& b )
2439 {
2440 m_gal->DrawSegment( a, b, thickness );
2441 } );
2442 }
2443
2444 for( SHAPE* shape : shapes )
2445 delete shape;
2446 }
2447 }
2448
2449 if( aLayer == LAYER_LOCKED_ITEM_SHADOW )
2450 {
2451 // For now, the textbox is a filled shape.
2452 // so the text drawn on LAYER_LOCKED_ITEM_SHADOW with a thick width is disabled
2453 // If enabled, the thick text position must be offsetted to be exactly on the
2454 // initial text, which is not easy, depending on its rotation and justification.
2455#if 0
2456 const COLOR4D sh_color = m_pcbSettings.GetColor( aTextBox, aLayer );
2457 m_gal->SetFillColor( sh_color );
2458 m_gal->SetStrokeColor( sh_color );
2459 attrs.m_StrokeWidth += m_lockedShadowMargin;
2460#else
2461 return;
2462#endif
2463 }
2464
2465 if( aTextBox->IsKnockout() )
2466 {
2467 SHAPE_POLY_SET finalPoly;
2468 aTextBox->TransformTextToPolySet( finalPoly, 0, m_maxError, ERROR_INSIDE );
2469 finalPoly.Fracture();
2470
2471 m_gal->SetIsStroke( false );
2472 m_gal->SetIsFill( true );
2473 m_gal->DrawPolygon( finalPoly );
2474 }
2475 else
2476 {
2477 if( resolvedText.Length() == 0 )
2478 return;
2479
2480 const KIFONT::METRICS& metrics = aTextBox->GetFontMetrics();
2481 TEXT_ATTRIBUTES attrs = aTextBox->GetAttributes();
2483
2484 if( m_gal->IsFlippedX() && !aTextBox->IsSideSpecific() )
2485 {
2486 attrs.m_Mirrored = !attrs.m_Mirrored;
2487 strokeText( resolvedText, aTextBox->GetDrawPos( true ), attrs, metrics );
2488 return;
2489 }
2490
2491 std::vector<std::unique_ptr<KIFONT::GLYPH>>* cache = nullptr;
2492
2493 if( font->IsOutline() )
2494 cache = aTextBox->GetRenderCache( font, resolvedText );
2495
2496 if( cache )
2497 {
2499 m_gal->DrawGlyphs( *cache );
2500 }
2501 else
2502 {
2503 strokeText( resolvedText, aTextBox->GetDrawPos(), attrs, metrics );
2504 }
2505 }
2506}
2507
2508void PCB_PAINTER::draw( const PCB_TABLE* aTable, int aLayer )
2509{
2510 if( aTable->GetCells().empty() )
2511 return;
2512
2513 for( PCB_TABLECELL* cell : aTable->GetCells() )
2514 {
2515 if( cell->GetColSpan() > 0 || cell->GetRowSpan() > 0 )
2516 draw( static_cast<PCB_TEXTBOX*>( cell ), aLayer );
2517 }
2518
2519 COLOR4D color = m_pcbSettings.GetColor( aTable, aLayer );
2520
2521 aTable->DrawBorders(
2522 [&]( const VECTOR2I& ptA, const VECTOR2I& ptB, const STROKE_PARAMS& stroke )
2523 {
2524 int lineWidth = getLineThickness( stroke.GetWidth() );
2525 LINE_STYLE lineStyle = stroke.GetLineStyle();
2526
2527 m_gal->SetIsFill( false );
2528 m_gal->SetIsStroke( true );
2530 m_gal->SetLineWidth( lineWidth );
2531
2532 if( lineStyle <= LINE_STYLE::FIRST_TYPE )
2533 {
2534 m_gal->DrawLine( ptA, ptB );
2535 }
2536 else
2537 {
2538 SHAPE_SEGMENT seg( ptA, ptB );
2539
2540 STROKE_PARAMS::Stroke( &seg, lineStyle, lineWidth, &m_pcbSettings,
2541 [&]( VECTOR2I a, VECTOR2I b )
2542 {
2543 // DrawLine has problem with 0 length lines so enforce minimum
2544 if( a == b )
2545 m_gal->DrawLine( a+1, b );
2546 else
2547 m_gal->DrawLine( a, b );
2548 } );
2549 }
2550 } );
2551
2552 // Highlight selected tablecells with a background wash.
2553 for( PCB_TABLECELL* cell : aTable->GetCells() )
2554 {
2555 if( aTable->IsSelected() || cell->IsSelected() )
2556 {
2557 std::vector<VECTOR2I> corners = cell->GetCorners();
2558 std::deque<VECTOR2D> pts;
2559
2560 pts.insert( pts.end(), corners.begin(), corners.end() );
2561
2562 m_gal->SetFillColor( color.WithAlpha( 0.5 ) );
2563 m_gal->SetIsFill( true );
2564 m_gal->SetIsStroke( false );
2565 m_gal->DrawPolygon( pts );
2566 }
2567 }
2568}
2569
2570
2571void PCB_PAINTER::draw( const FOOTPRINT* aFootprint, int aLayer )
2572{
2573 if( aLayer == LAYER_ANCHOR )
2574 {
2575 const COLOR4D color = m_pcbSettings.GetColor( aFootprint, aLayer );
2576
2577 // Keep the size and width constant, not related to the scale because the anchor
2578 // is just a marker on screen
2579 double anchorSize = 5.0 / m_gal->GetWorldScale(); // 5 pixels size
2580 double anchorThickness = 1.0 / m_gal->GetWorldScale(); // 1 pixels width
2581
2582 // Draw anchor
2583 m_gal->SetIsFill( false );
2584 m_gal->SetIsStroke( true );
2586 m_gal->SetLineWidth( anchorThickness );
2587
2588 VECTOR2D center = aFootprint->GetPosition();
2589 m_gal->DrawLine( center - VECTOR2D( anchorSize, 0 ), center + VECTOR2D( anchorSize, 0 ) );
2590 m_gal->DrawLine( center - VECTOR2D( 0, anchorSize ), center + VECTOR2D( 0, anchorSize ) );
2591 }
2592
2593 if( aLayer == LAYER_LOCKED_ITEM_SHADOW && m_frameType == FRAME_PCB_EDITOR ) // happens only if locked
2594 {
2595 const COLOR4D color = m_pcbSettings.GetColor( aFootprint, aLayer );
2596
2597 m_gal->SetIsFill( true );
2598 m_gal->SetIsStroke( false );
2600
2601#if 0 // GetBoundingHull() can be very slow, especially for logos imported from graphics
2602 const SHAPE_POLY_SET& poly = aFootprint->GetBoundingHull();
2603 m_gal->DrawPolygon( poly );
2604#else
2605 BOX2I bbox = aFootprint->GetBoundingBox( false );
2606 VECTOR2I topLeft = bbox.GetPosition();
2607 VECTOR2I botRight = bbox.GetPosition() + bbox.GetSize();
2608
2609 m_gal->DrawRectangle( topLeft, botRight );
2610
2611 // Use segments to produce a margin with rounded corners
2612 m_gal->DrawSegment( topLeft, VECTOR2I( botRight.x, topLeft.y ), m_lockedShadowMargin );
2613 m_gal->DrawSegment( VECTOR2I( botRight.x, topLeft.y ), botRight, m_lockedShadowMargin );
2614 m_gal->DrawSegment( botRight, VECTOR2I( topLeft.x, botRight.y ), m_lockedShadowMargin );
2615 m_gal->DrawSegment( VECTOR2I( topLeft.x, botRight.y ), topLeft, m_lockedShadowMargin );
2616#endif
2617 }
2618
2619 if( aLayer == LAYER_CONFLICTS_SHADOW )
2620 {
2621 const SHAPE_POLY_SET& frontpoly = aFootprint->GetCourtyard( F_CrtYd );
2622 const SHAPE_POLY_SET& backpoly = aFootprint->GetCourtyard( B_CrtYd );
2623
2624 const COLOR4D color = m_pcbSettings.GetColor( aFootprint, aLayer );
2625
2626 m_gal->SetIsFill( true );
2627 m_gal->SetIsStroke( false );
2629
2630 if( frontpoly.OutlineCount() > 0 )
2631 m_gal->DrawPolygon( frontpoly );
2632
2633 if( backpoly.OutlineCount() > 0 )
2634 m_gal->DrawPolygon( backpoly );
2635 }
2636}
2637
2638
2639void PCB_PAINTER::draw( const PCB_GROUP* aGroup, int aLayer )
2640{
2641 if( aLayer == LAYER_ANCHOR )
2642 {
2643 if( aGroup->IsSelected() && !( aGroup->GetParent() && aGroup->GetParent()->IsSelected() ) )
2644 {
2645 // Selected on our own; draw enclosing box
2646 }
2647 else if( aGroup->IsEntered() )
2648 {
2649 // Entered group; draw enclosing box
2650 }
2651 else
2652 {
2653 // Neither selected nor entered; draw nothing at the group level (ie: only draw
2654 // its members)
2655 return;
2656 }
2657
2658 const COLOR4D color = m_pcbSettings.GetColor( aGroup, LAYER_ANCHOR );
2659
2662
2663 BOX2I bbox = aGroup->GetBoundingBox();
2664 VECTOR2I topLeft = bbox.GetPosition();
2665 VECTOR2I width = VECTOR2I( bbox.GetWidth(), 0 );
2666 VECTOR2I height = VECTOR2I( 0, bbox.GetHeight() );
2667
2668 m_gal->DrawLine( topLeft, topLeft + width );
2669 m_gal->DrawLine( topLeft + width, topLeft + width + height );
2670 m_gal->DrawLine( topLeft + width + height, topLeft + height );
2671 m_gal->DrawLine( topLeft + height, topLeft );
2672
2673 wxString name = aGroup->GetName();
2674
2675 if( name.IsEmpty() )
2676 return;
2677
2678 int ptSize = 12;
2679 int scaledSize = abs( KiROUND( m_gal->GetScreenWorldMatrix().GetScale().x * ptSize ) );
2680 int unscaledSize = pcbIUScale.MilsToIU( ptSize );
2681
2682 // Scale by zoom a bit, but not too much
2683 int textSize = ( scaledSize + ( unscaledSize * 2 ) ) / 3;
2684 VECTOR2I textOffset = VECTOR2I( width.x / 2, -KiROUND( textSize * 0.5 ) );
2685 VECTOR2I titleHeight = VECTOR2I( 0, KiROUND( textSize * 2.0 ) );
2686
2687 if( PrintableCharCount( name ) * textSize < bbox.GetWidth() )
2688 {
2689 m_gal->DrawLine( topLeft, topLeft - titleHeight );
2690 m_gal->DrawLine( topLeft - titleHeight, topLeft + width - titleHeight );
2691 m_gal->DrawLine( topLeft + width - titleHeight, topLeft + width );
2692
2693 TEXT_ATTRIBUTES attrs;
2694 attrs.m_Italic = true;
2697 attrs.m_Size = VECTOR2I( textSize, textSize );
2698 attrs.m_StrokeWidth = GetPenSizeForNormal( textSize );
2699
2700 KIFONT::FONT::GetFont()->Draw( m_gal, aGroup->GetName(), topLeft + textOffset, attrs,
2701 aGroup->GetFontMetrics() );
2702 }
2703 }
2704}
2705
2706
2707void PCB_PAINTER::draw( const ZONE* aZone, int aLayer )
2708{
2709 if( aLayer == LAYER_CONFLICTS_SHADOW )
2710 {
2711 COLOR4D color = m_pcbSettings.GetColor( aZone, aLayer );
2712
2713 m_gal->SetIsFill( true );
2714 m_gal->SetIsStroke( false );
2716
2717 m_gal->DrawPolygon( aZone->Outline()->Outline( 0 ) );
2718 return;
2719 }
2720
2721 /*
2722 * aLayer will be the virtual zone layer (LAYER_ZONE_START, ... in GAL_LAYER_ID)
2723 * This is used for draw ordering in the GAL.
2724 * The color for the zone comes from the associated copper layer ( aLayer - LAYER_ZONE_START )
2725 * and the visibility comes from the combination of that copper layer and LAYER_ZONES
2726 */
2727 PCB_LAYER_ID layer;
2728
2729 if( IsZoneFillLayer( aLayer ) )
2730 layer = ToLAYER_ID( aLayer - LAYER_ZONE_START );
2731 else
2732 layer = ToLAYER_ID( aLayer );
2733
2734 if( !aZone->IsOnLayer( layer ) )
2735 return;
2736
2737 COLOR4D color = m_pcbSettings.GetColor( aZone, layer );
2738 std::deque<VECTOR2D> corners;
2740
2741 if( aZone->IsTeardropArea() )
2742 displayMode = ZONE_DISPLAY_MODE::SHOW_FILLED;
2743
2744 // Draw the outline
2745 if( !IsZoneFillLayer( aLayer ) )
2746 {
2747 const SHAPE_POLY_SET* outline = aZone->Outline();
2748 bool allowDrawOutline = aZone->GetHatchStyle() != ZONE_BORDER_DISPLAY_STYLE::INVISIBLE_BORDER;
2749
2750 if( allowDrawOutline && !m_pcbSettings.m_isPrinting && outline && outline->OutlineCount() > 0 )
2751 {
2752 m_gal->SetStrokeColor( color.a > 0.0 ? color.WithAlpha( 1.0 ) : color );
2753 m_gal->SetIsFill( false );
2754 m_gal->SetIsStroke( true );
2756
2757 // Draw each contour (main contour and holes)
2758
2759 /*
2760 * m_gal->DrawPolygon( *outline );
2761 * should be enough, but currently does not work to draw holes contours in a complex
2762 * polygon so each contour is draw as a simple polygon
2763 */
2764
2765 // Draw the main contour(s?)
2766 for( int ii = 0; ii < outline->OutlineCount(); ++ii )
2767 {
2768 m_gal->DrawPolyline( outline->COutline( ii ) );
2769
2770 // Draw holes
2771 int holes_count = outline->HoleCount( ii );
2772
2773 for( int jj = 0; jj < holes_count; ++jj )
2774 m_gal->DrawPolyline( outline->CHole( ii, jj ) );
2775 }
2776
2777 // Draw hatch lines
2778 for( const SEG& hatchLine : aZone->GetHatchLines() )
2779 m_gal->DrawLine( hatchLine.A, hatchLine.B );
2780 }
2781 }
2782
2783 // Draw the filling
2784 if( IsZoneFillLayer( aLayer )
2785 && ( displayMode == ZONE_DISPLAY_MODE::SHOW_FILLED
2786 || displayMode == ZONE_DISPLAY_MODE::SHOW_FRACTURE_BORDERS
2787 || displayMode == ZONE_DISPLAY_MODE::SHOW_TRIANGULATION ) )
2788 {
2789 const std::shared_ptr<SHAPE_POLY_SET>& polySet = aZone->GetFilledPolysList( layer );
2790
2791 if( polySet->OutlineCount() == 0 ) // Nothing to draw
2792 return;
2793
2796 m_gal->SetLineWidth( 0 );
2797
2798 if( displayMode == ZONE_DISPLAY_MODE::SHOW_FILLED )
2799 {
2800 m_gal->SetIsFill( true );
2801 m_gal->SetIsStroke( false );
2802 }
2803 else
2804 {
2805 m_gal->SetIsFill( false );
2806 m_gal->SetIsStroke( true );
2807 }
2808
2809 // On Opengl, a not convex filled polygon is usually drawn by using triangles
2810 // as primitives. CacheTriangulation() can create basic triangle primitives to
2811 // draw the polygon solid shape on Opengl. GLU tessellation is much slower,
2812 // so currently we are using our tessellation.
2813 if( m_gal->IsOpenGlEngine() && !polySet->IsTriangulationUpToDate() )
2814 polySet->CacheTriangulation( true, true );
2815
2816 m_gal->DrawPolygon( *polySet, displayMode == ZONE_DISPLAY_MODE::SHOW_TRIANGULATION );
2817 }
2818}
2819
2820
2821void PCB_PAINTER::draw( const PCB_DIMENSION_BASE* aDimension, int aLayer )
2822{
2823 const COLOR4D& color = m_pcbSettings.GetColor( aDimension, aLayer );
2824
2827 m_gal->SetIsFill( false );
2828 m_gal->SetIsStroke( true );
2829
2831
2832 if( outline_mode )
2834 else
2836
2837 // Draw dimension shapes
2838 // TODO(JE) lift this out
2839 for( const std::shared_ptr<SHAPE>& shape : aDimension->GetShapes() )
2840 {
2841 switch( shape->Type() )
2842 {
2843 case SH_SEGMENT:
2844 {
2845 const SEG& seg = static_cast<const SHAPE_SEGMENT*>( shape.get() )->GetSeg();
2846 m_gal->DrawLine( seg.A, seg.B );
2847 break;
2848 }
2849
2850 case SH_CIRCLE:
2851 {
2852 int radius = static_cast<const SHAPE_CIRCLE*>( shape.get() )->GetRadius();
2853 m_gal->DrawCircle( shape->Centre(), radius );
2854 break;
2855 }
2856
2857 default:
2858 break;
2859 }
2860 }
2861
2862 // Draw text
2863 wxString resolvedText = aDimension->GetShownText( true );
2864 TEXT_ATTRIBUTES attrs = aDimension->GetAttributes();
2865
2866 if( m_gal->IsFlippedX() && !aDimension->IsSideSpecific() )
2867 attrs.m_Mirrored = !attrs.m_Mirrored;
2868
2869 if( outline_mode )
2871 else
2873
2874 std::vector<std::unique_ptr<KIFONT::GLYPH>>* cache = nullptr;
2875
2876 if( aDimension->GetFont() && aDimension->GetFont()->IsOutline() )
2877 cache = aDimension->GetRenderCache( aDimension->GetFont(), resolvedText );
2878
2879 if( cache )
2880 {
2881 for( const std::unique_ptr<KIFONT::GLYPH>& glyph : *cache )
2882 m_gal->DrawGlyph( *glyph.get() );
2883 }
2884 else
2885 {
2886 strokeText( resolvedText, aDimension->GetTextPos(), attrs, aDimension->GetFontMetrics() );
2887 }
2888}
2889
2890
2891void PCB_PAINTER::draw( const PCB_TARGET* aTarget )
2892{
2893 const COLOR4D& strokeColor = m_pcbSettings.GetColor( aTarget, aTarget->GetLayer() );
2894 VECTOR2D position( aTarget->GetPosition() );
2895 double size, radius;
2896
2897 m_gal->SetLineWidth( getLineThickness( aTarget->GetWidth() ) );
2898 m_gal->SetStrokeColor( strokeColor );
2899 m_gal->SetIsFill( false );
2900 m_gal->SetIsStroke( true );
2901
2902 m_gal->Save();
2903 m_gal->Translate( position );
2904
2905 if( aTarget->GetShape() )
2906 {
2907 // shape x
2908 m_gal->Rotate( M_PI / 4.0 );
2909 size = 2.0 * aTarget->GetSize() / 3.0;
2910 radius = aTarget->GetSize() / 2.0;
2911 }
2912 else
2913 {
2914 // shape +
2915 size = aTarget->GetSize() / 2.0;
2916 radius = aTarget->GetSize() / 3.0;
2917 }
2918
2919 m_gal->DrawLine( VECTOR2D( -size, 0.0 ), VECTOR2D( size, 0.0 ) );
2920 m_gal->DrawLine( VECTOR2D( 0.0, -size ), VECTOR2D( 0.0, size ) );
2921 m_gal->DrawCircle( VECTOR2D( 0.0, 0.0 ), radius );
2922
2923 m_gal->Restore();
2924}
2925
2926
2927void PCB_PAINTER::draw( const PCB_MARKER* aMarker, int aLayer )
2928{
2929 switch( aLayer )
2930 {
2932 case LAYER_DRC_ERROR:
2933 case LAYER_DRC_WARNING:
2934 {
2935 bool isShadow = aLayer == LAYER_MARKER_SHADOWS;
2936
2937 // Don't paint invisible markers.
2938 // It would be nice to do this through layer dependencies but we can't do an "or" there today
2939 if( aMarker->GetBoard()
2940 && !aMarker->GetBoard()->IsElementVisible( aMarker->GetColorLayer() ) )
2941 return;
2942
2943 const_cast<PCB_MARKER*>( aMarker )->SetZoom( 1.0 / sqrt( m_gal->GetZoomFactor() ) );
2944
2945 SHAPE_LINE_CHAIN polygon;
2946 aMarker->ShapeToPolygon( polygon );
2947
2949 : aMarker->GetColorLayer() );
2950
2951 m_gal->Save();
2952 m_gal->Translate( aMarker->GetPosition() );
2953
2954 if( isShadow )
2955 {
2957 m_gal->SetIsStroke( true );
2958 m_gal->SetLineWidth( aMarker->MarkerScale() );
2959 }
2960 else
2961 {
2963 m_gal->SetIsFill( true );
2964 }
2965
2966 m_gal->DrawPolygon( polygon );
2967 m_gal->Restore();
2968 return;
2969 }
2970 case LAYER_DRC_SHAPE1:
2971 case LAYER_DRC_SHAPE2:
2972 {
2973 if( !aMarker->IsBrightened() )
2974 return;
2975
2976 int arc_to_seg_error = gerbIUScale.mmToIU( 0.005 ); // Allow 5 microns
2977 m_gal->SetLineWidth( aMarker->MarkerScale() );
2978
2979 for( auto& shape :
2980 aLayer == LAYER_DRC_SHAPE1 ? aMarker->GetShapes1() : aMarker->GetShapes2() )
2981 {
2982 m_gal->SetIsFill( shape.IsSolidFill() );
2983 m_gal->SetIsStroke( aLayer == LAYER_DRC_SHAPE1 ? true : false );
2984 m_gal->SetStrokeColor( shape.GetLineColor() );
2985 m_gal->SetFillColor( shape.GetFillColor() );
2986
2987 switch( shape.GetShape() )
2988 {
2989 case SHAPE_T::SEGMENT:
2990 m_gal->DrawSegment( shape.GetStart(), shape.GetEnd(), shape.GetWidth() );
2991 break;
2992 case SHAPE_T::ARC:
2993 {
2994 EDA_ANGLE startAngle, endAngle;
2995 shape.CalcArcAngles( startAngle, endAngle );
2996 m_gal->DrawArcSegment( shape.GetCenter(), shape.GetRadius(), startAngle,
2997 shape.GetArcAngle(), shape.GetWidth(), arc_to_seg_error );
2998 break;
2999 }
3000 default: break;
3001 }
3002 }
3003 }
3004 }
3005}
3006
3007
int color
Definition: DXF_plotter.cpp:63
const char * name
Definition: DXF_plotter.cpp:62
ERROR_LOC
When approximating an arc or circle, should the error be placed on the outside or inside of the curve...
Definition: approximation.h:32
@ ERROR_OUTSIDE
Definition: approximation.h:33
@ ERROR_INSIDE
Definition: approximation.h:34
constexpr int ARC_HIGH_DEF
Definition: base_units.h:129
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:112
constexpr EDA_IU_SCALE gerbIUScale
Definition: base_units.h:111
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition: box2.h:990
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
Bezier curves to polygon converter.
Definition: bezier_curves.h:38
void GetPoly(std::vector< VECTOR2I > &aOutput, int aMaxError=10)
Convert a Bezier curve to a polygon.
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
virtual NETCLASS * GetEffectiveNetClass() const
Return the NETCLASS for this item.
const wxString & GetDisplayNetname() const
virtual int GetOwnClearance(PCB_LAYER_ID aLayer, wxString *aSource=nullptr) const
Return an item's "own" clearance in internal units.
Container for design settings for a BOARD object.
int GetHolePlatingThickness() const
Pad & via drills are finish size.
int GetLineThickness(PCB_LAYER_ID aLayer) const
Return the default graphic segment thickness from the layer class for the given layer.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:79
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
Definition: board_item.h:232
virtual BOARD_ITEM * Duplicate(bool addToParentGroup, BOARD_COMMIT *aCommit=nullptr) const
Create a copy of this BOARD_ITEM.
Definition: board_item.cpp:271
virtual bool IsConnected() const
Returns information if the object is derived from BOARD_CONNECTED_ITEM.
Definition: board_item.h:134
virtual bool IsKnockout() const
Definition: board_item.h:322
virtual const BOARD * GetBoard() const
Return the BOARD in which this BOARD_ITEM resides, or NULL if none.
Definition: board_item.cpp:79
FOOTPRINT * GetParentFootprint() const
Definition: board_item.cpp:97
virtual LSET GetLayerSet() const
Return a std::bitset of all layers on which the item physically resides.
Definition: board_item.h:252
const KIFONT::METRICS & GetFontMetrics() const
Definition: board_item.cpp:132
BOARD_ITEM_CONTAINER * GetParent() const
Definition: board_item.h:210
bool IsSideSpecific() const
Definition: board_item.cpp:181
virtual bool IsOnCopperLayer() const
Definition: board_item.h:151
Information pertinent to a Pcbnew printed circuit board.
Definition: board.h:314
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Test whether a given element category is visible.
Definition: board.cpp:892
const LSET & GetVisibleLayers() const
A proxy function that calls the correspondent function in m_BoardSettings.
Definition: board.cpp:840
int GetCopperLayerCount() const
Definition: board.cpp:778
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Definition: board.cpp:943
const LSET & GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
Definition: board.cpp:826
constexpr const Vec & GetPosition() const
Definition: box2.h:211
constexpr const Vec GetEnd() const
Definition: box2.h:212
constexpr void SetOrigin(const Vec &pos)
Definition: box2.h:237
constexpr BOX2< Vec > & Normalize()
Ensure that the height and width are positive.
Definition: box2.h:146
constexpr size_type GetWidth() const
Definition: box2.h:214
constexpr Vec Centre() const
Definition: box2.h:97
constexpr size_type GetHeight() const
Definition: box2.h:215
constexpr bool Contains(const Vec &aPoint) const
Definition: box2.h:168
constexpr const Vec & GetOrigin() const
Definition: box2.h:210
constexpr const SizeVec & GetSize() const
Definition: box2.h:206
constexpr void SetEnd(coord_type x, coord_type y)
Definition: box2.h:297
Color settings are a bit different than most of the settings objects in that there can be more than o...
COLOR4D GetColor(int aLayer) const
APPEARANCE m_Appearance
EDA_ANGLE Normalize90()
Definition: eda_angle.h:252
double AsRadians() const
Definition: eda_angle.h:120
wxString GetName() const
Definition: eda_group.h:51
virtual const BOX2I GetBoundingBox() const
Return the orthogonal bounding box of this object for display purposes.
Definition: eda_item.cpp:110
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:109
bool IsEntered() const
Definition: eda_item.h:127
bool IsSelected() const
Definition: eda_item.h:126
bool IsBrightened() const
Definition: eda_item.h:128
const VECTOR2I & GetBezierC2() const
Definition: eda_shape.h:258
virtual VECTOR2I GetTopLeft() const
Definition: eda_shape.h:246
const SHAPE_POLY_SET & GetHatching() const
Definition: eda_shape.h:148
virtual std::vector< SHAPE * > MakeEffectiveShapes(bool aEdgeOnly=false) const
Make a set of SHAPE objects representing the EDA_SHAPE.
Definition: eda_shape.h:379
void CalcArcAngles(EDA_ANGLE &aStartAngle, EDA_ANGLE &aEndAngle) const
Calc arc start and end angles such that aStartAngle < aEndAngle.
Definition: eda_shape.cpp:988
int GetRadius() const
Definition: eda_shape.cpp:1004
SHAPE_T GetShape() const
Definition: eda_shape.h:168
virtual VECTOR2I GetBotRight() const
Definition: eda_shape.h:247
bool IsHatchedFill() const
Definition: eda_shape.h:124
bool IsSolidFill() const
Definition: eda_shape.h:117
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
Definition: eda_shape.h:215
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
Definition: eda_shape.h:173
std::vector< VECTOR2I > GetRectCorners() const
Definition: eda_shape.cpp:1587
const std::vector< VECTOR2I > & GetBezierPoints() const
Definition: eda_shape.h:320
const VECTOR2I & GetBezierC1() const
Definition: eda_shape.h:255
const VECTOR2I & GetTextPos() const
Definition: eda_text.h:270
bool IsItalic() const
Definition: eda_text.h:166
virtual bool IsVisible() const
Definition: eda_text.h:184
KIFONT::FONT * GetFont() const
Definition: eda_text.h:244
BOX2I GetTextBox(int aLine=-1) const
Useful in multiline texts to calculate the full text or a line area (for zones filling,...
Definition: eda_text.cpp:730
std::vector< std::unique_ptr< KIFONT::GLYPH > > * GetRenderCache(const KIFONT::FONT *aFont, const wxString &forResolvedText, const VECTOR2I &aOffset={ 0, 0 }) const
Definition: eda_text.cpp:671
GR_TEXT_H_ALIGN_T GetHorizJustify() const
Definition: eda_text.h:197
const TEXT_ATTRIBUTES & GetAttributes() const
Definition: eda_text.h:228
int GetEffectiveTextPenWidth(int aDefaultPenWidth=0) const
The EffectiveTextPenWidth uses the text thickness if > 1 or aDefaultPenWidth.
Definition: eda_text.cpp:465
bool IsBold() const
Definition: eda_text.h:181
LSET GetPrivateLayers() const
Definition: footprint.h:149
SHAPE_POLY_SET GetBoundingHull() const
Return a bounding polygon for the shapes and pads in the footprint.
Definition: footprint.cpp:1529
const SHAPE_POLY_SET & GetCourtyard(PCB_LAYER_ID aLayer) const
Used in DRC to test the courtyard area (a complex polygon).
Definition: footprint.cpp:2990
VECTOR2I GetPosition() const override
Definition: footprint.h:227
DRAWINGS & GraphicalItems()
Definition: footprint.h:212
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
Definition: footprint.cpp:1334
APP_SETTINGS_BASE * KifaceSettings() const
Definition: kiface_base.h:95
FONT is an abstract base class for both outline and stroke fonts.
Definition: font.h:131
static FONT * GetFont(const wxString &aFontName=wxEmptyString, bool aBold=false, bool aItalic=false, const std::vector< wxString > *aEmbeddedFiles=nullptr, bool aForDrawingSheet=false)
Definition: font.cpp:147
virtual bool IsStroke() const
Definition: font.h:138
void Draw(KIGFX::GAL *aGal, const wxString &aText, const VECTOR2I &aPosition, const VECTOR2I &aCursor, const TEXT_ATTRIBUTES &aAttributes, const METRICS &aFontMetrics) const
Draw a string.
Definition: font.cpp:250
virtual bool IsOutline() const
Definition: font.h:139
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
COLOR4D WithAlpha(double aAlpha) const
Return a color with the same color, but the given alpha.
Definition: color4d.h:311
static const COLOR4D CLEAR
Definition: color4d.h:403
COLOR4D & Darken(double aFactor)
Makes the color darker by a given factor.
Definition: color4d.h:226
COLOR4D Inverted() const
Returns an inverted color, alpha remains the same.
Definition: color4d.h:323
COLOR4D & Brighten(double aFactor)
Makes the color brighter by a given factor.
Definition: color4d.h:209
static const COLOR4D WHITE
Definition: color4d.h:401
double a
Alpha component.
Definition: color4d.h:395
static const COLOR4D UNSPECIFIED
For legacy support; used as a value to indicate color hasn't been set yet.
Definition: color4d.h:398
static const COLOR4D BLACK
Definition: color4d.h:402
Abstract interface for drawing on a 2D-surface.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
virtual void DrawGlyph(const KIFONT::GLYPH &aGlyph, int aNth=0, int aTotal=1)
Draw a polygon representing a font glyph.
virtual void Rotate(double aAngle)
Rotate the context.
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a rectangle.
void SetVerticalJustify(const GR_TEXT_V_ALIGN_T aVerticalJustify)
void SetFontBold(const bool aBold)
void SetFontUnderlined(bool aUnderlined)
void SetHorizontalJustify(const GR_TEXT_H_ALIGN_T aHorizontalJustify)
double GetZoomFactor() const
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
virtual void Translate(const VECTOR2D &aTranslation)
Translate the context.
const MATRIX3x3D & GetScreenWorldMatrix() const
Get the screen <-> world transformation matrix.
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
virtual void Restore()
Restore the context.
virtual bool IsOpenGlEngine()
Return true if the GAL engine is a OpenGL based type.
void ResetTextAttributes()
Reset text attributes to default styling.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
void SetTextMirrored(const bool aMirrored)
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
virtual void DrawArcSegment(const VECTOR2D &aCenterPoint, double aRadius, const EDA_ANGLE &aStartAngle, const EDA_ANGLE &aAngle, double aWidth, double aMaxError)
Draw an arc segment.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
void SetGlyphSize(const VECTOR2I aSize)
virtual void DrawGlyphs(const std::vector< std::unique_ptr< KIFONT::GLYPH > > &aGlyphs)
Draw polygons representing font glyphs.
virtual void Scale(const VECTOR2D &aScale)
Scale the context.
virtual void DrawCurve(const VECTOR2D &startPoint, const VECTOR2D &controlPointA, const VECTOR2D &controlPointB, const VECTOR2D &endPoint, double aFilterValue=0.0)
Draw a cubic bezier spline.
virtual void DrawArc(const VECTOR2D &aCenterPoint, double aRadius, const EDA_ANGLE &aStartAngle, const EDA_ANGLE &aAngle)
Draw an arc.
void SetFontItalic(bool aItalic)
virtual void DrawBitmap(const BITMAP_BASE &aBitmap, double alphaBlend=1.0)
Draw a bitmap image.
virtual void DrawSegment(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth)
Draw a rounded segment.
virtual void BitmapText(const wxString &aText, const VECTOR2I &aPosition, const EDA_ANGLE &aAngle)
Draw a text using a bitmap font.
const VECTOR2I & GetScreenPixelSize() const
Return GAL canvas size in pixels.
virtual void Save()
Save the context.
virtual void DrawSegmentChain(const std::vector< VECTOR2D > &aPointList, double aWidth)
Draw a chain of rounded segments.
double GetWorldScale() const
Get the world scale.
Contains all the knowledge about how to draw graphical object onto any particular output device.
Definition: painter.h:59
GAL * m_gal
Instance of graphic abstraction layer that gives an interface to call commands used to draw (eg.
Definition: painter.h:102
virtual SHAPE_SEGMENT getPadHoleShape(const PAD *aPad) const
Return hole shape for a pad (internal units).
PCB_PAINTER(GAL *aGal, FRAME_T aFrameType)
int getLineThickness(int aActualThickness) const
Get the thickness to draw for a line (e.g.
void renderNetNameForSegment(const SHAPE_SEGMENT &aSeg, const COLOR4D &aColor, const wxString &aNetName) const
PCB_VIEWERS_SETTINGS_BASE * viewer_settings()
Definition: pcb_painter.cpp:84
void draw(const PCB_TRACK *aTrack, int aLayer)
virtual PAD_DRILL_SHAPE getDrillShape(const PAD *aPad) const
Return drill shape of a pad.
PCB_RENDER_SETTINGS m_pcbSettings
Definition: pcb_painter.h:244
virtual int getViaDrillSize(const PCB_VIA *aVia) const
Return drill diameter for a via (internal units).
void strokeText(const wxString &aText, const VECTOR2I &aPosition, const TEXT_ATTRIBUTES &aAttrs, const KIFONT::METRICS &aFontMetrics)
virtual bool Draw(const VIEW_ITEM *aItem, int aLayer) override
Takes an instance of VIEW_ITEM and passes it to a function that knows how to draw the item.
double m_zoneOpacity
Opacity override for filled zones.
Definition: pcb_painter.h:171
double m_trackOpacity
Opacity override for all tracks.
Definition: pcb_painter.h:168
double m_imageOpacity
Opacity override for user images.
Definition: pcb_painter.h:172
double m_viaOpacity
Opacity override for all types of via.
Definition: pcb_painter.h:169
ZONE_DISPLAY_MODE m_ZoneDisplayMode
Definition: pcb_painter.h:146
void LoadColors(const COLOR_SETTINGS *aSettings) override
double m_padOpacity
Opacity override for SMD pads and PTHs.
Definition: pcb_painter.h:170
void SetBackgroundColor(const COLOR4D &aColor) override
Set the background color.
Definition: pcb_painter.h:125
COLOR4D GetColor(const VIEW_ITEM *aItem, int aLayer) const override
Returns the color that should be used to draw the specific VIEW_ITEM on the specific layer using curr...
HIGH_CONTRAST_MODE m_ContrastModeDisplay
Definition: pcb_painter.h:147
std::map< int, KIGFX::COLOR4D > m_netColors
Set of net codes that should not have their ratsnest displayed.
Definition: pcb_painter.h:162
NET_COLOR_MODE m_netColorMode
Overrides for specific netclass colors.
Definition: pcb_painter.h:156
static const double MAX_FONT_SIZE
< Maximum font size for netnames (and other dynamically shown strings)
Definition: pcb_painter.h:153
double m_filledShapeOpacity
Opacity override for graphic shapes.
Definition: pcb_painter.h:173
bool GetShowPageLimits() const override
void LoadDisplayOptions(const PCB_DISPLAY_OPTIONS &aOptions)
Load settings related to display options (high-contrast mode, full or outline modes for vias/pads/tra...
PCB_LAYER_ID GetPrimaryHighContrastLayer() const
Return the board layer which is in high-contrast mode.
void SetGapLengthRatio(double aRatio)
const wxString & GetDefaultFont() const
const COLOR4D & GetLayerColor(int aLayer) const
Return the color used to draw a layer.
PCB_LAYER_ID GetActiveLayer() const
std::map< int, COLOR4D > m_layerColorsHi
virtual void update()
Precalculates extra colors for layers (e.g.
void SetDashLengthRatio(double aRatio)
std::set< int > m_highlightNetcodes
std::map< int, COLOR4D > m_layerColorsDark
std::map< int, COLOR4D > m_layerColorsSel
std::set< int > m_highContrastLayers
std::map< int, COLOR4D > m_layerColors
bool m_hiContrastEnabled
Parameters for display modes.
bool GetDrawBoundingBoxes() const
An abstract base class for deriving all objects that can be added to a VIEW.
Definition: view_item.h:86
bool IsBOARD_ITEM() const
Definition: view_item.h:102
double GetForcedTransparency() const
Definition: view_item.h:165
LSET is a set of PCB_LAYER_IDs.
Definition: lset.h:37
PCB_LAYER_ID ExtractLayer() const
Find the first set PCB_LAYER_ID.
Definition: lset.cpp:526
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Return a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:583
LSEQ Seq(const LSEQ &aSequence) const
Return an LSEQ from the union of this LSET and a desired sequence.
Definition: lset.cpp:297
static const LSET & PhysicalLayersMask()
Return a mask holding all layers which are physically realized.
Definition: lset.cpp:683
int MarkerScale() const
The scaling factor to convert polygonal shape coordinates to internal units.
Definition: marker_base.h:69
void ShapeToPolygon(SHAPE_LINE_CHAIN &aPolygon, int aScale=-1) const
Return the shape polygon in internal units in a SHAPE_LINE_CHAIN the coordinates are relatives to the...
VECTOR2< T > GetScale() const
Get the scale components of the matrix.
Definition: matrix3x3.h:295
A collection of nets and the parameters used to route or test these nets.
Definition: netclass.h:45
COLOR4D GetPcbColor(bool aIsForSave=false) const
Definition: netclass.h:186
bool HasPcbColor() const
Definition: netclass.h:185
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
Definition: netinfo.h:381
Definition: pad.h:54
int GetOwnClearance(PCB_LAYER_ID aLayer, wxString *aSource=nullptr) const override
Return the pad's "own" clearance in internal units.
Definition: pad.cpp:1134
LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
Definition: pad.h:437
const std::vector< std::shared_ptr< PCB_SHAPE > > & GetPrimitives(PCB_LAYER_ID aLayer) const
Accessor to the basic shape list for custom-shaped pads.
Definition: pad.h:365
int GetSizeX() const
Definition: pad.h:280
bool FlashLayer(int aLayer, bool aOnlyCheckIfPermitted=false) const
Check to see whether the pad should be flashed on the specific layer.
Definition: pad.cpp:356
virtual std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer, FLASHING flashPTHPads=FLASHING::DEFAULT) const override
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
Definition: pad.cpp:526
const BOX2I GetBoundingBox() const override
The bounding box is cached, so this will be efficient most of the time.
Definition: pad.cpp:850
PAD_ATTRIB GetAttribute() const
Definition: pad.h:440
const wxString & GetPinFunction() const
Definition: pad.h:147
const wxString & GetNumber() const
Definition: pad.h:136
bool IsNoConnectPad() const
Definition: pad.cpp:272
PAD_SHAPE GetShape(PCB_LAYER_ID aLayer) const
Definition: pad.h:195
void TransformShapeToPolygon(SHAPE_POLY_SET &aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc=ERROR_INSIDE, bool ignoreLineWidth=false) const override
Convert the pad shape to a closed polygon.
Definition: pad.cpp:1987
int GetSolderMaskExpansion(PCB_LAYER_ID aLayer) const
Definition: pad.cpp:1160
bool IsFreePad() const
Definition: pad.cpp:278
EDA_ANGLE GetOrientation() const
Return the rotation angle of the pad.
Definition: pad.h:408
PAD_DRILL_SHAPE GetDrillShape() const
Definition: pad.h:422
int GetSizeY() const
Definition: pad.h:291
VECTOR2I GetSolderPasteMargin(PCB_LAYER_ID aLayer) const
Usually < 0 (mask shape smaller than pad)because the margin can be dependent on the pad size,...
Definition: pad.cpp:1215
VECTOR2I ShapePos(PCB_LAYER_ID aLayer) const
Definition: pad.cpp:1051
std::shared_ptr< SHAPE_SEGMENT > GetEffectiveHoleShape() const override
Return a SHAPE_SEGMENT object representing the pad's hole.
Definition: pad.cpp:583
const VECTOR2I & GetSize(PCB_LAYER_ID aLayer) const
Definition: pad.h:264
DISPLAY_OPTIONS m_Display
EDA_ANGLE GetArcAngleStart() const
Definition: pcb_track.cpp:2144
double GetRadius() const
Definition: pcb_track.cpp:2127
EDA_ANGLE GetAngle() const
Definition: pcb_track.cpp:2134
const VECTOR2I & GetMid() const
Definition: pcb_track.h:344
virtual VECTOR2I GetCenter() const override
This defaults to the center of the bounding box if not overridden.
Definition: pcb_track.h:351
Abstract dimension API.
int GetLineThickness() const
const std::vector< std::shared_ptr< SHAPE > > & GetShapes() const
double m_TrackOpacity
Opacity override for all tracks.
double m_FilledShapeOpacity
Opacity override for graphic shapes.
double m_ZoneOpacity
Opacity override for filled zone areas.
double m_ImageOpacity
Opacity override for user images.
double m_PadOpacity
Opacity override for SMD pads and PTHs.
double m_ViaOpacity
Opacity override for all types of via.
HIGH_CONTRAST_MODE m_ContrastModeDisplay
How inactive layers are displayed.
NET_COLOR_MODE m_NetColorMode
How to use color overrides on specific nets and netclasses.
ZONE_DISPLAY_MODE m_ZoneDisplayMode
A set of BOARD_ITEMs (i.e., without duplicates).
Definition: pcb_group.h:53
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
Definition: pcb_group.cpp:211
std::vector< PCB_SHAPE > GetShapes1() const
Definition: pcb_marker.h:146
GAL_LAYER_ID GetColorLayer() const
Definition: pcb_marker.cpp:317
VECTOR2I GetPosition() const override
Definition: pcb_marker.h:69
std::vector< PCB_SHAPE > GetShapes2() const
Definition: pcb_marker.h:147
Object to handle a bitmap image that can be inserted in a PCB.
REFERENCE_IMAGE & GetReferenceImage()
VECTOR2I GetCenter() const override
This defaults to the center of the bounding box if not overridden.
Definition: pcb_shape.h:81
int GetWidth() const override
Definition: pcb_shape.cpp:385
bool HasSolderMask() const
Definition: pcb_shape.h:190
int GetSolderMaskExpansion() const
Definition: pcb_shape.cpp:185
virtual std::vector< VECTOR2I > GetCorners() const
Return 4 corners for a rectangle or rotated rectangle (stored as a poly).
Definition: pcb_shape.cpp:443
bool IsProxyItem() const override
Definition: pcb_shape.h:116
STROKE_PARAMS GetStroke() const override
Definition: pcb_shape.h:91
PCB_LAYER_ID GetLayer() const override
Return the primary layer this item is on.
Definition: pcb_shape.h:71
int GetRowSpan() const
Definition: pcb_tablecell.h:71
int GetColSpan() const
Definition: pcb_tablecell.h:68
std::vector< PCB_TABLECELL * > GetCells() const
Definition: pcb_table.h:150
void DrawBorders(const std::function< void(const VECTOR2I &aPt1, const VECTOR2I &aPt2, const STROKE_PARAMS &aStroke)> &aCallback) const
Definition: pcb_table.cpp:316
int GetShape() const
Definition: pcb_target.h:58
int GetWidth() const
Definition: pcb_target.h:64
int GetSize() const
Definition: pcb_target.h:61
VECTOR2I GetPosition() const override
Definition: pcb_target.h:55
bool IsBorderEnabled() const
Disables the border, this is done by changing the stroke internally.
void TransformTextToPolySet(SHAPE_POLY_SET &aBuffer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc) const
Function TransformTextToPolySet Convert the text to a polygonSet describing the actual character stro...
VECTOR2I GetDrawPos() const override
wxString GetShownText(bool aAllowExtraText, int aDepth=0) const override
Return the string actually shown after processing of the base text.
SHAPE_POLY_SET GetKnockoutCache(const KIFONT::FONT *aFont, const wxString &forResolvedText, int aMaxError) const
Definition: pcb_text.cpp:488
void TransformShapeToPolygon(SHAPE_POLY_SET &aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc, bool aIgnoreLineWidth=false) const override
Convert the item shape to a closed polygon.
Definition: pcb_text.cpp:612
wxString GetShownText(bool aAllowExtraText, int aDepth=0) const override
Return the string actually shown after processing of the base text.
Definition: pcb_text.cpp:138
EDA_ANGLE GetDrawRotation() const override
Definition: pcb_text.cpp:180
int GetSolderMaskExpansion() const
Definition: pcb_track.cpp:1133
const VECTOR2I & GetStart() const
Definition: pcb_track.h:152
const VECTOR2I & GetEnd() const
Definition: pcb_track.h:149
virtual int GetWidth() const
Definition: pcb_track.h:146
PCB_LAYER_ID BottomLayer() const
Definition: pcb_track.cpp:1390
bool FlashLayer(int aLayer) const
Check to see whether the via should have a pad on the specific layer.
Definition: pcb_track.cpp:1421
int GetWidth() const override
Definition: pcb_track.cpp:381
bool IsOnLayer(PCB_LAYER_ID aLayer) const override
Test to see if this object is on the given layer.
Definition: pcb_track.cpp:1177
PCB_LAYER_ID TopLayer() const
Definition: pcb_track.cpp:1384
int GetDrillValue() const
Calculate the drill value for vias (m_drill if > 0, or default drill value for the board).
Definition: pcb_track.cpp:632
VIATYPE GetViaType() const
Definition: pcb_track.h:450
void LayerPair(PCB_LAYER_ID *top_layer, PCB_LAYER_ID *bottom_layer) const
Return the 2 layers used by the via (the via actually uses all layers between these 2 layers)
Definition: pcb_track.cpp:1362
VIEWERS_DISPLAY_OPTIONS m_ViewersDisplay
virtual COMMON_SETTINGS * GetCommonSettings() const
Definition: pgm_base.cpp:556
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition: pgm_base.h:125
A REFERENCE_IMAGE is a wrapper around a BITMAP_IMAGE that is displayed in an editor as a reference fo...
VECTOR2I GetPosition() const
VECTOR2I GetSize() const
const BITMAP_BASE & GetImage() const
Get the underlying image.
double GetImageScale() const
Definition: seg.h:42
VECTOR2I A
Definition: seg.h:49
VECTOR2I::extended_type ecoord
Definition: seg.h:44
VECTOR2I B
Definition: seg.h:50
int Length() const
Return the length (this).
Definition: seg.h:333
ecoord SquaredLength() const
Definition: seg.h:338
T * GetAppSettings(const char *aFilename)
Return a handle to the a given settings by type.
const SHAPE_LINE_CHAIN ConvertToPolyline(int aMaxError=DefaultAccuracyForPCB(), int *aActualError=nullptr) const
Construct a SHAPE_LINE_CHAIN of segments from a given arc.
Definition: shape_arc.cpp:900
int GetRadius() const
Definition: shape_circle.h:118
const VECTOR2I GetCenter() const
Definition: shape_circle.h:123
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
int PointCount() const
Return the number of points (vertices) in this line chain.
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
Represent a set of closed polygons.
bool IsTriangulationUpToDate() const
virtual void CacheTriangulation(bool aPartition=true, bool aSimplify=false)
Build a polygon triangulation, needed to draw a polygon on OpenGL and in some other calculations.
void Fracture()
Convert a set of polygons with holes to a single outline with "slits"/"fractures" connecting the oute...
void Inflate(int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError, bool aSimplify=false)
Perform outline inflation/deflation.
int HoleCount(int aOutline) const
Returns the number of holes in a given outline.
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)
SHAPE_LINE_CHAIN & Outline(int aIndex)
Return the reference to aIndex-th outline in the set.
int NewOutline()
Creates a new empty polygon in the set and returns its index.
void Deflate(int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError)
const SHAPE_LINE_CHAIN & CHole(int aOutline, int aHole) const
int OutlineCount() const
Return the number of outlines in the set.
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
const VECTOR2I & GetPosition() const
Definition: shape_rect.h:160
const VECTOR2I GetSize() const
Definition: shape_rect.h:168
int GetWidth() const
Definition: shape_rect.h:176
int GetHeight() const
Definition: shape_rect.h:184
const SEG & GetSeg() const
int GetWidth() const
Represent a simple polygon consisting of a zero-thickness closed chain of connected line segments.
Definition: shape_simple.h:42
const SHAPE_LINE_CHAIN & Vertices() const
Return the list of vertices defining this simple polygon.
Definition: shape_simple.h:124
virtual const SEG GetSegment(int aIndex) const override
Definition: shape_simple.h:174
const VECTOR2I & CPoint(int aIndex) const
Return a const reference to a given point in the polygon.
Definition: shape_simple.h:102
int PointCount() const
Return the number of points (vertices) in this polygon.
Definition: shape_simple.h:88
virtual size_t GetSegmentCount() const override
Definition: shape_simple.h:176
An abstract shape on 2D plane.
Definition: shape.h:126
Simple container to manage line stroke parameters.
Definition: stroke_params.h:94
int GetWidth() const
LINE_STYLE GetLineStyle() const
static void Stroke(const SHAPE *aShape, LINE_STYLE aLineStyle, int aWidth, const KIGFX::RENDER_SETTINGS *aRenderSettings, const std::function< void(const VECTOR2I &a, const VECTOR2I &b)> &aStroker)
GR_TEXT_H_ALIGN_T m_Halign
GR_TEXT_V_ALIGN_T m_Valign
KIFONT::FONT * m_Font
VECTOR2< T > Resize(T aNewLength) const
Return a vector of the same direction, but length specified in aNewLength.
Definition: vector2d.h:385
Handle a list of polygons defining a copper zone.
Definition: zone.h:74
const std::vector< SEG > & GetHatchLines() const
Definition: zone.h:770
const std::shared_ptr< SHAPE_POLY_SET > & GetFilledPolysList(PCB_LAYER_ID aLayer) const
Definition: zone.h:595
SHAPE_POLY_SET * Outline()
Definition: zone.h:335
virtual bool IsOnLayer(PCB_LAYER_ID) const override
Test to see if this object is on the given layer.
Definition: zone.cpp:616
bool IsTeardropArea() const
Definition: zone.h:674
ZONE_BORDER_DISPLAY_STYLE GetHatchStyle() const
Definition: zone.h:584
@ MAGENTA
Definition: color4d.h:60
@ CYAN
Definition: color4d.h:58
void TransformArcToPolygon(SHAPE_POLY_SET &aBuffer, const VECTOR2I &aStart, const VECTOR2I &aMid, const VECTOR2I &aEnd, int aWidth, int aError, ERROR_LOC aErrorLoc)
Convert arc to multiple straight segments.
static constexpr EDA_ANGLE ANGLE_90
Definition: eda_angle.h:406
@ DEGREES_T
Definition: eda_angle.h:31
static constexpr EDA_ANGLE ANGLE_VERTICAL
Definition: eda_angle.h:401
static constexpr EDA_ANGLE ANGLE_HORIZONTAL
Definition: eda_angle.h:400
#define IGNORE_PARENT_GROUP
Definition: eda_item.h:54
FRAME_T
The set of EDA_BASE_FRAME derivatives, typically stored in EDA_BASE_FRAME::m_Ident.
Definition: frame_type.h:33
@ FRAME_PCB_EDITOR
Definition: frame_type.h:42
@ FRAME_CVPCB_DISPLAY
Definition: frame_type.h:53
@ FRAME_FOOTPRINT_VIEWER
Definition: frame_type.h:45
@ FRAME_FOOTPRINT_WIZARD
Definition: frame_type.h:46
@ FRAME_FOOTPRINT_PREVIEW
Definition: frame_type.h:48
@ FRAME_FOOTPRINT_CHOOSER
Definition: frame_type.h:44
@ FRAME_FOOTPRINT_EDITOR
Definition: frame_type.h:43
@ FRAME_PCB_DISPLAY3D
Definition: frame_type.h:47
@ FRAME_CVPCB
Definition: frame_type.h:52
a few functions useful in geometry calculations.
int GetPenSizeForNormal(int aTextSize)
Definition: gr_text.cpp:60
double m_HoleWallPaintingMultiplier
What factor to use when painting via and PTH pad hole walls, so that the painted hole wall can be ove...
bool IsSolderMaskLayer(int aLayer)
Definition: layer_ids.h:733
@ LAYER_PAD_FR_NETNAMES
Additional netnames layers (not associated with a PCB layer).
Definition: layer_ids.h:200
@ LAYER_PAD_BK_NETNAMES
Definition: layer_ids.h:201
@ LAYER_PAD_NETNAMES
Definition: layer_ids.h:202
@ NETNAMES_LAYER_ID_START
Definition: layer_ids.h:194
bool IsPcbLayer(int aLayer)
Test whether a layer is a valid layer for Pcbnew.
Definition: layer_ids.h:652
bool IsPadCopperLayer(int aLayer)
Definition: layer_ids.h:866
int GetNetnameLayer(int aLayer)
Return a netname layer corresponding to the given layer.
Definition: layer_ids.h:839
bool IsClearanceLayer(int aLayer)
Definition: layer_ids.h:878
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
Definition: layer_ids.h:663
@ GAL_LAYER_ID_START
Definition: layer_ids.h:229
@ LAYER_LOCKED_ITEM_SHADOW
Shadow layer for locked items.
Definition: layer_ids.h:306
@ LAYER_PAD_COPPER_START
Virtual layers for pad copper on a given copper layer.
Definition: layer_ids.h:331
@ LAYER_VIA_HOLEWALLS
Definition: layer_ids.h:297
@ LAYER_CONFLICTS_SHADOW
Shadow layer for items flagged conflicting.
Definition: layer_ids.h:309
@ LAYER_DRC_SHAPE1
Custom shape for DRC marker.
Definition: layer_ids.h:314
@ LAYER_NON_PLATEDHOLES
Draw usual through hole vias.
Definition: layer_ids.h:238
@ LAYER_DRC_EXCLUSION
Layer for DRC markers which have been individually excluded.
Definition: layer_ids.h:303
@ LAYER_PCB_BACKGROUND
PCB background color.
Definition: layer_ids.h:280
@ LAYER_PADS
Meta control for all pads opacity/visibility (color ignored).
Definition: layer_ids.h:291
@ LAYER_DRC_WARNING
Layer for DRC markers with #SEVERITY_WARNING.
Definition: layer_ids.h:300
@ LAYER_PAD_PLATEDHOLES
to draw pad holes (plated)
Definition: layer_ids.h:270
@ GAL_LAYER_ID_END
Definition: layer_ids.h:350
@ LAYER_VIA_COPPER_START
Virtual layers for via copper on a given copper layer.
Definition: layer_ids.h:335
@ LAYER_CLEARANCE_START
Virtual layers for pad/via/track clearance outlines for a given copper layer.
Definition: layer_ids.h:339
@ LAYER_DRC_SHAPE2
Custom shape for DRC marker.
Definition: layer_ids.h:315
@ LAYER_ZONE_START
Virtual layers for stacking zones and tracks on a given copper layer.
Definition: layer_ids.h:327
@ LAYER_ANCHOR
Anchor of items having an anchor point (texts, footprints).
Definition: layer_ids.h:247
@ LAYER_MARKER_SHADOWS
Shadows for DRC markers.
Definition: layer_ids.h:304
@ LAYER_VIA_HOLES
Draw via holes (pad holes do not use this layer).
Definition: layer_ids.h:273
@ LAYER_VIA_MICROVIA
Definition: layer_ids.h:233
@ LAYER_VIA_THROUGH
Draw blind/buried vias.
Definition: layer_ids.h:235
@ LAYER_DRC_ERROR
Layer for DRC markers with #SEVERITY_ERROR.
Definition: layer_ids.h:276
@ LAYER_VIA_BBLIND
Draw micro vias.
Definition: layer_ids.h:234
@ LAYER_PAD_HOLEWALLS
Definition: layer_ids.h:296
bool IsViaCopperLayer(int aLayer)
Definition: layer_ids.h:872
bool IsNetnameLayer(int aLayer)
Test whether a layer is a netname layer.
Definition: layer_ids.h:854
bool IsHoleLayer(int aLayer)
Definition: layer_ids.h:724
bool IsExternalCopperLayer(int aLayerId)
Test whether a layer is an external (F_Cu or B_Cu) copper layer.
Definition: layer_ids.h:674
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:60
@ F_CrtYd
Definition: layer_ids.h:116
@ Edge_Cuts
Definition: layer_ids.h:112
@ F_Paste
Definition: layer_ids.h:104
@ B_Mask
Definition: layer_ids.h:98
@ B_Cu
Definition: layer_ids.h:65
@ F_Mask
Definition: layer_ids.h:97
@ B_Paste
Definition: layer_ids.h:105
@ F_SilkS
Definition: layer_ids.h:100
@ B_CrtYd
Definition: layer_ids.h:115
@ UNDEFINED_LAYER
Definition: layer_ids.h:61
@ PCB_LAYER_ID_COUNT
Definition: layer_ids.h:171
@ F_Cu
Definition: layer_ids.h:64
bool IsZoneFillLayer(int aLayer)
Definition: layer_ids.h:860
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition: lset.cpp:747
The Cairo implementation of the graphics abstraction layer.
Definition: eda_group.h:33
PAD_DRILL_SHAPE
The set of pad drill shapes, used with PAD::{Set,Get}DrillShape()
Definition: padstack.h:69
Class to handle a set of BOARD_ITEMs.
PCBNEW_SETTINGS * pcbconfig()
Definition: pcb_painter.cpp:76
@ SHOW_WITH_VIA_ALWAYS
PGM_BASE & Pgm()
The global program "get" accessor.
Definition: pgm_base.cpp:893
PGM_BASE * PgmOrNull()
Return a reference that can be nullptr when running a shared lib from a script, not from a kicad app.
Definition: pgm_base.cpp:901
see class PGM_BASE
@ SH_RECT
axis-aligned rectangle
Definition: shape.h:47
@ SH_CIRCLE
circle
Definition: shape.h:50
@ SH_SIMPLE
simple polygon
Definition: shape.h:51
@ SH_SEGMENT
line segment
Definition: shape.h:48
wxString UnescapeString(const wxString &aSource)
int PrintableCharCount(const wxString &aString)
Return the number of printable (ie: non-formatting) chars.
LINE_STYLE
Dashed line types.
Definition: stroke_params.h:46
constexpr int MilsToIU(int mils) const
Definition: base_units.h:97
constexpr int mmToIU(double mm) const
Definition: base_units.h:92
TRACK_CLEARANCE_MODE m_TrackClearance
VECTOR2I center
int radius
VECTOR2I end
SHAPE_CIRCLE circle(c.m_circle_center, c.m_circle_radius)
int clearance
@ GR_TEXT_H_ALIGN_CENTER
@ GR_TEXT_H_ALIGN_RIGHT
@ GR_TEXT_H_ALIGN_LEFT
@ GR_TEXT_V_ALIGN_BOTTOM
@ GR_TEXT_V_ALIGN_CENTER
void RotatePoint(int *pX, int *pY, const EDA_ANGLE &aAngle)
Calculate the new point of coord coord pX, pY, for a rotation center 0, 0.
Definition: trigo.cpp:229
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
Definition: typeinfo.h:88
@ PCB_DIM_ORTHOGONAL_T
class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
Definition: typeinfo.h:105
@ PCB_DIM_LEADER_T
class PCB_DIM_LEADER, a leader dimension (graphic item)
Definition: typeinfo.h:102
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:97
@ PCB_DIM_CENTER_T
class PCB_DIM_CENTER, a center point marking (graphic item)
Definition: typeinfo.h:103
@ PCB_GROUP_T
class PCB_GROUP, a set of BOARD_ITEMs
Definition: typeinfo.h:110
@ PCB_TEXTBOX_T
class PCB_TEXTBOX, wrapped text on a layer
Definition: typeinfo.h:93
@ PCB_ZONE_T
class ZONE, a copper pour area
Definition: typeinfo.h:107
@ PCB_TEXT_T
class PCB_TEXT, text on a layer
Definition: typeinfo.h:92
@ PCB_REFERENCE_IMAGE_T
class PCB_REFERENCE_IMAGE, bitmap on a layer
Definition: typeinfo.h:89
@ PCB_FIELD_T
class PCB_FIELD, text associated with a footprint property
Definition: typeinfo.h:90
@ PCB_MARKER_T
class PCB_MARKER, a marker used to show something
Definition: typeinfo.h:99
@ PCB_TARGET_T
class PCB_TARGET, a target (graphic item)
Definition: typeinfo.h:106
@ PCB_TABLECELL_T
class PCB_TABLECELL, PCB_TEXTBOX for use in tables
Definition: typeinfo.h:95
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
Definition: typeinfo.h:86
@ PCB_DIM_ALIGNED_T
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
Definition: typeinfo.h:101
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition: typeinfo.h:87
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
Definition: typeinfo.h:98
@ PCB_TABLE_T
class PCB_TABLE, table of PCB_TABLECELLs
Definition: typeinfo.h:94
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:96
@ PCB_DIM_RADIAL_T
class PCB_DIM_RADIAL, a radius or diameter dimension
Definition: typeinfo.h:104
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:695
VECTOR2< double > VECTOR2D
Definition: vector2d.h:694