KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pcb_track.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) 2012 Jean-Pierre Charras, jp.charras at wanadoo.fr
5 * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
6 * Copyright (C) 2012 Wayne Stambaugh <[email protected]>
7 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program. If not, see <https://www.gnu.org/licenses/>.
21 */
22
23#include "pcb_track.h"
24
25#include <pcb_base_frame.h>
26#include <core/mirror.h>
28#include <bitmaps.h>
29#include <board.h>
32#include <base_units.h>
33#include <layer_range.h>
35#include <lset.h>
36#include <cstdlib>
37#include <map>
38#include <set>
39#include <string_utils.h>
40#include <view/view.h>
44#include <geometry/seg.h>
47#include <geometry/shape_arc.h>
48#include <drc/drc_engine.h>
49#include <pcb_painter.h>
50#include <pcbnew_settings.h>
51#include <trigo.h>
53#include <properties/property.h>
55
56#include <google/protobuf/any.pb.h>
57#include <api/api_enums.h>
58#include <api/api_utils.h>
59#include <api/api_pcb_utils.h>
60#include <api/board/board_types.pb.h>
61
64
66 BOARD_CONNECTED_ITEM( aParent, idtype )
67{
68 m_width = pcbIUScale.mmToIU( 0.2 ); // Gives a reasonable default width
69 m_hasSolderMask = false;
70}
71
72
74{
75 return new PCB_TRACK( *this );
76}
77
78
79void PCB_TRACK::CopyFrom( const BOARD_ITEM* aOther )
80{
81 wxCHECK( aOther && aOther->Type() == PCB_TRACE_T, /* void */ );
82 *this = *static_cast<const PCB_TRACK*>( aOther );
83}
84
85
86PCB_ARC::PCB_ARC( BOARD_ITEM* aParent, const SHAPE_ARC* aArc ) :
87 PCB_TRACK( aParent, PCB_ARC_T )
88{
89 m_Start = aArc->GetP0();
90 m_End = aArc->GetP1();
91 m_Mid = aArc->GetArcMid();
92}
93
94
95std::unique_ptr<PCB_TRACK> PCB_ARC::CreateFromThreePoints( BOARD_ITEM* aParent, const VECTOR2I& aStart,
96 const VECTOR2I& aMid, const VECTOR2I& aEnd )
97{
98 if( IsStraightArc( aStart, aMid, aEnd ) )
99 {
100 std::unique_ptr<PCB_TRACK> track = std::make_unique<PCB_TRACK>( aParent );
101
102 track->SetStart( aStart );
103 track->SetEnd( aEnd );
104 return track;
105 }
106
107 std::unique_ptr<PCB_ARC> arc = std::make_unique<PCB_ARC>( aParent );
108
109 arc->SetStart( aStart );
110 arc->SetMid( aMid );
111 arc->SetEnd( aEnd );
112 return arc;
113}
114
115
117{
118 return new PCB_ARC( *this );
119}
120
121
122void PCB_ARC::CopyFrom( const BOARD_ITEM* aOther )
123{
124 wxCHECK( aOther && aOther->Type() == PCB_ARC_T, /* void */ );
125 *this = *static_cast<const PCB_ARC*>( aOther );
126}
127
128
130 PCB_TRACK( aParent, PCB_VIA_T ),
131 m_padStack( this )
132{
134 Padstack().Drill().start = F_Cu;
135 Padstack().Drill().end = B_Cu;
137
138 m_padStack.SetUnconnectedLayerMode( UNCONNECTED_LAYER_MODE::KEEP_ALL );
139
140 // Padstack layerset is not used for vias right now
141 m_padStack.LayerSet().reset();
142
143 // For now, vias are always circles
145
147
148 m_isFree = false;
149}
150
151
152PCB_VIA::PCB_VIA( const PCB_VIA& aOther ) :
153 PCB_TRACK( aOther.GetParent(), PCB_VIA_T ),
154 m_padStack( this )
155{
156 PCB_VIA::operator=( aOther );
157
158 SetUuidDirect( aOther.m_Uuid );
159
160 for( size_t ii = 0; ii < m_zoneLayerOverrides.size(); ++ii )
161 {
162 m_zoneLayerOverrides[ii].store( aOther.m_zoneLayerOverrides[ii].load( std::memory_order_relaxed ),
163 std::memory_order_relaxed );
164 }
165}
166
167
169{
171
172 m_Start = aOther.m_Start;
173 m_End = aOther.m_End;
174
175 m_viaType = aOther.m_viaType;
176 m_padStack = aOther.m_padStack;
177 m_isFree = aOther.m_isFree;
178
179 return *this;
180}
181
182
183void PCB_VIA::CopyFrom( const BOARD_ITEM* aOther )
184{
185 wxCHECK( aOther && aOther->Type() == PCB_VIA_T, /* void */ );
186 *this = *static_cast<const PCB_VIA*>( aOther );
187}
188
189
191{
192 return new PCB_VIA( *this );
193}
194
195
196wxString PCB_VIA::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
197{
198 wxString formatStr;
199
200 switch( GetViaType() )
201 {
202 case VIATYPE::BLIND: formatStr = _( "Blind via %s on %s" ); break;
203 case VIATYPE::BURIED: formatStr = _( "Buried via %s on %s" ); break;
204 case VIATYPE::MICROVIA: formatStr = _( "Micro via %s on %s" ); break;
205 default: formatStr = _( "Via %s on %s" ); break;
206 }
207
208 return wxString::Format( formatStr, GetNetnameMsg(), LayerMaskDescribe() );
209}
210
211
213{
214 return BITMAPS::via;
215}
216
217
218bool PCB_TRACK::operator==( const BOARD_ITEM& aBoardItem ) const
219{
220 if( aBoardItem.Type() != Type() )
221 return false;
222
223 const PCB_TRACK& other = static_cast<const PCB_TRACK&>( aBoardItem );
224
225 return *this == other;
226}
227
228
229bool PCB_TRACK::operator==( const PCB_TRACK& aOther ) const
230{
231 return m_Start == aOther.m_Start
232 && m_End == aOther.m_End
233 && m_layer == aOther.m_layer
234 && m_width == aOther.m_width
237}
238
239
240double PCB_TRACK::Similarity( const BOARD_ITEM& aOther ) const
241{
242 if( aOther.Type() != Type() )
243 return 0.0;
244
245 const PCB_TRACK& other = static_cast<const PCB_TRACK&>( aOther );
246
247 double similarity = 1.0;
248
249 if( m_layer != other.m_layer )
250 similarity *= 0.9;
251
252 if( m_width != other.m_width )
253 similarity *= 0.9;
254
255 if( m_Start != other.m_Start )
256 similarity *= 0.9;
257
258 if( m_End != other.m_End )
259 similarity *= 0.9;
260
261 if( m_hasSolderMask != other.m_hasSolderMask )
262 similarity *= 0.9;
263
265 similarity *= 0.9;
266
267 return similarity;
268}
269
270
271bool PCB_ARC::operator==( const BOARD_ITEM& aBoardItem ) const
272{
273 if( aBoardItem.Type() != Type() )
274 return false;
275
276 const PCB_ARC& other = static_cast<const PCB_ARC&>( aBoardItem );
277
278 return *this == other;
279}
280
281
282bool PCB_ARC::operator==( const PCB_TRACK& aOther ) const
283{
284 if( aOther.Type() != Type() )
285 return false;
286
287 const PCB_ARC& other = static_cast<const PCB_ARC&>( aOther );
288
289 return *this == other;
290}
291
292
293bool PCB_ARC::operator==( const PCB_ARC& aOther ) const
294{
295 return m_Start == aOther.m_Start
296 && m_End == aOther.m_End
297 && m_Mid == aOther.m_Mid
298 && m_layer == aOther.m_layer
299 && GetWidth() == aOther.GetWidth()
302}
303
304
305double PCB_ARC::Similarity( const BOARD_ITEM& aOther ) const
306{
307 if( aOther.Type() != Type() )
308 return 0.0;
309
310 const PCB_ARC& other = static_cast<const PCB_ARC&>( aOther );
311
312 double similarity = 1.0;
313
314 if( m_layer != other.m_layer )
315 similarity *= 0.9;
316
317 if( GetWidth() != other.GetWidth() )
318 similarity *= 0.9;
319
320 if( m_Start != other.m_Start )
321 similarity *= 0.9;
322
323 if( m_End != other.m_End )
324 similarity *= 0.9;
325
326 if( m_Mid != other.m_Mid )
327 similarity *= 0.9;
328
329 if( m_hasSolderMask != other.m_hasSolderMask )
330 similarity *= 0.9;
331
333 similarity *= 0.9;
334
335 return similarity;
336}
337
338
339bool PCB_VIA::operator==( const BOARD_ITEM& aBoardItem ) const
340{
341 if( aBoardItem.Type() != Type() )
342 return false;
343
344 const PCB_VIA& other = static_cast<const PCB_VIA&>( aBoardItem );
345
346 return *this == other;
347}
348
349
350bool PCB_VIA::operator==( const PCB_TRACK& aOther ) const
351{
352 if( aOther.Type() != Type() )
353 return false;
354
355 const PCB_VIA& other = static_cast<const PCB_VIA&>( aOther );
356
357 return *this == other;
358}
359
360
361bool PCB_VIA::operator==( const PCB_VIA& aOther ) const
362{
363 return m_Start == aOther.m_Start
364 && m_End == aOther.m_End
365 && m_layer == aOther.m_layer
366 && m_padStack == aOther.m_padStack
367 && m_viaType == aOther.m_viaType
368 && sameZoneLayerOverrides( aOther );
369}
370
371
372bool PCB_VIA::sameZoneLayerOverrides( const PCB_VIA& aOther ) const
373{
374 for( size_t ii = 0; ii < m_zoneLayerOverrides.size(); ++ii )
375 {
376 if( m_zoneLayerOverrides[ii].load( std::memory_order_relaxed )
377 != aOther.m_zoneLayerOverrides[ii].load( std::memory_order_relaxed ) )
378 {
379 return false;
380 }
381 }
382
383 return true;
384}
385
386
387double PCB_VIA::Similarity( const BOARD_ITEM& aOther ) const
388{
389 if( aOther.Type() != Type() )
390 return 0.0;
391
392 const PCB_VIA& other = static_cast<const PCB_VIA&>( aOther );
393
394 double similarity = 1.0;
395
396 if( m_layer != other.m_layer )
397 similarity *= 0.9;
398
399 if( m_Start != other.m_Start )
400 similarity *= 0.9;
401
402 if( m_End != other.m_End )
403 similarity *= 0.9;
404
405 if( m_padStack != other.m_padStack )
406 similarity *= 0.9;
407
408 if( m_viaType != other.m_viaType )
409 similarity *= 0.9;
410
411 if( !sameZoneLayerOverrides( other ) )
412 similarity *= 0.9;
413
414 return similarity;
415}
416
417
418void PCB_VIA::SetWidth( int aWidth )
419{
420 m_padStack.SetSize( { aWidth, aWidth }, PADSTACK::ALL_LAYERS );
421 wxFAIL_MSG( wxT( "Warning: PCB_VIA::SetWidth() called without a layer argument" ) );
422}
423
424
426{
427 // This is present because of the parent class. It should never be actually called on a via.
428 wxCHECK_MSG( false, m_padStack.Size( PADSTACK::ALL_LAYERS ).x,
429 wxT( "Warning: PCB_VIA::GetWidth() called without a layer argument" ) );
430}
431
432
433void PCB_VIA::SetWidth( PCB_LAYER_ID aLayer, int aWidth )
434{
435 m_padStack.SetSize( { aWidth, aWidth }, aLayer );
436}
437
438
440{
441 return m_padStack.Size( aLayer ).x;
442}
443
444
445void PCB_TRACK::Serialize( google::protobuf::Any &aContainer ) const
446{
447 kiapi::board::types::Track track;
448
449 track.mutable_id()->set_value( m_Uuid.AsStdString() );
450 track.mutable_start()->set_x_nm( GetStart().x );
451 track.mutable_start()->set_y_nm( GetStart().y );
452 track.mutable_end()->set_x_nm( GetEnd().x );
453 track.mutable_end()->set_y_nm( GetEnd().y );
454 track.mutable_width()->set_value_nm( GetWidth() );
456 track.set_locked( IsLocked() ? kiapi::common::types::LockedState::LS_LOCKED
457 : kiapi::common::types::LockedState::LS_UNLOCKED );
458 PackNet( track.mutable_net() );
459
460 if( const BOARD* board = GetBoard() )
461 track.mutable_parent()->set_value( board->m_Uuid.AsStdString() );
462
463 if( HasSolderMask() )
464 {
465 kiapi::board::types::SolderMaskOverrides* sm = track.mutable_solder_mask();
466 sm->set_expose_copper( true );
467
468 if( GetLocalSolderMaskMargin().has_value() )
469 sm->mutable_solder_mask_margin()->set_value_nm( GetLocalSolderMaskMargin().value() );
470 }
471
472 kiapi::common::PackCustomProperties( track.mutable_custom_properties(), *this );
473
474 if( !aContainer.PackFrom( track ) )
475 wxFAIL_MSG( wxT( "Failed to pack PCB_TRACK" ) );
476}
477
478
479bool PCB_TRACK::Deserialize( const google::protobuf::Any &aContainer )
480{
481 kiapi::board::types::Track track;
482
483 if( !aContainer.UnpackTo( &track ) )
484 return false;
485
486 SetUuidDirect( KIID( track.id().value() ) );
487 SetStart( VECTOR2I( track.start().x_nm(), track.start().y_nm() ) );
488 SetEnd( VECTOR2I( track.end().x_nm(), track.end().y_nm() ) );
489 SetWidth( track.width().value_nm() );
491 UnpackNet( track.net() );
492 SetLocked( track.locked() == kiapi::common::types::LockedState::LS_LOCKED );
493 kiapi::common::UnpackCustomProperties( track.custom_properties(), *this );
494
495 if( track.has_solder_mask() )
496 {
497 SetHasSolderMask( track.solder_mask().expose_copper() );
498
499 if( track.solder_mask().has_solder_mask_margin() )
500 SetLocalSolderMaskMargin( track.solder_mask().solder_mask_margin().value_nm() );
501 else
503 }
504 else
505 {
506 SetHasSolderMask( false );
508 }
509
510 return true;
511}
512
513
514void PCB_ARC::Serialize( google::protobuf::Any &aContainer ) const
515{
516 kiapi::board::types::Arc arc;
517
518 arc.mutable_id()->set_value( m_Uuid.AsStdString() );
519 arc.mutable_start()->set_x_nm( GetStart().x );
520 arc.mutable_start()->set_y_nm( GetStart().y );
521 arc.mutable_mid()->set_x_nm( GetMid().x );
522 arc.mutable_mid()->set_y_nm( GetMid().y );
523 arc.mutable_end()->set_x_nm( GetEnd().x );
524 arc.mutable_end()->set_y_nm( GetEnd().y );
525 arc.mutable_width()->set_value_nm( GetWidth() );
527 arc.set_locked( IsLocked() ? kiapi::common::types::LockedState::LS_LOCKED
528 : kiapi::common::types::LockedState::LS_UNLOCKED );
529 PackNet( arc.mutable_net() );
530
531 if( const BOARD* board = GetBoard() )
532 arc.mutable_parent()->set_value( board->m_Uuid.AsStdString() );
533
534 if( HasSolderMask() )
535 {
536 kiapi::board::types::SolderMaskOverrides* sm = arc.mutable_solder_mask();
537 sm->set_expose_copper( true );
538
539 if( GetLocalSolderMaskMargin().has_value() )
540 sm->mutable_solder_mask_margin()->set_value_nm( GetLocalSolderMaskMargin().value() );
541 }
542
543 kiapi::common::PackCustomProperties( arc.mutable_custom_properties(), *this );
544
545 if( !aContainer.PackFrom( arc ) )
546 wxFAIL_MSG( wxT( "Failed to pack PCB_ARC" ) );
547}
548
549
550bool PCB_ARC::Deserialize( const google::protobuf::Any &aContainer )
551{
552 kiapi::board::types::Arc arc;
553
554 if( !aContainer.UnpackTo( &arc ) )
555 return false;
556
557 SetUuidDirect( KIID( arc.id().value() ) );
558 const VECTOR2I start( arc.start().x_nm(), arc.start().y_nm() );
559 const VECTOR2I mid( arc.mid().x_nm(), arc.mid().y_nm() );
560 const VECTOR2I end( arc.end().x_nm(), arc.end().y_nm() );
561
562 // The item type is fixed here, so reject points that have no arc center
563 if( IsStraightArc( start, mid, end ) )
564 return false;
565
566 SetStart( start );
567 SetMid( mid );
568 SetEnd( end );
569 SetWidth( arc.width().value_nm() );
571 UnpackNet( arc.net() );
572 SetLocked( arc.locked() == kiapi::common::types::LockedState::LS_LOCKED );
573 kiapi::common::UnpackCustomProperties( arc.custom_properties(), *this );
574
575 if( arc.has_solder_mask() )
576 {
577 SetHasSolderMask( arc.solder_mask().expose_copper() );
578
579 if( arc.solder_mask().has_solder_mask_margin() )
580 SetLocalSolderMaskMargin( arc.solder_mask().solder_mask_margin().value_nm() );
581 else
583 }
584 else
585 {
586 SetHasSolderMask( false );
588 }
589
590 return true;
591}
592
593
594void PCB_VIA::Serialize( google::protobuf::Any &aContainer ) const
595{
596 kiapi::board::types::Via via;
597 Serialize( via );
598
599 if( !aContainer.PackFrom( via ) )
600 wxFAIL_MSG( wxT( "Failed to pack PCB_VIA" ) );
601}
602
603
604void PCB_VIA::Serialize( kiapi::board::types::Via& aVia ) const
605{
606 aVia.mutable_id()->set_value( m_Uuid.AsStdString() );
607 aVia.mutable_position()->set_x_nm( GetPosition().x );
608 aVia.mutable_position()->set_y_nm( GetPosition().y );
609
610 PADSTACK padstack = Padstack();
611
612 padstack.Serialize( *aVia.mutable_pad_stack() );
613
614 // PADSTACK::m_layerSet is not used by vias
615 aVia.mutable_pad_stack()->clear_layers();
616 kiapi::board::PackLayerSet( *aVia.mutable_pad_stack()->mutable_layers(), GetLayerSet() );
617
619 aVia.set_locked( IsLocked() ? kiapi::common::types::LockedState::LS_LOCKED
620 : kiapi::common::types::LockedState::LS_UNLOCKED );
621 PackNet( aVia.mutable_net() );
622
623 if( const BOARD* board = GetBoard() )
624 aVia.mutable_parent()->set_value( board->m_Uuid.AsStdString() );
625
626 kiapi::board::PackTeardropSettings( *aVia.mutable_teardrop(), GetTeardropParams() );
627
628 aVia.set_is_free( GetIsFree() );
629
630 {
631 // Pack drops ZLO_NONE, so walking every copper layer emits only the overridden ones
632 std::map<PCB_LAYER_ID, ZONE_LAYER_OVERRIDE> overrides;
633
635 overrides[layer] = GetZoneLayerOverride( layer );
636
637 kiapi::board::PackZoneLayerOverrides( aVia.mutable_zone_layer_overrides(), overrides );
638 }
639
640 kiapi::common::PackCustomProperties( aVia.mutable_custom_properties(), *this );
641}
642
643
644bool PCB_VIA::Deserialize( const google::protobuf::Any &aContainer )
645{
646 kiapi::board::types::Via via;
647
648 if( !aContainer.UnpackTo( &via ) )
649 return false;
650
651 return Deserialize( via );
652}
653
654
655bool PCB_VIA::Deserialize( const kiapi::board::types::Via& aVia )
656{
657 SetUuidDirect( KIID( aVia.id().value() ) );
658 SetStart( VECTOR2I( aVia.position().x_nm(), aVia.position().y_nm() ) );
659 SetEnd( GetStart() );
660
661 google::protobuf::Any padStackWrapper;
662
663 if( !padStackWrapper.PackFrom( aVia.pad_stack() ) || !m_padStack.Deserialize( padStackWrapper ) )
664 return false;
665
666 // PADSTACK::m_layerSet is not used by vias
667 m_padStack.LayerSet().reset();
668
669 SetViaType( FromProtoEnum<VIATYPE>( aVia.type() ) );
670 UnpackNet( aVia.net() );
671 SetLocked( aVia.locked() == kiapi::common::types::LockedState::LS_LOCKED );
672 kiapi::common::UnpackCustomProperties( aVia.custom_properties(), *this );
673
674 if( aVia.has_teardrop() )
676 else
677 SetTeardropsEnabled( false );
678
679 SetIsFree( aVia.is_free() );
680
682
683 {
684 std::map<PCB_LAYER_ID, ZONE_LAYER_OVERRIDE> overrides;
685 kiapi::board::UnpackZoneLayerOverrides( overrides, aVia.zone_layer_overrides() );
686
687 for( const auto& [layer, value] : overrides )
688 SetZoneLayerOverride( layer, value );
689 }
690
691 return true;
692}
693
694
696{
697 SEG a( m_Start, m_End );
698 SEG b( aTrack.GetStart(), aTrack.GetEnd() );
699 return a.ApproxCollinear( b );
700}
701
702
704{
705 DRC_CONSTRAINT aggregate;
706
707 if( const BOARD* board = GetBoard() )
708 {
709 const std::shared_ptr<DRC_ENGINE>& drcEngine = board->GetDesignSettings().m_DRCEngine ;
710
711 if( drcEngine )
712 {
713 // Tracks are, at present, single layer
714 aggregate = drcEngine->EvalRules( TRACK_WIDTH_CONSTRAINT, this, nullptr, m_layer );
715 }
716 }
717
718 if( aSource )
719 *aSource = aggregate.GetName();
720
721 return aggregate.Value();
722}
723
724
726{
727 DRC_CONSTRAINT aggregate;
728
729 if( const BOARD* board = GetBoard() )
730 {
731 int layerCount = board->GetCopperLayerCount();
732 const std::shared_ptr<DRC_ENGINE>& drcEngine = board->GetDesignSettings().m_DRCEngine ;
733
734 if( drcEngine )
735 {
736 for( PCB_LAYER_ID layer : LAYER_RANGE( m_padStack.StartLayer(), m_padStack.EndLayer(), layerCount ) )
737 aggregate.Merge( drcEngine->EvalRules( VIA_DIAMETER_CONSTRAINT, this, nullptr, layer ) );
738 }
739 }
740
741 if( aSource )
742 *aSource = aggregate.GetName();
743
744 return aggregate.Value();
745}
746
747
749{
750 DRC_CONSTRAINT aggregate;
751
752 if( const BOARD* board = GetBoard() )
753 {
754 const std::shared_ptr<DRC_ENGINE>& drcEngine = board->GetDesignSettings().m_DRCEngine ;
755
756 if( drcEngine )
757 {
758 // Holes are not layer-specific, as in the hole size test
759 aggregate = drcEngine->EvalRules( HOLE_SIZE_CONSTRAINT, this, nullptr, UNDEFINED_LAYER );
760 }
761 }
762
763 if( aSource )
764 *aSource = aggregate.GetName();
765
766 return aggregate.Value();
767}
768
769
770void PCB_VIA::SetSizeFromRules( int aDiameter, int aDrill )
771{
772 // Area rules test the via's shape, so evaluate them at the preferred size
774 SetWidth( PADSTACK::ALL_LAYERS, aDiameter );
775 SetDrill( aDrill );
776
777 // Callers size vias that may still move, so keep them out of the pointer-keyed rule caches
778 bool wasTransient = HasFlag( ROUTER_TRANSIENT );
780
781 int diameter = GetWidthConstraint().PinnedOpt( aDiameter );
782 int drill = GetDrillConstraint().PinnedOpt( aDrill );
783
784 if( !wasTransient )
786
787 SetWidth( PADSTACK::ALL_LAYERS, diameter );
788 SetDrill( drill );
789}
790
791
792int PCB_VIA::GetMinAnnulus( PCB_LAYER_ID aLayer, wxString* aSource ) const
793{
794 if( !FlashLayer( aLayer ) )
795 {
796 if( aSource )
797 *aSource = _( "removed annular ring" );
798
799 return 0;
800 }
801
802 DRC_CONSTRAINT constraint;
803
804 if( const BOARD* board = GetBoard() )
805 {
806 const std::shared_ptr<DRC_ENGINE>& drcEngine = board->GetDesignSettings().m_DRCEngine ;
807
808 if( drcEngine )
809 constraint = drcEngine->EvalRules( ANNULAR_WIDTH_CONSTRAINT, this, nullptr, aLayer );
810 }
811
812 if( constraint.Value().HasMin() )
813 {
814 if( aSource )
815 *aSource = constraint.GetName();
816
817 return constraint.Value().Min();
818 }
819
820 return 0;
821}
822
823
825{
826 m_padStack.Drill().size = aSize;
827}
828
829
831{
832 m_padStack.Drill().shape = aShape;
833}
834
835
837{
838 m_padStack.Drill().start = aLayer;
839}
840
841
843{
844 m_padStack.Drill().end = aLayer;
845}
846
847
848void PCB_VIA::SetFrontPostMachining( const std::optional<PAD_DRILL_POST_MACHINING_MODE>& aMode )
849{
850 m_padStack.FrontPostMachining().mode = aMode;
851}
852
853
854void PCB_VIA::SetBackPostMachining( const std::optional<PAD_DRILL_POST_MACHINING_MODE>& aMode )
855{
856 m_padStack.BackPostMachining().mode = aMode;
857}
858
859
860void PCB_VIA::SetPrimaryDrillFilled( const std::optional<bool>& aFilled )
861{
862 m_padStack.Drill().is_filled = aFilled;
863}
864
865
867{
868 m_padStack.Drill().is_filled = aFilled;
869}
870
871
872void PCB_VIA::SetPrimaryDrillCapped( const std::optional<bool>& aCapped )
873{
874 m_padStack.Drill().is_capped = aCapped;
875}
876
877
879{
880 m_padStack.Drill().is_capped = aCapped;
881}
882
883
884// Two microvias belong to one structure when the upper one lands on the lower one. Exact
885// concentricity is only the extreme case of that, so the test is hole overlap.
886std::vector<std::vector<PCB_VIA*>> PCB_VIA::CollectMicroviaColumns( BOARD* aBoard )
887{
888 std::map<int, int> ordinals;
889 int n = 0;
890
891 for( PCB_LAYER_ID layer : LAYER_RANGE( F_Cu, B_Cu, aBoard->GetCopperLayerCount() ) )
892 ordinals[layer] = n++;
893
894 std::vector<PCB_VIA*> microvias;
895
896 for( PCB_TRACK* track : aBoard->Tracks() )
897 {
898 if( track->Type() != PCB_VIA_T )
899 continue;
900
901 PCB_VIA* via = static_cast<PCB_VIA*>( track );
902
903 if( via->GetViaType() != VIATYPE::MICROVIA )
904 continue;
905
906 // A via on a single layer lands on nothing.
907 if( via->TopLayer() == via->BottomLayer() )
908 continue;
909
910 if( ordinals.count( via->TopLayer() ) && ordinals.count( via->BottomLayer() ) )
911 microvias.push_back( via );
912 }
913
914 auto upper =
915 [&]( PCB_VIA* aVia )
916 {
917 return std::min( ordinals[aVia->TopLayer()], ordinals[aVia->BottomLayer()] );
918 };
919
920 auto lower =
921 [&]( PCB_VIA* aVia )
922 {
923 return std::max( ordinals[aVia->TopLayer()], ordinals[aVia->BottomLayer()] );
924 };
925
926 // Touching holes have no wall between them, so they count as one column too.
927 auto overlaps =
928 []( PCB_VIA* aFirst, PCB_VIA* aSecond )
929 {
930 double reach = ( aFirst->GetDrillValue() + aSecond->GetDrillValue() ) / 2.0;
931
932 return ( aFirst->GetPosition() - aSecond->GetPosition() ).EuclideanNorm() <= reach;
933 };
934
935 // Overlap needs the centres closer than the largest hole, so bucket the vias by landing
936 // layer and position and only the neighbouring buckets have to be looked at.
937 int cellSize = 1;
938
939 for( PCB_VIA* via : microvias )
940 cellSize = std::max( cellSize, via->GetDrillValue() );
941
942 auto cellOf =
943 [&]( int aCoord )
944 {
945 return (int) std::floor( (double) aCoord / cellSize );
946 };
947
948 std::map<std::tuple<int, int, int>, std::vector<PCB_VIA*>> byCell;
949
950 for( PCB_VIA* via : microvias )
951 {
952 VECTOR2I pos = via->GetPosition();
953 byCell[{ upper( via ), cellOf( pos.x ), cellOf( pos.y ) }].push_back( via );
954 }
955
956 // The via a given one lands on, if any.
957 auto below =
958 [&]( PCB_VIA* aVia ) -> PCB_VIA*
959 {
960 VECTOR2I pos = aVia->GetPosition();
961
962 for( int dx = -1; dx <= 1; ++dx )
963 {
964 for( int dy = -1; dy <= 1; ++dy )
965 {
966 auto it = byCell.find( { lower( aVia ), cellOf( pos.x ) + dx, cellOf( pos.y ) + dy } );
967
968 if( it == byCell.end() )
969 continue;
970
971 for( PCB_VIA* other : it->second )
972 {
973 if( other != aVia && overlaps( aVia, other ) )
974 return other;
975 }
976 }
977 }
978
979 return nullptr;
980 };
981
982 std::set<PCB_VIA*> carried;
983
984 for( PCB_VIA* via : microvias )
985 {
986 if( PCB_VIA* under = below( via ) )
987 carried.insert( under );
988 }
989
990 std::vector<std::vector<PCB_VIA*>> columns;
991 std::set<PCB_VIA*> taken;
992
993 for( PCB_VIA* via : microvias )
994 {
995 // Walk down from the top of each structure so every one is built once.
996 if( carried.count( via ) )
997 continue;
998
999 std::vector<PCB_VIA*> column;
1000 bool landsOnAnother = false;
1001
1002 for( PCB_VIA* step = via; step; step = below( step ) )
1003 {
1004 if( !taken.insert( step ).second )
1005 {
1006 landsOnAnother = true;
1007 break;
1008 }
1009
1010 column.push_back( step );
1011
1012 if( column.size() > ordinals.size() )
1013 break;
1014 }
1015
1016 if( column.size() > 1 || landsOnAnother )
1017 columns.push_back( std::move( column ) );
1018 }
1019
1020 return columns;
1021}
1022
1023
1025{
1026 if( m_padStack.Drill().size.x > 0 ) // Use the specific value.
1027 return m_padStack.Drill().size.x;
1028
1029 // Use the default value from the Netclass
1030 NETCLASS* netclass = GetEffectiveNetClass();
1031
1032 if( GetViaType() == VIATYPE::MICROVIA )
1033 return netclass->GetuViaDrill();
1034
1035 return netclass->GetViaDrill();
1036}
1037
1038
1040{
1041 m_padStack.SecondaryDrill().size = aSize;
1042}
1043
1044
1046{
1047 m_padStack.SecondaryDrill().size = { 0, 0 };
1048}
1049
1050
1051void PCB_VIA::SetSecondaryDrillSize( const std::optional<int>& aDrill )
1052{
1053 if( aDrill.has_value() && *aDrill > 0 )
1054 SetSecondaryDrillSize( { *aDrill, *aDrill } );
1055 else
1057}
1058
1059
1060std::optional<int> PCB_VIA::GetSecondaryDrillSize() const
1061{
1062 if( m_padStack.SecondaryDrill().size.x > 0 )
1063 return m_padStack.SecondaryDrill().size.x;
1064
1065 return std::nullopt;
1066}
1067
1068
1070{
1071 m_padStack.SecondaryDrill().start = aLayer;
1072
1073 if( aLayer == UNDEFINED_LAYER )
1074 m_padStack.SecondaryDrill().size = VECTOR2I( 0, 0 );
1075}
1076
1077
1079{
1080 m_padStack.SecondaryDrill().end = aLayer;
1081}
1082
1083
1085{
1086 m_padStack.SecondaryDrill().shape = aShape;
1087}
1088
1089
1091{
1092 m_padStack.TertiaryDrill().size = aSize;
1093}
1094
1095
1097{
1098 m_padStack.TertiaryDrill().size = { 0, 0 };
1099}
1100
1101
1102void PCB_VIA::SetTertiaryDrillSize( const std::optional<int>& aDrill )
1103{
1104 if( aDrill.has_value() && *aDrill > 0 )
1105 SetTertiaryDrillSize( { *aDrill, *aDrill } );
1106 else
1108}
1109
1110
1111std::optional<int> PCB_VIA::GetTertiaryDrillSize() const
1112{
1113 if( m_padStack.TertiaryDrill().size.x > 0 )
1114 return m_padStack.TertiaryDrill().size.x;
1115
1116 return std::nullopt;
1117}
1118
1119
1121{
1122 m_padStack.TertiaryDrill().start = aLayer;
1123
1124 if( aLayer == UNDEFINED_LAYER )
1125 m_padStack.TertiaryDrill().size = VECTOR2I( 0, 0 );
1126}
1127
1128
1130{
1131 m_padStack.TertiaryDrill().end = aLayer;
1132}
1133
1134
1136{
1137 m_padStack.TertiaryDrill().shape = aShape;
1138}
1139
1140
1142{
1143 return GetBackdrillOrPostMachiningKnockout( aLayer ) > 0;
1144}
1145
1146
1148{
1149 int knockout = GetBackdrillOrPostMachiningKnockout( aLayer );
1150
1151 return knockout > 0 && knockout >= GetWidth( aLayer );
1152}
1153
1154
1156{
1157 const BOARD* board = GetBoard();
1158
1159 if( !IsCopperLayer( aLayer ) || !board )
1160 return 0;
1161
1162 return m_padStack.MachiningKnockout( *board, aLayer );
1163}
1164
1165
1167{
1168 const BOARD* board = GetBoard();
1169
1170 if( !IsCopperLayer( aLayer ) || !board )
1171 return 0;
1172
1173 return m_padStack.PostMachiningKnockout( board->GetDesignSettings().GetStackupDescriptor(), aLayer );
1174}
1175
1176
1177EDA_ITEM_FLAGS PCB_TRACK::IsPointOnEnds( const VECTOR2I& point, int min_dist ) const
1178{
1180
1181 if( min_dist < 0 )
1182 min_dist = m_width / 2;
1183
1184 if( min_dist == 0 )
1185 {
1186 if( m_Start == point )
1187 result |= STARTPOINT;
1188
1189 if( m_End == point )
1190 result |= ENDPOINT;
1191 }
1192 else
1193 {
1194 double dist = m_Start.Distance( point );
1195
1196 if( min_dist >= dist )
1197 result |= STARTPOINT;
1198
1199 dist = m_End.Distance( point );
1200
1201 if( min_dist >= dist )
1202 result |= ENDPOINT;
1203 }
1204
1205 return result;
1206}
1207
1208
1210{
1211 // end of track is round, this is its radius, rounded up
1212 int radius = ( m_width + 1 ) / 2;
1213 int ymax, xmax, ymin, xmin;
1214
1215 if( Type() == PCB_ARC_T )
1216 {
1217 std::shared_ptr<SHAPE> arc = GetEffectiveShape();
1218 BOX2I bbox = arc->BBox();
1219
1220 xmin = bbox.GetLeft();
1221 xmax = bbox.GetRight();
1222 ymin = bbox.GetTop();
1223 ymax = bbox.GetBottom();
1224 }
1225 else
1226 {
1227 ymax = std::max( m_Start.y, m_End.y );
1228 xmax = std::max( m_Start.x, m_End.x );
1229
1230 ymin = std::min( m_Start.y, m_End.y );
1231 xmin = std::min( m_Start.x, m_End.x );
1232 }
1233
1234 ymax += radius;
1235 xmax += radius;
1236
1237 ymin -= radius;
1238 xmin -= radius;
1239
1240 // return a rectangle which is [pos,dim) in nature. therefore the +1
1241 return BOX2ISafe( VECTOR2I( xmin, ymin ),
1242 VECTOR2L( (int64_t) xmax - xmin + 1, (int64_t) ymax - ymin + 1 ) );
1243}
1244
1245
1247{
1248 int diameter = 0;
1249
1251 [&]( PCB_LAYER_ID aLayer )
1252 {
1253 if( IsGhostLayer( aLayer ) )
1254 return;
1255
1256 diameter = std::max( diameter, GetWidth( aLayer ) );
1257 } );
1258
1259 diameter = std::max( diameter, Padstack().GetMaxHoleSize() );
1260
1261 // via is round, this is its radius, rounded up
1262 int radius = ( diameter + 1 ) / 2;
1263
1264 int ymax = m_Start.y + radius;
1265 int xmax = m_Start.x + radius;
1266
1267 int ymin = m_Start.y - radius;
1268 int xmin = m_Start.x - radius;
1269
1270 // return a rectangle which is [pos,dim) in nature. therefore the +1
1271 return BOX2ISafe( VECTOR2I( xmin, ymin ),
1272 VECTOR2L( (int64_t) xmax - xmin + 1, (int64_t) ymax - ymin + 1 ) );
1273}
1274
1275
1277{
1278 int diameter = GetWidth( aLayer );
1279
1280 if( IsBackdrilledOrPostMachined( aLayer ) )
1281 diameter = std::max( diameter, Padstack().GetMaxHoleSize() );
1282
1283 // via is round, this is its radius, rounded up
1284 int radius = ( diameter + 1 ) / 2;
1285
1286 int ymax = m_Start.y + radius;
1287 int xmax = m_Start.x + radius;
1288
1289 int ymin = m_Start.y - radius;
1290 int xmin = m_Start.x - radius;
1291
1292 // return a rectangle which is [pos,dim) in nature. therefore the +1
1293 return BOX2ISafe( VECTOR2I( xmin, ymin ),
1294 VECTOR2L( (int64_t) xmax - xmin + 1, (int64_t) ymax - ymin + 1 ) );
1295}
1296
1297
1299{
1300 return m_Start.Distance( m_End );
1301}
1302
1303
1305{
1306 const BOARD* board = GetBoard();
1307
1308 if( !board )
1309 return 0.0;
1310
1311 const LENGTH_DELAY_CALCULATION* calc = board->GetLengthCalculation();
1312 std::vector<LENGTH_DELAY_CALCULATION_ITEM> items{ calc->GetLengthCalculationItem( this ) };
1313 constexpr PATH_OPTIMISATIONS opts = { .OptimiseVias = false,
1314 .MergeTracks = false,
1315 .OptimiseTracesInPads = false,
1316 .InferViaInPad = false
1317 };
1318
1319 return (double) calc->CalculateDelay( items, opts );
1320}
1321
1322
1323void PCB_TRACK::Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle )
1324{
1325 RotatePoint( m_Start, aRotCentre, aAngle );
1326 RotatePoint( m_End, aRotCentre, aAngle );
1327}
1328
1329
1330void PCB_ARC::Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle )
1331{
1332 RotatePoint( m_Start, aRotCentre, aAngle );
1333 RotatePoint( m_End, aRotCentre, aAngle );
1334 RotatePoint( m_Mid, aRotCentre, aAngle );
1335}
1336
1337
1338void PCB_TRACK::Mirror( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
1339{
1340 Mirror( MIRROR_AXIS( aCentre, aFlipDirection ) );
1341}
1342
1343
1344void PCB_TRACK::Mirror( const SEG& aAxis )
1345{
1346 m_Start = aAxis.ReflectPoint( m_Start );
1347 m_End = aAxis.ReflectPoint( m_End );
1348}
1349
1350
1351void PCB_ARC::Mirror( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
1352{
1353 Mirror( MIRROR_AXIS( aCentre, aFlipDirection ) );
1354}
1355
1356
1357void PCB_ARC::Mirror( const SEG& aAxis )
1358{
1359 m_Start = aAxis.ReflectPoint( m_Start );
1360 m_End = aAxis.ReflectPoint( m_End );
1361 m_Mid = aAxis.ReflectPoint( m_Mid );
1362}
1363
1364
1365void PCB_TRACK::Flip( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
1366{
1367 if( aFlipDirection == FLIP_DIRECTION::LEFT_RIGHT )
1368 {
1369 m_Start.x = aCentre.x - ( m_Start.x - aCentre.x );
1370 m_End.x = aCentre.x - ( m_End.x - aCentre.x );
1371 }
1372 else
1373 {
1374 m_Start.y = aCentre.y - ( m_Start.y - aCentre.y );
1375 m_End.y = aCentre.y - ( m_End.y - aCentre.y );
1376 }
1377
1379}
1380
1381
1382void PCB_ARC::Flip( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
1383{
1384 if( aFlipDirection == FLIP_DIRECTION::LEFT_RIGHT )
1385 {
1386 m_Start.x = aCentre.x - ( m_Start.x - aCentre.x );
1387 m_End.x = aCentre.x - ( m_End.x - aCentre.x );
1388 m_Mid.x = aCentre.x - ( m_Mid.x - aCentre.x );
1389 }
1390 else
1391 {
1392 m_Start.y = aCentre.y - ( m_Start.y - aCentre.y );
1393 m_End.y = aCentre.y - ( m_End.y - aCentre.y );
1394 m_Mid.y = aCentre.y - ( m_Mid.y - aCentre.y );
1395 }
1396
1398}
1399
1400
1401bool PCB_ARC::IsCCW() const
1402{
1403 VECTOR2L start = m_Start;
1404 VECTOR2L start_end = m_End - start;
1405 VECTOR2L start_mid = m_Mid - start;
1406
1407 return start_end.Cross( start_mid ) < 0;
1408}
1409
1410
1411void PCB_VIA::Flip( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
1412{
1413 if( aFlipDirection == FLIP_DIRECTION::LEFT_RIGHT )
1414 {
1415 m_Start.x = aCentre.x - ( m_Start.x - aCentre.x );
1416 m_End.x = aCentre.x - ( m_End.x - aCentre.x );
1417 }
1418 else
1419 {
1420 m_Start.y = aCentre.y - ( m_Start.y - aCentre.y );
1421 m_End.y = aCentre.y - ( m_End.y - aCentre.y );
1422 }
1423
1424 if( GetViaType() != VIATYPE::THROUGH )
1425 {
1426 PCB_LAYER_ID top_layer;
1427 PCB_LAYER_ID bottom_layer;
1428 LayerPair( &top_layer, &bottom_layer );
1429 top_layer = GetFlippedLayer( top_layer );
1430 bottom_layer = GetFlippedLayer( bottom_layer );
1431 SetLayerPair( top_layer, bottom_layer );
1432 }
1433}
1434
1435
1436INSPECT_RESULT PCB_TRACK::Visit( INSPECTOR inspector, void* testData, const std::vector<KICAD_T>& aScanTypes )
1437{
1438 for( KICAD_T scanType : aScanTypes )
1439 {
1440 if( scanType == Type() )
1441 {
1442 if( INSPECT_RESULT::QUIT == inspector( this, testData ) )
1443 return INSPECT_RESULT::QUIT;
1444 }
1445 }
1446
1448}
1449
1450
1451std::shared_ptr<SHAPE_SEGMENT> PCB_VIA::GetEffectiveHoleShape( PCB_LAYER_ID aLayer, DRC_CONSTRAINT_T aUsage ) const
1452{
1453 // An unset padstack drill falls back to the netclass value
1454 int holeSize = GetDrillValue();
1455
1456 // See if we want to include a larger backdrill or post-machining hole
1457 if( aUsage == HOLE_TO_HOLE_CONSTRAINT
1458 || ( aUsage == HOLE_CLEARANCE_CONSTRAINT && IsBackdrilledOrPostMachined( aLayer ) )
1459 || ( aUsage == ANNULAR_WIDTH_CONSTRAINT && IsBackdrilledOrPostMachined( aLayer ) )
1461 || ( aUsage == SILK_CLEARANCE_CONSTRAINT && IsBackdrilledOrPostMachined( aLayer ) ) )
1462 {
1463 holeSize = std::max( holeSize, Padstack().GetMaxHoleSize() );
1464 }
1465
1466 return std::make_shared<SHAPE_SEGMENT>( SEG( m_Start, m_Start ), holeSize );
1467}
1468
1469// clang-format off: the suggestion is slightly less readable
1471{
1472 switch( aMode )
1473 {
1474 case TENTING_MODE::FROM_BOARD: m_padStack.FrontOuterLayers().has_solder_mask.reset(); break;
1475 case TENTING_MODE::TENTED: m_padStack.FrontOuterLayers().has_solder_mask = true; break;
1476 case TENTING_MODE::NOT_TENTED: m_padStack.FrontOuterLayers().has_solder_mask = false; break;
1477 }
1478}
1479
1480
1482{
1483 if( m_padStack.FrontOuterLayers().has_solder_mask.has_value() )
1484 {
1485 return *m_padStack.FrontOuterLayers().has_solder_mask ? TENTING_MODE::TENTED
1487 }
1488
1490}
1491
1492
1494{
1496 {
1497 if( GetBoard() && GetBoard()->GetDesignSettings().m_TentViasFront )
1498 return TENTING_MODE::TENTED;
1499 else
1501 }
1502
1503 return GetFrontTentingMode();
1504}
1505
1506
1508{
1509 switch( aMode )
1510 {
1511 case TENTING_MODE::FROM_BOARD: m_padStack.BackOuterLayers().has_solder_mask.reset(); break;
1512 case TENTING_MODE::TENTED: m_padStack.BackOuterLayers().has_solder_mask = true; break;
1513 case TENTING_MODE::NOT_TENTED: m_padStack.BackOuterLayers().has_solder_mask = false; break;
1514 }
1515}
1516
1517
1519{
1520 if( m_padStack.BackOuterLayers().has_solder_mask.has_value() )
1521 {
1522 return *m_padStack.BackOuterLayers().has_solder_mask ? TENTING_MODE::TENTED
1524 }
1525
1527}
1528
1529
1531{
1533 {
1534 if( GetBoard() && GetBoard()->GetDesignSettings().m_TentViasBack )
1535 return TENTING_MODE::TENTED;
1536 else
1538 }
1539
1540 return GetBackTentingMode();
1541}
1542
1543
1545{
1546 switch( aMode )
1547 {
1548 case COVERING_MODE::FROM_BOARD: m_padStack.FrontOuterLayers().has_covering.reset(); break;
1549 case COVERING_MODE::COVERED: m_padStack.FrontOuterLayers().has_covering = true; break;
1550 case COVERING_MODE::NOT_COVERED: m_padStack.FrontOuterLayers().has_covering = false; break;
1551 }
1552}
1553
1554
1556{
1557 if( m_padStack.FrontOuterLayers().has_covering.has_value() )
1558 {
1559 return *m_padStack.FrontOuterLayers().has_covering ? COVERING_MODE::COVERED
1561 }
1562
1564}
1565
1566
1568{
1570 {
1571 if( GetBoard() && GetBoard()->GetDesignSettings().m_CoverViasFront )
1573 else
1575 }
1576
1577 return GetFrontCoveringMode();
1578}
1579
1580
1582{
1583 switch( aMode )
1584 {
1585 case COVERING_MODE::FROM_BOARD: m_padStack.BackOuterLayers().has_covering.reset(); break;
1586 case COVERING_MODE::COVERED: m_padStack.BackOuterLayers().has_covering = true; break;
1587 case COVERING_MODE::NOT_COVERED: m_padStack.BackOuterLayers().has_covering = false; break;
1588 }
1589}
1590
1591
1593{
1594 if( m_padStack.BackOuterLayers().has_covering.has_value() )
1595 {
1596 return *m_padStack.BackOuterLayers().has_covering ? COVERING_MODE::COVERED
1598 }
1599
1601}
1602
1603
1605{
1607 {
1608 if( GetBoard() && GetBoard()->GetDesignSettings().m_CoverViasBack )
1610 else
1612 }
1613
1614 return GetBackCoveringMode();
1615}
1616
1617
1619{
1620 switch( aMode )
1621 {
1622 case PLUGGING_MODE::FROM_BOARD: m_padStack.FrontOuterLayers().has_plugging.reset(); break;
1623 case PLUGGING_MODE::PLUGGED: m_padStack.FrontOuterLayers().has_plugging = true; break;
1624 case PLUGGING_MODE::NOT_PLUGGED: m_padStack.FrontOuterLayers().has_plugging = false; break;
1625 }
1626}
1627
1628
1630{
1631 if( m_padStack.FrontOuterLayers().has_plugging.has_value() )
1632 {
1633 return *m_padStack.FrontOuterLayers().has_plugging ? PLUGGING_MODE::PLUGGED
1635 }
1636
1638}
1639
1640
1642{
1644 {
1645 if( GetBoard() && GetBoard()->GetDesignSettings().m_PlugViasFront )
1647 else
1649 }
1650
1651 return GetFrontPluggingMode();
1652}
1653
1654
1656{
1657 switch( aMode )
1658 {
1659 case PLUGGING_MODE::FROM_BOARD: m_padStack.BackOuterLayers().has_plugging.reset(); break;
1660 case PLUGGING_MODE::PLUGGED: m_padStack.BackOuterLayers().has_plugging = true; break;
1661 case PLUGGING_MODE::NOT_PLUGGED: m_padStack.BackOuterLayers().has_plugging = false; break;
1662 }
1663}
1664
1665
1667{
1668 if( m_padStack.BackOuterLayers().has_plugging.has_value() )
1669 {
1670 return *m_padStack.BackOuterLayers().has_plugging ? PLUGGING_MODE::PLUGGED
1672 }
1673
1675}
1676
1677
1679{
1681 {
1682 if( GetBoard() && GetBoard()->GetDesignSettings().m_PlugViasBack )
1684 else
1686 }
1687
1688 return GetBackPluggingMode();
1689}
1690
1691
1693{
1694 switch( aMode )
1695 {
1696 case CAPPING_MODE::FROM_BOARD: m_padStack.Drill().is_capped.reset(); break;
1697 case CAPPING_MODE::CAPPED: m_padStack.Drill().is_capped = true; break;
1698 case CAPPING_MODE::NOT_CAPPED: m_padStack.Drill().is_capped = false; break;
1699 }
1700}
1701
1702
1704{
1705 if( m_padStack.Drill().is_capped.has_value() )
1706 {
1707 return *m_padStack.Drill().is_capped ? CAPPING_MODE::CAPPED
1709 }
1710
1712}
1713
1714
1716{
1718 {
1719 if( GetBoard() && GetBoard()->GetDesignSettings().m_CapVias )
1720 return CAPPING_MODE::CAPPED;
1721 else
1723 }
1724
1725 return GetCappingMode();
1726}
1727
1728
1730{
1731 switch( aMode )
1732 {
1733 case FILLING_MODE::FROM_BOARD: m_padStack.Drill().is_filled.reset(); break;
1734 case FILLING_MODE::FILLED: m_padStack.Drill().is_filled = true; break;
1735 case FILLING_MODE::NOT_FILLED: m_padStack.Drill().is_filled = false; break;
1736 }
1737}
1738
1739
1741{
1742 if( m_padStack.Drill().is_filled.has_value() )
1743 {
1744 return *m_padStack.Drill().is_filled ? FILLING_MODE::FILLED
1746 }
1747
1749}
1750
1751
1753{
1755 {
1756 if( GetBoard() && GetBoard()->GetDesignSettings().m_FillVias )
1757 return FILLING_MODE::FILLED;
1758 else
1760 }
1761
1762 return GetFillingMode();
1763}
1764
1765
1767{
1768 wxCHECK_MSG( IsFrontLayer( aLayer ) || IsBackLayer( aLayer ), true, "Invalid layer passed to IsTented" );
1769
1770 bool front = IsFrontLayer( aLayer );
1771
1772 if( front && m_padStack.FrontOuterLayers().has_solder_mask.has_value() )
1773 return *m_padStack.FrontOuterLayers().has_solder_mask;
1774
1775 if( !front && m_padStack.BackOuterLayers().has_solder_mask.has_value() )
1776 return *m_padStack.BackOuterLayers().has_solder_mask;
1777
1778 if( const BOARD* board = GetBoard() )
1779 {
1780 return front ? board->GetDesignSettings().m_TentViasFront
1781 : board->GetDesignSettings().m_TentViasBack;
1782 }
1783
1784 return true;
1785}
1786
1787
1789{
1790 if( const BOARD* board = GetBoard() )
1791 return board->GetDesignSettings().m_SolderMaskExpansion;
1792 else
1793 return 0;
1794}
1795
1796
1798{
1799 int margin = 0;
1800
1801 if( GetBoard() && GetBoard()->GetDesignSettings().m_DRCEngine
1802 && GetBoard()->GetDesignSettings().m_DRCEngine->HasRulesForConstraintType( SOLDER_MASK_EXPANSION_CONSTRAINT ) )
1803 {
1804 DRC_CONSTRAINT constraint;
1805 DRC_ENGINE* drcEngine = GetBoard()->GetDesignSettings().m_DRCEngine.get();
1806
1807 constraint = drcEngine->EvalRules( SOLDER_MASK_EXPANSION_CONSTRAINT, this, nullptr, m_layer );
1808
1809 if( constraint.m_Value.HasOpt() )
1810 margin = constraint.m_Value.Opt();
1811 }
1812 else if( m_solderMaskMargin.has_value() )
1813 {
1814 margin = m_solderMaskMargin.value();
1815 }
1816 else if( const BOARD* board = GetBoard() )
1817 {
1818 margin = board->GetDesignSettings().m_SolderMaskExpansion;
1819 }
1820
1821 // Ensure the resulting mask opening has a non-negative size
1822 if( margin < 0 )
1823 margin = std::max( margin, -m_width / 2 );
1824
1825 return margin;
1826}
1827
1828
1830{
1831 if( aLayer == m_layer )
1832 {
1833 return true;
1834 }
1835
1836 if( m_hasSolderMask && ( ( aLayer == F_Mask && m_layer == F_Cu )
1837 || ( aLayer == B_Mask && m_layer == B_Cu ) ) )
1838 {
1839 return true;
1840 }
1841
1842 return false;
1843}
1844
1845
1847{
1848 if( IsCopperLayer( aLayer ) &&
1849 LAYER_RANGE::Contains( Padstack().Drill().start, Padstack().Drill().end, aLayer ) )
1850 {
1851 return true;
1852 }
1853
1854 // Test for via on mask layers: a via on on a mask layer if not tented and if
1855 // it is on the corresponding external copper layer
1856 if( aLayer == F_Mask )
1857 return Padstack().Drill().start == F_Cu && !IsTented( F_Mask );
1858 else if( aLayer == B_Mask )
1859 return Padstack().Drill().end == B_Cu && !IsTented( B_Mask );
1860
1861 return false;
1862}
1863
1864
1866{
1867 return true;
1868}
1869
1870
1871bool PCB_VIA::HasValidLayerPair( int aCopperLayerCount ) const
1872{
1873 // return true if top and bottom layers are valid, depending on the copper layer count
1874 // aCopperLayerCount is expected >= 2
1875
1876 int layer_id = aCopperLayerCount*2;
1877
1878 if( Padstack().Drill().start > B_Cu )
1879 {
1880 if( Padstack().Drill().start > layer_id )
1881 return false;
1882 }
1883 if( Padstack().Drill().end > B_Cu )
1884 {
1885 if( Padstack().Drill().end > layer_id )
1886 return false;
1887 }
1888
1889 return true;
1890}
1891
1892
1894{
1895 return Padstack().Drill().start;
1896}
1897
1898
1900{
1901 Padstack().Drill().start = aLayer;
1902}
1903
1904
1905void PCB_TRACK::SetLayerSet( const LSET& aLayerSet )
1906{
1907 aLayerSet.RunOnLayers(
1908 [&]( PCB_LAYER_ID layer )
1909 {
1910 if( IsCopperLayer( layer ) )
1911 SetLayer( layer );
1912 else if( IsSolderMaskLayer( layer ) )
1913 SetHasSolderMask( true );
1914 } );
1915}
1916
1917
1919{
1920 LSET layermask( { m_layer } );
1921
1922 if( m_hasSolderMask )
1923 {
1924 if( layermask.test( F_Cu ) )
1925 layermask.set( F_Mask );
1926 else if( layermask.test( B_Cu ) )
1927 layermask.set( B_Mask );
1928 }
1929
1930 return layermask;
1931}
1932
1933
1935{
1936 LSET layermask;
1937
1938 if( Padstack().Drill().start < PCBNEW_LAYER_ID_START )
1939 return layermask;
1940
1941 if( GetViaType() == VIATYPE::THROUGH )
1942 {
1943 layermask = LSET::AllCuMask( BoardCopperLayerCount() );
1944 }
1945 else
1946 {
1947 LAYER_RANGE range( Padstack().Drill().start, Padstack().Drill().end, BoardCopperLayerCount() );
1948
1949 int cnt = BoardCopperLayerCount();
1950 // PCB_LAYER_IDs are numbered from front to back, this is top to bottom.
1951 for( PCB_LAYER_ID id : range )
1952 {
1953 layermask.set( id );
1954
1955 if( --cnt <= 0 )
1956 break;
1957 }
1958 }
1959
1960 if( !IsTented( F_Mask ) && layermask.test( F_Cu ) )
1961 layermask.set( F_Mask );
1962
1963 if( !IsTented( B_Mask ) && layermask.test( B_Cu ) )
1964 layermask.set( B_Mask );
1965
1966 return layermask;
1967}
1968
1969
1970void PCB_VIA::SetLayerSet( const LSET& aLayerSet )
1971{
1972 // Vias do not use a LSET, just a top and bottom layer pair
1973 // So we need to set these 2 layers according to the allowed layers in aLayerSet
1974
1975 // For via through, only F_Cu and B_Cu are allowed. aLayerSet is ignored
1976 if( GetViaType() == VIATYPE::THROUGH )
1977 {
1978 Padstack().Drill().start = F_Cu;
1979 Padstack().Drill().end = B_Cu;
1980 return;
1981 }
1982
1983 // For blind buried vias, find the top and bottom layers
1984 bool top_found = false;
1985 bool bottom_found = false;
1986
1987 aLayerSet.RunOnLayers(
1988 [&]( PCB_LAYER_ID layer )
1989 {
1990 // tpo layer and bottom Layer are copper layers, so consider only copper layers
1991 if( IsCopperLayer( layer ) )
1992 {
1993 // The top layer is the first layer found in list and
1994 // cannot the B_Cu
1995 if( !top_found && layer != B_Cu )
1996 {
1997 Padstack().Drill().start = layer;
1998 top_found = true;
1999 }
2000
2001 // The bottom layer is the last layer found in list or B_Cu
2002 if( !bottom_found )
2003 Padstack().Drill().end = layer;
2004
2005 if( layer == B_Cu )
2006 bottom_found = true;
2007 }
2008 } );
2009}
2010
2011
2012void PCB_VIA::SetLayerPair( PCB_LAYER_ID aTopLayer, PCB_LAYER_ID aBottomLayer )
2013{
2014 Padstack().Drill().start = aTopLayer;
2015 Padstack().Drill().end = aBottomLayer;
2017
2018 if( !( GetFlags() & ROUTER_TRANSIENT ) )
2019 {
2020 if( BOARD* board = GetBoard() )
2021 board->InvalidateClearanceCache( m_Uuid );
2022 }
2023}
2024
2025
2027{
2028 // refuse invalid via
2029 if( aLayer == Padstack().Drill().end )
2030 return;
2031
2032 Padstack().Drill().start = aLayer;
2034
2035 if( !( GetFlags() & ROUTER_TRANSIENT ) )
2036 {
2037 if( BOARD* board = GetBoard() )
2038 board->InvalidateClearanceCache( m_Uuid );
2039 }
2040}
2041
2042
2044{
2045 // refuse invalid via
2046 if( aLayer == Padstack().Drill().start )
2047 return;
2048
2049 Padstack().Drill().end = aLayer;
2051
2052 if( !( GetFlags() & ROUTER_TRANSIENT ) )
2053 {
2054 if( BOARD* board = GetBoard() )
2055 board->InvalidateClearanceCache( m_Uuid );
2056 }
2057}
2058
2059
2060void PCB_VIA::LayerPair( PCB_LAYER_ID* top_layer, PCB_LAYER_ID* bottom_layer ) const
2061{
2062 PCB_LAYER_ID t_layer = F_Cu;
2063 PCB_LAYER_ID b_layer = B_Cu;
2064
2065 if( GetViaType() != VIATYPE::THROUGH )
2066 {
2067 b_layer = Padstack().Drill().end;
2068 t_layer = Padstack().Drill().start;
2069
2070 if( !IsCopperLayerLowerThan( b_layer, t_layer ) )
2071 std::swap( b_layer, t_layer );
2072 }
2073
2074 if( top_layer )
2075 *top_layer = t_layer;
2076
2077 if( bottom_layer )
2078 *bottom_layer = b_layer;
2079}
2080
2081
2083{
2084 return Padstack().Drill().start;
2085}
2086
2087
2089{
2090 return Padstack().Drill().end;
2091}
2092
2093
2095{
2096 if( GetViaType() == VIATYPE::THROUGH )
2097 {
2098 Padstack().Drill().start = F_Cu;
2099 Padstack().Drill().end = B_Cu;
2100 }
2101
2102 if( !IsCopperLayerLowerThan( Padstack().Drill().end, Padstack().Drill().start) )
2103 std::swap( Padstack().Drill().end, Padstack().Drill().start );
2104
2105 int copperCount = BoardCopperLayerCount();
2106
2107 auto sanitizeBackdrill =
2108 [copperCount]( PADSTACK::DRILL_PROPS& aDrill )
2109 {
2110 if( aDrill.start != UNDEFINED_LAYER && !IsCopperLayer( aDrill.start ) )
2111 aDrill.start = UNDEFINED_LAYER;
2112
2113 if( aDrill.end != UNDEFINED_LAYER && !IsCopperLayer( aDrill.end ) )
2114 aDrill.end = UNDEFINED_LAYER;
2115
2116 if( copperCount > 0 )
2117 {
2118 LSET cuMask = LSET::AllCuMask( copperCount );
2119
2120 if( aDrill.start != UNDEFINED_LAYER && !cuMask.Contains( aDrill.start ) )
2121 aDrill.start = UNDEFINED_LAYER;
2122
2123 if( aDrill.end != UNDEFINED_LAYER && !cuMask.Contains( aDrill.end ) )
2124 aDrill.end = UNDEFINED_LAYER;
2125 }
2126
2127 // A backdrill side with no must-cut layer does not exist.
2128 if( aDrill.end == UNDEFINED_LAYER )
2129 aDrill.size = { 0, 0 };
2130 };
2131
2132 sanitizeBackdrill( Padstack().SecondaryDrill() );
2133 sanitizeBackdrill( Padstack().TertiaryDrill() );
2134}
2135
2136
2137std::optional<PCB_VIA::VIA_PARAMETER_ERROR>
2138PCB_VIA::ValidateViaParameters( std::optional<int> aDiameter,
2139 std::optional<int> aPrimaryDrill,
2140 std::optional<PCB_LAYER_ID> aPrimaryStartLayer,
2141 std::optional<PCB_LAYER_ID> aPrimaryEndLayer,
2142 std::optional<int> aSecondaryDrill,
2143 std::optional<PCB_LAYER_ID> aSecondaryStartLayer,
2144 std::optional<PCB_LAYER_ID> aSecondaryEndLayer,
2145 std::optional<int> aTertiaryDrill,
2146 std::optional<PCB_LAYER_ID> aTertiaryStartLayer,
2147 std::optional<PCB_LAYER_ID> aTertiaryEndLayer,
2148 int aCopperLayerCount )
2149{
2150 VIA_PARAMETER_ERROR error;
2151
2152 if( aDiameter.has_value() && aDiameter.value() < GEOMETRY_MIN_SIZE )
2153 {
2154 error.m_Message = _( "Via diameter is too small." );
2155 error.m_Field = VIA_PARAMETER_ERROR::FIELD::DIAMETER;
2156 return error;
2157 }
2158
2159 if( aPrimaryDrill.has_value() && aPrimaryDrill.value() < GEOMETRY_MIN_SIZE )
2160 {
2161 error.m_Message = _( "Via drill is too small." );
2162 error.m_Field = VIA_PARAMETER_ERROR::FIELD::DRILL;
2163 return error;
2164 }
2165
2166 if( aDiameter.has_value() && !aPrimaryDrill.has_value() )
2167 {
2168 error.m_Message = _( "No via hole size defined." );
2169 error.m_Field = VIA_PARAMETER_ERROR::FIELD::DRILL;
2170 return error;
2171 }
2172
2173 if( aPrimaryDrill.has_value() && !aDiameter.has_value() )
2174 {
2175 error.m_Message = _( "No via diameter defined." );
2176 error.m_Field = VIA_PARAMETER_ERROR::FIELD::DIAMETER;
2177 return error;
2178 }
2179
2180 if( aDiameter.has_value() && aPrimaryDrill.has_value()
2181 && aDiameter.value() <= aPrimaryDrill.value() )
2182 {
2183 error.m_Message = _( "Via hole size must be smaller than via diameter" );
2184 error.m_Field = VIA_PARAMETER_ERROR::FIELD::DRILL;
2185 return error;
2186 }
2187
2188 std::optional<LSET> copperMask;
2189
2190 auto validateLayer =
2191 [&]( std::optional<PCB_LAYER_ID> aLayer, VIA_PARAMETER_ERROR::FIELD aField ) -> bool
2192 {
2193 if( !aLayer.has_value() )
2194 return true;
2195
2196 PCB_LAYER_ID layer = aLayer.value();
2197
2198 if( layer == UNDEFINED_LAYER )
2199 return true;
2200
2201 if( !IsCopperLayer( layer ) )
2202 {
2203 error.m_Message = _( "Via layer must be a copper layer." );
2204 error.m_Field = aField;
2205 return false;
2206 }
2207
2208 if( aCopperLayerCount > 0 )
2209 {
2210 if( !copperMask.has_value() )
2211 copperMask = LSET::AllCuMask( aCopperLayerCount );
2212
2213 if( !copperMask->Contains( layer ) )
2214 {
2215 error.m_Message = _( "Via layer is outside the board stack." );
2216 error.m_Field = aField;
2217 return false;
2218 }
2219 }
2220
2221 return true;
2222 };
2223
2224 if( !validateLayer( aPrimaryStartLayer, VIA_PARAMETER_ERROR::FIELD::START_LAYER ) )
2225 return error;
2226
2227 if( !validateLayer( aPrimaryEndLayer, VIA_PARAMETER_ERROR::FIELD::END_LAYER ) )
2228 return error;
2229
2230 if( aPrimaryStartLayer.has_value() && aPrimaryEndLayer.has_value()
2231 && aPrimaryStartLayer.value() == aPrimaryEndLayer.value() )
2232 {
2233 error.m_Message = _( "Via start layer and end layer cannot be the same" );
2234 error.m_Field = VIA_PARAMETER_ERROR::FIELD::START_LAYER;
2235 return error;
2236 }
2237
2238 if( aSecondaryDrill.has_value() )
2239 {
2240 if( aSecondaryDrill.value() < aPrimaryDrill.value_or( GEOMETRY_MIN_SIZE ) )
2241 {
2242 error.m_Message = _( "Backdrill diameter is too small." );
2243 error.m_Field = VIA_PARAMETER_ERROR::FIELD::SECONDARY_DRILL;
2244 return error;
2245 }
2246
2247 if( !validateLayer( aSecondaryStartLayer, VIA_PARAMETER_ERROR::FIELD::SECONDARY_START_LAYER ) )
2248 return error;
2249
2250 if( !validateLayer( aSecondaryEndLayer, VIA_PARAMETER_ERROR::FIELD::SECONDARY_END_LAYER ) )
2251 return error;
2252 }
2253
2254 if( aTertiaryDrill.has_value() )
2255 {
2256 if( aTertiaryDrill.value() < aPrimaryDrill.value_or( GEOMETRY_MIN_SIZE ) )
2257 {
2258 error.m_Message = _( "Tertiary backdrill diameter is too small." );
2259 error.m_Field = VIA_PARAMETER_ERROR::FIELD::TERTIARY_DRILL;
2260 return error;
2261 }
2262
2263 if( !validateLayer( aTertiaryStartLayer, VIA_PARAMETER_ERROR::FIELD::TERTIARY_START_LAYER ) )
2264 return error;
2265
2266 if( !validateLayer( aTertiaryEndLayer, VIA_PARAMETER_ERROR::FIELD::TERTIARY_END_LAYER ) )
2267 return error;
2268 }
2269
2270 return std::nullopt;
2271}
2272
2273
2275{
2276 return m_viaType == VIATYPE::MICROVIA;
2277}
2278
2279
2281{
2282 // We don't actually have an GUI or file tokens to differentiate these, so we have to look at
2283 // the layers.
2285 {
2286 bool startOuter = Padstack().Drill().start == F_Cu || Padstack().Drill().start == B_Cu;
2287 bool endOuter = Padstack().Drill().end == F_Cu || Padstack().Drill().end == B_Cu;
2288
2289 return startOuter ^ endOuter;
2290 }
2291
2292 return false;
2293}
2294
2295
2297{
2298 // We don't actually have an GUI or file tokens to differentiate these, so we have to look at
2299 // the layers.
2301 {
2302 return Padstack().Drill().start != F_Cu && Padstack().Drill().start != B_Cu
2303 && Padstack().Drill().end != F_Cu && Padstack().Drill().end != B_Cu;
2304 }
2305
2306 return false;
2307}
2308
2309
2311{
2314 {
2315 switch( aLayer )
2316 {
2317 case F_Cu:
2318 if( Padstack().Drill().start != F_Cu )
2319 return true;
2320
2321 break;
2322
2323 case B_Cu:
2324 if( Padstack().Drill().end != B_Cu )
2325 return true;
2326
2327 break;
2328
2330 if( GetBoard() && GetBoard()->GetCopperLayerCount() == 2 )
2331 return true;
2332
2333 break;
2334
2335 default:
2336 wxFAIL_MSG( wxT( "Unsupported layer for FRONT_INNER_BACK" ) );
2337 }
2338 }
2339
2340 return false;
2341}
2342
2343
2344bool PCB_VIA::FlashLayer( const LSET& aLayers ) const
2345{
2346 for( PCB_LAYER_ID layer : aLayers )
2347 {
2348 if( FlashLayer( layer ) )
2349 return true;
2350 }
2351
2352 return false;
2353}
2354
2355
2356bool PCB_VIA::FlashLayer( int aLayer ) const
2357{
2358 // Return the "normal" shape if the caller doesn't specify a particular layer
2359 if( aLayer == UNDEFINED_LAYER )
2360 return true;
2361
2362 const BOARD* board = GetBoard();
2363 PCB_LAYER_ID layer = static_cast<PCB_LAYER_ID>( aLayer );
2364
2365 if( !board )
2366 return true;
2367
2368 if( !IsOnLayer( layer ) )
2369 return false;
2370
2371 if( !IsCopperLayer( layer ) )
2372 return true;
2373
2374 switch( Padstack().UnconnectedLayerMode() )
2375 {
2377 return true;
2378
2380 if( layer == Padstack().Drill().start || layer == Padstack().Drill().end )
2381 return true;
2382
2383 // Check for removal below
2384 break;
2385
2387 // Check for removal below
2388 break;
2389
2391 return layer == Padstack().Drill().start || layer == Padstack().Drill().end;
2392 }
2393
2394 if( GetZoneLayerOverride( layer ) == ZLO_FORCE_FLASHED )
2395 {
2396 return true;
2397 }
2398 else
2399 {
2400 // Must be static to keep from raising its ugly head in performance profiles
2401 static std::initializer_list<KICAD_T> nonZoneTypes = { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T,
2402 PCB_PAD_T };
2403
2404 return board->GetConnectivity()->IsConnectedOnLayer( this, layer, nonZoneTypes );
2405 }
2406}
2407
2408
2409// IsCopperLayer() accepts any even id below PCB_LAYER_ID_COUNT, but only F_Cu..In30_Cu carry a
2410// distinct ordinal. Anything above aliases B_Cu or indexes past the override array
2411static bool hasLayerOrdinal( PCB_LAYER_ID aLayer )
2412{
2413 return IsCopperLayer( aLayer ) && aLayer <= In30_Cu;
2414}
2415
2416
2418{
2419 for( std::atomic<ZONE_LAYER_OVERRIDE>& entry : m_zoneLayerOverrides )
2420 entry.store( ZLO_NONE, std::memory_order_relaxed );
2421}
2422
2423
2425{
2426 if( !hasLayerOrdinal( aLayer ) )
2427 return ZLO_NONE;
2428
2429 return m_zoneLayerOverrides[CopperLayerToOrdinal( aLayer )].load( std::memory_order_relaxed );
2430}
2431
2432
2434{
2435 if( !hasLayerOrdinal( aLayer ) )
2436 return;
2437
2438 m_zoneLayerOverrides[CopperLayerToOrdinal( aLayer )].store( aOverride, std::memory_order_relaxed );
2439}
2440
2441
2443 PCB_LAYER_ID* aBottommost ) const
2444{
2445 *aTopmost = UNDEFINED_LAYER;
2446 *aBottommost = UNDEFINED_LAYER;
2447
2448 static std::initializer_list<KICAD_T> nonZoneTypes = { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T,
2449 PCB_PAD_T };
2450
2451 for( int layer = TopLayer(); layer <= BottomLayer(); ++layer )
2452 {
2453 bool connected = false;
2454
2455 if( GetZoneLayerOverride( static_cast<PCB_LAYER_ID>( layer ) ) == ZLO_FORCE_FLASHED )
2456 {
2457 connected = true;
2458 }
2459 else if( GetBoard()
2460 && GetBoard()->GetConnectivity()->IsConnectedOnLayer( this, layer, nonZoneTypes ) )
2461 {
2462 connected = true;
2463 }
2464
2465 if( connected )
2466 {
2467 if( *aTopmost == UNDEFINED_LAYER )
2468 *aTopmost = ToLAYER_ID( layer );
2469
2470 *aBottommost = ToLAYER_ID( layer );
2471 }
2472 }
2473
2474}
2475
2476
2477std::vector<int> PCB_TRACK::ViewGetLayers() const
2478{
2479 // Show the track and its netname on different layers
2480 const PCB_LAYER_ID layer = GetLayer();
2481 std::vector<int> layers{
2482 layer,
2483 GetNetnameLayer( layer ),
2484 LAYER_CLEARANCE_START + layer,
2485 };
2486
2487 layers.reserve( 6 );
2488
2489 if( m_hasSolderMask )
2490 {
2491 if( m_layer == F_Cu )
2492 layers.push_back( F_Mask );
2493 else if( m_layer == B_Cu )
2494 layers.push_back( B_Mask );
2495 }
2496
2497 if( IsLocked() )
2498 layers.push_back( LAYER_LOCKED_ITEM_SHADOW );
2499
2500 return layers;
2501}
2502
2503
2504double PCB_TRACK::ViewGetLOD( int aLayer, const KIGFX::VIEW* aView ) const
2505{
2506 PCB_PAINTER* painter = static_cast<PCB_PAINTER*>( aView->GetPainter() );
2507 PCB_RENDER_SETTINGS* renderSettings = painter->GetSettings();
2508
2509 if( !aView->IsLayerVisibleCached( LAYER_TRACKS ) )
2510 return LOD_HIDE;
2511
2512 if( IsNetnameLayer( aLayer ) )
2513 {
2515 return LOD_HIDE;
2516
2517 // Hide netnames on dimmed tracks
2518 if( renderSettings->GetHighContrast() )
2519 {
2520 if( m_layer != renderSettings->GetPrimaryHighContrastLayer() )
2521 return LOD_HIDE;
2522 }
2523
2524 BOX2I clipBox = BOX2ISafe( aView->GetViewport() );
2525
2526 // Calc the approximate size of the netname (assume square chars)
2527 int nameSize = (int) GetDisplayNetname().size() * GetWidth();
2528
2529 if( Type() == PCB_ARC_T )
2530 {
2531 if( KiROUND( GetLength() ) < nameSize )
2532 return LOD_HIDE;
2533
2534 if( !clipBox.Intersects( GetBoundingBox() ) )
2535 return LOD_HIDE;
2536 }
2537 else if( Type() == PCB_TRACE_T )
2538 {
2539 VECTOR2I start( GetStart() );
2540 VECTOR2I end( GetEnd() );
2541
2542 if( VECTOR2I( end - start ).SquaredEuclideanNorm() < SEG::Square( nameSize ) )
2543 return LOD_HIDE;
2544
2545 ClipLine( &clipBox, start.x, start.y, end.x, end.y );
2546
2547 if( VECTOR2I( end - start ).SquaredEuclideanNorm() == 0 )
2548 return LOD_HIDE;
2549 }
2550
2551 // Netnames will be shown only if zoom is appropriate
2552 return lodScaleForThreshold( aView, m_width, pcbIUScale.mmToIU( 4.0 ) );
2553 }
2554
2555 if( aLayer == LAYER_LOCKED_ITEM_SHADOW )
2556 {
2557 // Hide shadow if the main layer is not shown
2558 if( !aView->IsLayerVisibleCached( m_layer ) )
2559 return LOD_HIDE;
2560
2561 // Hide shadow on dimmed tracks
2562 if( renderSettings->GetHighContrast() )
2563 {
2564 if( m_layer != renderSettings->GetPrimaryHighContrastLayer() )
2565 return LOD_HIDE;
2566 }
2567 }
2568
2569 // Other layers are shown without any conditions
2570 return LOD_SHOW;
2571}
2572
2573
2575{
2576 BOX2I bbox = GetBoundingBox();
2577
2578 if( const BOARD* board = GetBoard() )
2579 {
2580 bbox.Inflate( 2 * board->GetDesignSettings().GetBiggestClearanceValue() );
2581
2582 // Only a via drills, so a plain segment would just be given an oversized box
2583 if( HasHole() )
2584 bbox = board->ExpandBoundingBoxForDrillSymbols( bbox );
2585 }
2586 else
2587 {
2588 // Add a bit extra for safety.
2589 const PCB_VIA* via = dynamic_cast<const PCB_VIA*>( this );
2590 bbox.Inflate( via ? via->GetWidth( PADSTACK::ALL_LAYERS ) : GetWidth() );
2591 }
2592
2593 return bbox;
2594}
2595
2596
2597std::vector<int> PCB_VIA::ViewGetLayers() const
2598{
2599 LAYER_RANGE layers( Padstack().Drill().start, Padstack().Drill().end, MAX_CU_LAYERS );
2600 std::vector<int> ret_layers{ LAYER_VIA_HOLES, LAYER_VIA_HOLEWALLS, LAYER_VIA_NETNAMES };
2601 ret_layers.reserve( MAX_CU_LAYERS + 6 );
2602
2603 // A drill map on a layer asks the holes to draw their symbols there, so the symbols stay
2604 // in the view index and one hole edit repaints one hole
2605 if( const BOARD* drillBoard = GetBoard() )
2606 {
2607 for( PCB_LAYER_ID mapLayer : drillBoard->DrillSymbolLayers().Seq() )
2608 ret_layers.push_back( DRILL_SYMBOL_LAYER_FOR( mapLayer ) );
2609 }
2610
2611 // TODO(JE) Rendering order issue
2612#if 0
2613 // Blind/buried vias (and microvias) use a different net name layer
2614 PCB_LAYER_ID layerTop, layerBottom;
2615 LayerPair( &layerTop, &layerBottom );
2616
2617 bool isBlindBuried =
2620 || ( m_viaType == VIATYPE::MICROVIA && ( layerTop != F_Cu || layerBottom != B_Cu ) );
2621#endif
2622 LSET cuMask = LSET::AllCuMask();
2623
2624 if( const BOARD* board = GetBoard() )
2625 cuMask &= board->GetEnabledLayers();
2626
2627 for( PCB_LAYER_ID layer : layers )
2628 {
2629 if( !cuMask.Contains( layer ) )
2630 continue;
2631
2632 ret_layers.push_back( LAYER_VIA_COPPER_START + layer );
2633 ret_layers.push_back( LAYER_CLEARANCE_START + layer );
2634 }
2635
2636 if( IsLocked() )
2637 ret_layers.push_back( LAYER_LOCKED_ITEM_SHADOW );
2638
2639 // Vias can also be on a solder mask layer. They are on these layers or not,
2640 // depending on the plot and solder mask options
2641 if( IsOnLayer( F_Mask ) )
2642 ret_layers.push_back( F_Mask );
2643
2644 if( IsOnLayer( B_Mask ) )
2645 ret_layers.push_back( B_Mask );
2646
2647 return ret_layers;
2648}
2649
2650
2651double PCB_VIA::ViewGetLOD( int aLayer, const KIGFX::VIEW* aView ) const
2652{
2653 PCB_PAINTER* painter = static_cast<PCB_PAINTER*>( aView->GetPainter() );
2654 PCB_RENDER_SETTINGS* renderSettings = painter->GetSettings();
2655 const BOARD* board = GetBoard();
2656
2657 // Reviewing a drill drawing with vias hidden is normal, so the symbols answer to the
2658 // map's own layer rather than to the vias meta control
2659 if( IsDrillSymbolLayer( aLayer ) )
2660 {
2661 return aView->IsLayerVisibleCached( aLayer - LAYER_DRILL_SYMBOL_START ) ? LOD_SHOW
2662 : LOD_HIDE;
2663 }
2664
2665 // Meta control for hiding all vias
2666 if( !aView->IsLayerVisibleCached( LAYER_VIAS ) )
2667 return LOD_HIDE;
2668
2669 // In high contrast mode don't show vias that don't cross the high-contrast layer
2670 if( renderSettings->GetHighContrast() )
2671 {
2672 PCB_LAYER_ID highContrastLayer = renderSettings->GetPrimaryHighContrastLayer();
2673
2674 if( LSET::FrontTechMask().Contains( highContrastLayer ) )
2675 highContrastLayer = F_Cu;
2676 else if( LSET::BackTechMask().Contains( highContrastLayer ) )
2677 highContrastLayer = B_Cu;
2678
2679 if( IsCopperLayer( highContrastLayer ) && GetViaType() != VIATYPE::THROUGH )
2680 {
2681 if( IsCopperLayerLowerThan( Padstack().Drill().start, highContrastLayer )
2682 || IsCopperLayerLowerThan( highContrastLayer, Padstack().Drill().end ) )
2683 {
2684 return LOD_HIDE;
2685 }
2686 }
2687 }
2688
2689 // The painter draws a via copper layer only where the via flashes
2690 if( IsViaCopperLayer( aLayer ) && !FlashLayer( aLayer - LAYER_VIA_COPPER_START ) )
2691 return LOD_HIDE;
2692
2693 // The painter draws clearance outlines only for this display mode and never when printing
2694 if( IsClearanceLayer( aLayer ) )
2695 {
2696 if( renderSettings->IsPrinting() || !pcbconfig()
2697 || pcbconfig()->m_Display.m_TrackClearance != SHOW_WITH_VIA_ALWAYS )
2698 {
2699 return LOD_HIDE;
2700 }
2701 }
2702
2703 if( IsHoleLayer( aLayer ) )
2704 {
2705 LSET visible;
2706
2707 if( board )
2708 {
2709 visible = board->GetVisibleLayers();
2710 visible &= board->GetEnabledLayers();
2711 }
2712 else
2713 {
2714 visible = LSET::AllLayersMask();
2715 }
2716
2718 {
2719 // Show a through via's hole if any physical layer is shown
2720 visible &= LSET::PhysicalLayersMask();
2721
2722 if( !visible.any() )
2723 return LOD_HIDE;
2724 }
2725 else
2726 {
2727 // Show a blind or micro via's hole if it crosses a visible layer
2728 visible &= GetLayerSet();
2729
2730 if( !visible.any() )
2731 return LOD_HIDE;
2732 }
2733
2734 // The hole won't be visible anyway at this scale
2735 return lodScaleForThreshold( aView, GetDrillValue(), pcbIUScale.mmToIU( 0.25 ) );
2736 }
2737 else if( IsNetnameLayer( aLayer ) )
2738 {
2739 if( renderSettings->GetHighContrast() )
2740 {
2741 // Hide netnames unless via is flashed to a high-contrast layer
2742 if( !FlashLayer( renderSettings->GetPrimaryHighContrastLayer() ) )
2743 return LOD_HIDE;
2744 }
2745 else
2746 {
2747 // Hide netnames unless pad is flashed to a visible layer
2748 if( !FlashLayer( viewVisibleLayers( aView ) ) )
2749 return LOD_HIDE;
2750 }
2751
2752 int width = GetWidth( ToLAYER_ID( aLayer ) );
2753
2754 // Netnames will be shown only if zoom is appropriate
2755 return lodScaleForThreshold( aView, width, pcbIUScale.mmToIU( 10 ) );
2756 }
2757
2758 if( !IsCopperLayer( aLayer ) )
2759 {
2760 int width = GetWidth( ToLAYER_ID( aLayer ) );
2761
2762 return lodScaleForThreshold( aView, width, pcbIUScale.mmToIU( 0.6 ) );
2763 }
2764
2765 return LOD_SHOW;
2766}
2767
2768
2770{
2771 switch( Type() )
2772 {
2773 case PCB_ARC_T: return _( "Track (arc)" );
2774 case PCB_VIA_T: return _( "Via" );
2775 case PCB_TRACE_T:
2776 default: return _( "Track" );
2777 }
2778}
2779
2780
2781void PCB_TRACK::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
2782{
2783 wxString msg;
2784 BOARD* board = GetBoard();
2785
2786 aList.emplace_back( _( "Type" ), GetFriendlyName() );
2787
2788 GetMsgPanelInfoBase_Common( aFrame, aList );
2789
2790 aList.emplace_back( _( "Layer" ), LayerMaskDescribe() );
2791
2792 aList.emplace_back( _( "Width" ), aFrame->MessageTextFromValue( m_width ) );
2793
2794 if( Type() == PCB_ARC_T )
2795 {
2796 double radius = static_cast<PCB_ARC*>( this )->GetRadius();
2797 aList.emplace_back( _( "Radius" ), aFrame->MessageTextFromValue( radius ) );
2798
2799 aList.emplace_back( _( "Angle" ), wxString::Format( "%.2fdeg",
2800 static_cast<PCB_ARC*>(this)->GetAngle().AsDegrees() ) );
2801 }
2802
2803 double segmentLength = GetLength();
2804 double segmentDelay = GetDelay();
2805
2806 if( segmentDelay == 0.0 )
2807 {
2808 aList.emplace_back( _( "Segment Length" ), aFrame->MessageTextFromValue( segmentLength ) );
2809 }
2810 else
2811 {
2812 aList.emplace_back( _( "Segment Delay" ),
2813 aFrame->MessageTextFromValue( segmentDelay, true, EDA_DATA_TYPE::TIME ) );
2814 }
2815
2816 // Display full track length (in Pcbnew)
2817 if( board && GetNetCode() > 0 )
2818 {
2819 int count = 0;
2820 double trackLen = 0.0;
2821 double lenPadToDie = 0.0;
2822 double trackDelay = 0.0;
2823 double delayPadToDie = 0.0;
2824
2825 std::tie( count, trackLen, lenPadToDie, trackDelay, delayPadToDie ) = board->GetTrackLength( *this );
2826
2827 if( trackDelay == 0.0 )
2828 {
2829 aList.emplace_back( _( "Routed Length" ), aFrame->MessageTextFromValue( trackLen ) );
2830
2831 if( lenPadToDie != 0 )
2832 {
2833 msg = aFrame->MessageTextFromValue( lenPadToDie );
2834 aList.emplace_back( _( "Pad To Die Length" ), msg );
2835
2836 msg = aFrame->MessageTextFromValue( trackLen + lenPadToDie );
2837 aList.emplace_back( _( "Full Length" ), msg );
2838 }
2839 }
2840 else
2841 {
2842 aList.emplace_back( _( "Routed Delay" ),
2843 aFrame->MessageTextFromValue( trackDelay, true, EDA_DATA_TYPE::TIME ) );
2844
2845 if( delayPadToDie != 0.0 )
2846 {
2847 msg = aFrame->MessageTextFromValue( delayPadToDie, true, EDA_DATA_TYPE::TIME );
2848 aList.emplace_back( _( "Pad To Die Delay" ), msg );
2849
2850 msg = aFrame->MessageTextFromValue( trackDelay + delayPadToDie, true, EDA_DATA_TYPE::TIME );
2851 aList.emplace_back( _( "Full Delay" ), msg );
2852 }
2853 }
2854 }
2855
2856 SHAPE_POLY_SET copper;
2858 aList.emplace_back( _( "Copper Area" ),
2859 aFrame->MessageTextFromValue( copper.Area(), true, EDA_DATA_TYPE::AREA ) );
2860
2861 wxString source;
2863
2864 aList.emplace_back( wxString::Format( _( "Min Clearance: %s" ),
2865 aFrame->MessageTextFromValue( clearance ) ),
2866 wxString::Format( _( "(from %s)" ), source ) );
2867
2868 MINOPTMAX<int> constraintValue = GetWidthConstraint( &source );
2869 msg = aFrame->MessageTextFromMinOptMax( constraintValue );
2870
2871 if( !msg.IsEmpty() )
2872 {
2873 aList.emplace_back( wxString::Format( _( "Width Constraints: %s" ), msg ),
2874 wxString::Format( _( "(from %s)" ), source ) );
2875 }
2876}
2877
2878
2879void PCB_VIA::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
2880{
2881 wxString msg;
2882
2883 switch( GetViaType() )
2884 {
2885 case VIATYPE::MICROVIA: msg = _( "Micro Via" ); break;
2886 case VIATYPE::BLIND: msg = _( "Blind Via" ); break;
2887 case VIATYPE::BURIED: msg = _( "Buried Via" ); break;
2888 case VIATYPE::THROUGH: msg = _( "Through Via" ); break;
2889 default: msg = _( "Via" ); break;
2890 }
2891
2892 aList.emplace_back( _( "Type" ), msg );
2893
2894 GetMsgPanelInfoBase_Common( aFrame, aList );
2895
2896 aList.emplace_back( _( "Layer" ), LayerMaskDescribe() );
2897
2898 std::set<int> widths;
2899 m_padStack.ForEachUniqueLayer(
2900 [&]( PCB_LAYER_ID aLayer )
2901 {
2902 if( IsGhostLayer( aLayer ) )
2903 return;
2904
2905 widths.insert( GetWidth( aLayer ) );
2906 } );
2907
2908 if( widths.size() == 1 )
2909 aList.emplace_back( _( "Diameter" ), aFrame->MessageTextFromValue( *widths.begin() ) );
2910 else
2911 aList.emplace_back( _( "Diameter" ), _( "(mixed)" ) );
2912
2913 aList.emplace_back( _( "Hole" ), aFrame->MessageTextFromValue( GetDrillValue() ) );
2914
2915 wxString source;
2917
2918 aList.emplace_back( wxString::Format( _( "Min Clearance: %s" ), aFrame->MessageTextFromValue( clearance ) ),
2919 wxString::Format( _( "(from %s)" ), source ) );
2920
2921 int minAnnulus = GetMinAnnulus( GetLayer(), &source );
2922
2923 aList.emplace_back( wxString::Format( _( "Min Annular Width: %s" ), aFrame->MessageTextFromValue( minAnnulus ) ),
2924 wxString::Format( _( "(from %s)" ), source ) );
2925}
2926
2927
2928void PCB_TRACK::GetMsgPanelInfoBase_Common( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList ) const
2929{
2930 aList.emplace_back( _( "Net" ), UnescapeString( GetNetname() ) );
2931
2932 if( NETINFO_ITEM* netInfo = GetNet() )
2933 {
2934 const wxString& chainName = netInfo->GetNetChain();
2935
2936 if( !chainName.IsEmpty() )
2937 aList.emplace_back( _( "Net Chain" ), UnescapeString( chainName ) );
2938 }
2939
2940 aList.emplace_back( _( "Resolved Netclass" ),
2941 UnescapeString( GetEffectiveNetClass()->GetHumanReadableName() ) );
2942
2943#if 0 // Enable for debugging
2944 if( GetBoard() )
2945 aList.emplace_back( _( "NetCode" ), fmt::format( "{}", GetNetCode() ) );
2946
2947 aList.emplace_back( wxT( "Flags" ), fmt::format( "#08X", m_flags ) );
2948
2949 aList.emplace_back( wxT( "Start pos" ), fmt::format( "{} {}", m_Start.x, m_Start.y ) );
2950 aList.emplace_back( wxT( "End pos" ), fmt::format( "{} {}", m_End.x, m_End.y ) );
2951#endif
2952
2953 if( aFrame->GetName() == PCB_EDIT_FRAME_NAME && IsLocked() )
2954 aList.emplace_back( _( "Status" ), _( "Locked" ) );
2955}
2956
2957
2959{
2960 PCB_LAYER_ID top_layer;
2961 PCB_LAYER_ID bottom_layer;
2962
2963 LayerPair( &top_layer, &bottom_layer );
2964
2965 return GetLayerName( top_layer ) + wxT( " - " ) + GetLayerName( bottom_layer );
2966}
2967
2968
2969double PCB_TRACK::GetCoverageArea( int aTextMargin ) const
2970{
2971 // Width squared, so a long track does not outrank a short one it happens to cross
2972 const double width = GetWidth();
2973 return width * width;
2974}
2975
2976
2977bool PCB_TRACK::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
2978{
2979 return TestSegmentHit( aPosition, m_Start, m_End, aAccuracy + ( m_width / 2 ) );
2980}
2981
2982
2983bool PCB_ARC::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
2984{
2985 double max_dist = aAccuracy + ( GetWidth() / 2.0 );
2986
2987 // Short-circuit common cases where the arc is connected to a track or via at an endpoint
2988 if( GetStart().Distance( aPosition ) <= max_dist || GetEnd().Distance( aPosition ) <= max_dist )
2989 {
2990 return true;
2991 }
2992
2994 VECTOR2L relpos = aPosition - center;
2995 int64_t dist = relpos.EuclideanNorm();
2996 double radius = GetRadius();
2997
2998 if( std::abs( dist - radius ) > max_dist )
2999 return false;
3000
3001 EDA_ANGLE arc_angle = GetAngle();
3002 EDA_ANGLE arc_angle_start = GetArcAngleStart(); // Always 0.0 ... 360 deg
3003 EDA_ANGLE arc_hittest( relpos );
3004
3005 // Calculate relative angle between the starting point of the arc, and the test point
3006 arc_hittest -= arc_angle_start;
3007
3008 // Normalise arc_hittest between 0 ... 360 deg
3009 arc_hittest.Normalize();
3010
3011 if( arc_angle < ANGLE_0 )
3012 return arc_hittest >= ANGLE_360 + arc_angle;
3013
3014 return arc_hittest <= arc_angle;
3015}
3016
3017
3018double PCB_VIA::GetCoverageArea( int aTextMargin ) const
3019{
3020 // A via covers its pad, so the width rule it inherits from tracks does not apply
3021 return BOARD_ITEM::GetCoverageArea( aTextMargin );
3022}
3023
3024
3025bool PCB_VIA::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
3026{
3027 bool hit = false;
3028
3030 [&]( PCB_LAYER_ID aLayer )
3031 {
3032 if( hit )
3033 return;
3034
3035 if( IsGhostLayer( aLayer ) )
3036 return;
3037
3038 int max_dist = aAccuracy + ( GetWidth( aLayer ) / 2 );
3039
3040 // rel_pos is aPosition relative to m_Start (or the center of the via)
3041 VECTOR2D rel_pos = aPosition - m_Start;
3042 double dist = rel_pos.x * rel_pos.x + rel_pos.y * rel_pos.y;
3043
3044 if( dist <= static_cast<double>( max_dist ) * max_dist )
3045 hit = true;
3046 } );
3047
3048 return hit;
3049}
3050
3051
3052bool PCB_TRACK::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
3053{
3054 BOX2I arect = aRect;
3055 arect.Inflate( aAccuracy );
3056
3057 if( aContained )
3058 return arect.Contains( GetStart() ) && arect.Contains( GetEnd() );
3059 else
3060 return arect.Intersects( GetStart(), GetEnd() );
3061}
3062
3063
3064bool PCB_ARC::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
3065{
3066 BOX2I arect = aRect;
3067 arect.Inflate( aAccuracy );
3068
3069 BOX2I box( GetStart() );
3070 box.Merge( GetMid() );
3071 box.Merge( GetEnd() );
3072
3073 box.Inflate( GetWidth() / 2 );
3074
3075 if( aContained )
3076 return arect.Contains( box );
3077 else
3078 return arect.Intersects( box );
3079}
3080
3081
3082bool PCB_VIA::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
3083{
3084 BOX2I arect = aRect;
3085 arect.Inflate( aAccuracy );
3086
3087 bool hit = false;
3088
3090 [&]( PCB_LAYER_ID aLayer )
3091 {
3092 if( hit )
3093 return;
3094
3095 if( IsGhostLayer( aLayer ) )
3096 return;
3097
3098 BOX2I box( GetStart() );
3099 box.Inflate( GetWidth( aLayer ) / 2 );
3100
3101 if( aContained )
3102 hit = arect.Contains( box );
3103 else
3104 hit = arect.IntersectsCircle( GetStart(), GetWidth( aLayer ) / 2 );
3105 } );
3106
3107 return hit;
3108}
3109
3110
3111bool PCB_TRACK::HitTest( const SHAPE_LINE_CHAIN& aPoly, bool aContained ) const
3112{
3113 return KIGEOM::ShapeHitTest( aPoly, *GetEffectiveShape(), aContained );
3114}
3115
3116
3117wxString PCB_TRACK::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
3118{
3119 return wxString::Format( Type() == PCB_ARC_T ? _("Track (arc) %s on %s, length %s" )
3120 : _("Track %s on %s, length %s" ),
3121 GetNetnameMsg(),
3122 GetLayerName(),
3123 aUnitsProvider->MessageTextFromValue( GetLength() ) );
3124}
3125
3126
3128{
3129 return BITMAPS::add_tracks;
3130}
3131
3132
3134{
3135 wxASSERT( aImage->Type() == PCB_TRACE_T );
3136
3137 std::swap( *((PCB_TRACK*) this), *((PCB_TRACK*) aImage) );
3138}
3139
3140
3142{
3143 wxASSERT( aImage->Type() == PCB_ARC_T );
3144
3145 std::swap( *this, *static_cast<PCB_ARC*>( aImage ) );
3146}
3147
3148
3150{
3151 wxASSERT( aImage->Type() == PCB_VIA_T );
3152
3153 std::swap( *((PCB_VIA*) this), *((PCB_VIA*) aImage) );
3154}
3155
3156
3162
3163
3165{
3167 return std::min( center.Distance( m_Start ), (double) INT_MAX / 2.0 );
3168}
3169
3170
3172{
3174 EDA_ANGLE angle1 = EDA_ANGLE( m_Mid - center ) - EDA_ANGLE( m_Start - center );
3175 EDA_ANGLE angle2 = EDA_ANGLE( m_End - center ) - EDA_ANGLE( m_Mid - center );
3176
3177 return angle1.Normalize180() + angle2.Normalize180();
3178}
3179
3180
3182{
3183 VECTOR2D pos( GetPosition() );
3184 EDA_ANGLE angleStart( m_Start - pos );
3185
3186 return angleStart.Normalize();
3187}
3188
3189
3190// Note: used in python tests. Ignore CLion's claim that it's unused....
3192{
3193 VECTOR2D pos( GetPosition() );
3194 EDA_ANGLE angleEnd( m_End - pos );
3195
3196 return angleEnd.Normalize();
3197}
3198
3199bool PCB_ARC::IsDegenerated( int aThreshold ) const
3200{
3201 // We have lots of code that will blow up if the radius overflows an int.
3202 if( GetRadius() >= (double)INT_MAX/2.0 )
3203 return true;
3204
3205 // Too small arcs cannot be really handled: arc center (and arc radius)
3206 // cannot be safely computed if the distance between mid and end points
3207 // is too small (a few internal units)
3208
3209 // len of both segments must be < aThreshold to be a very small degenerated arc
3210 return ( GetMid() - GetStart() ).EuclideanNorm() < aThreshold
3211 && ( GetMid() - GetEnd() ).EuclideanNorm() < aThreshold;
3212}
3213
3214
3216{
3217 if( a->GetNetCode() != b->GetNetCode() )
3218 return a->GetNetCode() < b->GetNetCode();
3219
3220 if( a->GetLayer() != b->GetLayer() )
3221 return a->GetLayer() < b->GetLayer();
3222
3223 if( a->Type() != b->Type() )
3224 return a->Type() < b->Type();
3225
3226 if( a->m_Uuid != b->m_Uuid )
3227 return a->m_Uuid < b->m_Uuid;
3228
3229 return a < b;
3230}
3231
3232
3234{
3235 int width = m_width;
3236
3237 if( IsSolderMaskLayer( aLayer ) )
3238 width += 2 * GetSolderMaskExpansion();
3239
3240 return std::make_shared<SHAPE_SEGMENT>( m_Start, m_End, width );
3241}
3242
3243
3244std::shared_ptr<SHAPE> PCB_VIA::GetEffectiveShape( PCB_LAYER_ID aLayer, FLASHING aFlash,
3245 DRC_CONSTRAINT_T aUsage ) const
3246{
3247 int diameter = 0;
3248
3249 if( aFlash == FLASHING::ALWAYS_FLASHED || ( aFlash == FLASHING::DEFAULT && FlashLayer( aLayer ) ) )
3250 {
3251 if( aLayer == UNDEFINED_LAYER )
3252 {
3253 Padstack().ForEachUniqueLayer(
3254 [&]( PCB_LAYER_ID layer )
3255 {
3256 if( IsGhostLayer( layer ) )
3257 return;
3258
3259 diameter = std::max( diameter, GetWidth( layer ) );
3260 } );
3261 }
3262 else
3263 {
3264 PCB_LAYER_ID cuLayer = m_padStack.EffectiveLayerFor( aLayer );
3265 diameter = GetWidth( cuLayer );
3266
3267 if( IsSolderMaskLayer( aLayer ) )
3268 diameter += 2 * GetSolderMaskExpansion();
3269 }
3270 }
3271 else
3272 {
3273 diameter = GetDrillValue();
3274 }
3275
3276 // In some cases we want to add in any backdrill or post-machining
3277 if( ( aUsage == PHYSICAL_CLEARANCE_CONSTRAINT && IsBackdrilledOrPostMachined( aLayer ) )
3278 || ( aUsage == SILK_CLEARANCE_CONSTRAINT && IsBackdrilledOrPostMachined( aLayer ) ) )
3279 {
3280 diameter = std::max( diameter, Padstack().GetMaxHoleSize() );
3281 }
3282
3283 return std::make_shared<SHAPE_CIRCLE>( m_Start, diameter / 2 );
3284}
3285
3286
3288{
3289 int width = GetWidth();
3290
3291 if( IsSolderMaskLayer( aLayer ) )
3292 width += 2 * GetSolderMaskExpansion();
3293
3294 SHAPE_ARC arc( GetStart(), GetMid(), GetEnd(), width );
3295
3296 if( arc.IsEffectiveLine() )
3297 return std::make_shared<SHAPE_SEGMENT>( GetStart(), GetEnd(), width );
3298
3299 return std::make_shared<SHAPE_ARC>( arc );
3300}
3301
3302
3304 int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth ) const
3305{
3306 wxASSERT_MSG( !ignoreLineWidth, wxT( "IgnoreLineWidth has no meaning for tracks." ) );
3307
3308 switch( Type() )
3309 {
3310 case PCB_VIA_T:
3311 {
3312 int radius = ( static_cast<const PCB_VIA*>( this )->GetWidth( aLayer ) / 2 ) + aClearance;
3313 TransformCircleToPolygon( aBuffer, m_Start, radius, aError, aErrorLoc );
3314 break;
3315 }
3316
3317 case PCB_ARC_T:
3318 {
3319 const PCB_ARC* arc = static_cast<const PCB_ARC*>( this );
3320 int width = m_width + ( 2 * aClearance );
3321
3322 if( IsSolderMaskLayer( aLayer ) )
3323 width += 2 * GetSolderMaskExpansion();
3324
3325 TransformArcToPolygon( aBuffer, arc->GetStart(), arc->GetMid(), arc->GetEnd(), width, aError, aErrorLoc );
3326 break;
3327 }
3328
3329 default:
3330 {
3331 int width = m_width + ( 2 * aClearance );
3332
3333 if( IsSolderMaskLayer( aLayer ) )
3334 width += 2 * GetSolderMaskExpansion();
3335
3336 TransformOvalToPolygon( aBuffer, m_Start, m_End, width, aError, aErrorLoc );
3337
3338 break;
3339 }
3340 }
3341}
3342
3343
3344static struct TRACK_VIA_DESC
3345{
3347 {
3348 // clang-format off: the suggestion is less readable
3350 .Undefined( VIATYPE::NOT_DEFINED )
3351 .Map( VIATYPE::THROUGH, _HKI( "Through" ) )
3352 .Map( VIATYPE::BLIND, _HKI( "Blind" ) )
3353 .Map( VIATYPE::BURIED, _HKI( "Buried" ) )
3354 .Map( VIATYPE::MICROVIA, _HKI( "Micro" ) );
3355
3357 .Undefined( TENTING_MODE::FROM_BOARD )
3358 .Map( TENTING_MODE::FROM_BOARD, _HKI( "From board stackup" ) )
3359 .Map( TENTING_MODE::TENTED, _HKI( "Tented" ) )
3360 .Map( TENTING_MODE::NOT_TENTED, _HKI( "Not tented" ) );
3361
3363 .Undefined( COVERING_MODE::FROM_BOARD )
3364 .Map( COVERING_MODE::FROM_BOARD, _HKI( "From board stackup" ) )
3365 .Map( COVERING_MODE::COVERED, _HKI( "Covered" ) )
3366 .Map( COVERING_MODE::NOT_COVERED, _HKI( "Not covered" ) );
3367
3369 .Undefined( PLUGGING_MODE::FROM_BOARD )
3370 .Map( PLUGGING_MODE::FROM_BOARD, _HKI( "From board stackup" ) )
3371 .Map( PLUGGING_MODE::PLUGGED, _HKI( "Plugged" ) )
3372 .Map( PLUGGING_MODE::NOT_PLUGGED, _HKI( "Not plugged" ) );
3373
3375 .Undefined( CAPPING_MODE::FROM_BOARD )
3376 .Map( CAPPING_MODE::FROM_BOARD, _HKI( "From board stackup" ) )
3377 .Map( CAPPING_MODE::CAPPED, _HKI( "Capped" ) )
3378 .Map( CAPPING_MODE::NOT_CAPPED, _HKI( "Not capped" ) );
3379
3381 .Undefined( FILLING_MODE::FROM_BOARD )
3382 .Map( FILLING_MODE::FROM_BOARD, _HKI( "From board stackup" ) )
3383 .Map( FILLING_MODE::FILLED, _HKI( "Filled" ) )
3384 .Map( FILLING_MODE::NOT_FILLED, _HKI( "Not filled" ) );
3385
3386 // clang-format on: the suggestion is less readable
3387
3388 // Pad and via registration can run in either order across translation units.
3390
3391 if( pmMap.Choices().GetCount() == 0 )
3392 {
3397 }
3398
3400
3401 if( bdMap.Choices().GetCount() == 0 )
3402 {
3404 .Map( BACKDRILL_MODE::NO_BACKDRILL, _HKI( "No backdrill" ) )
3405 .Map( BACKDRILL_MODE::BACKDRILL_BOTTOM, _HKI( "Backdrill bottom" ) )
3406 .Map( BACKDRILL_MODE::BACKDRILL_TOP, _HKI( "Backdrill top" ) )
3407 .Map( BACKDRILL_MODE::BACKDRILL_BOTH, _HKI( "Backdrill both" ) );
3408 }
3409
3411
3412 if( layerEnum.Choices().GetCount() == 0 )
3413 {
3414 layerEnum.Undefined( UNDEFINED_LAYER );
3415
3416 for( PCB_LAYER_ID layer : LSET::AllLayersMask() )
3417 layerEnum.Map( layer, LSET::Name( layer ) );
3418 }
3419
3420 auto viaDiameterPropertyValidator =
3421 []( const wxAny&& aValue, EDA_ITEM* aItem ) -> VALIDATOR_RESULT
3422 {
3423 if( !aItem || aItem->Type() != PCB_VIA_T )
3424 return std::nullopt;
3425
3426 if( !aValue.CheckType<int>() )
3427 return std::nullopt;
3428
3429 PCB_VIA* via = static_cast<PCB_VIA*>( aItem );
3430
3431 std::optional<int> diameter = aValue.As<int>();
3432 std::optional<int> drill = via->GetDrillValue();
3433
3434 std::optional<PCB_LAYER_ID> startLayer;
3435
3436 if( via->Padstack().Drill().start != UNDEFINED_LAYER )
3437 startLayer = via->Padstack().Drill().start;
3438
3439 std::optional<PCB_LAYER_ID> endLayer;
3440
3441 if( via->Padstack().Drill().end != UNDEFINED_LAYER )
3442 endLayer = via->Padstack().Drill().end;
3443
3444 int copperLayerCount = via->BoardCopperLayerCount();
3445
3446 if( std::optional<PCB_VIA::VIA_PARAMETER_ERROR> error =
3447 PCB_VIA::ValidateViaParameters( diameter, drill, startLayer, endLayer,
3448 std::nullopt, std::nullopt, std::nullopt, // secondary drill
3449 std::nullopt, std::nullopt, std::nullopt, // tertiary drill
3450 copperLayerCount ) )
3451 {
3452 return std::make_unique<VALIDATION_ERROR_MSG>( error->m_Message );
3453 }
3454
3455 return std::nullopt;
3456 };
3457
3458 auto viaDrillPropertyValidator =
3459 []( const wxAny&& aValue, EDA_ITEM* aItem ) -> VALIDATOR_RESULT
3460 {
3461 if( !aItem || aItem->Type() != PCB_VIA_T )
3462 return std::nullopt;
3463
3464 if( !aValue.CheckType<int>() )
3465 return std::nullopt;
3466
3467 PCB_VIA* via = static_cast<PCB_VIA*>( aItem );
3468
3469 std::optional<int> diameter = via->GetFrontWidth();
3470 std::optional<int> drill = aValue.As<int>();
3471
3472 std::optional<PCB_LAYER_ID> startLayer;
3473
3474 if( via->Padstack().Drill().start != UNDEFINED_LAYER )
3475 startLayer = via->Padstack().Drill().start;
3476
3477 std::optional<PCB_LAYER_ID> endLayer;
3478
3479 if( via->Padstack().Drill().end != UNDEFINED_LAYER )
3480 endLayer = via->Padstack().Drill().end;
3481
3482 std::optional<int> secondaryDrill = via->GetSecondaryDrillSize();
3483
3484 std::optional<PCB_LAYER_ID> secondaryStart;
3485
3486 if( via->GetSecondaryDrillStartLayer() != UNDEFINED_LAYER )
3487 secondaryStart = via->GetSecondaryDrillStartLayer();
3488
3489 std::optional<PCB_LAYER_ID> secondaryEnd;
3490
3491 if( via->GetSecondaryDrillEndLayer() != UNDEFINED_LAYER )
3492 secondaryEnd = via->GetSecondaryDrillEndLayer();
3493
3494 std::optional<int> tertiaryDrill = via->GetTertiaryDrillSize();
3495
3496 std::optional<PCB_LAYER_ID> tertiaryStart;
3497
3498 if( via->GetTertiaryDrillStartLayer() != UNDEFINED_LAYER )
3499 tertiaryStart = via->GetTertiaryDrillStartLayer();
3500
3501 std::optional<PCB_LAYER_ID> tertiaryEnd;
3502
3503 if( via->GetTertiaryDrillEndLayer() != UNDEFINED_LAYER )
3504 tertiaryEnd = via->GetTertiaryDrillEndLayer();
3505
3506 int copperLayerCount = via->BoardCopperLayerCount();
3507
3508 if( std::optional<PCB_VIA::VIA_PARAMETER_ERROR> error =
3509 PCB_VIA::ValidateViaParameters( diameter, drill, startLayer, endLayer,
3510 secondaryDrill, secondaryStart, secondaryEnd,
3511 tertiaryDrill, tertiaryStart, tertiaryEnd,
3512 copperLayerCount ) )
3513 {
3514 return std::make_unique<VALIDATION_ERROR_MSG>( error->m_Message );
3515 }
3516
3517 return std::nullopt;
3518 };
3519
3520 auto viaStartLayerPropertyValidator =
3521 []( const wxAny&& aValue, EDA_ITEM* aItem ) -> VALIDATOR_RESULT
3522 {
3523 if( !aItem || aItem->Type() != PCB_VIA_T )
3524 return std::nullopt;
3525
3526 PCB_LAYER_ID layer;
3527
3528 if( aValue.CheckType<PCB_LAYER_ID>() )
3529 layer = aValue.As<PCB_LAYER_ID>();
3530 else if( aValue.CheckType<int>() )
3531 layer = static_cast<PCB_LAYER_ID>( aValue.As<int>() );
3532 else
3533 return std::nullopt;
3534
3535 PCB_VIA* via = static_cast<PCB_VIA*>( aItem );
3536
3537 std::optional<int> diameter = via->GetFrontWidth();
3538 std::optional<int> drill = via->GetDrillValue();
3539
3540 std::optional<PCB_LAYER_ID> endLayer;
3541
3542 if( via->BottomLayer() != UNDEFINED_LAYER )
3543 endLayer = via->BottomLayer();
3544
3545 std::optional<int> secondaryDrill = via->GetSecondaryDrillSize();
3546
3547 std::optional<PCB_LAYER_ID> secondaryStart;
3548
3549 if( via->GetSecondaryDrillStartLayer() != UNDEFINED_LAYER )
3550 secondaryStart = via->GetSecondaryDrillStartLayer();
3551
3552 std::optional<PCB_LAYER_ID> secondaryEnd;
3553
3554 if( via->GetSecondaryDrillEndLayer() != UNDEFINED_LAYER )
3555 secondaryEnd = via->GetSecondaryDrillEndLayer();
3556
3557 int copperLayerCount = via->BoardCopperLayerCount();
3558
3559 if( std::optional<PCB_VIA::VIA_PARAMETER_ERROR> error =
3560 PCB_VIA::ValidateViaParameters( diameter, drill, layer, endLayer,
3561 secondaryDrill, secondaryStart, secondaryEnd,
3562 std::nullopt, std::nullopt, std::nullopt, // tertiary drill
3563 copperLayerCount ) )
3564 {
3565 return std::make_unique<VALIDATION_ERROR_MSG>( error->m_Message );
3566 }
3567
3568 return std::nullopt;
3569 };
3570
3571 auto viaEndLayerPropertyValidator =
3572 []( const wxAny&& aValue, EDA_ITEM* aItem ) -> VALIDATOR_RESULT
3573 {
3574 if( !aItem || aItem->Type() != PCB_VIA_T )
3575 return std::nullopt;
3576
3577 PCB_LAYER_ID layer;
3578
3579 if( aValue.CheckType<PCB_LAYER_ID>() )
3580 layer = aValue.As<PCB_LAYER_ID>();
3581 else if( aValue.CheckType<int>() )
3582 layer = static_cast<PCB_LAYER_ID>( aValue.As<int>() );
3583 else
3584 return std::nullopt;
3585
3586 PCB_VIA* via = static_cast<PCB_VIA*>( aItem );
3587
3588 std::optional<int> diameter = via->GetFrontWidth();
3589 std::optional<int> drill = via->GetDrillValue();
3590
3591 std::optional<PCB_LAYER_ID> startLayer;
3592
3593 if( via->TopLayer() != UNDEFINED_LAYER )
3594 startLayer = via->TopLayer();
3595
3596 std::optional<int> secondaryDrill = via->GetSecondaryDrillSize();
3597
3598 std::optional<PCB_LAYER_ID> secondaryStart;
3599
3600 if( via->GetSecondaryDrillStartLayer() != UNDEFINED_LAYER )
3601 secondaryStart = via->GetSecondaryDrillStartLayer();
3602
3603 std::optional<PCB_LAYER_ID> secondaryEnd;
3604
3605 if( via->GetSecondaryDrillEndLayer() != UNDEFINED_LAYER )
3606 secondaryEnd = via->GetSecondaryDrillEndLayer();
3607
3608 int copperLayerCount = via->BoardCopperLayerCount();
3609
3610 if( std::optional<PCB_VIA::VIA_PARAMETER_ERROR> error =
3611 PCB_VIA::ValidateViaParameters( diameter, drill, startLayer, layer,
3612 secondaryDrill, secondaryStart, secondaryEnd,
3613 std::nullopt, std::nullopt, std::nullopt, // tertiary drill
3614 copperLayerCount ) )
3615 {
3616 return std::make_unique<VALIDATION_ERROR_MSG>( error->m_Message );
3617 }
3618
3619 return std::nullopt;
3620 };
3621
3623
3624 // Track
3627
3628 propMgr.AddProperty( new PROPERTY<PCB_TRACK, int>( _HKI( "Width" ),
3630 .SetIsCopyable();
3631 propMgr.ReplaceProperty( TYPE_HASH( BOARD_ITEM ), _HKI( "Position X" ),
3632 new PROPERTY<PCB_TRACK, int>( _HKI( "Start X" ),
3635 propMgr.ReplaceProperty( TYPE_HASH( BOARD_ITEM ), _HKI( "Position Y" ),
3636 new PROPERTY<PCB_TRACK, int>( _HKI( "Start Y" ),
3639 propMgr.AddProperty( new PROPERTY<PCB_TRACK, int>( _HKI( "End X" ),
3642 propMgr.AddProperty( new PROPERTY<PCB_TRACK, int>( _HKI( "End Y" ),
3645
3646 const wxString groupTechLayers = _HKI( "Technical Layers" );
3647
3648 auto isExternalLayerTrack =
3649 []( INSPECTABLE* aItem )
3650 {
3651 if( PCB_TRACK* track = dynamic_cast<PCB_TRACK*>( aItem ) )
3652 return IsExternalCopperLayer( track->GetLayer() );
3653
3654 return false;
3655 };
3656
3657 propMgr.AddProperty( new PROPERTY<PCB_TRACK, bool>( _HKI( "Soldermask" ),
3659 .SetAvailableFunc( isExternalLayerTrack )
3660 .SetIsCopyable();
3661 propMgr.AddProperty( new PROPERTY<PCB_TRACK, std::optional<int>>( _HKI( "Soldermask Margin Override" ),
3664 groupTechLayers )
3665 .SetAvailableFunc( isExternalLayerTrack )
3666 .SetIsCopyable();
3667
3668 // Arc
3671
3672 // Via
3675
3676 const wxString groupVia = _HKI( "Via Properties" );
3677 const wxString groupBackdrill = _HKI( "Backdrill" );
3678 const wxString groupPostMachining = _HKI( "Post-machining" );
3679
3680 propMgr.Mask( TYPE_HASH( PCB_VIA ), TYPE_HASH( BOARD_CONNECTED_ITEM ), _HKI( "Layer" ) );
3681
3682 propMgr.AddProperty( new PROPERTY<PCB_VIA, bool>( _HKI( "Automatically Update Net" ),
3684
3685 // clang-format off: the suggestion is less readable
3686 propMgr.AddProperty( new PROPERTY<PCB_VIA, int>( _HKI( "Diameter" ),
3688 groupVia )
3689 .SetValidator( viaDiameterPropertyValidator )
3690 .SetIsCopyable();
3691 propMgr.AddProperty( new PROPERTY<PCB_VIA, int>( _HKI( "Hole" ),
3693 groupVia )
3694 .SetValidator( viaDrillPropertyValidator )
3695 .SetIsCopyable();
3696 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, PCB_LAYER_ID>( _HKI( "Layer Top" ),
3698 groupVia )
3699 .SetValidator( viaStartLayerPropertyValidator );
3700 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, PCB_LAYER_ID>( _HKI( "Layer Bottom" ),
3702 groupVia )
3703 .SetValidator( viaEndLayerPropertyValidator );
3704 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, VIATYPE>( _HKI( "Via Type" ),
3706 groupVia );
3707 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, TENTING_MODE>( _HKI( "Front Tenting" ),
3709 groupVia )
3710 .SetIsCopyable();
3711 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, TENTING_MODE>( _HKI( "Back Tenting" ),
3713 groupVia )
3714 .SetIsCopyable();
3715 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, COVERING_MODE>( _HKI( "Front Covering" ),
3717 groupVia )
3718 .SetIsCopyable();
3719 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, COVERING_MODE>( _HKI( "Back Covering" ),
3721 groupVia )
3722 .SetIsCopyable();
3723 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, PLUGGING_MODE>( _HKI( "Front Plugging" ),
3725 groupVia )
3726 .SetIsCopyable();
3727 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, PLUGGING_MODE>( _HKI( "Back Plugging" ),
3729 groupVia )
3730 .SetIsCopyable();
3731 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, CAPPING_MODE>( _HKI( "Capping" ),
3733 groupVia )
3734 .SetIsCopyable();
3735 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, FILLING_MODE>( _HKI( "Filling" ),
3737 groupVia )
3738 .SetIsCopyable();
3739
3740 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, BACKDRILL_MODE>( _HKI( "Backdrill Mode" ),
3742 groupBackdrill )
3743 .SetAvailableFunc( []( INSPECTABLE* aItem )
3744 {
3745 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
3746 {
3747 if( via->GetViaType() == VIATYPE::THROUGH )
3748 return true;
3749
3750 if( via->Padstack().GetBackdrillMode() != BACKDRILL_MODE::NO_BACKDRILL )
3751 return true;
3752 }
3753
3754 return false;
3755 } );
3756
3757 propMgr.AddProperty( new PROPERTY<PCB_VIA, std::optional<int>>( _HKI( "Bottom Backdrill Size" ),
3759 groupBackdrill )
3760 .SetAvailableFunc( []( INSPECTABLE* aItem ) -> bool
3761 {
3762 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
3763 {
3764 BACKDRILL_MODE mode = via->GetBackdrillMode();
3767 }
3768
3769 return false;
3770 } );
3771
3772 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, PCB_LAYER_ID>( _HKI( "Bottom Backdrill Must-Cut" ),
3774 .SetAvailableFunc( []( INSPECTABLE* aItem ) -> bool
3775 {
3776 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
3777 {
3778 BACKDRILL_MODE mode = via->GetBackdrillMode();
3781 }
3782
3783 return false;
3784 } );
3785
3786 propMgr.AddProperty( new PROPERTY<PCB_VIA, std::optional<int>>( _HKI( "Top Backdrill Size" ),
3788 groupBackdrill )
3789 .SetAvailableFunc( []( INSPECTABLE* aItem ) -> bool
3790 {
3791 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
3792 {
3793 BACKDRILL_MODE mode = via->GetBackdrillMode();
3794 return mode == BACKDRILL_MODE::BACKDRILL_TOP
3796 }
3797
3798 return false;
3799 } );
3800
3801 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, PCB_LAYER_ID>( _HKI( "Top Backdrill Must-Cut" ),
3803 .SetAvailableFunc( []( INSPECTABLE* aItem ) -> bool
3804 {
3805 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
3806 {
3807 BACKDRILL_MODE mode = via->GetBackdrillMode();
3808 return mode == BACKDRILL_MODE::BACKDRILL_TOP
3810 }
3811
3812 return false;
3813 } );
3814
3815 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, PAD_DRILL_POST_MACHINING_MODE>( _HKI( "Front Post-machining" ),
3817 groupPostMachining );
3818
3819 propMgr.AddProperty( new PROPERTY<PCB_VIA, int>( _HKI( "Front Post-machining Size" ),
3822 groupPostMachining )
3824 []( INSPECTABLE* aItem )
3825 {
3826 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
3827 {
3828 std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = via->GetFrontPostMachining();
3829
3830 if( mode.has_value() )
3831 {
3832 return mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE
3834 }
3835 }
3836
3837 return false;
3838 } );
3839
3840 propMgr.AddProperty( new PROPERTY<PCB_VIA, int>( _HKI( "Front Post-machining Depth" ),
3843 groupPostMachining )
3845 []( INSPECTABLE* aItem )
3846 {
3847 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
3848 {
3849 std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = via->GetFrontPostMachining();
3850
3851 if( mode.has_value() )
3852 return mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE;
3853 }
3854
3855 return false;
3856 } );
3857
3858 propMgr.AddProperty( new PROPERTY<PCB_VIA, int>( _HKI( "Front Post-machining Angle" ),
3861 groupPostMachining )
3863 []( INSPECTABLE* aItem )
3864 {
3865 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
3866 {
3867 std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = via->GetFrontPostMachining();
3868
3869 if( mode.has_value() )
3871 }
3872
3873 return false;
3874 } );
3875
3876 propMgr.AddProperty( new PROPERTY_ENUM<PCB_VIA, PAD_DRILL_POST_MACHINING_MODE>( _HKI( "Back Post-machining" ),
3878
3879 propMgr.AddProperty( new PROPERTY<PCB_VIA, int>( _HKI( "Back Post-machining Size" ),
3881 groupPostMachining )
3883 []( INSPECTABLE* aItem )
3884 {
3885 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
3886 {
3887 std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = via->GetBackPostMachining();
3888
3889 if( mode.has_value() )
3890 {
3891 return mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE
3893 }
3894 }
3895
3896 return false;
3897 } );
3898
3899 propMgr.AddProperty( new PROPERTY<PCB_VIA, int>( _HKI( "Back Post-machining Depth" ),
3901 groupPostMachining )
3903 []( INSPECTABLE* aItem )
3904 {
3905 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
3906 {
3907 std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = via->GetBackPostMachining();
3908
3909 if( mode.has_value() )
3910 return mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE;
3911 }
3912
3913 return false;
3914 } );
3915
3916 propMgr.AddProperty( new PROPERTY<PCB_VIA, int>( _HKI( "Back Post-machining Angle" ),
3918 groupPostMachining )
3920 []( INSPECTABLE* aItem )
3921 {
3922 if( PCB_VIA* via = dynamic_cast<PCB_VIA*>( aItem ) )
3923 {
3924 std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = via->GetBackPostMachining();
3925
3926 if( mode.has_value() )
3927 return mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK;
3928 }
3929
3930 return false;
3931 } );
3932 // clang-format on: the suggestion is less readable
3933 }
3935
KICOMMON_API types::KiCadObjectType ToProtoEnum(KICAD_T aValue)
KICOMMON_API KICAD_T FromProtoEnum(types::KiCadObjectType aValue)
Definition api_enums.cpp:56
ERROR_LOC
When approximating an arc or circle, should the error be placed on the outside or inside of the curve...
@ ERROR_INSIDE
constexpr EDA_IU_SCALE pcbIUScale
Definition base_units.h:128
constexpr int ARC_LOW_DEF
Definition base_units.h:143
BITMAPS
A list of all bitmap identifiers.
ZONE_LAYER_OVERRIDE
Conditionally flashed vias and pads that interact with zones of different priority can be very squirr...
Definition board_item.h:75
@ ZLO_NONE
Definition board_item.h:76
@ ZLO_FORCE_FLASHED
Definition board_item.h:77
SEG MIRROR_AXIS(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection)
Definition board_item.h:85
constexpr BOX2I BOX2ISafe(const BOX2D &aInput)
Definition box2.h:924
BOX2< VECTOR2I > BOX2I
Definition box2.h:917
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition box2.h:985
BASE_SET & set(size_t pos)
Definition base_set.h:126
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.
PCB_LAYER_ID GetLayer() const override
Return the primary layer this item is on.
BOARD_CONNECTED_ITEM(BOARD_ITEM *aParent, KICAD_T idtype)
void PackNet(kiapi::board::types::Net *aProto) const
void SetLayer(PCB_LAYER_ID aLayer) override
Set the layer this item is on.
NETINFO_ITEM * GetNet() const
Return NETINFO_ITEM object for a given 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.
void UnpackNet(const kiapi::board::types::Net &aProto)
Assigns a net to this item from an API message.
TEARDROP_PARAMETERS & GetTeardropParams()
void SetTeardropsEnabled(bool aEnable)
std::shared_ptr< DRC_ENGINE > m_DRCEngine
BOARD_STACKUP & GetStackupDescriptor()
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition board_item.h:99
BOARD_ITEM(BOARD_ITEM *aParent, KICAD_T idtype, PCB_LAYER_ID aLayer=F_Cu)
Definition board_item.h:101
void SetUuidDirect(const KIID &aUuid)
Raw UUID assignment.
void SetLocked(bool aLocked) override
Definition board_item.h:441
PCB_LAYER_ID GetFlippedLayer(PCB_LAYER_ID aLayer) const
Return the layer paired with aLayer on the opposite side of the board.
LSET viewVisibleLayers(const KIGFX::VIEW *aView) const
Enabled board layers that aView shows, for LOD checks on views that hide layers on their own.
PCB_LAYER_ID m_layer
Definition board_item.h:625
bool IsLocked() const override
virtual double GetCoverageArea(int aTextMargin) const
Return the board area this item covers, used to rank candidates under the cursor so a click on a smal...
virtual const BOARD * GetBoard() const
Return the BOARD in which this BOARD_ITEM resides, or NULL if none.
virtual void TransformShapeToPolySet(SHAPE_POLY_SET &aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, KIGFX::RENDER_SETTINGS *aRenderSettings=nullptr) const
Convert the item shape to a polyset.
Definition board_item.h:582
virtual wxString LayerMaskDescribe() const
Return a string (to be shown to the user) describing a layer mask.
BOARD_ITEM & operator=(const BOARD_ITEM &aOther)
Definition board_item.h:118
BOARD_ITEM_CONTAINER * GetParent() const
Definition board_item.h:281
virtual int BoardCopperLayerCount() const
Return the total number of copper layers for the board that this item resides on.
wxString GetLayerName() const
Return the name of the PCB layer on which the item resides.
virtual bool HasHole() const
Definition board_item.h:222
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:411
LENGTH_DELAY_CALCULATION * GetLengthCalculation() const
Returns the track length calculator.
Definition board.h:1703
std::tuple< int, double, double, double, double > GetTrackLength(const PCB_TRACK &aTrack) const
Return data on the length and number of track segments connected to a given track.
Definition board.cpp:3517
const LSET & GetVisibleLayers() const
A proxy function that calls the correspondent function in m_BoardSettings.
Definition board.cpp:1216
int GetCopperLayerCount() const
Definition board.cpp:1155
const TRACKS & Tracks() const
Definition board.h:463
const LSET & GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
Definition board.cpp:1202
BOARD_DESIGN_SETTINGS & GetDesignSettings()
Definition board.cpp:1318
std::shared_ptr< CONNECTIVITY_DATA > GetConnectivity() const
Return a list of missing connections between components/tracks.
Definition board.h:758
constexpr BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
Definition box2.h:556
constexpr BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition box2.h:597
bool IntersectsCircle(const Vec &aCenter, const int aRadius) const
Definition box2.h:502
constexpr coord_type GetLeft() const
Definition box2.h:231
constexpr bool Contains(const Vec &aPoint) const
Definition box2.h:171
constexpr coord_type GetRight() const
Definition box2.h:220
constexpr coord_type GetTop() const
Definition box2.h:232
constexpr bool Intersects(const BOX2< Vec > &aRect) const
Definition box2.h:314
constexpr coord_type GetBottom() const
Definition box2.h:225
bool IsConnectedOnLayer(const BOARD_CONNECTED_ITEM *aItem, int aLayer, const std::initializer_list< KICAD_T > &aTypes={}) const
wxString GetName() const
Definition drc_rule.h:162
MINOPTMAX< int > & Value()
Definition drc_rule.h:130
MINOPTMAX< int > m_Value
Definition drc_rule.h:206
void Merge(const DRC_CONSTRAINT &aOther)
Definition drc_rule.cpp:121
Design Rule Checker object that performs all the DRC tests.
Definition drc_engine.h:129
DRC_CONSTRAINT EvalRules(DRC_CONSTRAINT_T aConstraintType, const BOARD_ITEM *a, const BOARD_ITEM *b, PCB_LAYER_ID aLayer, REPORTER *aReporter=nullptr)
EDA_ANGLE Normalize()
Definition eda_angle.h:228
EDA_ANGLE Normalize180()
Definition eda_angle.h:273
The base class for create windows for drawing purpose.
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
void SetFlags(EDA_ITEM_FLAGS aMask)
Definition eda_item.h:158
const KIID m_Uuid
Definition eda_item.h:599
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
Definition eda_item.h:160
EDA_ITEM_FLAGS m_flags
Definition eda_item.h:608
bool HasFlag(EDA_ITEM_FLAGS aFlag) const
Definition eda_item.h:168
EDA_ITEM_FLAGS GetFlags() const
Definition eda_item.h:167
EDA_ITEM(EDA_ITEM *parent, KICAD_T idType, bool isSCH_ITEM=false, bool isBOARD_ITEM=false)
Definition eda_item.cpp:84
ENUM_MAP & Map(T aValue, const wxString &aName)
Definition property.h:817
static ENUM_MAP< T > & Instance()
Definition property.h:811
ENUM_MAP & Undefined(T aValue)
Definition property.h:824
wxPGChoices & Choices()
Definition property.h:862
Class that other classes need to inherit from, in order to be inspectable.
Definition inspectable.h:39
Contains methods for drawing PCB-specific items.
virtual PCB_RENDER_SETTINGS * GetSettings() override
Return a pointer to current settings that are going to be used when drawing items.
PCB specific render settings.
Definition pcb_painter.h:94
PCB_LAYER_ID GetPrimaryHighContrastLayer() const
Return the board layer which is in high-contrast mode.
static double lodScaleForThreshold(const KIGFX::VIEW *aView, int aWhatIu, int aThresholdIu)
Get the scale at which aWhatIu would be drawn at the same size as aThresholdIu on screen.
Definition view_item.cpp:35
static constexpr double LOD_HIDE
Return this constant from ViewGetLOD() to hide the item unconditionally.
Definition view_item.h:176
static constexpr double LOD_SHOW
Return this constant from ViewGetLOD() to show the item unconditionally.
Definition view_item.h:181
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition view.h:68
BOX2D GetViewport() const
Return the current viewport visible area rectangle.
Definition view.cpp:860
bool IsLayerVisibleCached(int aLayer) const
Definition view.h:472
PAINTER * GetPainter() const
Return the painter object used by the view for drawing VIEW_ITEM objects.
Definition view.h:242
Definition kiid.h:46
static bool Contains(int aStart_layer, int aEnd_layer, int aTest_layer)
Class which calculates lengths (and associated routing statistics) in a BOARD context.
int64_t CalculateDelay(std::vector< LENGTH_DELAY_CALCULATION_ITEM > &aItems, PATH_OPTIMISATIONS aOptimisations, const PAD *aStartPad=nullptr, const PAD *aEndPad=nullptr) const
Calculates the electrical propagation delay of the given items.
LENGTH_DELAY_CALCULATION_ITEM GetLengthCalculationItem(const BOARD_CONNECTED_ITEM *aBoardItem) const
Return a LENGTH_CALCULATION_ITEM constructed from the given BOARD_CONNECTED_ITEM.
LSET is a set of PCB_LAYER_IDs.
Definition lset.h:37
static const LSET & AllCuMask()
return AllCuMask( MAX_CU_LAYERS );
Definition lset.cpp:604
void RunOnLayers(const std::function< void(PCB_LAYER_ID)> &aFunction) const
Execute a function on each layer of the LSET.
Definition lset.h:275
static const LSET & BackTechMask()
Return a mask holding all technical layers (no CU layer) on back side.
Definition lset.cpp:644
static const LSET & AllLayersMask()
Definition lset.cpp:637
static const LSET & PhysicalLayersMask()
Return a mask holding all layers which are physically realized.
Definition lset.cpp:693
static wxString Name(PCB_LAYER_ID aLayerId)
Return the fixed name association with aLayerId.
Definition lset.cpp:184
bool Contains(PCB_LAYER_ID aLayer) const
See if the layer set contains a PCB layer.
Definition lset.h:63
static const LSET & FrontTechMask()
Return a mask holding all technical layers (no CU layer) on front side.
Definition lset.cpp:658
T Min() const
Definition minoptmax.h:29
T PinnedOpt() const
Definition minoptmax.h:32
bool HasMin() const
Definition minoptmax.h:37
T Opt() const
Definition minoptmax.h:31
bool HasOpt() const
Definition minoptmax.h:39
A collection of nets and the parameters used to route or test these nets.
Definition netclass.h:44
int GetViaDrill() const
Definition netclass.h:166
int GetuViaDrill() const
Definition netclass.h:182
Handle the data for a net.
Definition netinfo.h:50
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
Definition netinfo.h:281
A PADSTACK defines the characteristics of a single or multi-layer pad, in the IPC sense of the word.
Definition padstack.h:161
void ForEachUniqueLayer(const std::function< void(PCB_LAYER_ID)> &aMethod) const
Runs the given callable for each active unique copper layer in this padstack, meaning F_Cu for MODE::...
DRILL_PROPS & Drill()
Definition padstack.h:363
@ NORMAL
Shape is the same on all layers.
Definition padstack.h:175
@ FRONT_INNER_BACK
Up to three shapes can be defined (F_Cu, inner copper layers, B_Cu)
Definition padstack.h:176
void Serialize(google::protobuf::Any &aContainer) const override
Serializes this object to the given Any message.
Definition padstack.cpp:863
static constexpr PCB_LAYER_ID ALL_LAYERS
! The layer identifier to use for the single defintion on normal padstacks
Definition padstack.h:184
static constexpr PCB_LAYER_ID INNER_LAYERS
! The layer identifier to use for "inner layers" on top/inner/bottom padstacks
Definition padstack.h:187
VECTOR2I GetPosition() const override
static std::unique_ptr< PCB_TRACK > CreateFromThreePoints(BOARD_ITEM *aParent, const VECTOR2I &aStart, const VECTOR2I &aMid, const VECTOR2I &aEnd)
Create a PCB_ARC through the three points, or a PCB_TRACK segment when they are straight.
Definition pcb_track.cpp:95
bool IsDegenerated(int aThreshold=5) const
virtual void swapData(BOARD_ITEM *aImage) override
bool IsCCW() const
void Serialize(google::protobuf::Any &aContainer) const override
Serializes this object to the given Any message.
EDA_ITEM * Clone() const override
Create a duplicate of this item with linked list members set to NULL.
void Flip(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Flip this object, i.e.
EDA_ANGLE GetArcAngleStart() const
std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=FLASHING::DEFAULT, DRC_CONSTRAINT_T aUsage=NULL_CONSTRAINT) const override
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
void Mirror(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Mirror this object relative to a given horizontal axis the layer is not changed.
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
EDA_ANGLE GetArcAngleEnd() const
bool Deserialize(const google::protobuf::Any &aContainer) override
Deserializes the given protobuf message into this object.
void SetMid(const VECTOR2I &aMid)
Definition pcb_track.h:303
double GetRadius() const
EDA_ANGLE GetAngle() const
const VECTOR2I & GetMid() const
Definition pcb_track.h:304
PCB_ARC(BOARD_ITEM *aParent)
Definition pcb_track.h:268
double Similarity(const BOARD_ITEM &aOther) const override
Return a measure of how likely the other object is to represent the same object.
VECTOR2I m_Mid
Arc mid point, halfway between start and end.
Definition pcb_track.h:368
void Rotate(const VECTOR2I &aRotCentre, const EDA_ANGLE &aAngle) override
Rotate this object.
bool operator==(const PCB_ARC &aOther) const
void CopyFrom(const BOARD_ITEM *aOther) override
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
virtual void SetLayerSet(const LSET &aLayers) override
int GetSolderMaskExpansion() const
void Rotate(const VECTOR2I &aRotCentre, const EDA_ANGLE &aAngle) override
Rotate this object.
void Serialize(google::protobuf::Any &aContainer) const override
Serializes this object to the given Any message.
void SetEndY(int aY)
Definition pcb_track.h:109
void SetHasSolderMask(bool aVal)
Definition pcb_track.h:123
virtual double GetLength() const
Get the length of the track using the hypotenuse calculation.
double ViewGetLOD(int aLayer, const KIGFX::VIEW *aView) const override
Return the level of detail (LOD) of the item.
void swapData(BOARD_ITEM *aImage) override
void SetEnd(const VECTOR2I &aEnd)
Definition pcb_track.h:96
bool HasSolderMask() const
Definition pcb_track.h:124
void SetStart(const VECTOR2I &aStart)
Definition pcb_track.h:99
const BOX2I ViewBBox() const override
Return the bounding box of the item covering all its layers.
int GetStartY() const
Definition pcb_track.h:106
int GetEndX() const
Definition pcb_track.h:111
wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider, bool aFull) const override
Return a user-visible description string of this item.
void Mirror(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Mirror this object relative to a given horizontal axis the layer is not changed.
bool Deserialize(const google::protobuf::Any &aContainer) override
Deserializes the given protobuf message into this object.
INSPECT_RESULT Visit(INSPECTOR inspector, void *testData, const std::vector< KICAD_T > &aScanTypes) override
May be re-implemented for each derived class in order to handle all the types given by its member dat...
bool ApproxCollinear(const PCB_TRACK &aTrack)
VECTOR2I m_End
Line end point.
Definition pcb_track.h:255
void SetLocalSolderMaskMargin(std::optional< int > aMargin)
Definition pcb_track.h:126
std::optional< int > m_solderMaskMargin
Definition pcb_track.h:258
void CopyFrom(const BOARD_ITEM *aOther) override
Definition pcb_track.cpp:79
std::optional< int > GetLocalSolderMaskMargin() const
Definition pcb_track.h:127
virtual double GetDelay() const
Get the time delay of the track.
void GetMsgPanelInfo(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList) override
Populate aList of MSG_PANEL_ITEM objects with it's internal state for display purposes.
EDA_ITEM * Clone() const override
Create a duplicate of this item with linked list members set to NULL.
Definition pcb_track.cpp:73
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
void TransformShapeToPolygon(SHAPE_POLY_SET &aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=false) const override
Convert the track shape to a closed polygon.
const VECTOR2I & GetStart() const
Definition pcb_track.h:100
bool operator==(const BOARD_ITEM &aOther) const override
VECTOR2I m_Start
Line start point.
Definition pcb_track.h:254
int GetEndY() const
Definition pcb_track.h:112
wxString GetFriendlyName() const override
std::vector< int > ViewGetLayers() const override
Return the all the layers within the VIEW the object is painted on.
BITMAPS GetMenuImage() const override
Return a pointer to an image to be used in menus.
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
void Flip(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Flip this object, i.e.
double Similarity(const BOARD_ITEM &aOther) const override
Return a measure of how likely the other object is to represent the same object.
bool m_hasSolderMask
Definition pcb_track.h:257
void SetStartX(int aX)
Definition pcb_track.h:102
const VECTOR2I & GetEnd() const
Definition pcb_track.h:97
PCB_TRACK(BOARD_ITEM *aParent, KICAD_T idtype=PCB_TRACE_T)
Definition pcb_track.cpp:65
void SetStartY(int aY)
Definition pcb_track.h:103
std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=FLASHING::DEFAULT, DRC_CONSTRAINT_T aUsage=NULL_CONSTRAINT) const override
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
bool IsOnLayer(PCB_LAYER_ID aLayer) const override
Test to see if this object is on the given layer.
virtual MINOPTMAX< int > GetWidthConstraint(wxString *aSource=nullptr) const
double GetCoverageArea(int aTextMargin) const override
Return the board area this item covers, used to rank candidates under the cursor so a click on a smal...
void SetEndX(int aX)
Definition pcb_track.h:108
int GetStartX() const
Definition pcb_track.h:105
int m_width
Thickness of track (or arc) – no longer the width of a via.
Definition pcb_track.h:261
EDA_ITEM_FLAGS IsPointOnEnds(const VECTOR2I &point, int min_dist=0) const
Return STARTPOINT if point if near (dist = min_dist) start point, ENDPOINT if point if near (dist = m...
virtual void SetWidth(int aWidth)
Definition pcb_track.h:93
virtual int GetWidth() const
Definition pcb_track.h:94
void GetMsgPanelInfoBase_Common(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList) const
FILLING_MODE ResolveFillingMode() const
bool GetIsFree() const
Check if the via is a free via (as opposed to one created on a track by the router).
Definition pcb_track.h:890
int GetFrontPostMachiningSize() const
Definition pcb_track.h:755
PCB_LAYER_ID BottomLayer() const
BITMAPS GetMenuImage() const override
Return a pointer to an image to be used in menus.
std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=FLASHING::DEFAULT, DRC_CONSTRAINT_T aUsage=NULL_CONSTRAINT) const override
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
PLUGGING_MODE GetFrontPluggingMode() const
VECTOR2I GetPosition() const override
Definition pcb_track.h:615
bool IsTented(PCB_LAYER_ID aLayer) const override
Checks if the given object is tented (its copper shape is covered by solder mask) on a given side of ...
void CopyFrom(const BOARD_ITEM *aOther) override
double GetCoverageArea(int aTextMargin) const override
Return the board area this item covers, used to rank candidates under the cursor so a click on a smal...
PCB_LAYER_ID GetTopBackdrillLayer() const
Definition pcb_track.h:455
bool IsGhostLayer(PCB_LAYER_ID aLayer) const
void SetFrontPostMachiningDepth(int aDepth)
Definition pcb_track.h:756
void SetCappingMode(CAPPING_MODE aMode)
void SetFrontCoveringMode(COVERING_MODE aMode)
wxString LayerMaskDescribe() const override
Return a string (to be shown to the user) describing a layer mask.
CAPPING_MODE ResolveCappingMode() const
int GetBackPostMachiningDepth() const
Definition pcb_track.h:780
bool Deserialize(const google::protobuf::Any &aContainer) override
Deserializes the given protobuf message into this object.
void SetBackPostMachiningAngle(int aAngle)
Definition pcb_track.h:781
int GetBackPostMachiningAngle() const
Definition pcb_track.h:782
COVERING_MODE GetBackCoveringMode() const
std::optional< int > GetTertiaryDrillSize() const
PLUGGING_MODE ResolveFrontPluggingMode() const
void SetTopBackdrillSize(std::optional< int > aSize)
Definition pcb_track.h:453
bool FlashLayer(int aLayer) const
Check to see whether the via should have a pad on the specific layer.
ZONE_LAYER_OVERRIDE GetZoneLayerOverride(PCB_LAYER_ID aLayer) const
void SetBackPostMachiningMode(PAD_DRILL_POST_MACHINING_MODE aMode)
Definition pcb_track.h:767
std::optional< int > GetTopBackdrillSize() const
Definition pcb_track.h:452
void SetBackdrillMode(BACKDRILL_MODE aMode)
Definition pcb_track.h:444
void SetDrillDefault()
Set the drill value for vias to the default value UNDEFINED_DRILL_DIAMETER.
Definition pcb_track.h:850
void SetBottomBackdrillSize(std::optional< int > aSize)
Definition pcb_track.h:447
void ClearZoneLayerOverrides()
CAPPING_MODE GetCappingMode() const
const PADSTACK & Padstack() const
Definition pcb_track.h:435
void SetFrontTentingMode(TENTING_MODE aMode)
bool m_isFree
"Free" vias don't get their nets auto-updated
Definition pcb_track.h:938
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
bool HasCopperRemoved(PCB_LAYER_ID aLayer) const
Check whether backdrilling or post-machining left no copper at all on a layer.
int GetFrontPostMachiningDepth() const
Definition pcb_track.h:757
bool IsBlindVia() const
static std::vector< std::vector< PCB_VIA * > > CollectMicroviaColumns(BOARD *aBoard)
Runs of microvias that land on one another, each ordered from its outermost hop down.
TENTING_MODE GetFrontTentingMode() const
int GetPostMachiningKnockout(PCB_LAYER_ID aLayer) const
Get the knockout diameter for a layer affected by post-machining.
void SetBottomLayer(PCB_LAYER_ID aLayer)
void SetPrimaryDrillSize(const VECTOR2I &aSize)
Set the drill value for vias.
bool IsBackdrilledOrPostMachined(PCB_LAYER_ID aLayer) const
Check if a layer is affected by backdrilling or post-machining operations.
std::optional< int > GetSecondaryDrillSize() const
PLUGGING_MODE ResolveBackPluggingMode() const
void SetPrimaryDrillCappedFlag(bool aCapped)
int GetSolderMaskExpansion() const
void SetSecondaryDrillStartLayer(PCB_LAYER_ID aLayer)
void SetTertiaryDrillEndLayer(PCB_LAYER_ID aLayer)
bool HasValidLayerPair(int aCopperLayerCount) const
void ClearSecondaryDrillSize()
void SetBackPostMachiningDepth(int aDepth)
Definition pcb_track.h:779
void SetDrill(int aDrill)
Definition pcb_track.h:831
PLUGGING_MODE GetBackPluggingMode() const
void SetBackPluggingMode(PLUGGING_MODE aMode)
MINOPTMAX< int > GetDrillConstraint(wxString *aSource=nullptr) const
void SetPadstackMode(PADSTACK::MODE aMode)
Definition pcb_track.h:499
void SetBackTentingMode(TENTING_MODE aMode)
void SetIsFree(bool aFree=true)
Definition pcb_track.h:891
COVERING_MODE ResolveBackCoveringMode() const
void SetFrontPluggingMode(PLUGGING_MODE aMode)
void Flip(const VECTOR2I &aCentre, FLIP_DIRECTION aFlipDirection) override
Flip this object, i.e.
void GetMsgPanelInfo(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList) override
Populate aList of MSG_PANEL_ITEM objects with it's internal state for display purposes.
EDA_ITEM * Clone() const override
Create a duplicate of this item with linked list members set to NULL.
void SetFrontPostMachining(const std::optional< PAD_DRILL_POST_MACHINING_MODE > &aMode)
bool operator==(const PCB_VIA &aOther) const
PCB_LAYER_ID GetLayer() const override
Return the primary layer this item is on.
void SetSecondaryDrillEndLayer(PCB_LAYER_ID aLayer)
int GetFrontPostMachiningAngle() const
Definition pcb_track.h:759
std::shared_ptr< SHAPE_SEGMENT > GetEffectiveHoleShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, DRC_CONSTRAINT_T aUsage=NULL_CONSTRAINT) const override
void SetFrontPostMachiningAngle(int aAngle)
Definition pcb_track.h:758
void SetTopLayer(PCB_LAYER_ID aLayer)
FILLING_MODE GetFillingMode() const
int GetBackdrillOrPostMachiningKnockout(PCB_LAYER_ID aLayer) const
bool IsBuriedVia() const
int GetFrontWidth() const
Definition pcb_track.h:509
void SetSizeFromRules(int aDiameter, int aDrill)
Give the via a uniform padstack sized from its diameter and hole rules.
std::array< std::atomic< ZONE_LAYER_OVERRIDE >, MAX_CU_LAYERS > m_zoneLayerOverrides
Definition pcb_track.h:941
void SetLayerPair(PCB_LAYER_ID aTopLayer, PCB_LAYER_ID aBottomLayer)
For a via m_layer contains the top layer, the other layer is in m_bottomLayer/.
PAD_DRILL_POST_MACHINING_MODE GetFrontPostMachiningMode() const
Definition pcb_track.h:749
bool IsOnCopperLayer() const override
void SetFrontPostMachiningSize(int aSize)
Definition pcb_track.h:754
wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider, bool aFull) const override
Return a user-visible description string of this item.
double Similarity(const BOARD_ITEM &aOther) const override
Return a measure of how likely the other object is to represent the same object.
void SetLayer(PCB_LAYER_ID aLayer) override
Set the layer this item is on.
void SetTertiaryDrillStartLayer(PCB_LAYER_ID aLayer)
PCB_LAYER_ID GetBottomBackdrillLayer() const
Definition pcb_track.h:449
void SetPrimaryDrillShape(PAD_DRILL_SHAPE aShape)
static std::optional< VIA_PARAMETER_ERROR > ValidateViaParameters(std::optional< int > aDiameter, std::optional< int > aPrimaryDrill, std::optional< PCB_LAYER_ID > aPrimaryStartLayer=std::nullopt, std::optional< PCB_LAYER_ID > aPrimaryEndLayer=std::nullopt, std::optional< int > aSecondaryDrill=std::nullopt, std::optional< PCB_LAYER_ID > aSecondaryStartLayer=std::nullopt, std::optional< PCB_LAYER_ID > aSecondaryEndLayer=std::nullopt, std::optional< int > aTertiaryDrill=std::nullopt, std::optional< PCB_LAYER_ID > aTertiaryStartLayer=std::nullopt, std::optional< PCB_LAYER_ID > aTertiaryEndLayer=std::nullopt, int aCopperLayerCount=0)
bool IsMicroVia() const
void SetTertiaryDrillShape(PAD_DRILL_SHAPE aShape)
virtual void SetLayerSet(const LSET &aLayers) override
Note SetLayerSet() initialize the first and last copper layers connected by the via.
void GetOutermostConnectedLayers(PCB_LAYER_ID *aTopmost, PCB_LAYER_ID *aBottommost) const
Return the top-most and bottom-most connected layers.
void SetSecondaryDrillShape(PAD_DRILL_SHAPE aShape)
void SanitizeLayers()
Check so that the layers are correct depending on the type of via, and so that the top actually is on...
int GetWidth() const override
void SetBackPostMachining(const std::optional< PAD_DRILL_POST_MACHINING_MODE > &aMode)
PCB_VIA & operator=(const PCB_VIA &aOther)
void swapData(BOARD_ITEM *aImage) override
void Serialize(google::protobuf::Any &aContainer) const override
Serializes this object to the given Any message.
void SetFillingMode(FILLING_MODE aMode)
bool GetIsNotFree() const
Definition pcb_track.h:894
PCB_VIA(BOARD_ITEM *aParent)
void SetPrimaryDrillFilledFlag(bool aFilled)
std::optional< int > GetBottomBackdrillSize() const
Definition pcb_track.h:446
std::vector< int > ViewGetLayers() const override
Return the all the layers within the VIEW the object is painted on.
void SetViaType(VIATYPE aViaType)
Definition pcb_track.h:427
int GetMinAnnulus(PCB_LAYER_ID aLayer, wxString *aSource) const
bool IsOnLayer(PCB_LAYER_ID aLayer) const override
Test to see if this object is on the given layer.
TENTING_MODE GetBackTentingMode() const
PCB_LAYER_ID TopLayer() const
void ClearTertiaryDrillSize()
VIATYPE m_viaType
through, blind/buried or micro
Definition pcb_track.h:934
void SetBottomBackdrillLayer(PCB_LAYER_ID aLayer)
Definition pcb_track.h:450
int GetBackPostMachiningSize() const
Definition pcb_track.h:778
TENTING_MODE ResolveBackTentingMode() const
void SetTertiaryDrillSize(const VECTOR2I &aSize)
void SetIsNotFree(bool aNotFree)
Definition pcb_track.h:895
PADSTACK m_padStack
Definition pcb_track.h:936
void SetSecondaryDrillSize(const VECTOR2I &aSize)
COVERING_MODE GetFrontCoveringMode() const
int GetDrillValue() const
Calculate the drill value for vias (m_drill if > 0, or default drill value for the board).
void SetZoneLayerOverride(PCB_LAYER_ID aLayer, ZONE_LAYER_OVERRIDE aOverride)
bool sameZoneLayerOverrides(const PCB_VIA &aOther) const
PAD_DRILL_POST_MACHINING_MODE GetBackPostMachiningMode() const
Definition pcb_track.h:772
void SetFrontWidth(int aWidth)
Definition pcb_track.h:508
VIATYPE GetViaType() const
Definition pcb_track.h:426
double ViewGetLOD(int aLayer, const KIGFX::VIEW *aView) const override
Return the level of detail (LOD) of the item.
void SetPrimaryDrillCapped(const std::optional< bool > &aCapped)
COVERING_MODE ResolveFrontCoveringMode() const
MINOPTMAX< int > GetWidthConstraint(wxString *aSource=nullptr) const override
BACKDRILL_MODE GetBackdrillMode() const
Definition pcb_track.h:443
void SetWidth(int aWidth) override
void SetBackCoveringMode(COVERING_MODE aMode)
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
void SetPrimaryDrillFilled(const std::optional< bool > &aFilled)
void SetTopBackdrillLayer(PCB_LAYER_ID aLayer)
Definition pcb_track.h:456
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)
void SetFrontPostMachiningMode(PAD_DRILL_POST_MACHINING_MODE aMode)
Definition pcb_track.h:744
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
TENTING_MODE ResolveFrontTentingMode() const
void SetBackPostMachiningSize(int aSize)
Definition pcb_track.h:777
void SetPrimaryDrillEndLayer(PCB_LAYER_ID aLayer)
void SetPrimaryDrillStartLayer(PCB_LAYER_ID aLayer)
PROPERTY_BASE & SetAvailableFunc(std::function< bool(INSPECTABLE *)> aFunc)
Set a callback function to determine whether an object provides this property.
Definition property.h:275
PROPERTY_BASE & SetValidator(PROPERTY_VALIDATOR_FN &&aValidator)
Definition property.h:397
PROPERTY_BASE & SetIsCopyable(bool aIsCopyable=true)
Definition property.h:388
Provide class metadata.
void InheritsAfter(TYPE_ID aDerived, TYPE_ID aBase)
Declare an inheritance relationship between types.
void Mask(TYPE_ID aDerived, TYPE_ID aBase, const wxString &aName)
Sets a base class property as masked in a derived class.
static PROPERTY_MANAGER & Instance()
PROPERTY_BASE & AddProperty(PROPERTY_BASE *aProperty, const wxString &aGroup=wxEmptyString)
Register a property.
PROPERTY_BASE & ReplaceProperty(size_t aBase, const wxString &aName, PROPERTY_BASE *aNew, const wxString &aGroup=wxEmptyString)
Replace an existing property for a specific type.
Definition seg.h:38
const VECTOR2I ReflectPoint(const VECTOR2I &aP) const
Reflect a point using this segment as axis.
Definition seg.cpp:630
static SEG::ecoord Square(int a)
Definition seg.h:119
bool ApproxCollinear(const SEG &aSeg, int aDistanceThreshold=1) const
Definition seg.cpp:759
const VECTOR2I & GetArcMid() const
Definition shape_arc.h:116
const VECTOR2I & GetP1() const
Definition shape_arc.h:115
bool IsEffectiveLine() const
const VECTOR2I & GetP0() const
Definition shape_arc.h:114
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
Represent a set of closed polygons.
double Area()
Return the area of this poly set.
wxString MessageTextFromValue(double aValue, bool aAddUnitLabel=true, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE) const
A lower-precision version of StringFromValue().
wxString MessageTextFromMinOptMax(const MINOPTMAX< int > &aValue, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE) const
constexpr extended_type Cross(const VECTOR2< T > &aVector) const
Compute cross product of self with aVector.
Definition vector2d.h:559
T EuclideanNorm() const
Compute the Euclidean norm of the vector, which is defined as sqrt(x ** 2 + y ** 2).
Definition vector2d.h:281
void TransformCircleToPolygon(SHAPE_LINE_CHAIN &aBuffer, const VECTOR2I &aCenter, int aRadius, int aError, ERROR_LOC aErrorLoc, int aMinSegCount=0)
Convert a circle to a polygon, using multiple straight lines.
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.
void TransformOvalToPolygon(SHAPE_POLY_SET &aBuffer, const VECTOR2I &aStart, const VECTOR2I &aEnd, int aWidth, int aError, ERROR_LOC aErrorLoc, int aMinSegCount=0)
Convert a oblong shape to a polygon, using multiple segments.
@ ANNULAR_WIDTH_CONSTRAINT
@ VIA_DIAMETER_CONSTRAINT
@ TRACK_WIDTH_CONSTRAINT
@ SILK_CLEARANCE_CONSTRAINT
@ HOLE_CLEARANCE_CONSTRAINT
@ SOLDER_MASK_EXPANSION_CONSTRAINT
@ HOLE_SIZE_CONSTRAINT
@ PHYSICAL_CLEARANCE_CONSTRAINT
@ HOLE_TO_HOLE_CONSTRAINT
#define _(s)
static constexpr EDA_ANGLE ANGLE_0
Definition eda_angle.h:472
static constexpr EDA_ANGLE ANGLE_360
Definition eda_angle.h:478
#define PCB_EDIT_FRAME_NAME
INSPECT_RESULT
Definition eda_item.h:44
const INSPECTOR_FUNC & INSPECTOR
std::function passed to nested users by ref, avoids copying std::function.
Definition eda_item.h:91
#define ROUTER_TRANSIENT
transient items that should NOT be cached
#define ENDPOINT
ends. (Used to support dragging.)
std::uint32_t EDA_ITEM_FLAGS
#define STARTPOINT
When a line is selected, these flags indicate which.
a few functions useful in geometry calculations.
bool ClipLine(const BOX2I *aClipBox, int &x1, int &y1, int &x2, int &y2)
Test if any part of a line falls within the bounds of a rectangle.
std::string source
bool IsSolderMaskLayer(int aLayer)
Definition layer_ids.h:815
@ LAYER_VIA_NETNAMES
Definition layer_ids.h:199
bool IsDrillSymbolLayer(int aLayer)
Definition layer_ids.h:966
bool IsCopperLayerLowerThan(PCB_LAYER_ID aLayerA, PCB_LAYER_ID aLayerB)
Return true if copper aLayerA is placed lower than aLayerB, false otherwise.
Definition layer_ids.h:891
constexpr PCB_LAYER_ID PCBNEW_LAYER_ID_START
Definition layer_ids.h:170
bool IsFrontLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a front layer.
Definition layer_ids.h:847
FLASHING
Enum used during connectivity building to ensure we do not query connectivity while building the data...
Definition layer_ids.h:180
@ DEFAULT
Flashing follows connectivity.
Definition layer_ids.h:181
@ ALWAYS_FLASHED
Always flashed for connectivity.
Definition layer_ids.h:182
bool IsBackLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a back layer.
Definition layer_ids.h:870
#define MAX_CU_LAYERS
Definition layer_ids.h:172
int GetNetnameLayer(int aLayer)
Return a netname layer corresponding to the given layer.
Definition layer_ids.h:921
bool IsClearanceLayer(int aLayer)
Definition layer_ids.h:960
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
Definition layer_ids.h:744
@ LAYER_DRILL_SYMBOL_START
Drill symbols, one channel per board layer.
Definition layer_ids.h:385
@ LAYER_LOCKED_ITEM_SHADOW
Shadow layer for locked items.
Definition layer_ids.h:303
@ LAYER_VIA_HOLEWALLS
Definition layer_ids.h:294
@ LAYER_VIA_COPPER_START
Virtual layers for via copper on a given copper layer.
Definition layer_ids.h:362
@ LAYER_TRACKS
Definition layer_ids.h:263
@ LAYER_CLEARANCE_START
Virtual layers for pad/via/track clearance outlines for a given copper layer.
Definition layer_ids.h:366
@ LAYER_VIA_HOLES
Draw via holes (pad holes do not use this layer).
Definition layer_ids.h:270
@ LAYER_VIAS
Meta control for all vias opacity/visibility.
Definition layer_ids.h:228
size_t CopperLayerToOrdinal(PCB_LAYER_ID aLayer)
Converts KiCad copper layer enum to an ordinal between the front and back layers.
Definition layer_ids.h:986
bool IsViaCopperLayer(int aLayer)
Definition layer_ids.h:954
#define DRILL_SYMBOL_LAYER_FOR(boardLayer)
Definition layer_ids.h:400
bool IsNetnameLayer(int aLayer)
Test whether a layer is a netname layer.
Definition layer_ids.h:936
bool IsHoleLayer(int aLayer)
Definition layer_ids.h:806
bool IsExternalCopperLayer(int aLayerId)
Test whether a layer is an external (F_Cu or B_Cu) copper layer.
Definition layer_ids.h:755
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:56
@ In30_Cu
Definition layer_ids.h:91
@ B_Mask
Definition layer_ids.h:94
@ B_Cu
Definition layer_ids.h:61
@ F_Mask
Definition layer_ids.h:93
@ UNDEFINED_LAYER
Definition layer_ids.h:57
@ F_Cu
Definition layer_ids.h:60
PCB_LAYER_ID ToLAYER_ID(int aLayer)
Definition lset.cpp:750
FLIP_DIRECTION
Definition mirror.h:26
@ LEFT_RIGHT
Flip left to right (around the Y axis)
Definition mirror.h:27
bool ShapeHitTest(const SHAPE_LINE_CHAIN &aHitter, const SHAPE &aHittee, bool aHitteeContained)
Perform a shape-to-shape hit test.
void PackLayerSet(google::protobuf::RepeatedField< int > &aOutput, const LSET &aLayerSet)
void PackZoneLayerOverrides(google::protobuf::RepeatedPtrField< types::ZoneLayerOverrideEntry > *aOutput, const std::map< PCB_LAYER_ID, ZONE_LAYER_OVERRIDE > &aInput)
void UnpackTeardropSettings(TEARDROP_PARAMETERS &aOutput, const types::PadTeardropSettings &aProto)
void UnpackZoneLayerOverrides(std::map< PCB_LAYER_ID, ZONE_LAYER_OVERRIDE > &aOutput, const google::protobuf::RepeatedPtrField< types::ZoneLayerOverrideEntry > &aInput)
void PackTeardropSettings(types::PadTeardropSettings &aOutput, const TEARDROP_PARAMETERS &aParams)
KICOMMON_API void PackCustomProperties(google::protobuf::RepeatedPtrField< types::CustomProperty > *aOutput, const EDA_ITEM &aItem)
KICOMMON_API void UnpackCustomProperties(const google::protobuf::RepeatedPtrField< types::CustomProperty > &aInput, EDA_ITEM &aItem)
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
Definition eda_angle.h:461
PAD_DRILL_SHAPE
The set of pad drill shapes, used with PAD::{Set,Get}DrillShape()
Definition padstack.h:70
BACKDRILL_MODE
Definition padstack.h:85
#define _HKI(x)
Definition page_info.cpp:40
PCBNEW_SETTINGS * pcbconfig()
static bool hasLayerOrdinal(PCB_LAYER_ID aLayer)
static struct TRACK_VIA_DESC _TRACK_VIA_DESC
#define GEOMETRY_MIN_SIZE
Definition pcb_track.h:58
FILLING_MODE
VIATYPE
TENTING_MODE
COVERING_MODE
PLUGGING_MODE
CAPPING_MODE
@ SHOW_WITH_VIA_ALWAYS
#define TYPE_HASH(x)
Macro to generate unique identifier for a type.
Definition property.h:74
#define ENUM_TO_WXANY(type)
Definition property.h:918
@ PT_COORD
Coordinate expressed in distance units (mm/inch)
Definition property.h:65
@ PT_DECIDEGREE
Angle expressed in decidegrees.
Definition property.h:67
@ PT_SIZE
Size expressed in distance units (mm/inch)
Definition property.h:63
#define REGISTER_TYPE(x)
Helper macro to map type hashes to names.
std::optional< std::unique_ptr< VALIDATION_ERROR > > VALIDATOR_RESULT
Null optional means validation succeeded.
wxString UnescapeString(const wxString &aSource)
The properties of a padstack drill.
Definition padstack.h:277
PCB_LAYER_ID start
Definition padstack.h:280
PCB_LAYER_ID end
Definition padstack.h:281
Struct to control which optimisations the length calculation code runs on the given path objects.
bool operator()(const PCB_TRACK *aFirst, const PCB_TRACK *aSecond) const
VECTOR2I center
int radius
VECTOR2I end
int clearance
wxString result
Test unit parsing edge cases and error handling.
bool TestSegmentHit(const VECTOR2I &aRefPoint, const VECTOR2I &aStart, const VECTOR2I &aEnd, int aDist)
Test if aRefPoint is with aDistance on the line defined by aStart and aEnd.
Definition trigo.cpp:173
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:227
bool IsStraightArc(const VECTOR2I &aStart, const VECTOR2I &aMid, const VECTOR2I &aEnd)
Definition trigo.cpp:549
const VECTOR2I CalcArcCenter(const VECTOR2I &aStart, const VECTOR2I &aMid, const VECTOR2I &aEnd)
Determine the center of an arc or circle given three points on its circumference.
Definition trigo.cpp:540
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition typeinfo.h:70
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition typeinfo.h:89
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition typeinfo.h:79
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
Definition typeinfo.h:90
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition typeinfo.h:88
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:708
VECTOR2< double > VECTOR2D
Definition vector2d.h:707
VECTOR2< int64_t > VECTOR2L
Definition vector2d.h:709