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 (C) 1992-2023 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 SetCopperLayerCount( 2 ); // Default design is a double sided board
64 m_CurrentViaType = VIATYPE::THROUGH;
65
66 // if true, when creating a new track starting on an existing track, use this track width
69
70 // First is always the reference designator
71 m_DefaultFPTextItems.emplace_back( wxT( "REF**" ), true, F_SilkS );
72 // Second is always the value
73 m_DefaultFPTextItems.emplace_back( wxT( "" ), true, F_Fab );
74 // Any following ones are freebies
75 m_DefaultFPTextItems.emplace_back( wxT( "${REFERENCE}" ), true, F_Fab );
76
83
90
91 // Edges & Courtyards; text properties aren't used but better to have them holding
92 // reasonable values than not.
99
106
111 m_TextItalic[ LAYER_CLASS_FAB ] = false;
113
120
121 m_StyleFPFields = false;
122 m_StyleFPText = false;
123 m_StyleFPShapes = false;
124
125 m_DimensionPrecision = DIM_PRECISION::X_XXXX;
126 m_DimensionUnitsMode = DIM_UNITS_MODE::AUTOMATIC;
127 m_DimensionUnitsFormat = DIM_UNITS_FORMAT::BARE_SUFFIX;
129 m_DimensionTextPosition = DIM_TEXT_POSITION::OUTSIDE;
133
134 m_useCustomTrackVia = false;
138
139 m_useCustomDiffPair = false;
143
160
161 for( int errorCode = DRCE_FIRST; errorCode <= DRCE_LAST; ++errorCode )
162 m_DRCSeverities[ errorCode ] = RPT_SEVERITY_ERROR;
163
166
170
173
176
178
185
191
193
196
198
202
203 // Global mask margins:
207
208 // Solder paste margin absolute value
210 // Solder paste margin as a ratio of pad size
211 // The final margin is the sum of these 2 values
212 // Usually < 0 because the mask is smaller than pad
214
216 m_TentViasFront = true;
217 m_TentViasBack = true;
218
219 // Layer thickness for 3D viewer
221
222 // Default spacing for meanders
226
227 m_viaSizeIndex = 0;
229 m_diffPairIndex = 0;
230
231 // Parameters stored in JSON in the project file
232
233 // NOTE: Previously, BOARD_DESIGN_SETTINGS stored the basic board layer information (layer
234 // names and enable/disable state) in the project file even though this information is also
235 // stored in the board file. This was implemented for importing these settings from another
236 // project. Going forward, the import feature will just import from other board files (since
237 // we could have multi-board projects in the future anyway) so this functionality is dropped.
238
239
240 m_params.emplace_back( new PARAM<bool>( "rules.use_height_for_length_calcs",
241 &m_UseHeightForLengthCalcs, true ) );
242
243 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_clearance",
246
247 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_connection",
249 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 100.0 ), pcbIUScale.MM_PER_IU ) );
250
251 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_track_width",
254
255 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_via_annular_width",
258
259 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_via_diameter",
262
263 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_through_hole_diameter",
266
267 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_microvia_diameter",
270
271 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_microvia_drill",
274
275 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_hole_to_hole",
278
279 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_hole_clearance",
281 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 100.0 ), pcbIUScale.MM_PER_IU ) );
282
283 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_silk_clearance",
285 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 100.0 ), pcbIUScale.MM_PER_IU ) );
286
287 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_groove_width",
290
291 // While the maximum *effective* value is 4, we've had users interpret this as the count on
292 // all layers, and enter something like 10. They'll figure it out soon enough *unless* we
293 // enforce a max of 4 (and therefore reset it back to the default of 2), at which point it
294 // just looks buggy.
295 m_params.emplace_back( new PARAM<int>( "rules.min_resolved_spokes",
297
298 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_text_height",
300 pcbIUScale.mmToIU( 0.00 ), pcbIUScale.mmToIU( 100.0 ), pcbIUScale.MM_PER_IU ) );
301
302 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_text_thickness",
305
306 // Note: a clearance of -0.01 is a flag indicating we should use the legacy (pre-6.0) method
307 // based on the edge cut thicknesses.
308 m_params.emplace_back( new PARAM_SCALED<int>( "rules.min_copper_edge_clearance",
310 pcbIUScale.mmToIU( -0.01 ), pcbIUScale.mmToIU( 25.0 ), pcbIUScale.MM_PER_IU ) );
311
312 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "rule_severities",
313 [&]() -> nlohmann::json
314 {
315 nlohmann::json ret = {};
316
317 for( const RC_ITEM& item : DRC_ITEM::GetItemsWithSeverities() )
318 {
319 wxString name = item.GetSettingsKey();
320 int code = item.GetErrorCode();
321
322 if( name.IsEmpty() || m_DRCSeverities.count( code ) == 0 )
323 continue;
324
325 ret[std::string( name.ToUTF8() )] = SeverityToString( m_DRCSeverities[code] );
326 }
327
328 return ret;
329 },
330 [&]( const nlohmann::json& aJson )
331 {
332 if( !aJson.is_object() )
333 return;
334
335 for( const RC_ITEM& item : DRC_ITEM::GetItemsWithSeverities() )
336 {
337 wxString name = item.GetSettingsKey();
338 std::string key( name.ToUTF8() );
339
340 if( aJson.contains( key ) )
341 m_DRCSeverities[item.GetErrorCode()] = SeverityFromString( aJson[key] );
342 }
343 }, {} ) );
344
345 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "drc_exclusions",
346 [&]() -> nlohmann::json
347 {
348 nlohmann::json js = nlohmann::json::array();
349
350 for( const wxString& entry : m_DrcExclusions )
351 js.push_back( { entry, m_DrcExclusionComments[ entry ] } );
352
353 return js;
354 },
355 [&]( const nlohmann::json& aObj )
356 {
357 m_DrcExclusions.clear();
358
359 if( !aObj.is_array() )
360 return;
361
362 for( const nlohmann::json& entry : aObj )
363 {
364 if( entry.is_array() )
365 {
366 wxString serialized = entry[0].get<wxString>();
367 m_DrcExclusions.insert( serialized );
368 m_DrcExclusionComments[ serialized ] = entry[1].get<wxString>();
369 }
370 else if( entry.is_string() )
371 {
372 m_DrcExclusions.insert( entry.get<wxString>() );
373 }
374 }
375 },
376 {} ) );
377
378 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "track_widths",
379 [&]() -> nlohmann::json
380 {
381 nlohmann::json js = nlohmann::json::array();
382
383 for( const int& width : m_TrackWidthList )
384 js.push_back( pcbIUScale.IUTomm( width ) );
385
386 return js;
387 },
388 [&]( const nlohmann::json& aJson )
389 {
390 if( !aJson.is_array() )
391 return;
392
393 m_TrackWidthList.clear();
394
395 for( const nlohmann::json& entry : aJson )
396 {
397 if( entry.empty() )
398 continue;
399
400 m_TrackWidthList.emplace_back( pcbIUScale.mmToIU( entry.get<double>() ) );
401 }
402 },
403 {} ) );
404
405 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "via_dimensions",
406 [&]() -> nlohmann::json
407 {
408 nlohmann::json js = nlohmann::json::array();
409
410 for( const auto& via : m_ViasDimensionsList )
411 {
412 nlohmann::json entry = {};
413
414 entry["diameter"] = pcbIUScale.IUTomm( via.m_Diameter );
415 entry["drill"] = pcbIUScale.IUTomm( via.m_Drill );
416
417 js.push_back( entry );
418 }
419
420 return js;
421 },
422 [&]( const nlohmann::json& aObj )
423 {
424 if( !aObj.is_array() )
425 return;
426
427 m_ViasDimensionsList.clear();
428
429 for( const nlohmann::json& entry : aObj )
430 {
431 if( entry.empty() || !entry.is_object() )
432 continue;
433
434 if( !entry.contains( "diameter" ) || !entry.contains( "drill" ) )
435 continue;
436
437 int diameter = pcbIUScale.mmToIU( entry["diameter"].get<double>() );
438 int drill = pcbIUScale.mmToIU( entry["drill"].get<double>() );
439
440 m_ViasDimensionsList.emplace_back( VIA_DIMENSION( diameter, drill ) );
441 }
442 },
443 {} ) );
444
445 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "diff_pair_dimensions",
446 [&]() -> nlohmann::json
447 {
448 nlohmann::json js = nlohmann::json::array();
449
450 for( const auto& pair : m_DiffPairDimensionsList )
451 {
452 nlohmann::json entry = {};
453
454 entry["width"] = pcbIUScale.IUTomm( pair.m_Width );
455 entry["gap"] = pcbIUScale.IUTomm( pair.m_Gap );
456 entry["via_gap"] = pcbIUScale.IUTomm( pair.m_ViaGap );
457
458 js.push_back( entry );
459 }
460
461 return js;
462 },
463 [&]( const nlohmann::json& aObj )
464 {
465 if( !aObj.is_array() )
466 return;
467
469
470 for( const nlohmann::json& entry : aObj )
471 {
472 if( entry.empty() || !entry.is_object() )
473 continue;
474
475 if( !entry.contains( "width" ) || !entry.contains( "gap" )
476 || !entry.contains( "via_gap" ) )
477 continue;
478
479 int width = pcbIUScale.mmToIU( entry["width"].get<double>() );
480 int gap = pcbIUScale.mmToIU( entry["gap"].get<double>() );
481 int via_gap = pcbIUScale.mmToIU( entry["via_gap"].get<double>() );
482
483 m_DiffPairDimensionsList.emplace_back(
484 DIFF_PAIR_DIMENSION( width, gap, via_gap ) );
485 }
486 },
487 {} ) );
488
489 // Handle options for teardrops (targets and some others):
490 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "teardrop_options",
491 [&]() -> nlohmann::json
492 {
493 nlohmann::json js = nlohmann::json::array();
494 nlohmann::json entry = {};
495
496 entry["td_onvia"] = m_TeardropParamsList.m_TargetVias;
497 entry["td_onpthpad"] = m_TeardropParamsList.m_TargetPTHPads;
498 entry["td_onsmdpad"] = m_TeardropParamsList.m_TargetSMDPads;
499 entry["td_ontrackend"] = m_TeardropParamsList.m_TargetTrack2Track;
500 entry["td_onroundshapesonly"] = m_TeardropParamsList.m_UseRoundShapesOnly;
501
502 js.push_back( entry );
503
504 return js;
505 },
506 [&]( const nlohmann::json& aObj )
507 {
508 if( !aObj.is_array() )
509 return;
510
511 for( const nlohmann::json& entry : aObj )
512 {
513 if( entry.empty() || !entry.is_object() )
514 continue;
515
516 if( entry.contains( "td_onvia" ) )
517 m_TeardropParamsList.m_TargetVias = entry["td_onvia"].get<bool>();
518
519 if( entry.contains( "td_onpthpad" ) )
520 m_TeardropParamsList.m_TargetPTHPads = entry["td_onpthpad"].get<bool>();
521
522 if( entry.contains( "td_onsmdpad" ) )
523 m_TeardropParamsList.m_TargetSMDPads = entry["td_onsmdpad"].get<bool>();
524
525 if( entry.contains( "td_ontrackend" ) )
526 m_TeardropParamsList.m_TargetTrack2Track = entry["td_ontrackend"].get<bool>();
527
528 if( entry.contains( "td_onroundshapesonly" ) )
529 m_TeardropParamsList.m_UseRoundShapesOnly = entry["td_onroundshapesonly"].get<bool>();
530
531 // Legacy settings
532 for( int ii = 0; ii < 3; ++ii )
533 {
535
536 if( entry.contains( "td_allow_use_two_tracks" ) )
537 td_prm->m_AllowUseTwoTracks = entry["td_allow_use_two_tracks"].get<bool>();
538
539 if( entry.contains( "td_curve_segcount" ) )
540 td_prm->m_CurveSegCount = entry["td_curve_segcount"].get<int>();
541
542 if( entry.contains( "td_on_pad_in_zone" ) )
543 td_prm->m_TdOnPadsInZones = entry["td_on_pad_in_zone"].get<bool>();
544 }
545 }
546 },
547 {} ) );
548
549 // Handle parameters (sizes, shape) for each type of teardrop:
550 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "teardrop_parameters",
551 [&]() -> nlohmann::json
552 {
553 nlohmann::json js = nlohmann::json::array();
554
555 for( size_t ii = 0; ii < m_TeardropParamsList.GetParametersCount(); ii++ )
556 {
557 nlohmann::json entry = {};
559
560 entry["td_target_name"] = GetTeardropTargetCanonicalName( (TARGET_TD)ii );
561 entry["td_maxlen"] = pcbIUScale.IUTomm( td_prm->m_TdMaxLen );
562 entry["td_maxheight"] = pcbIUScale.IUTomm( td_prm->m_TdMaxWidth );
563 entry["td_length_ratio"] = td_prm->m_BestLengthRatio;
564 entry["td_height_ratio"] = td_prm->m_BestWidthRatio;
565 entry["td_curve_segcount"] = td_prm->m_CurveSegCount;
566 entry["td_width_to_size_filter_ratio"] = td_prm->m_WidthtoSizeFilterRatio;
567 entry["td_allow_use_two_tracks"] = td_prm->m_AllowUseTwoTracks;
568 entry["td_on_pad_in_zone"] = td_prm->m_TdOnPadsInZones;
569
570 js.push_back( entry );
571 }
572
573 return js;
574 },
575 [&]( const nlohmann::json& aObj )
576 {
577 if( !aObj.is_array() )
578 return;
579
580 for( const nlohmann::json& entry : aObj )
581 {
582 if( entry.empty() || !entry.is_object() )
583 continue;
584
585 if( !entry.contains( "td_target_name" ) )
586 continue;
587
588 int idx = GetTeardropTargetTypeFromCanonicalName( entry["td_target_name"].get<std::string>() );
589
590 if( idx >= 0 && idx < 3 )
591 {
593
594 if( entry.contains( "td_maxlen" ) )
595 td_prm->m_TdMaxLen = pcbIUScale.mmToIU( entry["td_maxlen"].get<double>() );
596
597 if( entry.contains( "td_maxheight" ) )
598 td_prm->m_TdMaxWidth = pcbIUScale.mmToIU( entry["td_maxheight"].get<double>() );
599
600 if( entry.contains( "td_length_ratio" ) )
601 td_prm->m_BestLengthRatio = entry["td_length_ratio"].get<double>();
602
603 if( entry.contains( "td_height_ratio" ) )
604 td_prm->m_BestWidthRatio = entry["td_height_ratio"].get<double>();
605
606 if( entry.contains( "td_curve_segcount" ) )
607 td_prm->m_CurveSegCount = entry["td_curve_segcount"].get<int>();
608
609 if( entry.contains( "td_width_to_size_filter_ratio" ) )
610 td_prm->m_WidthtoSizeFilterRatio = entry["td_width_to_size_filter_ratio"].get<double>();
611
612 if( entry.contains( "td_allow_use_two_tracks" ) )
613 td_prm->m_AllowUseTwoTracks = entry["td_allow_use_two_tracks"].get<bool>();
614
615 if( entry.contains( "td_on_pad_in_zone" ) )
616 td_prm->m_TdOnPadsInZones = entry["td_on_pad_in_zone"].get<bool>();
617 }
618 }
619 },
620 {} ) );
621
622 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "tuning_pattern_settings",
623 [&]() -> nlohmann::json
624 {
625 nlohmann::json js = {};
626
627 auto make_settings =
628 []( const PNS::MEANDER_SETTINGS& aSettings )
629 {
630 nlohmann::json entry = {};
631
632 entry["min_amplitude"] = pcbIUScale.IUTomm( aSettings.m_minAmplitude );
633 entry["max_amplitude"] = pcbIUScale.IUTomm( aSettings.m_maxAmplitude );
634 entry["spacing"] = pcbIUScale.IUTomm( aSettings.m_spacing );
635 entry["corner_style"] = aSettings.m_cornerStyle == PNS::MEANDER_STYLE_CHAMFER ? 0 : 1;
636 entry["corner_radius_percentage"] = aSettings.m_cornerRadiusPercentage;
637 entry["single_sided"] = aSettings.m_singleSided;
638
639 return entry;
640 };
641
642 js["single_track_defaults"] = make_settings( m_SingleTrackMeanderSettings );
643 js["diff_pair_defaults"] = make_settings( m_DiffPairMeanderSettings );
644 js["diff_pair_skew_defaults"] = make_settings( m_SkewMeanderSettings );
645
646 return js;
647 },
648 [&]( const nlohmann::json& aObj )
649 {
650 auto read_settings =
651 []( const nlohmann::json& entry ) -> PNS::MEANDER_SETTINGS
652 {
653 PNS::MEANDER_SETTINGS settings;
654
655 if( entry.contains( "min_amplitude" ) )
656 settings.m_minAmplitude = pcbIUScale.mmToIU( entry["min_amplitude"].get<double>() );
657
658 if( entry.contains( "max_amplitude" ) )
659 settings.m_maxAmplitude = pcbIUScale.mmToIU( entry["max_amplitude"].get<double>() );
660
661 if( entry.contains( "spacing" ) )
662 settings.m_spacing = pcbIUScale.mmToIU( entry["spacing"].get<double>() );
663
664 if( entry.contains( "corner_style" ) )
665 {
666 settings.m_cornerStyle = entry["corner_style"] == 0 ? PNS::MEANDER_STYLE_CHAMFER
668 }
669
670 if( entry.contains( "corner_radius_percentage" ) )
671 settings.m_cornerRadiusPercentage = entry["corner_radius_percentage"].get<int>();
672
673 if( entry.contains( "single_sided" ) )
674 settings.m_singleSided = entry["single_sided"].get<bool>();
675
676 return settings;
677 };
678
679 if( aObj.contains( "single_track_defaults" ) )
680 m_SingleTrackMeanderSettings = read_settings( aObj["single_track_defaults"] );
681
682 if( aObj.contains( "diff_pair_defaults" ) )
683 m_DiffPairMeanderSettings = read_settings( aObj["diff_pair_defaults"] );
684
685 if( aObj.contains( "diff_pair_skew_defaults" ) )
686 m_SkewMeanderSettings = read_settings( aObj["diff_pair_skew_defaults"] );
687 },
688 {} ) );
689
690 int minTextSize = pcbIUScale.mmToIU( TEXT_MIN_SIZE_MM );
691 int maxTextSize = pcbIUScale.mmToIU( TEXT_MAX_SIZE_MM );
692 int minStroke = 1;
693 int maxStroke = pcbIUScale.mmToIU( 100 );
694
695 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.silk_line_width",
697 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
698
699 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.silk_text_size_v",
701 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
702
703 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.silk_text_size_h",
705 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
706
707 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.silk_text_thickness",
709 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
710
711 m_params.emplace_back( new PARAM<bool>( "defaults.silk_text_italic",
712 &m_TextItalic[LAYER_CLASS_SILK], false ) );
713
714 m_params.emplace_back( new PARAM<bool>( "defaults.silk_text_upright",
715 &m_TextUpright[ LAYER_CLASS_SILK ], true ) );
716
717 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.copper_line_width",
719 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
720
721 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.copper_text_size_v",
723 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
724
725 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.copper_text_size_h",
727 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
728
729 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.copper_text_thickness",
731 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
732
733 m_params.emplace_back( new PARAM<bool>( "defaults.copper_text_italic",
734 &m_TextItalic[LAYER_CLASS_COPPER], false ) );
735
736 m_params.emplace_back( new PARAM<bool>( "defaults.copper_text_upright",
738
739 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.board_outline_line_width",
741 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
742
743 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.courtyard_line_width",
745 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
746
747 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.fab_line_width",
749 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
750
751 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.fab_text_size_v",
753 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
754
755 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.fab_text_size_h",
757 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
758
759 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.fab_text_thickness",
761 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
762
763 m_params.emplace_back( new PARAM<bool>( "defaults.fab_text_italic",
764 &m_TextItalic[LAYER_CLASS_FAB], false ) );
765
766 m_params.emplace_back( new PARAM<bool>( "defaults.fab_text_upright",
767 &m_TextUpright[LAYER_CLASS_FAB], true ) );
768
769 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.other_line_width",
771 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
772
773 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.other_text_size_v",
775 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
776
777 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.other_text_size_h",
779 minTextSize, maxTextSize, pcbIUScale.MM_PER_IU ) );
780
781 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.other_text_thickness",
783 minStroke, maxStroke, pcbIUScale.MM_PER_IU ) );
784
785 m_params.emplace_back( new PARAM<bool>( "defaults.other_text_italic",
786 &m_TextItalic[LAYER_CLASS_OTHERS], false ) );
787
788 m_params.emplace_back( new PARAM<bool>( "defaults.other_text_upright",
790
791 m_params.emplace_back( new PARAM_ENUM<DIM_UNITS_MODE>( "defaults.dimension_units",
792 &m_DimensionUnitsMode, DIM_UNITS_MODE::AUTOMATIC, DIM_UNITS_MODE::INCHES,
793 DIM_UNITS_MODE::AUTOMATIC ) );
794
795 m_params.emplace_back( new PARAM_ENUM<DIM_PRECISION>( "defaults.dimension_precision",
796 &m_DimensionPrecision, DIM_PRECISION::X_XXXX, DIM_PRECISION::X, DIM_PRECISION::V_VVVVV ) );
797
798 m_params.emplace_back( new PARAM_ENUM<DIM_UNITS_FORMAT>( "defaults.dimensions.units_format",
799 &m_DimensionUnitsFormat, DIM_UNITS_FORMAT::BARE_SUFFIX, DIM_UNITS_FORMAT::NO_SUFFIX,
800 DIM_UNITS_FORMAT::PAREN_SUFFIX ) );
801
802 m_params.emplace_back( new PARAM<bool>( "defaults.dimensions.suppress_zeroes",
803 &m_DimensionSuppressZeroes, false ) );
804
805 // NOTE: excluding DIM_TEXT_POSITION::MANUAL from the valid range here
806 m_params.emplace_back( new PARAM_ENUM<DIM_TEXT_POSITION>( "defaults.dimensions.text_position",
807 &m_DimensionTextPosition, DIM_TEXT_POSITION::OUTSIDE, DIM_TEXT_POSITION::OUTSIDE,
808 DIM_TEXT_POSITION::INLINE ) );
809
810 m_params.emplace_back( new PARAM<bool>( "defaults.dimensions.keep_text_aligned",
812
813 m_params.emplace_back( new PARAM<int>( "defaults.dimensions.arrow_length",
816
817 m_params.emplace_back( new PARAM<int>( "defaults.dimensions.extension_offset",
820
821 m_params.emplace_back( new PARAM<bool>( "defaults.apply_defaults_to_fp_fields",
822 &m_StyleFPFields, false ) );
823 m_params.emplace_back( new PARAM<bool>( "defaults.apply_defaults_to_fp_text",
824 &m_StyleFPText, false ) );
825 m_params.emplace_back( new PARAM<bool>( "defaults.apply_defaults_to_fp_shapes",
826 &m_StyleFPShapes, false ) );
827
828 m_params.emplace_back( new PARAM_SCALED<int>( "defaults.zones.min_clearance",
831
832 m_params.emplace_back( new PARAM_LAMBDA<nlohmann::json>( "defaults.pads",
833 [&]() -> nlohmann::json
834 {
835 nlohmann::json ret =
836 {
837 { "width", pcbIUScale.IUTomm( m_Pad_Master->GetSize( PADSTACK::ALL_LAYERS ).x ) },
838 { "height", pcbIUScale.IUTomm( m_Pad_Master->GetSize( PADSTACK::ALL_LAYERS ).y ) },
839 { "drill", pcbIUScale.IUTomm( m_Pad_Master->GetDrillSize().x ) }
840 };
841
842 return ret;
843 },
844 [&]( const nlohmann::json& aJson )
845 {
846 if( aJson.contains( "width" ) && aJson.contains( "height" )
847 && aJson.contains( "drill" ) )
848 {
849 VECTOR2I sz;
850 sz.x = pcbIUScale.mmToIU( aJson["width"].get<double>() );
851 sz.y = pcbIUScale.mmToIU( aJson["height"].get<double>() );
852
853 m_Pad_Master->SetSize( PADSTACK::ALL_LAYERS, sz );
854
855 int drill = pcbIUScale.mmToIU( aJson["drill"].get<double>() );
856
857 m_Pad_Master->SetDrillSize( VECTOR2I( drill, drill ) );
858 }
859 }, {} ) );
860
861 m_params.emplace_back( new PARAM_SCALED<int>( "rules.max_error",
863
864 m_params.emplace_back( new PARAM_SCALED<int>( "rules.solder_mask_to_copper_clearance",
867
868 m_params.emplace_back( new PARAM<bool>( "zones_allow_external_fillets",
869 &m_ZoneKeepExternalFillets, false ) );
870
872
873 registerMigration( 1, 2,
874 [&]() -> bool
875 {
876 // Schema 1 to 2: move mask and paste margin settings back to board.
877 // The parameters are removed, so we just have to manually load them here and
878 // they will get saved with the board
879 if( std::optional<double> optval = Get<double>( "rules.solder_mask_clearance" ) )
880 m_SolderMaskExpansion = static_cast<int>( *optval * pcbIUScale.IU_PER_MM );
881
882 if( std::optional<double> optval = Get<double>( "rules.solder_mask_min_width" ) )
883 m_SolderMaskMinWidth = static_cast<int>( *optval * pcbIUScale.IU_PER_MM );
884
885 if( std::optional<double> optval = Get<double>( "rules.solder_paste_clearance" ) )
886 m_SolderPasteMargin = static_cast<int>( *optval * pcbIUScale.IU_PER_MM );
887
888 if( std::optional<double> optval = Get<double>( "rules.solder_paste_margin_ratio" ) )
889 m_SolderPasteMarginRatio = *optval;
890
891 try
892 {
893 At( "rules" ).erase( "solder_mask_clearance" );
894 At( "rules" ).erase( "solder_mask_min_width" );
895 At( "rules" ).erase( "solder_paste_clearance" );
896 At( "rules" ).erase( "solder_paste_margin_ratio" );
897 }
898 catch( ... )
899 {}
900
901 return true;
902 } );
903}
904
905
907{
908 if( m_parent )
909 {
911 m_parent = nullptr;
912 }
913}
914
915
917 NESTED_SETTINGS( "board_design_settings", bdsSchemaVersion, aOther.m_parent,
918 aOther.m_path ),
919 m_Pad_Master( nullptr )
920{
921 initFromOther( aOther );
922}
923
924
926{
927 initFromOther( aOther );
928 return *this;
929}
930
931
933{
934 // Copy of NESTED_SETTINGS around is not allowed, so let's just update the params.
943 m_MinConn = aOther.m_MinConn;
961 m_MaxError = aOther.m_MaxError;
971
972 std::copy( std::begin( aOther.m_LineThickness ), std::end( aOther.m_LineThickness ),
973 std::begin( m_LineThickness ) );
974
975 std::copy( std::begin( aOther.m_TextSize ), std::end( aOther.m_TextSize ),
976 std::begin( m_TextSize ) );
977
978 std::copy( std::begin( aOther.m_TextThickness ), std::end( aOther.m_TextThickness ),
979 std::begin( m_TextThickness ) );
980
981 std::copy( std::begin( aOther.m_TextItalic ), std::end( aOther.m_TextItalic ),
982 std::begin( m_TextItalic ) );
983
984 std::copy( std::begin( aOther.m_TextUpright ), std::end( aOther.m_TextUpright ),
985 std::begin( m_TextUpright ) );
986
995
996 m_auxOrigin = aOther.m_auxOrigin;
997 m_gridOrigin = aOther.m_gridOrigin;
998 m_HasStackup = aOther.m_HasStackup;
1000
1013 m_stackup = aOther.m_stackup;
1015 m_Pad_Master = std::make_unique<PAD>( *aOther.m_Pad_Master );
1017
1021}
1022
1023
1025{
1026 if( m_TrackWidthList != aOther.m_TrackWidthList ) return false;
1027 if( m_ViasDimensionsList != aOther.m_ViasDimensionsList ) return false;
1028 if( m_DiffPairDimensionsList != aOther.m_DiffPairDimensionsList ) return false;
1029 if( m_CurrentViaType != aOther.m_CurrentViaType ) return false;
1030 if( m_UseConnectedTrackWidth != aOther.m_UseConnectedTrackWidth ) return false;
1031 if( m_TempOverrideTrackWidth != aOther.m_TempOverrideTrackWidth ) return false;
1032 if( m_MinClearance != aOther.m_MinClearance ) return false;
1033 if( m_MinGrooveWidth != aOther.m_MinGrooveWidth ) return false;
1034 if( m_MinConn != aOther.m_MinConn ) return false;
1035 if( m_TrackMinWidth != aOther.m_TrackMinWidth ) return false;
1036 if( m_ViasMinAnnularWidth != aOther.m_ViasMinAnnularWidth ) return false;
1037 if( m_ViasMinSize != aOther.m_ViasMinSize ) return false;
1038 if( m_MinThroughDrill != aOther.m_MinThroughDrill ) return false;
1039 if( m_MicroViasMinSize != aOther.m_MicroViasMinSize ) return false;
1040 if( m_MicroViasMinDrill != aOther.m_MicroViasMinDrill ) return false;
1041 if( m_CopperEdgeClearance != aOther.m_CopperEdgeClearance ) return false;
1042 if( m_HoleClearance != aOther.m_HoleClearance ) return false;
1043 if( m_HoleToHoleMin != aOther.m_HoleToHoleMin ) return false;
1044 if( m_SilkClearance != aOther.m_SilkClearance ) return false;
1045 if( m_MinResolvedSpokes != aOther.m_MinResolvedSpokes ) return false;
1046 if( m_MinSilkTextHeight != aOther.m_MinSilkTextHeight ) return false;
1047 if( m_MinSilkTextThickness != aOther.m_MinSilkTextThickness ) return false;
1048 if( m_DRCSeverities != aOther.m_DRCSeverities ) return false;
1049 if( m_DrcExclusions != aOther.m_DrcExclusions ) return false;
1050 if( m_DrcExclusionComments != aOther.m_DrcExclusionComments ) return false;
1051 if( m_ZoneKeepExternalFillets != aOther.m_ZoneKeepExternalFillets ) return false;
1052 if( m_MaxError != aOther.m_MaxError ) return false;
1053 if( m_SolderMaskExpansion != aOther.m_SolderMaskExpansion ) return false;
1054 if( m_SolderMaskMinWidth != aOther.m_SolderMaskMinWidth ) return false;
1056 if( m_SolderPasteMargin != aOther.m_SolderPasteMargin ) return false;
1057 if( m_SolderPasteMarginRatio != aOther.m_SolderPasteMarginRatio ) return false;
1059 if( m_TentViasFront != aOther.m_TentViasFront ) return false;
1060 if( m_TentViasBack != aOther.m_TentViasBack ) return false;
1061 if( m_DefaultFPTextItems != aOther.m_DefaultFPTextItems ) return false;
1062
1063 if( !std::equal( std::begin( m_LineThickness ), std::end( m_LineThickness ),
1064 std::begin( aOther.m_LineThickness ) ) )
1065 return false;
1066
1067 if( !std::equal( std::begin( m_TextSize ), std::end( m_TextSize ),
1068 std::begin( aOther.m_TextSize ) ) )
1069 return false;
1070
1071 if( !std::equal( std::begin( m_TextThickness ), std::end( m_TextThickness ),
1072 std::begin( aOther.m_TextThickness ) ) )
1073 return false;
1074
1075 if( !std::equal( std::begin( m_TextItalic ), std::end( m_TextItalic ),
1076 std::begin( aOther.m_TextItalic ) ) )
1077 return false;
1078
1079 if( !std::equal( std::begin( m_TextUpright ), std::end( m_TextUpright ),
1080 std::begin( aOther.m_TextUpright ) ) )
1081 return false;
1082
1083 if( m_DimensionUnitsMode != aOther.m_DimensionUnitsMode ) return false;
1084 if( m_DimensionPrecision != aOther.m_DimensionPrecision ) return false;
1085 if( m_DimensionUnitsFormat != aOther.m_DimensionUnitsFormat ) return false;
1086 if( m_DimensionSuppressZeroes != aOther.m_DimensionSuppressZeroes ) return false;
1087 if( m_DimensionTextPosition != aOther.m_DimensionTextPosition ) return false;
1088 if( m_DimensionKeepTextAligned != aOther.m_DimensionKeepTextAligned ) return false;
1089 if( m_DimensionArrowLength != aOther.m_DimensionArrowLength ) return false;
1090 if( m_DimensionExtensionOffset != aOther.m_DimensionExtensionOffset ) return false;
1091 if( m_auxOrigin != aOther.m_auxOrigin ) return false;
1092 if( m_gridOrigin != aOther.m_gridOrigin ) return false;
1093 if( m_HasStackup != aOther.m_HasStackup ) return false;
1094 if( m_UseHeightForLengthCalcs != aOther.m_UseHeightForLengthCalcs ) return false;
1095 if( m_trackWidthIndex != aOther.m_trackWidthIndex ) return false;
1096 if( m_viaSizeIndex != aOther.m_viaSizeIndex ) return false;
1097 if( m_diffPairIndex != aOther.m_diffPairIndex ) return false;
1098 if( m_useCustomTrackVia != aOther.m_useCustomTrackVia ) return false;
1099 if( m_customTrackWidth != aOther.m_customTrackWidth ) return false;
1100 if( m_customViaSize != aOther.m_customViaSize ) return false;
1101 if( m_useCustomDiffPair != aOther.m_useCustomDiffPair ) return false;
1102 if( m_customDiffPair != aOther.m_customDiffPair ) return false;
1103 if( m_copperLayerCount != aOther.m_copperLayerCount ) return false;
1104 if( m_enabledLayers != aOther.m_enabledLayers ) return false;
1105 if( m_boardThickness != aOther.m_boardThickness ) return false;
1106 if( m_currentNetClassName != aOther.m_currentNetClassName ) return false;
1107 if( m_stackup != aOther.m_stackup ) return false;
1108 if( *m_NetSettings != *aOther.m_NetSettings ) return false;
1109 if( *m_Pad_Master != *aOther.m_Pad_Master ) return false;
1110 if( m_defaultZoneSettings != aOther.m_defaultZoneSettings ) return false;
1111
1112 if( m_StyleFPFields != aOther.m_StyleFPFields ) return false;
1113 if( m_StyleFPText != aOther.m_StyleFPText ) return false;
1114 if( m_StyleFPShapes != aOther.m_StyleFPShapes ) return false;
1115
1116 return true;
1117}
1118
1119
1121{
1139 std::string units_ptr( "defaults.dimension_units" );
1140 std::string precision_ptr( "defaults.dimension_precision" );
1141
1142 if( !( Contains( units_ptr ) && Contains( precision_ptr ) &&
1143 At( units_ptr ).is_number_integer() &&
1144 At( precision_ptr ).is_number_integer() ) )
1145 {
1146 // if either is missing or invalid, migration doesn't make sense
1147 return true;
1148 }
1149
1150 int units = *Get<int>( units_ptr );
1151 int precision = *Get<int>( precision_ptr );
1152
1153 // The enum maps directly to precision if the units is mils
1154 int extraDigits = 0;
1155
1156 switch( units )
1157 {
1158 case 0: extraDigits = 3; break;
1159 case 2: extraDigits = 2; break;
1160 default: break;
1161 }
1162
1163 precision += extraDigits;
1164
1165 Set( precision_ptr, precision );
1166
1167 return true;
1168}
1169
1170
1171bool BOARD_DESIGN_SETTINGS::LoadFromFile( const wxString& aDirectory )
1172{
1173 bool ret = NESTED_SETTINGS::LoadFromFile( aDirectory );
1174
1175 // A number of things won't have been translated by the PROJECT_FILE migration because of
1176 // descoped objects required to decode this data. So, it will be in the legacy.pcbnew
1177 // section and needs to be pulled out here
1178
1179 PROJECT_FILE* project = dynamic_cast<PROJECT_FILE*>( GetParent() );
1180
1181 if( !project )
1182 return ret;
1183
1184 bool migrated = false;
1185
1186 auto drcName =
1187 []( int aCode ) -> std::string
1188 {
1189 std::shared_ptr<DRC_ITEM> item = DRC_ITEM::Create( aCode );
1190 wxString name = item->GetSettingsKey();
1191 return std::string( name.ToUTF8() );
1192 };
1193
1194 const std::string rs = "rule_severities.";
1195 const std::string no_courtyard_key = "legacy_no_courtyard_defined";
1196 const std::string courtyard_overlap_key = "legacy_courtyards_overlap";
1197
1198 try
1199 {
1200 nlohmann::json& severities =
1201 project->Internals()->at( "/board/design_settings/rule_severities"_json_pointer );
1202
1203 if( severities.contains( no_courtyard_key ) )
1204 {
1205 if( severities[no_courtyard_key].get<bool>() )
1206 Set( rs + drcName( DRCE_MISSING_COURTYARD ), "error" );
1207 else
1208 Set( rs + drcName( DRCE_MISSING_COURTYARD ), "ignore" );
1209
1210 severities.erase( no_courtyard_key );
1211 migrated = true;
1212 }
1213
1214 if( severities.contains( courtyard_overlap_key ) )
1215 {
1216 if( severities[courtyard_overlap_key].get<bool>() )
1217 Set( rs + drcName( DRCE_OVERLAPPING_FOOTPRINTS ), "error" );
1218 else
1219 Set( rs + drcName( DRCE_OVERLAPPING_FOOTPRINTS ), "ignore" );
1220
1221 severities.erase( courtyard_overlap_key );
1222 migrated = true;
1223 }
1224 }
1225 catch( ... )
1226 {
1227 }
1228 if( Contains( "legacy" ) )
1229 {
1230 // This defaults to false for new boards, but version 5.1.x and prior kept the fillets
1231 // so we do the same for legacy boards.
1233
1234 project->At( "legacy" ).erase( "pcbnew" );
1235 }
1236
1237 // Now that we have everything, we need to load again
1238 if( migrated )
1239 Load();
1240
1241 return ret;
1242}
1243
1244
1246{
1247 return m_DRCSeverities[ aDRCErrorCode ];
1248}
1249
1250
1251bool BOARD_DESIGN_SETTINGS::Ignore( int aDRCErrorCode )
1252{
1253 return m_DRCSeverities[ aDRCErrorCode ] == RPT_SEVERITY_IGNORE;
1254}
1255
1256
1258{
1259 int biggest = std::max( m_MinClearance, m_HoleClearance );
1260 DRC_CONSTRAINT constraint;
1261
1262 biggest = std::max( biggest, m_HoleToHoleMin );
1263 biggest = std::max( biggest, m_CopperEdgeClearance );
1264
1265 if( m_DRCEngine )
1266 {
1267 m_DRCEngine->QueryWorstConstraint( CLEARANCE_CONSTRAINT, constraint );
1268 biggest = std::max( biggest, constraint.Value().Min() );
1269
1270 m_DRCEngine->QueryWorstConstraint( PHYSICAL_CLEARANCE_CONSTRAINT, constraint );
1271 biggest = std::max( biggest, constraint.Value().Min() );
1272
1273 m_DRCEngine->QueryWorstConstraint( HOLE_CLEARANCE_CONSTRAINT, constraint );
1274 biggest = std::max( biggest, constraint.Value().Min() );
1275
1276 m_DRCEngine->QueryWorstConstraint( EDGE_CLEARANCE_CONSTRAINT, constraint );
1277 biggest = std::max( biggest, constraint.Value().Min() );
1278
1279 m_DRCEngine->QueryWorstConstraint( HOLE_TO_HOLE_CONSTRAINT, constraint );
1280 biggest = std::max( biggest, constraint.Value().Min() );
1281 }
1282
1283 return biggest;
1284}
1285
1286
1288{
1289 int clearance = m_NetSettings->GetDefaultNetclass()->GetClearance();
1290
1291 for( const auto& [name, netclass] : m_NetSettings->GetNetclasses() )
1292 clearance = std::min( clearance, netclass->GetClearance() );
1293
1294 return clearance;
1295}
1296
1297
1299{
1300 m_viaSizeIndex = std::min( aIndex, (unsigned) m_ViasDimensionsList.size() );
1301 m_useCustomTrackVia = false;
1302}
1303
1304
1306{
1309 else if( m_viaSizeIndex == 0 )
1310 return m_NetSettings->GetDefaultNetclass()->GetViaDiameter();
1311 else
1312 return m_ViasDimensionsList[ m_viaSizeIndex ].m_Diameter;
1313}
1314
1315
1317{
1318 int drill;
1319
1321 drill = m_customViaSize.m_Drill;
1322 else if( m_viaSizeIndex == 0 )
1323 drill = m_NetSettings->GetDefaultNetclass()->GetViaDrill();
1324 else
1325 drill = m_ViasDimensionsList[ m_viaSizeIndex ].m_Drill;
1326
1327 return drill > 0 ? drill : -1;
1328}
1329
1330
1332{
1333 m_trackWidthIndex = std::min( aIndex, (unsigned) m_TrackWidthList.size() );
1334 m_useCustomTrackVia = false;
1335}
1336
1337
1339{
1341 return m_customTrackWidth;
1342 else if( m_trackWidthIndex == 0 )
1343 return m_NetSettings->GetDefaultNetclass()->GetTrackWidth();
1344 else
1346}
1347
1348
1350{
1351 if( !m_DiffPairDimensionsList.empty() )
1352 {
1353 m_diffPairIndex = std::min( aIndex,
1354 static_cast<unsigned>( m_DiffPairDimensionsList.size() ) - 1 );
1355 }
1356
1357 m_useCustomDiffPair = false;
1358}
1359
1360
1362{
1364 {
1366 }
1367 else if( m_diffPairIndex == 0 )
1368 {
1369 if( m_NetSettings->GetDefaultNetclass()->HasDiffPairWidth() )
1370 return m_NetSettings->GetDefaultNetclass()->GetDiffPairWidth();
1371 else
1372 return m_NetSettings->GetDefaultNetclass()->GetTrackWidth();
1373 }
1374 else
1375 {
1377 }
1378}
1379
1380
1382{
1384 {
1385 return m_customDiffPair.m_Gap;
1386 }
1387 else if( m_diffPairIndex == 0 )
1388 {
1389 if( m_NetSettings->GetDefaultNetclass()->HasDiffPairGap() )
1390 return m_NetSettings->GetDefaultNetclass()->GetDiffPairGap();
1391 else
1392 return m_NetSettings->GetDefaultNetclass()->GetClearance();
1393 }
1394 else
1395 {
1397 }
1398}
1399
1400
1402{
1404 {
1406 }
1407 else if( m_diffPairIndex == 0 )
1408 {
1409 if( m_NetSettings->GetDefaultNetclass()->HasDiffPairViaGap() )
1410 return m_NetSettings->GetDefaultNetclass()->GetDiffPairViaGap();
1411 else
1412 return GetCurrentDiffPairGap();
1413 }
1414 else
1415 {
1417 }
1418}
1419
1420
1422{
1423 m_copperLayerCount = aNewLayerCount;
1424
1425 // Update only enabled copper layers mask
1426 m_enabledLayers &= ~LSET::AllCuMask();
1427
1428 if( aNewLayerCount > 0 )
1429 m_enabledLayers |= LSET::AllCuMask( aNewLayerCount );
1430}
1431
1432
1434{
1435 // Ensures mandatory back and front layers are always enabled
1436 // regardless of board file configuration.
1437 aMask.set( B_Cu ).set( F_Cu )
1438 .set( B_CrtYd ).set( F_CrtYd )
1439 .set( Edge_Cuts ).set( Margin );
1440
1441 m_enabledLayers = aMask;
1442
1443 // update m_CopperLayerCount to ensure its consistency with m_EnabledLayers
1444 m_copperLayerCount = ( aMask & LSET::AllCuMask() ).count();
1445}
1446
1447
1448// Return the layer class index { silk, copper, edges & courtyards, fab, others } of the
1449// given layer.
1451{
1452 if( aLayer == F_SilkS || aLayer == B_SilkS )
1453 return LAYER_CLASS_SILK;
1454 else if( IsCopperLayer( aLayer ) )
1455 return LAYER_CLASS_COPPER;
1456 else if( aLayer == Edge_Cuts )
1457 return LAYER_CLASS_EDGES;
1458 else if( aLayer == F_CrtYd || aLayer == B_CrtYd )
1459 return LAYER_CLASS_COURTYARD;
1460 else if( aLayer == F_Fab || aLayer == B_Fab )
1461 return LAYER_CLASS_FAB;
1462 else
1463 return LAYER_CLASS_OTHERS;
1464}
1465
1466
1468{
1469 return pcbIUScale.mmToIU( ADVANCED_CFG::GetCfg().m_DRCEpsilon );
1470}
1471
1472
1474{
1475 return pcbIUScale.mmToIU( ADVANCED_CFG::GetCfg().m_HoleWallThickness );
1476}
1477
1478
1480{
1481 return m_LineThickness[ GetLayerClass( aLayer ) ];
1482}
1483
1484
1486{
1487 return m_TextSize[ GetLayerClass( aLayer ) ];
1488}
1489
1490
1492{
1493 return m_TextThickness[ GetLayerClass( aLayer ) ];
1494}
1495
1496
1498{
1499 return m_TextItalic[ GetLayerClass( aLayer ) ];
1500}
1501
1502
1504{
1505 return m_TextUpright[ GetLayerClass( aLayer ) ];
1506}
1507
1509{
1510 m_Pad_Master.get()->SetSizeX( pcbIUScale.mmToIU( DEFAULT_PAD_WIDTH_MM ) );
1512 m_Pad_Master.get()->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
1513 m_Pad_Master.get()->SetDrillSize(
1515 m_Pad_Master.get()->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::ROUNDRECT );
1516 m_Pad_Master.get()->SetRoundRectCornerRadius(
1519}
const char * name
Definition: DXF_plotter.cpp:57
constexpr int ARC_HIGH_DEF
Definition: base_units.h:120
constexpr EDA_IU_SCALE pcbIUScale
Definition: base_units.h:108
const int bdsSchemaVersion
#define DEFAULT_MICROVIASMINDRILL
#define DEFAULT_SOLDERPASTE_CLEARANCE
#define DEFAULT_SOLDERPASTE_RATIO
#define DEFAULT_CUSTOMDPAIRWIDTH
#define DEFAULT_DP_MEANDER_SPACING
#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
@ LAYER_CLASS_OTHERS
@ LAYER_CLASS_FAB
@ LAYER_CLASS_COURTYARD
@ LAYER_CLASS_SILK
@ LAYER_CLASS_COPPER
@ LAYER_CLASS_EDGES
#define DEFAULT_SOLDERMASK_MIN_WIDTH
#define DEFAULT_DIMENSION_EXTENSION_OFFSET
#define DEFAULT_PAD_REACT_RADIUS
#define DEFAULT_COPPEREDGECLEARANCE
#define DEFAULT_PAD_HEIGTH_MM
#define DEFAULT_DIMENSION_ARROW_LENGTH
#define DEFAULT_TRACKMINWIDTH
#define DEFAULT_MINTHROUGHDRILL
#define DEFAULT_SILK_TEXT_SIZE
#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:115
Container for design settings for a BOARD object.
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 SetDiffPairIndex(unsigned aIndex)
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.
std::shared_ptr< DRC_ENGINE > m_DRCEngine
void SetEnabledLayers(LSET aMask)
Change the bit-mask of enabled layers to aMask.
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::unique_ptr< PAD > m_Pad_Master
void SetTrackWidthIndex(unsigned aIndex)
Set the current track width list index to aIndex.
TEARDROP_PARAMETERS_LIST m_TeardropParamsList
The parameters of teardrops for the different teardrop targets (via/pad, track end) 3 set of paramete...
void SetViaSizeIndex(unsigned aIndex)
Set the current via size list index to aIndex.
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.
bool LoadFromFile(const wxString &aDirectory="") override
Loads the backing file from disk and then calls Load()
PNS::MEANDER_SETTINGS m_SingleTrackMeanderSettings
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.
DIM_UNITS_MODE m_DimensionUnitsMode
std::vector< VIA_DIMENSION > m_ViasDimensionsList
BOARD_DESIGN_SETTINGS & operator=(const BOARD_DESIGN_SETTINGS &aOther)
MINOPTMAX< int > & Value()
Definition: drc_rule.h:153
static std::vector< std::reference_wrapper< RC_ITEM > > GetItemsWithSeverities()
Definition: drc_item.h:130
static std::shared_ptr< DRC_ITEM > Create(int aErrorCode)
Constructs a DRC_ITEM for the given error code.
Definition: drc_item.cpp:372
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::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...
void ReleaseNestedSettings(NESTED_SETTINGS *aSettings)
Saves and frees a nested settings object, if it exists within this one.
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:36
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Return a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:676
T Min() const
Definition: minoptmax.h:33
NESTED_SETTINGS is a JSON_SETTINGS that lives inside a JSON_SETTINGS.
JSON_SETTINGS * GetParent()
JSON_SETTINGS * m_parent
A pointer to the parent object to load and store from.
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:144
Stores an enum as an integer.
Definition: parameters.h:228
Like a normal param, but with custom getter and setter functions.
Definition: parameters.h:295
Represents a parameter that has a scaling factor between the value in the file and the value used int...
Definition: parameters.h:392
Dimensions for the meandering algorithm.
Definition: pns_meander.h:68
int m_minAmplitude
Maximum meandering amplitude.
Definition: pns_meander.h:83
int m_cornerRadiusPercentage
Place meanders on one side.
Definition: pns_meander.h:109
bool m_singleSided
Initial side when placing meanders at segment.
Definition: pns_meander.h:112
MEANDER_STYLE m_cornerStyle
Rounding percentage (0 - 100).
Definition: pns_meander.h:106
int m_maxAmplitude
Meandering period/spacing (see dialog picture for explanation).
Definition: pns_meander.h:86
int m_spacing
Amplitude/spacing adjustment step.
Definition: pns_meander.h:89
The backing store for a PROJECT, in JSON format.
Definition: project_file.h:72
A holder for a rule check item, DRC in Pcbnew or ERC in Eeschema.
Definition: rc_item.h:79
bool m_UseRoundShapesOnly
True to create teardrops for round shapes only.
bool m_TargetVias
True to create teardrops for vias.
bool m_TargetPTHPads
True to create teardrops for pads with holes.
bool m_TargetTrack2Track
True to create teardrops at the end of a track connected to the end of another track having a differe...
TEARDROP_PARAMETERS * GetParameters(TARGET_TD aTdType)
bool m_TargetSMDPads
True to create teardrops for pads SMD, edge connectors,.
TEARDROP_PARAMETARS is a helper class to handle parameters needed to build teardrops for a board thes...
int m_CurveSegCount
True if the teardrop should be curved.
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.
@ DRCE_SILK_EDGE_CLEARANCE
Definition: drc_item.h:98
@ DRCE_FOOTPRINT_FILTERS
Definition: drc_item.h:79
@ DRCE_PADSTACK
Definition: drc_item.h:62
@ 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_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_SILK_CLEARANCE
Definition: drc_item.h:96
@ DRCE_LAST
Definition: drc_item.h:109
@ 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:74
@ HOLE_TO_HOLE_CONSTRAINT
Definition: drc_rule.h:52
#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)
Tests whether a layer is a copper layer.
Definition: layer_ids.h:532
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
SEVERITY
@ RPT_SEVERITY_WARNING
@ RPT_SEVERITY_ERROR
@ RPT_SEVERITY_IGNORE
Container to handle a stock of specific differential pairs each with unique track width,...
constexpr double IUTomm(int iu) const
Definition: base_units.h:86
const double IU_PER_MM
Definition: base_units.h:76
const double MM_PER_IU
Definition: base_units.h:78
constexpr int MilsToIU(int mils) const
Definition: base_units.h:93
constexpr int mmToIU(double mm) const
Definition: base_units.h:88
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)
wxString SeverityToString(const SEVERITY &aSeverity)
Definition: ui_common.cpp:66
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:691
#define ZONE_CLEARANCE_MM
Definition: zones.h:37