KiCad PCB EDA Suite
Loading...
Searching...
No Matches
drc_rule_editor_utils.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) 2024 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, see <https://www.gnu.org/licenses/>.
18 */
19
22#include <kiplatform/io.h>
23#include <reporter.h>
25#include <drc/drc_rule_parser.h>
26#include <drc_rules_lexer.h>
27#include <drc/drc_rule.h>
45#include <board.h>
46#include <wx/ffile.h>
47#include <wx/regex.h>
48#include <unordered_map>
49
50using CODE_MAP = std::unordered_map<DRC_RULE_EDITOR_CONSTRAINT_NAME, const char*>;
51using REVERSE_CODE_MAP = std::unordered_map<wxString, DRC_RULE_EDITOR_CONSTRAINT_NAME, wxStringHash, wxStringEqual>;
52
53static const CODE_MAP sCodeMap = {
54 { MINIMUM_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_clearance ) },
55 { CREEPAGE_DISTANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_creepage ) },
56 { MINIMUM_CONNECTION_WIDTH, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_connection_width ) },
57 { COPPER_TO_HOLE_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_clearance ) },
58 { MINIMUM_THERMAL_RELIEF_SPOKE_COUNT, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_min_resolved_spokes ) },
59 { MICROVIA_STACK_DEPTH, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_microvia_stack_depth ) },
60 { HOLE_ASPECT_RATIO, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_aspect_ratio ) },
61 { MINIMUM_ANNULAR_WIDTH, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_annular_width ) },
62 { COPPER_TO_EDGE_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_edge_clearance ) },
63 { COURTYARD_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_courtyard_clearance ) },
64 { PHYSICAL_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_physical_clearance ) },
65 { MINIMUM_DRILL_SIZE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_size ) },
66 { HOLE_SIZE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_size ) },
67 { HOLE_TO_HOLE_DISTANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_to_hole ) },
68 { MINIMUM_VIA_DIAMETER, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_via_diameter ) },
69 { VIA_STYLE, "via_style" },
70 { MINIMUM_TEXT_HEIGHT_AND_THICKNESS, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_text_height ) },
71 { SILK_TO_SILK_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_silk_clearance ) },
72 { SILK_TO_SOLDERMASK_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_silk_clearance ) },
73 { MINIMUM_SOLDERMASK_SLIVER, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_mask_sliver ) },
74 { SOLDERMASK_EXPANSION, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_mask_expansion ) },
75 { SOLDERPASTE_EXPANSION, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_paste_abs_margin ) },
76 { MATCHED_LENGTH_DIFF_PAIR, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_length ) },
77 { ROUTING_DIFF_PAIR, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_diff_pair_gap ) },
78 { ROUTING_WIDTH, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_track_width ) },
79 { MAXIMUM_VIA_COUNT, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_via_count ) },
80 { ABSOLUTE_LENGTH, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_length ) },
81 { PERMITTED_LAYERS, "permitted_layers" },
82 { ALLOWED_ORIENTATION, "allowed_orientation" },
83 { VIAS_UNDER_SMD, "disallow_via" }
84};
85
87{
89 for( const auto& [type, code] : sCodeMap )
90 map.emplace( wxString::FromUTF8( code ), type );
91 return map;
92}();
93
94static std::vector<DRC_RULE_EDITOR_UTILS::RuleConverter>& GetRuleConverters()
95{
96 static std::vector<DRC_RULE_EDITOR_UTILS::RuleConverter> converters;
97 return converters;
98}
99
101{
102 GetRuleConverters().insert( GetRuleConverters().begin(), aConverter );
103}
104
106{
107 switch( aType )
108 {
109 case CLEARANCE_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_clearance );
110 case EDGE_CLEARANCE_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_edge_clearance );
111 case HOLE_CLEARANCE_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_clearance );
112 case HOLE_TO_HOLE_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_to_hole );
113 case HOLE_SIZE_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_size );
114 case TRACK_WIDTH_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_track_width );
115 case ANNULAR_WIDTH_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_annular_width );
116 case VIA_DIAMETER_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_via_diameter );
117 case DISALLOW_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_disallow );
118 case COURTYARD_CLEARANCE_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_courtyard_clearance );
119 case SILK_CLEARANCE_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_silk_clearance );
120 case TEXT_HEIGHT_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_text_height );
121 case LINE_WIDTH_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_line_width );
122 case TRACK_ANGLE_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_track_angle );
123 case TRACK_SEGMENT_LENGTH_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_track_segment_length );
124 case CONNECTION_WIDTH_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_connection_width );
125 case VIA_DANGLING_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_via_dangling );
126 case ZONE_CONNECTION_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_zone_connection );
127 case THERMAL_RELIEF_GAP_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_thermal_relief_gap );
128 case THERMAL_SPOKE_WIDTH_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_thermal_spoke_width );
129 case MIN_RESOLVED_SPOKES_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_min_resolved_spokes );
130 case MICROVIA_STACK_DEPTH_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_microvia_stack_depth );
131 case HOLE_ASPECT_RATIO_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_aspect_ratio );
132 case SOLDER_MASK_EXPANSION_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_mask_expansion );
133 case SOLDER_PASTE_ABS_MARGIN_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_paste_abs_margin );
134 case SOLDER_PASTE_REL_MARGIN_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_paste_rel_margin );
135 case LENGTH_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_length );
136 case SKEW_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_skew );
137 case VIA_COUNT_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_via_count );
138 case DIFF_PAIR_GAP_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_diff_pair_gap );
139 case MAX_UNCOUPLED_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_diff_pair_uncoupled );
140 case PHYSICAL_CLEARANCE_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_physical_clearance );
141 case PHYSICAL_HOLE_CLEARANCE_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_physical_hole_clearance );
142 case BRIDGED_MASK_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_bridged_mask );
143 case SOLDER_MASK_SLIVER_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_mask_sliver );
144 case ASSERTION_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_assertion );
145 default: return "";
146 }
147}
148
150{
151 static bool initialized = false;
152 if( initialized )
153 return;
154 initialized = true;
155
156 // Generic Converter
158 []( const std::shared_ptr<DRC_RULE>& aRule ) -> std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>
159 {
160 if( aRule->m_Constraints.empty() ) return nullptr;
161
162 const auto& constraint = aRule->m_Constraints[0];
163 wxString code = GetConstraintCodeFromType( constraint.m_Type );
164
165 if( code.IsEmpty() ) return nullptr;
166
167 if( sCodeReverse.count( code ) )
168 {
169 auto type = sCodeReverse.at( code );
170
172 {
173 double val = constraint.GetValue().Min() / 1000000.0;
175 data->SetRuleName( aRule->m_Name );
176 data->SetNumericInputValue( val );
177 data->SetConstraintCode( code );
178 return data;
179 }
181 {
182 auto data = std::make_shared<DRC_RE_BOOL_INPUT_CONSTRAINT_DATA>( 0, true, aRule->m_Name );
183 data->SetConstraintCode( code );
184 return data;
185 }
186 else if( code == "track_width" )
187 {
188 double minW = constraint.GetValue().Min() / 1000000.0;
189 double optW = constraint.GetValue().Opt() / 1000000.0;
190 double maxW = constraint.GetValue().Max() / 1000000.0;
191
192 double tol = 0;
193 if( optW > 0 )
194 tol = std::max( optW - minW, maxW - optW );
195
196 auto data = std::make_shared<DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA>( 0, aRule->m_Name, optW, tol );
197 data->SetConstraintCode( code );
198 return data;
199 }
200 }
201 return nullptr;
202 } );
203
204 // Via Style Converter
206 []( const std::shared_ptr<DRC_RULE>& aRule ) -> std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>
207 {
208 auto diaConstraint = aRule->FindConstraint( VIA_DIAMETER_CONSTRAINT );
209 auto holeConstraint = aRule->FindConstraint( HOLE_SIZE_CONSTRAINT );
210
211 if( diaConstraint && holeConstraint )
212 {
213 double minDia = diaConstraint->GetValue().Min() / 1000000.0;
214 double maxDia = diaConstraint->GetValue().Max() / 1000000.0;
215
216 double minDrill = holeConstraint->GetValue().Min() / 1000000.0;
217 double maxDrill = holeConstraint->GetValue().Max() / 1000000.0;
218
220
221 if( aRule->m_Condition )
222 {
223 wxString expr = aRule->m_Condition->GetExpression();
224
225 if( expr.Contains( wxS( "'Micro'" ) ) )
226 viaType = VIA_STYLE_TYPE::MICRO;
227 else if( expr.Contains( wxS( "'Through'" ) ) )
228 viaType = VIA_STYLE_TYPE::THROUGH;
229 else if( expr.Contains( wxS( "'Blind'" ) ) )
230 viaType = VIA_STYLE_TYPE::BLIND;
231 else if( expr.Contains( wxS( "'Buried'" ) ) )
232 viaType = VIA_STYLE_TYPE::BURIED;
233 }
234
235 auto data = std::make_shared<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>( 0, aRule->m_Name, minDia, maxDia,
236 minDrill, maxDrill, viaType );
237 data->SetConstraintCode( "via_style" );
238 return data;
239 }
240 return nullptr;
241 } );
242}
243
244
246{
247 auto it = sCodeMap.find( aConstraintType );
248 if( it != sCodeMap.end() )
249 return wxString::FromUTF8( it->second );
250
251 return wxString();
252}
253
254
255std::optional<DRC_RULE_EDITOR_CONSTRAINT_NAME> DRC_RULE_EDITOR_UTILS::GetConstraintTypeFromCode( const wxString& aCode )
256{
257 auto it = sCodeReverse.find( aCode );
258 if( it != sCodeReverse.end() )
259 return it->second;
260
261 return std::nullopt;
262}
263
264
269
270
272{
273 switch( aConstraintType )
274 {
275 default: return false;
276 }
277}
278
279
281{
282 switch( aConstraintType )
283 {
289 case HOLE_SIZE:
306 return true;
307 default:
308 return false;
309 }
310}
311
312
313bool DRC_RULE_EDITOR_UTILS::ValidateNumericCtrl( wxTextCtrl* aTextCtrl, const wxString& aLabel, bool aCanBeZero,
314 int* aErrorCount, wxString* aValidationMessage )
315{
316 VALIDATOR_NUMERIC_CTRL validator( aCanBeZero );
317 aTextCtrl->SetValidator( validator );
318
319 if( !aTextCtrl->Validate() )
320 {
321 VALIDATOR_NUMERIC_CTRL* v = static_cast<VALIDATOR_NUMERIC_CTRL*>( aTextCtrl->GetValidator() );
322
323 switch( v->GetValidationState() )
324 {
326 {
327 ( *aErrorCount )++;
328 *aValidationMessage +=
330 wxString::Format( _( "%s should not be empty." ), aLabel ) );
331 return false;
332 }
334 {
335 ( *aErrorCount )++;
336 *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
337 *aErrorCount, wxString::Format( _( "The value of %s must be a valid number." ), aLabel ) );
338 return false;
339 }
341 {
342 ( *aErrorCount )++;
343 *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
344 *aErrorCount, wxString::Format( _( "The value of %s must be greater than 0." ), aLabel ) );
345 return false;
346 }
347 default: break;
348 }
349 }
350
351 return true;
352}
353
354
355bool DRC_RULE_EDITOR_UTILS::ValidateIntegerCtrl( wxTextCtrl* aTextCtrl, const wxString& aLabel, bool aCanBeZero,
356 int* aErrorCount, wxString* aValidationMessage )
357{
358 VALIDATOR_NUMERIC_CTRL validator( aCanBeZero, true );
359 aTextCtrl->SetValidator( validator );
360
361 if( !aTextCtrl->Validate() )
362 {
363 VALIDATOR_NUMERIC_CTRL* v = static_cast<VALIDATOR_NUMERIC_CTRL*>( aTextCtrl->GetValidator() );
364
365 switch( v->GetValidationState() )
366 {
368 {
369 ( *aErrorCount )++;
370 *aValidationMessage +=
372 wxString::Format( _( "%s should not be empty." ), aLabel ) );
373 return false;
374 }
376 {
377 ( *aErrorCount )++;
378 *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
379 *aErrorCount, wxString::Format( _( "The value of %s must be a valid integer." ), aLabel ) );
380 return false;
381 }
383 {
384 ( *aErrorCount )++;
385 *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
386 *aErrorCount, wxString::Format( _( "The value of %s must be greater than 0." ), aLabel ) );
387 return false;
388 }
389 default: break;
390 }
391 }
392
393 return true;
394}
395
396
397bool DRC_RULE_EDITOR_UTILS::ValidateComboCtrl( wxComboBox* aComboBox, const wxString& aLabel, int* aErrorCount,
398 wxString* aValidationMessage )
399{
400 VALIDATOR_COMBO_CTRL cmbCtrlValidator;
401 aComboBox->SetValidator( cmbCtrlValidator );
402
403 if( !aComboBox->Validate() )
404 {
405 VALIDATOR_COMBO_CTRL* v = static_cast<VALIDATOR_COMBO_CTRL*>( aComboBox->GetValidator() );
406
407 switch( v->GetValidationState() )
408 {
410 {
411 ( *aErrorCount )++;
412 *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage( *aErrorCount,
413 wxString::Format( _( "Please choose %s." ), aLabel ) );
414 return false;
415 }
416 default: break;
417 }
418 }
419
420 return true;
421}
422
423
424bool DRC_RULE_EDITOR_UTILS::ValidateMinMaxCtrl( wxTextCtrl* aMinTextCtrl, wxTextCtrl* aMaxTextCtrl,
425 const wxString& aMinLabel, const wxString& aMaxLabel,
426 int* aErrorCount, wxString* aValidationMessage )
427{
428 aMinTextCtrl->SetName( "min" );
429 aMaxTextCtrl->SetName( "max" );
430
431 aMinTextCtrl->SetValidator( VALIDATE_MIN_MAX_CTRL( aMinTextCtrl, aMaxTextCtrl ) );
432
433 if( !aMinTextCtrl->Validate() )
434 {
435 VALIDATE_MIN_MAX_CTRL* v = static_cast<VALIDATE_MIN_MAX_CTRL*>( aMinTextCtrl->GetValidator() );
436
437 switch( v->GetValidationState() )
438 {
440 {
441 ( *aErrorCount )++;
442 *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
443 *aErrorCount, wxString::Format( _( "%s value cannot be greater than %s value." ),
444 aMinLabel, aMaxLabel ) );
445 return false;
446 }
447 default: break;
448 }
449 }
450
451 aMinTextCtrl->SetName( "text" );
452 aMaxTextCtrl->SetName( "text" );
453
454 return true;
455}
456
457
458bool DRC_RULE_EDITOR_UTILS::ValidateMinPreferredMaxCtrl( wxTextCtrl* aMinTextCtrl, wxTextCtrl* aPreferredTextCtrl,
459 wxTextCtrl* aMaxTextCtrl, const wxString& aMinLabel,
460 const wxString& aPreferredLabel, const wxString& aMaxLabel,
461 int* aErrorCount, wxString* aValidationMessage )
462{
463 aMinTextCtrl->SetName( "min" );
464 aPreferredTextCtrl->SetName( "preferred" );
465 aMaxTextCtrl->SetName( "max" );
466
467 aMinTextCtrl->SetValidator( VALIDATE_MIN_PREFERRED_MAX_CTRL( aMinTextCtrl, aPreferredTextCtrl, aMaxTextCtrl ) );
468
469 if( !aMinTextCtrl->Validate() )
470 {
472 static_cast<VALIDATE_MIN_PREFERRED_MAX_CTRL*>( aMinTextCtrl->GetValidator() );
473
474 switch( v->GetValidationState() )
475 {
477 {
478 ( *aErrorCount )++;
479 *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
480 *aErrorCount, wxString::Format( _( "%s value cannot be greater than %s value." ),
481 aMinLabel, aPreferredLabel ) );
482 return false;
483 }
485 {
486 ( *aErrorCount )++;
487 *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
488 *aErrorCount, wxString::Format( _( "%s value cannot be greater than %s value." ),
489 aPreferredLabel, aMaxLabel ) );
490 return false;
491 }
493 {
494 ( *aErrorCount )++;
495 *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
496 *aErrorCount, wxString::Format( _( "%s value cannot be greater than %s value." ),
497 aMinLabel, aMaxLabel ) );
498 return false;
499 }
500 default: break;
501 }
502 }
503
504 aMinTextCtrl->SetName( "text" );
505 aPreferredTextCtrl->SetName( "text" );
506 aMaxTextCtrl->SetName( "text" );
507
508 return true;
509}
510
511
512bool DRC_RULE_EDITOR_UTILS::ValidateCheckBoxCtrls( const std::vector<wxCheckBox*>& aCheckboxes, const wxString& aLabel,
513 int* aErrorCount, wxString* aValidationMessage )
514{
515 VALIDATE_CHECKBOX_LIST validator( aCheckboxes );
516
517 aCheckboxes[0]->SetValidator( validator );
518
519 if( !aCheckboxes[0]->Validate() )
520 {
521 VALIDATE_CHECKBOX_LIST* v = static_cast<VALIDATE_CHECKBOX_LIST*>( aCheckboxes[0]->GetValidator() );
522
523 switch( v->GetValidationState() )
524 {
526 {
527 ( *aErrorCount )++;
528 *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
529 *aErrorCount, wxString::Format( _( "Please select at least one option from %s list." ), aLabel ));
530 return false;
531 }
532 default: break;
533 }
534 }
535
536 return true;
537}
538
539
540wxString DRC_RULE_EDITOR_UTILS::FormatErrorMessage( int aErrorCount, const wxString& aErrorMessage )
541{
542 return wxString::Format( wxS( "%d. %s\n" ), aErrorCount, aErrorMessage );
543}
544
545
546// ==================== Pure Validators (No GUI Dependencies) ====================
547
548bool DRC_RULE_EDITOR_UTILS::ValidateNumericValue( double aValue, bool aCanBeZero, const wxString& aLabel,
549 VALIDATION_RESULT* aResult )
550{
551 if( !aCanBeZero && aValue <= 0.0 )
552 {
553 aResult->AddError( wxString::Format( _( "The value of %s must be greater than 0." ), aLabel ) );
554 return false;
555 }
556
557 return true;
558}
559
560
561bool DRC_RULE_EDITOR_UTILS::ValidateNumericString( const wxString& aValueStr, bool aCanBeZero,
562 bool aIntegerOnly, const wxString& aLabel,
563 VALIDATION_RESULT* aResult )
564{
565 if( aValueStr.IsEmpty() )
566 {
567 aResult->AddError( wxString::Format( _( "%s should not be empty." ), aLabel ) );
568 return false;
569 }
570
571 try
572 {
573 if( aIntegerOnly )
574 {
575 std::string stdStr = aValueStr.ToStdString();
576 size_t pos;
577 long intVal = std::stol( stdStr, &pos );
578
579 if( pos != stdStr.length() )
580 {
581 aResult->AddError( wxString::Format( _( "The value of %s must be a valid integer." ), aLabel ) );
582 return false;
583 }
584
585 if( !aCanBeZero && intVal <= 0 )
586 {
587 aResult->AddError( wxString::Format( _( "The value of %s must be greater than 0." ), aLabel ) );
588 return false;
589 }
590 }
591 else
592 {
593 std::string stdStr = aValueStr.ToStdString();
594 size_t pos;
595 double floatVal = std::stod( stdStr, &pos );
596
597 if( pos != stdStr.length() )
598 {
599 aResult->AddError( wxString::Format( _( "The value of %s must be a valid number." ), aLabel ) );
600 return false;
601 }
602
603 if( !aCanBeZero && floatVal <= 0.0 )
604 {
605 aResult->AddError( wxString::Format( _( "The value of %s must be greater than 0." ), aLabel ) );
606 return false;
607 }
608 }
609 }
610 catch( const std::exception& )
611 {
612 if( aIntegerOnly )
613 aResult->AddError( wxString::Format( _( "The value of %s must be a valid integer." ), aLabel ) );
614 else
615 aResult->AddError( wxString::Format( _( "The value of %s must be a valid number." ), aLabel ) );
616
617 return false;
618 }
619
620 return true;
621}
622
623
624bool DRC_RULE_EDITOR_UTILS::ValidateMinMax( double aMin, double aMax, const wxString& aMinLabel,
625 const wxString& aMaxLabel, VALIDATION_RESULT* aResult )
626{
627 if( aMin > aMax )
628 {
629 aResult->AddError( wxString::Format( _( "%s value cannot be greater than %s value." ), aMinLabel, aMaxLabel ));
630 return false;
631 }
632
633 return true;
634}
635
636
637bool DRC_RULE_EDITOR_UTILS::ValidateMinPreferredMax( double aMin, double aPreferred, double aMax,
638 const wxString& aMinLabel,
639 const wxString& aPrefLabel,
640 const wxString& aMaxLabel,
641 VALIDATION_RESULT* aResult )
642{
643 bool valid = true;
644
645 if( aMin > aPreferred )
646 {
647 aResult->AddError( wxString::Format( _( "%s value cannot be greater than %s value." ), aMinLabel, aPrefLabel ));
648 valid = false;
649 }
650
651 if( aPreferred > aMax )
652 {
653 aResult->AddError( wxString::Format( _( "%s value cannot be greater than %s value." ), aPrefLabel, aMaxLabel ));
654 valid = false;
655 }
656
657 if( aMin > aMax )
658 {
659 aResult->AddError( wxString::Format( _( "%s value cannot be greater than %s value." ), aMinLabel, aMaxLabel ));
660 valid = false;
661 }
662
663 return valid;
664}
665
666
667bool DRC_RULE_EDITOR_UTILS::ValidateAtLeastOneSelected( const std::vector<bool>& aSelected,
668 const wxString& aLabel,
669 VALIDATION_RESULT* aResult )
670{
671 for( bool selected : aSelected )
672 {
673 if( selected )
674 return true;
675 }
676
677 aResult->AddError( wxString::Format( _( "Please select at least one option from %s list." ), aLabel ) );
678 return false;
679}
680
681
682bool DRC_RULE_EDITOR_UTILS::ValidateSelection( int aSelectionIndex, const wxString& aLabel,
683 VALIDATION_RESULT* aResult )
684{
685 if( aSelectionIndex < 0 )
686 {
687 aResult->AddError( wxString::Format( _( "Please choose %s." ), aLabel ) );
688 return false;
689 }
690
691 return true;
692}
693
694
695std::vector<std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>> DRC_RULE_EDITOR_UTILS::ParseRules( const wxString& aRules )
696{
698
699 std::vector<std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>> rules;
700 std::vector<std::shared_ptr<DRC_RULE>> parsedRules;
701
702 wxString rulesText = aRules;
703 if( !rulesText.Contains( "(version" ) )
704 rulesText.Prepend( "(version 2)\n" );
705
706 try
707 {
708 DRC_RULES_PARSER parser( rulesText, "Rule Editor Source" );
709 parser.Parse( parsedRules, nullptr );
710 }
711 catch( const IO_ERROR& )
712 {
713 }
714
715 for( const auto& rule : parsedRules )
716 {
717 std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA> data;
718
719 for( const auto& converter : GetRuleConverters() )
720 {
721 data = converter( rule );
722 if( data )
723 break;
724 }
725
726 if( !data )
727 {
728 auto customData = std::make_shared<DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA>( 0, rule->m_Name );
729 customData->SetRuleText( wxString::Format( "(rule \"%s\" ...)", rule->m_Name ) );
730 data = customData;
731 }
732
733 if( rule->m_Condition )
734 data->SetRuleCondition( rule->m_Condition->GetExpression() );
735
736 rules.push_back( data );
737 }
738
739 return rules;
740}
741
742bool DRC_RULE_EDITOR_UTILS::SaveRules( const wxString& aFilename,
743 const std::vector<std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>>& aRules,
744 const BOARD* aBoard )
745{
746 wxString content = wxT( "(version 2)\n" );
747
748 for( const auto& data : aRules )
749 {
750 if( !data )
751 continue;
752
754 ctx.ruleName = data->GetRuleName();
755 ctx.comment = data->GetComment();
756 ctx.conditionExpression = data->GetRuleCondition();
757 ctx.constraintCode = data->GetConstraintCode();
758
759 std::vector<PCB_LAYER_ID> layers = data->GetLayers();
760
761 if( !layers.empty() && aBoard )
762 {
763 wxString layerStr = "(layer";
764
765 for( PCB_LAYER_ID layer : layers )
766 layerStr += " \"" + aBoard->GetLayerName( layer ) + "\"";
767
768 layerStr += ")";
769 ctx.layerClause = layerStr;
770 }
771
772 content += data->GenerateRule( ctx ) + wxT( "\n" );
773 }
774
775 std::string utf8 = std::string( content.mb_str( wxConvUTF8 ) );
776 return KIPLATFORM::IO::AtomicWriteFile( aFilename, utf8.data(), utf8.size() );
777}
778
779
780// ==================== Layer Filtering ====================
781
783 DRC_RULE_EDITOR_CONSTRAINT_NAME aConstraintType )
784{
785 switch( aConstraintType )
786 {
787 // COPPER_ONLY: Constraints that only apply to copper layers
792 case VIA_STYLE:
796 case ROUTING_WIDTH:
801 case ABSOLUTE_LENGTH:
803
804 // SILKSCREEN_ONLY: Constraints that only apply to silkscreen layers
807
808 // SOLDERMASK_ONLY: Constraints that only apply to soldermask layers
812
813 // SOLDERPASTE_ONLY: Constraints that only apply to solderpaste layers
816
817 // TOP_BOTTOM_ANY: Constraints with simplified top/bottom/any selection
820 case VIAS_UNDER_SMD:
823
824 // GENERAL_ANY_LAYER: Constraints that can apply to any layer type
826 case HOLE_SIZE:
831
832 // NO_LAYER_SELECTOR: Constraints where layer selection doesn't apply
834 case PERMITTED_LAYERS:
836 case CUSTOM_RULE:
838
839 default:
841 }
842}
843
844
846{
847 switch( aConstraintType )
848 {
849 case COURTYARD_CLEARANCE: return aIsTop ? F_CrtYd : B_CrtYd;
850 case SILK_TO_SOLDERMASK_CLEARANCE: return aIsTop ? F_SilkS : B_SilkS;
851 default: return aIsTop ? F_Cu : B_Cu;
852 }
853}
854
855
857 bool aIsTop )
858{
859 switch( aConstraintType )
860 {
862 // Matches silk on one side against the mask on that same side
863 return wxString::Format( wxS( "(condition \"A.Layer == '%s' && B.Layer == '%s'\")" ),
864 LSET::Name( TopBottomLayerId( aConstraintType, aIsTop ) ),
865 aIsTop ? wxS( "F.Mask" ) : wxS( "B.Mask" ) );
866
868 case VIAS_UNDER_SMD:
870 return wxString::Format( wxS( "(layer \"%s\")" ), LSET::Name( TopBottomLayerId( aConstraintType, aIsTop ) ) );
871
872 default:
873 return wxEmptyString;
874 }
875}
876
877
878std::shared_ptr<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>
880{
881 switch( aType )
882 {
883 case COPPER_TO_EDGE_CLEARANCE: return std::make_shared<DRC_RE_COPPER_TO_EDGE_CLEARANCE_CONSTRAINT_DATA>();
884 case COPPER_TO_HOLE_CLEARANCE: return std::make_shared<DRC_RE_COPPER_TO_HOLE_CLEARANCE_CONSTRAINT_DATA>();
885 case COURTYARD_CLEARANCE: return std::make_shared<DRC_RE_COURTYARD_CLEARANCE_CONSTRAINT_DATA>();
886 case PHYSICAL_CLEARANCE: return std::make_shared<DRC_RE_PHYSICAL_CLEARANCE_CONSTRAINT_DATA>();
887 case CREEPAGE_DISTANCE: return std::make_shared<DRC_RE_CREEPAGE_DISTANCE_CONSTRAINT_DATA>();
888 case HOLE_SIZE: return std::make_shared<DRC_RE_HOLE_SIZE_CONSTRAINT_DATA>();
889 case HOLE_TO_HOLE_DISTANCE: return std::make_shared<DRC_RE_HOLE_TO_HOLE_DISTANCE_CONSTRAINT_DATA>();
890 case MAXIMUM_VIA_COUNT: return std::make_shared<DRC_RE_MAXIMUM_VIA_COUNT_CONSTRAINT_DATA>();
891 case MINIMUM_ANNULAR_WIDTH: return std::make_shared<DRC_RE_MINIMUM_ANNULAR_WIDTH_CONSTRAINT_DATA>();
892 case MINIMUM_CLEARANCE: return std::make_shared<DRC_RE_MINIMUM_CLEARANCE_CONSTRAINT_DATA>();
893 case MINIMUM_CONNECTION_WIDTH: return std::make_shared<DRC_RE_MINIMUM_CONNECTION_WIDTH_CONSTRAINT_DATA>();
894 case MINIMUM_SOLDERMASK_SLIVER: return std::make_shared<DRC_RE_MINIMUM_SOLDERMASK_SLIVER_CONSTRAINT_DATA>();
895 case MINIMUM_THERMAL_RELIEF_SPOKE_COUNT: return std::make_shared<DRC_RE_MINIMUM_THERMAL_SPOKE_COUNT_CONSTRAINT_DATA>();
896 case MICROVIA_STACK_DEPTH: return std::make_shared<DRC_RE_MICROVIA_STACK_DEPTH_CONSTRAINT_DATA>();
897 case HOLE_ASPECT_RATIO: return std::make_shared<DRC_RE_HOLE_ASPECT_RATIO_CONSTRAINT_DATA>();
898 case MINIMUM_DRILL_SIZE: return std::make_shared<DRC_RE_MINIMUM_DRILL_SIZE_CONSTRAINT_DATA>();
899 case MINIMUM_VIA_DIAMETER: return std::make_shared<DRC_RE_MINIMUM_VIA_DIAMETER_CONSTRAINT_DATA>();
900 case SILK_TO_SILK_CLEARANCE: return std::make_shared<DRC_RE_SILK_TO_SILK_CLEARANCE_CONSTRAINT_DATA>();
901 case SILK_TO_SOLDERMASK_CLEARANCE: return std::make_shared<DRC_RE_SILK_TO_SOLDERMASK_CLEARANCE_CONSTRAINT_DATA>();
902 case SOLDERMASK_EXPANSION: return std::make_shared<DRC_RE_SOLDERMASK_EXPANSION_CONSTRAINT_DATA>();
903 case SOLDERPASTE_EXPANSION: return std::make_shared<DRC_RE_SOLDERPASTE_EXPANSION_CONSTRAINT_DATA>();
904 default: return std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>();
905 }
906}
907
908
909std::shared_ptr<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>
911 const DRC_RE_BASE_CONSTRAINT_DATA& aBase )
912{
913 switch( aType )
914 {
915 case COPPER_TO_EDGE_CLEARANCE: return std::make_shared<DRC_RE_COPPER_TO_EDGE_CLEARANCE_CONSTRAINT_DATA>( aBase );
916 case COPPER_TO_HOLE_CLEARANCE: return std::make_shared<DRC_RE_COPPER_TO_HOLE_CLEARANCE_CONSTRAINT_DATA>( aBase );
917 case COURTYARD_CLEARANCE: return std::make_shared<DRC_RE_COURTYARD_CLEARANCE_CONSTRAINT_DATA>( aBase );
918 case PHYSICAL_CLEARANCE: return std::make_shared<DRC_RE_PHYSICAL_CLEARANCE_CONSTRAINT_DATA>( aBase );
919 case CREEPAGE_DISTANCE: return std::make_shared<DRC_RE_CREEPAGE_DISTANCE_CONSTRAINT_DATA>( aBase );
920 case HOLE_SIZE: return std::make_shared<DRC_RE_HOLE_SIZE_CONSTRAINT_DATA>( aBase );
921 case HOLE_TO_HOLE_DISTANCE: return std::make_shared<DRC_RE_HOLE_TO_HOLE_DISTANCE_CONSTRAINT_DATA>( aBase );
922 case MAXIMUM_VIA_COUNT: return std::make_shared<DRC_RE_MAXIMUM_VIA_COUNT_CONSTRAINT_DATA>( aBase );
923 case MINIMUM_ANNULAR_WIDTH: return std::make_shared<DRC_RE_MINIMUM_ANNULAR_WIDTH_CONSTRAINT_DATA>( aBase );
924 case MINIMUM_CLEARANCE: return std::make_shared<DRC_RE_MINIMUM_CLEARANCE_CONSTRAINT_DATA>( aBase );
925 case MINIMUM_CONNECTION_WIDTH: return std::make_shared<DRC_RE_MINIMUM_CONNECTION_WIDTH_CONSTRAINT_DATA>( aBase );
926 case MINIMUM_SOLDERMASK_SLIVER: return std::make_shared<DRC_RE_MINIMUM_SOLDERMASK_SLIVER_CONSTRAINT_DATA>( aBase );
927 case MINIMUM_THERMAL_RELIEF_SPOKE_COUNT: return std::make_shared<DRC_RE_MINIMUM_THERMAL_SPOKE_COUNT_CONSTRAINT_DATA>( aBase );
928 case MICROVIA_STACK_DEPTH: return std::make_shared<DRC_RE_MICROVIA_STACK_DEPTH_CONSTRAINT_DATA>( aBase );
929 case HOLE_ASPECT_RATIO: return std::make_shared<DRC_RE_HOLE_ASPECT_RATIO_CONSTRAINT_DATA>( aBase );
930 case MINIMUM_DRILL_SIZE: return std::make_shared<DRC_RE_MINIMUM_DRILL_SIZE_CONSTRAINT_DATA>( aBase );
931 case MINIMUM_VIA_DIAMETER: return std::make_shared<DRC_RE_MINIMUM_VIA_DIAMETER_CONSTRAINT_DATA>( aBase );
932 case SILK_TO_SILK_CLEARANCE: return std::make_shared<DRC_RE_SILK_TO_SILK_CLEARANCE_CONSTRAINT_DATA>( aBase );
933 case SILK_TO_SOLDERMASK_CLEARANCE: return std::make_shared<DRC_RE_SILK_TO_SOLDERMASK_CLEARANCE_CONSTRAINT_DATA>( aBase );
934 case SOLDERMASK_EXPANSION: return std::make_shared<DRC_RE_SOLDERMASK_EXPANSION_CONSTRAINT_DATA>( aBase );
935 case SOLDERPASTE_EXPANSION: return std::make_shared<DRC_RE_SOLDERPASTE_EXPANSION_CONSTRAINT_DATA>( aBase );
936 default: return std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( aBase );
937 }
938}
939
940
941std::optional<DRC_RULE_EDITOR_UTILS::SELECTOR_CONDITION>
943{
944 // Anchored at the end too, or a trailing comparison such as "== 0" would be dropped when the rule is saved
945 static wxRegEx netRe( wxT( "^NetName\\s*==\\s*'([^']*)'\\s*$" ) );
946 static wxRegEx netclassRe1( wxT( "^hasNetclass\\('([^']*)'\\)\\s*$" ) );
947 static wxRegEx netclassRe2( wxT( "^NetClass\\s*==\\s*'([^']*)'\\s*$" ) );
948 static wxRegEx intersectsRe( wxT( "^intersectsArea\\('([^']*)'\\)\\s*$" ) );
949 static wxRegEx enclosedRe( wxT( "^enclosedByArea\\('([^']*)'\\)\\s*$" ) );
950
951 if( netRe.Matches( aExpr ) )
952 return SELECTOR_CONDITION{ SELECTOR_KIND::NET, netRe.GetMatch( aExpr, 1 ) };
953
954 if( netclassRe1.Matches( aExpr ) )
955 return SELECTOR_CONDITION{ SELECTOR_KIND::NETCLASS, netclassRe1.GetMatch( aExpr, 1 ) };
956
957 if( netclassRe2.Matches( aExpr ) )
958 return SELECTOR_CONDITION{ SELECTOR_KIND::NETCLASS, netclassRe2.GetMatch( aExpr, 1 ) };
959
960 if( intersectsRe.Matches( aExpr ) )
961 return SELECTOR_CONDITION{ SELECTOR_KIND::INTERSECTS_AREA, intersectsRe.GetMatch( aExpr, 1 ) };
962
963 if( enclosedRe.Matches( aExpr ) )
964 return SELECTOR_CONDITION{ SELECTOR_KIND::ENCLOSED_BY_AREA, enclosedRe.GetMatch( aExpr, 1 ) };
965
966 return std::nullopt;
967}
968
969
970std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>
972 const DRC_RE_BASE_CONSTRAINT_DATA& aBase )
973{
974 switch( aType )
975 {
976 case VIA_STYLE: return std::make_shared<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>( aBase );
978 return std::make_shared<DRC_RE_MINIMUM_TEXT_HEIGHT_THICKNESS_CONSTRAINT_DATA>( aBase );
979 case ROUTING_DIFF_PAIR: return std::make_shared<DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA>( aBase );
980 case ROUTING_WIDTH: return std::make_shared<DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA>( aBase );
981 case PERMITTED_LAYERS: return std::make_shared<DRC_RE_PERMITTED_LAYERS_CONSTRAINT_DATA>( aBase );
982 case ALLOWED_ORIENTATION: return std::make_shared<DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA>( aBase );
983 case CUSTOM_RULE: return std::make_shared<DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA>( aBase );
984 case ABSOLUTE_LENGTH: return std::make_shared<DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA>( aBase );
985 case MATCHED_LENGTH_DIFF_PAIR: return std::make_shared<DRC_RE_MATCHED_LENGTH_DIFF_PAIR_CONSTRAINT_DATA>( aBase );
986 case VIAS_UNDER_SMD: return std::make_shared<DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA>( aBase );
987 default: break;
988 }
989
990 if( IsNumericInputType( aType ) )
991 return CreateNumericConstraintData( aType, aBase );
992
993 if( IsBoolInputType( aType ) )
994 return std::make_shared<DRC_RE_BOOL_INPUT_CONSTRAINT_DATA>( aBase );
995
996 wxLogWarning( "No factory found for constraint type: %d", aType );
997 return std::make_shared<DRC_RE_BASE_CONSTRAINT_DATA>( aBase );
998}
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:411
const wxString GetLayerName(PCB_LAYER_ID aLayer) const
Return the name of a aLayer.
Definition board.cpp:960
void Parse(std::vector< std::shared_ptr< DRC_RULE > > &aRules, REPORTER *aReporter)
static bool IsNumericInputType(const DRC_RULE_EDITOR_CONSTRAINT_NAME &aConstraintType)
static wxString ConstraintToKicadDrc(DRC_RULE_EDITOR_CONSTRAINT_NAME aType)
Convert a constraint type into the keyword used in a .kicad_drc file.
static bool ValidateNumericValue(double aValue, bool aCanBeZero, const wxString &aLabel, VALIDATION_RESULT *aResult)
Validates a numeric value.
static bool ValidateAtLeastOneSelected(const std::vector< bool > &aSelected, const wxString &aLabel, VALIDATION_RESULT *aResult)
Validates that at least one option is selected.
static bool ValidateSelection(int aSelectionIndex, const wxString &aLabel, VALIDATION_RESULT *aResult)
Validates that a selection has been made (index >= 0).
static std::shared_ptr< DRC_RE_BASE_CONSTRAINT_DATA > CreateConstraintData(DRC_RULE_EDITOR_CONSTRAINT_NAME aType, const DRC_RE_BASE_CONSTRAINT_DATA &aBase)
Create the data object that holds a rule of the given constraint type, taking the identity fields fro...
static wxString GetConstraintCode(DRC_RULE_EDITOR_CONSTRAINT_NAME aConstraintType)
Translate a rule tree node type into the keyword used by the rules file for that constraint.
static bool ValidateNumericCtrl(wxTextCtrl *aTextCtrl, const wxString &aLabel, bool aCanBeZero, int *aErrorCount, wxString *aValidationMessage)
Validates a numeric input control, checking if the value is valid, non-empty, and greater than zero.
static bool ValidateMinMax(double aMin, double aMax, const wxString &aMinLabel, const wxString &aMaxLabel, VALIDATION_RESULT *aResult)
Validates that min <= max.
static bool ValidateMinPreferredMaxCtrl(wxTextCtrl *aMinTextCtrl, wxTextCtrl *aPreferredTextCtrl, wxTextCtrl *aMaxTextCtrl, const wxString &aMinLabel, const wxString &aPreferredLabel, const wxString &aMaxLabel, int *aErrorCount, wxString *aValidationMessage)
Validates the minimum, preferred, and maximum value controls, ensuring that:
static wxString FormatErrorMessage(int aErrorCount, const wxString &aErrorMessage)
static std::optional< DRC_RULE_EDITOR_CONSTRAINT_NAME > GetConstraintTypeFromCode(const wxString &aCode)
Resolve a constraint keyword from a rules file into the corresponding rule tree enumeration value.
static bool ValidateComboCtrl(wxComboBox *aComboBox, const wxString &aLabel, int *aErrorCount, wxString *aValidationMessage)
Validates a combo box control, ensuring that a selection has been made.
static bool SaveRules(const wxString &aFilename, const std::vector< std::shared_ptr< DRC_RE_BASE_CONSTRAINT_DATA > > &aRules, const BOARD *aBoard)
static void RegisterRuleConverter(RuleConverter aConverter)
static wxString TranslateTopBottomLayer(DRC_RULE_EDITOR_CONSTRAINT_NAME aConstraintType, bool aIsTop)
Translate a top/bottom selection to the appropriate layer clause or condition.
static bool ValidateCheckBoxCtrls(const std::vector< wxCheckBox * > &aCheckboxes, const wxString &aLabel, int *aErrorCount, wxString *aValidationMessage)
Validates a list of checkboxes, ensuring that at least one option is selected.
static bool ValidateNumericString(const wxString &aValueStr, bool aCanBeZero, bool aIntegerOnly, const wxString &aLabel, VALIDATION_RESULT *aResult)
Validates that a string represents a valid numeric value.
static bool ValidateMinMaxCtrl(wxTextCtrl *aMinTextCtrl, wxTextCtrl *aMaxTextCtrl, const wxString &aMinLabel, const wxString &aMaxLabel, int *aErrorCount, wxString *aValidationMessage)
Validates the minimum and maximum value controls, ensuring that the minimum value is not greater than...
std::function< std::shared_ptr< DRC_RE_BASE_CONSTRAINT_DATA >(const std::shared_ptr< DRC_RULE > &)> RuleConverter
static std::optional< SELECTOR_CONDITION > ParseSelectorCondition(const wxString &aExpr)
Match a condition that a net, netclass or area selector can show.
static std::shared_ptr< DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA > CreateNumericConstraintData(DRC_RULE_EDITOR_CONSTRAINT_NAME aType)
static DRC_LAYER_CATEGORY GetLayerCategoryForConstraint(DRC_RULE_EDITOR_CONSTRAINT_NAME aConstraintType)
Get the layer category for a constraint type.
static PCB_LAYER_ID TopBottomLayerId(DRC_RULE_EDITOR_CONSTRAINT_NAME aConstraintType, bool aIsTop)
The layer a side of the board means for a constraint, which is not copper for every one.
static bool ValidateMinPreferredMax(double aMin, double aPreferred, double aMax, const wxString &aMinLabel, const wxString &aPrefLabel, const wxString &aMaxLabel, VALIDATION_RESULT *aResult)
Validates that min <= preferred <= max.
static bool ValidateIntegerCtrl(wxTextCtrl *aTextCtrl, const wxString &aLabel, bool aCanBeZero, int *aErrorCount, wxString *aValidationMessage)
Validates an integer input control, ensuring the value is a valid integer, non-empty,...
static bool IsBoolInputType(const DRC_RULE_EDITOR_CONSTRAINT_NAME &aConstraintType)
static std::vector< std::shared_ptr< DRC_RE_BASE_CONSTRAINT_DATA > > ParseRules(const wxString &aRules)
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
static wxString Name(PCB_LAYER_ID aLayerId)
Return the fixed name association with aLayerId.
Definition lset.cpp:184
VALIDATION_STATE GetValidationState() const
VALIDATION_STATE GetValidationState() const
VALIDATION_STATE GetValidationState() const
VALIDATION_STATE GetValidationState() const
std::string utf8(const wxString &aText)
@ ANNULAR_WIDTH_CONSTRAINT
@ BRIDGED_MASK_CONSTRAINT
@ COURTYARD_CLEARANCE_CONSTRAINT
@ VIA_DIAMETER_CONSTRAINT
@ ZONE_CONNECTION_CONSTRAINT
@ DIFF_PAIR_GAP_CONSTRAINT
@ VIA_DANGLING_CONSTRAINT
@ SOLDER_MASK_SLIVER_CONSTRAINT
@ DISALLOW_CONSTRAINT
@ TRACK_WIDTH_CONSTRAINT
@ SILK_CLEARANCE_CONSTRAINT
@ EDGE_CLEARANCE_CONSTRAINT
@ MIN_RESOLVED_SPOKES_CONSTRAINT
@ TRACK_SEGMENT_LENGTH_CONSTRAINT
@ HOLE_ASPECT_RATIO_CONSTRAINT
@ LENGTH_CONSTRAINT
@ VIA_COUNT_CONSTRAINT
@ PHYSICAL_HOLE_CLEARANCE_CONSTRAINT
@ CLEARANCE_CONSTRAINT
@ THERMAL_SPOKE_WIDTH_CONSTRAINT
@ CONNECTION_WIDTH_CONSTRAINT
@ THERMAL_RELIEF_GAP_CONSTRAINT
@ MAX_UNCOUPLED_CONSTRAINT
@ ASSERTION_CONSTRAINT
@ SKEW_CONSTRAINT
@ LINE_WIDTH_CONSTRAINT
@ MICROVIA_STACK_DEPTH_CONSTRAINT
@ HOLE_CLEARANCE_CONSTRAINT
@ SOLDER_PASTE_ABS_MARGIN_CONSTRAINT
@ SOLDER_MASK_EXPANSION_CONSTRAINT
@ TRACK_ANGLE_CONSTRAINT
@ HOLE_SIZE_CONSTRAINT
@ TEXT_HEIGHT_CONSTRAINT
@ PHYSICAL_CLEARANCE_CONSTRAINT
@ SOLDER_PASTE_REL_MARGIN_CONSTRAINT
@ HOLE_TO_HOLE_CONSTRAINT
DRC_RULE_EDITOR_CONSTRAINT_NAME
@ HOLE_ASPECT_RATIO
@ ALLOWED_ORIENTATION
@ SILK_TO_SILK_CLEARANCE
@ ROUTING_DIFF_PAIR
@ SOLDERPASTE_EXPANSION
@ SILK_TO_SOLDERMASK_CLEARANCE
@ VIAS_UNDER_SMD
@ COURTYARD_CLEARANCE
@ MINIMUM_CONNECTION_WIDTH
@ SOLDERMASK_EXPANSION
@ MAXIMUM_VIA_COUNT
@ MINIMUM_ANNULAR_WIDTH
@ PHYSICAL_CLEARANCE
@ CREEPAGE_DISTANCE
@ ABSOLUTE_LENGTH
@ MINIMUM_CLEARANCE
@ MINIMUM_THERMAL_RELIEF_SPOKE_COUNT
@ PERMITTED_LAYERS
@ MICROVIA_STACK_DEPTH
@ MINIMUM_TEXT_HEIGHT_AND_THICKNESS
@ COPPER_TO_HOLE_CLEARANCE
@ HOLE_TO_HOLE_DISTANCE
@ ROUTING_WIDTH
@ MINIMUM_DRILL_SIZE
@ MATCHED_LENGTH_DIFF_PAIR
@ COPPER_TO_EDGE_CLEARANCE
@ MINIMUM_SOLDERMASK_SLIVER
@ MINIMUM_VIA_DIAMETER
DRC_LAYER_CATEGORY
Layer categories for filtering the layer selector dropdown.
@ NO_LAYER_SELECTOR
Hide layer selector entirely.
@ TOP_BOTTOM_ANY
Simplified top/bottom/any selector with custom translation.
@ SOLDERMASK_ONLY
F_Mask, B_Mask.
@ GENERAL_ANY_LAYER
All layers + inner/outer synthetic.
@ SOLDERPASTE_ONLY
F_Paste, B_Paste.
@ COPPER_ONLY
Copper layers + inner/outer synthetic.
@ SILKSCREEN_ONLY
F_SilkS, B_SilkS.
static wxString GetConstraintCodeFromType(DRC_CONSTRAINT_T aType)
std::unordered_map< DRC_RULE_EDITOR_CONSTRAINT_NAME, const char * > CODE_MAP
static void RegisterDefaultConverters()
static const CODE_MAP sCodeMap
static const REVERSE_CODE_MAP sCodeReverse
std::unordered_map< wxString, DRC_RULE_EDITOR_CONSTRAINT_NAME, wxStringHash, wxStringEqual > REVERSE_CODE_MAP
static std::vector< DRC_RULE_EDITOR_UTILS::RuleConverter > & GetRuleConverters()
#define _(s)
PCB_LAYER_ID
A quick note on layer IDs:
Definition layer_ids.h:56
@ F_CrtYd
Definition layer_ids.h:112
@ B_Cu
Definition layer_ids.h:61
@ F_SilkS
Definition layer_ids.h:96
@ B_CrtYd
Definition layer_ids.h:111
@ B_SilkS
Definition layer_ids.h:97
@ F_Cu
Definition layer_ids.h:60
bool AtomicWriteFile(const wxString &aTargetPath, const void *aData, size_t aSize, wxString *aError=nullptr)
Writes aData to aTargetPath via a sibling temp file, fsyncs the data and directory,...
Result of a validation operation.
void AddError(const wxString &aError)
JSON_SCHEMA_VALIDATOR validator(schema)