drc_rule_editor_utils.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#include "drc_rule_editor_utils.h"
#include "drc_re_numeric_constraint_types.h"
#include <kiplatform/io.h>
#include <reporter.h>
#include <component_classes/component_class_assignment_rule.h>
#include <drc/drc_rule_parser.h>
#include <drc_rules_lexer.h>
#include <drc/drc_rule.h>
#include <drc/drc_rule_condition.h>
#include "drc_re_validator_numeric_ctrl.h"
#include "drc_re_validator_min_max_ctrl.h"
#include "drc_re_validator_min_preferred_max_ctrl.h"
#include "drc_re_validator_checkbox_list.h"
#include "drc_re_validator_combo_ctrl.h"
#include "drc_re_custom_rule_constraint_data.h"
#include "drc_re_via_style_constraint_data.h"
#include "drc_re_routing_width_constraint_data.h"
#include "drc_re_numeric_input_constraint_data.h"
#include "drc_re_bool_input_constraint_data.h"
#include <board.h>
#include <wx/ffile.h>
#include <wx/regex.h>
#include <unordered_map>
 
using CODE_MAP = std::unordered_map<DRC_RULE_EDITOR_CONSTRAINT_NAME, const char*>;
using REVERSE_CODE_MAP = std::unordered_map<wxString, DRC_RULE_EDITOR_CONSTRAINT_NAME, wxStringHash, wxStringEqual>;
 
static const CODE_MAP sCodeMap = { { MINIMUM_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_clearance ) },
                                   { CREEPAGE_DISTANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_creepage ) },
                                   { MINIMUM_CONNECTION_WIDTH, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_connection_width ) },
                                   { COPPER_TO_HOLE_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_clearance ) },
                                   { MINIMUM_THERMAL_RELIEF_SPOKE_COUNT, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_min_resolved_spokes ) },
                                   { MINIMUM_ANNULAR_WIDTH, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_annular_width ) },
                                   { COPPER_TO_EDGE_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_edge_clearance ) },
                                   { COURTYARD_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_courtyard_clearance ) },
                                   { PHYSICAL_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_physical_clearance ) },
                                   { MINIMUM_DRILL_SIZE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_size ) },
                                   { HOLE_SIZE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_size ) },
                                   { HOLE_TO_HOLE_DISTANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_to_hole ) },
                                   { MINIMUM_VIA_DIAMETER, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_via_diameter ) },
                                   { VIA_STYLE, "via_style" },
                                   { MINIMUM_TEXT_HEIGHT_AND_THICKNESS, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_text_height ) },
                                   { SILK_TO_SILK_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_silk_clearance ) },
                                   { SILK_TO_SOLDERMASK_CLEARANCE, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_silk_clearance ) },
                                   { MINIMUM_SOLDERMASK_SLIVER, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_mask_sliver ) },
                                   { SOLDERMASK_EXPANSION, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_mask_expansion ) },
                                   { SOLDERPASTE_EXPANSION, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_paste_abs_margin ) },
                                   { MATCHED_LENGTH_DIFF_PAIR, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_length ) },
                                   { ROUTING_DIFF_PAIR, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_diff_pair_gap ) },
                                   { ROUTING_WIDTH, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_track_width ) },
                                   { MAXIMUM_VIA_COUNT, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_via_count ) },
                                   { ABSOLUTE_LENGTH, DRC_RULES_LEXER::TokenName( DRCRULE_T::T_length ) },
                                   { PERMITTED_LAYERS, "permitted_layers" },
                                   { ALLOWED_ORIENTATION, "allowed_orientation" },
                                   { VIAS_UNDER_SMD, "disallow_via" } };
 
static const REVERSE_CODE_MAP sCodeReverse = []
{
    REVERSE_CODE_MAP map;
    for( const auto& [type, code] : sCodeMap )
        map.emplace( wxString::FromUTF8( code ), type );
    return map;
}();
 
static std::vector<DRC_RULE_EDITOR_UTILS::RuleConverter>& GetRuleConverters()
{
    static std::vector<DRC_RULE_EDITOR_UTILS::RuleConverter> converters;
    return converters;
}
 
void DRC_RULE_EDITOR_UTILS::RegisterRuleConverter( RuleConverter aConverter )
{
    GetRuleConverters().insert( GetRuleConverters().begin(), aConverter );
}
 
static wxString GetConstraintCodeFromType( DRC_CONSTRAINT_T aType )
{
    switch( aType )                                                                                                   
    {
    case CLEARANCE_CONSTRAINT:               return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_clearance );             
    case EDGE_CLEARANCE_CONSTRAINT:          return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_edge_clearance );
    case HOLE_CLEARANCE_CONSTRAINT:          return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_clearance );
    case HOLE_TO_HOLE_CONSTRAINT:            return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_to_hole );
    case HOLE_SIZE_CONSTRAINT:               return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_hole_size );
    case TRACK_WIDTH_CONSTRAINT:             return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_track_width );
    case ANNULAR_WIDTH_CONSTRAINT:           return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_annular_width );
    case VIA_DIAMETER_CONSTRAINT:            return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_via_diameter );
    case DISALLOW_CONSTRAINT:                return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_disallow );
    case COURTYARD_CLEARANCE_CONSTRAINT:     return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_courtyard_clearance );
    case SILK_CLEARANCE_CONSTRAINT:          return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_silk_clearance );
    case TEXT_HEIGHT_CONSTRAINT:             return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_text_height );
    case TEXT_THICKNESS_CONSTRAINT:          return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_text_thickness );
    case TRACK_ANGLE_CONSTRAINT:             return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_track_angle );
    case TRACK_SEGMENT_LENGTH_CONSTRAINT:    return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_track_segment_length );
    case CONNECTION_WIDTH_CONSTRAINT:        return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_connection_width );
    case VIA_DANGLING_CONSTRAINT:            return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_via_dangling );
    case ZONE_CONNECTION_CONSTRAINT:         return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_zone_connection );
    case THERMAL_RELIEF_GAP_CONSTRAINT:      return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_thermal_relief_gap );
    case THERMAL_SPOKE_WIDTH_CONSTRAINT:     return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_thermal_spoke_width );
    case MIN_RESOLVED_SPOKES_CONSTRAINT:     return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_min_resolved_spokes );
    case SOLDER_MASK_EXPANSION_CONSTRAINT:   return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_mask_expansion );
    case SOLDER_PASTE_ABS_MARGIN_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_paste_abs_margin );
    case SOLDER_PASTE_REL_MARGIN_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_paste_rel_margin );
    case LENGTH_CONSTRAINT:                  return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_length );
    case SKEW_CONSTRAINT:                    return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_skew );
    case VIA_COUNT_CONSTRAINT:               return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_via_count );
    case DIFF_PAIR_GAP_CONSTRAINT:           return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_diff_pair_gap );
    case MAX_UNCOUPLED_CONSTRAINT:           return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_diff_pair_uncoupled );
    case PHYSICAL_CLEARANCE_CONSTRAINT:      return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_physical_clearance );
    case PHYSICAL_HOLE_CLEARANCE_CONSTRAINT: return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_physical_hole_clearance );
    case BRIDGED_MASK_CONSTRAINT:            return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_bridged_mask );
    case SOLDER_MASK_SLIVER_CONSTRAINT:      return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_solder_mask_sliver );
    case ASSERTION_CONSTRAINT:               return DRC_RULES_LEXER::TokenName( DRCRULE_T::T_assertion );
    default:                                 return "";
    }
}
 
static void RegisterDefaultConverters()
{
    static bool initialized = false;
    if( initialized )
        return;
    initialized = true;
 
    // Generic Converter
    DRC_RULE_EDITOR_UTILS::RegisterRuleConverter(
        []( const std::shared_ptr<DRC_RULE>& aRule ) -> std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>
        {
            if( aRule->m_Constraints.empty() ) return nullptr;
 
            const auto& constraint = aRule->m_Constraints[0];
            wxString code = GetConstraintCodeFromType( constraint.m_Type );
 
            if( code.IsEmpty() ) return nullptr;
 
            if( sCodeReverse.count( code ) )
            {
                auto type = sCodeReverse.at( code );
 
                if( DRC_RULE_EDITOR_UTILS::IsNumericInputType( type ) )
                {
                    double val = constraint.GetValue().Min() / 1000000.0;
                    auto data = DRC_RULE_EDITOR_UTILS::CreateNumericConstraintData( type );
                    data->SetRuleName( aRule->m_Name );
                    data->SetNumericInputValue( val );
                    data->SetConstraintCode( code );
                    return data;
                }
                else if( DRC_RULE_EDITOR_UTILS::IsBoolInputType( type ) )
                {
                    auto data = std::make_shared<DRC_RE_BOOL_INPUT_CONSTRAINT_DATA>( 0, 0, true, aRule->m_Name );
                    data->SetConstraintCode( code );
                    return data;
                }
                else if( code == "track_width" )
                {
                    double minW = constraint.GetValue().Min() / 1000000.0;
                    double optW = constraint.GetValue().Opt() / 1000000.0;
                    double maxW = constraint.GetValue().Max() / 1000000.0;
 
                    double tol = 0;
                    if( optW > 0 )
                        tol = std::max( optW - minW, maxW - optW );
 
                    auto data =
                            std::make_shared<DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA>( 0, 0, aRule->m_Name, optW, tol );
                    data->SetConstraintCode( code );
                    return data;
                }
            }
            return nullptr;
        } );
 
    // Via Style Converter
    DRC_RULE_EDITOR_UTILS::RegisterRuleConverter(
        []( const std::shared_ptr<DRC_RULE>& aRule ) -> std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>
        {
            auto diaConstraint = aRule->FindConstraint( VIA_DIAMETER_CONSTRAINT );
            auto holeConstraint = aRule->FindConstraint( HOLE_SIZE_CONSTRAINT );
 
            if( diaConstraint && holeConstraint )
            {
                double minDia = diaConstraint->GetValue().Min() / 1000000.0;
                double maxDia = diaConstraint->GetValue().Max() / 1000000.0;
 
                double minDrill = holeConstraint->GetValue().Min() / 1000000.0;
                double maxDrill = holeConstraint->GetValue().Max() / 1000000.0;
 
                VIA_STYLE_TYPE viaType = VIA_STYLE_TYPE::ANY;
 
                if( aRule->m_Condition )
                {
                    wxString expr = aRule->m_Condition->GetExpression();
 
                    if( expr.Contains( wxS( "'Micro'" ) ) )
                        viaType = VIA_STYLE_TYPE::MICRO;
                    else if( expr.Contains( wxS( "'Through'" ) ) )
                        viaType = VIA_STYLE_TYPE::THROUGH;
                    else if( expr.Contains( wxS( "'Blind'" ) ) )
                        viaType = VIA_STYLE_TYPE::BLIND;
                    else if( expr.Contains( wxS( "'Buried'" ) ) )
                        viaType = VIA_STYLE_TYPE::BURIED;
                }
 
                auto data = std::make_shared<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>( 0, 0, aRule->m_Name, minDia, maxDia,
                                                                                minDrill, maxDrill, viaType );
                data->SetConstraintCode( "via_style" );
                return data;
            }
            return nullptr;
        } );
}
 
 
wxString DRC_RULE_EDITOR_UTILS::GetConstraintCode( DRC_RULE_EDITOR_CONSTRAINT_NAME aConstraintType )
{
    auto it = sCodeMap.find( aConstraintType );
    if( it != sCodeMap.end() )
        return wxString::FromUTF8( it->second );
 
    return wxString();
}
 
 
std::optional<DRC_RULE_EDITOR_CONSTRAINT_NAME> DRC_RULE_EDITOR_UTILS::GetConstraintTypeFromCode( const wxString& aCode )
{
    auto it = sCodeReverse.find( aCode );
    if( it != sCodeReverse.end() )
        return it->second;
 
    return std::nullopt;
}
 
 
wxString DRC_RULE_EDITOR_UTILS::ConstraintToKicadDrc( DRC_RULE_EDITOR_CONSTRAINT_NAME aType )
{
    return GetConstraintCode( aType );
}
 
 
bool DRC_RULE_EDITOR_UTILS::ConstraintFromKicadDrc( const wxString& aCode, DRC_RE_BASE_CONSTRAINT_DATA* aData )
{
    if( !aData )
        return false;
 
    auto type = GetConstraintTypeFromCode( aCode );
    if( type )
    {
        aData->SetConstraintCode( GetConstraintCode( *type ) );
        return true;
    }
 
    aData->SetConstraintCode( aCode );
    return false;
}
 
 
bool DRC_RULE_EDITOR_UTILS::IsBoolInputType( const DRC_RULE_EDITOR_CONSTRAINT_NAME& aConstraintType )
{
    switch( aConstraintType )
    {
    default: return false;
    }
}
 
 
bool DRC_RULE_EDITOR_UTILS::IsNumericInputType( const DRC_RULE_EDITOR_CONSTRAINT_NAME& aConstraintType )
{
    switch( aConstraintType )
    {
    case COPPER_TO_EDGE_CLEARANCE:
    case COPPER_TO_HOLE_CLEARANCE:
    case COURTYARD_CLEARANCE:
    case PHYSICAL_CLEARANCE:
    case CREEPAGE_DISTANCE:
    case HOLE_SIZE:
    case HOLE_TO_HOLE_DISTANCE:
    case MATCHED_LENGTH_DIFF_PAIR:
    case MAXIMUM_VIA_COUNT:
    case MINIMUM_ANNULAR_WIDTH:
    case MINIMUM_CLEARANCE:
    case MINIMUM_CONNECTION_WIDTH:
    case MINIMUM_SOLDERMASK_SLIVER:
    case MINIMUM_THERMAL_RELIEF_SPOKE_COUNT:
    case MINIMUM_DRILL_SIZE:
    case MINIMUM_VIA_DIAMETER:
    case SILK_TO_SILK_CLEARANCE:
    case SILK_TO_SOLDERMASK_CLEARANCE:
    case SOLDERMASK_EXPANSION:
    case SOLDERPASTE_EXPANSION:
        return true;
    default:
        return false;
    }
}
 
 
bool DRC_RULE_EDITOR_UTILS::ValidateNumericCtrl( wxTextCtrl* aTextCtrl, const wxString& aLabel, bool aCanBeZero,
                                                 int* aErrorCount, wxString* aValidationMessage )
{
    VALIDATOR_NUMERIC_CTRL validator( aCanBeZero );
    aTextCtrl->SetValidator( validator );
 
    if( !aTextCtrl->Validate() )
    {
        VALIDATOR_NUMERIC_CTRL* v = static_cast<VALIDATOR_NUMERIC_CTRL*>( aTextCtrl->GetValidator() );
 
        switch( v->GetValidationState() )
        {
        case VALIDATOR_NUMERIC_CTRL::VALIDATION_STATE::Empty:
        {
            ( *aErrorCount )++;
            *aValidationMessage +=
                    DRC_RULE_EDITOR_UTILS::FormatErrorMessage( *aErrorCount,
                            wxString::Format( _( "%s should not be empty." ), aLabel ) );
            return false;
        }
        case VALIDATOR_NUMERIC_CTRL::VALIDATION_STATE::NotNumeric:
        {
            ( *aErrorCount )++;
            *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
                    *aErrorCount, wxString::Format( _( "The value of %s must be a valid number." ), aLabel ) );
            return false;
        }
        case VALIDATOR_NUMERIC_CTRL::VALIDATION_STATE::NotGreaterThanZero:
        {
            ( *aErrorCount )++;
            *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
                    *aErrorCount, wxString::Format( _( "The value of %s must be greater than 0." ), aLabel ) );
            return false;
        }
        default: break;
        }
    }
 
    return true;
}
 
 
bool DRC_RULE_EDITOR_UTILS::ValidateIntegerCtrl( wxTextCtrl* aTextCtrl, const wxString& aLabel, bool aCanBeZero,
                                                 int* aErrorCount, wxString* aValidationMessage )
{
    VALIDATOR_NUMERIC_CTRL validator( aCanBeZero, true );
    aTextCtrl->SetValidator( validator );
 
    if( !aTextCtrl->Validate() )
    {
        VALIDATOR_NUMERIC_CTRL* v = static_cast<VALIDATOR_NUMERIC_CTRL*>( aTextCtrl->GetValidator() );
 
        switch( v->GetValidationState() )
        {
        case VALIDATOR_NUMERIC_CTRL::VALIDATION_STATE::Empty:
        {
            ( *aErrorCount )++;
            *aValidationMessage +=
                    DRC_RULE_EDITOR_UTILS::FormatErrorMessage( *aErrorCount,
                            wxString::Format( _( "%s should not be empty." ), aLabel ) );
            return false;
        }
        case VALIDATOR_NUMERIC_CTRL::VALIDATION_STATE::NotInteger:
        {
            ( *aErrorCount )++;
            *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
                    *aErrorCount, wxString::Format( _( "The value of %s must be a valid integer." ), aLabel ) );
            return false;
        }
        case VALIDATOR_NUMERIC_CTRL::VALIDATION_STATE::NotGreaterThanZero:
        {
            ( *aErrorCount )++;
            *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
                    *aErrorCount, wxString::Format( _( "The value of %s must be greater than 0." ), aLabel ) );
            return false;
        }
        default: break;
        }
    }
 
    return true;
}
 
 
bool DRC_RULE_EDITOR_UTILS::ValidateComboCtrl( wxComboBox* aComboBox, const wxString& aLabel, int* aErrorCount,
                                               wxString* aValidationMessage )
{
    VALIDATOR_COMBO_CTRL cmbCtrlValidator;
    aComboBox->SetValidator( cmbCtrlValidator );
 
    if( !aComboBox->Validate() )
    {
        VALIDATOR_COMBO_CTRL* v = static_cast<VALIDATOR_COMBO_CTRL*>( aComboBox->GetValidator() );
 
        switch( v->GetValidationState() )
        {
        case VALIDATOR_COMBO_CTRL::VALIDATION_STATE::NothingSelected:
        {
            ( *aErrorCount )++;
            *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage( *aErrorCount,
                    wxString::Format( _( "Please choose %s." ), aLabel ) );
            return false;
        }
        default: break;
        }
    }
 
    return true;
}
 
 
bool DRC_RULE_EDITOR_UTILS::ValidateMinMaxCtrl( wxTextCtrl* aMinTextCtrl, wxTextCtrl* aMaxTextCtrl,
                                                const wxString& aMinLabel, const wxString& aMaxLabel,
                                                int* aErrorCount, wxString* aValidationMessage )
{
    aMinTextCtrl->SetName( "min" );
    aMaxTextCtrl->SetName( "max" );
 
    aMinTextCtrl->SetValidator( VALIDATE_MIN_MAX_CTRL( aMinTextCtrl, aMaxTextCtrl ) );
 
    if( !aMinTextCtrl->Validate() )
    {
        VALIDATE_MIN_MAX_CTRL* v = static_cast<VALIDATE_MIN_MAX_CTRL*>( aMinTextCtrl->GetValidator() );
 
        switch( v->GetValidationState() )
        {
        case VALIDATE_MIN_MAX_CTRL::VALIDATION_STATE::MinGreaterThanMax:
        {
            ( *aErrorCount )++;
            *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
                    *aErrorCount, wxString::Format( _( "%s value cannot be greater than %s value." ),
                                                    aMinLabel, aMaxLabel ) );
            return false;
        }
        default: break;
        }
    }
 
    aMinTextCtrl->SetName( "text" );
    aMaxTextCtrl->SetName( "text" );
 
    return true;
}
 
 
bool DRC_RULE_EDITOR_UTILS::ValidateMinPreferredMaxCtrl( wxTextCtrl* aMinTextCtrl, wxTextCtrl* aPreferredTextCtrl,
                                                         wxTextCtrl* aMaxTextCtrl, const wxString& aMinLabel,
                                                         const wxString& aPreferredLabel, const wxString& aMaxLabel,
                                                         int* aErrorCount, wxString* aValidationMessage )
{
    aMinTextCtrl->SetName( "min" );
    aPreferredTextCtrl->SetName( "preferred" );
    aMaxTextCtrl->SetName( "max" );
 
    aMinTextCtrl->SetValidator( VALIDATE_MIN_PREFERRED_MAX_CTRL( aMinTextCtrl, aPreferredTextCtrl, aMaxTextCtrl ) );
 
    if( !aMinTextCtrl->Validate() )
    {
        VALIDATE_MIN_PREFERRED_MAX_CTRL* v =
                static_cast<VALIDATE_MIN_PREFERRED_MAX_CTRL*>( aMinTextCtrl->GetValidator() );
 
        switch( v->GetValidationState() )
        {
        case VALIDATE_MIN_PREFERRED_MAX_CTRL::VALIDATION_STATE::MinGreaterThanPreferred:
        {
            ( *aErrorCount )++;
            *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
                    *aErrorCount, wxString::Format( _( "%s value cannot be greater than %s value." ),
                                                    aMinLabel, aPreferredLabel ) );
            return false;
        }
        case VALIDATE_MIN_PREFERRED_MAX_CTRL::VALIDATION_STATE::PreferredGreaterThanMax:
        {
            ( *aErrorCount )++;
            *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
                    *aErrorCount, wxString::Format( _( "%s value cannot be greater than %s value." ),
                                                    aPreferredLabel, aMaxLabel ) );
            return false;
        }
        case VALIDATE_MIN_PREFERRED_MAX_CTRL::VALIDATION_STATE::MinGreaterThanMax:
        {
            ( *aErrorCount )++;
            *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
                     *aErrorCount, wxString::Format( _( "%s value cannot be greater than %s value." ),
                                                    aMinLabel, aMaxLabel ) );
            return false;
        }
        default: break;
        }
    }
 
    aMinTextCtrl->SetName( "text" );
    aPreferredTextCtrl->SetName( "text" );
    aMaxTextCtrl->SetName( "text" );
 
    return true;
}
 
 
bool DRC_RULE_EDITOR_UTILS::ValidateCheckBoxCtrls( const std::vector<wxCheckBox*>& aCheckboxes, const wxString& aLabel,
                                                   int* aErrorCount, wxString* aValidationMessage )
{
    VALIDATE_CHECKBOX_LIST validator( aCheckboxes );
 
    aCheckboxes[0]->SetValidator( validator );
 
    if( !aCheckboxes[0]->Validate() )
    {
        VALIDATE_CHECKBOX_LIST* v = static_cast<VALIDATE_CHECKBOX_LIST*>( aCheckboxes[0]->GetValidator() );
 
        switch( v->GetValidationState() )
        {
        case VALIDATE_CHECKBOX_LIST::VALIDATION_STATE::NotSelected:
        {
            ( *aErrorCount )++;
            *aValidationMessage += DRC_RULE_EDITOR_UTILS::FormatErrorMessage(
                    *aErrorCount, wxString::Format( _( "Please select at least one option from %s list." ), aLabel ));
            return false;
        }
        default: break;
        }
    }
 
    return true;
}
 
 
wxString DRC_RULE_EDITOR_UTILS::FormatErrorMessage( int aErrorCount, const wxString& aErrorMessage )
{
    return wxString::Format( wxS( "%d. %s\n" ), aErrorCount, aErrorMessage );
}
 
 
// ==================== Pure Validators (No GUI Dependencies) ====================
 
bool DRC_RULE_EDITOR_UTILS::ValidateNumericValue( double aValue, bool aCanBeZero, const wxString& aLabel,
                                                   VALIDATION_RESULT* aResult )
{
    if( !aCanBeZero && aValue <= 0.0 )
    {
        aResult->AddError( wxString::Format( _( "The value of %s must be greater than 0." ), aLabel ) );
        return false;
    }
 
    return true;
}
 
 
bool DRC_RULE_EDITOR_UTILS::ValidateNumericString( const wxString& aValueStr, bool aCanBeZero,
                                                    bool aIntegerOnly, const wxString& aLabel,
                                                    VALIDATION_RESULT* aResult )
{
    if( aValueStr.IsEmpty() )
    {
        aResult->AddError( wxString::Format( _( "%s should not be empty." ), aLabel ) );
        return false;
    }
 
    try
    {
        if( aIntegerOnly )
        {
            std::string stdStr = aValueStr.ToStdString();
            size_t pos;
            long   intVal = std::stol( stdStr, &pos );
 
            if( pos != stdStr.length() )
            {
                aResult->AddError( wxString::Format( _( "The value of %s must be a valid integer." ), aLabel ) );
                return false;
            }
 
            if( !aCanBeZero && intVal <= 0 )
            {
                aResult->AddError( wxString::Format( _( "The value of %s must be greater than 0." ), aLabel ) );
                return false;
            }
        }
        else
        {
            std::string stdStr = aValueStr.ToStdString();
            size_t pos;
            double floatVal = std::stod( stdStr, &pos );
 
            if( pos != stdStr.length() )
            {
                aResult->AddError( wxString::Format( _( "The value of %s must be a valid number." ), aLabel ) );
                return false;
            }
 
            if( !aCanBeZero && floatVal <= 0.0 )
            {
                aResult->AddError( wxString::Format( _( "The value of %s must be greater than 0." ), aLabel ) );
                return false;
            }
        }
    }
    catch( const std::exception& )
    {
        if( aIntegerOnly )
            aResult->AddError( wxString::Format( _( "The value of %s must be a valid integer." ), aLabel ) );
        else
            aResult->AddError( wxString::Format( _( "The value of %s must be a valid number." ), aLabel ) );
 
        return false;
    }
 
    return true;
}
 
 
bool DRC_RULE_EDITOR_UTILS::ValidateMinMax( double aMin, double aMax, const wxString& aMinLabel,
                                             const wxString& aMaxLabel, VALIDATION_RESULT* aResult )
{
    if( aMin > aMax )
    {
        aResult->AddError( wxString::Format( _( "%s value cannot be greater than %s value." ), aMinLabel, aMaxLabel ));
        return false;
    }
 
    return true;
}
 
 
bool DRC_RULE_EDITOR_UTILS::ValidateMinPreferredMax( double aMin, double aPreferred, double aMax,
                                                      const wxString& aMinLabel,
                                                      const wxString& aPrefLabel,
                                                      const wxString& aMaxLabel,
                                                      VALIDATION_RESULT* aResult )
{
    bool valid = true;
 
    if( aMin > aPreferred )
    {
        aResult->AddError( wxString::Format( _( "%s value cannot be greater than %s value." ), aMinLabel, aPrefLabel ));
        valid = false;
    }
 
    if( aPreferred > aMax )
    {
        aResult->AddError( wxString::Format( _( "%s value cannot be greater than %s value." ), aPrefLabel, aMaxLabel ));
        valid = false;
    }
 
    if( aMin > aMax )
    {
        aResult->AddError( wxString::Format( _( "%s value cannot be greater than %s value." ), aMinLabel, aMaxLabel ));
        valid = false;
    }
 
    return valid;
}
 
 
bool DRC_RULE_EDITOR_UTILS::ValidateAtLeastOneSelected( const std::vector<bool>& aSelected,
                                                         const wxString&          aLabel,
                                                         VALIDATION_RESULT*       aResult )
{
    for( bool selected : aSelected )
    {
        if( selected )
            return true;
    }
 
    aResult->AddError( wxString::Format( _( "Please select at least one option from %s list." ), aLabel ) );
    return false;
}
 
 
bool DRC_RULE_EDITOR_UTILS::ValidateSelection( int aSelectionIndex, const wxString& aLabel,
                                                VALIDATION_RESULT* aResult )
{
    if( aSelectionIndex < 0 )
    {
        aResult->AddError( wxString::Format( _( "Please choose %s." ), aLabel ) );
        return false;
    }
 
    return true;
}
 
 
std::vector<std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>> DRC_RULE_EDITOR_UTILS::ParseRules( const wxString& aRules )
{
    RegisterDefaultConverters();
 
    std::vector<std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>> rules;
    std::vector<std::shared_ptr<DRC_RULE>> parsedRules;
 
    wxString rulesText = aRules;
    if( !rulesText.Contains( "(version" ) )
        rulesText.Prepend( "(version 1)\n" );
 
    try
    {
        DRC_RULES_PARSER parser( rulesText, "Rule Editor Source" );
        parser.Parse( parsedRules, nullptr );
    }
    catch( const IO_ERROR& )
    {
    }
 
    for( const auto& rule : parsedRules )
    {
        std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA> data;
 
        for( const auto& converter : GetRuleConverters() )
        {
            data = converter( rule );
            if( data )
                break;
        }
 
        if( !data )
        {
            auto customData = std::make_shared<DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA>( 0, 0, rule->m_Name );
            customData->SetRuleText( wxString::Format( "(rule \"%s\" ...)", rule->m_Name ) );
            data = customData;
        }
 
        if( rule->m_Condition )
            data->SetRuleCondition( rule->m_Condition->GetExpression() );
 
        rules.push_back( data );
    }
 
    return rules;
}
 
bool DRC_RULE_EDITOR_UTILS::SaveRules( const wxString& aFilename,
                                       const std::vector<std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>>& aRules,
                                       const BOARD* aBoard )
{
    wxString content = wxT( "(version 1)\n" );
 
    for( const auto& data : aRules )
    {
        if( !data )
            continue;
 
        RULE_GENERATION_CONTEXT ctx;
        ctx.ruleName = data->GetRuleName();
        ctx.comment = data->GetComment();
        ctx.conditionExpression = data->GetRuleCondition();
        ctx.constraintCode = data->GetConstraintCode();
 
        std::vector<PCB_LAYER_ID> layers = data->GetLayers();
 
        if( !layers.empty() && aBoard )
        {
            wxString layerStr = "(layer";
 
            for( PCB_LAYER_ID layer : layers )
                layerStr += " \"" + aBoard->GetLayerName( layer ) + "\"";
 
            layerStr += ")";
            ctx.layerClause = layerStr;
        }
 
        content += data->GenerateRule( ctx ) + wxT( "\n" );
    }
 
    std::string utf8 = std::string( content.mb_str( wxConvUTF8 ) );
    return KIPLATFORM::IO::AtomicWriteFile( aFilename, utf8.data(), utf8.size() );
}
 
 
// ==================== Layer Filtering ====================
 
DRC_LAYER_CATEGORY DRC_RULE_EDITOR_UTILS::GetLayerCategoryForConstraint(
        DRC_RULE_EDITOR_CONSTRAINT_NAME aConstraintType )
{
    switch( aConstraintType )
    {
    // COPPER_ONLY: Constraints that only apply to copper layers
    case MINIMUM_CLEARANCE:
    case CREEPAGE_DISTANCE:
    case COPPER_TO_HOLE_CLEARANCE:
    case COPPER_TO_EDGE_CLEARANCE:
    case VIA_STYLE:
    case MINIMUM_VIA_DIAMETER:
    case MINIMUM_ANNULAR_WIDTH:
    case MINIMUM_CONNECTION_WIDTH:
    case ROUTING_WIDTH:
    case ROUTING_DIFF_PAIR:
    case MINIMUM_THERMAL_RELIEF_SPOKE_COUNT:
    case MATCHED_LENGTH_DIFF_PAIR:
    case ABSOLUTE_LENGTH:
        return DRC_LAYER_CATEGORY::COPPER_ONLY;
 
    // SILKSCREEN_ONLY: Constraints that only apply to silkscreen layers
    case SILK_TO_SILK_CLEARANCE:
        return DRC_LAYER_CATEGORY::SILKSCREEN_ONLY;
 
    // SOLDERMASK_ONLY: Constraints that only apply to soldermask layers
    case MINIMUM_SOLDERMASK_SLIVER:
    case SOLDERMASK_EXPANSION:
        return DRC_LAYER_CATEGORY::SOLDERMASK_ONLY;
 
    // SOLDERPASTE_ONLY: Constraints that only apply to solderpaste layers
    case SOLDERPASTE_EXPANSION:
        return DRC_LAYER_CATEGORY::SOLDERPASTE_ONLY;
 
    // TOP_BOTTOM_ANY: Constraints with simplified top/bottom/any selection
    case COURTYARD_CLEARANCE:
    case SILK_TO_SOLDERMASK_CLEARANCE:
    case VIAS_UNDER_SMD:
    case ALLOWED_ORIENTATION:
        return DRC_LAYER_CATEGORY::TOP_BOTTOM_ANY;
 
    // GENERAL_ANY_LAYER: Constraints that can apply to any layer type
    case PHYSICAL_CLEARANCE:
    case HOLE_SIZE:
    case HOLE_TO_HOLE_DISTANCE:
    case MINIMUM_DRILL_SIZE:
    case MINIMUM_TEXT_HEIGHT_AND_THICKNESS:
        return DRC_LAYER_CATEGORY::GENERAL_ANY_LAYER;
 
    // NO_LAYER_SELECTOR: Constraints where layer selection doesn't apply
    case MAXIMUM_VIA_COUNT:
    case PERMITTED_LAYERS:
    case CUSTOM_RULE:
        return DRC_LAYER_CATEGORY::NO_LAYER_SELECTOR;
 
    default:
        return DRC_LAYER_CATEGORY::GENERAL_ANY_LAYER;
    }
}
 
 
wxString DRC_RULE_EDITOR_UTILS::TranslateTopBottomLayer( DRC_RULE_EDITOR_CONSTRAINT_NAME aConstraintType,
                                                         bool aIsTop )
{
    switch( aConstraintType )
    {
    case COURTYARD_CLEARANCE:
        return wxString::Format( wxS( "(layer \"%s\")" ),
                                 aIsTop ? wxS( "F.CrtYd" ) : wxS( "B.CrtYd" ) );
 
    case SILK_TO_SOLDERMASK_CLEARANCE:
        // Generates a condition to match silk on one side with mask on the same side
        return wxString::Format( wxS( "(condition \"A.Layer == '%s' && B.Layer == '%s'\")" ),
                                 aIsTop ? wxS( "F.SilkS" ) : wxS( "B.SilkS" ),
                                 aIsTop ? wxS( "F.Mask" ) : wxS( "B.Mask" ) );
 
    case VIAS_UNDER_SMD:
    case ALLOWED_ORIENTATION:
        return wxString::Format( wxS( "(layer \"%s\")" ), aIsTop ? wxS( "F.Cu" ) : wxS( "B.Cu" ) );
 
    default:
        return wxEmptyString;
    }
}
 
 
std::shared_ptr<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>
DRC_RULE_EDITOR_UTILS::CreateNumericConstraintData( DRC_RULE_EDITOR_CONSTRAINT_NAME aType )
{
    switch( aType )
    {
    case COPPER_TO_EDGE_CLEARANCE:           return std::make_shared<DRC_RE_COPPER_TO_EDGE_CLEARANCE_CONSTRAINT_DATA>();
    case COPPER_TO_HOLE_CLEARANCE:           return std::make_shared<DRC_RE_COPPER_TO_HOLE_CLEARANCE_CONSTRAINT_DATA>();
    case COURTYARD_CLEARANCE:                return std::make_shared<DRC_RE_COURTYARD_CLEARANCE_CONSTRAINT_DATA>();
    case PHYSICAL_CLEARANCE:                 return std::make_shared<DRC_RE_PHYSICAL_CLEARANCE_CONSTRAINT_DATA>();
    case CREEPAGE_DISTANCE:                  return std::make_shared<DRC_RE_CREEPAGE_DISTANCE_CONSTRAINT_DATA>();
    case HOLE_SIZE:                          return std::make_shared<DRC_RE_HOLE_SIZE_CONSTRAINT_DATA>();
    case HOLE_TO_HOLE_DISTANCE:              return std::make_shared<DRC_RE_HOLE_TO_HOLE_DISTANCE_CONSTRAINT_DATA>();
    case MAXIMUM_VIA_COUNT:                  return std::make_shared<DRC_RE_MAXIMUM_VIA_COUNT_CONSTRAINT_DATA>();
    case MINIMUM_ANNULAR_WIDTH:              return std::make_shared<DRC_RE_MINIMUM_ANNULAR_WIDTH_CONSTRAINT_DATA>();
    case MINIMUM_CLEARANCE:                  return std::make_shared<DRC_RE_MINIMUM_CLEARANCE_CONSTRAINT_DATA>();
    case MINIMUM_CONNECTION_WIDTH:           return std::make_shared<DRC_RE_MINIMUM_CONNECTION_WIDTH_CONSTRAINT_DATA>();
    case MINIMUM_SOLDERMASK_SLIVER:          return std::make_shared<DRC_RE_MINIMUM_SOLDERMASK_SLIVER_CONSTRAINT_DATA>();
    case MINIMUM_THERMAL_RELIEF_SPOKE_COUNT: return std::make_shared<DRC_RE_MINIMUM_THERMAL_SPOKE_COUNT_CONSTRAINT_DATA>();
    case MINIMUM_DRILL_SIZE:                 return std::make_shared<DRC_RE_MINIMUM_DRILL_SIZE_CONSTRAINT_DATA>();
    case MINIMUM_VIA_DIAMETER:               return std::make_shared<DRC_RE_MINIMUM_VIA_DIAMETER_CONSTRAINT_DATA>();
    case SILK_TO_SILK_CLEARANCE:             return std::make_shared<DRC_RE_SILK_TO_SILK_CLEARANCE_CONSTRAINT_DATA>();
    case SILK_TO_SOLDERMASK_CLEARANCE:       return std::make_shared<DRC_RE_SILK_TO_SOLDERMASK_CLEARANCE_CONSTRAINT_DATA>();
    case SOLDERMASK_EXPANSION:               return std::make_shared<DRC_RE_SOLDERMASK_EXPANSION_CONSTRAINT_DATA>();
    case SOLDERPASTE_EXPANSION:              return std::make_shared<DRC_RE_SOLDERPASTE_EXPANSION_CONSTRAINT_DATA>();
    default:                                 return std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>();
    }
}
 
 
std::shared_ptr<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>
DRC_RULE_EDITOR_UTILS::CreateNumericConstraintData( DRC_RULE_EDITOR_CONSTRAINT_NAME aType,
                                                    const DRC_RE_BASE_CONSTRAINT_DATA& aBase )
{
    switch( aType )
    {
    case COPPER_TO_EDGE_CLEARANCE:           return std::make_shared<DRC_RE_COPPER_TO_EDGE_CLEARANCE_CONSTRAINT_DATA>( aBase );
    case COPPER_TO_HOLE_CLEARANCE:           return std::make_shared<DRC_RE_COPPER_TO_HOLE_CLEARANCE_CONSTRAINT_DATA>( aBase );
    case COURTYARD_CLEARANCE:                return std::make_shared<DRC_RE_COURTYARD_CLEARANCE_CONSTRAINT_DATA>( aBase );
    case PHYSICAL_CLEARANCE:                 return std::make_shared<DRC_RE_PHYSICAL_CLEARANCE_CONSTRAINT_DATA>( aBase );
    case CREEPAGE_DISTANCE:                  return std::make_shared<DRC_RE_CREEPAGE_DISTANCE_CONSTRAINT_DATA>( aBase );
    case HOLE_SIZE:                          return std::make_shared<DRC_RE_HOLE_SIZE_CONSTRAINT_DATA>( aBase );
    case HOLE_TO_HOLE_DISTANCE:              return std::make_shared<DRC_RE_HOLE_TO_HOLE_DISTANCE_CONSTRAINT_DATA>( aBase );
    case MAXIMUM_VIA_COUNT:                  return std::make_shared<DRC_RE_MAXIMUM_VIA_COUNT_CONSTRAINT_DATA>( aBase );
    case MINIMUM_ANNULAR_WIDTH:              return std::make_shared<DRC_RE_MINIMUM_ANNULAR_WIDTH_CONSTRAINT_DATA>( aBase );
    case MINIMUM_CLEARANCE:                  return std::make_shared<DRC_RE_MINIMUM_CLEARANCE_CONSTRAINT_DATA>( aBase );
    case MINIMUM_CONNECTION_WIDTH:           return std::make_shared<DRC_RE_MINIMUM_CONNECTION_WIDTH_CONSTRAINT_DATA>( aBase );
    case MINIMUM_SOLDERMASK_SLIVER:          return std::make_shared<DRC_RE_MINIMUM_SOLDERMASK_SLIVER_CONSTRAINT_DATA>( aBase );
    case MINIMUM_THERMAL_RELIEF_SPOKE_COUNT: return std::make_shared<DRC_RE_MINIMUM_THERMAL_SPOKE_COUNT_CONSTRAINT_DATA>( aBase );
    case MINIMUM_DRILL_SIZE:                 return std::make_shared<DRC_RE_MINIMUM_DRILL_SIZE_CONSTRAINT_DATA>( aBase );
    case MINIMUM_VIA_DIAMETER:               return std::make_shared<DRC_RE_MINIMUM_VIA_DIAMETER_CONSTRAINT_DATA>( aBase );
    case SILK_TO_SILK_CLEARANCE:             return std::make_shared<DRC_RE_SILK_TO_SILK_CLEARANCE_CONSTRAINT_DATA>( aBase );
    case SILK_TO_SOLDERMASK_CLEARANCE:       return std::make_shared<DRC_RE_SILK_TO_SOLDERMASK_CLEARANCE_CONSTRAINT_DATA>( aBase );
    case SOLDERMASK_EXPANSION:               return std::make_shared<DRC_RE_SOLDERMASK_EXPANSION_CONSTRAINT_DATA>( aBase );
    case SOLDERPASTE_EXPANSION:              return std::make_shared<DRC_RE_SOLDERPASTE_EXPANSION_CONSTRAINT_DATA>( aBase );
    default:                                 return std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( aBase );
    }
}