pad.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2018 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * Copyright The 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, see <https://www.gnu.org/licenses/>.
 */
 
#include <base_units.h>
#include <api/api_pcb_utils.h>
#include <bitmaps.h>
#include <math/util.h>      // for KiROUND
#include <eda_draw_frame.h>
#include <geometry/shape_circle.h>
#include <geometry/shape_segment.h>
#include <geometry/shape_simple.h>
#include <geometry/shape_rect.h>
#include <geometry/shape_compound.h>
#include <geometry/shape_null.h>
#include <geometry/geometry_utils.h>
#include <layer_range.h>
#include <string_utils.h>
#include <i18n_utility.h>
#include <view/view.h>
#include <board.h>
#include <board_connected_item.h>
#include <board_design_settings.h>
#include <footprint.h>
#include <lset.h>
#include <pad.h>
#include <pad_utils.h>
#include <pcb_shape.h>
#include <connectivity/connectivity_data.h>
#include <drc/drc_engine.h>
#include <eda_units.h>
#include <convert_basic_shapes_to_polygon.h>
#include <widgets/msgpanel.h>
#include <pcb_painter.h>
#include <properties/property_validators.h>
#include <properties/property.h>
#include <properties/property_mgr.h>
#include <wx/log.h>
#include <api/api_enums.h>
#include <api/api_utils.h>
#include <api/api_pcb_utils.h>
#include <api/board/board_types.pb.h>
 
#include <memory>
#include <macros.h>
#include <magic_enum.hpp>
#include "kiface_base.h"
#include "pcbnew_settings.h"
 
#include <pcb_group.h>
#include <gal/graphics_abstraction_layer.h>
#include <pin_type.h>
 
using KIGFX::PCB_PAINTER;
using KIGFX::PCB_RENDER_SETTINGS;
 
 
PAD::PAD( FOOTPRINT* parent ) :
        BOARD_CONNECTED_ITEM( parent, PCB_PAD_T ),
        m_libOrientation( ANGLE_0 ),
        m_padStack( this )
{
    VECTOR2I& drill = m_padStack.Drill().size;
    m_padStack.SetSize( { EDA_UNIT_UTILS::Mils2IU( pcbIUScale, 60 ), EDA_UNIT_UTILS::Mils2IU( pcbIUScale, 60 ) },
                        PADSTACK::ALL_LAYERS );
    drill.x = drill.y = EDA_UNIT_UTILS::Mils2IU( pcbIUScale, 30 );       // Default drill size 30 mils.
    m_lengthPadToDie = 0;
    m_delayPadToDie = 0;
 
    SetShape( F_Cu, PAD_SHAPE::CIRCLE );          // Default pad shape is PAD_CIRCLE.
    SetAnchorPadShape( F_Cu, PAD_SHAPE::CIRCLE ); // Default anchor shape for custom shaped pads is PAD_CIRCLE.
    SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );     // Default pad drill shape is a circle.
    m_attribute = PAD_ATTRIB::PTH;                // Default pad type is plated through hole
    SetProperty( PAD_PROP::NONE );                // no special fabrication property
 
    // Parameters for round rect only:
    m_padStack.SetRoundRectRadiusRatio( 0.25, F_Cu );  // from IPC-7351C standard
 
    // Parameters for chamfered rect only:
    m_padStack.SetChamferRatio( 0.2, F_Cu );
    m_padStack.SetChamferPositions( RECT_NO_CHAMFER, F_Cu );
 
    // Set layers mask to default for a standard thru hole pad.
    m_padStack.SetLayerSet( PTHMask() );
 
    SetSubRatsnest( 0 );                       // used in ratsnest calculations
 
    SetDirty();
    m_effectiveBoundingRadius = 0;
 
    for( PCB_LAYER_ID layer : LAYER_RANGE( F_Cu, B_Cu, BoardCopperLayerCount() ) )
        m_zoneLayerOverrides[layer] = ZLO_NONE;
 
}
 
 
PAD::PAD( const PAD& aOther ) :
        BOARD_CONNECTED_ITEM( aOther.GetParent(), PCB_PAD_T ),
        m_libOrientation( ANGLE_0 ),
        m_padStack( this )
{
    PAD::operator=( aOther );
 
    SetUuidDirect( aOther.m_Uuid );
}
 
 
namespace
{
 
static int scaleLength( int aLength, double aFactor )
{
    return KiROUND( aLength * aFactor );
}
 

static void scaleInChildFrame( double aSx, double aSy, const EDA_ANGLE& aRelOrient, double& aLocalSx, double& aLocalSy )
{
    const double c = aRelOrient.Cos();
    const double s = aRelOrient.Sin();
    aLocalSx = aSx * c * c + aSy * s * s;
    aLocalSy = aSx * s * s + aSy * c * c;
}
 

static VECTOR2I derivePadBoardSize( const VECTOR2I& aLibSize, PAD_SHAPE aShape, const TRANSFORM_TRS& aXform,
                                    const EDA_ANGLE& aRelOrient )
{
    const double sx = std::abs( aXform.GetScaleX() );
    const double sy = std::abs( aXform.GetScaleY() );
 
    if( aShape == PAD_SHAPE::CIRCLE )
    {
        const double uniform = ( sx + sy ) * 0.5;
        return { scaleLength( aLibSize.x, uniform ), scaleLength( aLibSize.y, uniform ) };
    }
 
    // Size is in the pad frame, so conjugate the footprint scale by the pad orientation.
    double localSx, localSy;
    scaleInChildFrame( sx, sy, aRelOrient, localSx, localSy );
    return { scaleLength( aLibSize.x, localSx ), scaleLength( aLibSize.y, localSy ) };
}
 

static VECTOR2I derivePadLibSize( const VECTOR2I& aBoardSize, PAD_SHAPE aShape, const TRANSFORM_TRS& aXform,
                                  const EDA_ANGLE& aRelOrient )
{
    const double sx = std::abs( aXform.GetScaleX() );
    const double sy = std::abs( aXform.GetScaleY() );
 
    if( aShape == PAD_SHAPE::CIRCLE )
    {
        const double uniform = ( sx + sy ) * 0.5;
        return { scaleLength( aBoardSize.x, 1.0 / uniform ), scaleLength( aBoardSize.y, 1.0 / uniform ) };
    }
 
    double localSx, localSy;
    scaleInChildFrame( sx, sy, aRelOrient, localSx, localSy );
    return { scaleLength( aBoardSize.x, 1.0 / localSx ), scaleLength( aBoardSize.y, 1.0 / localSy ) };
}
 

static VECTOR2I derivePadBoardDrill( const VECTOR2I& aLibDrill, PAD_DRILL_SHAPE aDrillShape,
                                     const TRANSFORM_TRS& aXform, const EDA_ANGLE& aRelOrient )
{
    const double sx = std::abs( aXform.GetScaleX() );
    const double sy = std::abs( aXform.GetScaleY() );
 
    if( aDrillShape == PAD_DRILL_SHAPE::CIRCLE )
    {
        const double uniform = ( sx + sy ) * 0.5;
        return { scaleLength( aLibDrill.x, uniform ), scaleLength( aLibDrill.y, uniform ) };
    }
 
 
    double localSx, localSy;
    scaleInChildFrame( sx, sy, aRelOrient, localSx, localSy );
    return { scaleLength( aLibDrill.x, localSx ), scaleLength( aLibDrill.y, localSy ) };
}
 

static VECTOR2I derivePadLibDrill( const VECTOR2I& aBoardDrill, PAD_DRILL_SHAPE aDrillShape,
                                   const TRANSFORM_TRS& aXform, const EDA_ANGLE& aRelOrient )
{
    const double sx = std::abs( aXform.GetScaleX() );
    const double sy = std::abs( aXform.GetScaleY() );
 
    if( aDrillShape == PAD_DRILL_SHAPE::CIRCLE )
    {
        const double uniform = ( sx + sy ) * 0.5;
        return { scaleLength( aBoardDrill.x, 1.0 / uniform ), scaleLength( aBoardDrill.y, 1.0 / uniform ) };
    }
 
    double localSx, localSy;
    scaleInChildFrame( sx, sy, aRelOrient, localSx, localSy );
    return { scaleLength( aBoardDrill.x, 1.0 / localSx ), scaleLength( aBoardDrill.y, 1.0 / localSy ) };
}
 

static VECTOR2I derivePadBoardOffset( const VECTOR2I& aLibOffset, const TRANSFORM_TRS& aXform,
                                      const EDA_ANGLE& aRelOrient )
{
    double localSx, localSy;
    scaleInChildFrame( std::abs( aXform.GetScaleX() ), std::abs( aXform.GetScaleY() ), aRelOrient, localSx, localSy );
    return { scaleLength( aLibOffset.x, localSx ), scaleLength( aLibOffset.y, localSy ) };
}
 

static VECTOR2I derivePadLibOffset( const VECTOR2I& aBoardOffset, const TRANSFORM_TRS& aXform,
                                    const EDA_ANGLE& aRelOrient )
{
    double localSx, localSy;
    scaleInChildFrame( std::abs( aXform.GetScaleX() ), std::abs( aXform.GetScaleY() ), aRelOrient, localSx, localSy );
    return { scaleLength( aBoardOffset.x, 1.0 / localSx ), scaleLength( aBoardOffset.y, 1.0 / localSy ) };
}
 
} // namespace
 
 
void PAD::SetPosition( const VECTOR2I& aPos )
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
        m_libPos = fp->GetTransform().InverseApply( aPos );
    else
        m_libPos = aPos;
 
    SetDirty();
}
 
 
VECTOR2I PAD::GetPosition() const
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
        return fp->GetTransform().Apply( m_libPos );
 
    return m_libPos;
}
 
 
void PAD::SetSize( PCB_LAYER_ID aLayer, const VECTOR2I& aSize )
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
        m_padStack.SetSize(
                derivePadLibSize( aSize, GetShape( aLayer ), fp->GetTransform(), GetFPRelativeOrientation() ), aLayer );
    else
        m_padStack.SetSize( aSize, aLayer );
 
    SetDirty();
}
 
 
void PAD::SetLibSize( PCB_LAYER_ID aLayer, const VECTOR2I& aSize )
{
    m_padStack.SetSize( aSize, aLayer );
    SetDirty();
}
 
 
void PAD::SetLibDrillSize( const VECTOR2I& aSize )
{
    m_padStack.Drill().size = aSize;
    SetDirty();
}
 
 
void PAD::SetLibOffset( PCB_LAYER_ID aLayer, const VECTOR2I& aOffset )
{
    m_padStack.Offset( aLayer ) = aOffset;
    SetDirty();
}
 
 
VECTOR2I PAD::GetSize( PCB_LAYER_ID aLayer ) const
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
        return derivePadBoardSize( m_padStack.Size( aLayer ), GetShape( aLayer ), fp->GetTransform(),
                                   GetFPRelativeOrientation() );
 
    return m_padStack.Size( aLayer );
}
 
 
void PAD::SetSizeXProp( int aX )
{
    if( aX <= 0 )
        return;
 
    int y = GetSize( PADSTACK::ALL_LAYERS ).y;
 
    if( GetShape( PADSTACK::ALL_LAYERS ) == PAD_SHAPE::CIRCLE )
        y = aX;
 
    SetSize( PADSTACK::ALL_LAYERS, { aX, y } );
}
 
 
int PAD::GetSizeXProp() const
{
    return GetSize( PADSTACK::ALL_LAYERS ).x;
}
 
 
void PAD::SetSizeYProp( int aY )
{
    if( aY <= 0 )
        return;
 
    int x = GetSize( PADSTACK::ALL_LAYERS ).x;
 
    if( GetShape( PADSTACK::ALL_LAYERS ) == PAD_SHAPE::CIRCLE )
        x = aY;
 
    SetSize( PADSTACK::ALL_LAYERS, { x, aY } );
}
 
 
int PAD::GetSizeYProp() const
{
    return GetSize( PADSTACK::ALL_LAYERS ).y;
}
 
 
PAD& PAD::operator=( const PAD &aOther )
{
    BOARD_CONNECTED_ITEM::operator=( aOther );
 
    ImportSettingsFrom( aOther );
    SetSimElectricalType( aOther.GetSimElectricalType() );
    SetPadToDieLength( aOther.GetPadToDieLength() );
    SetPadToDieDelay( aOther.GetPadToDieDelay() );
    SetPosition( aOther.GetPosition() );
    SetNumber( aOther.GetNumber() );
    SetPinType( aOther.GetPinType() );
    SetPinFunction( aOther.GetPinFunction() );
    SetSubRatsnest( aOther.GetSubRatsnest() );
    m_effectiveBoundingRadius = aOther.m_effectiveBoundingRadius;
 
    return *this;
}
 
 
void PAD::CopyFrom( const BOARD_ITEM* aOther )
{
    wxCHECK( aOther && aOther->Type() == PCB_PAD_T, /* void */ );
    *this = *static_cast<const PAD*>( aOther );
}
 
 
// This should probably move elsewhere once it is needed elsewhere
std::optional<std::pair<ELECTRICAL_PINTYPE, bool>> parsePinType( const wxString& aPinTypeString )
{
    // The netlister formats the pin type as "<canonical_name>[+no_connect]"
    static std::map<wxString, ELECTRICAL_PINTYPE> map = {
        { wxT( "input" ), ELECTRICAL_PINTYPE::PT_INPUT },
        { wxT( "output" ), ELECTRICAL_PINTYPE::PT_OUTPUT },
        { wxT( "bidirectional" ), ELECTRICAL_PINTYPE::PT_BIDI },
        { wxT( "tri_state" ), ELECTRICAL_PINTYPE::PT_TRISTATE },
        { wxT( "passive" ), ELECTRICAL_PINTYPE::PT_PASSIVE },
        { wxT( "free" ), ELECTRICAL_PINTYPE::PT_NIC },
        { wxT( "unspecified" ), ELECTRICAL_PINTYPE::PT_UNSPECIFIED },
        { wxT( "power_in" ), ELECTRICAL_PINTYPE::PT_POWER_IN },
        { wxT( "power_out" ), ELECTRICAL_PINTYPE::PT_POWER_OUT },
        { wxT( "open_collector" ), ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR },
        { wxT( "open_emitter" ), ELECTRICAL_PINTYPE::PT_OPENEMITTER },
        { wxT( "no_connect" ), ELECTRICAL_PINTYPE::PT_NC }
    };
 
    bool hasNoConnect = aPinTypeString.EndsWith( wxT( "+no_connect" ) );
 
    if( auto it = map.find( aPinTypeString.BeforeFirst( '+' ) ); it != map.end() )
        return std::make_pair( it->second, hasNoConnect );
 
    return std::nullopt;
}
 
 
void PAD::Serialize( google::protobuf::Any &aContainer ) const
{
    using namespace kiapi::board::types;
    using namespace kiapi::common::types;
    Pad pad;
 
    pad.mutable_id()->set_value( m_Uuid.AsStdString() );
    kiapi::common::PackVector2( *pad.mutable_position(), GetPosition() );
    pad.set_locked( IsLocked() ? LockedState::LS_LOCKED
                               : LockedState::LS_UNLOCKED );
    PackNet( pad.mutable_net() );
    pad.set_number( GetNumber().ToUTF8() );
    pad.set_type( ToProtoEnum<PAD_ATTRIB, PadType>( GetAttribute() ) );
    pad.mutable_pad_to_die_length()->set_value_nm( GetPadToDieLength() );
    pad.mutable_pad_to_die_delay()->set_value_as( GetPadToDieDelay() );
 
    m_padStack.Serialize( *pad.mutable_pad_stack() );
 
    if( GetLocalClearance().has_value() )
        pad.mutable_copper_clearance_override()->set_value_nm( *GetLocalClearance() );
 
    pad.mutable_symbol_pin()->set_name( m_pinFunction.ToUTF8() );
 
    if( std::optional<std::pair<ELECTRICAL_PINTYPE, bool>> pt = parsePinType( m_pinType ) )
    {
        pad.mutable_symbol_pin()->set_type( ToProtoEnum<ELECTRICAL_PINTYPE, ElectricalPinType>( pt->first ) );
        pad.mutable_symbol_pin()->set_no_connect( pt->second );
    }
 
    pad.set_sim_electrical_type( ToProtoEnum<PAD_SIM_ELECTRICAL_TYPE, PadSimElectricalType>( GetSimElectricalType() ) );
    pad.set_fab_property( ToProtoEnum<PAD_PROP, PadFabricationProperty>( GetProperty() ) );
 
    if( FOOTPRINT* parent = GetParentFootprint() )
        pad.mutable_parent()->set_value( parent->m_Uuid.AsStdString() );
 
    kiapi::board::PackTeardropSettings( *pad.mutable_teardrop(), GetTeardropParams() );
 
    {
        std::unique_lock lock( m_dataMutex );
        kiapi::board::PackZoneLayerOverrides( pad.mutable_zone_layer_overrides(), m_zoneLayerOverrides );
    }
 
    kiapi::common::PackCustomProperties( pad.mutable_custom_properties(), *this );
    aContainer.PackFrom( pad );
}
 
 
bool PAD::Deserialize( const google::protobuf::Any &aContainer )
{
    kiapi::board::types::Pad pad;
 
    if( !aContainer.UnpackTo( &pad ) )
        return false;
 
    SetUuidDirect( KIID( pad.id().value() ) );
    SetPosition( kiapi::common::UnpackVector2( pad.position() ) );
    UnpackNet( pad.net() );
    SetLocked( pad.locked() == kiapi::common::types::LockedState::LS_LOCKED );
    SetAttribute( FromProtoEnum<PAD_ATTRIB>( pad.type() ) );
    SetNumber( wxString::FromUTF8( pad.number() ) );
    SetPadToDieLength( pad.pad_to_die_length().value_nm() );
    SetPadToDieDelay( pad.pad_to_die_delay().value_as() );
    SetSimElectricalType( FromProtoEnum<PAD_SIM_ELECTRICAL_TYPE>( pad.sim_electrical_type() ) );
    SetProperty( FromProtoEnum<PAD_PROP>( pad.fab_property() ) );
 
    google::protobuf::Any padStackWrapper;
    padStackWrapper.PackFrom( pad.pad_stack() );
    m_padStack.Deserialize( padStackWrapper );
    SetOrientation( m_padStack.GetOrientation() );
 
    SetLayer( m_padStack.StartLayer() );
 
    if( pad.has_copper_clearance_override() )
        SetLocalClearance( pad.copper_clearance_override().value_nm() );
    else
        SetLocalClearance( std::nullopt );
 
    m_pinFunction = wxString::FromUTF8( pad.symbol_pin().name() );
 
    if( pad.symbol_pin().type() != kiapi::common::types::EPT_UNKNOWN )
    {
        ELECTRICAL_PINTYPE type = FromProtoEnum<ELECTRICAL_PINTYPE>( pad.symbol_pin().type() );
        m_pinType = GetCanonicalElectricalTypeName( type );
 
        if( pad.symbol_pin().no_connect() )
            m_pinType += wxT( "+no_connect" );
    }
 
    if( pad.has_teardrop() )
        kiapi::board::UnpackTeardropSettings( GetTeardropParams(), pad.teardrop() );
    else
        SetTeardropsEnabled( false );
 
    ClearZoneLayerOverrides();
 
    {
        std::unique_lock lock( m_dataMutex );
        kiapi::board::UnpackZoneLayerOverrides( m_zoneLayerOverrides, pad.zone_layer_overrides() );
    }
 
    kiapi::common::UnpackCustomProperties( pad.custom_properties(), *this );
 
    return true;
}
 
 
void PAD::ClearZoneLayerOverrides()
{
    std::unique_lock<std::mutex> cacheLock( m_dataMutex );
 
    for( PCB_LAYER_ID layer : LAYER_RANGE( F_Cu, B_Cu, BoardCopperLayerCount() ) )
        m_zoneLayerOverrides[layer] = ZLO_NONE;
}
 
 
const ZONE_LAYER_OVERRIDE& PAD::GetZoneLayerOverride( PCB_LAYER_ID aLayer ) const
{
    std::unique_lock<std::mutex> cacheLock( m_dataMutex );
 
    static const ZONE_LAYER_OVERRIDE defaultOverride = ZLO_NONE;
    auto it = m_zoneLayerOverrides.find( aLayer );
    return it != m_zoneLayerOverrides.end() ? it->second : defaultOverride;
}
 
 
void PAD::SetZoneLayerOverride( PCB_LAYER_ID aLayer, ZONE_LAYER_OVERRIDE aOverride )
{
    std::unique_lock<std::mutex> cacheLock( m_dataMutex );
    m_zoneLayerOverrides[aLayer] = aOverride;
}
 
 
bool PAD::CanHaveNumber() const
{
    // Aperture pads don't get a number
    if( IsAperturePad() )
        return false;
 
    // NPTH pads don't get numbers
    if( GetAttribute() == PAD_ATTRIB::NPTH )
        return false;
 
    return true;
}
 
 
bool PAD::IsNPTHWithNoCopper() const
{
    if( GetAttribute() != PAD_ATTRIB::NPTH )
        return false;
 
    bool hasCopper = false;
 
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID layer )
            {
                if( GetShape( layer ) == PAD_SHAPE::CIRCLE )
                {
                    if( GetSize( layer ).x > GetDrillSize().x )
                        hasCopper = true;
                }
                else if( GetShape( layer ) == PAD_SHAPE::OVAL )
                {
                    if( GetSize( layer ).x > GetDrillSize().x || GetSize( layer ).y > GetDrillSize().y )
                        hasCopper = true;
                }
                else
                {
                    hasCopper = true;
                }
            } );
 
    return !hasCopper;
}
 
 
bool PAD::IsLocked() const
{
    if( GetParent() && GetParent()->IsLocked() )
        return true;
 
    return BOARD_ITEM::IsLocked();
};
 
 
bool PAD::SharesNetTieGroup( const PAD* aOther ) const
{
    FOOTPRINT* parentFp = GetParentFootprint();
 
    if( parentFp && parentFp->IsNetTie() && aOther->GetParentFootprint() == parentFp )
    {
        std::map<wxString, int> padToNetTieGroupMap = parentFp->MapPadNumbersToNetTieGroups();
        int thisNetTieGroup = padToNetTieGroupMap[ GetNumber() ];
        int otherNetTieGroup = padToNetTieGroupMap[ aOther->GetNumber() ];
 
        return thisNetTieGroup >= 0 && thisNetTieGroup == otherNetTieGroup;
    }
 
    return false;
}
 
 
bool PAD::IsNoConnectPad() const
{
    return m_pinType.Contains( wxT( "no_connect" ) );
}
 
 
bool PAD::IsFreePad() const
{
    return GetShortNetname().StartsWith( wxT( "unconnected-(" ) ) && m_pinType == wxT( "free" );
}
 
 
LSET PAD::PTHMask()
{
    static LSET saved = LSET::AllCuMask() | LSET( { F_Mask, B_Mask } );
    return saved;
}
 
 
LSET PAD::SMDMask()
{
    static LSET saved( { F_Cu, F_Paste, F_Mask } );
    return saved;
}
 
 
LSET PAD::ConnSMDMask()
{
    static LSET saved( { F_Cu, F_Mask } );
    return saved;
}
 
 
LSET PAD::UnplatedHoleMask()
{
    static LSET saved = LSET( { F_Cu, B_Cu, F_Mask, B_Mask } );
    return saved;
}
 
 
LSET PAD::ApertureMask()
{
    static LSET saved( { F_Paste } );
    return saved;
}
 
 
bool PAD::IsFlipped() const
{
    FOOTPRINT* parent = GetParentFootprint();
 
    return ( parent && parent->GetLayer() == B_Cu );
}
 
 
PCB_LAYER_ID PAD::GetLayer() const
{
    return GetPrincipalLayer();
}
 
 
PCB_LAYER_ID PAD::GetPrincipalLayer() const
{
    if( m_attribute == PAD_ATTRIB::SMD || m_attribute == PAD_ATTRIB::CONN || GetLayerSet().none() )
        return m_layer;
    else
        return GetLayerSet().Seq().front();
 
}
 
 
bool PAD::FlashLayer( const LSET& aLayers ) const
{
    for( PCB_LAYER_ID layer : aLayers )
    {
        if( FlashLayer( layer ) )
            return true;
    }
 
    return false;
}
 
 
bool PAD::FlashLayer( int aLayer, bool aOnlyCheckIfPermitted ) const
{
    if( aLayer == UNDEFINED_LAYER )
        return true;
 
    // Sometimes this is called with GAL layers and should just return true
    if( aLayer > PCB_LAYER_ID_COUNT )
        return true;
 
    PCB_LAYER_ID layer = static_cast<PCB_LAYER_ID>( aLayer );
 
    if( !IsOnLayer( layer ) )
        return false;
 
    if( GetAttribute() == PAD_ATTRIB::NPTH && IsCopperLayer( aLayer ) )
    {
        if( GetShape( layer ) == PAD_SHAPE::CIRCLE && GetDrillShape() == PAD_DRILL_SHAPE::CIRCLE )
        {
            if( GetOffset( layer ) == VECTOR2I( 0, 0 ) && GetDrillSize().x >= GetSize( layer ).x )
                return false;
        }
        else if( GetShape( layer ) == PAD_SHAPE::OVAL
                 && GetDrillShape() == PAD_DRILL_SHAPE::OBLONG )
        {
            if( GetOffset( layer ) == VECTOR2I( 0, 0 )
                    && GetDrillSize().x >= GetSize( layer ).x
                    && GetDrillSize().y >= GetSize( layer ).y )
            {
                return false;
            }
        }
    }
 
    if( GetAttribute() == PAD_ATTRIB::PTH && ( layer == F_Mask || layer == B_Mask ) )
        return true;
 
    if( LSET::FrontBoardTechMask().test( aLayer ) )
        aLayer = F_Cu;
    else if( LSET::BackBoardTechMask().test( aLayer ) )
        aLayer = B_Cu;
 
    if( GetAttribute() == PAD_ATTRIB::PTH && IsCopperLayer( aLayer ) )
    {
        UNCONNECTED_LAYER_MODE mode = m_padStack.UnconnectedLayerMode();
 
        if( mode == UNCONNECTED_LAYER_MODE::KEEP_ALL )
            return true;
 
        // Plated through hole pads need copper on the top/bottom layers for proper soldering
        // Unless the user has removed them in the pad dialog
        if( mode == UNCONNECTED_LAYER_MODE::START_END_ONLY )
        {
            return aLayer == m_padStack.Drill().start || aLayer == m_padStack.Drill().end;
        }
 
        if( mode == UNCONNECTED_LAYER_MODE::REMOVE_EXCEPT_START_AND_END
            && IsExternalCopperLayer( aLayer ) )
        {
            return true;
        }
 
        if( const BOARD* board = GetBoard() )
        {
            if( GetZoneLayerOverride( layer ) == ZLO_FORCE_FLASHED )
            {
                return true;
            }
            else if( aOnlyCheckIfPermitted )
            {
                return true;
            }
            else
            {
                // Must be static to keep from raising its ugly head in performance profiles
                static std::initializer_list<KICAD_T> nonZoneTypes = { PCB_TRACE_T, PCB_ARC_T,
                                                                       PCB_VIA_T, PCB_PAD_T };
 
                return board->GetConnectivity()->IsConnectedOnLayer( this, aLayer, nonZoneTypes );
            }
        }
    }
 
    return true;
}
 
 
void PAD::SetPrimaryDrillSize( const VECTOR2I& aSize )
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
        m_padStack.Drill().size =
                derivePadLibDrill( aSize, GetPrimaryDrillShape(), fp->GetTransform(), GetFPRelativeOrientation() );
    else
        m_padStack.Drill().size = aSize;
 
    SetDirty();
}
 
 
VECTOR2I PAD::GetPrimaryDrillSize() const
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
        return derivePadBoardDrill( m_padStack.Drill().size, GetPrimaryDrillShape(), fp->GetTransform(),
                                    GetFPRelativeOrientation() );
 
    return m_padStack.Drill().size;
}
 
 
void PAD::SetPrimaryDrillSizeX( const int aX )
{
    VECTOR2I drill = GetPrimaryDrillSize();
    drill.x = aX;
 
    if( GetPrimaryDrillShape() == PAD_DRILL_SHAPE::CIRCLE )
        drill.y = aX;
 
    SetPrimaryDrillSize( drill );
}
 
 
void PAD::SetDrillSizeXProp( const int aX )
{
    SetPrimaryDrillSizeX( aX );
}
 
 
void PAD::SetPrimaryDrillSizeY( const int aY )
{
    VECTOR2I drill = GetPrimaryDrillSize();
    drill.y = aY;
    SetPrimaryDrillSize( drill );
}
 
 
void PAD::SetDrillSizeYProp( const int aY )
{
    SetPrimaryDrillSizeY( aY );
}
 
 
void PAD::SetOffset( PCB_LAYER_ID aLayer, const VECTOR2I& aOffset )
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
        m_padStack.Offset( aLayer ) = derivePadLibOffset( aOffset, fp->GetTransform(), GetFPRelativeOrientation() );
    else
        m_padStack.Offset( aLayer ) = aOffset;
 
    SetDirty();
}
 
 
VECTOR2I PAD::GetOffset( PCB_LAYER_ID aLayer ) const
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
        return derivePadBoardOffset( m_padStack.Offset( aLayer ), fp->GetTransform(), GetFPRelativeOrientation() );
 
    return m_padStack.Offset( aLayer );
}
 
 
void PAD::SetPrimaryDrillShape( PAD_DRILL_SHAPE aShape )
{
    m_padStack.Drill().shape = aShape;
 
    if( aShape == PAD_DRILL_SHAPE::CIRCLE )
        m_padStack.Drill().size.y = m_padStack.Drill().size.x;
 
    m_shapesDirty = true;
    SetDirty();
}
 
 
void PAD::SetPrimaryDrillStartLayer( PCB_LAYER_ID aLayer )
{
    m_padStack.Drill().start = aLayer;
    SetDirty();
}
 
 
void PAD::SetPrimaryDrillEndLayer( PCB_LAYER_ID aLayer )
{
    m_padStack.Drill().end = aLayer;
    SetDirty();
}
 
 
bool PAD::IsBackdrilledOrPostMachined( PCB_LAYER_ID aLayer ) const
{
    if( !IsCopperLayer( aLayer ) )
        return false;
 
    const BOARD* board = GetBoard();
 
    if( !board )
        return false;
 
    // Check secondary drill (backdrill from top)
    const PADSTACK::DRILL_PROPS& secondaryDrill = m_padStack.SecondaryDrill();
 
    if( secondaryDrill.size.x > 0 && secondaryDrill.start != UNDEFINED_LAYER && secondaryDrill.end != UNDEFINED_LAYER )
    {
        // Secondary drill goes from start to end layer, removing copper on those layers
        int startOrdinal = board->IsLayerEnabled( secondaryDrill.start )
                ? board->IsLayerEnabled( F_Cu ) ? ( secondaryDrill.start == F_Cu ? 0
                                                                                 : secondaryDrill.start / 2 + 1 )
                                                 : secondaryDrill.start / 2
                : -1;
        int endOrdinal = board->IsLayerEnabled( secondaryDrill.end )
                ? board->IsLayerEnabled( F_Cu ) ? ( secondaryDrill.end == B_Cu ? board->GetCopperLayerCount() - 1
                                                                               : secondaryDrill.end / 2 + 1 )
                                                : secondaryDrill.end / 2
                : -1;
        int layerOrdinal = board->IsLayerEnabled( aLayer )
                ? board->IsLayerEnabled( F_Cu ) ? ( aLayer == F_Cu ? 0
                                                                   : aLayer == B_Cu ? board->GetCopperLayerCount() - 1
                                                                                    : aLayer / 2 + 1 )
                                                : aLayer / 2
                : -1;
 
        if( layerOrdinal >= 0 && startOrdinal >= 0 && endOrdinal >= 0 )
        {
            if( startOrdinal > endOrdinal )
                std::swap( startOrdinal, endOrdinal );
 
            if( layerOrdinal >= startOrdinal && layerOrdinal <= endOrdinal )
                return true;
        }
    }
 
    // Check tertiary drill (backdrill from bottom)
    const PADSTACK::DRILL_PROPS& tertiaryDrill = m_padStack.TertiaryDrill();
 
    if( tertiaryDrill.size.x > 0 && tertiaryDrill.start != UNDEFINED_LAYER && tertiaryDrill.end != UNDEFINED_LAYER )
    {
        int startOrdinal = board->IsLayerEnabled( tertiaryDrill.start )
                ? board->IsLayerEnabled( F_Cu ) ? ( tertiaryDrill.start == F_Cu ? 0
                                                                                : tertiaryDrill.start / 2 + 1 )
                                                : tertiaryDrill.start / 2
                : -1;
        int endOrdinal = board->IsLayerEnabled( tertiaryDrill.end )
                ? board->IsLayerEnabled( F_Cu ) ? ( tertiaryDrill.end == B_Cu ? board->GetCopperLayerCount() - 1
                                                                              : tertiaryDrill.end / 2 + 1 )
                                                : tertiaryDrill.end / 2
                : -1;
        int layerOrdinal = board->IsLayerEnabled( aLayer )
                ? board->IsLayerEnabled( F_Cu ) ? ( aLayer == F_Cu ? 0
                                                                   : aLayer == B_Cu ? board->GetCopperLayerCount() - 1
                                                                                    : aLayer / 2 + 1 )
                                                : aLayer / 2
                : -1;
 
        if( layerOrdinal >= 0 && startOrdinal >= 0 && endOrdinal >= 0 )
        {
            if( startOrdinal > endOrdinal )
                std::swap( startOrdinal, endOrdinal );
 
            if( layerOrdinal >= startOrdinal && layerOrdinal <= endOrdinal )
                return true;
        }
    }
 
    // Check if the layer is affected by post-machining
    if( GetPostMachiningKnockout( aLayer ) > 0 )
        return true;
 
    return false;
}
 
 
int PAD::GetPostMachiningKnockout( PCB_LAYER_ID aLayer ) const
{
    if( !IsCopperLayer( aLayer ) )
        return 0;
 
    const BOARD* board = GetBoard();
 
    if( !board )
        return 0;
 
    const BOARD_STACKUP& stackup = board->GetDesignSettings().GetStackupDescriptor();
 
    // Check front post-machining (counterbore/countersink from top)
    const PADSTACK::POST_MACHINING_PROPS& frontPM = m_padStack.FrontPostMachining();
 
    if( frontPM.mode.has_value() && *frontPM.mode != PAD_DRILL_POST_MACHINING_MODE::NOT_POST_MACHINED
            && *frontPM.mode != PAD_DRILL_POST_MACHINING_MODE::UNKNOWN && frontPM.size > 0 )
    {
        int pmDepth = frontPM.depth;
 
        // For countersink without explicit depth, calculate from diameter and angle
        if( pmDepth <= 0 && *frontPM.mode == PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK && frontPM.angle > 0 )
        {
            double halfAngleRad = ( frontPM.angle / 10.0 ) * M_PI / 180.0 / 2.0;
            pmDepth = static_cast<int>( ( frontPM.size / 2.0 ) / tan( halfAngleRad ) );
        }
 
        if( pmDepth > 0 )
        {
            // Calculate distance from F_Cu to aLayer
            int layerDist = stackup.GetLayerDistance( F_Cu, aLayer );
 
            if( layerDist < pmDepth )
            {
                // For countersink, diameter decreases with depth
                if( *frontPM.mode == PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK && frontPM.angle > 0 )
                {
                    double halfAngleRad = ( frontPM.angle / 10.0 ) * M_PI / 180.0 / 2.0;
                    int diameterAtLayer = frontPM.size - static_cast<int>( 2.0 * layerDist * tan( halfAngleRad ) );
                    return std::max( 0, diameterAtLayer );
                }
                else
                {
                    // Counterbore - constant diameter
                    return frontPM.size;
                }
            }
        }
    }
 
    // Check back post-machining (counterbore/countersink from bottom)
    const PADSTACK::POST_MACHINING_PROPS& backPM = m_padStack.BackPostMachining();
 
    if( backPM.mode.has_value() && *backPM.mode != PAD_DRILL_POST_MACHINING_MODE::NOT_POST_MACHINED
            && *backPM.mode != PAD_DRILL_POST_MACHINING_MODE::UNKNOWN && backPM.size > 0 )
    {
        int pmDepth = backPM.depth;
 
        // For countersink without explicit depth, calculate from diameter and angle
        if( pmDepth <= 0 && *backPM.mode == PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK && backPM.angle > 0 )
        {
            double halfAngleRad = ( backPM.angle / 10.0 ) * M_PI / 180.0 / 2.0;
            pmDepth = static_cast<int>( ( backPM.size / 2.0 ) / tan( halfAngleRad ) );
        }
 
        if( pmDepth > 0 )
        {
            // Calculate distance from B_Cu to aLayer
            int layerDist = stackup.GetLayerDistance( B_Cu, aLayer );
 
            if( layerDist < pmDepth )
            {
                // For countersink, diameter decreases with depth
                if( *backPM.mode == PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK && backPM.angle > 0 )
                {
                    double halfAngleRad = ( backPM.angle / 10.0 ) * M_PI / 180.0 / 2.0;
                    int diameterAtLayer = backPM.size - static_cast<int>( 2.0 * layerDist * tan( halfAngleRad ) );
                    return std::max( 0, diameterAtLayer );
                }
                else
                {
                    // Counterbore - constant diameter
                    return backPM.size;
                }
            }
        }
    }
 
    return 0;
}
 
 
void PAD::SetPrimaryDrillFilled( const std::optional<bool>& aFilled )
{
    m_padStack.Drill().is_filled = aFilled;
    SetDirty();
}
 
 
void PAD::SetPrimaryDrillFilledFlag( bool aFilled )
{
    m_padStack.Drill().is_filled = aFilled;
    SetDirty();
}
 
 
void PAD::SetPrimaryDrillCapped( const std::optional<bool>& aCapped )
{
    m_padStack.Drill().is_capped = aCapped;
    SetDirty();
}
 
 
void PAD::SetPrimaryDrillCappedFlag( bool aCapped )
{
    m_padStack.Drill().is_capped = aCapped;
    SetDirty();
}
 
 
void PAD::SetSecondaryDrillSize( const VECTOR2I& aSize )
{
    m_padStack.SecondaryDrill().size = aSize;
    SetDirty();
}
 
 
void PAD::SetSecondaryDrillSizeX( int aX )
{
    m_padStack.SecondaryDrill().size.x = aX;
 
    if( GetSecondaryDrillShape() == PAD_DRILL_SHAPE::CIRCLE )
        m_padStack.SecondaryDrill().size.y = aX;
 
    SetDirty();
}
 
 
void PAD::SetSecondaryDrillSizeY( int aY )
{
    m_padStack.SecondaryDrill().size.y = aY;
    SetDirty();
}
 
 
void PAD::ClearSecondaryDrillSize()
{
    m_padStack.SecondaryDrill().size = VECTOR2I( 0, 0 );
    SetDirty();
}
 
 
void PAD::SetSecondaryDrillShape( PAD_DRILL_SHAPE aShape )
{
    m_padStack.SecondaryDrill().shape = aShape;
    SetDirty();
}
 
 
void PAD::SetSecondaryDrillStartLayer( PCB_LAYER_ID aLayer )
{
    m_padStack.SecondaryDrill().start = aLayer;
    SetDirty();
}
 
 
void PAD::SetSecondaryDrillEndLayer( PCB_LAYER_ID aLayer )
{
    m_padStack.SecondaryDrill().end = aLayer;
    SetDirty();
}
 
 
void PAD::SetTertiaryDrillSize( const VECTOR2I& aSize )
{
    m_padStack.TertiaryDrill().size = aSize;
    SetDirty();
}
 
 
void PAD::SetTertiaryDrillSizeX( int aX )
{
    m_padStack.TertiaryDrill().size.x = aX;
 
    if( GetTertiaryDrillShape() == PAD_DRILL_SHAPE::CIRCLE )
        m_padStack.TertiaryDrill().size.y = aX;
 
    SetDirty();
}
 
 
void PAD::SetTertiaryDrillSizeY( int aY )
{
    m_padStack.TertiaryDrill().size.y = aY;
    SetDirty();
}
 
 
void PAD::ClearTertiaryDrillSize()
{
    m_padStack.TertiaryDrill().size = VECTOR2I( 0, 0 );
    SetDirty();
}
 
 
void PAD::SetTertiaryDrillShape( PAD_DRILL_SHAPE aShape )
{
    m_padStack.TertiaryDrill().shape = aShape;
    SetDirty();
}
 
 
void PAD::SetTertiaryDrillStartLayer( PCB_LAYER_ID aLayer )
{
    m_padStack.TertiaryDrill().start = aLayer;
    SetDirty();
}
 
 
void PAD::SetTertiaryDrillEndLayer( PCB_LAYER_ID aLayer )
{
    m_padStack.TertiaryDrill().end = aLayer;
    SetDirty();
}
 
 
int PAD::GetRoundRectCornerRadius( PCB_LAYER_ID aLayer ) const
{
    return m_padStack.RoundRectRadius( aLayer );
}
 
 
void PAD::SetRoundRectCornerRadius( PCB_LAYER_ID aLayer, double aRadius )
{
    m_padStack.SetRoundRectRadius( aRadius, aLayer );
}
 
 
void PAD::SetRoundRectRadiusRatio( PCB_LAYER_ID aLayer, double aRadiusScale )
{
    m_padStack.SetRoundRectRadiusRatio( std::clamp( aRadiusScale, 0.0, 0.5 ), aLayer );
 
    SetDirty();
}
 
 
void PAD::SetFrontRoundRectRadiusRatio( double aRadiusScale )
{
    wxASSERT_MSG( m_padStack.Mode() == PADSTACK::MODE::NORMAL,
                  "Set front radius only meaningful for normal padstacks" );
 
    m_padStack.SetRoundRectRadiusRatio( std::clamp( aRadiusScale, 0.0, 0.5 ), F_Cu );
    SetDirty();
}
 
 
void PAD::SetFrontRoundRectRadiusSize( int aRadius )
{
    const VECTOR2I size = GetSize( F_Cu );
    const int      minSize = std::min( size.x, size.y );
    const double   newRatio = aRadius / double( minSize );
 
    SetFrontRoundRectRadiusRatio( newRatio );
}
 
 
int PAD::GetFrontRoundRectRadiusSize() const
{
    const VECTOR2I size = GetSize( F_Cu );
    const int      minSize = std::min( size.x, size.y );
    const double   ratio = GetFrontRoundRectRadiusRatio();
 
    return KiROUND( ratio * minSize );
}
 
 
void PAD::SetChamferRectRatio( PCB_LAYER_ID aLayer, double aChamferScale )
{
    m_padStack.SetChamferRatio( aChamferScale, aLayer );
 
    SetDirty();
}
 
 
const std::shared_ptr<SHAPE_POLY_SET>& PAD::GetEffectivePolygon( PCB_LAYER_ID aLayer, ERROR_LOC aErrorLoc ) const
{
    if( m_polyDirty[ aErrorLoc ] )
        BuildEffectivePolygon( aErrorLoc );
 
    aLayer = Padstack().EffectiveLayerFor( aLayer );
 
    const PAD_DRAW_CACHE_DATA& drawCache = getDrawCache();
 
    return drawCache.m_effectivePolygons.at( aLayer )[ aErrorLoc ];
}
 
 
std::shared_ptr<SHAPE> PAD::GetEffectiveShape( PCB_LAYER_ID aLayer, FLASHING aFlash, DRC_CONSTRAINT_T aUsage ) const
{
    if( aLayer == Edge_Cuts )
    {
        std::shared_ptr<SHAPE_COMPOUND> effective_compound = std::make_shared<SHAPE_COMPOUND>();
 
        if( GetAttribute() == PAD_ATTRIB::PTH || GetAttribute() == PAD_ATTRIB::NPTH )
        {
            effective_compound->AddShape( GetEffectiveHoleShape( aLayer, aUsage ) );
            return effective_compound;
        }
        else
        {
            effective_compound->AddShape( std::make_shared<SHAPE_NULL>() );
            return effective_compound;
        }
    }
 
    if( GetAttribute() == PAD_ATTRIB::PTH )
    {
        bool flash;
        std::shared_ptr<SHAPE_COMPOUND> effective_compund = std::make_shared<SHAPE_COMPOUND>();
 
        if( aFlash == FLASHING::NEVER_FLASHED )
            flash = false;
        else if( aFlash == FLASHING::ALWAYS_FLASHED )
            flash = true;
        else
            flash = FlashLayer( aLayer );
 
        if( !flash )
        {
            if( GetAttribute() == PAD_ATTRIB::PTH )
            {
                effective_compund->AddShape( GetEffectiveHoleShape( aLayer, aUsage ) );
                return effective_compund;
            }
            else
            {
                effective_compund->AddShape( std::make_shared<SHAPE_NULL>() );
                return effective_compund;
            }
        }
    }
 
    if( m_shapesDirty )
        BuildEffectiveShapes();
 
    // A normal padstack keeps one shape, under ALL_LAYERS, so the cache accepts only the remapped
    // layer.  The machining tests below still use the layer that the caller asked for
    PCB_LAYER_ID effectiveLayer = Padstack().EffectiveLayerFor( aLayer );
 
    const PAD_DRAW_CACHE_DATA& drawCache = getDrawCache();
 
    wxCHECK_MSG( drawCache.m_effectiveShapes.contains( effectiveLayer ), nullptr,
                 wxString::Format( wxT( "Missing shape in PAD::GetEffectiveShape for layer %s." ),
                                   magic_enum::enum_name( effectiveLayer ) ) );
    wxCHECK_MSG( drawCache.m_effectiveShapes.at( effectiveLayer ), nullptr,
                 wxString::Format( wxT( "Null shape in PAD::GetEffectiveShape for layer %s." ),
                                   magic_enum::enum_name( effectiveLayer ) ) );
 
    std::shared_ptr<SHAPE> shape = drawCache.m_effectiveShapes.at( effectiveLayer );
 
    if( IsSolderMaskLayer( aLayer ) )
    {
        if( int expansion = GetSolderMaskExpansion( aLayer ) )
            shape = getMaskShape( aLayer, expansion );
    }
 
    // In some cases we want to add in any backdrill or post-machining
    if( ( aUsage == PHYSICAL_CLEARANCE_CONSTRAINT || aUsage == SILK_CLEARANCE_CONSTRAINT )
            && IsBackdrilledOrPostMachined( aLayer ) )
    {
        std::shared_ptr<SHAPE_COMPOUND> effective_compound = std::make_shared<SHAPE_COMPOUND>();
        effective_compound->AddShape( shape );
        effective_compound->AddShape( GetEffectiveHoleShape( aLayer, aUsage ) );
        return effective_compound;
    }
 
    return shape;
}
 
 
std::shared_ptr<SHAPE_COMPOUND> PAD::getMaskShape( PCB_LAYER_ID aLayer, int aExpansion ) const
{
    {
        std::lock_guard<std::mutex> RAII_lock( m_maskShapeMutex );
        auto                        it = m_maskShapes.find( aLayer );
 
        if( it != m_maskShapes.end() && it->second.first == aExpansion )
            return it->second.second;
    }
 
    // Built outside the lock because this can re-enter the pad through the rule engine
    SHAPE_POLY_SET aperture;
    TransformShapeToPolygon( aperture, aLayer, aExpansion, GetMaxError(), ERROR_OUTSIDE );
 
    std::shared_ptr<SHAPE_COMPOUND> shape = std::make_shared<SHAPE_COMPOUND>();
 
    for( int ii = 0; ii < aperture.OutlineCount(); ++ii )
        shape->AddShape( new SHAPE_SIMPLE( aperture.COutline( ii ) ) );
 
    std::lock_guard<std::mutex> RAII_lock( m_maskShapeMutex );
    m_maskShapes[aLayer] = { aExpansion, shape };
 
    return shape;
}
 
 
std::shared_ptr<SHAPE_SEGMENT> PAD::GetEffectiveHoleShape( PCB_LAYER_ID aLayer, DRC_CONSTRAINT_T aUsage ) const
{
    if( m_shapesDirty )
        BuildEffectiveShapes();
 
    if( aUsage == HOLE_TO_HOLE_CONSTRAINT
            || ( aUsage == HOLE_CLEARANCE_CONSTRAINT && IsBackdrilledOrPostMachined( aLayer ) )
            || ( aUsage == ANNULAR_WIDTH_CONSTRAINT && IsBackdrilledOrPostMachined( aLayer ) )
            || ( aUsage == PHYSICAL_CLEARANCE_CONSTRAINT && IsBackdrilledOrPostMachined( aLayer ) )
            || ( aUsage == SILK_CLEARANCE_CONSTRAINT && IsBackdrilledOrPostMachined( aLayer ) ) )
    {
        int maxHoleSize = Padstack().GetMaxHoleSize();
 
        // If it's bigger than the pad's hole, return it
        if( maxHoleSize > getDrawCache().m_effectiveHoleShape->GetWidth() )
            return std::make_shared<SHAPE_SEGMENT>( GetPosition(), GetPosition(), maxHoleSize );
    }
 
    return getDrawCache().m_effectiveHoleShape;
}
 
 
int PAD::GetBoundingRadius() const
{
    if( m_polyDirty[ ERROR_OUTSIDE ] )
        BuildEffectivePolygon( ERROR_OUTSIDE );
 
    return m_effectiveBoundingRadius;
}
 
 
PAD::PAD_DRAW_CACHE_DATA& PAD::getDrawCache() const
{
    if( !m_drawCache )
        m_drawCache = std::make_unique<PAD_DRAW_CACHE_DATA>();
 
    return *m_drawCache;
}
 
 
void PAD::BuildEffectiveShapes() const
{
    std::lock_guard<std::mutex> RAII_lock( m_dataMutex );
 
    // If we had to wait for the lock then we were probably waiting for someone else to
    // finish rebuilding the shapes.  So check to see if they're clean now.
    if( !m_shapesDirty )
        return;
 
    PAD_DRAW_CACHE_DATA& drawCache = getDrawCache();
 
    drawCache.m_effectiveBoundingBox = BOX2I();
    drawCache.m_effectiveShapes.clear();
 
    {
        std::lock_guard<std::mutex> RAII_maskLock( m_maskShapeMutex );
        m_maskShapes.clear();
    }
 
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                const SHAPE_COMPOUND& layerShape = buildEffectiveShape( aLayer );
                drawCache.m_effectiveBoundingBox.Merge( layerShape.BBox() );
            } );
 
    // Hole shape
    drawCache.m_effectiveHoleShape = nullptr;
 
    VECTOR2I half_size = GetDrillSize() / 2;
    int      half_width;
    VECTOR2I half_len;
 
    if( m_padStack.Drill().shape == PAD_DRILL_SHAPE::CIRCLE )
    {
        half_width = half_size.x;
    }
    else
    {
        half_width = std::min( half_size.x, half_size.y );
        half_len = VECTOR2I( half_size.x - half_width, half_size.y - half_width );
    }
 
    RotatePoint( half_len, GetOrientation() );
 
    VECTOR2I pos = GetPosition();
    drawCache.m_effectiveHoleShape = std::make_shared<SHAPE_SEGMENT>( pos - half_len, pos + half_len, half_width * 2 );
 
    drawCache.m_effectiveBoundingBox.Merge( drawCache.m_effectiveHoleShape->BBox() );
 
    if( m_padStack.Drill().shape == PAD_DRILL_SHAPE::CIRCLE )
    {
        int maxHole = m_padStack.GetMaxHoleSize();
        drawCache.m_effectiveBoundingBox.Merge( BOX2I::ByCenter( pos, VECTOR2I( maxHole, maxHole ) ) );
    }
 
    // All done
    m_shapesDirty = false;
}
 
 
const SHAPE_COMPOUND& PAD::buildEffectiveShape( PCB_LAYER_ID aLayer ) const
{
    PAD_DRAW_CACHE_DATA& drawCache = getDrawCache();
 
    drawCache.m_effectiveShapes[aLayer] = std::make_shared<SHAPE_COMPOUND>();
 
    auto add = [this, aLayer]( SHAPE* aShape )
               {
                   getDrawCache().m_effectiveShapes[aLayer]->AddShape( aShape );
               };
 
    VECTOR2I  shapePos = ShapePos( aLayer ); // Fetch only once; rotation involves trig
    PAD_SHAPE effectiveShape = GetShape( aLayer );
    const VECTOR2I size = GetSize( aLayer );
 
    if( effectiveShape == PAD_SHAPE::CUSTOM )
        effectiveShape = GetAnchorPadShape( aLayer );
 
    switch( effectiveShape )
    {
    case PAD_SHAPE::CIRCLE:
        add( new SHAPE_CIRCLE( shapePos, size.x / 2 ) );
        break;
 
    case PAD_SHAPE::OVAL:
        if( size.x == size.y ) // the oval pad is in fact a circle
        {
            add( new SHAPE_CIRCLE( shapePos, size.x / 2 ) );
        }
        else
        {
            VECTOR2I half_size = size / 2;
            int     half_width = std::min( half_size.x, half_size.y );
            VECTOR2I half_len( half_size.x - half_width, half_size.y - half_width );
            RotatePoint( half_len, GetOrientation() );
            add( new SHAPE_SEGMENT( shapePos - half_len, shapePos + half_len, half_width * 2 ) );
        }
 
        break;
 
    case PAD_SHAPE::RECTANGLE:
    case PAD_SHAPE::TRAPEZOID:
    case PAD_SHAPE::ROUNDRECT:
    {
        int r = ( effectiveShape == PAD_SHAPE::ROUNDRECT ) ? GetRoundRectCornerRadius( aLayer ) : 0;
        VECTOR2I half_size( size.x / 2, size.y / 2 );
        VECTOR2I trap_delta( 0, 0 );
 
        if( r )
        {
            half_size -= VECTOR2I( r, r );
 
            // Avoid degenerated shapes (0 length segments) that always create issues
            // For roundrect pad very near a circle, use only a circle
            const int min_len = pcbIUScale.mmToIU( 0.0001 );
 
            if( half_size.x < min_len && half_size.y < min_len )
            {
                add( new SHAPE_CIRCLE( shapePos, r ) );
                break;
            }
        }
        else if( effectiveShape == PAD_SHAPE::TRAPEZOID )
        {
            trap_delta = m_padStack.TrapezoidDeltaSize( aLayer ) / 2;
        }
 
        SHAPE_LINE_CHAIN corners;
 
        corners.Append( -half_size.x - trap_delta.y,  half_size.y + trap_delta.x );
        corners.Append(  half_size.x + trap_delta.y,  half_size.y - trap_delta.x );
        corners.Append(  half_size.x - trap_delta.y, -half_size.y + trap_delta.x );
        corners.Append( -half_size.x + trap_delta.y, -half_size.y - trap_delta.x );
 
        corners.Rotate( GetOrientation() );
        corners.Move( shapePos );
 
        // GAL renders rectangles faster than 4-point polygons so it's worth checking if our
        // body shape is a rectangle.
        if( corners.PointCount() == 4
                &&
                ( ( corners.CPoint( 0 ).y == corners.CPoint( 1 ).y
                    && corners.CPoint( 1 ).x == corners.CPoint( 2 ).x
                    && corners.CPoint( 2 ).y == corners.CPoint( 3 ).y
                    && corners.CPoint( 3 ).x == corners.CPoint( 0 ).x )
                    ||
                ( corners.CPoint( 0 ).x == corners.CPoint( 1 ).x
                    && corners.CPoint( 1 ).y == corners.CPoint( 2 ).y
                    && corners.CPoint( 2 ).x == corners.CPoint( 3 ).x
                    && corners.CPoint( 3 ).y == corners.CPoint( 0 ).y )
                )
            )
        {
            int width  = std::abs( corners.CPoint( 2 ).x - corners.CPoint( 0 ).x );
            int height = std::abs( corners.CPoint( 2 ).y - corners.CPoint( 0 ).y );
            VECTOR2I pos( std::min( corners.CPoint( 2 ).x, corners.CPoint( 0 ).x ),
                          std::min( corners.CPoint( 2 ).y, corners.CPoint( 0 ).y ) );
 
            add( new SHAPE_RECT( pos, width, height ) );
        }
        else
        {
            add( new SHAPE_SIMPLE( corners ) );
        }
 
        if( r )
        {
            add( new SHAPE_SEGMENT( corners.CPoint( 0 ), corners.CPoint( 1 ), r * 2 ) );
            add( new SHAPE_SEGMENT( corners.CPoint( 1 ), corners.CPoint( 2 ), r * 2 ) );
            add( new SHAPE_SEGMENT( corners.CPoint( 2 ), corners.CPoint( 3 ), r * 2 ) );
            add( new SHAPE_SEGMENT( corners.CPoint( 3 ), corners.CPoint( 0 ), r * 2 ) );
        }
    }
        break;
 
    case PAD_SHAPE::CHAMFERED_RECT:
    {
        SHAPE_POLY_SET outline;
 
        TransformRoundChamferedRectToPolygon( outline, shapePos, GetSize( aLayer ),
                                              GetOrientation(), GetRoundRectCornerRadius( aLayer ),
                                              GetChamferRectRatio( aLayer ),
                                              GetChamferPositions( aLayer ), 0, GetMaxError(),
                                              ERROR_INSIDE );
 
        add( new SHAPE_SIMPLE( outline.COutline( 0 ) ) );
    }
        break;
 
    default:
        wxFAIL_MSG( wxT( "PAD::buildEffectiveShapes: Unsupported pad shape: PAD_SHAPE::" )
                    + wxString( std::string( magic_enum::enum_name( effectiveShape ) ) ) );
        break;
    }
 
    if( GetShape( aLayer ) == PAD_SHAPE::CUSTOM )
    {
        for( const std::shared_ptr<PCB_SHAPE>& primitive : m_padStack.Primitives( aLayer ) )
        {
            if( !primitive->IsProxyItem() )
            {
                for( SHAPE* shape : primitive->MakeEffectiveShapes() )
                {
                    shape->Rotate( GetOrientation() );
                    shape->Move( shapePos );
                    add( shape );
                }
            }
        }
    }
 
    return *drawCache.m_effectiveShapes[aLayer];
}
 
 
void PAD::BuildEffectivePolygon( ERROR_LOC aErrorLoc ) const
{
    std::lock_guard<std::mutex> RAII_lock( m_dataMutex );
 
    // Only calculate this once, not for both ERROR_INSIDE and ERROR_OUTSIDE
    bool doBoundingRadius = aErrorLoc == ERROR_OUTSIDE;
 
    // If we had to wait for the lock then we were probably waiting for someone else to
    // finish rebuilding the shapes.  So check to see if they're clean now.
    if( !m_polyDirty[ aErrorLoc ] )
        return;
 
    PAD_DRAW_CACHE_DATA& drawCache = getDrawCache();
 
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                // Polygon
                std::shared_ptr<SHAPE_POLY_SET>& effectivePolygon =
                        drawCache.m_effectivePolygons[ aLayer ][ aErrorLoc ];
 
                effectivePolygon = std::make_shared<SHAPE_POLY_SET>();
                TransformShapeToPolygon( *effectivePolygon, aLayer, 0, GetMaxError(), aErrorLoc );
            } );
 
    if( doBoundingRadius )
    {
        m_effectiveBoundingRadius = 0;
 
        Padstack().ForEachUniqueLayer(
                [&]( PCB_LAYER_ID aLayer )
                {
                    std::shared_ptr<SHAPE_POLY_SET>& effectivePolygon =
                            drawCache.m_effectivePolygons[ aLayer ][ aErrorLoc ];
 
                    for( int cnt = 0; cnt < effectivePolygon->OutlineCount(); ++cnt )
                    {
                        const SHAPE_LINE_CHAIN& poly = effectivePolygon->COutline( cnt );
 
                        for( int ii = 0; ii < poly.PointCount(); ++ii )
                        {
                            int dist = KiROUND( ( poly.CPoint( ii ) - GetPosition() ).EuclideanNorm() );
                            m_effectiveBoundingRadius = std::max( m_effectiveBoundingRadius, dist );
                        }
                    }
                } );
 
        m_effectiveBoundingRadius = std::max( m_effectiveBoundingRadius, KiROUND( GetDrillSize().x / 2.0 ) );
        m_effectiveBoundingRadius = std::max( m_effectiveBoundingRadius, KiROUND( GetDrillSize().y / 2.0 ) );
    }
 
    // All done
    m_polyDirty[ aErrorLoc ] = false;
}
 
 
const BOX2I PAD::GetBoundingBox() const
{
    if( m_shapesDirty )
        BuildEffectiveShapes();
 
    return getDrawCache().m_effectiveBoundingBox;
}
 
 
// Thermal spokes are built on the bounding box, so we must have a layer-specific version
const BOX2I PAD::GetBoundingBox( PCB_LAYER_ID aLayer ) const
{
    return buildEffectiveShape( aLayer ).BBox();
}
 
 
void PAD::SetAttribute( PAD_ATTRIB aAttribute )
{
    if( m_attribute != aAttribute )
    {
        m_attribute = aAttribute;
 
        LSET& layerMask = m_padStack.LayerSet();
 
        switch( aAttribute )
        {
        case PAD_ATTRIB::PTH:
            // Plump up to all copper layers
            layerMask |= LSET::AllCuMask();
            break;
 
        case PAD_ATTRIB::SMD:
        case PAD_ATTRIB::CONN:
        {
            // Trim down to no more than one copper layer
            LSET copperLayers = layerMask & LSET::AllCuMask();
 
            if( copperLayers.count() > 1 )
            {
                layerMask &= ~LSET::AllCuMask();
 
                if( copperLayers.test( B_Cu ) )
                    layerMask.set( B_Cu );
                else
                    layerMask.set( copperLayers.Seq().front() );
            }
 
            // No hole, so no drilling of any kind
            PAD_UTILS::RemoveAllDrillsFromPadstack( m_padStack );
            break;
        }
 
        case PAD_ATTRIB::NPTH:
            // No number; no net
            m_number = wxEmptyString;
            SetNetCode( NETINFO_LIST::UNCONNECTED );
            break;
        }
 
        if( !( GetFlags() & ROUTER_TRANSIENT ) )
        {
            if( BOARD* board = GetBoard() )
                board->InvalidateClearanceCache( m_Uuid );
        }
    }
 
    SetDirty();
}
 
 
void PAD::SetFrontShape( PAD_SHAPE aShape )
{
    const bool wasRoundable = PAD_UTILS::PadHasMeaningfulRoundingRadius( *this, F_Cu );
 
    m_padStack.SetShape( aShape, F_Cu );
 
    const bool isRoundable = PAD_UTILS::PadHasMeaningfulRoundingRadius( *this, F_Cu );
 
    // If we have become roundable, set a sensible rounding default using the IPC rules.
    if( !wasRoundable && isRoundable )
    {
        const double ipcRadiusRatio = PAD_UTILS::GetDefaultIpcRoundingRatio( *this, F_Cu );
        m_padStack.SetRoundRectRadiusRatio( ipcRadiusRatio, F_Cu );
    }
 
    SetDirty();
}
 
 
void PAD::SetProperty( PAD_PROP aProperty )
{
    m_property = aProperty;
 
    SetDirty();
}
 
 
void PAD::SetOrientation( const EDA_ANGLE& aAngle )
{
    if( const FOOTPRINT* parentFP = GetParentFootprint() )
        m_libOrientation = aAngle - parentFP->GetOrientation();
    else
        m_libOrientation = aAngle;
 
    m_padStack.SetOrientation( aAngle );
    SetDirty();
}
 
 
void PAD::SetFPRelativeOrientation( const EDA_ANGLE& aAngle )
{
    m_libOrientation = aAngle;
 
    if( const FOOTPRINT* parentFP = GetParentFootprint() )
        m_padStack.SetOrientation( aAngle + parentFP->GetOrientation() );
    else
        m_padStack.SetOrientation( aAngle );
 
    SetDirty();
}
 
 
EDA_ANGLE PAD::GetOrientation() const
{
    if( const FOOTPRINT* parentFP = GetParentFootprint() )
    {
        EDA_ANGLE angle = m_libOrientation.GetAngle() + parentFP->GetOrientation();
        return angle.Normalized();
    }
 
    return m_libOrientation.GetAngle();
}
 
 
EDA_ANGLE PAD::GetFPRelativeOrientation() const
{
    return m_libOrientation.GetAngle();
}
 
 
void PAD::Flip( const VECTOR2I& aCentre, FLIP_DIRECTION aFlipDirection )
{
    if( const FOOTPRINT* fp = GetParentFootprint() )
    {
        // Mirror in the footprint's library frame (rotation-independent).
        VECTOR2I libCentre = fp->GetTransform().InverseApply( aCentre );
        MIRROR( m_libPos, libCentre, aFlipDirection );
    }
    else
    {
        VECTOR2I newPos = GetPosition();
        MIRROR( newPos, aCentre, aFlipDirection );
        SetPosition( newPos );
    }
 
    m_padStack.ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                MIRROR( m_padStack.Offset( aLayer ), VECTOR2I{ 0, 0 }, aFlipDirection );
                MIRROR( m_padStack.TrapezoidDeltaSize( aLayer ), VECTOR2I{ 0, 0 }, aFlipDirection );
            } );
 
    SetFPRelativeOrientation( -GetFPRelativeOrientation() );
 
    auto mirrorBitFlags = []( int& aBitfield, int a, int b )
                          {
                              bool temp = aBitfield & a;
 
                              if( aBitfield & b )
                                  aBitfield |= a;
                              else
                                  aBitfield &= ~a;
 
                              if( temp )
                                  aBitfield |= b;
                              else
                                  aBitfield &= ~b;
                          };
 
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                if( aFlipDirection == FLIP_DIRECTION::LEFT_RIGHT )
                {
                    mirrorBitFlags( m_padStack.ChamferPositions( aLayer ), RECT_CHAMFER_TOP_LEFT,
                                    RECT_CHAMFER_TOP_RIGHT );
                    mirrorBitFlags( m_padStack.ChamferPositions( aLayer ), RECT_CHAMFER_BOTTOM_LEFT,
                                    RECT_CHAMFER_BOTTOM_RIGHT );
                }
                else
                {
                    mirrorBitFlags( m_padStack.ChamferPositions( aLayer ), RECT_CHAMFER_TOP_LEFT,
                                    RECT_CHAMFER_BOTTOM_LEFT );
                    mirrorBitFlags( m_padStack.ChamferPositions( aLayer ), RECT_CHAMFER_TOP_RIGHT,
                                    RECT_CHAMFER_BOTTOM_RIGHT );
                }
            } );
 
    m_padStack.FlipLayers( GetBoard() );
 
    // Flip pads layers after padstack geometry
    LSET flipped;
 
    for( PCB_LAYER_ID layer : m_padStack.LayerSet() )
        flipped.set( GetFlippedLayer( layer ) );
 
    SetLayerSet( flipped );
 
    // Flip the basic shapes, in custom pads
    FlipPrimitives( aFlipDirection );
 
    SetDirty();
}
 
 
void PAD::FlipPrimitives( FLIP_DIRECTION aFlipDirection )
{
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                for( std::shared_ptr<PCB_SHAPE>& primitive : m_padStack.Primitives( aLayer ) )
                {
                    // Ensure the primitive parent is up to date. Flip uses GetBoard() that
                    // imply primitive parent is valid
                    primitive->SetParent(this);
                    primitive->Flip( VECTOR2I( 0, 0 ), aFlipDirection );
                }
            } );
 
    SetDirty();
}
 
 
VECTOR2I PAD::ShapePos( PCB_LAYER_ID aLayer ) const
{
    VECTOR2I pos = GetPosition();
    VECTOR2I loc_offset = GetOffset( aLayer );
 
    if( loc_offset.x == 0 && loc_offset.y == 0 )
        return pos;
 
    RotatePoint( loc_offset, GetOrientation() );
 
    return pos + loc_offset;
}
 
 
void PAD::SwapShapePositions( PAD* aLhs, PAD* aRhs )
{
    wxCHECK( aLhs && aRhs, /* void */ );
 
    LSET uniqueLayerUnion;
 
    aLhs->Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID layer )
            {
                uniqueLayerUnion.set( layer );
            } );
 
    aRhs->Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID layer )
            {
                uniqueLayerUnion.set( layer );
            } );
 
    std::map<PCB_LAYER_ID, std::pair<VECTOR2I, VECTOR2I>> positions;
 
    for( PCB_LAYER_ID layer : uniqueLayerUnion.Seq() )
    {
        VECTOR2I lhsShapePos = aLhs->ShapePos( layer );
        VECTOR2I rhsShapePos = aRhs->ShapePos( layer );
 
        VECTOR2I lhsOffset = aLhs->GetOffset( layer );
        VECTOR2I rhsOffset = aRhs->GetOffset( layer );
 
        RotatePoint( lhsOffset, aLhs->GetOrientation() );
        RotatePoint( rhsOffset, aRhs->GetOrientation() );
 
        positions[layer].first = rhsShapePos - lhsOffset;
        positions[layer].second = lhsShapePos - rhsOffset;
    }
 
    aLhs->Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID layer )
            {
                aLhs->SetPosition( positions[layer].first );
            } );
 
    aRhs->Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID layer )
            {
                aRhs->SetPosition( positions[layer].second );
            } );
}
 
 
bool PAD::IsOnCopperLayer() const
{
    if( GetAttribute() == PAD_ATTRIB::NPTH )
    {
        // NPTH pads have no plated hole cylinder.  If their annular ring size is 0 or
        // negative, then they have no annular ring either.
        bool hasAnnularRing = true;
 
        Padstack().ForEachUniqueLayer(
                [&]( PCB_LAYER_ID aLayer )
                {
                    switch( GetShape( aLayer ) )
                    {
                    case PAD_SHAPE::CIRCLE:
                        if( m_padStack.Offset( aLayer ) == VECTOR2I( 0, 0 )
                            && m_padStack.Size( aLayer ).x <= m_padStack.Drill().size.x )
                        {
                            hasAnnularRing = false;
                        }
 
                        break;
 
                    case PAD_SHAPE::OVAL:
                        if( m_padStack.Offset( aLayer ) == VECTOR2I( 0, 0 )
                            && m_padStack.Size( aLayer ).x <= m_padStack.Drill().size.x
                            && m_padStack.Size( aLayer ).y <= m_padStack.Drill().size.y )
                        {
                            hasAnnularRing = false;
                        }
 
                        break;
 
                    default:
                        // We could subtract the hole polygon from the shape polygon for these, but it
                        // would be expensive and we're probably well out of the common use cases....
                        break;
                    }
                } );
 
        if( !hasAnnularRing )
            return false;
    }
 
    return ( m_padStack.LayerSet() & LSET::AllCuMask() ).any();
}
 
 
std::optional<int> PAD::GetLocalClearance( wxString* aSource ) const
{
    if( m_padStack.Clearance().has_value() && aSource )
        *aSource = _( "pad" );
 
    return m_padStack.Clearance();
}
 
 
std::optional<int> PAD::GetClearanceOverrides( wxString* aSource ) const
{
    if( m_padStack.Clearance().has_value() )
        return GetLocalClearance( aSource );
 
    if( FOOTPRINT* parentFootprint = GetParentFootprint() )
        return parentFootprint->GetClearanceOverrides( aSource );
 
    return std::optional<int>();
}
 
 
void PAD::SetLayerSet( const LSET& aLayers )
{
    m_padStack.SetLayerSet( aLayers );
    SetDirty();
 
    // In theory m_layer should never be read, but set it just to be safe.
    if( m_layer == UNDEFINED_LAYER || !aLayers.test( m_layer ) )
    {
        auto seq = aLayers.Seq();
        if( !seq.empty() )
            m_layer = seq.front();
        else
            m_layer = UNDEFINED_LAYER;
    }
 
    if( !( GetFlags() & ROUTER_TRANSIENT ) )
    {
        if( BOARD* board = GetBoard() )
            board->InvalidateClearanceCache( m_Uuid );
    }
}
 
 
int PAD::GetOwnClearance( PCB_LAYER_ID aLayer, wxString* aSource ) const
{
    // The NPTH vs regular pad logic is handled in DRC_ENGINE::GetCachedOwnClearance
    return BOARD_CONNECTED_ITEM::GetOwnClearance( aLayer, aSource );
}
 
 
int PAD::GetSolderMaskExpansion( PCB_LAYER_ID aLayer ) const
{
    // Pads defined only on mask layers (and perhaps on other tech layers) use the shape
    // defined by the pad settings only.  ALL other pads, even those that don't actually have
    // any copper (such as NPTH pads with holes the same size as the pad) get mask expansion.
    if( ( m_padStack.LayerSet() & LSET::AllCuMask() ).none() )
        return 0;
 
    if( IsFrontLayer( aLayer ) )
        aLayer = F_Mask;
    else if( IsBackLayer( aLayer ) )
        aLayer = B_Mask;
    else
        return 0;
 
    std::optional<int> margin;
 
    if( GetBoard() && GetBoard()->GetDesignSettings().m_DRCEngine
        && GetBoard()->GetDesignSettings().m_DRCEngine->HasRulesForConstraintType( SOLDER_MASK_EXPANSION_CONSTRAINT ) )
    {
        DRC_CONSTRAINT constraint;
        DRC_ENGINE*    drcEngine = GetBoard()->GetDesignSettings().m_DRCEngine.get();
 
        constraint = drcEngine->EvalRules( SOLDER_MASK_EXPANSION_CONSTRAINT, this, nullptr, aLayer );
 
        if( constraint.m_Value.HasOpt() )
            margin = constraint.m_Value.Opt();
    }
    else
    {
        margin = m_padStack.SolderMaskMargin( aLayer );
 
        if( !margin.has_value() )
        {
            if( FOOTPRINT* parentFootprint = GetParentFootprint() )
                margin = parentFootprint->GetLocalSolderMaskMargin();
        }
 
        if( !margin.has_value() )
        {
            if( const BOARD* brd = GetBoard() )
                margin = brd->GetDesignSettings().m_SolderMaskExpansion;
        }
    }
 
    int marginValue = margin.value_or( 0 );
 
    PCB_LAYER_ID cuLayer = ( aLayer == B_Mask ) ? B_Cu : F_Cu;
 
    // ensure mask have a size always >= 0
    if( marginValue < 0 )
    {
        int minsize = -std::min( m_padStack.Size( cuLayer ).x, m_padStack.Size( cuLayer ).y ) / 2;
 
        if( marginValue < minsize )
            marginValue = minsize;
    }
 
    return marginValue;
}
 
 
VECTOR2I PAD::GetSolderPasteMargin( PCB_LAYER_ID aLayer ) const
{
    // Pads defined only on mask layers (and perhaps on other tech layers) use the shape
    // defined by the pad settings only.  ALL other pads, even those that don't actually have
    // any copper (such as NPTH pads with holes the same size as the pad) get paste expansion.
    if( ( m_padStack.LayerSet() & LSET::AllCuMask() ).none() )
        return VECTOR2I( 0, 0 );
 
    if( IsFrontLayer( aLayer ) )
        aLayer = F_Paste;
    else if( IsBackLayer( aLayer ) )
        aLayer = B_Paste;
    else
        return VECTOR2I( 0, 0 );
 
    std::optional<int>    margin;
    std::optional<double> mratio;
 
    std::shared_ptr<DRC_ENGINE> drcEngine;
 
    if( GetBoard() )
        drcEngine = GetBoard()->GetDesignSettings().m_DRCEngine;
 
    bool hasAbsRules = drcEngine
                       && drcEngine->HasRulesForConstraintType( SOLDER_PASTE_ABS_MARGIN_CONSTRAINT );
    bool hasRelRules = drcEngine
                       && drcEngine->HasRulesForConstraintType( SOLDER_PASTE_REL_MARGIN_CONSTRAINT );
 
    if( hasAbsRules || hasRelRules )
    {
        DRC_CONSTRAINT constraint;
 
        if( hasAbsRules )
        {
            constraint = drcEngine->EvalRules( SOLDER_PASTE_ABS_MARGIN_CONSTRAINT, this, nullptr,
                                               aLayer );
 
            if( constraint.m_Value.HasOpt() )
                margin = constraint.m_Value.Opt();
        }
 
        if( hasRelRules )
        {
            constraint = drcEngine->EvalRules( SOLDER_PASTE_REL_MARGIN_CONSTRAINT, this, nullptr,
                                               aLayer );
 
            if( constraint.m_Value.HasOpt() )
                mratio = constraint.m_Value.Opt() / 1000.0;
        }
    }
 
    if( !margin.has_value() )
    {
        margin = m_padStack.SolderPasteMargin( aLayer );
 
        if( !margin.has_value() )
        {
            if( FOOTPRINT* parentFootprint = GetParentFootprint() )
                margin = parentFootprint->GetLocalSolderPasteMargin();
        }
 
        if( !margin.has_value() )
        {
            if( const BOARD* brd = GetBoard() )
                margin = brd->GetDesignSettings().m_SolderPasteMargin;
        }
    }
 
    if( !mratio.has_value() )
    {
        mratio = m_padStack.SolderPasteMarginRatio( aLayer );
 
        if( !mratio.has_value() )
        {
            if( FOOTPRINT* parentFootprint = GetParentFootprint() )
                mratio = parentFootprint->GetLocalSolderPasteMarginRatio();
        }
 
        if( !mratio.has_value() )
        {
            if( const BOARD* brd = GetBoard() )
                mratio = brd->GetDesignSettings().m_SolderPasteMarginRatio;
        }
    }
 
    PCB_LAYER_ID cuLayer = ( aLayer == B_Paste ) ? B_Cu : F_Cu;
    VECTOR2I     padSize = GetSize( cuLayer );
 
    VECTOR2I pad_margin;
    pad_margin.x = margin.value_or( 0 ) + KiROUND( padSize.x * mratio.value_or( 0 ) );
    pad_margin.y = margin.value_or( 0 ) + KiROUND( padSize.y * mratio.value_or( 0 ) );
 
    // ensure paste have a size always >= 0
    if( m_padStack.Shape( aLayer ) != PAD_SHAPE::CUSTOM )
    {
        if( pad_margin.x < -padSize.x / 2 )
            pad_margin.x = -padSize.x / 2;
 
        if( pad_margin.y < -padSize.y / 2 )
            pad_margin.y = -padSize.y / 2;
    }
 
    return pad_margin;
}
 
 
ZONE_CONNECTION PAD::GetZoneConnectionOverrides( wxString* aSource ) const
{
    ZONE_CONNECTION connection = m_padStack.ZoneConnection().value_or( ZONE_CONNECTION::INHERITED );
 
    if( connection != ZONE_CONNECTION::INHERITED )
    {
        if( aSource )
            *aSource = _( "pad" );
    }
 
    if( connection == ZONE_CONNECTION::INHERITED )
    {
        if( FOOTPRINT* parentFootprint = GetParentFootprint() )
            connection = parentFootprint->GetZoneConnectionOverrides( aSource );
    }
 
    return connection;
}
 
 
int PAD::GetLocalSpokeWidthOverride( wxString* aSource ) const
{
    if( m_padStack.ThermalSpokeWidth().has_value() && aSource )
        *aSource = _( "pad" );
 
    return m_padStack.ThermalSpokeWidth().value_or( 0 );
}
 
 
int PAD::GetLocalThermalGapOverride( wxString* aSource ) const
{
    if( m_padStack.ThermalGap().has_value() && aSource )
        *aSource = _( "pad" );
 
    return GetLocalThermalGapOverride().value_or( 0 );
}
 
 
void PAD::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
{
    wxString   msg;
    FOOTPRINT* parentFootprint = static_cast<FOOTPRINT*>( m_parent );
 
    if( aFrame->GetName() == PCB_EDIT_FRAME_NAME )
    {
        if( parentFootprint )
            aList.emplace_back( _( "Footprint" ), parentFootprint->GetReference() );
    }
 
    aList.emplace_back( _( "Pad" ), m_number );
 
    if( !GetPinFunction().IsEmpty() )
        aList.emplace_back( _( "Pin Name" ), GetPinFunction() );
 
    if( !GetPinType().IsEmpty() )
        aList.emplace_back( _( "Pin Type" ), GetPinType() );
 
    if( aFrame->GetName() == PCB_EDIT_FRAME_NAME )
    {
        aList.emplace_back( _( "Net" ), UnescapeString( GetNetname() ) );
 
        if( NETINFO_ITEM* netInfo = GetNet() )
        {
            const wxString& chainName = netInfo->GetNetChain();
 
            if( !chainName.IsEmpty() )
                aList.emplace_back( _( "Net Chain" ), UnescapeString( chainName ) );
        }
 
        aList.emplace_back( _( "Resolved Netclass" ),
                            UnescapeString( GetEffectiveNetClass()->GetHumanReadableName() ) );
 
        if( IsLocked() )
            aList.emplace_back( _( "Status" ), _( "Locked" ) );
    }
 
    if( GetAttribute() == PAD_ATTRIB::SMD || GetAttribute() == PAD_ATTRIB::CONN )
        aList.emplace_back( _( "Layer" ), LayerMaskDescribe() );
 
    if( aFrame->GetName() == FOOTPRINT_EDIT_FRAME_NAME )
    {
        if( GetAttribute() == PAD_ATTRIB::SMD )
        {
            // TOOD(JE) padstacks
            const std::shared_ptr<SHAPE_POLY_SET>& poly = GetEffectivePolygon( PADSTACK::TEMP_ALL_LAYERS );
            double area = poly->Area();
 
            aList.emplace_back( _( "Area" ), aFrame->MessageTextFromValue( area, true, EDA_DATA_TYPE::AREA ) );
        }
    }
 
    // Show the pad shape, attribute and property
    wxString props = ShowPadAttr();
 
    if( GetProperty() != PAD_PROP::NONE )
        props += ',';
 
    switch( GetProperty() )
    {
    case PAD_PROP::NONE:                                            break;
    case PAD_PROP::BGA:            props += _( "BGA" );             break;
    case PAD_PROP::FIDUCIAL_GLBL:  props += _( "Fiducial global" ); break;
    case PAD_PROP::FIDUCIAL_LOCAL: props += _( "Fiducial local" );  break;
    case PAD_PROP::TESTPOINT:      props += _( "Test point" );      break;
    case PAD_PROP::HEATSINK:       props += _( "Heat sink" );       break;
    case PAD_PROP::CASTELLATED:    props += _( "Castellated" );     break;
    case PAD_PROP::MECHANICAL:     props += _( "Mechanical" );      break;
    case PAD_PROP::PRESSFIT:       props += _( "Press-fit" );       break;
    }
 
    std::set<bool>      circles;
    std::set<PAD_SHAPE> shapes;
    std::set<int>       widths;
    std::set<int>       heights;
 
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                PAD_SHAPE shape = GetShape( aLayer );
                VECTOR2I  size = GetSize( aLayer );
 
                circles.insert( shape == PAD_SHAPE::CIRCLE || ( shape == PAD_SHAPE::OVAL && size.x == size.y ) );
                shapes.insert( shape );
                widths.insert( size.x );
                heights.insert( size.y );
            } );
 
    aList.emplace_back( shapes.size() == 1 ? ShowPadShape( *shapes.begin() ) : _( "(mixed shapes)" ), props );
 
    if( circles.size() == 1 && *circles.begin() )
    {
        aList.emplace_back( _( "Diameter" ), widths.size() == 1 ? aFrame->MessageTextFromValue( *widths.begin() )
                                                                : _( "(mixed)" ) );
    }
    else
    {
        aList.emplace_back( _( "Width" ), widths.size() == 1 ? aFrame->MessageTextFromValue( *widths.begin() )
                                                             : _( "(mixed)" ) );
        aList.emplace_back( _( "Height" ), heights.size() == 1 ? aFrame->MessageTextFromValue( *heights.begin() )
                                                               : _( "(mixed)" ) );
    }
 
    EDA_ANGLE fp_orient = parentFootprint ? parentFootprint->GetOrientation() : ANGLE_0;
    EDA_ANGLE pad_orient = GetOrientation() - fp_orient;
    pad_orient.Normalize180();
 
    if( !fp_orient.IsZero() )
        msg.Printf( wxT( "%g(+ %g)" ), pad_orient.AsDegrees(), fp_orient.AsDegrees() );
    else
        msg.Printf( wxT( "%g" ), GetOrientation().AsDegrees() );
 
    aList.emplace_back( _( "Rotation" ), msg );
 
    if( GetPadToDieLength() )
        aList.emplace_back( _( "Length in Package" ), aFrame->MessageTextFromValue( GetPadToDieLength() ) );
 
    const VECTOR2I drill = GetDrillSize();
 
    if( drill.x > 0 || drill.y > 0 )
    {
        if( GetDrillShape() == PAD_DRILL_SHAPE::CIRCLE )
        {
            aList.emplace_back( _( "Hole" ),
                                wxString::Format( wxT( "%s" ),
                                                  aFrame->MessageTextFromValue( drill.x ) ) );
        }
        else
        {
            aList.emplace_back( _( "Hole X / Y" ),
                                wxString::Format( wxT( "%s / %s" ),
                                                  aFrame->MessageTextFromValue( drill.x ),
                                                  aFrame->MessageTextFromValue( drill.y ) ) );
        }
    }
 
    wxString source;
    int      clearance = GetOwnClearance( UNDEFINED_LAYER, &source );
 
    if( !source.IsEmpty() )
    {
        aList.emplace_back( wxString::Format( _( "Min Clearance: %s" ),
                                              aFrame->MessageTextFromValue( clearance ) ),
                            wxString::Format( _( "(from %s)" ),
                                              source ) );
    }
#if 0
    // useful for debug only
    aList.emplace_back( wxT( "UUID" ), m_Uuid.AsString() );
#endif
}
 
 
bool PAD::HitTest( const VECTOR2I& aPosition, int aAccuracy, PCB_LAYER_ID aLayer ) const
{
    if( !IsOnLayer( aLayer ) )
        return false;
 
    VECTOR2I delta = aPosition - GetPosition();
    int      boundingRadius = GetBoundingRadius() + aAccuracy;
 
    if( delta.SquaredEuclideanNorm() > SEG::Square( boundingRadius ) )
        return false;
 
    bool contains = GetEffectivePolygon( aLayer, ERROR_INSIDE )->Contains( aPosition, -1, aAccuracy );
 
    return contains;
}
 
 
bool PAD::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
{
    VECTOR2I delta = aPosition - GetPosition();
    int      boundingRadius = GetBoundingRadius() + aAccuracy;
 
    if( delta.SquaredEuclideanNorm() > SEG::Square( boundingRadius ) )
        return false;
 
    bool contains = false;
 
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID l )
            {
                if( contains )
                    return;
 
                if( GetEffectivePolygon( l, ERROR_INSIDE )->Contains( aPosition, -1, aAccuracy ) )
                    contains = true;
            } );
 
    contains |= GetEffectiveHoleShape()->Collide( aPosition, aAccuracy );
 
    return contains;
}
 
 
bool PAD::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
{
    BOX2I arect = aRect;
    arect.Normalize();
    arect.Inflate( aAccuracy );
 
    BOX2I bbox = GetBoundingBox();
 
    if( aContained )
    {
        return arect.Contains( bbox );
    }
    else
    {
        // Fast test: if aRect is outside the polygon bounding box,
        // rectangles cannot intersect
        if( !arect.Intersects( bbox ) )
            return false;
 
        bool hit = false;
 
        Padstack().ForEachUniqueLayer(
                [&]( PCB_LAYER_ID aLayer )
                {
                    if( hit )
                        return;
 
                    const std::shared_ptr<SHAPE_POLY_SET>& poly = GetEffectivePolygon( aLayer, ERROR_INSIDE );
 
                    int count = poly->TotalVertices();
 
                    for( int ii = 0; ii < count; ii++ )
                    {
                        VECTOR2I vertex = poly->CVertex( ii );
                        VECTOR2I vertexNext = poly->CVertex( ( ii + 1 ) % count );
 
                        // Test if the point is within aRect
                        if( arect.Contains( vertex ) )
                        {
                            hit = true;
                            break;
                        }
 
                        // Test if this edge intersects aRect
                        if( arect.Intersects( vertex, vertexNext ) )
                        {
                            hit = true;
                            break;
                        }
                    }
                } );
 
        if( !hit )
        {
            SHAPE_RECT rect( arect );
            hit |= GetEffectiveHoleShape()->Collide( &rect );
        }
 
        return hit;
    }
}
 
 
bool PAD::HitTest( const SHAPE_LINE_CHAIN& aPoly, bool aContained ) const
{
    SHAPE_COMPOUND effectiveShape;
 
    // Add padstack shapes
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                effectiveShape.AddShape( GetEffectiveShape( aLayer ) );
            } );
 
    // Add hole shape
    effectiveShape.AddShape( GetEffectiveHoleShape() );
 
    return KIGEOM::ShapeHitTest( aPoly, effectiveShape, aContained );
}
 
 
int PAD::Compare( const PAD* aPadRef, const PAD* aPadCmp )
{
    int diff;
 
    if( ( diff = static_cast<int>( aPadRef->m_attribute ) - static_cast<int>( aPadCmp->m_attribute ) ) != 0 )
        return diff;
 
    return PADSTACK::Compare( &aPadRef->Padstack(), &aPadCmp->Padstack() );
}
 
 
void PAD::Rotate( const VECTOR2I& aRotCentre, const EDA_ANGLE& aAngle )
{
    VECTOR2I newPos = GetPosition();
    RotatePoint( newPos, aRotCentre, aAngle );
    SetPosition( newPos );
 
    SetOrientation( GetOrientation() + aAngle );
}
 
 
void PAD::GetPrimitiveLibScale( double& aScaleX, double& aScaleY ) const
{
    aScaleX = 1.0;
    aScaleY = 1.0;
 
    if( const FOOTPRINT* fp = GetParentFootprint() )
    {
        const TRANSFORM_TRS& xform = fp->GetTransform();
        scaleInChildFrame( std::abs( xform.GetScaleX() ), std::abs( xform.GetScaleY() ), GetFPRelativeOrientation(),
                           aScaleX, aScaleY );
    }
}
 
 
void PAD::rebakePrimitiveToFootprint( PCB_SHAPE* aPrimitive ) const
{
    if( !GetParentFootprint() )
        return;
 
    double localSx, localSy;
    GetPrimitiveLibScale( localSx, localSy );
    aPrimitive->RebakeWithScale( localSx, localSy );
}
 
 
void PAD::OnFootprintRescaled( double aRatioX, double aRatioY, double aLinearFactor, const VECTOR2I& aAnchor,
                               const EDA_ANGLE& aParentRotate )
{
    // Pad size, drill, and offset auto-derive from lib-frame padstack values
    // through the parent transform on read. Custom-shape primitives carry their
    // own geometry in the pad frame and are excluded from the read-time transform
    // (transformFp returns null for pad children), so rescale them explicitly.
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                for( const std::shared_ptr<PCB_SHAPE>& prim : Padstack().Primitives( aLayer ) )
                    rebakePrimitiveToFootprint( prim.get() );
            } );
 
    OnFootprintTransformed();
}
 
 
void PAD::OnFootprintTransformed()
{
    EDA_ANGLE parentOrient = ANGLE_0;
 
    if( const FOOTPRINT* fp = GetParentFootprint() )
        parentOrient = fp->GetOrientation();
 
    Padstack().SetOrientation( GetFPRelativeOrientation() + parentOrient );
    SetDirty();
}
 
 
wxString PAD::ShowPadShape( PAD_SHAPE aShape )
{
    switch( aShape )
    {
    case PAD_SHAPE::CIRCLE:         return _( "Circle" );
    case PAD_SHAPE::OVAL:           return _( "Oval" );
    case PAD_SHAPE::RECTANGLE:      return _( "Rectangle" );
    case PAD_SHAPE::TRAPEZOID:      return _( "Trapezoid" );
    case PAD_SHAPE::ROUNDRECT:      return _( "Rounded rectangle" );
    case PAD_SHAPE::CHAMFERED_RECT: return _( "Chamfered rectangle" );
    case PAD_SHAPE::CUSTOM:         return _( "Custom shape" );
    default:                        return wxT( "???" );
    }
}
 
 
wxString PAD::ShowPadShape( PCB_LAYER_ID aLayer ) const
{
    return ShowPadShape( GetShape( aLayer ) );
}
 
 
wxString PAD::ShowLegacyPadShape( PCB_LAYER_ID aLayer ) const
{
    switch( GetShape( aLayer ) )
    {
    case PAD_SHAPE::CIRCLE:         return _( "Circle" );
    case PAD_SHAPE::OVAL:           return _( "Oval" );
    case PAD_SHAPE::RECTANGLE:      return _( "Rect" );
    case PAD_SHAPE::TRAPEZOID:      return _( "Trap" );
    case PAD_SHAPE::ROUNDRECT:      return _( "Roundrect" );
    case PAD_SHAPE::CHAMFERED_RECT: return _( "Chamferedrect" );
    case PAD_SHAPE::CUSTOM:         return _( "CustomShape" );
    default:                        return wxT( "???" );
    }
}
 
 
wxString PAD::ShowPadAttr() const
{
    switch( GetAttribute() )
    {
    case PAD_ATTRIB::PTH:    return _( "PTH" );
    case PAD_ATTRIB::SMD:    return _( "SMD" );
    case PAD_ATTRIB::CONN:   return _( "Conn" );
    case PAD_ATTRIB::NPTH:   return _( "NPTH" );
    default:                 return wxT( "???" );
    }
}
 
 
wxString PAD::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
{
    FOOTPRINT* parentFP = GetParentFootprint();
 
    // Don't report parent footprint info from footprint editor, viewer, etc.
    if( GetBoard() && GetBoard()->GetBoardUse() == BOARD_USE::FPHOLDER )
        parentFP = nullptr;
 
    if( GetAttribute() == PAD_ATTRIB::NPTH )
    {
        if( parentFP )
            return wxString::Format( _( "NPTH pad of %s" ), parentFP->GetReference() );
        else
            return _( "NPTH pad" );
    }
    else if( GetNumber().IsEmpty() )
    {
        if( GetAttribute() == PAD_ATTRIB::SMD || GetAttribute() == PAD_ATTRIB::CONN )
        {
            if( parentFP )
            {
                return wxString::Format( _( "Pad %s of %s on %s" ),
                                         GetNetnameMsg(),
                                         parentFP->GetReference(),
                                         LayerMaskDescribe() );
            }
            else
            {
                return wxString::Format( _( "Pad on %s" ),
                                         LayerMaskDescribe() );
            }
        }
        else
        {
            if( parentFP )
            {
                return wxString::Format( _( "PTH pad %s of %s" ),
                                         GetNetnameMsg(),
                                         parentFP->GetReference() );
            }
            else
            {
                return _( "PTH pad" );
            }
        }
    }
    else
    {
        if( GetAttribute() == PAD_ATTRIB::SMD || GetAttribute() == PAD_ATTRIB::CONN )
        {
            if( parentFP )
            {
                return wxString::Format( _( "Pad %s %s of %s on %s" ),
                                         GetNumber(),
                                         GetNetnameMsg(),
                                         parentFP->GetReference(),
                                         LayerMaskDescribe() );
            }
            else
            {
                return wxString::Format( _( "Pad %s on %s" ),
                                         GetNumber(),
                                         LayerMaskDescribe() );
            }
        }
        else
        {
            if( parentFP )
            {
                return wxString::Format( _( "PTH pad %s %s of %s" ),
                                         GetNumber(),
                                         GetNetnameMsg(),
                                         parentFP->GetReference() );
            }
            else
            {
                return wxString::Format( _( "PTH pad %s" ),
                                         GetNumber() );
            }
        }
    }
}
 
 
BITMAPS PAD::GetMenuImage() const
{
    return BITMAPS::pad;
}
 
 
EDA_ITEM* PAD::Clone() const
{
    PAD* cloned = new PAD( *this );
 
    // Ensure the cloned primitives of the pad stack have the right parent
    cloned->Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                for( std::shared_ptr<PCB_SHAPE>& primitive : cloned->m_padStack.Primitives( aLayer ) )
                    primitive->SetParent( cloned );
            } );
 
    return cloned;
}
 
 
std::vector<int> PAD::ViewGetLayers() const
{
    std::vector<int> layers;
    layers.reserve( 64 );
 
    // A drill map on a layer asks the holes to draw their symbols there, so the symbols stay
    // in the view index and one hole edit repaints one hole
    if( m_attribute == PAD_ATTRIB::PTH || m_attribute == PAD_ATTRIB::NPTH )
    {
        if( const BOARD* drillBoard = GetBoard() )
        {
            for( PCB_LAYER_ID mapLayer : drillBoard->DrillSymbolLayers().Seq() )
                layers.push_back( DRILL_SYMBOL_LAYER_FOR( mapLayer ) );
        }
    }
 
    // These 2 types of pads contain a hole
    if( m_attribute == PAD_ATTRIB::PTH )
    {
        layers.push_back( LAYER_PAD_PLATEDHOLES );
        layers.push_back( LAYER_PAD_HOLEWALLS );
    }
 
    if( m_attribute == PAD_ATTRIB::NPTH )
        layers.push_back( LAYER_NON_PLATEDHOLES );
 
 
    if( IsLocked() || ( GetParentFootprint() && GetParentFootprint()->IsLocked() ) )
        layers.push_back( LAYER_LOCKED_ITEM_SHADOW );
 
    LSET cuLayers = ( m_padStack.LayerSet() & LSET::AllCuMask() );
 
    // Don't spend cycles rendering layers that aren't visible
    if( const BOARD* board = GetBoard() )
        cuLayers &= board->GetEnabledLayers();
 
    if( cuLayers.count() > 1 )
    {
        // Multi layer pad
        for( PCB_LAYER_ID layer : cuLayers.Seq() )
        {
            layers.push_back( LAYER_PAD_COPPER_START + layer );
            layers.push_back( LAYER_CLEARANCE_START + layer );
        }
 
        layers.push_back( LAYER_PAD_NETNAMES );
    }
    else if( IsOnLayer( F_Cu ) )
    {
        layers.push_back( LAYER_PAD_COPPER_START );
        layers.push_back( LAYER_CLEARANCE_START );
 
        // Is this a PTH pad that has only front copper?  If so, we need to also display the
        // net name on the PTH netname layer so that it isn't blocked by the drill hole.
        if( m_attribute == PAD_ATTRIB::PTH )
            layers.push_back( LAYER_PAD_NETNAMES );
        else
            layers.push_back( LAYER_PAD_FR_NETNAMES );
    }
    else if( IsOnLayer( B_Cu ) )
    {
        layers.push_back( LAYER_PAD_COPPER_START + B_Cu );
        layers.push_back( LAYER_CLEARANCE_START + B_Cu );
 
        // Is this a PTH pad that has only back copper?  If so, we need to also display the
        // net name on the PTH netname layer so that it isn't blocked by the drill hole.
        if( m_attribute == PAD_ATTRIB::PTH )
            layers.push_back( LAYER_PAD_NETNAMES );
        else
            layers.push_back( LAYER_PAD_BK_NETNAMES );
    }
    else if( cuLayers.count() == 1 )
    {
        PCB_LAYER_ID layer = cuLayers.Seq().front();
 
        layers.push_back( LAYER_PAD_COPPER_START + layer );
        layers.push_back( LAYER_CLEARANCE_START + layer );
        layers.push_back( LAYER_PAD_NETNAMES );
    }
 
    // Check non-copper layers. This list should include all the layers that the
    // footprint editor allows a pad to be placed on.
    static const PCB_LAYER_ID layers_mech[] = { F_Mask, B_Mask, F_Paste, B_Paste,
        F_Adhes, B_Adhes, F_SilkS, B_SilkS, Dwgs_User, Eco1_User, Eco2_User };
 
    for( PCB_LAYER_ID each_layer : layers_mech )
    {
        if( IsOnLayer( each_layer ) )
            layers.push_back( each_layer );
    }
 
    return layers;
}
 
 
double PAD::ViewGetLOD( int aLayer, const KIGFX::VIEW* aView ) const
{
    PCB_PAINTER&         painter = static_cast<PCB_PAINTER&>( *aView->GetPainter() );
    PCB_RENDER_SETTINGS& renderSettings = *painter.GetSettings();
    const BOARD*         board = GetBoard();
 
    // Reviewing a drill drawing with pads hidden is normal, so the symbols answer to the
    // map's own layer rather than to the pads meta control
    if( IsDrillSymbolLayer( aLayer ) )
    {
        return aView->IsLayerVisibleCached( aLayer - LAYER_DRILL_SYMBOL_START ) ? LOD_SHOW
                                                                                : LOD_HIDE;
    }
 
    // Meta control for hiding all pads
    if( !aView->IsLayerVisibleCached( LAYER_PADS ) )
        return LOD_HIDE;
 
    // Handle Render tab switches
    //const PCB_LAYER_ID& pcbLayer = static_cast<PCB_LAYER_ID>( aLayer );
 
    {
        const LSET padLayers = GetLayerSet();
        const bool onFront = ( padLayers & LSET::FrontMask() ).any();
        const bool onBack = ( padLayers & LSET::BackMask() ).any();
        const bool frVis = aView->IsLayerVisible( LAYER_FOOTPRINTS_FR );
        const bool bkVis = aView->IsLayerVisible( LAYER_FOOTPRINTS_BK );
 
        if( onFront && !onBack && !frVis )
            return LOD_HIDE;
 
        if( onBack && !onFront && !bkVis )
            return LOD_HIDE;
 
        if( onFront && onBack && !frVis && !bkVis )
            return LOD_HIDE;
    }
 
    // Selection and net highlight draw a pad on layers where it otherwise draws nothing
    const bool drawnRegardless = IsSelected() || renderSettings.IsPrinting()
                                 || ( renderSettings.IsHighlightEnabled()
                                      && renderSettings.GetHighlightNetCodes().contains( GetNetCode() ) );
 
    if( !drawnRegardless )
    {
        // The painter draws a pad copper layer only where the pad flashes, plus the post-machining
        // indicator of a layer that has one
        if( IsPadCopperLayer( aLayer ) )
        {
            const PCB_LAYER_ID copperLayer = ToLAYER_ID( aLayer - LAYER_PAD_COPPER_START );
 
            if( !FlashLayer( copperLayer ) && GetPostMachiningKnockout( copperLayer ) <= 0 )
                return LOD_HIDE;
        }
 
        // The painter draws clearance outlines only when the pad clearance option is on
        if( IsClearanceLayer( aLayer ) && pcbconfig() && !pcbconfig()->m_Display.m_PadClearance )
            return LOD_HIDE;
    }
 
    if( IsHoleLayer( aLayer ) )
    {
        LSET visiblePhysical = board->GetVisibleLayers();
        visiblePhysical &= board->GetEnabledLayers();
        visiblePhysical &= LSET::PhysicalLayersMask();
 
        if( !visiblePhysical.any() )
            return LOD_HIDE;
    }
    else if( IsNetnameLayer( aLayer ) )
    {
        if( renderSettings.GetHighContrast() )
        {
            // Hide netnames unless pad is flashed to a high-contrast layer
            if( !FlashLayer( renderSettings.GetPrimaryHighContrastLayer() ) )
                return LOD_HIDE;
        }
        else
        {
            LSET visible = board->GetVisibleLayers();
            visible &= board->GetEnabledLayers();
 
            // Hide netnames unless pad is flashed to a visible layer
            if( !FlashLayer( visible ) )
                return LOD_HIDE;
        }
 
        // Netnames will be shown only if zoom is appropriate
        const int minSize = std::min( GetBoundingBox().GetWidth(), GetBoundingBox().GetHeight() );
 
        return lodScaleForThreshold( aView, minSize, pcbIUScale.mmToIU( 0.5 ) );
    }
 
    VECTOR2L padSize = GetBoundingBox().GetSize();
    int64_t  minSide = std::min( padSize.x, padSize.y );
 
    if( minSide > 0 )
        return std::min( lodScaleForThreshold( aView, minSide, pcbIUScale.mmToIU( 0.2 ) ), 3.5 );
 
    return LOD_SHOW;
}
 
 
const BOX2I PAD::ViewBBox() const
{
    // Bounding box includes soldermask too. Remember mask and/or paste margins can be < 0
    int      solderMaskMargin = 0;
    VECTOR2I solderPasteMargin;
 
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                solderMaskMargin = std::max( solderMaskMargin, std::max( GetSolderMaskExpansion( aLayer ), 0 ) );
                VECTOR2I layerMargin = GetSolderPasteMargin( aLayer );
                solderPasteMargin.x = std::max( solderPasteMargin.x, layerMargin.x );
                solderPasteMargin.y = std::max( solderPasteMargin.y, layerMargin.y );
            } );
 
    BOX2I    bbox              = GetBoundingBox();
    int      clearance                                 = 0;
 
    // If we're drawing clearance lines then get the biggest possible clearance
    if( PCBNEW_SETTINGS* cfg = dynamic_cast<PCBNEW_SETTINGS*>( Kiface().KifaceSettings() ) )
    {
        if( cfg && cfg->m_Display.m_PadClearance && GetBoard() )
            clearance = GetBoard()->GetMaxClearanceValue();
    }
 
    // Look for the biggest possible bounding box
    int xMargin = std::max( solderMaskMargin, solderPasteMargin.x ) + clearance;
    int yMargin = std::max( solderMaskMargin, solderPasteMargin.y ) + clearance;
 
    BOX2I viewBox( VECTOR2I( bbox.GetOrigin() ) - VECTOR2I( xMargin, yMargin ),
                   VECTOR2I( bbox.GetSize() ) + VECTOR2I( 2 * xMargin, 2 * yMargin ) );
 
    // Only a hole draws a drill symbol, so an SMD pad would just be given an oversized box
    if( HasHole() && GetBoard() )
        return GetBoard()->ExpandBoundingBoxForDrillSymbols( viewBox );
 
    return viewBox;
}
 
 
void PAD::ImportSettingsFrom( const PAD& aMasterPad )
{
    SetPadstack( aMasterPad.Padstack() );
    // Layer Set should be updated before calling SetAttribute()
    SetLayerSet( aMasterPad.GetLayerSet() );
    SetAttribute( aMasterPad.GetAttribute() );
    // Unfortunately, SetAttribute() can change m_layerMask.
    // Be sure we keep the original mask by calling SetLayerSet() after SetAttribute()
    SetLayerSet( aMasterPad.GetLayerSet() );
    SetProperty( aMasterPad.GetProperty() );
 
    // Must be after setting attribute and layerSet
    if( !CanHaveNumber() )
        SetNumber( wxEmptyString );
 
    // I am not sure the m_LengthPadToDie should be imported, because this is a parameter
    // really specific to a given pad (JPC).
#if 0
    SetPadToDieLength( aMasterPad.GetPadToDieLength() );
    SetPadToDieDelay( aMasterPad.GetPadToDieDelay() );
#endif
 
    // The pad orientation, for historical reasons is the pad rotation + parent rotation.
    EDA_ANGLE pad_rot = aMasterPad.GetOrientation();
 
    if( aMasterPad.GetParentFootprint() )
        pad_rot -= aMasterPad.GetParentFootprint()->GetOrientation();
 
    if( GetParentFootprint() )
        pad_rot += GetParentFootprint()->GetOrientation();
 
    SetOrientation( pad_rot );
 
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                // Ensure that circles are circles
                // Stay in the library frame, since a board-frame round trip under a scale rounds the size
                if( aMasterPad.GetShape( aLayer ) == PAD_SHAPE::CIRCLE )
                    SetLibSize( aLayer, VECTOR2I( Padstack().Size( aLayer ).x, Padstack().Size( aLayer ).x ) );
            } );
 
    switch( aMasterPad.GetAttribute() )
    {
    case PAD_ATTRIB::SMD:
    case PAD_ATTRIB::CONN:
        // These pads have no hole, or any kind of drilling.
        PAD_UTILS::RemoveAllDrillsFromPadstack( m_padStack );
        break;
 
    default:
        ;
    }
 
    // copy also local settings:
    SetLocalClearance( aMasterPad.GetLocalClearance() );
    SetLocalSolderMaskMargin( aMasterPad.GetLocalSolderMaskMargin() );
    SetLocalSolderPasteMargin( aMasterPad.GetLocalSolderPasteMargin() );
    SetLocalSolderPasteMarginRatio( aMasterPad.GetLocalSolderPasteMarginRatio() );
 
    SetLocalZoneConnection( aMasterPad.GetLocalZoneConnection() );
    SetLocalThermalSpokeWidthOverride( aMasterPad.GetLocalThermalSpokeWidthOverride() );
    SetThermalSpokeAngle( aMasterPad.GetThermalSpokeAngle() );
    SetLocalThermalGapOverride( aMasterPad.GetLocalThermalGapOverride() );
 
    SetCustomShapeInZoneOpt( aMasterPad.GetCustomShapeInZoneOpt() );
 
    m_teardropParams = aMasterPad.m_teardropParams;
 
    SetDirty();
}
 
 
void PAD::swapData( BOARD_ITEM* aImage )
{
    assert( aImage->Type() == PCB_PAD_T );
 
    std::swap( *this, *static_cast<PAD*>( aImage ) );
}
 
 
bool PAD::TransformHoleToPolygon( SHAPE_POLY_SET& aBuffer, int aClearance, int aError,
                                  ERROR_LOC aErrorLoc ) const
{
    VECTOR2I drillsize = GetDrillSize();
 
    if( !drillsize.x || !drillsize.y )
        return false;
 
    std::shared_ptr<SHAPE_SEGMENT> slot = GetEffectiveHoleShape();
 
    TransformOvalToPolygon( aBuffer, slot->GetSeg().A, slot->GetSeg().B, slot->GetWidth() + aClearance * 2,
                            aError, aErrorLoc );
 
    return true;
}
 
 
double PAD::GetCoverageArea( int aTextMargin ) const
{
    SHAPE_POLY_SET poly;
 
    Padstack().ForEachUniqueLayer(
            [&]( PCB_LAYER_ID aLayer )
            {
                SHAPE_POLY_SET layerPoly;
                TransformShapeToPolygon( layerPoly, aLayer, 0, ARC_LOW_DEF, ERROR_OUTSIDE );
                poly.BooleanAdd( layerPoly );
            } );
 
    return polygonArea( poly );
}
 
 
void PAD::TransformShapeToPolygon( SHAPE_POLY_SET& aBuffer, PCB_LAYER_ID aLayer, int aClearance,
                                   int aMaxError, ERROR_LOC aErrorLoc, bool ignoreLineWidth ) const
{
    wxASSERT_MSG( aLayer != UNDEFINED_LAYER,
                  wxT( "UNDEFINED_LAYER is no longer allowed for PAD::TransformShapeToPolygon" ) );
 
    // minimal segment count to approximate a circle to create the polygonal pad shape
    // This minimal value is mainly for very small pads, like SM0402.
    // Most of time pads are using the segment count given by aError value.
    const int      pad_min_seg_per_circle_count = 16;
    const VECTOR2I padSize = GetSize( aLayer );
    int            dx = padSize.x / 2;
    int            dy = padSize.y / 2;
 
    VECTOR2I padShapePos = ShapePos( aLayer ); // Note: for pad having a shape offset, the pad
                                               // position is NOT the shape position
 
    switch( PAD_SHAPE shape = GetShape( aLayer ) )
    {
    case PAD_SHAPE::CIRCLE:
    case PAD_SHAPE::OVAL:
        // Note: dx == dy is not guaranteed for circle pads in legacy boards
        if( dx == dy || ( shape == PAD_SHAPE::CIRCLE ) )
        {
            TransformCircleToPolygon( aBuffer, padShapePos, dx + aClearance, aMaxError, aErrorLoc,
                                      pad_min_seg_per_circle_count );
        }
        else
        {
            int      half_width = std::min( dx, dy );
            VECTOR2I delta( dx - half_width, dy - half_width );
 
            RotatePoint( delta, GetOrientation() );
 
            TransformOvalToPolygon( aBuffer, padShapePos - delta, padShapePos + delta,
                                    ( half_width + aClearance ) * 2, aMaxError, aErrorLoc,
                                    pad_min_seg_per_circle_count );
        }
 
        break;
 
    case PAD_SHAPE::TRAPEZOID:
    case PAD_SHAPE::RECTANGLE:
    {
        const VECTOR2I& trapDelta = m_padStack.TrapezoidDeltaSize( aLayer );
        int  ddx = shape == PAD_SHAPE::TRAPEZOID ? trapDelta.x / 2 : 0;
        int  ddy = shape == PAD_SHAPE::TRAPEZOID ? trapDelta.y / 2 : 0;
 
        SHAPE_POLY_SET outline;
        TransformTrapezoidToPolygon( outline, padShapePos, padSize, GetOrientation(), ddx, ddy, aClearance, aMaxError,
                                     aErrorLoc );
        aBuffer.Append( outline );
        break;
    }
 
    case PAD_SHAPE::CHAMFERED_RECT:
    case PAD_SHAPE::ROUNDRECT:
    {
        bool doChamfer = shape == PAD_SHAPE::CHAMFERED_RECT;
 
        SHAPE_POLY_SET outline;
        TransformRoundChamferedRectToPolygon(
                outline, padShapePos, padSize, GetOrientation(), GetRoundRectCornerRadius( aLayer ),
                doChamfer ? GetChamferRectRatio( aLayer ) : 0, doChamfer ? GetChamferPositions( aLayer ) : 0,
                aClearance, aMaxError, aErrorLoc );
        aBuffer.Append( outline );
        break;
    }
 
    case PAD_SHAPE::CUSTOM:
    {
        SHAPE_POLY_SET outline;
        MergePrimitivesAsPolygon( aLayer, &outline, aErrorLoc );
        outline.Rotate( GetOrientation() );
        outline.Move( VECTOR2I( padShapePos ) );
 
        if( aClearance > 0 || aErrorLoc == ERROR_OUTSIDE )
        {
            if( aErrorLoc == ERROR_OUTSIDE )
                aClearance += aMaxError;
 
            outline.Inflate( aClearance, CORNER_STRATEGY::ROUND_ALL_CORNERS, aMaxError );
            outline.Fracture();
        }
        else if( aClearance < 0 )
        {
            // Negative clearances are primarily for drawing solder paste layer, so we don't
            // worry ourselves overly about which side the error is on.
 
            // aClearance is negative so this is actually a deflate
            outline.Inflate( aClearance, CORNER_STRATEGY::ALLOW_ACUTE_CORNERS, aMaxError );
            outline.Fracture();
        }
 
        aBuffer.Append( outline );
        break;
    }
 
    default:
        wxFAIL_MSG( wxT( "PAD::TransformShapeToPolygon no implementation for " )
                    + wxString( std::string( magic_enum::enum_name( shape ) ) ) );
        break;
    }
}
 
 
std::vector<PCB_SHAPE*> PAD::Recombine( bool aIsDryRun, int maxError )
{
    FOOTPRINT* footprint = GetParentFootprint();
 
    for( BOARD_ITEM* item : footprint->GraphicalItems() )
        item->ClearFlags( SKIP_STRUCT );
 
    auto findNext =
            [&]( PCB_LAYER_ID aLayer ) -> PCB_SHAPE*
            {
                SHAPE_POLY_SET padPoly;
                TransformShapeToPolygon( padPoly, aLayer, 0, maxError, ERROR_INSIDE );
 
                for( BOARD_ITEM* item : footprint->GraphicalItems() )
                {
                    PCB_SHAPE* shape = dynamic_cast<PCB_SHAPE*>( item );
 
                    if( !shape || ( shape->GetFlags() & SKIP_STRUCT ) )
                        continue;
 
                    if( shape->GetLayer() != aLayer )
                        continue;
 
                    if( shape->IsProxyItem() )    // Pad number (and net name) box
                        return shape;
 
                    SHAPE_POLY_SET drawPoly;
                    shape->TransformShapeToPolygon( drawPoly, aLayer, 0, maxError, ERROR_INSIDE );
                    drawPoly.BooleanIntersection( padPoly );
 
                    if( !drawPoly.IsEmpty() )
                        return shape;
                }
 
                return nullptr;
            };
 
    auto findMatching =
            [&]( PCB_SHAPE* aShape ) -> std::vector<PCB_SHAPE*>
            {
                std::vector<PCB_SHAPE*> matching;
 
                for( BOARD_ITEM* item : footprint->GraphicalItems() )
                {
                    PCB_SHAPE* other = dynamic_cast<PCB_SHAPE*>( item );
 
                    if( !other || ( other->GetFlags() & SKIP_STRUCT ) )
                        continue;
 
                    if( Padstack().Mode() == PADSTACK::MODE::NORMAL )
                    {
                        // A signle layer (F_Cu) in NORMAL mode represents _all_ layers,
                        // so disable the layer test entirely
                    }
                    else
                    {
                        if( aShape->GetLayer() != other->GetLayer() )
                            continue;
                    }
 
                    if( aShape->Compare( other ) == 0 )
                        matching.push_back( other );
                }
 
                return matching;
            };
 
    std::vector<PCB_SHAPE*> mergedShapes;
 
    auto recombine =
            [&]( PCB_LAYER_ID sourceBoardLayer, PCB_LAYER_ID padstackStorageLayer )
            {
                PAD_SHAPE origShape = GetShape( sourceBoardLayer );
 
                // If there are intersecting items to combine, we need to first make sure the pad is a
                // custom-shape pad.
                if( !aIsDryRun && findNext( sourceBoardLayer ) && origShape != PAD_SHAPE::CUSTOM )
                {
                    if( origShape == PAD_SHAPE::CIRCLE || origShape == PAD_SHAPE::RECTANGLE )
                    {
                        // Use the existing pad as an anchor
                        SetAnchorPadShape( padstackStorageLayer, origShape );
                        SetShape( padstackStorageLayer, PAD_SHAPE::CUSTOM );
                    }
                    else
                    {
                        // Create a new circular anchor and convert existing pad to a polygon primitive
                        SHAPE_POLY_SET existingOutline;
                        TransformShapeToPolygon( existingOutline, padstackStorageLayer, 0, maxError, ERROR_INSIDE );
 
                        VECTOR2I      origin( ShapePos( padstackStorageLayer ) );
                        VECTOR2I      nearestPoint, dummyPoint;
                        SHAPE_SEGMENT originSeg( origin, origin );
                        existingOutline.NearestPoints( &originSeg, nearestPoint, dummyPoint );
                        int           radius = ( nearestPoint - origin ).EuclideanNorm();
 
                        SetAnchorPadShape( padstackStorageLayer, PAD_SHAPE::CIRCLE );
                        SetSize( padstackStorageLayer, VECTOR2I( radius * 2, radius * 2 ) );
                        SetShape( padstackStorageLayer, PAD_SHAPE::CUSTOM );
 
                        PCB_SHAPE* shape = new PCB_SHAPE( nullptr, SHAPE_T::POLY );
                        shape->SetFilled( true );
                        shape->SetStroke( STROKE_PARAMS( 0, LINE_STYLE::SOLID ) );
                        shape->SetPolyShape( existingOutline );
                        shape->Move( - ShapePos( padstackStorageLayer ) );
                        shape->Rotate( VECTOR2I( 0, 0 ), - GetOrientation() );
                        AddPrimitive( padstackStorageLayer, shape );
                    }
                }
 
                while( PCB_SHAPE* fpShape = findNext( sourceBoardLayer ) )
                {
                    fpShape->SetFlags( SKIP_STRUCT );
 
                    mergedShapes.push_back( fpShape );
 
                    if( !aIsDryRun )
                    {
                        // If the editor was inside a group when the pad was exploded, the added exploded shapes
                        // will be part of the group.  Remove them here before duplicating; we don't want the
                        // primitives to wind up in a group.
                        if( EDA_GROUP* group = fpShape->GetParentGroup(); group )
                            group->RemoveItem( fpShape );
 
                        PCB_SHAPE* primitive = static_cast<PCB_SHAPE*>( fpShape->Duplicate( IGNORE_PARENT_GROUP ) );
 
                        primitive->SetParent( nullptr );
 
                        // Convert any hatched fills to solid
                        if( primitive->IsAnyFill() )
                            primitive->SetFillMode( FILL_T::FILLED_SHAPE );
 
                        primitive->Move( - ShapePos( padstackStorageLayer ) );
                        primitive->Rotate( VECTOR2I( 0, 0 ), - GetOrientation() );
 
                        AddPrimitive( padstackStorageLayer, primitive );
                    }
 
                    // See if there are other shapes that match and mark them for delete.
                    for( PCB_SHAPE* other : findMatching( fpShape ) )
                    {
                        other->SetFlags( SKIP_STRUCT );
                        mergedShapes.push_back( other );
                    }
                }
            };
 
    if( Padstack().Mode() == PADSTACK::MODE::NORMAL )
    {
        recombine( GetPrincipalLayer(), PADSTACK::ALL_LAYERS );
    }
    else
    {
        Padstack().ForEachUniqueLayer(
                [&]( PCB_LAYER_ID aLayer )
                {
                    recombine( aLayer, aLayer );
                } );
    }
 
    for( BOARD_ITEM* item : footprint->GraphicalItems() )
        item->ClearFlags( SKIP_STRUCT );
 
    if( !aIsDryRun )
        ClearFlags( ENTERED );
 
    return mergedShapes;
}
 
 
bool PAD::operator==( const BOARD_ITEM& aBoardItem ) const
{
    if( Type() != aBoardItem.Type() )
        return false;
 
    if( m_parent && aBoardItem.GetParent() && m_parent->m_Uuid != aBoardItem.GetParent()->m_Uuid )
        return false;
 
    const PAD& other = static_cast<const PAD&>( aBoardItem );
 
    return *this == other;
}
 
 
bool PAD::operator==( const PAD& aOther ) const
{
    if( Padstack() != aOther.Padstack() )
        return false;
 
    if( GetPosition() != aOther.GetPosition() )
        return false;
 
    if( GetAttribute() != aOther.GetAttribute() )
        return false;
 
    return true;
}
 
 
double PAD::Similarity( const BOARD_ITEM& aOther ) const
{
    if( aOther.Type() != Type() )
        return 0.0;
 
    if( m_parent->m_Uuid != aOther.GetParent()->m_Uuid )
        return 0.0;
 
    const PAD& other = static_cast<const PAD&>( aOther );
 
    double similarity = 1.0;
 
    if( GetPosition() != other.GetPosition() )
        similarity *= 0.9;
 
    if( GetAttribute() != other.GetAttribute() )
        similarity *= 0.9;
 
    similarity *= Padstack().Similarity( other.Padstack() );
 
    return similarity;
}
 
 
void PAD::AddPrimitivePoly( PCB_LAYER_ID aLayer, const SHAPE_POLY_SET& aPoly, int aThickness,
                            bool aFilled )
{
    // If aPoly has holes, convert it to a polygon with no holes.
    SHAPE_POLY_SET poly_no_hole;
    poly_no_hole.Append( aPoly );
 
    if( poly_no_hole.HasHoles() )
        poly_no_hole.Fracture();
 
    // There should never be multiple shapes, but if there are, we split them into
    // primitives so that we can edit them both.
    for( int ii = 0; ii < poly_no_hole.OutlineCount(); ++ii )
    {
        SHAPE_POLY_SET poly_outline( poly_no_hole.COutline( ii ) );
        PCB_SHAPE* item = new PCB_SHAPE();
        item->SetShape( SHAPE_T::POLY );
        item->SetFilled( aFilled );
        item->SetPolyShape( poly_outline );
        item->SetStroke( STROKE_PARAMS( aThickness, LINE_STYLE::SOLID ) );
        AddPrimitive( aLayer, item );
    }
 
    SetDirty();
}
 
 
void PAD::AddPrimitivePoly( PCB_LAYER_ID aLayer, const std::vector<VECTOR2I>& aPoly, int aThickness,
                            bool aFilled )
{
    PCB_SHAPE* item = new PCB_SHAPE( nullptr, SHAPE_T::POLY );
    item->SetFilled( aFilled );
    item->SetPolyPoints( aPoly );
    item->SetStroke( STROKE_PARAMS( aThickness, LINE_STYLE::SOLID ) );
    AddPrimitive( aLayer, item );
    SetDirty();
}
 
 
void PAD::ReplacePrimitives( PCB_LAYER_ID aLayer, const std::vector<std::shared_ptr<PCB_SHAPE>>& aPrimitivesList )
{
    // clear old list
    DeletePrimitivesList( aLayer );
 
    // Import to the given shape list
    if( aPrimitivesList.size() )
        AppendPrimitives( aLayer, aPrimitivesList );
 
    SetDirty();
}
 
 
void PAD::AppendPrimitives( PCB_LAYER_ID aLayer, const std::vector<std::shared_ptr<PCB_SHAPE>>& aPrimitivesList )
{
    // Add duplicates of aPrimitivesList to the pad primitives list:
    for( const std::shared_ptr<PCB_SHAPE>& prim : aPrimitivesList )
        AddPrimitive( aLayer, new PCB_SHAPE( *prim ) );
 
    SetDirty();
}
 
 
void PAD::AddPrimitive( PCB_LAYER_ID aLayer, PCB_SHAPE* aPrimitive )
{
    aPrimitive->SetParent( this );
 
    // Seed lib state from the primitive's current values, then rebake so the
    // runtime cache reflects the parent FP transform reachable via the pad.
    aPrimitive->OverrideLibCoords( aPrimitive->GetStart(), aPrimitive->GetEnd(),
                                   aPrimitive->GetShape() == SHAPE_T::ARC ? aPrimitive->GetArcMid()
                                                                          : VECTOR2I( 0, 0 ) );
 
    if( aPrimitive->GetShape() == SHAPE_T::BEZIER )
        aPrimitive->OverrideLibBezier( aPrimitive->GetBezierC1(), aPrimitive->GetBezierC2() );
 
    if( aPrimitive->GetShape() == SHAPE_T::POLY )
        aPrimitive->OverrideLibPoly( aPrimitive->GetPolyShape() );
 
    // Covers load, where the footprint scale is set before the primitives are parsed.
    rebakePrimitiveToFootprint( aPrimitive );
 
    m_padStack.AddPrimitive( aPrimitive, aLayer );
 
    SetDirty();
}
 
 
void PAD::DeletePrimitivesList( PCB_LAYER_ID aLayer )
{
    if( aLayer == UNDEFINED_LAYER )
    {
        m_padStack.ForEachUniqueLayer(
                [&]( PCB_LAYER_ID l )
                {
                    m_padStack.ClearPrimitives( l );
                } );
    }
    else
    {
        m_padStack.ClearPrimitives( aLayer);
    }
 
    SetDirty();
}
 
 
void PAD::MergePrimitivesAsPolygon( PCB_LAYER_ID aLayer, SHAPE_POLY_SET* aMergedPolygon,
                                    ERROR_LOC aErrorLoc ) const
{
    aMergedPolygon->RemoveAllContours();
 
    // Add the anchor pad shape in aMergedPolygon, others in aux_polyset:
    // The anchor pad is always at 0,0
    VECTOR2I padSize = GetSize( aLayer );
 
    switch( GetAnchorPadShape( aLayer ) )
    {
    case PAD_SHAPE::RECTANGLE:
    {
        SHAPE_RECT rect( -padSize.x / 2, -padSize.y / 2, padSize.x, padSize.y );
        aMergedPolygon->AddOutline( rect.Outline() );
        break;
    }
 
    default:
    case PAD_SHAPE::CIRCLE:
        TransformCircleToPolygon( *aMergedPolygon, VECTOR2I( 0, 0 ), padSize.x / 2, GetMaxError(), aErrorLoc );
        break;
    }
 
    SHAPE_POLY_SET polyset;
 
    for( const std::shared_ptr<PCB_SHAPE>& primitive : m_padStack.Primitives( aLayer ) )
    {
        if( !primitive->IsProxyItem() )
            primitive->TransformShapeToPolygon( polyset, UNDEFINED_LAYER, 0, GetMaxError(), aErrorLoc );
    }
 
    polyset.Simplify();
 
    // Merge all polygons with the initial pad anchor shape
    if( polyset.OutlineCount() )
    {
        aMergedPolygon->BooleanAdd( polyset );
        aMergedPolygon->Fracture();
    }
}
 
 
static struct PAD_DESC
{
    PAD_DESC()
    {
        ENUM_MAP<PAD_ATTRIB>::Instance()
                .Map( PAD_ATTRIB::PTH,             _HKI( "Through-hole" ) )
                .Map( PAD_ATTRIB::SMD,             _HKI( "SMD" ) )
                .Map( PAD_ATTRIB::CONN,            _HKI( "Edge connector" ) )
                .Map( PAD_ATTRIB::NPTH,            _HKI( "NPTH, mechanical" ) );
 
        ENUM_MAP<PAD_SHAPE>::Instance()
                .Map( PAD_SHAPE::CIRCLE,           _HKI( "Circle" ) )
                .Map( PAD_SHAPE::RECTANGLE,        _HKI( "Rectangle" ) )
                .Map( PAD_SHAPE::OVAL,             _HKI( "Oval" ) )
                .Map( PAD_SHAPE::TRAPEZOID,        _HKI( "Trapezoid" ) )
                .Map( PAD_SHAPE::ROUNDRECT,        _HKI( "Rounded rectangle" ) )
                .Map( PAD_SHAPE::CHAMFERED_RECT,   _HKI( "Chamfered rectangle" ) )
                .Map( PAD_SHAPE::CUSTOM,           _HKI( "Custom" ) );
 
        ENUM_MAP<PAD_PROP>::Instance()
                .Map( PAD_PROP::NONE,              _HKI( "None" ) )
                .Map( PAD_PROP::BGA,               _HKI( "BGA pad" ) )
                .Map( PAD_PROP::FIDUCIAL_GLBL,     _HKI( "Fiducial, global to board" ) )
                .Map( PAD_PROP::FIDUCIAL_LOCAL,    _HKI( "Fiducial, local to footprint" ) )
                .Map( PAD_PROP::TESTPOINT,         _HKI( "Test point pad" ) )
                .Map( PAD_PROP::HEATSINK,          _HKI( "Heatsink pad" ) )
                .Map( PAD_PROP::CASTELLATED,       _HKI( "Castellated pad" ) )
                .Map( PAD_PROP::MECHANICAL,        _HKI( "Mechanical pad" ) )
                .Map( PAD_PROP::PRESSFIT,          _HKI( "Press-fit pad" ) );
 
        ENUM_MAP<PAD_DRILL_SHAPE>::Instance()
                .Map( PAD_DRILL_SHAPE::UNDEFINED,  _HKI( "Undefined" ) )
                .Map( PAD_DRILL_SHAPE::CIRCLE,     _HKI( "Round" ) )
                .Map( PAD_DRILL_SHAPE::OBLONG,     _HKI( "Oblong" ) );
 
        ENUM_MAP<PAD_SIM_ELECTRICAL_TYPE>::Instance()
                .Map( PAD_SIM_ELECTRICAL_TYPE::NONE, _HKI( "None" ) )
                .Map( PAD_SIM_ELECTRICAL_TYPE::SOURCE, _HKI( "Source" ) )
                .Map( PAD_SIM_ELECTRICAL_TYPE::SINK, _HKI( "Sink" ) );
 
        // Ensure post-machining mode enum choices are defined before properties use them
        {
            ENUM_MAP<PAD_DRILL_POST_MACHINING_MODE>& pmMap =
                    ENUM_MAP<PAD_DRILL_POST_MACHINING_MODE>::Instance();
 
            if( pmMap.Choices().GetCount() == 0 )
            {
                pmMap.Undefined( PAD_DRILL_POST_MACHINING_MODE::UNKNOWN )
                    .Map( PAD_DRILL_POST_MACHINING_MODE::NOT_POST_MACHINED, _HKI( "Not post-machined" ) )
                    .Map( PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE,       _HKI( "Counterbore" ) )
                    .Map( PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK,       _HKI( "Countersink" ) );
            }
        }
 
        // Ensure backdrill mode enum choices are defined before properties use them
        {
            ENUM_MAP<BACKDRILL_MODE>& bdMap = ENUM_MAP<BACKDRILL_MODE>::Instance();
 
            if( bdMap.Choices().GetCount() == 0 )
            {
                bdMap.Undefined( BACKDRILL_MODE::NO_BACKDRILL )
                    .Map( BACKDRILL_MODE::NO_BACKDRILL,     _HKI( "No backdrill" ) )
                    .Map( BACKDRILL_MODE::BACKDRILL_BOTTOM, _HKI( "Backdrill bottom" ) )
                    .Map( BACKDRILL_MODE::BACKDRILL_TOP,    _HKI( "Backdrill top" ) )
                    .Map( BACKDRILL_MODE::BACKDRILL_BOTH,   _HKI( "Backdrill both" ) );
            }
        }
 
        ENUM_MAP<ZONE_CONNECTION>& zcMap = ENUM_MAP<ZONE_CONNECTION>::Instance();
 
        if( zcMap.Choices().GetCount() == 0 )
        {
            zcMap.Undefined( ZONE_CONNECTION::INHERITED );
            zcMap.Map( ZONE_CONNECTION::INHERITED,   _HKI( "Inherited" ) )
                 .Map( ZONE_CONNECTION::NONE,        _HKI( "None" ) )
                 .Map( ZONE_CONNECTION::THERMAL,     _HKI( "Thermal reliefs" ) )
                 .Map( ZONE_CONNECTION::FULL,        _HKI( "Solid" ) )
                 .Map( ZONE_CONNECTION::THT_THERMAL, _HKI( "Thermal reliefs for PTH" ) );
        }
 
        ENUM_MAP<UNCONNECTED_LAYER_MODE>::Instance()
                .Map( UNCONNECTED_LAYER_MODE::KEEP_ALL,                    _HKI( "All copper layers" ) )
                .Map( UNCONNECTED_LAYER_MODE::REMOVE_ALL,                  _HKI( "Connected layers only" ) )
                .Map( UNCONNECTED_LAYER_MODE::REMOVE_EXCEPT_START_AND_END, _HKI( "Front, back and connected layers" ) )
                .Map( UNCONNECTED_LAYER_MODE::START_END_ONLY,              _HKI( "Start and end layers only" ) );
 
        PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
        REGISTER_TYPE( PAD );
        propMgr.AddTypeCast( new TYPE_CAST<PAD, BOARD_ITEM> );
        propMgr.AddTypeCast( new TYPE_CAST<PAD, BOARD_CONNECTED_ITEM> );
        propMgr.InheritsAfter( TYPE_HASH( PAD ), TYPE_HASH( BOARD_ITEM ) );
        propMgr.InheritsAfter( TYPE_HASH( PAD ), TYPE_HASH( BOARD_CONNECTED_ITEM ) );
 
        propMgr.Mask( TYPE_HASH( PAD ), TYPE_HASH( BOARD_CONNECTED_ITEM ), _HKI( "Layer" ) );
        propMgr.Mask( TYPE_HASH( PAD ), TYPE_HASH( BOARD_ITEM ), _HKI( "Locked" ) );
 
        propMgr.AddProperty( new PROPERTY<PAD, double>( _HKI( "Orientation" ),
                    &PAD::SetOrientationDegrees, &PAD::GetOrientationDegrees, PROPERTY_DISPLAY::PT_DEGREE ) );
 
        auto isCopperPad =
                []( INSPECTABLE* aItem ) -> bool
                {
                    if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                        return pad->GetAttribute() != PAD_ATTRIB::NPTH;
 
                    return false;
                };
 
        auto padCanHaveHole =
                []( INSPECTABLE* aItem ) -> bool
                {
                    if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                        return pad->GetAttribute() == PAD_ATTRIB::PTH || pad->GetAttribute() == PAD_ATTRIB::NPTH;
 
                    return false;
                };
 
        auto hasNormalPadstack =
                []( INSPECTABLE* aItem ) -> bool
                {
                    if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                        return pad->Padstack().Mode() == PADSTACK::MODE::NORMAL;
 
                    return true;
                };
 
        propMgr.OverrideAvailability( TYPE_HASH( PAD ), TYPE_HASH( BOARD_CONNECTED_ITEM ), _HKI( "Net" ),
                                      isCopperPad );
        propMgr.OverrideAvailability( TYPE_HASH( PAD ), TYPE_HASH( BOARD_CONNECTED_ITEM ), _HKI( "Net Class" ),
                                      isCopperPad );
 
        const wxString groupPad = _HKI( "Pad Properties" );
        const wxString groupPostMachining = _HKI( "Post-machining Properties" );
        const wxString groupBackdrill = _HKI( "Backdrill Properties" );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, PAD_ATTRIB>( _HKI( "Pad Type" ),
                    &PAD::SetAttribute, &PAD::GetAttribute ),
                    groupPad );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, PAD_SHAPE>( _HKI( "Pad Shape" ),
                    &PAD::SetFrontShape, &PAD::GetFrontShape ),
                    groupPad )
                .SetAvailableFunc( hasNormalPadstack );
 
        propMgr.AddProperty( new PROPERTY<PAD, wxString>( _HKI( "Pad Number" ),
                    &PAD::SetNumber, &PAD::GetNumber ),
                    groupPad )
                .SetAvailableFunc( isCopperPad );
 
        propMgr.AddProperty( new PROPERTY<PAD, wxString>( _HKI( "Pin Name" ),
                    &PAD::SetPinFunction, &PAD::GetPinFunction ),
                    groupPad )
                .SetIsHiddenFromLibraryEditors();
 
        propMgr.AddProperty( new PROPERTY<PAD, wxString>( _HKI( "Pin Type" ),
                    &PAD::SetPinType, &PAD::GetPinType ),
                    groupPad )
                .SetIsHiddenFromLibraryEditors()
                .SetChoicesFunc( []( INSPECTABLE* aItem )
                                 {
                                     wxPGChoices choices;
 
                                     for( int ii = 0; ii < ELECTRICAL_PINTYPES_TOTAL; ii++ )
                                         choices.Add( GetCanonicalElectricalTypeName( (ELECTRICAL_PINTYPE) ii ) );
 
                                     return choices;
                                 } );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, PAD_SIM_ELECTRICAL_TYPE>( _HKI( "Simulation Electrical Type" ),
                    &PAD::SetSimElectricalType, &PAD::GetSimElectricalType ),
                    groupPad );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Size X" ),
                    &PAD::SetSizeXProp, &PAD::GetSizeXProp, PROPERTY_DISPLAY::PT_SIZE ),
                    groupPad )
                .SetAvailableFunc( hasNormalPadstack );
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Size Y" ),
                    &PAD::SetSizeYProp, &PAD::GetSizeYProp, PROPERTY_DISPLAY::PT_SIZE ),
                    groupPad )
                .SetAvailableFunc( []( INSPECTABLE* aItem ) -> bool
                                   {
                                       if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                                       {
                                           // Custom padstacks can't have size modified through panel
                                           if( pad->Padstack().Mode() != PADSTACK::MODE::NORMAL )
                                               return false;
 
                                           // Circle pads have no usable y-size
                                           return pad->GetShape( PADSTACK::ALL_LAYERS ) != PAD_SHAPE::CIRCLE;
                                       }
 
                                       return true;
                                   } );
 
        const auto hasRoundRadius =
                []( INSPECTABLE* aItem ) -> bool
                {
                    if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                    {
                        // Custom padstacks can't have this property modified through panel
                        if( pad->Padstack().Mode() != PADSTACK::MODE::NORMAL )
                            return false;
 
                        return PAD_UTILS::PadHasMeaningfulRoundingRadius( *pad, F_Cu );
                    }
 
                    return false;
                };
 
        propMgr.AddProperty( new PROPERTY<PAD, double>( _HKI( "Corner Radius Ratio" ),
                    &PAD::SetFrontRoundRectRadiusRatio, &PAD::GetFrontRoundRectRadiusRatio ),
                    groupPad )
                .SetAvailableFunc( hasRoundRadius );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Corner Radius Size" ),
                    &PAD::SetFrontRoundRectRadiusSize, &PAD::GetFrontRoundRectRadiusSize, PROPERTY_DISPLAY::PT_SIZE ),
                    groupPad )
                .SetAvailableFunc( hasRoundRadius );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, PAD_DRILL_SHAPE>( _HKI( "Hole Shape" ),
                    &PAD::SetDrillShape, &PAD::GetDrillShape ), groupPad )
                .SetWriteableFunc( padCanHaveHole );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Hole Size X" ),
                    &PAD::SetDrillSizeXProp, &PAD::GetDrillSizeXProp, PROPERTY_DISPLAY::PT_SIZE ),
                    groupPad )
                .SetWriteableFunc( padCanHaveHole )
                .SetValidator( PROPERTY_VALIDATORS::PositiveIntValidator );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Hole Size Y" ),
                    &PAD::SetDrillSizeYProp, &PAD::GetDrillSizeYProp, PROPERTY_DISPLAY::PT_SIZE ),
                    groupPad )
                .SetWriteableFunc( padCanHaveHole )
                .SetValidator( PROPERTY_VALIDATORS::PositiveIntValidator )
                .SetAvailableFunc( []( INSPECTABLE* aItem ) -> bool
                                   {
                                       // Circle holes have no usable y-size
                                       if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                                           return pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE;
 
                                       return true;
                                   } );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, PAD_DRILL_POST_MACHINING_MODE>( _HKI( "Top Post-machining" ),
                    &PAD::SetFrontPostMachiningMode, &PAD::GetFrontPostMachiningMode ),
                    groupPostMachining )
                .SetWriteableFunc( padCanHaveHole )
                .SetAvailableFunc( []( INSPECTABLE* aItem )
                                   {
                                       if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                                           return pad->GetDrillShape() == PAD_DRILL_SHAPE::CIRCLE;
 
                                       return false;
                                   } );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Top Post-machining Size" ),
                    &PAD::SetFrontPostMachiningSize, &PAD::GetFrontPostMachiningSize, PROPERTY_DISPLAY::PT_SIZE ),
                    groupPostMachining )
                .SetWriteableFunc( padCanHaveHole )
                .SetAvailableFunc(
                        []( INSPECTABLE* aItem )
                        {
                            if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                            {
                                if( pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE )
                                    return false;
 
                                std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = pad->GetFrontPostMachining();
                                return mode.has_value()
                                        && (   mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE
                                            || mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK );
                            }
 
                            return false;
                        } );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Top Counterbore Depth" ),
                    &PAD::SetFrontPostMachiningDepth, &PAD::GetFrontPostMachiningDepth, PROPERTY_DISPLAY::PT_SIZE ),
                    groupPostMachining )
                .SetWriteableFunc( padCanHaveHole )
                .SetAvailableFunc(
                        []( INSPECTABLE* aItem )
                        {
                            if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                            {
                                if( pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE )
                                    return false;
 
                                std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = pad->GetFrontPostMachining();
                                return mode.has_value() && mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE;
                            }
 
                            return false;
                        } );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Top Countersink Angle" ),
                    &PAD::SetFrontPostMachiningAngle, &PAD::GetFrontPostMachiningAngle, PROPERTY_DISPLAY::PT_DECIDEGREE ),
                    groupPostMachining )
                .SetWriteableFunc( padCanHaveHole )
                .SetAvailableFunc(
                        []( INSPECTABLE* aItem )
                        {
                            if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                            {
                                if( pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE )
                                    return false;
 
                                std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = pad->GetFrontPostMachining();
                                return mode.has_value() && mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK;
                            }
 
                            return false;
                        } );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, PAD_DRILL_POST_MACHINING_MODE>( _HKI( "Bottom Post-machining" ),
                    &PAD::SetBackPostMachiningMode, &PAD::GetBackPostMachiningMode ),
                    groupPostMachining )
                .SetWriteableFunc( padCanHaveHole )
                .SetAvailableFunc( []( INSPECTABLE* aItem )
                                   {
                                       if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                                           return pad->GetDrillShape() == PAD_DRILL_SHAPE::CIRCLE;
 
                                       return false;
                                   } );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Bottom Post-machining Size" ),
                    &PAD::SetBackPostMachiningSize, &PAD::GetBackPostMachiningSize, PROPERTY_DISPLAY::PT_SIZE ),
                    groupPostMachining )
                .SetWriteableFunc( padCanHaveHole )
                .SetAvailableFunc(
                        []( INSPECTABLE* aItem )
                        {
                            if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                            {
                                if( pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE )
                                    return false;
 
                                std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = pad->GetBackPostMachining();
                                return mode.has_value()
                                        && (   mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE
                                            || mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK );
                            }
 
                            return false;
                        } );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Bottom Counterbore Depth" ),
                    &PAD::SetBackPostMachiningDepth, &PAD::GetBackPostMachiningDepth, PROPERTY_DISPLAY::PT_SIZE ),
                    groupPostMachining )
                .SetWriteableFunc( padCanHaveHole )
                .SetAvailableFunc(
                        []( INSPECTABLE* aItem )
                        {
                            if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                            {
                                if( pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE )
                                    return false;
 
                                std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = pad->GetBackPostMachining();
                                return mode.has_value() && mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERBORE;
                            }
 
                            return false;
                        } );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Bottom Countersink Angle" ),
                    &PAD::SetBackPostMachiningAngle, &PAD::GetBackPostMachiningAngle, PROPERTY_DISPLAY::PT_DECIDEGREE ),
                    groupPostMachining )
                .SetWriteableFunc( padCanHaveHole )
                .SetAvailableFunc(
                        []( INSPECTABLE* aItem )
                        {
                            if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                            {
                                if( pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE )
                                    return false;
 
                                std::optional<PAD_DRILL_POST_MACHINING_MODE> mode = pad->GetBackPostMachining();
                                return mode.has_value() && mode.value() == PAD_DRILL_POST_MACHINING_MODE::COUNTERSINK;
                            }
 
                            return false;
                        } );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, BACKDRILL_MODE>( _HKI( "Backdrill Mode" ),
                    &PAD::SetBackdrillMode, &PAD::GetBackdrillMode ),
                    groupBackdrill );
 
        propMgr.AddProperty( new PROPERTY<PAD, std::optional<int>>( _HKI( "Bottom Backdrill Size" ),
                    &PAD::SetBottomBackdrillSize, &PAD::GetBottomBackdrillSize, PROPERTY_DISPLAY::PT_SIZE ),
                    groupBackdrill )
                .SetAvailableFunc(
                        []( INSPECTABLE* aItem ) -> bool
                        {
                            if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                            {
                                if( pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE )
                                    return false;
 
                                BACKDRILL_MODE mode = pad->GetBackdrillMode();
                                return mode == BACKDRILL_MODE::BACKDRILL_BOTTOM
                                        || mode == BACKDRILL_MODE::BACKDRILL_BOTH;
                            }
 
                            return false;
                        } );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, PCB_LAYER_ID>( _HKI( "Bottom Backdrill Must-Cut" ),
                    &PAD::SetBottomBackdrillLayer, &PAD::GetBottomBackdrillLayer ),
                    groupBackdrill )
                .SetAvailableFunc(
                        []( INSPECTABLE* aItem ) -> bool
                        {
                            if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                            {
                                if( pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE )
                                    return false;
 
                                BACKDRILL_MODE mode = pad->GetBackdrillMode();
                                return mode == BACKDRILL_MODE::BACKDRILL_BOTTOM
                                        || mode == BACKDRILL_MODE::BACKDRILL_BOTH;
                            }
 
                            return false;
                        } );
 
        propMgr.AddProperty( new PROPERTY<PAD, std::optional<int>>( _HKI( "Top Backdrill Size" ),
                    &PAD::SetTopBackdrillSize, &PAD::GetTopBackdrillSize, PROPERTY_DISPLAY::PT_SIZE ),
                    groupBackdrill )
                .SetAvailableFunc(
                        []( INSPECTABLE* aItem ) -> bool
                        {
                            if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                            {
                                if( pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE )
                                    return false;
 
                                BACKDRILL_MODE mode = pad->GetBackdrillMode();
                                return mode == BACKDRILL_MODE::BACKDRILL_TOP || mode == BACKDRILL_MODE::BACKDRILL_BOTH;
                            }
 
                            return false;
                        } );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, PCB_LAYER_ID>( _HKI( "Top Backdrill Must-Cut" ),
                    &PAD::SetTopBackdrillLayer, &PAD::GetTopBackdrillLayer ),
                    groupBackdrill )
                .SetAvailableFunc(
                        []( INSPECTABLE* aItem ) -> bool
                        {
                            if( PAD* pad = dynamic_cast<PAD*>( aItem ) )
                            {
                                if( pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE )
                                    return false;
 
                                BACKDRILL_MODE mode = pad->GetBackdrillMode();
                                return mode == BACKDRILL_MODE::BACKDRILL_TOP || mode == BACKDRILL_MODE::BACKDRILL_BOTH;
                            }
 
                            return false;
                        } );
 
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, PAD_PROP>( _HKI( "Fabrication Property" ),
                    &PAD::SetProperty, &PAD::GetProperty ),
                    groupPad );
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, UNCONNECTED_LAYER_MODE>( _HKI( "Copper Layers" ),
                    &PAD::SetUnconnectedLayerMode, &PAD::GetUnconnectedLayerMode ),
                    groupPad );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Pad To Die Length" ),
                    &PAD::SetPadToDieLength, &PAD::GetPadToDieLength, PROPERTY_DISPLAY::PT_SIZE ),
                    groupPad )
                .SetAvailableFunc( isCopperPad );
 
        propMgr.AddProperty( new PROPERTY<PAD, int>( _HKI( "Pad To Die Delay" ),
                    &PAD::SetPadToDieDelay, &PAD::GetPadToDieDelay, PROPERTY_DISPLAY::PT_TIME ),
                    groupPad )
                .SetAvailableFunc( isCopperPad );
 
        const wxString groupOverrides = _HKI( "Overrides" );
 
        propMgr.AddProperty( new PROPERTY<PAD, std::optional<int>>( _HKI( "Clearance Override" ),
                    &PAD::SetLocalClearance, &PAD::GetLocalClearance, PROPERTY_DISPLAY::PT_SIZE ),
                    groupOverrides ).SetIsCopyable();
 
        propMgr.AddProperty( new PROPERTY<PAD, std::optional<int>>( _HKI( "Soldermask Margin Override" ),
                    &PAD::SetLocalSolderMaskMargin, &PAD::GetLocalSolderMaskMargin, PROPERTY_DISPLAY::PT_SIZE ),
                    groupOverrides ).SetIsCopyable();
 
        propMgr.AddProperty( new PROPERTY<PAD, std::optional<int>>( _HKI( "Solderpaste Margin Override" ),
                    &PAD::SetLocalSolderPasteMargin, &PAD::GetLocalSolderPasteMargin, PROPERTY_DISPLAY::PT_SIZE ),
                    groupOverrides ).SetIsCopyable();
 
        propMgr.AddProperty( new PROPERTY<PAD, std::optional<double>>( _HKI( "Solderpaste Margin Ratio Override" ),
                    &PAD::SetLocalSolderPasteMarginRatio, &PAD::GetLocalSolderPasteMarginRatio,
                    PROPERTY_DISPLAY::PT_RATIO ),
                    groupOverrides ).SetIsCopyable();
 
        propMgr.AddProperty( new PROPERTY_ENUM<PAD, ZONE_CONNECTION>( _HKI( "Zone Connection Style" ),
                    &PAD::SetLocalZoneConnection, &PAD::GetLocalZoneConnection ),
                    groupOverrides ).SetIsCopyable();
 
        constexpr int minZoneWidth = pcbIUScale.mmToIU( ZONE_THICKNESS_MIN_VALUE_MM );
 
        propMgr.AddProperty( new PROPERTY<PAD, std::optional<int>>( _HKI( "Thermal Relief Spoke Width" ),
                    &PAD::SetLocalThermalSpokeWidthOverride, &PAD::GetLocalThermalSpokeWidthOverride,
                    PROPERTY_DISPLAY::PT_SIZE ),
                    groupOverrides )
                .SetValidator( PROPERTY_VALIDATORS::RangeIntValidator<minZoneWidth, INT_MAX> ).SetIsCopyable();
 
        propMgr.AddProperty( new PROPERTY<PAD, double>( _HKI( "Thermal Relief Spoke Angle" ),
                    &PAD::SetThermalSpokeAngleDegrees, &PAD::GetThermalSpokeAngleDegrees,
                    PROPERTY_DISPLAY::PT_DEGREE ),
                    groupOverrides ).SetIsCopyable();
 
        propMgr.AddProperty( new PROPERTY<PAD, std::optional<int>>( _HKI( "Thermal Relief Gap" ),
                    &PAD::SetLocalThermalGapOverride, &PAD::GetLocalThermalGapOverride,
                    PROPERTY_DISPLAY::PT_SIZE ),
                    groupOverrides )
                .SetValidator( PROPERTY_VALIDATORS::PositiveIntValidator ).SetIsCopyable();
 
        // TODO delta, drill shape offset, layer set
    }
} _PAD_DESC;
 
ENUM_TO_WXANY( PAD_ATTRIB );
ENUM_TO_WXANY( PAD_SHAPE );
ENUM_TO_WXANY( PAD_PROP );
ENUM_TO_WXANY( PAD_DRILL_SHAPE );
ENUM_TO_WXANY( PAD_SIM_ELECTRICAL_TYPE );