KiCad PCB EDA Suite
Loading...
Searching...
No Matches
dialog_track_via_properties.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) 2015 CERN
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 * @author Maciej Suminski <[email protected]>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22#include <bitmaps.h>
23#include <core/kicad_algo.h>
29#include <footprint.h>
30#include <pad.h>
31#include <padstack.h>
32#include <pcb_track.h>
33#include <confirm.h>
34#include <kidialog.h>
36#include <board_commit.h>
37#include <magic_enum.hpp>
38#include <macros.h>
39#include <cmath>
40#include <optional>
41
42
43// Item order of the choice controls in the form
51
59
66
67
68bool DIALOG_TRACK_VIA_PROPERTIES::IPC4761_CONFIGURATION::operator==( const IPC4761_CONFIGURATION& aOther ) const
69{
70 return ( tent == aOther.tent ) && ( plug == aOther.plug ) && ( cover == aOther.cover )
71 && ( cap == aOther.cap ) && ( fill == aOther.fill );
72}
73
74
77 m_frame( aParent ),
78 m_items( aItems ),
81 m_trackEndX( aParent, m_TrackEndXLabel, m_TrackEndXCtrl, nullptr ),
85 m_viaX( aParent, m_ViaXLabel, m_ViaXCtrl, nullptr ),
104 m_tracks( false ),
105 m_vias( false ),
106 m_editLayer( F_Cu ),
107 m_padstackDirty( false )
108{
109 commonInit( aParent );
110}
111
112
114 PCB_VIA* aStandaloneVia ) :
116 m_frame( aParent ),
120 m_trackEndX( aParent, m_TrackEndXLabel, m_TrackEndXCtrl, nullptr ),
124 m_viaX( aParent, m_ViaXLabel, m_ViaXCtrl, nullptr ),
143 m_tracks( false ),
144 m_vias( false ),
145 m_editLayer( F_Cu ),
146 m_padstackDirty( false )
147{
148 wxASSERT( aStandaloneVia );
149
150 m_standalone = true;
151 m_viaStandaloneSelection.Add( aStandaloneVia );
152
153 commonInit( aParent );
154}
155
156
158{
159 m_useCalculatedSize = true;
160
161 wxASSERT( !m_items.Empty() );
162
164 m_legacyTeardropsWarning->Show( m_frame->GetBoard()->LegacyTeardrops() );
165
167
171
172 m_minTrackWidthHint->SetFont( KIUI::GetInfoFont( this ).Italic() );
173
174 // Configure display origin transforms
181
182 m_TrackLayerCtrl->SetLayersHotkeys( false );
183 m_TrackLayerCtrl->SetNotAllowedLayerSet( LSET::AllNonCuMask() );
184 m_TrackLayerCtrl->SetBoardFrame( aParent );
185 m_TrackLayerCtrl->Resync();
186
187 m_ViaStartLayer->SetLayersHotkeys( false );
188 m_ViaStartLayer->SetNotAllowedLayerSet( LSET::AllNonCuMask() );
189 m_ViaStartLayer->SetBoardFrame( aParent );
190 m_ViaStartLayer->Resync();
191
192 m_ViaEndLayer->SetLayersHotkeys( false );
193 m_ViaEndLayer->SetNotAllowedLayerSet( LSET::AllNonCuMask() );
194 m_ViaEndLayer->SetBoardFrame( aParent );
195 m_ViaEndLayer->Resync();
196
197 m_backdrillFrontLayer->SetLayersHotkeys( false );
198 m_backdrillFrontLayer->SetNotAllowedLayerSet( LSET::AllNonCuMask() );
199 m_backdrillFrontLayer->SetBoardFrame( aParent );
200 m_backdrillFrontLayer->SetUndefinedLayerName( _( "None" ) );
201 m_backdrillFrontLayer->Resync();
202
203 m_backdrillBackLayer->SetLayersHotkeys( false );
204 m_backdrillBackLayer->SetNotAllowedLayerSet( LSET::AllNonCuMask() );
205 m_backdrillBackLayer->SetBoardFrame( aParent );
206 m_backdrillBackLayer->SetUndefinedLayerName( _( "None" ) );
207 m_backdrillBackLayer->Resync();
208
209 wxFont infoFont = KIUI::GetSmallInfoFont( this );
210 m_techLayersLabel->SetFont( infoFont );
211 m_postMachineSectionLabel->SetFont( infoFont );
212
213 m_frame->Bind( EDA_EVT_UNITS_CHANGED, &DIALOG_TRACK_VIA_PROPERTIES::onUnitsChanged, this );
214 m_netSelector->Bind( FILTERED_ITEM_SELECTED, &DIALOG_TRACK_VIA_PROPERTIES::onNetSelector, this );
215 m_annularRingsCtrl->Bind( wxEVT_CHOICE,
216 [this]( wxCommandEvent& )
217 {
219 } );
220
221 for( auto& preset : magic_enum::enum_values<IPC4761_PRESET>() )
222 {
223 if( preset >= IPC4761_PRESET::CUSTOM )
224 continue;
225
226 const auto& name_it = m_IPC4761Names.find( preset );
227
228 wxString name = _( "Unknown choice" );
229
230 if( name_it != m_IPC4761Names.end() )
231 name = name_it->second;
232
233 m_protectionFeatures->AppendString( name );
234 }
235
237}
238
239
245
246
248{
249 // Setting widgets states/values must be in TransferDataToWindow, not in CTor
250 // otherwise states/values are overwritten by the DIALOG_SHIM::TransferDataToWindow() config values
251 bool nets = false;
252 int net = 0;
253 bool hasLocked = false;
254 bool hasUnlocked = false;
256
257 // Start and end layers of vias
258 // if at least 2 vias do not have the same start or the same end layer
259 // the layers will be set as undefined
260 int selection_first_layer = UNDEFINED_LAYER;
261 bool selection_first_layer_mixed = false;
262 int selection_last_layer = UNDEFINED_LAYER;
263 bool selection_last_layer_mixed = false;
264
265 // The selection layer for tracks
266 int track_selection_layer = UNDEFINED_LAYER;
267 bool track_selection_layer_mixed = false;
268
269 // Drill information for vias
270 int secondary_drill_end_layer = UNDEFINED_LAYER;
271 bool secondary_drill_end_layer_mixed = false;
272 int secondary_drill_size = 0;
273 bool secondary_drill_size_mixed = false;
274
275 int tertiary_drill_end_layer = UNDEFINED_LAYER;
276 bool tertiary_drill_end_layer_mixed = false;
277 int tertiary_drill_size = 0;
278 bool tertiary_drill_size_mixed = false;
279
281 bool backdrill_dir_mixed = false;
282
283 std::optional<PAD_DRILL_POST_MACHINING_MODE> primary_post_machining_value;
284 bool primary_post_machining_mixed = false;
285 int primary_post_machining_size = 0;
286 bool primary_post_machining_size_mixed = false;
287 int primary_post_machining_depth = 0;
288 bool primary_post_machining_depth_mixed = false;
289 int primary_post_machining_angle = 0;
290 bool primary_post_machining_angle_mixed = false;
291
292 std::optional<PAD_DRILL_POST_MACHINING_MODE> secondary_post_machining_value;
293 bool secondary_post_machining_mixed = false;
294 int secondary_post_machining_size = 0;
295 bool secondary_post_machining_size_mixed = false;
296 int secondary_post_machining_depth = 0;
297 bool secondary_post_machining_depth_mixed = false;
298 int secondary_post_machining_angle = 0;
299 bool secondary_post_machining_angle_mixed = false;
300
301 m_padstackDirty = false;
302
303 const int annularRingChoices = static_cast<int>( m_annularRingsCtrl->GetCount() );
304
305 auto getAnnularRingSelection =
306 []( const PCB_VIA* via ) -> int
307 {
308 switch( via->Padstack().UnconnectedLayerMode() )
309 {
310 default:
315 }
316 };
317
318 auto getBackdrillDrills =
319 []( const PCB_VIA* via, PADSTACK::DRILL_PROPS& aTop, PADSTACK::DRILL_PROPS& aBottom )
320 {
321 const PADSTACK::DRILL_PROPS& sec = via->Padstack().SecondaryDrill();
322 const PADSTACK::DRILL_PROPS& ter = via->Padstack().TertiaryDrill();
323
324 aTop = PADSTACK::DRILL_PROPS();
325 aBottom = PADSTACK::DRILL_PROPS();
326
327 if( sec.start == F_Cu )
328 aTop = sec;
329 else if( ter.start == F_Cu )
330 aTop = ter;
331
332 if( sec.start == B_Cu )
333 aBottom = sec;
334 else if( ter.start == B_Cu )
335 aBottom = ter;
336 };
337
338 // Look for values that are common for every item that is selected
339 for( EDA_ITEM* item : m_items )
340 {
341 if( !nets )
342 {
343 net = static_cast<BOARD_CONNECTED_ITEM*>( item )->GetNetCode();
344 nets = true;
345 }
346 else if( net != static_cast<BOARD_CONNECTED_ITEM*>( item )->GetNetCode() )
347 {
348 net = -1;
349 }
350
351 switch( item->Type() )
352 {
353 case PCB_TRACE_T:
354 case PCB_ARC_T:
355 {
356 const PCB_TRACK* t = static_cast<const PCB_TRACK*>( item );
357
358 if( !m_tracks ) // first track in the list
359 {
360 m_trackStartX.SetValue( t->GetStartX() );
361 m_trackStartY.SetValue( t->GetStartY() );
362 m_trackEndX.SetValue( t->GetEndX() );
363 m_trackEndY.SetValue( t->GetEndY() );
364 m_trackWidth.SetValue( t->GetWidth() );
365 track_selection_layer = t->GetLayer();
366 m_trackHasSolderMask->SetValue ( t->HasSolderMask() );
367
368 if( t->GetLocalSolderMaskMargin().has_value() )
369 m_trackMaskMargin.SetValue( t->GetLocalSolderMaskMargin().value() );
370 else
371 m_trackMaskMargin.SetValue( wxEmptyString );
372
373 m_tracks = true;
374 }
375 else // check if values are the same for every selected track
376 {
377 if( m_trackStartX.GetValue() != t->GetStartX() )
379
380 if( m_trackStartY.GetValue() != t->GetStartY() )
382
383 if( m_trackEndX.GetValue() != t->GetEndX() )
385
386 if( m_trackEndY.GetValue() != t->GetEndY() )
388
389 if( m_trackWidth.GetValue() != t->GetWidth() )
391
392 if( track_selection_layer != t->GetLayer() )
393 track_selection_layer_mixed = true;
394
395 if( m_trackHasSolderMask->GetValue() != t->HasSolderMask() )
396 m_trackHasSolderMask->Set3StateValue( wxCHK_UNDETERMINED );
397
398 if( m_trackMaskMargin.GetValue() != t->GetLocalSolderMaskMargin() )
400 }
401
402 if( t->IsLocked() )
403 hasLocked = true;
404 else
405 hasUnlocked = true;
406
407 break;
408 }
409
410 case PCB_VIA_T:
411 {
412 PCB_VIA* v = static_cast<PCB_VIA*>( item );
413
414 if( !m_vias ) // first via in the list
415 {
416 m_viaX.SetValue( v->GetPosition().x );
417 m_viaY.SetValue( v->GetPosition().y );
418 m_viaStack = std::make_unique<PADSTACK>( v->Padstack() );
419 m_viaDiameter.SetValue( v->GetWidth( m_editLayer ) );
420 m_viaDrill.SetValue( v->GetDrillValue() );
421 m_vias = true;
422 viaType = v->GetViaType();
423 m_viaNotFree->SetValue( !v->GetIsFree() );
424 m_annularRingsCtrl->SetSelection( getAnnularRingSelection( v ) );
425
426 primary_post_machining_value = v->Padstack().FrontPostMachining().mode;
427 primary_post_machining_size = v->Padstack().FrontPostMachining().size;
428 primary_post_machining_depth = v->Padstack().FrontPostMachining().depth;
429 primary_post_machining_angle = v->Padstack().FrontPostMachining().angle;
430
431 secondary_post_machining_value = v->Padstack().BackPostMachining().mode;
432 secondary_post_machining_size = v->Padstack().BackPostMachining().size;
433 secondary_post_machining_depth = v->Padstack().BackPostMachining().depth;
434 secondary_post_machining_angle = v->Padstack().BackPostMachining().angle;
435
436 PADSTACK::DRILL_PROPS topDrill;
437 PADSTACK::DRILL_PROPS bottomDrill;
438 getBackdrillDrills( v, topDrill, bottomDrill );
439
440 // secondary_* holds the top (front) backdrill, tertiary_* the bottom (back) one
441 secondary_drill_end_layer = topDrill.end;
442 tertiary_drill_end_layer = bottomDrill.end;
443
444 secondary_drill_size = topDrill.size.x;
445 tertiary_drill_size = bottomDrill.size.x;
446
447 bool top = topDrill.end != UNDEFINED_LAYER && topDrill.size.x > 0;
448 bool bottom = bottomDrill.end != UNDEFINED_LAYER && bottomDrill.size.x > 0;
449
450 if( top && bottom )
451 backdrill_dir = BACKDRILL_MODE::BACKDRILL_BOTH;
452 else if( bottom )
453 backdrill_dir = BACKDRILL_MODE::BACKDRILL_BOTTOM;
454 else if( top )
455 backdrill_dir = BACKDRILL_MODE::BACKDRILL_TOP;
456 else
457 backdrill_dir = BACKDRILL_MODE::NO_BACKDRILL;
458
459 selection_first_layer = v->TopLayer();
460 selection_last_layer = v->BottomLayer();
461
462 m_cbTeardrops->SetValue( v->GetTeardropParams().m_Enabled );
466 m_teardropLenPercent.SetDoubleValue( v->GetTeardropParams().m_BestLengthRatio*100.0 );
467 m_teardropWidthPercent.SetDoubleValue( v->GetTeardropParams().m_BestWidthRatio*100.0 );
470
472
473 if( preset >= IPC4761_PRESET::CUSTOM )
475 else
476 m_protectionFeatures->SetSelection( static_cast<int>( preset ) );
477 }
478 else // check if values are the same for every selected via
479 {
480 if( m_viaX.GetValue() != v->GetPosition().x )
481 m_viaX.SetValue( INDETERMINATE_STATE );
482
483 if( m_viaY.GetValue() != v->GetPosition().y )
484 m_viaY.SetValue( INDETERMINATE_STATE );
485
486 if( m_viaDiameter.GetValue() != v->GetWidth( m_editLayer ) )
488
489 if( m_viaDrill.GetValue() != v->GetDrillValue() )
491
492 if( viaType != v->GetViaType() )
493 viaType = VIATYPE::NOT_DEFINED;
494
495 if( v->GetIsFree() != !m_viaNotFree->GetValue() )
496 m_viaNotFree->Set3StateValue( wxCHK_UNDETERMINED );
497
498 if( selection_first_layer != v->TopLayer() )
499 selection_first_layer_mixed = true;
500
501 if( selection_last_layer != v->BottomLayer() )
502 selection_last_layer_mixed = true;
503
504 if( m_annularRingsCtrl->GetSelection() != getAnnularRingSelection( v ) )
505 {
506 if( m_annularRingsCtrl->GetSelection() != annularRingChoices )
508
509 m_annularRingsCtrl->SetSelection( annularRingChoices );
510 }
511
512 if( m_cbTeardrops->GetValue() != v->GetTeardropParams().m_Enabled )
513 m_cbTeardrops->Set3StateValue( wxCHK_UNDETERMINED );
514
516 m_cbTeardropsUseNextTrack->Set3StateValue( wxCHK_UNDETERMINED );
517
518 if( m_teardropMaxLen.GetValue() != v->GetTeardropParams().m_TdMaxLen )
520
521 if( m_teardropMaxWidth.GetValue() != v->GetTeardropParams().m_TdMaxWidth )
523
524 if( m_teardropLenPercent.GetDoubleValue() != v->GetTeardropParams().m_BestLengthRatio *100.0 )
526
527 if( m_teardropWidthPercent.GetDoubleValue() != v->GetTeardropParams().m_BestWidthRatio *100.0 )
529
530 if( m_teardropHDPercent.GetDoubleValue() != v->GetTeardropParams().m_WidthtoSizeFilterRatio*100.0 )
532
533 if( static_cast<int>( getViaConfiguration( v ) ) != m_protectionFeatures->GetSelection() )
535
536 if( primary_post_machining_value != v->Padstack().FrontPostMachining().mode )
537 primary_post_machining_mixed = true;
538
539 if( primary_post_machining_size != v->Padstack().FrontPostMachining().size )
540 primary_post_machining_size_mixed = true;
541
542 if( primary_post_machining_depth != v->Padstack().FrontPostMachining().depth )
543 primary_post_machining_depth_mixed = true;
544
545 if( primary_post_machining_angle != v->Padstack().FrontPostMachining().angle )
546 primary_post_machining_angle_mixed = true;
547
548 if( secondary_post_machining_value != v->Padstack().BackPostMachining().mode )
549 secondary_post_machining_mixed = true;
550
551 if( secondary_post_machining_size != v->Padstack().BackPostMachining().size )
552 secondary_post_machining_size_mixed = true;
553
554 if( secondary_post_machining_depth != v->Padstack().BackPostMachining().depth )
555 secondary_post_machining_depth_mixed = true;
556
557 if( secondary_post_machining_angle != v->Padstack().BackPostMachining().angle )
558 secondary_post_machining_angle_mixed = true;
559
560 PADSTACK::DRILL_PROPS topDrill;
561 PADSTACK::DRILL_PROPS bottomDrill;
562 getBackdrillDrills( v, topDrill, bottomDrill );
563
564 bool top = topDrill.end != UNDEFINED_LAYER && topDrill.size.x > 0;
565 bool bottom = bottomDrill.end != UNDEFINED_LAYER && bottomDrill.size.x > 0;
566
568
569 if( top && bottom )
570 new_backdrill_dir = BACKDRILL_MODE::BACKDRILL_BOTH;
571 else if( bottom )
572 new_backdrill_dir = BACKDRILL_MODE::BACKDRILL_BOTTOM;
573 else if( top )
574 new_backdrill_dir = BACKDRILL_MODE::BACKDRILL_TOP;
575 else
576 new_backdrill_dir = BACKDRILL_MODE::NO_BACKDRILL;
577
578 if( secondary_drill_end_layer != topDrill.end )
579 secondary_drill_end_layer_mixed = true;
580
581 if( tertiary_drill_end_layer != bottomDrill.end )
582 tertiary_drill_end_layer_mixed = true;
583
584 if( backdrill_dir != new_backdrill_dir )
585 backdrill_dir_mixed = true;
586
587 if( bottomDrill.size.x != tertiary_drill_size )
588 tertiary_drill_size_mixed = true;
589
590 if( topDrill.size.x != secondary_drill_size )
591 secondary_drill_size_mixed = true;
592 }
593
594 if( v->IsLocked() )
595 hasLocked = true;
596 else
597 hasUnlocked = true;
598
599 break;
600 }
601
602 default:
603 {
604 UNIMPLEMENTED_FOR( item->GetClass() );
605 break;
606 }
607 }
608 }
609
610 if( m_tracks )
611 {
612 // Set the track layer selection state:
613 if( track_selection_layer_mixed )
614 {
615 m_TrackLayerCtrl->SetUndefinedLayerName( INDETERMINATE_STATE );
616 m_TrackLayerCtrl->Resync();
617 m_TrackLayerCtrl->SetLayerSelection( UNDEFINED_LAYER );
618 }
619 else
620 {
621 m_TrackLayerCtrl->SetLayerSelection( track_selection_layer );
622 }
623 }
624
625 // Set the vias layers selections state:
626 if( m_vias )
627 {
628 if( selection_first_layer_mixed )
629 {
630 m_ViaStartLayer->SetUndefinedLayerName( INDETERMINATE_STATE );
631 m_ViaStartLayer->Resync();
632 m_ViaStartLayer->SetLayerSelection( UNDEFINED_LAYER );
633 }
634 else
635 {
636 m_ViaStartLayer->SetLayerSelection( selection_first_layer );
637 }
638
639 if( selection_last_layer_mixed )
640 {
641 m_ViaEndLayer->SetUndefinedLayerName( INDETERMINATE_STATE );
642 m_ViaEndLayer->Resync();
643 m_ViaEndLayer->SetLayerSelection( UNDEFINED_LAYER );
644 }
645 else
646 {
647 m_ViaEndLayer->SetLayerSelection( selection_last_layer );
648 }
649
650 // Set backdrill controls
651
652 // Backdrill direction selector
653 if( backdrill_dir_mixed )
654 {
655 m_backdrillChoice->SetSelection( wxNOT_FOUND );
656
657 if( tertiary_drill_size_mixed )
659 else
660 m_backdrillBackSize.SetValue( tertiary_drill_size );
661
662 if( secondary_drill_size_mixed )
664 else
665 m_backdrillFrontSize.SetValue( secondary_drill_size );
666 }
667 else
668 {
669 m_backdrillChoice->SetSelection( static_cast<int>( backdrill_dir ) );
670
671 if( backdrill_dir == BACKDRILL_MODE::BACKDRILL_BOTTOM || backdrill_dir == BACKDRILL_MODE::BACKDRILL_BOTH )
672 {
673 if( tertiary_drill_size_mixed )
675 else
676 m_backdrillBackSize.SetValue( tertiary_drill_size );
677 }
678 else
679 {
680 m_backdrillBackSize.SetValue( wxEmptyString );
681 }
682
683 if( backdrill_dir == BACKDRILL_MODE::BACKDRILL_TOP || backdrill_dir == BACKDRILL_MODE::BACKDRILL_BOTH )
684 {
685 if( secondary_drill_size_mixed )
687 else
688 m_backdrillFrontSize.SetValue( secondary_drill_size );
689 }
690 else
691 {
692 m_backdrillFrontSize.SetValue( wxEmptyString );
693 }
694
695 }
696
697 // Top backdrill control
698 m_backdrillFrontLayerMixed = secondary_drill_end_layer_mixed;
699
700 if( secondary_drill_end_layer_mixed )
701 {
702 m_backdrillFrontLayer->SetUndefinedLayerName( INDETERMINATE_STATE );
703 m_backdrillFrontLayer->Resync();
704 m_backdrillFrontLayer->SetLayerSelection( UNDEFINED_LAYER );
705 }
706 else
707 {
708 m_backdrillFrontLayer->SetUndefinedLayerName( _( "None" ) );
709 m_backdrillFrontLayer->Resync();
710 m_backdrillFrontLayer->SetLayerSelection( secondary_drill_end_layer );
711 }
712
713 // Bottom backdrill control
714 m_backdrillBackLayerMixed = tertiary_drill_end_layer_mixed;
715
716 if( tertiary_drill_end_layer_mixed )
717 {
718 m_backdrillBackLayer->SetUndefinedLayerName( INDETERMINATE_STATE );
719 m_backdrillBackLayer->Resync();
720 m_backdrillBackLayer->SetLayerSelection( UNDEFINED_LAYER );
721 }
722 else
723 {
724 m_backdrillBackLayer->SetUndefinedLayerName( _( "None" ) );
725 m_backdrillBackLayer->Resync();
726 m_backdrillBackLayer->SetLayerSelection( tertiary_drill_end_layer );
727 }
728
729 // Post Machining
730 if( primary_post_machining_mixed )
731 {
732 m_topPostMachine->SetSelection( wxNOT_FOUND );
734 m_topPostMachineSize2.SetUnits( m_frame->GetUserUnits() );
736 }
737 else if( primary_post_machining_value.has_value() )
738 {
739 switch( primary_post_machining_value.value() )
740 {
742 m_topPostMachine->SetSelection( 2 );
743
744 if( primary_post_machining_size_mixed )
746 else
747 m_topPostMachineSize1.SetValue( primary_post_machining_size );
748
749 m_topPostMachineSize2.SetUnits( m_frame->GetUserUnits() );
750
751 if( primary_post_machining_depth_mixed )
753 else
754 m_topPostMachineSize2.SetValue( primary_post_machining_depth );
755
756 break;
757
759 m_topPostMachine->SetSelection( 1 );
760
761 if( primary_post_machining_size_mixed )
763 else
764 m_topPostMachineSize1.SetValue( primary_post_machining_size );
765
767
768 if( primary_post_machining_angle_mixed )
770 else
771 m_topPostMachineSize2.SetDoubleValue( primary_post_machining_angle / 10.0 );
772
773 break;
774
775 default:
776 m_topPostMachine->SetSelection( 0 );
777 m_topPostMachineSize1.SetValue( wxEmptyString );
778 m_topPostMachineSize2.SetUnits( m_frame->GetUserUnits() );
779 m_topPostMachineSize2.SetValue( wxEmptyString );
780 break;
781 }
782 }
783 else
784 {
785 m_topPostMachine->SetSelection( 0 );
786 m_topPostMachineSize1.SetValue( wxEmptyString );
787 m_topPostMachineSize2.SetUnits( m_frame->GetUserUnits() );
788 m_topPostMachineSize2.SetValue( wxEmptyString );
789 }
790
791 if( secondary_post_machining_mixed )
792 {
793 m_bottomPostMachine->SetSelection( wxNOT_FOUND );
795 m_bottomPostMachineSize2.SetUnits( m_frame->GetUserUnits() );
797 }
798 else if( secondary_post_machining_value.has_value() )
799 {
800 switch( secondary_post_machining_value.value() )
801 {
803 m_bottomPostMachine->SetSelection( 2 );
804
805 if( secondary_post_machining_size_mixed )
807 else
808 m_bottomPostMachineSize1.SetValue( secondary_post_machining_size );
809
810 m_bottomPostMachineSize2.SetUnits( m_frame->GetUserUnits() );
811
812 if( secondary_post_machining_depth_mixed )
814 else
815 m_bottomPostMachineSize2.SetValue( secondary_post_machining_depth );
816
817 break;
818
820 m_bottomPostMachine->SetSelection( 1 );
821
822 if( secondary_post_machining_size_mixed )
824 else
825 m_bottomPostMachineSize1.SetValue( secondary_post_machining_size );
826
828
829 if( secondary_post_machining_angle_mixed )
831 else
832 m_bottomPostMachineSize2.SetDoubleValue( secondary_post_machining_angle / 10.0 );
833
834 break;
835
836 default:
837 m_bottomPostMachine->SetSelection( 0 );
838 m_bottomPostMachineSize1.SetValue( wxEmptyString );
839 m_bottomPostMachineSize2.SetValue( wxEmptyString );
840 m_bottomPostMachineSize2.SetUnits( m_frame->GetUserUnits() );
841 break;
842 }
843 }
844 else
845 {
846 m_bottomPostMachine->SetSelection( 0 );
847 m_bottomPostMachineSize1.SetValue( wxEmptyString );
848 m_bottomPostMachineSize2.SetUnits( m_frame->GetUserUnits() );
849 m_bottomPostMachineSize2.SetValue( wxEmptyString );
850 }
851 }
852
853 m_netSelector->SetNetInfo( &m_frame->GetBoard()->GetNetInfo() );
854
855 if ( net >= 0 )
856 {
857 m_netSelector->SetSelectedNetcode( net );
858 }
859 else
860 {
861 m_netSelector->SetIndeterminateString( INDETERMINATE_STATE );
862 m_netSelector->SetIndeterminate();
863 }
864
865 wxASSERT( m_tracks || m_vias );
866
867 if( m_vias )
868 {
869 if( m_viaNotFree->GetValue() && !m_tracks )
870 {
871 // Disable net selector to re-inforce meaning of "Automatically update via nets",
872 // but not when tracks are also selected as then things get harder if you want to
873 // update all the nets to match.
874 m_netSelectorLabel->Disable();
875 m_netSelector->Disable();
876 }
877
878 int viaSelection = wxNOT_FOUND;
879
880 // 0 is the netclass place-holder
881 for( unsigned ii = 1; ii < m_frame->GetDesignSettings().m_ViasDimensionsList.size(); ii++ )
882 {
883 VIA_DIMENSION* viaDimension = &m_frame->GetDesignSettings().m_ViasDimensionsList[ii];
884 wxString msg = m_frame->StringFromValue( viaDimension->m_Diameter )
885 + wxT( " / " )
886 + m_frame->StringFromValue( viaDimension->m_Drill );
887 m_predefinedViaSizesCtrl->Append( msg, viaDimension );
888
889 if( viaSelection == wxNOT_FOUND
890 && m_viaDiameter.GetValue() == viaDimension->m_Diameter
891 && m_viaDrill.GetValue() == viaDimension->m_Drill )
892 {
893 viaSelection = ii - 1;
894 }
895 }
896
897 m_predefinedViaSizesCtrl->SetSelection( viaSelection );
898 m_predefinedViaSizesUnits->SetLabel( EDA_UNIT_UTILS::GetLabel( m_frame->GetUserUnits() ) );
899
900 m_ViaTypeChoice->Enable();
901
902 switch( viaType )
903 {
904 case VIATYPE::THROUGH: m_ViaTypeChoice->SetSelection( 0 ); break;
905 case VIATYPE::MICROVIA: m_ViaTypeChoice->SetSelection( 1 ); break;
906 case VIATYPE::BLIND: m_ViaTypeChoice->SetSelection( 2 ); break;
907 case VIATYPE::BURIED: m_ViaTypeChoice->SetSelection( 3 ); break;
908 case VIATYPE::NOT_DEFINED: m_ViaTypeChoice->SetSelection( wxNOT_FOUND ); break;
909 }
910
911 m_ViaStartLayer->Enable( viaType != VIATYPE::THROUGH );
912 m_ViaEndLayer->Enable( viaType != VIATYPE::THROUGH );
913
914 m_annularRingsLabel->Show( getLayerDepth() > 1 );
915 m_annularRingsCtrl->Show( getLayerDepth() > 1 );
916 m_annularRingsCtrl->Enable( true );
917
919 }
920 else
921 {
922 m_viaNotFree->Hide();
923 m_MainSizer->Hide( m_sbViaSizer, true );
924 }
925
926 if( m_tracks )
927 {
928 int widthSelection = wxNOT_FOUND;
929
930 // 0 is the netclass place-holder
931 for( unsigned ii = 1; ii < m_frame->GetDesignSettings().m_TrackWidthList.size(); ii++ )
932 {
933 int width = m_frame->GetDesignSettings().m_TrackWidthList[ii];
934 wxString msg = m_frame->StringFromValue( width );
935 m_predefinedTrackWidthsCtrl->Append( msg );
936
937 if( widthSelection == wxNOT_FOUND && m_trackWidth.GetValue() == width )
938 widthSelection = ii - 1;
939 }
940
941 m_predefinedTrackWidthsCtrl->SetSelection( widthSelection );
942 m_predefinedTrackWidthsUnits->SetLabel( EDA_UNIT_UTILS::GetLabel( m_frame->GetUserUnits() ) );
943
944 wxCommandEvent event;
945 onTrackEdit( event );
946 }
947 else
948 {
949 m_MainSizer->Hide( m_sbTrackSizer, true );
950 }
951
952 if( hasLocked && hasUnlocked )
953 m_lockedCbox->Set3StateValue( wxCHK_UNDETERMINED );
954 else if( hasLocked )
955 m_lockedCbox->Set3StateValue( wxCHK_CHECKED );
956 else
957 m_lockedCbox->Set3StateValue( wxCHK_UNCHECKED );
958
959 if( m_tracks )
961 else if( m_netSelector->IsEnabled() )
963 else
965
967
968 // Now all widgets have the size fixed, call FinishDialogSettings
970
971 return true;
972}
973
974
976{
977 if( m_vias )
978 {
979 int viaSel = m_predefinedViaSizesCtrl->GetSelection();
980
982
983 // 0 is the netclass place-holder
984 for( unsigned ii = 1; ii < m_frame->GetDesignSettings().m_ViasDimensionsList.size(); ii++ )
985 {
986 VIA_DIMENSION* viaDimension = &m_frame->GetDesignSettings().m_ViasDimensionsList[ii];
987 wxString msg = m_frame->StringFromValue( viaDimension->m_Diameter )
988 + wxT( " / " )
989 + m_frame->StringFromValue( viaDimension->m_Drill );
990 m_predefinedViaSizesCtrl->Append( msg, viaDimension );
991 }
992
993 m_predefinedViaSizesCtrl->SetSelection( viaSel );
994 m_predefinedViaSizesUnits->SetLabel( EDA_UNIT_UTILS::GetLabel( m_frame->GetUserUnits() ) );
995 }
996
997 if( m_tracks )
998 {
999 int trackSel = m_predefinedTrackWidthsCtrl->GetSelection();
1000
1002
1003 // 0 is the netclass place-holder
1004 for( unsigned ii = 1; ii < m_frame->GetDesignSettings().m_TrackWidthList.size(); ii++ )
1005 {
1006 int width = m_frame->GetDesignSettings().m_TrackWidthList[ii];
1007 wxString msg = m_frame->StringFromValue( width );
1008 m_predefinedTrackWidthsCtrl->Append( msg );
1009 }
1010
1011 m_predefinedTrackWidthsCtrl->SetSelection( trackSel );
1012 m_predefinedTrackWidthsUnits->SetLabel( EDA_UNIT_UTILS::GetLabel( m_frame->GetUserUnits() ) );
1013 }
1014
1015 aEvent.Skip();
1016}
1017
1018
1019bool DIALOG_TRACK_VIA_PROPERTIES::confirmShortingNets( int aNet, const std::set<int>& shortingNets )
1020{
1021 wxString msg;
1022
1023 if( shortingNets.size() == 1 )
1024 {
1025 msg.Printf( _( "Applying these changes will short net %s with %s." ),
1026 m_netSelector->GetValue(),
1027 m_frame->GetBoard()->FindNet( *shortingNets.begin() )->GetNetname() );
1028 }
1029 else
1030 {
1031 msg.Printf( _( "Applying these changes will short net %s with other nets." ),
1032 m_netSelector->GetValue() );
1033 }
1034
1035 KIDIALOG dlg( this, msg, _( "Confirmation" ), wxOK | wxCANCEL | wxICON_WARNING );
1036 dlg.SetOKCancelLabels( _( "Apply Anyway" ), _( "Cancel Changes" ) );
1037 dlg.DoNotShowCheckbox( __FILE__, __LINE__ );
1038
1039 return dlg.ShowModal() == wxID_OK;
1040}
1041
1042
1043bool DIALOG_TRACK_VIA_PROPERTIES::confirmPadChange( const std::set<PAD*>& changingPads )
1044{
1045 wxString msg;
1046
1047 if( changingPads.size() == 1 )
1048 {
1049 PAD* pad = *changingPads.begin();
1050 msg.Printf( _( "Changing the net will also update %s pad %s to %s." ),
1051 pad->GetParentFootprint()->GetReference(),
1052 pad->GetNumber(),
1053 m_netSelector->GetValue() );
1054 }
1055 else if( changingPads.size() == 2 )
1056 {
1057 PAD* pad1 = *changingPads.begin();
1058 PAD* pad2 = *( ++changingPads.begin() );
1059 msg.Printf( _( "Changing the net will also update %s pad %s and %s pad %s to %s." ),
1061 pad1->GetNumber(),
1063 pad2->GetNumber(),
1064 m_netSelector->GetValue() );
1065 }
1066 else
1067 {
1068 msg.Printf( _( "Changing the net will also update %lu connected pads to %s." ),
1069 static_cast<unsigned long>( changingPads.size() ),
1070 m_netSelector->GetValue() );
1071 }
1072
1073 KIDIALOG dlg( this, msg, _( "Confirmation" ), wxOK | wxCANCEL | wxICON_WARNING );
1074 dlg.SetOKCancelLabels( _( "Change Nets" ), _( "Leave Nets Unchanged" ) );
1075 dlg.DoNotShowCheckbox( __FILE__, __LINE__ );
1076
1077 return dlg.ShowModal() == wxID_OK;
1078}
1079
1080
1082{
1083 std::shared_ptr<CONNECTIVITY_DATA> connectivity = m_frame->GetBoard()->GetConnectivity();
1084 std::vector<PCB_TRACK*> selected_tracks;
1085 std::set<PCB_TRACK*> connected_tracks;
1086
1087 for( EDA_ITEM* item : m_items )
1088 {
1089 if( PCB_TRACK* track = dynamic_cast<PCB_TRACK*>( item ) )
1090 selected_tracks.push_back( track );
1091 }
1092
1093 for( PCB_TRACK* selected_track : selected_tracks )
1094 {
1095 connected_tracks.insert( selected_track );
1096
1097 // Exclude zones so we only follow direct copper, via, and pad connections. Zone
1098 // propagation would pull in unrelated same-net tracks and rewrite their net below.
1099 for( BOARD_CONNECTED_ITEM* connected_item :
1100 connectivity->GetConnectedItems( selected_track, EXCLUDE_ZONES ) )
1101 {
1102 if( PCB_TRACK* track = dynamic_cast<PCB_TRACK*>( connected_item ) )
1103 connected_tracks.insert( track );
1104 }
1105 }
1106
1107 // Check for malformed data ONLY; design rules and constraints are the business of DRC.
1108
1109 if( m_vias )
1110 {
1111 // Marshal UI values into optionals; the malformed-data checks themselves live on
1112 // PCB_VIA::ValidateViaParameters so they can be reused and unit tested.
1113
1114 std::optional<int> viaDiameter;
1115
1116 if( m_ViaDiameterCtrl->IsEnabled() && !m_viaDiameter.IsIndeterminate() )
1117 viaDiameter = m_viaDiameter.GetValue();
1118
1119 std::optional<int> viaDrill;
1120
1121 if( m_ViaDrillCtrl->IsEnabled() && !m_viaDrill.IsIndeterminate() )
1122 viaDrill = m_viaDrill.GetValue();
1123
1124 std::optional<PCB_LAYER_ID> startLayer;
1125
1126 if( m_ViaStartLayer->GetLayerSelection() != UNDEFINED_LAYER )
1127 startLayer = static_cast<PCB_LAYER_ID>( m_ViaStartLayer->GetLayerSelection() );
1128
1129 std::optional<PCB_LAYER_ID> endLayer;
1130
1131 if( m_ViaEndLayer->GetLayerSelection() != UNDEFINED_LAYER )
1132 endLayer = static_cast<PCB_LAYER_ID>( m_ViaEndLayer->GetLayerSelection() );
1133
1134 std::optional<int> secondaryDrill;
1135 std::optional<int> tertiaryDrill;
1136 std::optional<PCB_LAYER_ID> secondaryStartLayer;
1137 std::optional<PCB_LAYER_ID> secondaryEndLayer;
1138 std::optional<PCB_LAYER_ID> tertiaryStartLayer;
1139 std::optional<PCB_LAYER_ID> tertiaryEndLayer;
1140
1141 if( m_backdrillChoice->GetSelection() != wxNOT_FOUND )
1142 {
1143 switch( static_cast<BACKDRILL_MODE>( m_backdrillChoice->GetSelection() ) )
1144 {
1146 break;
1147
1149 tertiaryStartLayer = B_Cu;
1150
1151 if( m_backdrillBackLayer->GetLayerSelection() != UNDEFINED_LAYER )
1152 tertiaryEndLayer = ToLAYER_ID( m_backdrillBackLayer->GetLayerSelection() );
1153
1154 if( !m_backdrillBackSize.IsIndeterminate() && !m_backdrillBackSize.IsNull() )
1155 tertiaryDrill = m_backdrillBackSize.GetIntValue();
1156
1157 break;
1158
1160 secondaryStartLayer = F_Cu;
1161
1162 if( m_backdrillFrontLayer->GetLayerSelection() != UNDEFINED_LAYER )
1163 secondaryEndLayer = ToLAYER_ID( m_backdrillFrontLayer->GetLayerSelection() );
1164
1165 if( !m_backdrillFrontSize.IsIndeterminate() && !m_backdrillFrontSize.IsNull() )
1166 secondaryDrill = m_backdrillFrontSize.GetIntValue();
1167
1168 break;
1169
1171 secondaryStartLayer = F_Cu;
1172
1173 if( m_backdrillFrontLayer->GetLayerSelection() != UNDEFINED_LAYER )
1174 secondaryEndLayer = ToLAYER_ID( m_backdrillFrontLayer->GetLayerSelection() );
1175
1176 if( !m_backdrillFrontSize.IsIndeterminate() && !m_backdrillFrontSize.IsNull() )
1177 secondaryDrill = m_backdrillFrontSize.GetIntValue();
1178
1179 tertiaryStartLayer = B_Cu;
1180
1181 if( m_backdrillBackLayer->GetLayerSelection() != UNDEFINED_LAYER )
1182 tertiaryEndLayer = ToLAYER_ID( m_backdrillBackLayer->GetLayerSelection() );
1183
1184 if( !m_backdrillBackSize.IsIndeterminate() && !m_backdrillBackSize.IsNull() )
1185 tertiaryDrill = m_backdrillBackSize.GetIntValue();
1186
1187 break;
1188 }
1189 }
1190
1191 // Post Machining
1192 std::optional<PADSTACK::POST_MACHINING_PROPS> frontPostMachining;
1193 std::optional<PADSTACK::POST_MACHINING_PROPS> backPostMachining;
1194
1195 if( m_topPostMachine->GetSelection() != wxNOT_FOUND )
1196 {
1198
1199 switch( m_topPostMachine->GetSelection() )
1200 {
1201 case 1: props.mode = PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK; break;
1202 case 2: props.mode = PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE; break;
1204 }
1205
1206 if( !m_topPostMachineSize1.IsIndeterminate() )
1207 props.size = m_topPostMachineSize1.GetIntValue();
1208
1209 if( !m_topPostMachineSize2.IsIndeterminate() )
1210 {
1212 props.angle = KiROUND( m_topPostMachineSize2.GetDoubleValue() * 10.0 );
1213 else
1214 props.depth = m_topPostMachineSize2.GetIntValue();
1215 }
1216
1217 frontPostMachining = props;
1218 }
1219
1220 if( m_bottomPostMachine->GetSelection() != wxNOT_FOUND )
1221 {
1223
1224 switch( m_bottomPostMachine->GetSelection() )
1225 {
1226 case 1: props.mode = PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK; break;
1227 case 2: props.mode = PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE; break;
1229 }
1230
1231 if( !m_bottomPostMachineSize1.IsIndeterminate() )
1232 props.size = m_bottomPostMachineSize1.GetIntValue();
1233
1234 if( !m_bottomPostMachineSize2.IsIndeterminate() )
1235 {
1237 props.angle = KiROUND( m_bottomPostMachineSize2.GetDoubleValue() * 10.0 );
1238 else
1239 props.depth = m_bottomPostMachineSize2.GetIntValue();
1240 }
1241
1242 backPostMachining = props;
1243 }
1244
1245 int copperLayerCount = m_frame->GetBoard() ? m_frame->GetBoard()->GetCopperLayerCount() : 0;
1246
1247 if( std::optional<PCB_VIA::VIA_PARAMETER_ERROR> error =
1248 PCB_VIA::ValidateViaParameters( viaDiameter, viaDrill, startLayer, endLayer,
1249 secondaryDrill, secondaryStartLayer,
1250 secondaryEndLayer, tertiaryDrill, tertiaryStartLayer,
1251 tertiaryEndLayer, copperLayerCount ) )
1252 {
1253 DisplayError( GetParent(), error->m_Message );
1254
1255 if( error->m_Field == PCB_VIA::VIA_PARAMETER_ERROR::FIELD::DRILL )
1256 {
1257 m_ViaDrillCtrl->SelectAll();
1258 m_ViaDrillCtrl->SetFocus();
1259 }
1260 else if( error->m_Field == PCB_VIA::VIA_PARAMETER_ERROR::FIELD::DIAMETER )
1261 {
1262 m_ViaDiameterCtrl->SelectAll();
1263 m_ViaDiameterCtrl->SetFocus();
1264 }
1265
1266 // Other fields might not have direct focus targets in new UI or I'd need to map them
1267 return false;
1268 }
1269
1270 }
1271
1272 if( m_tracks )
1273 {
1274 if( !m_trackWidth.Validate( GEOMETRY_MIN_SIZE, INT_MAX ) )
1275 return false;
1276 }
1277
1278 // If we survived that, then save the changes:
1279 //
1280 // We don't bother with updating the nets at this point as it will be useless (any connected
1281 // pads will simply drive their existing nets back onto the track segments and vias).
1282
1283 BOARD_COMMIT commit( m_frame );
1284 bool changeLock = m_lockedCbox->Get3StateValue() != wxCHK_UNDETERMINED;
1285 bool setLock = m_lockedCbox->Get3StateValue() == wxCHK_CHECKED;
1286
1287 for( PCB_TRACK* track : selected_tracks )
1288 {
1289
1290 if( !m_standalone )
1291 commit.Modify( track );
1292
1293 switch( track->Type() )
1294 {
1295 case PCB_TRACE_T:
1296 case PCB_ARC_T:
1297 {
1298 wxASSERT( m_tracks );
1299
1300 if( !m_trackStartX.IsIndeterminate() )
1301 track->SetStartX( m_trackStartX.GetIntValue() );
1302
1303 if( !m_trackStartY.IsIndeterminate() )
1304 track->SetStartY( m_trackStartY.GetIntValue() );
1305
1306 if( !m_trackEndX.IsIndeterminate() )
1307 track->SetEndX( m_trackEndX.GetIntValue() );
1308
1309 if( !m_trackEndY.IsIndeterminate() )
1310 track->SetEndY( m_trackEndY.GetIntValue() );
1311
1312 if( !m_trackWidth.IsIndeterminate() )
1313 track->SetWidth( m_trackWidth.GetIntValue() );
1314
1315 if( m_TrackLayerCtrl->GetLayerSelection() != UNDEFINED_LAYER )
1316 track->SetLayer( ToLAYER_ID( m_TrackLayerCtrl->GetLayerSelection() ) );
1317
1318 if ( m_trackHasSolderMask->Get3StateValue() != wxCHK_UNDETERMINED )
1319 track->SetHasSolderMask( m_trackHasSolderMask->GetValue() );
1320
1321 if( !m_trackMaskMargin.IsIndeterminate() )
1322 {
1323 if( m_trackMaskMargin.IsNull() )
1324 track->SetLocalSolderMaskMargin( {} );
1325 else
1326 track->SetLocalSolderMaskMargin( m_trackMaskMargin.GetIntValue() );
1327 }
1328
1329 if( changeLock )
1330 track->SetLocked( setLock );
1331
1332 break;
1333 }
1334
1335 case PCB_VIA_T:
1336 {
1337 wxASSERT( m_vias );
1338 PCB_VIA* via = static_cast<PCB_VIA*>( track );
1339 bool updatePadstack = m_padstackDirty;
1340
1341 // Edit each via's own padstack. Only a mode change replaces it wholesale.
1342 PADSTACK viaStack = m_padstackDirty ? *m_viaStack : via->Padstack();
1343
1344 if( !m_viaX.IsIndeterminate() )
1345 via->SetPosition( VECTOR2I( m_viaX.GetIntValue(), via->GetPosition().y ) );
1346
1347 if( !m_viaY.IsIndeterminate() )
1348 via->SetPosition( VECTOR2I( via->GetPosition().x, m_viaY.GetIntValue() ) );
1349
1350 if( m_viaNotFree->Get3StateValue() != wxCHK_UNDETERMINED )
1351 via->SetIsFree( !m_viaNotFree->GetValue() );
1352
1353 if( !m_viaDiameter.IsIndeterminate() )
1354 {
1355 int newDiameter = m_viaDiameter.GetIntValue();
1356 const VECTOR2I& currentSize = via->Padstack().Size( m_editLayer );
1357
1358 if( currentSize.x != newDiameter || currentSize.y != newDiameter )
1359 {
1360 viaStack.SetSize( { newDiameter, newDiameter }, m_editLayer );
1361 updatePadstack = true;
1362 }
1363 }
1364
1365 // Backdrill
1366 PADSTACK::DRILL_PROPS tertiaryDrill = via->Padstack().TertiaryDrill();
1367 PADSTACK::DRILL_PROPS secondaryDrill = via->Padstack().SecondaryDrill();
1368
1369 if( m_backdrillChoice->GetSelection() != wxNOT_FOUND )
1370 {
1371 switch( static_cast<BACKDRILL_MODE>( m_backdrillChoice->GetSelection() ) )
1372 {
1374 secondaryDrill.size = VECTOR2I( 0, 0 );
1375 secondaryDrill.start = UNDEFINED_LAYER;
1376 tertiaryDrill.size = VECTOR2I( 0, 0 );
1377 tertiaryDrill.start = UNDEFINED_LAYER;
1378 break;
1379
1381 secondaryDrill.size = VECTOR2I( 0, 0 );
1382 secondaryDrill.start = UNDEFINED_LAYER;
1383 tertiaryDrill.start = B_Cu;
1384 tertiaryDrill.shape = PAD_DRILL_SHAPE::CIRCLE;
1385
1386 if( !m_backdrillBackSize.IsIndeterminate() && !m_backdrillBackSize.IsNull() )
1387 {
1388 tertiaryDrill.size = VECTOR2I( m_backdrillBackSize.GetIntValue(),
1389 m_backdrillBackSize.GetIntValue() );
1390 }
1391
1392 if( m_backdrillBackLayer->GetLayerSelection() != UNDEFINED_LAYER )
1393 tertiaryDrill.end = ToLAYER_ID( m_backdrillBackLayer->GetLayerSelection() );
1394 else if( m_backdrillBackLayerMixed )
1395 tertiaryDrill.end = viaStack.TertiaryDrill().end;
1396
1397 break;
1398
1400 secondaryDrill.start = F_Cu;
1401 secondaryDrill.shape = PAD_DRILL_SHAPE::CIRCLE;
1402 tertiaryDrill.size = VECTOR2I( 0, 0 );
1403 tertiaryDrill.start = UNDEFINED_LAYER;
1404
1405 if( !m_backdrillFrontSize.IsIndeterminate() && !m_backdrillFrontSize.IsNull() )
1406 {
1407 secondaryDrill.size = VECTOR2I( m_backdrillFrontSize.GetIntValue(),
1408 m_backdrillFrontSize.GetIntValue() );
1409 }
1410
1411 if( m_backdrillFrontLayer->GetLayerSelection() != UNDEFINED_LAYER )
1412 secondaryDrill.end = ToLAYER_ID( m_backdrillFrontLayer->GetLayerSelection() );
1414 secondaryDrill.end = viaStack.SecondaryDrill().end;
1415
1416 break;
1417
1419 secondaryDrill.start = F_Cu;
1420 secondaryDrill.shape = PAD_DRILL_SHAPE::CIRCLE;
1421 tertiaryDrill.start = B_Cu;
1422 tertiaryDrill.shape = PAD_DRILL_SHAPE::CIRCLE;
1423
1424 if(! m_backdrillFrontSize.IsIndeterminate() && !m_backdrillFrontSize.IsNull() )
1425 {
1426 secondaryDrill.size = VECTOR2I( m_backdrillFrontSize.GetIntValue(),
1427 m_backdrillFrontSize.GetIntValue() );
1428 }
1429
1430 if( m_backdrillFrontLayer->GetLayerSelection() != UNDEFINED_LAYER )
1431 secondaryDrill.end = ToLAYER_ID( m_backdrillFrontLayer->GetLayerSelection() );
1433 secondaryDrill.end = viaStack.SecondaryDrill().end;
1434
1435 if( !m_backdrillBackSize.IsIndeterminate() && !m_backdrillBackSize.IsNull() )
1436 {
1437 tertiaryDrill.size = VECTOR2I( m_backdrillBackSize.GetIntValue(),
1438 m_backdrillBackSize.GetIntValue() );
1439 }
1440
1441 if( m_backdrillBackLayer->GetLayerSelection() != UNDEFINED_LAYER )
1442 tertiaryDrill.end = ToLAYER_ID( m_backdrillBackLayer->GetLayerSelection() );
1443 else if( m_backdrillBackLayerMixed )
1444 tertiaryDrill.end = viaStack.TertiaryDrill().end;
1445
1446 break;
1447 }
1448 }
1449 else
1450 {
1451 if( !m_backdrillFrontSize.IsIndeterminate() && !m_backdrillFrontSize.IsNull() )
1452 {
1453 secondaryDrill.size = VECTOR2I( m_backdrillFrontSize.GetIntValue(),
1454 m_backdrillFrontSize.GetIntValue() );
1455 }
1456
1457 if( !m_backdrillBackSize.IsIndeterminate() && !m_backdrillBackSize.IsNull() )
1458 {
1459 tertiaryDrill.size = VECTOR2I( m_backdrillBackSize.GetIntValue(),
1460 m_backdrillBackSize.GetIntValue() );
1461 }
1462 }
1463
1464 viaStack.SecondaryDrill() = secondaryDrill;
1465
1466 if( via->Padstack().SecondaryDrill() != secondaryDrill )
1467 updatePadstack = true;
1468
1469 viaStack.TertiaryDrill() = tertiaryDrill;
1470
1471 if( via->Padstack().TertiaryDrill() != tertiaryDrill )
1472 updatePadstack = true;
1473
1474 // Post Machining
1475 if( m_topPostMachine->GetSelection() != wxNOT_FOUND )
1476 {
1477 PADSTACK::POST_MACHINING_PROPS props = via->Padstack().FrontPostMachining();
1478
1479 switch( m_topPostMachine->GetSelection() )
1480 {
1481 case 1: props.mode = PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK; break;
1482 case 2: props.mode = PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE; break;
1484 }
1485
1486 if( !m_topPostMachineSize1.IsIndeterminate() )
1487 props.size = m_topPostMachineSize1.GetIntValue();
1488
1489 if( !m_topPostMachineSize2.IsIndeterminate() )
1490 {
1492 props.angle = KiROUND( m_topPostMachineSize2.GetDoubleValue() * 10.0 );
1493 else
1494 props.depth = m_topPostMachineSize2.GetIntValue();
1495 }
1496
1497 viaStack.FrontPostMachining() = props;
1498
1499 if( via->Padstack().FrontPostMachining() != props )
1500 updatePadstack = true;
1501 }
1502
1503 if( m_bottomPostMachine->GetSelection() != wxNOT_FOUND )
1504 {
1505 PADSTACK::POST_MACHINING_PROPS props = via->Padstack().BackPostMachining();
1506
1507 switch( m_bottomPostMachine->GetSelection() )
1508 {
1509 case 1: props.mode = PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK; break;
1510 case 2: props.mode = PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE; break;
1512 }
1513
1514 if( !m_bottomPostMachineSize1.IsIndeterminate() )
1515 props.size = m_bottomPostMachineSize1.GetIntValue();
1516
1517 if( !m_bottomPostMachineSize2.IsIndeterminate() )
1518 {
1520 props.angle = KiROUND( m_bottomPostMachineSize2.GetDoubleValue() * 10.0 );
1521 else
1522 props.depth = m_bottomPostMachineSize2.GetIntValue();
1523 }
1524
1525 viaStack.BackPostMachining() = props;
1526
1527 if( via->Padstack().BackPostMachining() != props )
1528 updatePadstack = true;
1529 }
1530
1531 switch( m_ViaTypeChoice->GetSelection() )
1532 {
1533 case 0: via->SetViaType( VIATYPE::THROUGH ); break;
1534 case 1: via->SetViaType( VIATYPE::MICROVIA ); break;
1535 case 2: via->SetViaType( VIATYPE::BLIND ); break;
1536 case 3: via->SetViaType( VIATYPE::BURIED ); break;
1537 default: break;
1538 }
1539
1540 PCB_LAYER_ID startLayer = static_cast<PCB_LAYER_ID>( m_ViaStartLayer->GetLayerSelection() );
1541 PCB_LAYER_ID endLayer = static_cast<PCB_LAYER_ID>( m_ViaEndLayer->GetLayerSelection() );
1542
1543 if( startLayer != UNDEFINED_LAYER )
1544 {
1545 viaStack.Drill().start = startLayer;
1546
1547 if( via->Padstack().Drill().start != startLayer )
1548 updatePadstack = true;
1549
1550 via->SetTopLayer( startLayer );
1551 }
1552
1553 if( endLayer != UNDEFINED_LAYER )
1554 {
1555 viaStack.Drill().end = endLayer;
1556
1557 if( via->Padstack().Drill().end != endLayer )
1558 updatePadstack = true;
1559
1560 via->SetBottomLayer( endLayer );
1561 }
1562
1563 if( updatePadstack )
1564 {
1565 via->SetPadstack( viaStack );
1566 via->SanitizeLayers();
1567 }
1568
1569 switch( m_annularRingsCtrl->GetSelection() )
1570 {
1571 case 0:
1572 via->Padstack().SetUnconnectedLayerMode( UNCONNECTED_LAYER_MODE::KEEP_ALL );
1573 break;
1574 case 1:
1575 via->Padstack().SetUnconnectedLayerMode( UNCONNECTED_LAYER_MODE::REMOVE_EXCEPT_START_AND_END );
1576 break;
1577 case 2:
1578 via->Padstack().SetUnconnectedLayerMode( UNCONNECTED_LAYER_MODE::REMOVE_ALL );
1579 break;
1580 case 3:
1581 via->Padstack().SetUnconnectedLayerMode( UNCONNECTED_LAYER_MODE::START_END_ONLY );
1582 break;
1583 default:
1584 break;
1585 }
1586
1587
1588 if( !m_viaDrill.IsIndeterminate() )
1589 via->SetDrill( m_viaDrill.GetIntValue() );
1590
1591 TEARDROP_PARAMETERS* targetParams = &via->GetTeardropParams();
1592
1593 if( m_cbTeardrops->Get3StateValue() != wxCHK_UNDETERMINED )
1594 targetParams->m_Enabled = m_cbTeardrops->GetValue();
1595
1596 if( m_cbTeardropsUseNextTrack->Get3StateValue() != wxCHK_UNDETERMINED )
1597 targetParams->m_AllowUseTwoTracks = m_cbTeardropsUseNextTrack->GetValue();
1598
1599 if( !m_teardropMaxLen.IsIndeterminate() )
1600 targetParams->m_TdMaxLen = m_teardropMaxLen.GetIntValue();
1601
1602 if( !m_teardropMaxWidth.IsIndeterminate() )
1603 targetParams->m_TdMaxWidth = m_teardropMaxWidth.GetIntValue();
1604
1605 if( !m_teardropLenPercent.IsIndeterminate() )
1606 targetParams->m_BestLengthRatio = m_teardropLenPercent.GetDoubleValue() / 100.0;
1607
1608 if( !m_teardropWidthPercent.IsIndeterminate() )
1609 targetParams->m_BestWidthRatio = m_teardropWidthPercent.GetDoubleValue() / 100.0;
1610
1611 if( !m_teardropHDPercent.IsIndeterminate() )
1612 targetParams->m_WidthtoSizeFilterRatio = m_teardropHDPercent.GetDoubleValue() / 100.0;
1613
1614 if( m_curvedEdges->Get3StateValue() != wxCHK_UNDETERMINED )
1615 targetParams->m_CurvedEdges = m_curvedEdges->GetValue();
1616
1617 if( changeLock )
1618 via->SetLocked( setLock );
1619
1620 setViaConfiguration( via, static_cast<IPC4761_PRESET>( m_protectionFeatures->GetSelection() ) );
1621 break;
1622 }
1623
1624 default:
1625 UNIMPLEMENTED_FOR( track->GetClass() );
1626 break;
1627 }
1628 }
1629
1630 std::set<int> shortingNets;
1631 int newNetCode = m_netSelector->GetSelectedNetcode();
1632 std::set<PAD*> changingPads;
1633
1634 // Do NOT use the connectivity code here. It will propagate through zones, and we haven't
1635 // refilled those yet so it's going to pick up a whole bunch of other nets any time the track
1636 // width was increased.
1637 auto collide =
1639 {
1640 for( PCB_LAYER_ID layer : LSET( a->GetLayerSet() & b->GetLayerSet() ) )
1641 {
1642 if( a->GetEffectiveShape( layer )->Collide( b->GetEffectiveShape( layer ).get() ) )
1643 return true;
1644 }
1645
1646 return false;
1647 };
1648
1649 for( PCB_TRACK* track : connected_tracks )
1650 {
1651 for( PCB_TRACK* other : m_frame->GetBoard()->Tracks() )
1652 {
1653 if( other->GetNetCode() == track->GetNetCode() || other->GetNetCode() == newNetCode )
1654 continue;
1655
1656 if( collide( track, other ) )
1657 shortingNets.insert( other->GetNetCode() );
1658 }
1659
1660 for( FOOTPRINT* footprint : m_frame->GetBoard()->Footprints() )
1661 {
1662 for( PAD* pad : footprint->Pads() )
1663 {
1664 if( pad->GetNetCode() == newNetCode )
1665 continue;
1666
1667 if( collide( track, pad ) )
1668 {
1669 if( pad->GetNetCode() == track->GetNetCode() )
1670 changingPads.insert( pad );
1671 else
1672 shortingNets.insert( pad->GetNetCode() );
1673 }
1674 }
1675 }
1676 }
1677
1678 if( shortingNets.size() && !confirmShortingNets( newNetCode, shortingNets ) )
1679 {
1680 commit.Revert();
1681 return true;
1682 }
1683
1684 if( !m_netSelector->IsIndeterminate() )
1685 {
1686 if( changingPads.empty() || confirmPadChange( changingPads ) )
1687 {
1688 for( PCB_TRACK* track : connected_tracks )
1689 {
1690 if( !alg::contains( selected_tracks, track ) )
1691 commit.Modify( track );
1692
1693 track->SetNetCode( newNetCode );
1694 }
1695
1696 for( PAD* pad : changingPads )
1697 {
1698 commit.Modify( pad );
1699 pad->SetNetCode( newNetCode );
1700 }
1701 }
1702 }
1703
1704 if( !m_standalone )
1705 commit.Push( _( "Edit Track/Via Properties" ) );
1706
1707 return true;
1708}
1709
1710
1712{
1713 m_viaNotFree->SetValue( false );
1714}
1715
1716
1718{
1719 if( !m_tracks )
1720 {
1721 m_netSelectorLabel->Enable( !m_viaNotFree->GetValue() );
1722 m_netSelector->Enable( !m_viaNotFree->GetValue() );
1723 }
1724}
1725
1726
1728{
1729 m_TrackWidthCtrl->ChangeValue( m_predefinedTrackWidthsCtrl->GetStringSelection() );
1730 m_TrackWidthCtrl->SelectAll();
1731}
1732
1733
1734void DIALOG_TRACK_VIA_PROPERTIES::onWidthEdit( wxCommandEvent& aEvent )
1735{
1736 m_predefinedTrackWidthsCtrl->SetStringSelection( m_TrackWidthCtrl->GetValue() );
1737}
1738
1739
1740void DIALOG_TRACK_VIA_PROPERTIES::onViaSelect( wxCommandEvent& aEvent )
1741{
1742 VIA_DIMENSION* viaDimension = static_cast<VIA_DIMENSION*> ( aEvent.GetClientData() );
1743
1744 m_viaDiameter.ChangeValue( viaDimension->m_Diameter );
1745 m_viaDrill.ChangeValue( viaDimension->m_Drill );
1746}
1747
1748
1750{
1751 wxCHECK_MSG( m_viaStack, /* void */, "Expected valid via stack in onPadstackModeChanged" );
1752
1753 switch( m_cbPadstackMode->GetSelection() )
1754 {
1755 default:
1756 case 0: m_viaStack->SetMode( PADSTACK::MODE::NORMAL ); break;
1757 case 1: m_viaStack->SetMode( PADSTACK::MODE::FRONT_INNER_BACK ); break;
1758 case 2: m_viaStack->SetMode( PADSTACK::MODE::CUSTOM ); break;
1759 }
1760
1761 m_padstackDirty = true;
1762
1764}
1765
1766
1768{
1769 wxCHECK_MSG( m_viaStack, /* void */, "Expected valid via stack in onEditLayerChanged" );
1770
1771 // Save data from the previous layer
1772 if( !m_viaDiameter.IsIndeterminate() )
1773 {
1774 int diameter = m_viaDiameter.GetIntValue();
1775 const VECTOR2I& currentSize = m_viaStack->Size( m_editLayer );
1776
1777 if( currentSize.x != diameter || currentSize.y != diameter )
1778 {
1779 m_viaStack->SetSize( { diameter, diameter }, m_editLayer );
1780 m_padstackDirty = true;
1781 }
1782 }
1783
1784 switch( m_viaStack->Mode() )
1785 {
1786 default:
1789 break;
1790
1792 switch( m_cbEditLayer->GetSelection() )
1793 {
1794 default:
1795 case 0: m_editLayer = F_Cu; break;
1796 case 1: m_editLayer = PADSTACK::INNER_LAYERS; break;
1797 case 2: m_editLayer = B_Cu; break;
1798 }
1799 break;
1800
1802 {
1803 int layer = m_cbEditLayer->GetSelection();
1804
1805 if( layer < 0 )
1806 layer = 0;
1807
1808 if( m_editLayerCtrlMap.contains( layer ) )
1809 m_editLayer = m_editLayerCtrlMap.at( layer );
1810 else
1811 m_editLayer = F_Cu;
1812 }
1813 }
1814
1815 // Load controls with the current layer
1816 m_viaDiameter.SetValue( m_viaStack->Size( m_editLayer ).x );
1817}
1818
1819
1821{
1822 // NOTE: synchronize changes here with DIALOG_PAD_PROPERTIES::afterPadstackModeChanged
1823
1824 wxCHECK_MSG( m_viaStack, /* void */, "Expected valid via stack in afterPadstackModeChanged" );
1825 m_cbEditLayer->Clear();
1826
1827 BOARD* board = m_frame->GetBoard();
1828
1829 switch( m_viaStack->Mode() )
1830 {
1832 m_cbPadstackMode->SetSelection( 0 );
1833 m_cbEditLayer->Append( _( "All layers" ) );
1834 m_cbEditLayer->Disable();
1837 break;
1838
1840 {
1841 m_cbPadstackMode->SetSelection( 1 );
1842 m_cbEditLayer->Enable();
1843
1844 std::vector choices = {
1845 board->GetLayerName( F_Cu ),
1846 _( "Inner Layers" ),
1847 board->GetLayerName( B_Cu )
1848 };
1849
1850 m_cbEditLayer->Append( choices );
1851
1853 { 0, F_Cu },
1855 { 2, B_Cu }
1856 };
1857
1858 if( m_editLayer != F_Cu && m_editLayer != B_Cu )
1860
1861 break;
1862 }
1863
1865 {
1866 m_cbPadstackMode->SetSelection( 2 );
1867 m_cbEditLayer->Enable();
1868 LSET layers = LSET::AllCuMask() & board->GetEnabledLayers();
1869
1870 for( PCB_LAYER_ID layer : layers.UIOrder() )
1871 {
1872 int idx = m_cbEditLayer->Append( board->GetLayerName( layer ) );
1873 m_editLayerCtrlMap[idx] = layer;
1874 }
1875
1876 break;
1877 }
1878 }
1879
1880 for( const auto& [idx, layer] : m_editLayerCtrlMap )
1881 {
1882 if( layer == m_editLayer )
1883 {
1884 m_cbEditLayer->SetSelection( idx );
1885 break;
1886 }
1887 }
1888}
1889
1890
1892{
1893 int viaType = m_ViaTypeChoice->GetSelection();
1894
1895 if( viaType <= 0 )
1896 return m_frame->GetBoard()->GetCopperLayerCount() - 1;
1897
1898 int startLayer = m_ViaStartLayer->GetLayerSelection();
1899 int endLayer = m_ViaEndLayer->GetLayerSelection();
1900
1901 if( startLayer < 0 || endLayer < 0 )
1902 return m_frame->GetBoard()->GetCopperLayerCount() - 1;
1903 else
1904 return m_frame->GetBoard()->LayerDepth( ToLAYER_ID( startLayer ), ToLAYER_ID( endLayer ) );
1905}
1906
1907
1908void DIALOG_TRACK_VIA_PROPERTIES::onViaEdit( wxCommandEvent& aEvent )
1909{
1910 m_predefinedViaSizesCtrl->SetSelection( wxNOT_FOUND );
1911
1912 if( m_vias )
1913 {
1914 if( m_ViaTypeChoice->GetSelection() != 0 ) // check if selected type isn't through.
1915 {
1916 m_ViaStartLayer->Enable();
1917 m_ViaEndLayer->Enable();
1918 }
1919 else
1920 {
1921 m_ViaStartLayer->SetLayerSelection( F_Cu );
1922 m_ViaEndLayer->SetLayerSelection( B_Cu );
1923
1924 m_ViaStartLayer->Enable( false );
1925 m_ViaEndLayer->Enable( false );
1926 }
1927
1928 m_annularRingsLabel->Show( getLayerDepth() > 1 );
1929 m_annularRingsCtrl->Show( getLayerDepth() > 1 );
1930 m_annularRingsCtrl->Enable( true );
1931
1932 // Blind and buried are told apart by the layers, so the type follows the selectors
1933 const int typeSel = m_ViaTypeChoice->GetSelection();
1934
1935 if( typeSel == VIA_TYPE_BLIND || typeSel == VIA_TYPE_BURIED )
1936 {
1937 const VIA_SPAN span = viaSpan();
1938
1939 if( span.m_ReachesFront != span.m_ReachesBack )
1940 m_ViaTypeChoice->SetSelection( VIA_TYPE_BLIND );
1941 else if( !span.m_ReachesFront && !span.m_ReachesBack )
1942 m_ViaTypeChoice->SetSelection( VIA_TYPE_BURIED );
1943 }
1944
1946 }
1947}
1948
1949
1950void DIALOG_TRACK_VIA_PROPERTIES::onTrackEdit( wxCommandEvent& aEvent )
1951{
1952 bool externalCuLayer = m_TrackLayerCtrl->GetLayerSelection() == F_Cu
1953 || m_TrackLayerCtrl->GetLayerSelection() == B_Cu;
1954
1955 m_techLayersLabel->Enable( externalCuLayer );
1956 m_trackHasSolderMask->Enable( externalCuLayer );
1957
1958 bool showMaskMargin = externalCuLayer && m_trackHasSolderMask->GetValue();
1959
1960 m_trackMaskMarginCtrl->Enable( showMaskMargin );
1961 m_trackMaskMarginLabel->Enable( showMaskMargin );
1962 m_trackMaskMarginUnit->Enable( showMaskMargin );
1963}
1964
1965
1967{
1968 event.Enable( !m_frame->GetBoard()->LegacyTeardrops() );
1969}
1970
1971
1973{
1974 const BACKDRILL_MODE mode = static_cast<BACKDRILL_MODE>( m_backdrillChoice->GetSelection() );
1975
1976 bool enableTop = mode == BACKDRILL_MODE::BACKDRILL_TOP || mode == BACKDRILL_MODE::BACKDRILL_BOTH;
1977 bool enableBottom = mode == BACKDRILL_MODE::BACKDRILL_BOTTOM || mode == BACKDRILL_MODE::BACKDRILL_BOTH;
1978
1979 m_backdrillFrontSize.Enable( enableTop );
1980 m_backdrillFrontLayer->Enable( enableTop );
1981 m_backdrillFrontLayerLabel->Enable( enableTop );
1982
1983 m_backdrillBackSize.Enable( enableBottom );
1984 m_backdrillBackLayer->Enable( enableBottom ); // Back layer selector
1985 m_backdrillBackLayerLabel->Enable( enableBottom ); // Back layer label
1986
1987 // Initialize values if this was a user event that turned on backdrills
1988 if( aFromUserEvent )
1989 {
1990 if( enableTop )
1991 {
1992 if( m_backdrillFrontLayer->GetLayerSelection() == UNDEFINED_LAYER )
1993 m_backdrillFrontLayer->SetLayerSelection( F_Cu );
1994
1995 if( m_backdrillFrontSize.GetIntValue() == 0 )
1996 {
1997 // Initialize backdrill slightly larger than main drill (see PADSTACK::SetBackdrillMode())
1998 m_backdrillFrontSize.SetValue( KiROUND( m_viaDrill.GetIntValue() * 1.1 ) );
1999 }
2000 }
2001
2002 if( enableBottom )
2003 {
2004 if( m_backdrillBackLayer->GetLayerSelection() == UNDEFINED_LAYER )
2005 m_backdrillBackLayer->SetLayerSelection( B_Cu );
2006
2007 if( m_backdrillBackSize.GetIntValue() == 0 )
2008 {
2009 // Initialize backdrill slightly larger than main drill (see PADSTACK::SetBackdrillMode())
2010 m_backdrillBackSize.SetValue( KiROUND( m_viaDrill.GetIntValue() * 1.1 ) );
2011 }
2012 }
2013 }
2014}
2015
2016
2018{
2019 syncBackdrillControls( true );
2021}
2022
2023
2037
2038
2039void DIALOG_TRACK_VIA_PROPERTIES::syncPostMachineControls( bool aFront, bool aFromUserEvent )
2040{
2042 const int selection = ctrls.m_Mode->GetSelection();
2043
2044 bool enable = selection != POST_MACHINE_NONE;
2045 ctrls.m_Size.Enable( enable );
2046 ctrls.m_AngleOrDepth.Enable( enable );
2047 ctrls.m_SizeLabel->Enable( enable );
2048 ctrls.m_AngleOrDepthLabel->Enable( enable );
2049
2050 // The second field holds an angle for a countersink and a depth for a counterbore, so a
2051 // value left over from the other mode is replaced rather than reread in the new units
2052 bool wasAngle = ctrls.m_AngleOrDepth.GetUnits() == EDA_UNITS::DEGREES;
2053
2054 if( selection == POST_MACHINE_COUNTERBORE )
2055 {
2056 ctrls.m_AngleOrDepthLabel->SetLabel( _( "Depth:" ) );
2057 ctrls.m_AngleOrDepthUnits->SetLabel( EDA_UNIT_UTILS::GetLabel( m_frame->GetUserUnits() ) );
2058 ctrls.m_AngleOrDepth.SetUnits( m_frame->GetUserUnits() );
2059
2060 if( wasAngle )
2061 ctrls.m_AngleOrDepth.SetValue( wxEmptyString );
2062 }
2063 else
2064 {
2065 ctrls.m_AngleOrDepthLabel->SetLabel( _( "Angle:" ) );
2066 ctrls.m_AngleOrDepthUnits->SetLabel( _( "deg" ) );
2068 }
2069
2070 // Initialize values if this was a user event that turned on post machining
2071 if( aFromUserEvent && selection == POST_MACHINE_COUNTERSINK )
2072 {
2073 if( !wasAngle || ctrls.m_AngleOrDepth.IsIndeterminate() || ctrls.m_AngleOrDepth.GetDoubleValue() == 0 )
2074 ctrls.m_AngleOrDepth.SetDoubleValue( 82.0 );
2075 }
2076}
2077
2078
2080{
2081 syncPostMachineControls( true, true );
2083}
2084
2085
2087{
2088 syncPostMachineControls( false, true );
2090}
2091
2092
2094{
2096}
2097
2098
2100{
2102}
2103
2104
2106{
2107 if( aLayer == B_Cu )
2108 return m_frame->GetBoard()->GetCopperLayerCount() - 1;
2109
2110 return static_cast<int>( CopperLayerToOrdinal( aLayer ) );
2111}
2112
2113
2115{
2116 if( aOrdinal <= 0 )
2117 return F_Cu;
2118
2119 if( aOrdinal >= m_frame->GetBoard()->GetCopperLayerCount() - 1 )
2120 return B_Cu;
2121
2122 return ToLAYER_ID( B_Cu + 2 * aOrdinal );
2123}
2124
2125
2127{
2128 const int last = m_frame->GetBoard()->GetCopperLayerCount() - 1;
2129 const int typeSel = m_ViaTypeChoice->GetSelection();
2130
2131 VIA_SPAN span{ 0, last, typeSel == VIA_TYPE_THROUGH || typeSel == wxNOT_FOUND, true, true };
2132
2133 // A through via spans the board, and so does a selection whose layers are mixed
2134 if( span.m_Through )
2135 return span;
2136
2137 const int start = m_ViaStartLayer->GetLayerSelection();
2138 const int end = m_ViaEndLayer->GetLayerSelection();
2139
2140 if( start == UNDEFINED_LAYER || end == UNDEFINED_LAYER )
2141 return span;
2142
2143 const int a = copperOrdinal( ToLAYER_ID( start ) );
2144 const int b = copperOrdinal( ToLAYER_ID( end ) );
2145
2146 span.m_Top = std::min( a, b );
2147 span.m_Bottom = std::max( a, b );
2148 span.m_ReachesFront = span.m_Top == 0;
2149 span.m_ReachesBack = span.m_Bottom == last;
2150
2151 return span;
2152}
2153
2154
2156{
2157 if( !m_vias )
2158 return;
2159
2160 const BOARD* board = m_frame->GetBoard();
2161 const BOARD_DESIGN_SETTINGS& bds = board->GetDesignSettings();
2162 const int copperLayers = board->GetCopperLayerCount();
2163 const VIA_SPAN span = viaSpan();
2164
2166 state.m_InnerLayers = std::max( 0, copperLayers - 2 );
2167 state.m_TopLayer = span.m_Top;
2168 state.m_BottomLayer = span.m_Bottom;
2169
2170 const int boardThickness = VIA_CROSS_SECTION_GEOMETRY::SetLayersFromStackup( state, board->GetStackupOrDefault(),
2171 copperLayers );
2172
2173 const int drillSize = m_viaDrill.IsIndeterminate() ? 0 : m_viaDrill.GetIntValue();
2174
2175 auto ratioToDrill =
2176 [&]( UNIT_BINDER& aSize, double& aRatio )
2177 {
2178 if( drillSize > 0 && !aSize.IsIndeterminate() && !aSize.IsNull() )
2179 aRatio = (double) aSize.GetIntValue() / drillSize;
2180 };
2181
2182 ratioToDrill( m_viaDiameter, state.m_PadRatio );
2183
2184 // Which layers keep an annular ring. Connection is a board question, so it is only asked
2185 // for a single via, and a multi-via selection keeps every ring.
2186 const PCB_VIA* via = nullptr;
2187
2188 if( m_items.CountType( PCB_VIA_T ) == 1 )
2189 {
2190 for( EDA_ITEM* item : m_items )
2191 {
2192 if( item->Type() == PCB_VIA_T )
2193 via = static_cast<const PCB_VIA*>( item );
2194 }
2195 }
2196
2197 const int ringMode = m_annularRingsCtrl->GetSelection();
2198
2199 if( via && ringMode > ANNULAR_RINGS_ALL && ringMode <= ANNULAR_RINGS_START_END )
2200 {
2201 std::shared_ptr<CONNECTIVITY_DATA> connectivity = board->GetConnectivity();
2202
2203 for( int ordinal = 0; ordinal < copperLayers; ordinal++ )
2204 {
2205 bool startEnd = ordinal == span.m_Top || ordinal == span.m_Bottom;
2206 bool connected = connectivity->IsConnectedOnLayer( via, copperLayer( ordinal ),
2208
2209 switch( ringMode )
2210 {
2211 case ANNULAR_RINGS_START_END_CONNECTED: state.m_RingLayers.push_back( startEnd || connected ); break;
2212 case ANNULAR_RINGS_CONNECTED: state.m_RingLayers.push_back( connected ); break;
2213 default: state.m_RingLayers.push_back( startEnd ); break;
2214 }
2215 }
2216 }
2217
2218 // The protection features come from the preset, or from a single via's own padstack when
2219 // the preset is custom, each resolved against the board default. Several custom vias have
2220 // no common padstack, so every feature is left unset there and drawn mixed.
2221 std::optional<PADSTACK> stack;
2222 const int preset = m_protectionFeatures->GetSelection();
2223
2224 if( preset >= 0 && preset < static_cast<int>( IPC4761_PRESET::CUSTOM ) )
2225 {
2226 stack.emplace( nullptr );
2227 setViaConfiguration( *stack, static_cast<IPC4761_PRESET>( preset ) );
2228 }
2229 else if( m_viaStack && m_items.CountType( PCB_VIA_T ) == 1 )
2230 {
2231 stack = *m_viaStack;
2232 }
2233
2234 if( stack )
2235 {
2236 state.m_TentFront = stack->FrontOuterLayers().has_solder_mask.value_or( bds.m_TentViasFront );
2237 state.m_TentBack = stack->BackOuterLayers().has_solder_mask.value_or( bds.m_TentViasBack );
2238 state.m_CoverFront = stack->FrontOuterLayers().has_covering.value_or( bds.m_CoverViasFront );
2239 state.m_CoverBack = stack->BackOuterLayers().has_covering.value_or( bds.m_CoverViasBack );
2240 state.m_PlugFront = stack->FrontOuterLayers().has_plugging.value_or( bds.m_PlugViasFront );
2241 state.m_PlugBack = stack->BackOuterLayers().has_plugging.value_or( bds.m_PlugViasBack );
2242 state.m_Filled = stack->Drill().is_filled.value_or( bds.m_FillVias );
2243 state.m_Capped = stack->Drill().is_capped.value_or( bds.m_CapVias );
2244 }
2245
2246 // A backdrill removes every copper layer from its surface down to the layer chosen, so the
2247 // count includes the surface layer
2248 auto backdrilledLayers = [&]( PCB_LAYER_BOX_SELECTOR* aLayerBox, bool aFromFront ) -> std::optional<int>
2249 {
2250 int layer = aLayerBox->GetLayerSelection();
2251
2252 if( layer == UNDEFINED_LAYER )
2253 return std::nullopt;
2254
2255 int ordinal = copperOrdinal( ToLAYER_ID( layer ) );
2256
2257 return aFromFront ? ordinal + 1 : copperLayers - ordinal;
2258 };
2259
2260 // Backdrilling is a through via operation, the greyed controls of any other type are ignored
2261 const int backdrill =
2262 span.m_Through ? m_backdrillChoice->GetSelection() : static_cast<int>( BACKDRILL_MODE::NO_BACKDRILL );
2263
2264 if( backdrill == wxNOT_FOUND )
2265 {
2266 state.m_BackdrillFrontLayers.reset();
2267 state.m_BackdrillBackLayers.reset();
2268 }
2269 else
2270 {
2271 BACKDRILL_MODE mode = static_cast<BACKDRILL_MODE>( backdrill );
2272
2274 {
2275 state.m_BackdrillFrontLayers = backdrilledLayers( m_backdrillFrontLayer, true );
2276 ratioToDrill( m_backdrillFrontSize, state.m_BackdrillFrontWidthRatio );
2277 }
2278
2280 {
2281 state.m_BackdrillBackLayers = backdrilledLayers( m_backdrillBackLayer, false );
2282 ratioToDrill( m_backdrillBackSize, state.m_BackdrillBackWidthRatio );
2283 }
2284 }
2285
2286 auto postMachining = [&]( bool aFront )
2287 {
2290
2291 switch( ctrls.m_Mode->GetSelection() )
2292 {
2296 default: cut.m_Mode.reset(); break;
2297 }
2298
2299 ratioToDrill( ctrls.m_Size, cut.m_WidthRatio );
2300
2301 if( boardThickness > 0 && !ctrls.m_AngleOrDepth.IsIndeterminate() && !ctrls.m_AngleOrDepth.IsNull() )
2302 {
2303 double depth = 0;
2304
2306 {
2307 // The cone meets the hole wall where its half angle says it does
2308 double angle = std::clamp( ctrls.m_AngleOrDepth.GetDoubleValue(), 20.0, 170.0 );
2309 depth = drillSize * ( cut.m_WidthRatio - 1 ) / 2 / std::tan( angle * M_PI / 360.0 );
2310 }
2311 else
2312 {
2313 depth = ctrls.m_AngleOrDepth.GetIntValue();
2314 }
2315
2316 cut.m_DepthFraction = depth / boardThickness;
2317 }
2318
2319 return cut;
2320 };
2321
2322 state.m_PostMachiningFront = postMachining( true );
2323 state.m_PostMachiningBack = postMachining( false );
2324
2325 m_viaPreview->SetState( state );
2326}
2327
2328
2330{
2331 // Backdrilling needs a through via and a cut needs a surface the via reaches. What cannot
2332 // apply is greyed, never changed, so a stored value survives a round trip.
2333 const VIA_SPAN span = viaSpan();
2334
2335 // The choices set their dependent fields first, the span then overrides
2336 syncBackdrillControls( false );
2337 syncPostMachineControls( true, false );
2338 syncPostMachineControls( false, false );
2339
2340 m_backdrillLabel->Enable( span.m_Through );
2341 m_backdrillChoice->Enable( span.m_Through );
2342
2343 if( !span.m_Through )
2344 {
2345 m_backdrillFrontSize.Enable( false );
2346 m_backdrillBackSize.Enable( false );
2347
2348 for( wxWindow* ctrl : std::initializer_list<wxWindow*>{ m_backdrillFrontLayer, m_backdrillFrontLayerLabel,
2350 {
2351 ctrl->Enable( false );
2352 }
2353 }
2354
2355 for( bool front : { true, false } )
2356 {
2357 const bool reaches = front ? span.m_ReachesFront : span.m_ReachesBack;
2359
2360 ctrls.m_ModeLabel->Enable( reaches );
2361 ctrls.m_Mode->Enable( reaches );
2362
2363 if( !reaches )
2364 {
2365 ctrls.m_Size.Enable( false );
2366 ctrls.m_AngleOrDepth.Enable( false );
2367 ctrls.m_SizeLabel->Enable( false );
2368 ctrls.m_AngleOrDepthLabel->Enable( false );
2369 }
2370 }
2371
2373}
const char * name
wxBitmapBundle KiBitmapBundle(BITMAPS aBitmap, int aMinHeight)
Definition bitmap.cpp:106
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition box2.h:985
void Push(const wxString &aMessage=wxEmptyString, int aCommitFlags=0) override
Execute the changes.
void Revert() override
Revert the commit by restoring the modified items state.
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
PCB_LAYER_ID GetLayer() const override
Return the primary layer this item is on.
TEARDROP_PARAMETERS & GetTeardropParams()
Container for design settings for a BOARD object.
bool IsLocked() const override
FOOTPRINT * GetParentFootprint() const
virtual LSET GetLayerSet() const
Return a std::bitset of all layers on which the item physically resides.
Definition board_item.h:369
virtual std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=FLASHING::DEFAULT, DRC_CONSTRAINT_T aUsage=NULL_CONSTRAINT) const
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:411
BOARD_STACKUP GetStackupOrDefault() const
Definition board.cpp:3506
int GetCopperLayerCount() const
Definition board.cpp:1155
const wxString GetLayerName(PCB_LAYER_ID aLayer) const
Return the name of a aLayer.
Definition board.cpp:960
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
COMMIT & Modify(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr, RECURSE_MODE aRecurse=RECURSE_MODE::NO_RECURSE)
Modify a given item in the model.
Definition commit.h:102
void SetInitialFocus(wxWindow *aWindow)
Sets the window (usually a wxTextCtrl) that should be focused when the dialog is shown.
Definition dialog_shim.h:95
void SetupStandardButtons(std::map< int, wxString > aLabels={})
bool m_useCalculatedSize
void finishDialogSettings()
In all dialogs, we must call the same functions to fix minimal dlg size, the default position and per...
DIALOG_TRACK_VIA_PROPERTIES_BASE(wxWindow *parent, wxWindowID id=wxID_ANY, const wxString &title=_("Track & Via Properties"), const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxSize(-1,-1), long style=wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER|wxSYSTEM_MENU)
void onWidthEdit(wxCommandEvent &aEvent) override
void onUnitsChanged(wxCommandEvent &aEvent)
void onNetSelector(wxCommandEvent &aEvent)
void onWidthSelect(wxCommandEvent &aEvent) override
bool confirmShortingNets(int aNet, const std::set< int > &shortingNets)
int copperOrdinal(PCB_LAYER_ID aLayer) const
Copper layers as ordinals, 0 for the front and the copper count minus one for the back.
void syncBackdrillControls(bool aFromUserEvent)
Enable the fields that depend on a choice, without touching the preview.
bool m_standalone
Dialog was constructed for a standalone via (via stitching.
void syncPostMachineControls(bool aFront, bool aFromUserEvent)
bool m_backdrillFrontLayerMixed
A layer selector cannot hold a mixed state in its value, so the dialog remembers it.
void onTeardropsUpdateUi(wxUpdateUIEvent &event) override
void onPadstackModeChanged(wxCommandEvent &aEvent) override
void onBackdrillChange(wxCommandEvent &aEvent) override
void onViaEdit(wxCommandEvent &aEvent) override
std::map< int, PCB_LAYER_ID > m_editLayerCtrlMap
PCB_LAYER_ID copperLayer(int aOrdinal) const
void onProtectionFeaturesChange(wxCommandEvent &aEvent) override
PCB_LAYER_ID m_editLayer
The currently-shown copper layer of the edited via(s)
void onViaSelect(wxCommandEvent &aEvent) override
bool TransferDataToWindow() override
Get data from the PCB board and display it to dialog.
void onBottomPostMachineChange(wxCommandEvent &aEvent) override
void onEditLayerChanged(wxCommandEvent &aEvent) override
void onTopPostMachineChange(wxCommandEvent &aEvent) override
void onViaNotFreeClicked(wxCommandEvent &aEvent) override
void commonInit(PCB_BASE_EDIT_FRAME *aParent)
DIALOG_TRACK_VIA_PROPERTIES(PCB_BASE_EDIT_FRAME *aParent, const PCB_SELECTION &aItems)
std::unique_ptr< PADSTACK > m_viaStack
Temporary padstack of the edited via(s)
PCB_SELECTION m_viaStandaloneSelection
Used for standalone via mode to flow through the normal update logic.
bool confirmPadChange(const std::set< PAD * > &connectedPads)
POST_MACHINE_CONTROLS postMachineControls(bool aFront)
void onMachiningEdit(wxCommandEvent &aEvent) override
void onTrackEdit(wxCommandEvent &aEvent) override
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
const wxString & GetReference() const
Definition footprint.h:793
Helper class to create more flexible dialogs, including 'do not show again' checkbox handling.
Definition kidialog.h:38
void DoNotShowCheckbox(wxString file, int line)
Shows the 'do not show again' checkbox.
Definition kidialog.cpp:51
bool SetOKCancelLabels(const ButtonLabel &ok, const ButtonLabel &cancel) override
Definition kidialog.h:48
int ShowModal() override
Definition kidialog.cpp:89
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
LSEQ UIOrder() const
Return the copper, technical and user layers in the order shown in layer widget.
Definition lset.cpp:739
static LSET AllNonCuMask()
Return a mask holding all layer minus CU layers.
Definition lset.cpp:623
A PADSTACK defines the characteristics of a single or multi-layer pad, in the IPC sense of the word.
Definition padstack.h:161
POST_MACHINING_PROPS & FrontPostMachining()
Definition padstack.h:372
DRILL_PROPS & TertiaryDrill()
Definition padstack.h:369
DRILL_PROPS & Drill()
Definition padstack.h:363
@ NORMAL
Shape is the same on all layers.
Definition padstack.h:175
@ CUSTOM
Shapes can be defined on arbitrary layers.
Definition padstack.h:177
@ FRONT_INNER_BACK
Up to three shapes can be defined (F_Cu, inner copper layers, B_Cu)
Definition padstack.h:176
DRILL_PROPS & SecondaryDrill()
Definition padstack.h:366
POST_MACHINING_PROPS & BackPostMachining()
Definition padstack.h:375
void SetSize(const VECTOR2I &aSize, PCB_LAYER_ID aLayer)
Definition padstack.cpp:873
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
Definition pad.h:61
const wxString & GetNumber() const
Definition pad.h:143
Common, abstract interface for edit frames.
Class to display a pcb layer list in a wxBitmapComboBox.
bool HasSolderMask() const
Definition pcb_track.h:124
int GetStartY() const
Definition pcb_track.h:106
int GetEndX() const
Definition pcb_track.h:111
std::optional< int > GetLocalSolderMaskMargin() const
Definition pcb_track.h:127
int GetEndY() const
Definition pcb_track.h:112
int GetStartX() const
Definition pcb_track.h:105
virtual int GetWidth() const
Definition pcb_track.h:94
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
PCB_LAYER_ID BottomLayer() const
VECTOR2I GetPosition() const override
Definition pcb_track.h:615
const PADSTACK & Padstack() const
Definition pcb_track.h:435
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)
int GetWidth() const override
PCB_LAYER_ID TopLayer() const
int GetDrillValue() const
Calculate the drill value for vias (m_drill if > 0, or default drill value for the board).
VIATYPE GetViaType() const
Definition pcb_track.h:426
virtual bool Collide(const VECTOR2I &aP, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const
Check if the boundary of shape (this) lies closer to the point aP than aClearance,...
Definition shape.h:181
TEARDROP_PARAMETARS is a helper class to handle parameters needed to build teardrops for a board thes...
double m_BestWidthRatio
The height of a teardrop as ratio between height and size of pad/via.
int m_TdMaxLen
max allowed length for teardrops in IU. <= 0 to disable
bool m_AllowUseTwoTracks
True to create teardrops using 2 track segments if the first in too small.
int m_TdMaxWidth
max allowed height for teardrops in IU. <= 0 to disable
double m_BestLengthRatio
The length of a teardrop as ratio between length and size of pad/via.
double m_WidthtoSizeFilterRatio
The ratio (H/D) between the via/pad size and the track width max value to create a teardrop 1....
bool m_Enabled
Flag to enable teardrops.
bool m_CurvedEdges
True if the teardrop should be curved.
void Enable(bool aEnable)
Enable/disable the label, widget and units label.
EDA_UNITS GetUnits() const
Definition unit_binder.h:70
virtual void SetUnits(EDA_UNITS aUnits)
Normally not needed (as the UNIT_BINDER inherits from the parent frame), but can be used to set to DE...
virtual double GetDoubleValue() const
Return the current value in Internal Units.
bool IsIndeterminate() const
Return true if the control holds the indeterminate value (for instance, if it represents a multiple s...
int GetIntValue() const
virtual void SetDoubleValue(double aValue)
Set new value (in Internal Units) for the text field, taking care of units conversion.
virtual void SetValue(long long int aValue)
Set new value (in Internal Units) for the text field, taking care of units conversion.
bool IsNull() const
Return true if the control holds no value (ie: empty string, not 0).
static int SetLayersFromStackup(STATE &aState, const BOARD_STACKUP &aStackup, int aCopperLayerCount)
Fill the layer depths and thicknesses from a stackup, or leave them empty when it does not match the ...
VIA_CROSS_SECTION_GEOMETRY::STATE STATE
VIA_CROSS_SECTION_GEOMETRY::POST_MACHINING POST_MACHINING
IPC4761_PRESET getViaConfiguration(const PCB_VIA *aVia)
const std::map< IPC4761_PRESET, wxString > m_IPC4761Names
void setViaConfiguration(PADSTACK &aStack, const IPC4761_PRESET &aPreset)
void DisplayError(wxWindow *aParent, const wxString &aText)
Display an error or warning message box with aMessage.
Definition confirm.cpp:192
This file is part of the common library.
#define EXCLUDE_ZONES
@ ANNULAR_RINGS_START_END_CONNECTED
#define _(s)
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
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:56
@ B_Cu
Definition layer_ids.h:61
@ 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
This file contains miscellaneous commonly used macros and functions.
#define UNIMPLEMENTED_FOR(type)
Definition macros.h:92
KICOMMON_API wxString GetLabel(EDA_UNITS aUnits, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE)
Get the units string for a given units type.
KICOMMON_API wxFont GetInfoFont(wxWindow *aWindow)
KICOMMON_API wxFont GetSmallInfoFont(wxWindow *aWindow)
bool contains(const _Container &__container, _Value __value)
Returns true if the container contains the given value.
Definition kicad_algo.h:96
BACKDRILL_MODE
Definition padstack.h:85
#define GEOMETRY_MIN_SIZE
Definition pcb_track.h:58
VIATYPE
bool collide(T aObject, U aAnotherObject, int aLayer, int aMinDistance)
Used by SHAPE_INDEX to implement Query().
The copper layers the edited via spans, as read from the type and layer controls.
bool m_Through
the type control says through, or is mixed
int m_Top
ordinal of the first copper layer
int m_Bottom
ordinal of the last copper layer
bool m_ReachesBack
the span ends on the back copper
bool m_ReachesFront
the span starts on the front copper
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
VECTOR2I size
Drill diameter (x == y) or slot dimensions (x != y)
Definition padstack.h:278
PAD_DRILL_SHAPE shape
Definition padstack.h:279
std::optional< PAD_DRILL_POST_MACHINING_MODE > mode
Definition padstack.h:292
std::vector< bool > m_RingLayers
Which spanned copper layers keep an annular ring. Empty means all of them.
int m_TopLayer
Copper layers the via spans, as ordinals where 0 is the front layer and the inner count plus one is t...
std::optional< int > m_BackdrillFrontLayers
Copper layers removed from that side by the backdrill, 0 for no backdrill, and the backdrill diameter...
double m_PadRatio
Pad diameter over hole diameter.
Container to handle a stock of specific vias each with unique diameter and drill sizes in the BOARD c...
KIBIS top(path, &reporter)
VECTOR2I end
#define M_PI
@ 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
#define INDETERMINATE_ACTION
Definition ui_common.h:49
#define INDETERMINATE_STATE
Used for holding indeterminate values, such as with multiple selections holding different values or c...
Definition ui_common.h:48
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:708