KiCad PCB EDA Suite
Loading...
Searching...
No Matches
board_design_settings.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 The KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, you may find one here:
18 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
19 * or you may search the http://www.gnu.org website for the version 2 license,
20 * or you may write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24#include <pcb_dimension.h>
25#include <pcb_track.h>
26#include <layer_ids.h>
27#include <lset.h>
28#include <kiface_base.h>
29#include <pad.h>
31#include <drc/drc_item.h>
32#include <drc/drc_engine.h>
34#include <settings/parameters.h>
36#include <advanced_config.h>
37
38const int bdsSchemaVersion = 2;
39
40
41BOARD_DESIGN_SETTINGS::BOARD_DESIGN_SETTINGS( JSON_SETTINGS* aParent, const std::string& aPath ) :
42 NESTED_SETTINGS( "board_design_settings", bdsSchemaVersion, aParent, aPath )
43{
44 // We want to leave alone parameters that aren't found in the project JSON as they may be
45 // initialized by the board file parser before NESTED_SETTINGS::LoadFromFile is called.
47
48 // Create a default NET_SETTINGS so that things don't break horribly if there's no project
49 // loaded. This also is used during file load for legacy boards that have netclasses stored
50 // in the file. After load, this information will be moved to the project and the pointer
51 // updated.
52 m_NetSettings = std::make_shared<NET_SETTINGS>( nullptr, "" );
53
54 m_HasStackup = false; // no stackup defined by default
55
56 m_Pad_Master = std::make_unique<PAD>( nullptr );
58
59 LSET all_set = LSET().set();
60 m_enabledLayers = all_set; // All layers enabled at first.
61 // SetCopperLayerCount() will adjust this.
62
63 // Default design is a double layer board with 4 user defined layers
66
68
69 // if true, when creating a new track starting on an existing track, use this track width
72
73 // First is always the reference designator
74 m_DefaultFPTextItems.emplace_back( wxT( "REF**" ), true, F_SilkS );
75 // Second is always the value
76 m_DefaultFPTextItems.emplace_back( wxT( "" ), true, F_Fab );
77 // Any following ones are freebies
78 m_DefaultFPTextItems.emplace_back( wxT( "${REFERENCE}" ), true, F_Fab );
79
86
93
94 // Edges & Courtyards; text properties aren't used but better to have them holding
95 // reasonable values than not.
98 pcbIUScale.mmToIU( DEFAULT_TEXT_SIZE ) );
102
105 pcbIUScale.mmToIU( DEFAULT_TEXT_SIZE ) );
109
112 pcbIUScale.mmToIU( DEFAULT_TEXT_SIZE ) );
114 m_TextItalic[ LAYER_CLASS_FAB ] = false;
116
119 pcbIUScale.mmToIU( DEFAULT_TEXT_SIZE ) );
123
124 m_StyleFPFields = false;
125 m_StyleFPText = false;
126 m_StyleFPShapes = false;
127
136
137 m_useCustomTrackVia = false;
139 m_customViaSize.m_Diameter = pcbIUScale.mmToIU( DEFAULT_VIASMINSIZE );
141
142 m_useCustomDiffPair = false;
146
163
164 for( int errorCode = DRCE_FIRST; errorCode <= DRCE_LAST; ++errorCode )
165 m_DRCSeverities[ errorCode ] = RPT_SEVERITY_ERROR;
166
169
173
176
179
181
188
194
196
199
201
204
208
209 // Global mask margins:
213
214 // Solder paste margin absolute value
216 // Solder paste margin as a ratio of pad size
217 // The final margin is the sum of these 2 values
218 // Usually < 0 because the mask is smaller than pad
220
222 m_TentViasFront = true;
223 m_TentViasBack = true;
224
225 m_CoverViasFront = false;
226 m_CoverViasBack = false;
227
228 m_PlugViasFront = false;
229 m_PlugViasBack = false;
230
231 m_CapVias = false;
232
233 m_FillVias = false;
234
235 // Layer thickness for 3D viewer
237
238 // Default spacing for meanders
242
243 m_viaSizeIndex = 0;
245 m_diffPairIndex = 0;
246
247 // Parameters stored in JSON in the project file
248
249 // NOTE: Previously, BOARD_DESIGN_SETTINGS stored the basic board layer information (layer
250 // names and enable/disable state) in the project file even though this information is also
251 // stored in the board file. This was implemented for importing these settings from another
252 // project. Going forward, the import feature will just import from other board files (since
253 // we could have multi-board projects in the future anyway) so this functionality is dropped.
254
255
256 m_params.emplace_back( new PARAM<bool>( "rules.use_height_for_length_calcs",
257 &m_UseHeightForLengthCalcs, true ) );
258
259 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_clearance",
261 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 25.0 ), pcbIUScale.MM_PER_IU ) );
262
263 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_connection",
265 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 100.0 ), pcbIUScale.MM_PER_IU ) );
266
267 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_track_width",
269 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 25.0 ), pcbIUScale.MM_PER_IU ) );
270
271 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_via_annular_width",
273 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 25.0 ), pcbIUScale.MM_PER_IU ) );
274
275 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_via_diameter",
277 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 25.0 ), pcbIUScale.MM_PER_IU ) );
278
279 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_through_hole_diameter",
281 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 25.0 ), pcbIUScale.MM_PER_IU ) );
282
283 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_microvia_diameter",
285 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 10.0 ), pcbIUScale.MM_PER_IU ) );
286
287 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_microvia_drill",
289 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 10.0 ), pcbIUScale.MM_PER_IU ) );
290
291 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_hole_to_hole",
293 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 10.0 ), pcbIUScale.MM_PER_IU ) );
294
295 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_hole_clearance",
297 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 100.0 ), pcbIUScale.MM_PER_IU ) );
298
299 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_silk_clearance",
301 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 100.0 ), pcbIUScale.MM_PER_IU ) );
302
303 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_groove_width",
305 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 25.0 ), pcbIUScale.MM_PER_IU ) );
306
307 // While the maximum *effective* value is 4, we've had users interpret this as the count on
308 // all layers, and enter something like 10. They'll figure it out soon enough *unless* we
309 // enforce a max of 4 (and therefore reset it back to the default of 2), at which point it
310 // just looks buggy.
311 m_params.emplace_back( new PARAM<int>( "rules.min_resolved_spokes",
313
314 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_text_height",
316 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 100.0 ), pcbIUScale.MM_PER_IU ) );
317
318 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_text_thickness",
320 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 25.0 ), pcbIUScale.MM_PER_IU ) );
321
322 // Note: a clearance of -0.01 is a flag indicating we should use the legacy (pre-6.0) method
323 // based on the edge cut thicknesses.
324 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_copper_edge_clearance",
326 pcbIUScale.mmToIU( -0.01 ), pcbIUScale.mmToIU( 25.0 ), pcbIUScale.MM_PER_IU ) );
327
328 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "rule_severities",
329 [&]() -> nlohmann::json
330 {
331 nlohmann::json ret = {};
332
333 for( const RC_ITEM& item : DRC_ITEM::GetItemsWithSeverities() )
334 {
335 wxString name = item.GetSettingsKey();
336 int code = item.GetErrorCode();
337
338 if( name.IsEmpty() || m_DRCSeverities.count( code ) == 0 )
339 continue;
340
341 ret[std::string( name.ToUTF8() )] = SeverityToString( m_DRCSeverities[code] );
342 }
343
344 return ret;
345 },
346 [&]( const nlohmann::json& aJson )
347 {
348 if( !aJson.is_object() )
349 return;
350
351 // Load V8 'hole_near_hole' token first (if present). Any current 'hole_to_hole' token
352 // found will then overwrite it.
353 // We can't use the migration architecture because we forgot to bump the version number
354 // when the change was made. But this is a one-off as any future deprecations should
355 // bump the version number and use registerMigration().
356 if( aJson.contains( "hole_near_hole" ) )
358
359 for( const RC_ITEM& item : DRC_ITEM::GetItemsWithSeverities() )
360 {
361 wxString name = item.GetSettingsKey();
362 std::string key( name.ToUTF8() );
363
364 if( aJson.contains( key ) )
365 m_DRCSeverities[item.GetErrorCode()] = SeverityFromString( aJson[key] );
366 }
367 }, {} ) );
368
369 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "drc_exclusions",
370 [&]() -> nlohmann::json
371 {
372 nlohmann::json js = nlohmann::json::array();
373
374 for( const wxString& entry : m_DrcExclusions )
375 js.push_back( { entry, m_DrcExclusionComments[ entry ] } );
376
377 return js;
378 },
379 [&]( const nlohmann::json& aObj )
380 {
381 m_DrcExclusions.clear();
382
383 if( !aObj.is_array() )
384 return;
385
386 for( const nlohmann::json& entry : aObj )
387 {
388 if( entry.is_array() )
389 {
390 wxString serialized = entry[0].get<wxString>();
391 m_DrcExclusions.insert( serialized );
392 m_DrcExclusionComments[ serialized ] = entry[1].get<wxString>();
393 }
394 else if( entry.is_string() )
395 {
396 m_DrcExclusions.insert( entry.get<wxString>() );
397 }
398 }
399 },
400 {} ) );
401
402 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "track_widths",
403 [&]() -> nlohmann::json
404 {
405 nlohmann::json js = nlohmann::json::array();
406
407 for( const int& width : m_TrackWidthList )
408 js.push_back( pcbIUScale.IUTomm( width ) );
409
410 return js;
411 },
412 [&]( const nlohmann::json& aJson )
413 {
414 if( !aJson.is_array() )
415 return;
416
417 m_TrackWidthList.clear();
418
419 for( const nlohmann::json& entry : aJson )
420 {
421 if( entry.empty() )
422 continue;
423
424 m_TrackWidthList.emplace_back( pcbIUScale.mmToIU( entry.get<double>() ) );
425 }
426 },
427 {} ) );
428
429 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "via_dimensions",
430 [&]() -> nlohmann::json
431 {
432 nlohmann::json js = nlohmann::json::array();
433
434 for( const auto& via : m_ViasDimensionsList )
435 {
436 nlohmann::json entry = {};
437
438 entry["diameter"] = pcbIUScale.IUTomm( via.m_Diameter );
439 entry["drill"] = pcbIUScale.IUTomm( via.m_Drill );
440
441 js.push_back( entry );
442 }
443
444 return js;
445 },
446 [&]( const nlohmann::json& aObj )
447 {
448 if( !aObj.is_array() )
449 return;
450
451 m_ViasDimensionsList.clear();
452
453 for( const nlohmann::json& entry : aObj )
454 {
455 if( entry.empty() || !entry.is_object() )
456 continue;
457
458 if( !entry.contains( "diameter" ) || !entry.contains( "drill" ) )
459 continue;
460
461 int diameter = pcbIUScale.mmToIU( entry["diameter"].get<double>() );
462 int drill = pcbIUScale.mmToIU( entry["drill"].get<double>() );
463
464 m_ViasDimensionsList.emplace_back( VIA_DIMENSION( diameter, drill ) );
465 }
466 },
467 {} ) );
468
469 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "diff_pair_dimensions",
470 [&]() -> nlohmann::json
471 {
472 nlohmann::json js = nlohmann::json::array();
473
474 for( const auto& pair : m_DiffPairDimensionsList )
475 {
476 nlohmann::json entry = {};
477
478 entry["width"] = pcbIUScale.IUTomm( pair.m_Width );
479 entry["gap"] = pcbIUScale.IUTomm( pair.m_Gap );
480 entry["via_gap"] = pcbIUScale.IUTomm( pair.m_ViaGap );
481
482 js.push_back( entry );
483 }
484
485 return js;
486 },
487 [&]( const nlohmann::json& aObj )
488 {
489 if( !aObj.is_array() )
490 return;
491
493
494 for( const nlohmann::json& entry : aObj )
495 {
496 if( entry.empty() || !entry.is_object() )
497 continue;
498
499 if( !entry.contains( "width" )
500 || !entry.contains( "gap" )
501 || !entry.contains( "via_gap" ) )
502 {
503 continue;
504 }
505
506 int width = pcbIUScale.mmToIU( entry["width"].get<double>() );
507 int gap = pcbIUScale.mmToIU( entry["gap"].get<double>() );
508 int via_gap = pcbIUScale.mmToIU( entry["via_gap"].get<double>() );
509
510 m_DiffPairDimensionsList.emplace_back( DIFF_PAIR_DIMENSION( width, gap, via_gap ) );
511 }
512 },
513 {} ) );
514
515 // Handle options for teardrops (targets and some others):
516 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "teardrop_options",
517 [&]() -> nlohmann::json
518 {
519 nlohmann::json js = nlohmann::json::array();
520 nlohmann::json entry = {};
521
522 entry["td_onvia"] = m_TeardropParamsList.m_TargetVias;
523 entry["td_onpthpad"] = m_TeardropParamsList.m_TargetPTHPads;
524 entry["td_onsmdpad"] = m_TeardropParamsList.m_TargetSMDPads;
525 entry["td_ontrackend"] = m_TeardropParamsList.m_TargetTrack2Track;
526 entry["td_onroundshapesonly"] = m_TeardropParamsList.m_UseRoundShapesOnly;
527
528 js.push_back( entry );
529
530 return js;
531 },
532 [&]( const nlohmann::json& aObj )
533 {
534 if( !aObj.is_array() )
535 return;
536
537 for( const nlohmann::json& entry : aObj )
538 {
539 if( entry.empty() || !entry.is_object() )
540 continue;
541
542 if( entry.contains( "td_onvia" ) )
543 m_TeardropParamsList.m_TargetVias = entry["td_onvia"].get<bool>();
544
545 if( entry.contains( "td_onpthpad" ) )
546 m_TeardropParamsList.m_TargetPTHPads = entry["td_onpthpad"].get<bool>();
547
548 if( entry.contains( "td_onsmdpad" ) )
549 m_TeardropParamsList.m_TargetSMDPads = entry["td_onsmdpad"].get<bool>();
550
551 if( entry.contains( "td_ontrackend" ) )
552 m_TeardropParamsList.m_TargetTrack2Track = entry["td_ontrackend"].get<bool>();
553
554 if( entry.contains( "td_onroundshapesonly" ) )
555 m_TeardropParamsList.m_UseRoundShapesOnly = entry["td_onroundshapesonly"].get<bool>();
556
557 // Legacy settings
558 for( int ii = 0; ii < 3; ++ii )
559 {
560 TEARDROP_PARAMETERS* td_prm = m_TeardropParamsList.GetParameters( (TARGET_TD)ii );
561
562 if( entry.contains( "td_allow_use_two_tracks" ) )
563 td_prm->m_AllowUseTwoTracks = entry["td_allow_use_two_tracks"].get<bool>();
564
565 if( entry.contains( "td_curve_segcount" ) )
566 {
567 if( entry["td_curve_segcount"].get<int>() > 0 )
568 td_prm->m_CurvedEdges = true;
569 }
570
571 if( entry.contains( "td_on_pad_in_zone" ) )
572 td_prm->m_TdOnPadsInZones = entry["td_on_pad_in_zone"].get<bool>();
573 }
574 }
575 },
576 {} ) );
577
578 // Handle parameters (sizes, shape) for each type of teardrop:
579 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "teardrop_parameters",
580 [&]() -> nlohmann::json
581 {
582 nlohmann::json js = nlohmann::json::array();
583
584 for( size_t ii = 0; ii < m_TeardropParamsList.GetParametersCount(); ii++ )
585 {
586 nlohmann::json entry = {};
587 TEARDROP_PARAMETERS* td_prm = m_TeardropParamsList.GetParameters( (TARGET_TD)ii );
588
589 entry["td_target_name"] = GetTeardropTargetCanonicalName( (TARGET_TD)ii );
590 entry["td_maxlen"] = pcbIUScale.IUTomm( td_prm->m_TdMaxLen );
591 entry["td_maxheight"] = pcbIUScale.IUTomm( td_prm->m_TdMaxWidth );
592 entry["td_length_ratio"] = td_prm->m_BestLengthRatio;
593 entry["td_height_ratio"] = td_prm->m_BestWidthRatio;
594 entry["td_curve_segcount"] = td_prm->m_CurvedEdges ? 1 : 0;
595 entry["td_width_to_size_filter_ratio"] = td_prm->m_WidthtoSizeFilterRatio;
596 entry["td_allow_use_two_tracks"] = td_prm->m_AllowUseTwoTracks;
597 entry["td_on_pad_in_zone"] = td_prm->m_TdOnPadsInZones;
598
599 js.push_back( entry );
600 }
601
602 return js;
603 },
604 [&]( const nlohmann::json& aObj )
605 {
606 if( !aObj.is_array() )
607 return;
608
609 for( const nlohmann::json& entry : aObj )
610 {
611 if( entry.empty() || !entry.is_object() )
612 continue;
613
614 if( !entry.contains( "td_target_name" ) )
615 continue;
616
617 int idx = GetTeardropTargetTypeFromCanonicalName( entry["td_target_name"].get<std::string>() );
618
619 if( idx >= 0 && idx < 3 )
620 {
621 TEARDROP_PARAMETERS* td_prm = m_TeardropParamsList.GetParameters( (TARGET_TD)idx );
622
623 if( entry.contains( "td_maxlen" ) )
624 td_prm->m_TdMaxLen = pcbIUScale.mmToIU( entry["td_maxlen"].get<double>() );
625
626 if( entry.contains( "td_maxheight" ) )
627 td_prm->m_TdMaxWidth = pcbIUScale.mmToIU( entry["td_maxheight"].get<double>() );
628
629 if( entry.contains( "td_length_ratio" ) )
630 td_prm->m_BestLengthRatio = entry["td_length_ratio"].get<double>();
631
632 if( entry.contains( "td_height_ratio" ) )
633 td_prm->m_BestWidthRatio = entry["td_height_ratio"].get<double>();
634
635 if( entry.contains( "td_curve_segcount" ) )
636 {
637 if( entry["td_curve_segcount"].get<int>() > 0 )
638 td_prm->m_CurvedEdges = true;
639 }
640
641 if( entry.contains( "td_width_to_size_filter_ratio" ) )
642 td_prm->m_WidthtoSizeFilterRatio = entry["td_width_to_size_filter_ratio"].get<double>();
643
644 if( entry.contains( "td_allow_use_two_tracks" ) )
645 td_prm->m_AllowUseTwoTracks = entry["td_allow_use_two_tracks"].get<bool>();
646
647 if( entry.contains( "td_on_pad_in_zone" ) )
648 td_prm->m_TdOnPadsInZones = entry["td_on_pad_in_zone"].get<bool>();
649 }
650 }
651 },
652 {} ) );
653
654 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "tuning_pattern_settings",
655 [&]() -> nlohmann::json
656 {
657 nlohmann::json js = {};
658
659 auto make_settings =
660 []( const PNS::MEANDER_SETTINGS& aSettings )
661 {
662 nlohmann::json entry = {};
663
664 entry["min_amplitude"] = pcbIUScale.IUTomm( aSettings.m_minAmplitude );
665 entry["max_amplitude"] = pcbIUScale.IUTomm( aSettings.m_maxAmplitude );
666 entry["spacing"] = pcbIUScale.IUTomm( aSettings.m_spacing );
667 entry["corner_style"] = aSettings.m_cornerStyle == PNS::MEANDER_STYLE_CHAMFER ? 0 : 1;
668 entry["corner_radius_percentage"] = aSettings.m_cornerRadiusPercentage;
669 entry["single_sided"] = aSettings.m_singleSided;
670
671 return entry;
672 };
673
674 js["single_track_defaults"] = make_settings( m_SingleTrackMeanderSettings );
675 js["diff_pair_defaults"] = make_settings( m_DiffPairMeanderSettings );
676 js["diff_pair_skew_defaults"] = make_settings( m_SkewMeanderSettings );
677
678 return js;
679 },
680 [&]( const nlohmann::json& aObj )
681 {
682 auto read_settings =
683 []( const nlohmann::json& entry ) -> PNS::MEANDER_SETTINGS
684 {
685 PNS::MEANDER_SETTINGS settings;
686
687 if( entry.contains( "min_amplitude" ) )
688 settings.m_minAmplitude = pcbIUScale.mmToIU( entry["min_amplitude"].get<double>() );
689
690 if( entry.contains( "max_amplitude" ) )
691 settings.m_maxAmplitude = pcbIUScale.mmToIU( entry["max_amplitude"].get<double>() );
692
693 if( entry.contains( "spacing" ) )
694 settings.m_spacing = pcbIUScale.mmToIU( entry["spacing"].get<double>() );
695
696 if( entry.contains( "corner_style" ) )
697 {
698 settings.m_cornerStyle = entry["corner_style"] == 0 ? PNS::MEANDER_STYLE_CHAMFER
700 }
701
702 if( entry.contains( "corner_radius_percentage" ) )
703 settings.m_cornerRadiusPercentage = entry["corner_radius_percentage"].get<int>();
704
705 if( entry.contains( "single_sided" ) )
706 settings.m_singleSided = entry["single_sided"].get<bool>();
707
708 return settings;
709 };
710
711 if( aObj.contains( "single_track_defaults" ) )
712 m_SingleTrackMeanderSettings = read_settings( aObj["single_track_defaults"] );
713
714 if( aObj.contains( "diff_pair_defaults" ) )
715 m_DiffPairMeanderSettings = read_settings( aObj["diff_pair_defaults"] );
716
717 if( aObj.contains( "diff_pair_skew_defaults" ) )
718 m_SkewMeanderSettings = read_settings( aObj["diff_pair_skew_defaults"] );
719 },
720 {} ) );
721
722 int minTextSize = pcbIUScale.mmToIU( TEXT_MIN_SIZE_MM );
723 int maxTextSize = pcbIUScale.mmToIU( TEXT_MAX_SIZE_MM );
724 int minStroke = 1;
725 int maxStroke = pcbIUScale.mmToIU( 100 );
726
727 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.silk_line_width",
729 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
730
731 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.silk_text_size_v",
733 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
734
735 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.silk_text_size_h",
737 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
738
739 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.silk_text_thickness",
741 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
742
743 m_params.emplace_back( new PARAM<bool>( "defaults.silk_text_italic",
744 &m_TextItalic[LAYER_CLASS_SILK], false ) );
745
746 m_params.emplace_back( new PARAM<bool>( "defaults.silk_text_upright",
747 &m_TextUpright[ LAYER_CLASS_SILK ], true ) );
748
749 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.copper_line_width",
751 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
752
753 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.copper_text_size_v",
755 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
756
757 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.copper_text_size_h",
759 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
760
761 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.copper_text_thickness",
763 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
764
765 m_params.emplace_back( new PARAM<bool>( "defaults.copper_text_italic",
766 &m_TextItalic[LAYER_CLASS_COPPER], false ) );
767
768 m_params.emplace_back( new PARAM<bool>( "defaults.copper_text_upright",
770
771 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.board_outline_line_width",
773 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
774
775 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.courtyard_line_width",
777 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
778
779 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.fab_line_width",
781 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
782
783 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.fab_text_size_v",
785 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
786
787 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.fab_text_size_h",
789 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
790
791 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.fab_text_thickness",
793 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
794
795 m_params.emplace_back( new PARAM<bool>( "defaults.fab_text_italic",
796 &m_TextItalic[LAYER_CLASS_FAB], false ) );
797
798 m_params.emplace_back( new PARAM<bool>( "defaults.fab_text_upright",
799 &m_TextUpright[LAYER_CLASS_FAB], true ) );
800
801 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.other_line_width",
803 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
804
805 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.other_text_size_v",
807 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
808
809 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.other_text_size_h",
811 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
812
813 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.other_text_thickness",
815 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
816
817 m_params.emplace_back( new PARAM<bool>( "defaults.other_text_italic",
818 &m_TextItalic[LAYER_CLASS_OTHERS], false ) );
819
820 m_params.emplace_back( new PARAM<bool>( "defaults.other_text_upright",
822
823 m_params.emplace_back( new PARAM_ENUM<DIM_UNITS_MODE>( "defaults.dimension_units",
826
827 m_params.emplace_back( new PARAM_ENUM<DIM_PRECISION>( "defaults.dimension_precision",
829
830 m_params.emplace_back( new PARAM_ENUM<DIM_UNITS_FORMAT>( "defaults.dimensions.units_format",
833
834 m_params.emplace_back( new PARAM<bool>( "defaults.dimensions.suppress_zeroes",
835 &m_DimensionSuppressZeroes, true ) );
836
837 // NOTE: excluding DIM_TEXT_POSITION::MANUAL from the valid range here
838 m_params.emplace_back( new PARAM_ENUM<DIM_TEXT_POSITION>( "defaults.dimensions.text_position",
841
842 m_params.emplace_back( new PARAM<bool>( "defaults.dimensions.keep_text_aligned",
844
845 m_params.emplace_back( new PARAM<int>( "defaults.dimensions.arrow_length",
848
849 m_params.emplace_back( new PARAM<int>( "defaults.dimensions.extension_offset",
852
853 m_params.emplace_back( new PARAM<bool>( "defaults.apply_defaults_to_fp_fields",
854 &m_StyleFPFields, false ) );
855 m_params.emplace_back( new PARAM<bool>( "defaults.apply_defaults_to_fp_text",
856 &m_StyleFPText, false ) );
857 m_params.emplace_back( new PARAM<bool>( "defaults.apply_defaults_to_fp_shapes",
858 &m_StyleFPShapes, false ) );
859
860 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.zones.min_clearance",
861 &m_defaultZoneSettings.m_ZoneClearance, pcbIUScale.mmToIU( ZONE_CLEARANCE_MM ),
862 pcbIUScale.mmToIU( 0.0 ), pcbIUScale.mmToIU( 25.0 ), pcbIUScale.MM_PER_IU ) );
863
864 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "defaults.pads",
865 [&]() -> nlohmann::json
866 {
867 nlohmann::json ret =
868 {
869 { "width", pcbIUScale.IUTomm( m_Pad_Master->GetSize( PADSTACK::ALL_LAYERS ).x ) },
870 { "height", pcbIUScale.IUTomm( m_Pad_Master->GetSize( PADSTACK::ALL_LAYERS ).y ) },
871 { "drill", pcbIUScale.IUTomm( m_Pad_Master->GetDrillSize().x ) }
872 };
873
874 return ret;
875 },
876 [&]( const nlohmann::json& aJson )
877 {
878 if( aJson.contains( "width" ) && aJson.contains( "height" )
879 && aJson.contains( "drill" ) )
880 {
881 VECTOR2I sz;
882 sz.x = pcbIUScale.mmToIU( aJson["width"].get<double>() );
883 sz.y = pcbIUScale.mmToIU( aJson["height"].get<double>() );
884
885 m_Pad_Master->SetSize( PADSTACK::ALL_LAYERS, sz );
886
887 int drill = pcbIUScale.mmToIU( aJson["drill"].get<double>() );
888
889 m_Pad_Master->SetDrillSize( VECTOR2I( drill, drill ) );
890 }
891 }, {} ) );
892
893 m_params.emplace_back( new PARAM_SCALED<int>( "rules.max_error",
895 pcbIUScale.mmToIU( 0.0001 ), pcbIUScale.mmToIU( 1.0 ), pcbIUScale.MM_PER_IU ) );
896
897 m_params.emplace_back( new PARAM_SCALED<int>( "rules.solder_mask_to_copper_clearance",
899 pcbIUScale.mmToIU( 0.0 ), pcbIUScale.mmToIU( 25.0 ), pcbIUScale.MM_PER_IU ) );
900
901 m_params.emplace_back( new PARAM<bool>( "zones_allow_external_fillets",
902 &m_ZoneKeepExternalFillets, false ) );
903
905
906 registerMigration( 1, 2,
907 [&]() -> bool
908 {
909 // Schema 1 to 2: move mask and paste margin settings back to board.
910 // The parameters are removed, so we just have to manually load them here and
911 // they will get saved with the board
912 if( std::optional<double> optval = Get<double>( "rules.solder_mask_clearance" ) )
913 m_SolderMaskExpansion = static_cast<int>( *optval * pcbIUScale.IU_PER_MM );
914
915 if( std::optional<double> optval = Get<double>( "rules.solder_mask_min_width" ) )
916 m_SolderMaskMinWidth = static_cast<int>( *optval * pcbIUScale.IU_PER_MM );
917
918 if( std::optional<double> optval = Get<double>( "rules.solder_paste_clearance" ) )
919 m_SolderPasteMargin = static_cast<int>( *optval * pcbIUScale.IU_PER_MM );
920
921 if( std::optional<double> optval = Get<double>( "rules.solder_paste_margin_ratio" ) )
922 m_SolderPasteMarginRatio = *optval;
923
924 try
925 {
926 At( "rules" ).erase( "solder_mask_clearance" );
927 At( "rules" ).erase( "solder_mask_min_width" );
928 At( "rules" ).erase( "solder_paste_clearance" );
929 At( "rules" ).erase( "solder_paste_margin_ratio" );
930 }
931 catch( ... )
932 {}
933
934 return true;
935 } );
936}
937
938
940{
941 if( m_parent )
942 {
943 m_parent->ReleaseNestedSettings( this );
944 m_parent = nullptr;
945 }
946}
947
948
950 NESTED_SETTINGS( "board_design_settings", bdsSchemaVersion, aOther.m_parent,
951 aOther.m_path ),
952 m_Pad_Master( nullptr )
953{
954 initFromOther( aOther );
955}
956
957
959{
960 initFromOther( aOther );
961 return *this;
962}
963
964
966{
967 // Copy of NESTED_SETTINGS around is not allowed, so let's just update the params.
976 m_MinConn = aOther.m_MinConn;
994 m_MaxError = aOther.m_MaxError;
1007 m_CapVias = aOther.m_CapVias;
1008 m_FillVias = aOther.m_FillVias;
1011
1012 std::copy( std::begin( aOther.m_LineThickness ), std::end( aOther.m_LineThickness ),
1013 std::begin( m_LineThickness ) );
1014
1015 std::copy( std::begin( aOther.m_TextSize ), std::end( aOther.m_TextSize ),
1016 std::begin( m_TextSize ) );
1017
1018 std::copy( std::begin( aOther.m_TextThickness ), std::end( aOther.m_TextThickness ),
1019 std::begin( m_TextThickness ) );
1020
1021 std::copy( std::begin( aOther.m_TextItalic ), std::end( aOther.m_TextItalic ),
1022 std::begin( m_TextItalic ) );
1023
1024 std::copy( std::begin( aOther.m_TextUpright ), std::end( aOther.m_TextUpright ),
1025 std::begin( m_TextUpright ) );
1026
1035
1036 m_auxOrigin = aOther.m_auxOrigin;
1037 m_gridOrigin = aOther.m_gridOrigin;
1038 m_HasStackup = aOther.m_HasStackup;
1040
1054 m_stackup = aOther.m_stackup;
1056 m_Pad_Master = std::make_unique<PAD>( *aOther.m_Pad_Master );
1058
1062}
1063
1064
1066{
1067 if( m_TrackWidthList != aOther.m_TrackWidthList ) return false;
1068 if( m_ViasDimensionsList != aOther.m_ViasDimensionsList ) return false;
1069 if( m_DiffPairDimensionsList != aOther.m_DiffPairDimensionsList ) return false;
1070 if( m_CurrentViaType != aOther.m_CurrentViaType ) return false;
1071 if( m_UseConnectedTrackWidth != aOther.m_UseConnectedTrackWidth ) return false;
1072 if( m_TempOverrideTrackWidth != aOther.m_TempOverrideTrackWidth ) return false;
1073 if( m_MinClearance != aOther.m_MinClearance ) return false;
1074 if( m_MinGrooveWidth != aOther.m_MinGrooveWidth ) return false;
1075 if( m_MinConn != aOther.m_MinConn ) return false;
1076 if( m_TrackMinWidth != aOther.m_TrackMinWidth ) return false;
1077 if( m_ViasMinAnnularWidth != aOther.m_ViasMinAnnularWidth ) return false;
1078 if( m_ViasMinSize != aOther.m_ViasMinSize ) return false;
1079 if( m_MinThroughDrill != aOther.m_MinThroughDrill ) return false;
1080 if( m_MicroViasMinSize != aOther.m_MicroViasMinSize ) return false;
1081 if( m_MicroViasMinDrill != aOther.m_MicroViasMinDrill ) return false;
1082 if( m_CopperEdgeClearance != aOther.m_CopperEdgeClearance ) return false;
1083 if( m_HoleClearance != aOther.m_HoleClearance ) return false;
1084 if( m_HoleToHoleMin != aOther.m_HoleToHoleMin ) return false;
1085 if( m_SilkClearance != aOther.m_SilkClearance ) return false;
1086 if( m_MinResolvedSpokes != aOther.m_MinResolvedSpokes ) return false;
1087 if( m_MinSilkTextHeight != aOther.m_MinSilkTextHeight ) return false;
1088 if( m_MinSilkTextThickness != aOther.m_MinSilkTextThickness ) return false;
1089 if( m_DRCSeverities != aOther.m_DRCSeverities ) return false;
1090 if( m_DrcExclusions != aOther.m_DrcExclusions ) return false;
1091 if( m_DrcExclusionComments != aOther.m_DrcExclusionComments ) return false;
1092 if( m_ZoneKeepExternalFillets != aOther.m_ZoneKeepExternalFillets ) return false;
1093 if( m_MaxError != aOther.m_MaxError ) return false;
1094 if( m_SolderMaskExpansion != aOther.m_SolderMaskExpansion ) return false;
1095 if( m_SolderMaskMinWidth != aOther.m_SolderMaskMinWidth ) return false;
1097 if( m_SolderPasteMargin != aOther.m_SolderPasteMargin ) return false;
1098 if( m_SolderPasteMarginRatio != aOther.m_SolderPasteMarginRatio ) return false;
1100 if( m_TentViasFront != aOther.m_TentViasFront ) return false;
1101 if( m_TentViasBack != aOther.m_TentViasBack ) return false;
1102 if( m_CoverViasFront != aOther.m_CoverViasFront ) return false;
1103 if( m_CoverViasBack != aOther.m_CoverViasBack ) return false;
1104 if( m_PlugViasFront != aOther.m_PlugViasFront ) return false;
1105 if( m_PlugViasBack != aOther.m_PlugViasBack ) return false;
1106 if( m_CapVias != aOther.m_CapVias ) return false;
1107 if( m_FillVias != aOther.m_FillVias ) return false;
1108 if( m_DefaultFPTextItems != aOther.m_DefaultFPTextItems ) return false;
1109 if( m_UserLayerNames != aOther.m_UserLayerNames ) return false;
1110
1111 if( !std::equal( std::begin( m_LineThickness ), std::end( m_LineThickness ),
1112 std::begin( aOther.m_LineThickness ) ) )
1113 return false;
1114
1115 if( !std::equal( std::begin( m_TextSize ), std::end( m_TextSize ),
1116 std::begin( aOther.m_TextSize ) ) )
1117 return false;
1118
1119 if( !std::equal( std::begin( m_TextThickness ), std::end( m_TextThickness ),
1120 std::begin( aOther.m_TextThickness ) ) )
1121 return false;
1122
1123 if( !std::equal( std::begin( m_TextItalic ), std::end( m_TextItalic ),
1124 std::begin( aOther.m_TextItalic ) ) )
1125 return false;
1126
1127 if( !std::equal( std::begin( m_TextUpright ), std::end( m_TextUpright ),
1128 std::begin( aOther.m_TextUpright ) ) )
1129 return false;
1130
1131 if( m_DimensionUnitsMode != aOther.m_DimensionUnitsMode ) return false;
1132 if( m_DimensionPrecision != aOther.m_DimensionPrecision ) return false;
1133 if( m_DimensionUnitsFormat != aOther.m_DimensionUnitsFormat ) return false;
1134 if( m_DimensionSuppressZeroes != aOther.m_DimensionSuppressZeroes ) return false;
1135 if( m_DimensionTextPosition != aOther.m_DimensionTextPosition ) return false;
1136 if( m_DimensionKeepTextAligned != aOther.m_DimensionKeepTextAligned ) return false;
1137 if( m_DimensionArrowLength != aOther.m_DimensionArrowLength ) return false;
1138 if( m_DimensionExtensionOffset != aOther.m_DimensionExtensionOffset ) return false;
1139 if( m_auxOrigin != aOther.m_auxOrigin ) return false;
1140 if( m_gridOrigin != aOther.m_gridOrigin ) return false;
1141 if( m_HasStackup != aOther.m_HasStackup ) return false;
1142 if( m_UseHeightForLengthCalcs != aOther.m_UseHeightForLengthCalcs ) return false;
1143 if( m_trackWidthIndex != aOther.m_trackWidthIndex ) return false;
1144 if( m_viaSizeIndex != aOther.m_viaSizeIndex ) return false;
1145 if( m_diffPairIndex != aOther.m_diffPairIndex ) return false;
1146 if( m_useCustomTrackVia != aOther.m_useCustomTrackVia ) return false;
1147 if( m_customTrackWidth != aOther.m_customTrackWidth ) return false;
1148 if( m_customViaSize != aOther.m_customViaSize ) return false;
1149 if( m_useCustomDiffPair != aOther.m_useCustomDiffPair ) return false;
1150 if( m_customDiffPair != aOther.m_customDiffPair ) return false;
1151 if( m_copperLayerCount != aOther.m_copperLayerCount ) return false;
1152 if( m_userDefinedLayerCount != aOther.m_userDefinedLayerCount ) return false;
1153 if( m_enabledLayers != aOther.m_enabledLayers ) return false;
1154 if( m_boardThickness != aOther.m_boardThickness ) return false;
1155 if( m_currentNetClassName != aOther.m_currentNetClassName ) return false;
1156 if( m_stackup != aOther.m_stackup ) return false;
1157 if( *m_NetSettings != *aOther.m_NetSettings ) return false;
1158 if( *m_Pad_Master != *aOther.m_Pad_Master ) return false;
1159 if( m_defaultZoneSettings != aOther.m_defaultZoneSettings ) return false;
1160
1161 if( m_StyleFPFields != aOther.m_StyleFPFields ) return false;
1162 if( m_StyleFPText != aOther.m_StyleFPText ) return false;
1163 if( m_StyleFPShapes != aOther.m_StyleFPShapes ) return false;
1164
1165 return true;
1166}
1167
1168
1170{
1188 std::string units_ptr( "defaults.dimension_units" );
1189 std::string precision_ptr( "defaults.dimension_precision" );
1190
1191 if( !( Contains( units_ptr )
1192 && Contains( precision_ptr )
1193 && At( units_ptr ).is_number_integer()
1194 && At( precision_ptr ).is_number_integer() ) )
1195 {
1196 // if either is missing or invalid, migration doesn't make sense
1197 return true;
1198 }
1199
1200 int units = *Get<int>( units_ptr );
1201 int precision = *Get<int>( precision_ptr );
1202
1203 // The enum maps directly to precision if the units is mils
1204 int extraDigits = 0;
1205
1206 switch( units )
1207 {
1208 case 0: extraDigits = 3; break;
1209 case 2: extraDigits = 2; break;
1210 default: break;
1211 }
1212
1213 precision += extraDigits;
1214
1215 Set( precision_ptr, precision );
1216
1217 return true;
1218}
1219
1220
1221bool BOARD_DESIGN_SETTINGS::LoadFromFile( const wxString& aDirectory )
1222{
1223 bool ret = NESTED_SETTINGS::LoadFromFile( aDirectory );
1224
1225 // A number of things won't have been translated by the PROJECT_FILE migration because of
1226 // descoped objects required to decode this data. So, it will be in the legacy.pcbnew
1227 // section and needs to be pulled out here
1228
1229 PROJECT_FILE* project = dynamic_cast<PROJECT_FILE*>( GetParent() );
1230
1231 if( !project )
1232 return ret;
1233
1234 bool migrated = false;
1235
1236 auto drcName =
1237 []( int aCode ) -> std::string
1238 {
1239 return std::string( DRC_ITEM::Create( aCode )->GetSettingsKey().ToUTF8() );
1240 };
1241
1242 const std::string rs = "rule_severities.";
1243 const std::string no_courtyard_key = "legacy_no_courtyard_defined";
1244 const std::string courtyard_overlap_key = "legacy_courtyards_overlap";
1245
1246 try
1247 {
1248 nlohmann::json& severities =
1249 project->Internals()->at( "/board/design_settings/rule_severities"_json_pointer );
1250
1251 if( severities.contains( no_courtyard_key ) )
1252 {
1253 if( severities[no_courtyard_key].get<bool>() )
1254 Set( rs + drcName( DRCE_MISSING_COURTYARD ), "error" );
1255 else
1256 Set( rs + drcName( DRCE_MISSING_COURTYARD ), "ignore" );
1257
1258 severities.erase( no_courtyard_key );
1259 migrated = true;
1260 }
1261
1262 if( severities.contains( courtyard_overlap_key ) )
1263 {
1264 if( severities[courtyard_overlap_key].get<bool>() )
1265 Set( rs + drcName( DRCE_OVERLAPPING_FOOTPRINTS ), "error" );
1266 else
1267 Set( rs + drcName( DRCE_OVERLAPPING_FOOTPRINTS ), "ignore" );
1268
1269 severities.erase( courtyard_overlap_key );
1270 migrated = true;
1271 }
1272 }
1273 catch( ... )
1274 {
1275 }
1276
1277 if( Contains( "legacy" ) )
1278 {
1279 // This defaults to false for new boards, but version 5.1.x and prior kept the fillets
1280 // so we do the same for legacy boards.
1282
1283 project->At( "legacy" ).erase( "pcbnew" );
1284 }
1285
1286 // Now that we have everything, we need to load again
1287 if( migrated )
1288 Load();
1289
1290 return ret;
1291}
1292
1293
1295{
1296 return m_DRCSeverities[ aDRCErrorCode ];
1297}
1298
1299
1300bool BOARD_DESIGN_SETTINGS::Ignore( int aDRCErrorCode )
1301{
1302 return m_DRCSeverities[ aDRCErrorCode ] == RPT_SEVERITY_IGNORE;
1303}
1304
1305
1307{
1308 int biggest = std::max( m_MinClearance, m_HoleClearance );
1309 DRC_CONSTRAINT constraint;
1310
1311 biggest = std::max( biggest, m_HoleToHoleMin );
1312 biggest = std::max( biggest, m_CopperEdgeClearance );
1313
1314 if( m_DRCEngine )
1315 {
1316 m_DRCEngine->QueryWorstConstraint( CLEARANCE_CONSTRAINT, constraint );
1317 biggest = std::max( biggest, constraint.Value().Min() );
1318
1319 m_DRCEngine->QueryWorstConstraint( PHYSICAL_CLEARANCE_CONSTRAINT, constraint );
1320 biggest = std::max( biggest, constraint.Value().Min() );
1321
1322 m_DRCEngine->QueryWorstConstraint( HOLE_CLEARANCE_CONSTRAINT, constraint );
1323 biggest = std::max( biggest, constraint.Value().Min() );
1324
1325 m_DRCEngine->QueryWorstConstraint( EDGE_CLEARANCE_CONSTRAINT, constraint );
1326 biggest = std::max( biggest, constraint.Value().Min() );
1327
1328 m_DRCEngine->QueryWorstConstraint( HOLE_TO_HOLE_CONSTRAINT, constraint );
1329 biggest = std::max( biggest, constraint.Value().Min() );
1330 }
1331
1332 // Clip to avoid integer overflows in subsequent calculations
1333 return std::min( biggest, MAXIMUM_CLEARANCE );
1334}
1335
1336
1338{
1339 int clearance = m_NetSettings->GetDefaultNetclass()->GetClearance();
1340
1341 for( const auto& [name, netclass] : m_NetSettings->GetNetclasses() )
1342 clearance = std::min( clearance, netclass->GetClearance() );
1343
1344 return clearance;
1345}
1346
1347
1349{
1350 m_viaSizeIndex = std::min( aIndex, (int) m_ViasDimensionsList.size() - 1 );
1351 m_useCustomTrackVia = false;
1352}
1353
1354
1356{
1358 return m_customViaSize.m_Diameter;
1360 return m_NetSettings->GetDefaultNetclass()->GetViaDiameter();
1361 else
1362 return m_ViasDimensionsList[ m_viaSizeIndex ].m_Diameter;
1363}
1364
1365
1367{
1368 int drill;
1369
1371 drill = m_customViaSize.m_Drill;
1373 drill = m_NetSettings->GetDefaultNetclass()->GetViaDrill();
1374 else
1375 drill = m_ViasDimensionsList[ m_viaSizeIndex ].m_Drill;
1376
1377 return drill > 0 ? drill : -1;
1378}
1379
1380
1382{
1383 m_trackWidthIndex = std::min( aIndex, (int) m_TrackWidthList.size() - 1 );
1384 m_useCustomTrackVia = false;
1385}
1386
1387
1389{
1391 return m_customTrackWidth;
1393 return m_NetSettings->GetDefaultNetclass()->GetTrackWidth();
1394 else
1396}
1397
1398
1400{
1401 if( !m_DiffPairDimensionsList.empty() )
1402 m_diffPairIndex = std::min( aIndex, (int) m_DiffPairDimensionsList.size() - 1 );
1403
1404 m_useCustomDiffPair = false;
1405}
1406
1407
1409{
1411 {
1412 return m_customDiffPair.m_Width;
1413 }
1415 {
1416 if( m_NetSettings->GetDefaultNetclass()->HasDiffPairWidth() )
1417 return m_NetSettings->GetDefaultNetclass()->GetDiffPairWidth();
1418 else
1419 return m_NetSettings->GetDefaultNetclass()->GetTrackWidth();
1420 }
1421 else
1422 {
1424 }
1425}
1426
1427
1429{
1431 {
1432 return m_customDiffPair.m_Gap;
1433 }
1434 else if( m_diffPairIndex == 0 )
1435 {
1436 if( m_NetSettings->GetDefaultNetclass()->HasDiffPairGap() )
1437 return m_NetSettings->GetDefaultNetclass()->GetDiffPairGap();
1438 else
1439 return m_NetSettings->GetDefaultNetclass()->GetClearance();
1440 }
1441 else
1442 {
1444 }
1445}
1446
1447
1449{
1451 {
1452 return m_customDiffPair.m_ViaGap;
1453 }
1454 else if( m_diffPairIndex == 0 )
1455 {
1456 if( m_NetSettings->GetDefaultNetclass()->HasDiffPairViaGap() )
1457 return m_NetSettings->GetDefaultNetclass()->GetDiffPairViaGap();
1458 else
1459 return GetCurrentDiffPairGap();
1460 }
1461 else
1462 {
1464 }
1465}
1466
1467
1469{
1470 m_copperLayerCount = aNewLayerCount;
1471
1472 // Update only enabled copper layers mask
1473 m_enabledLayers.ClearCopperLayers();
1474
1475 if( aNewLayerCount > 0 )
1476 m_enabledLayers |= LSET::AllCuMask( aNewLayerCount );
1477}
1478
1479
1481{
1482 m_userDefinedLayerCount = aNewLayerCount;
1483
1484 m_enabledLayers.ClearUserDefinedLayers();
1485
1486 if( aNewLayerCount > 0 )
1487 m_enabledLayers |= LSET::UserDefinedLayersMask( aNewLayerCount );
1488}
1489
1490
1492{
1493 m_enabledLayers = aMask;
1494
1495 // Ensures mandatory back and front layers are always enabled regardless of board file
1496 // configuration.
1497 m_enabledLayers.set( B_Cu ).set( F_Cu )
1498 .set( B_CrtYd ).set( F_CrtYd )
1499 .set( Edge_Cuts )
1500 .set( Margin );
1501
1502 // update layer counts to ensure their consistency with m_EnabledLayers
1503 LSET copperLayers = aMask;
1504 copperLayers.ClearNonCopperLayers();
1505
1506 LSET userLayers = aMask & LSET::UserDefinedLayersMask();
1507
1508 m_copperLayerCount = (int) copperLayers.count();
1509 m_userDefinedLayerCount = (int) userLayers.count();
1510}
1511
1512
1513// Return the layer class index { silk, copper, edges & courtyards, fab, others } of the
1514// given layer.
1516{
1517 if( aLayer == F_SilkS || aLayer == B_SilkS )
1518 return LAYER_CLASS_SILK;
1519 else if( IsCopperLayer( aLayer ) )
1520 return LAYER_CLASS_COPPER;
1521 else if( aLayer == Edge_Cuts )
1522 return LAYER_CLASS_EDGES;
1523 else if( aLayer == F_CrtYd || aLayer == B_CrtYd )
1524 return LAYER_CLASS_COURTYARD;
1525 else if( aLayer == F_Fab || aLayer == B_Fab )
1526 return LAYER_CLASS_FAB;
1527 else
1528 return LAYER_CLASS_OTHERS;
1529}
1530
1531
1533{
1534 return pcbIUScale.mmToIU( ADVANCED_CFG::GetCfg().m_DRCEpsilon );
1535}
1536
1537
1539{
1540 return pcbIUScale.mmToIU( ADVANCED_CFG::GetCfg().m_HoleWallThickness );
1541}
1542
1543
1545{
1546 return m_LineThickness[ GetLayerClass( aLayer ) ];
1547}
1548
1549
1551{
1552 return m_TextSize[ GetLayerClass( aLayer ) ];
1553}
1554
1555
1557{
1558 return m_TextThickness[ GetLayerClass( aLayer ) ];
1559}
1560
1561
1563{
1564 return m_TextItalic[ GetLayerClass( aLayer ) ];
1565}
1566
1567
1569{
1570 return m_TextUpright[ GetLayerClass( aLayer ) ];
1571}
1572
1574{
1575 m_Pad_Master->SetSizeX( pcbIUScale.mmToIU( DEFAULT_PAD_WIDTH_MM ) );
1576 m_Pad_Master->SetSizeY( pcbIUScale.mmToIU( DEFAULT_PAD_HEIGTH_MM ) );
1577 m_Pad_Master->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
1578 m_Pad_Master->SetDrillSize( VECTOR2I( pcbIUScale.mmToIU( DEFAULT_PAD_DRILL_DIAMETER_MM ), 0 ) );
1580
1581 constexpr double RR_RADIUS = DEFAULT_PAD_HEIGTH_MM * DEFAULT_PAD_RR_RADIUS_RATIO;
1582 m_Pad_Master->SetRoundRectCornerRadius( PADSTACK::ALL_LAYERS, pcbIUScale.mmToIU( RR_RADIUS ) );
1583
1584 if( m_Pad_Master->GetFrontShape() == PAD_SHAPE::CIRCLE )
1585 m_Pad_Master->SetThermalSpokeAngle( ANGLE_45 );
1586 else
1587 m_Pad_Master->SetThermalSpokeAngle( ANGLE_90 );
1588}
const char * name
constexpr int ARC_HIGH_DEF
Definition base_units.h:129
constexpr EDA_IU_SCALE pcbIUScale
Definition base_units.h:112
const int bdsSchemaVersion
#define DEFAULT_MICROVIASMINDRILL
#define DEFAULT_SOLDERPASTE_CLEARANCE
#define DEFAULT_SOLDERPASTE_RATIO
#define DEFAULT_CUSTOMDPAIRWIDTH
#define DEFAULT_DP_MEANDER_SPACING
@ LAYER_CLASS_OTHERS
@ LAYER_CLASS_FAB
@ LAYER_CLASS_COURTYARD
@ LAYER_CLASS_SILK
@ LAYER_CLASS_COPPER
@ LAYER_CLASS_EDGES
#define DEFAULT_PAD_WIDTH_MM
#define DEFAULT_VIASMINSIZE
#define DEFAULT_PAD_DRILL_DIAMETER_MM
#define DEFAULT_TEXT_WIDTH
#define DEFAULT_COPPER_TEXT_WIDTH
#define DEFAULT_CUSTOMDPAIRGAP
#define DEFAULT_MINCLEARANCE
#define DEFAULT_HOLECLEARANCE
#define DEFAULT_SOLDERMASK_EXPANSION
#define DEFAULT_SOLDERMASK_MIN_WIDTH
#define DEFAULT_DIMENSION_EXTENSION_OFFSET
#define DEFAULT_COPPEREDGECLEARANCE
#define DEFAULT_PAD_HEIGTH_MM
#define DEFAULT_DIMENSION_ARROW_LENGTH
#define DEFAULT_TRACKMINWIDTH
#define DEFAULT_MINTHROUGHDRILL
#define DEFAULT_PAD_RR_RADIUS_RATIO
#define DEFAULT_SILK_TEXT_SIZE
#define MAXIMUM_CLEARANCE
#define DEFAULT_HOLETOHOLEMIN
#define DEFAULT_MINCONNECTION
#define DEFAULT_COPPER_LINE_WIDTH
#define DEFAULT_SILK_LINE_WIDTH
#define DEFAULT_SILKCLEARANCE
#define DEFAULT_MICROVIASMINSIZE
#define DEFAULT_SILK_TEXT_WIDTH
#define DEFAULT_MINGROOVEWIDTH
#define DEFAULT_TEXT_SIZE
#define DEFAULT_EDGE_WIDTH
#define DEFAULT_CUSTOMTRACKWIDTH
#define DEFAULT_CUSTOMDPAIRVIAGAP
#define DEFAULT_COPPER_TEXT_SIZE
#define DEFAULT_SOLDERMASK_TO_COPPER_CLEARANCE
#define DEFAULT_LINE_WIDTH
#define DEFAULT_MEANDER_SPACING
#define DEFAULT_COURTYARD_WIDTH
#define DEFAULT_BOARD_THICKNESS_MM
#define DEFAULT_MINRESOLVEDSPOKES
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
BASE_SET & set(size_t pos)
Definition base_set.h:116
DIM_PRECISION m_DimensionPrecision
Number of digits after the decimal.
std::vector< TEXT_ITEM_INFO > m_DefaultFPTextItems
int GetHolePlatingThickness() const
Pad & via drills are finish size.
VIATYPE m_CurrentViaType
(VIA_BLIND_BURIED, VIA_THROUGH, VIA_MICROVIA)
void SetEnabledLayers(const LSET &aMask)
Change the bit-mask of enabled layers to aMask.
std::shared_ptr< NET_SETTINGS > m_NetSettings
bool operator==(const BOARD_DESIGN_SETTINGS &aOther) const
std::map< wxString, wxString > m_DrcExclusionComments
DIM_UNITS_FORMAT m_DimensionUnitsFormat
void initFromOther(const BOARD_DESIGN_SETTINGS &aOther)
bool GetTextUpright(PCB_LAYER_ID aLayer) const
std::map< int, SEVERITY > m_DRCSeverities
VECTOR2I m_gridOrigin
origin for grid offsets
int GetTextThickness(PCB_LAYER_ID aLayer) const
Return the default text thickness from the layer class for the given layer.
VECTOR2I m_auxOrigin
origin for plot exports
bool m_TextUpright[LAYER_CLASS_COUNT]
BOARD_DESIGN_SETTINGS(JSON_SETTINGS *aParent, const std::string &aPath)
bool GetTextItalic(PCB_LAYER_ID aLayer) const
wxString m_currentNetClassName
Current net class name used to display netclass info.
void SetViaSizeIndex(int aIndex)
Set the current via size list index to aIndex.
std::shared_ptr< DRC_ENGINE > m_DRCEngine
std::vector< DIFF_PAIR_DIMENSION > m_DiffPairDimensionsList
std::set< wxString > m_DrcExclusions
bool Ignore(int aDRCErrorCode)
Return true if the DRC error code's severity is SEVERITY_IGNORE.
std::map< std::string, wxString > m_UserLayerNames
std::unique_ptr< PAD > m_Pad_Master
TEARDROP_PARAMETERS_LIST m_TeardropParamsList
The parameters of teardrops for the different teardrop targets (via/pad, track end).
void SetUserDefinedLayerCount(int aNewLayerCount)
Set the number of user defined layers to aNewLayerCount.
int GetDRCEpsilon() const
Return an epsilon which accounts for rounding errors, etc.
int GetLayerClass(PCB_LAYER_ID aLayer) const
PNS::MEANDER_SETTINGS m_DiffPairMeanderSettings
int m_boardThickness
Board thickness for 3D viewer.
int m_copperLayerCount
Number of copper layers for this design.
int m_userDefinedLayerCount
Number of user defined layers for this design.
bool LoadFromFile(const wxString &aDirectory="") override
Loads the backing file from disk and then calls Load()
PNS::MEANDER_SETTINGS m_SingleTrackMeanderSettings
void SetTrackWidthIndex(int aIndex)
Set the current track width list index to aIndex.
int m_TextThickness[LAYER_CLASS_COUNT]
ZONE_SETTINGS m_defaultZoneSettings
The default settings that will be used for new zones.
SEVERITY GetSeverity(int aDRCErrorCode)
std::vector< int > m_TrackWidthList
DIFF_PAIR_DIMENSION m_customDiffPair
int m_LineThickness[LAYER_CLASS_COUNT]
VECTOR2I GetTextSize(PCB_LAYER_ID aLayer) const
Return the default text size from the layer class for the given layer.
int GetLineThickness(PCB_LAYER_ID aLayer) const
Return the default graphic segment thickness from the layer class for the given layer.
bool m_UseHeightForLengthCalcs
Enable inclusion of stackup height in track length measurements and length tuning.
VECTOR2I m_TextSize[LAYER_CLASS_COUNT]
PNS::MEANDER_SETTINGS m_SkewMeanderSettings
LSET m_enabledLayers
Bit-mask for layer enabling.
bool m_TextItalic[LAYER_CLASS_COUNT]
void SetCopperLayerCount(int aNewLayerCount)
Set the copper layer count to aNewLayerCount.
DIM_TEXT_POSITION m_DimensionTextPosition
BOARD_STACKUP m_stackup
The description of layers stackup, for board fabrication only physical layers are in layers stackup.
std::vector< VIA_DIMENSION > m_ViasDimensionsList
BOARD_DESIGN_SETTINGS & operator=(const BOARD_DESIGN_SETTINGS &aOther)
MINOPTMAX< int > & Value()
Definition drc_rule.h:163
static std::vector< std::reference_wrapper< RC_ITEM > > GetItemsWithSeverities()
Definition drc_item.h:133
static std::shared_ptr< DRC_ITEM > Create(int aErrorCode)
Constructs a DRC_ITEM for the given error code.
Definition drc_item.cpp:381
void Set(const std::string &aPath, ValueType aVal)
Stores a value into the JSON document Will throw an exception if ValueType isn't something that the l...
bool Contains(const std::string &aPath) const
virtual void Load()
Updates the parameters of this object based on the current JSON document contents.
std::optional< ValueType > Get(const std::string &aPath) const
Fetches a value from within the JSON document.
std::vector< PARAM_BASE * > m_params
The list of parameters (owned by this object)
void registerMigration(int aOldSchemaVersion, int aNewSchemaVersion, std::function< bool(void)> aMigrator)
Registers a migration from one schema version to another.
nlohmann::json & At(const std::string &aPath)
Wrappers for the underlying JSON API so that most consumers don't need json.hpp All of these function...
JSON_SETTINGS(const wxString &aFilename, SETTINGS_LOC aLocation, int aSchemaVersion)
bool m_resetParamsIfMissing
Whether or not to set parameters to their default value if missing from JSON on Load()
LSET is a set of PCB_LAYER_IDs.
Definition lset.h:37
LSET & ClearNonCopperLayers()
Clear the non-copper layers in this set.
Definition lset.cpp:933
static LSET UserDefinedLayersMask(int aUserDefinedLayerCount=MAX_USER_DEFINED_LAYERS)
Return a mask with the requested number of user defined layers.
Definition lset.cpp:687
static LSET AllCuMask()
return AllCuMask( MAX_CU_LAYERS );
Definition lset.cpp:591
T Min() const
Definition minoptmax.h:33
std::string m_path
The path (in pointer format) of where to store this document in the parent.
JSON_SETTINGS * GetParent()
JSON_SETTINGS * m_parent
A pointer to the parent object to load and store from.
NESTED_SETTINGS(const std::string &aName, int aSchemaVersion, JSON_SETTINGS *aParent, const std::string &aPath, bool aLoadFromFile=true)
bool LoadFromFile(const wxString &aDirectory="") override
Loads the JSON document from the parent and then calls Load()
static constexpr PCB_LAYER_ID ALL_LAYERS
! Temporary layer identifier to identify code that is not padstack-aware
Definition padstack.h:145
Stores an enum as an integer.
Definition parameters.h:229
Like a normal param, but with custom getter and setter functions.
Definition parameters.h:296
Represents a parameter that has a scaling factor between the value in the file and the value used int...
Definition parameters.h:393
Dimensions for the meandering algorithm.
Definition pns_meander.h:68
int m_minAmplitude
Maximum meandering amplitude.
Definition pns_meander.h:93
int m_cornerRadiusPercentage
Place meanders on one side.
bool m_singleSided
Initial side when placing meanders at segment.
MEANDER_STYLE m_cornerStyle
Rounding percentage (0 - 100).
int m_maxAmplitude
Meandering period/spacing (see dialog picture for explanation).
Definition pns_meander.h:96
int m_spacing
Amplitude/spacing adjustment step.
Definition pns_meander.h:99
The backing store for a PROJECT, in JSON format.
A holder for a rule check item, DRC in Pcbnew or ERC in Eeschema.
Definition rc_item.h:79
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_TdOnPadsInZones
A filter to exclude pads inside zone fills.
bool m_CurvedEdges
True if the teardrop should be curved.
@ DRCE_SILK_EDGE_CLEARANCE
Definition drc_item.h:98
@ DRCE_FOOTPRINT_FILTERS
Definition drc_item.h:79
@ DRCE_SILK_MASK_CLEARANCE
Definition drc_item.h:96
@ DRCE_PADSTACK
Definition drc_item.h:62
@ DRCE_MIRRORED_TEXT_ON_FRONT_LAYER
Definition drc_item.h:109
@ DRCE_LIB_FOOTPRINT_ISSUES
Definition drc_item.h:82
@ DRCE_OVERLAPPING_FOOTPRINTS
Definition drc_item.h:65
@ DRCE_OVERLAPPING_SILK
Definition drc_item.h:101
@ DRCE_MISSING_COURTYARD
Definition drc_item.h:66
@ DRCE_ISOLATED_COPPER
Definition drc_item.h:48
@ DRCE_DRILLED_HOLES_TOO_CLOSE
Definition drc_item.h:52
@ DRCE_COPPER_SLIVER
Definition drc_item.h:92
@ DRCE_PTH_IN_COURTYARD
Definition drc_item.h:69
@ DRCE_FIRST
Definition drc_item.h:38
@ DRCE_DANGLING_VIA
Definition drc_item.h:50
@ DRCE_FOOTPRINT_TYPE_MISMATCH
Definition drc_item.h:81
@ DRCE_NONMIRRORED_TEXT_ON_BACK_LAYER
Definition drc_item.h:110
@ DRCE_DUPLICATE_FOOTPRINT
Definition drc_item.h:75
@ DRCE_DANGLING_TRACK
Definition drc_item.h:51
@ DRCE_TEXT_HEIGHT
Definition drc_item.h:99
@ DRCE_DRILLED_HOLES_COLOCATED
Definition drc_item.h:53
@ DRCE_EXTRA_FOOTPRINT
Definition drc_item.h:76
@ DRCE_LAST
Definition drc_item.h:112
@ DRCE_LIB_FOOTPRINT_MISMATCH
Definition drc_item.h:83
@ DRCE_NET_CONFLICT
Definition drc_item.h:77
@ DRCE_MISSING_FOOTPRINT
Definition drc_item.h:74
@ DRCE_TEXT_THICKNESS
Definition drc_item.h:100
@ DRCE_NPTH_IN_COURTYARD
Definition drc_item.h:70
@ DRCE_CONNECTION_WIDTH
Definition drc_item.h:59
@ DRCE_SCHEMATIC_PARITY
Definition drc_item.h:78
@ EDGE_CLEARANCE_CONSTRAINT
Definition drc_rule.h:53
@ CLEARANCE_CONSTRAINT
Definition drc_rule.h:49
@ HOLE_CLEARANCE_CONSTRAINT
Definition drc_rule.h:51
@ PHYSICAL_CLEARANCE_CONSTRAINT
Definition drc_rule.h:77
@ HOLE_TO_HOLE_CONSTRAINT
Definition drc_rule.h:52
static constexpr EDA_ANGLE ANGLE_90
Definition eda_angle.h:413
static constexpr EDA_ANGLE ANGLE_45
Definition eda_angle.h:412
#define TEXT_MIN_SIZE_MM
Minimum text size (1 micron).
Definition eda_text.h:46
#define TEXT_MAX_SIZE_MM
Maximum text size in mm (~10 inches)
Definition eda_text.h:47
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
Definition layer_ids.h:674
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:60
@ F_CrtYd
Definition layer_ids.h:116
@ Edge_Cuts
Definition layer_ids.h:112
@ B_Cu
Definition layer_ids.h:65
@ F_Fab
Definition layer_ids.h:119
@ Margin
Definition layer_ids.h:113
@ F_SilkS
Definition layer_ids.h:100
@ B_CrtYd
Definition layer_ids.h:115
@ B_SilkS
Definition layer_ids.h:101
@ F_Cu
Definition layer_ids.h:64
@ B_Fab
Definition layer_ids.h:118
@ MEANDER_STYLE_ROUND
Definition pns_meander.h:52
@ MEANDER_STYLE_CHAMFER
Definition pns_meander.h:53
@ ROUNDRECT
Definition padstack.h:57
@ OUTSIDE
Text appears outside the dimension line (default)
@ INLINE
Text appears in line with the dimension line.
@ THROUGH
Definition pcb_track.h:67
SEVERITY
@ RPT_SEVERITY_WARNING
@ RPT_SEVERITY_ERROR
@ RPT_SEVERITY_IGNORE
Container to handle a stock of specific differential pairs each with unique track width,...
Container to handle a stock of specific vias each with unique diameter and drill sizes in the BOARD c...
std::string GetTeardropTargetCanonicalName(TARGET_TD aTdType)
TARGET_TD GetTeardropTargetTypeFromCanonicalName(const std::string &aTargetName)
int clearance
SEVERITY SeverityFromString(const wxString &aSeverity)
Definition ui_common.cpp:56
wxString SeverityToString(const SEVERITY &aSeverity)
Definition ui_common.cpp:67
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:695
#define ZONE_CLEARANCE_MM
Definition zones.h:37