sch_pin.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2016 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2015 Wayne Stambaugh <[email protected]>
 * Copyright (C) 2018 CERN
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 * @author Jon Evans <[email protected]>
 *
 * 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 <sch_render_settings.h>
#include "sch_pin.h"
 
#include <connectivity/conn_pin_name.h>
#include <lib_id.h>
#include <lib_symbol.h>
#include <pin_map.h>
#include <sch_symbol.h>
#include <sch_sheet_path.h>
#include <api/api_enums.h>
#include <api/api_utils.h>
#include <base_units.h>
#include <pgm_base.h>
#include <pin_layout_cache.h>
#include <plotters/plotter.h>
#include <sch_draw_panel.h>
#include <sch_edit_frame.h>
#include <symbol_edit_frame.h>
#include <settings/settings_manager.h>
#include <symbol_editor/symbol_editor_settings.h>
#include <trace_helpers.h>
#include <trigo.h>
#include <string_utils.h>
#include <properties/property.h>
#include <properties/property_mgr.h>
#include <api/schematic/schematic_types.pb.h>
 
wxString FormatStackedPinForDisplay( const wxString& aPinNumber, int aPinLength, int aTextSize, KIFONT::FONT* aFont,
                                     const KIFONT::METRICS& aFontMetrics )
{
    // Check if this is stacked pin notation: [A,B,C]
    if( !aPinNumber.StartsWith( "[" ) || !aPinNumber.EndsWith( "]" ) )
        return aPinNumber;
 
    // Escaping must never reach the user, so every display form below is built from the unescaped
    // items.  Range notation (e.g. 1-5) is preserved rather than expanded.
    wxString              inner = aPinNumber.Mid( 1, aPinNumber.Length() - 2 );
    std::vector<wxString> parts = SplitStackedPinDisplayItems( inner );
 
    if( parts.empty() )
        return aPinNumber; // malformed; fallback
 
    for( wxString& part : parts )
        part.Trim( true ).Trim( false );
 
    // Build the single-line (unescaped) form and check whether it fits along the pin.
    wxString singleLine = "[";
 
    for( size_t i = 0; i < parts.size(); ++i )
    {
        if( i > 0 )
            singleLine += ",";
 
        singleLine += parts[i];
    }
 
    singleLine += "]";
 
    const int minPinTextWidth = schIUScale.MilsToIU( 50 );
    const int maxPinTextWidth = std::max( aPinLength, minPinTextWidth );
 
    VECTOR2D fontSize( aTextSize, aTextSize );
    int      penWidth = GetPenSizeForNormal( aTextSize );
    VECTOR2I textExtents = aFont->StringBoundaryLimits( singleLine, fontSize, penWidth, false, false, aFontMetrics );
 
    if( textExtents.x <= maxPinTextWidth )
        return singleLine; // Fits already
 
    // Build multi-line representation inside braces.
    wxString result = "[";
 
    for( size_t i = 0; i < parts.size(); ++i )
    {
        if( i > 0 )
            result += "\n";
 
        result += parts[i];
    }
 
    result += "]";
    return result;
}
 
 
// small margin in internal units between the pin text and the pin line
#define PIN_TEXT_MARGIN 4

static int internalPinDecoSize( const RENDER_SETTINGS* aSettings, const SCH_PIN &aPin )
{
    const SCH_RENDER_SETTINGS* settings = static_cast<const SCH_RENDER_SETTINGS*>( aSettings );
 
    if( settings && settings->m_PinSymbolSize )
        return settings->m_PinSymbolSize;
 
    return aPin.GetNameTextSize() != 0 ? aPin.GetNameTextSize() / 2 : aPin.GetNumberTextSize() / 2;
}
 

static int externalPinDecoSize( const RENDER_SETTINGS* aSettings, const SCH_PIN &aPin )
{
    const SCH_RENDER_SETTINGS* settings = static_cast<const SCH_RENDER_SETTINGS*>( aSettings );
 
    if( settings && settings->m_PinSymbolSize )
        return settings->m_PinSymbolSize;
 
    return aPin.GetNumberTextSize() / 2;
}
 
 
SCH_PIN::SCH_PIN( LIB_SYMBOL* aParentSymbol ) :
        SCH_ITEM( aParentSymbol, SCH_PIN_T, 0, 0 ),
        m_libPin( nullptr ),
        m_position( { 0, 0 } ),
        m_length( schIUScale.MilsToIU( DEFAULT_PIN_LENGTH ) ),
        m_orientation( PIN_ORIENTATION::PIN_RIGHT ),
        m_shape( GRAPHIC_PINSHAPE::LINE ),
        m_type( ELECTRICAL_PINTYPE::PT_UNSPECIFIED ),
        m_hidden( false ),
        m_numTextSize( schIUScale.MilsToIU( DEFAULT_PINNUM_SIZE ) ),
        m_nameTextSize( schIUScale.MilsToIU( DEFAULT_PINNAME_SIZE ) ),
        m_isDangling( true )
{
    if( SYMBOL_EDITOR_SETTINGS* cfg = GetAppSettings<SYMBOL_EDITOR_SETTINGS>( "symbol_editor" ) )
    {
        m_length       = schIUScale.MilsToIU( cfg->m_Defaults.pin_length );
        m_numTextSize  = schIUScale.MilsToIU( cfg->m_Defaults.pin_num_size );
        m_nameTextSize = schIUScale.MilsToIU( cfg->m_Defaults.pin_name_size );
    }
 
    m_layer = LAYER_DEVICE;
}
 
 
SCH_PIN::SCH_PIN( LIB_SYMBOL* aParentSymbol, const wxString& aName, const wxString& aNumber,
                  PIN_ORIENTATION aOrientation, ELECTRICAL_PINTYPE aPinType, int aLength,
                  int aNameTextSize, int aNumTextSize, int aBodyStyle, const VECTOR2I& aPos,
                  int aUnit ) :
        SCH_ITEM( aParentSymbol, SCH_PIN_T, aUnit, aBodyStyle ),
        m_libPin( nullptr ),
        m_position( aPos ),
        m_length( aLength ),
        m_orientation( aOrientation ),
        m_shape( GRAPHIC_PINSHAPE::LINE ),
        m_type( aPinType ),
        m_hidden( false ),
        m_numTextSize( aNumTextSize ),
        m_nameTextSize( aNameTextSize ),
        m_isDangling( true )
{
    SetName( aName );
    SetNumber( aNumber );
 
    m_layer = LAYER_DEVICE;
}
 
 
SCH_PIN::SCH_PIN( SCH_SYMBOL* aParentSymbol, SCH_PIN* aLibPin ) :
        SCH_ITEM( aParentSymbol, SCH_PIN_T, 0, 0 ),
        m_libPin( aLibPin ),
        m_orientation( PIN_ORIENTATION::INHERIT ),
        m_shape( GRAPHIC_PINSHAPE::INHERIT ),
        m_type( ELECTRICAL_PINTYPE::PT_INHERIT ),
        m_isDangling( true )
{
    wxASSERT( aParentSymbol );
 
    SetName( m_libPin->GetName() );
    SetNumber( m_libPin->GetNumber() );
    m_position = m_libPin->GetPosition();
 
    m_layer = LAYER_PIN;
}
 
 
SCH_PIN::SCH_PIN( SCH_SYMBOL* aParentSymbol, const wxString& aNumber, const wxString& aAlt,
                  const KIID& aUuid ) :
        SCH_ITEM( aParentSymbol, SCH_PIN_T ),
        m_libPin( nullptr ),
        m_orientation( PIN_ORIENTATION::INHERIT ),
        m_shape( GRAPHIC_PINSHAPE::INHERIT ),
        m_type( ELECTRICAL_PINTYPE::PT_INHERIT ),
        m_number( aNumber ),
        m_alt( aAlt ),
        m_isDangling( true )
{
    wxASSERT( aParentSymbol );
 
    const_cast<KIID&>( m_Uuid ) = aUuid;
    m_layer = LAYER_PIN;
}
 
 
SCH_PIN::SCH_PIN( const SCH_PIN& aPin ) :
        SCH_ITEM( aPin ),
        m_libPin( aPin.m_libPin ),
        m_alternates( aPin.m_alternates ),
        m_position( aPin.m_position ),
        m_length( aPin.m_length ),
        m_orientation( aPin.m_orientation ),
        m_shape( aPin.m_shape ),
        m_type( aPin.m_type ),
        m_hidden( aPin.m_hidden ),
        m_numTextSize( aPin.m_numTextSize ),
        m_nameTextSize( aPin.m_nameTextSize ),
        m_alt( aPin.m_alt ),
        m_isDangling( aPin.m_isDangling )
{
    SetName( aPin.m_name );
    SetNumber( aPin.m_number );
 
    m_layer = aPin.m_layer;
}
 
 
SCH_PIN::~SCH_PIN()
{
}
 
 
SCH_PIN& SCH_PIN::operator=( const SCH_PIN& aPin )
{
    SCH_ITEM::operator=( aPin );
 
    m_libPin = aPin.m_libPin;
    m_alternates = aPin.m_alternates;
    m_alt = aPin.m_alt;
    m_name = aPin.m_name;
    m_number = aPin.m_number;
    m_position = aPin.m_position;
    m_length = aPin.m_length;
    m_orientation = aPin.m_orientation;
    m_shape = aPin.m_shape;
    m_type = aPin.m_type;
    m_hidden = aPin.m_hidden;
    m_numTextSize = aPin.m_numTextSize;
    m_nameTextSize = aPin.m_nameTextSize;
    m_isDangling = aPin.m_isDangling;
    m_layoutCache.reset();
 
    return *this;
}
 
 
void SCH_PIN::swapData( SCH_ITEM* aItem )
{
    wxCHECK( aItem && aItem->Type() == SCH_PIN_T, /* void */ );
 
    SCH_PIN* pin = static_cast<SCH_PIN*>( aItem );
 
    std::swap( m_libPin, pin->m_libPin );
    std::swap( m_alternates, pin->m_alternates );
    std::swap( m_alt, pin->m_alt );
    std::swap( m_name, pin->m_name );
    std::swap( m_number, pin->m_number );
    std::swap( m_position, pin->m_position );
    std::swap( m_length, pin->m_length );
    std::swap( m_orientation, pin->m_orientation );
    std::swap( m_shape, pin->m_shape );
    std::swap( m_type, pin->m_type );
    std::swap( m_hidden, pin->m_hidden );
    std::swap( m_numTextSize, pin->m_numTextSize );
    std::swap( m_nameTextSize, pin->m_nameTextSize );
    std::swap( m_isDangling, pin->m_isDangling );
}
 
 
void SCH_PIN::Serialize( google::protobuf::Any& aContainer ) const
{
    using namespace kiapi::common;
    using namespace kiapi::schematic::types;
    SchematicPin pin;
 
    pin.mutable_id()->set_value( m_Uuid.AsStdString() );
    pin.set_name( GetBaseName().ToUTF8() );
    pin.set_number( GetNumber().ToUTF8() );
 
    PackVector2( *pin.mutable_position(), GetLocalPosition(), schIUScale );
    PackDistance( *pin.mutable_length(), GetLength(), schIUScale );
    pin.set_orientation( ToProtoEnum<PIN_ORIENTATION, SchematicPinOrientation>( GetOrientation() ) );
 
    pin.set_electrical_type( ToProtoEnum<ELECTRICAL_PINTYPE, types::ElectricalPinType>( GetType() ) );
    pin.set_shape( ToProtoEnum<GRAPHIC_PINSHAPE, SchematicPinShape>( GetShape() ) );
    pin.set_visible( IsVisible() );
 
    PackDistance( *pin.mutable_name_text_size(), GetNameTextSize(), schIUScale );
    PackDistance( *pin.mutable_number_text_size(), GetNumberTextSize(), schIUScale );
 
    for( const ALT& alt : GetAlternates() | std::views::values )
    {
        SchematicPinAlternate* altProto = pin.add_alternates();
        altProto->set_name( alt.m_Name.ToUTF8() );
        altProto->set_shape( ToProtoEnum<GRAPHIC_PINSHAPE, SchematicPinShape>( alt.m_Shape ) );
        altProto->set_electrical_type( ToProtoEnum<ELECTRICAL_PINTYPE, types::ElectricalPinType>( alt.m_Type ) );
    }
 
    if( !m_alt.IsEmpty() && m_alt != GetBaseName() )
        pin.set_active_alternate( m_alt.ToUTF8() );
 
    kiapi::common::PackCustomProperties( pin.mutable_custom_properties(), *this );
    aContainer.PackFrom( pin );
}
 
 
bool SCH_PIN::Deserialize( const google::protobuf::Any& aContainer )
{
    using namespace kiapi::common;
    using namespace kiapi::schematic::types;
 
    SchematicPin pin;
 
    if( !aContainer.UnpackTo( &pin ) )
        return false;
 
    const_cast<KIID&>( m_Uuid ) = KIID( pin.id().value() );
    m_name = wxString::FromUTF8( pin.name() );
    m_number = wxString::FromUTF8( pin.number() );
 
    SetPosition( UnpackVector2( pin.position(), schIUScale ) );
    SetLength( UnpackDistance( pin.length(), schIUScale ) );
    SetOrientation( FromProtoEnum<PIN_ORIENTATION>( pin.orientation() ) );
 
    m_type = FromProtoEnum<ELECTRICAL_PINTYPE>( pin.electrical_type() );
    m_shape = FromProtoEnum<GRAPHIC_PINSHAPE>( pin.shape() );
    SetVisible( pin.visible() );
 
    m_nameTextSize = UnpackDistance( pin.name_text_size(), schIUScale );
    m_numTextSize = UnpackDistance( pin.number_text_size(), schIUScale );
 
    std::map<wxString, ALT>& alts = GetAlternates();
 
    for( const SchematicPinAlternate& altProto : pin.alternates() )
    {
        ALT alt;
        alt.m_Name = wxString::FromUTF8( altProto.name() );
        alt.m_Shape = FromProtoEnum<GRAPHIC_PINSHAPE>( altProto.shape() );
        alt.m_Type = FromProtoEnum<ELECTRICAL_PINTYPE>( altProto.electrical_type() );
        alts.emplace( alt.m_Name, alt );
    }
 
    kiapi::common::UnpackCustomProperties( pin.custom_properties(), *this );
 
    if( m_layoutCache )
        m_layoutCache->MarkDirty( PIN_LAYOUT_CACHE::DIRTY_FLAGS::ALL );
 
    return true;
}
 
 
VECTOR2I SCH_PIN::GetPosition() const
{
    if( const SCH_SYMBOL* symbol = dynamic_cast<const SCH_SYMBOL*>( GetParentSymbol() ) )
        return symbol->GetTransform().TransformCoordinate( m_position ) + symbol->GetPosition();
    else
        return m_position;
}
 
PIN_ORIENTATION SCH_PIN::GetOrientation() const
{
    if( m_orientation == PIN_ORIENTATION::INHERIT )
    {
        if( !m_libPin )
            return PIN_ORIENTATION::PIN_RIGHT;
 
        return m_libPin->GetOrientation();
    }
 
    return m_orientation;
}
 
 
GRAPHIC_PINSHAPE SCH_PIN::GetShape() const
{
    if( !m_alt.IsEmpty() )
    {
        if( !m_libPin )
            return GRAPHIC_PINSHAPE::LINE;
 
        return m_libPin->GetAlt( m_alt ).m_Shape;
    }
    else if( m_shape == GRAPHIC_PINSHAPE::INHERIT )
    {
        if( !m_libPin )
            return GRAPHIC_PINSHAPE::LINE;
 
        return m_libPin->GetShape();
    }
 
    return m_shape;
}
 
 
int SCH_PIN::GetLength() const
{
    if( !m_length.has_value() )
    {
        if( !m_libPin )
            return 0;
 
        return m_libPin->GetLength();
    }
 
    return m_length.value();
}
 
 
ELECTRICAL_PINTYPE SCH_PIN::GetType() const
{
    if( !m_alt.IsEmpty() )
    {
        if( !m_libPin )
            return ELECTRICAL_PINTYPE::PT_UNSPECIFIED;
 
        return m_libPin->GetAlt( m_alt ).m_Type;
    }
    else if( m_type == ELECTRICAL_PINTYPE::PT_INHERIT )
    {
        if( !m_libPin )
            return ELECTRICAL_PINTYPE::PT_UNSPECIFIED;
 
        return m_libPin->GetType();
    }
 
    return m_type;
}
 
void SCH_PIN::SetType( ELECTRICAL_PINTYPE aType )
{
    if( aType == m_type )
        return;
 
    m_type = aType;
 
    if( m_layoutCache )
        m_layoutCache->MarkDirty( PIN_LAYOUT_CACHE::DIRTY_FLAGS::ELEC_TYPE );
}
 
 
wxString SCH_PIN::GetCanonicalElectricalTypeName() const
{
    // Use GetType() which correctly handles alternates
    return ::GetCanonicalElectricalTypeName( GetType() );
}
 
 
wxString SCH_PIN::GetElectricalTypeName() const
{
    // Use GetType() which correctly handles alternates
    return ElectricalPinTypeGetText( GetType() );
}
 
 
bool SCH_PIN::IsGlobalPower() const
{
    if( GetType() != ELECTRICAL_PINTYPE::PT_POWER_IN )
        return false;
 
    const SYMBOL* parent = GetParentSymbol();
 
    if( parent->IsGlobalPower() )
        return true;
 
    // Local power symbols are never global, even with invisible pins
    if( parent->IsLocalPower() )
        return false;
 
    // Legacy support: invisible power-in pins on non-power symbols act as global power
    return !IsVisible();
}
 
 
bool SCH_PIN::IsLocalPower() const
{
    return GetType() == ELECTRICAL_PINTYPE::PT_POWER_IN
           && GetParentSymbol()->IsLocalPower();
}
 
 
bool SCH_PIN::IsPower() const
{
    return IsLocalPower() || IsGlobalPower();
}
 
 
bool SCH_PIN::IsVisible() const
{
    if( !m_hidden.has_value() )
    {
        if( !m_libPin )
            return true;
 
        return m_libPin->IsVisible();
    }
 
    return !m_hidden.value();
}
 
 
const wxString& SCH_PIN::GetName() const
{
    if( !m_alt.IsEmpty() )
        return m_alt;
 
    return GetBaseName();
}
 
 
const wxString& SCH_PIN::GetBaseName() const
{
    if( m_libPin )
        return m_libPin->GetBaseName();
 
    return m_name;
}
 
 
void SCH_PIN::SetName( const wxString& aName )
{
    if( m_name == aName )
        return;
 
    m_name = aName;
 
    // pin name string does not support spaces
    m_name.Replace( wxT( " " ), wxT( "_" ) );
 
    if( m_layoutCache )
        m_layoutCache->MarkDirty( PIN_LAYOUT_CACHE::DIRTY_FLAGS::NAME );
}
 
 
void SCH_PIN::SetAlt( const wxString& aAlt )
{
    // Do not set the alternate pin definition to the default pin name.  This breaks the library
    // symbol comparison for the ERC and the library diff tool.  It also incorrectly causes the
    // schematic symbol pin alternate to be set.
    if( aAlt.IsEmpty() || aAlt == GetBaseName() )
    {
        m_alt = wxEmptyString;
        return;
    }
 
    if( !m_libPin )
    {
        wxFAIL_MSG( wxString::Format( wxS( "Pin '%s' has no corresponding lib_pin" ), m_number ) );
        m_alt = wxEmptyString;
        return;
    }
 
    if( !m_libPin->GetAlternates().contains( aAlt ) )
    {
        wxFAIL_MSG( wxString::Format( wxS( "Pin '%s' has no alterate '%s'" ), m_number, aAlt ) );
        m_alt = wxEmptyString;
        return;
    }
 
    m_alt = aAlt;
}
 
bool SCH_PIN::IsDangling() const
{
    if( GetType() == ELECTRICAL_PINTYPE::PT_NC || GetType() == ELECTRICAL_PINTYPE::PT_NIC )
        return false;
 
    return m_isDangling;
}
 
 
bool SCH_PIN::SetIsDangling( bool aIsDangling )
{
    const bool changed = m_isDangling != aIsDangling;
    m_isDangling = aIsDangling;
    return changed;
}
 
 
bool SCH_PIN::IsStacked( const SCH_PIN* aPin ) const
{
    const auto isPassiveOrNic = []( ELECTRICAL_PINTYPE t )
    {
        return t == ELECTRICAL_PINTYPE::PT_PASSIVE || t == ELECTRICAL_PINTYPE::PT_NIC;
    };
 
    const bool sameParent = m_parent == aPin->GetParent();
    const bool samePos    = GetPosition() == aPin->GetPosition();
    const bool sameName   = GetName() == aPin->GetName();
    const bool typeCompat = GetType() == aPin->GetType()
                             || isPassiveOrNic( GetType() )
                             || isPassiveOrNic( aPin->GetType() );
 
    wxLogTrace( traceStackedPins,
                wxString::Format( "IsStacked: this='%s/%s' other='%s/%s' sameParent=%d samePos=%d sameName=%d typeCompat=%d",
                                  GetName(), GetNumber(), aPin->GetName(), aPin->GetNumber(), sameParent,
                                  samePos, sameName, typeCompat ) );
 
    return sameParent && samePos && sameName && typeCompat;
}
 
 
bool SCH_PIN::Matches( const EDA_SEARCH_DATA& aSearchData, void* aAuxData ) const
{
    const SCH_SEARCH_DATA& schSearchData =
            dynamic_cast<const SCH_SEARCH_DATA&>( aSearchData );
 
    if( schSearchData.searchAllPins
        && ( EDA_ITEM::Matches( GetName(), aSearchData )
             || EDA_ITEM::Matches( GetNumber(), aSearchData ) ) )
    {
        return true;
    }
 
    SCH_SHEET_PATH* sheetPath = reinterpret_cast<SCH_SHEET_PATH*>( aAuxData );
 
    return schSearchData.searchNetNames && sheetPath && MatchesNetName( aSearchData, sheetPath );
}
 
 
bool SCH_PIN::Replace( const EDA_SEARCH_DATA& aSearchData, void* aAuxData )
{
    bool isReplaced = false;
 
    if( dynamic_cast<LIB_SYMBOL*>( GetParentSymbol() ) )
    {
        isReplaced |= EDA_ITEM::Replace( aSearchData, m_name );
        isReplaced |= EDA_ITEM::Replace( aSearchData, m_number );
    }
    else
    {
        /* TODO: waiting on a way to override pins in the schematic...
        isReplaced |= EDA_ITEM::Replace( aSearchData, m_name );
        isReplaced |= EDA_ITEM::Replace( aSearchData, m_number );
         */
    }
 
    return isReplaced;
}
 
 
bool SCH_PIN::HitTest( const VECTOR2I& aPosition, int aAccuracy ) const
{
    // When looking for an "exact" hit aAccuracy will be 0 which works poorly if the pin has
    // no pin number or name.  Give it a floor.
    if( Schematic() )
        aAccuracy = std::max( aAccuracy, Schematic()->Settings().m_PinSymbolSize / 4 );
 
    BOX2I rect = GetBoundingBox( false, true, m_flags & SHOW_ELEC_TYPE );
 
    return rect.Inflate( aAccuracy ).Contains( aPosition );
}
 
 
bool SCH_PIN::HitTest( const BOX2I& aRect, bool aContained, int aAccuracy ) const
{
    if( m_flags & (STRUCT_DELETED | SKIP_STRUCT ) )
        return false;
 
    BOX2I sel = aRect;
 
    if ( aAccuracy )
        sel.Inflate( aAccuracy );
 
    if( aContained )
        return sel.Contains( GetBoundingBox( false, false, false ) );
 
    return sel.Intersects( GetBoundingBox( false, true, m_flags & SHOW_ELEC_TYPE ) );
}
 
 
const wxString& SCH_PIN::GetShownName() const
{
    if( !m_alt.IsEmpty() )
        return m_alt;
    else if( m_libPin )
        return m_libPin->GetShownName();
 
    return m_name;
}
 
 
const wxString& SCH_PIN::GetShownNumber() const
{
    return m_number;
}
 
 
std::vector<wxString> SCH_PIN::GetStackedPinNumbers( bool* aValid ) const
{
    return ExpandStackedPinNotation( GetShownNumber(), aValid );
}
 
 
int SCH_PIN::GetStackedPinCount( bool* aValid ) const
{
    const wxString& shown = GetShownNumber();
    return CountStackedPinNotation( shown, aValid );
}
 
 
std::optional<wxString> SCH_PIN::GetSmallestLogicalNumber() const
{
    bool valid = false;
    auto numbers = GetStackedPinNumbers( &valid );
 
    if( valid && !numbers.empty() )
        return numbers.front();    // Already in ascending order
 
    return std::nullopt;
}
 
 
wxString SCH_PIN::GetSmallestStackedPadNumber() const
{
    if( auto smallest = GetSmallestLogicalNumber() )
        return *smallest;
 
    return GetShownNumber();
}
 
 
wxString SCH_PIN::GetEffectivePadNumber( const SCH_SHEET_PATH& aSheet, const wxString& aVariantName,
                                         const LIB_ID& aFootprintLibId, const std::set<wxString>* aFootprintPadNumbers,
                                         PAD_RESOLUTION* aState ) const
{
    const wxString& pinNumber = GetNumber();
    const PIN_MAP*  map = nullptr;
 
    if( const SCH_SYMBOL* symbol = dynamic_cast<const SCH_SYMBOL*>( GetParentSymbol() ) )
    {
        PIN_MAP_INSTANCE_OVERRIDE ovr = symbol->GetPinMapOverride( &aSheet, aVariantName );
 
        const LIB_SYMBOL* lib = symbol->GetLibSymbolRef().get();
 
        if( ovr.m_Mode == PIN_MAP_OVERRIDE_MODE::USE_NAMED_MAP && lib )
            map = lib->GetEffectivePinMaps().FindByName( ovr.m_ActiveMapName );
 
        // Library default, or a named map that no longer exists, resolves through the footprint.
        if( !map && ovr.m_Mode != PIN_MAP_OVERRIDE_MODE::FORCE_IDENTITY && lib )
        {
            for( const ASSOCIATED_FOOTPRINT& assoc : lib->GetEffectiveAssociatedFootprints() )
            {
                if( assoc.m_FootprintLibId == aFootprintLibId )
                {
                    map = lib->GetEffectivePinMaps().FindByName( assoc.m_MapName );
                    break;
                }
            }
        }
 
        // Instance-local sparse edits patch the resolved map, but are ignored under forced
        // identity per the PIN_MAP_INSTANCE_OVERRIDE contract.
        if( ovr.m_Mode != PIN_MAP_OVERRIDE_MODE::FORCE_IDENTITY )
        {
            for( const PIN_MAP_ENTRY& edit : ovr.m_Edits )
            {
                if( edit.m_PinNumber == pinNumber )
                {
                    if( aState )
                        *aState = PAD_RESOLUTION::MAPPED;
 
                    return edit.m_PadNumber;
                }
            }
        }
    }
 
    // 1. MAPPED - an explicit entry wins and needs no footprint.
    if( map && map->HasEntry( pinNumber ) )
    {
        if( aState )
            *aState = PAD_RESOLUTION::MAPPED;
 
        return map->GetPadNumber( pinNumber );
    }
 
    if( aFootprintPadNumbers && HasIdentityPad( pinNumber, *aFootprintPadNumbers ) )
    {
        if( aState )
            *aState = PAD_RESOLUTION::IDENTITY;
 
        return pinNumber;
    }
 
    // 3. UNMAPPED, or assumed identity when no footprint is available (the painter path).
    if( aState )
        *aState = aFootprintPadNumbers ? PAD_RESOLUTION::UNMAPPED : PAD_RESOLUTION::IDENTITY;
 
    return aFootprintPadNumbers ? wxString() : pinNumber;
}
 
 
bool SCH_PIN::HasIdentityPad( const wxString& aPinNumber, const std::set<wxString>& aPads )
{
    if( aPads.contains( aPinNumber ) )
        return true;
 
    bool valid = false;
    const auto numbers = ExpandStackedPinNotation( aPinNumber, &valid );
    return valid && std::any_of( numbers.begin(), numbers.end(),
                                [&]( const wxString& number ) { return aPads.contains( number ); } );
}
 
 
wxString SCH_PIN::GetEffectivePadNumber( const SCH_SHEET_PATH& aSheet, const wxString& aVariantName ) const
{
    LIB_ID footprintLibId;
 
    if( const SCH_SYMBOL* symbol = dynamic_cast<const SCH_SYMBOL*>( GetParentSymbol() ) )
        footprintLibId.Parse( symbol->GetFootprintFieldText( &aSheet, RESOLVED, aVariantName ) );
 
    return GetEffectivePadNumber( aSheet, aVariantName, footprintLibId, nullptr );
}
 
 
void SCH_PIN::SetNumber( const wxString& aNumber )
{
    if( m_number == aNumber )
        return;
 
    m_number = aNumber;
    // pin number string does not support spaces
    m_number.Replace( wxT( " " ), wxT( "_" ) );
 
    if( m_layoutCache )
        m_layoutCache->MarkDirty( PIN_LAYOUT_CACHE::DIRTY_FLAGS::NUMBER );
}
 
 
int SCH_PIN::GetNameTextSize() const
{
    if( !m_nameTextSize.has_value() )
    {
        if( !m_libPin )
            return schIUScale.MilsToIU( DEFAULT_PINNAME_SIZE );
 
        return m_libPin->GetNameTextSize();
    }
 
    return m_nameTextSize.value();
}
 
 
void SCH_PIN::SetNameTextSize( int aSize )
{
    if( aSize == m_nameTextSize )
        return;
 
    m_nameTextSize = aSize;
 
    if( m_layoutCache )
        m_layoutCache->MarkDirty( PIN_LAYOUT_CACHE::DIRTY_FLAGS::NAME );
}
 
 
int SCH_PIN::GetNumberTextSize() const
{
    if( !m_numTextSize.has_value() )
    {
        if( !m_libPin )
            return schIUScale.MilsToIU( DEFAULT_PINNUM_SIZE );
 
        return m_libPin->GetNumberTextSize();
    }
 
    return m_numTextSize.value();
}
 
 
void SCH_PIN::SetNumberTextSize( int aSize )
{
    if( aSize == m_numTextSize )
        return;
 
    m_numTextSize = aSize;
 
    if( m_layoutCache )
        m_layoutCache->MarkDirty( PIN_LAYOUT_CACHE::DIRTY_FLAGS::NUMBER );
}
 
 
VECTOR2I SCH_PIN::GetPinRoot() const
{
    if( const SCH_SYMBOL* symbol = dynamic_cast<const SCH_SYMBOL*>( GetParentSymbol() ) )
    {
        const TRANSFORM& t = symbol->GetTransform();
 
        if( !m_libPin )
            return GetPosition();
 
        return t.TransformCoordinate( m_libPin->GetPinRoot() ) + symbol->GetPosition();
    }
 
    switch( GetOrientation() )
    {
    default:
    case PIN_ORIENTATION::PIN_RIGHT: return m_position + VECTOR2I(  GetLength(), 0 );
    case PIN_ORIENTATION::PIN_LEFT:  return m_position + VECTOR2I( -GetLength(), 0 );
    case PIN_ORIENTATION::PIN_UP:    return m_position + VECTOR2I( 0, -GetLength() );
    case PIN_ORIENTATION::PIN_DOWN:  return m_position + VECTOR2I( 0,  GetLength() );
    }
}
 
 
void SCH_PIN::PlotPinType( PLOTTER *aPlotter, const VECTOR2I &aPosition,
                           PIN_ORIENTATION aOrientation, bool aDimmed ) const
{
    int                  MapX1, MapY1, x1, y1;
    SCH_RENDER_SETTINGS* renderSettings = getRenderSettings( aPlotter );
    COLOR4D              color = renderSettings->GetLayerColor( LAYER_PIN );
    COLOR4D              bg = renderSettings->GetBackgroundColor();
    int                  penWidth = GetEffectivePenWidth( renderSettings );
    int                  pinLength = GetLength();
 
    if( bg == COLOR4D::UNSPECIFIED || !aPlotter->GetColorMode() )
        bg = COLOR4D::WHITE;
 
    if( color.m_text && Schematic() )
        color = COLOR4D( ResolveText( *color.m_text, &Schematic()->CurrentSheet() ) );
 
    if( aDimmed )
    {
        color.Desaturate( );
        color = color.Mix( bg, 0.5f );
    }
 
    aPlotter->SetColor( color );
    aPlotter->SetCurrentLineWidth( penWidth );
 
    MapX1 = MapY1 = 0;
    x1 = aPosition.x; y1 = aPosition.y;
 
    switch( aOrientation )
    {
    case PIN_ORIENTATION::PIN_UP:     y1 = aPosition.y - pinLength;  MapY1 = 1;              break;
    case PIN_ORIENTATION::PIN_DOWN:   y1 = aPosition.y + pinLength;  MapY1 = -1;             break;
    case PIN_ORIENTATION::PIN_LEFT:   x1 = aPosition.x - pinLength;  MapX1 = 1;              break;
    case PIN_ORIENTATION::PIN_RIGHT:  x1 = aPosition.x + pinLength;  MapX1 = -1;             break;
    case PIN_ORIENTATION::INHERIT:    wxFAIL_MSG( wxS( "aOrientation must be resolved!" ) ); break;
    }
 
    if( m_shape == GRAPHIC_PINSHAPE::INVERTED || m_shape == GRAPHIC_PINSHAPE::INVERTED_CLOCK )
    {
        const int radius = externalPinDecoSize( aPlotter->RenderSettings(), *this );
        aPlotter->Circle( VECTOR2I( MapX1 * radius + x1, MapY1 * radius + y1 ), radius * 2,
                          FILL_T::NO_FILL, penWidth );
 
        aPlotter->MoveTo( VECTOR2I( MapX1 * radius * 2 + x1, MapY1 * radius * 2 + y1 ) );
        aPlotter->FinishTo( aPosition );
    }
    else if( m_shape == GRAPHIC_PINSHAPE::FALLING_EDGE_CLOCK )
    {
        const int deco_size = internalPinDecoSize( aPlotter->RenderSettings(), *this );
        if( MapY1 == 0 ) /* MapX1 = +- 1 */
        {
            aPlotter->MoveTo( VECTOR2I( x1, y1 + deco_size ) );
            aPlotter->LineTo( VECTOR2I( x1 + MapX1 * deco_size * 2, y1 ) );
            aPlotter->FinishTo( VECTOR2I( x1, y1 - deco_size ) );
        }
        else    /* MapX1 = 0 */
        {
            aPlotter->MoveTo( VECTOR2I( x1 + deco_size, y1 ) );
            aPlotter->LineTo( VECTOR2I( x1, y1 + MapY1 * deco_size * 2 ) );
            aPlotter->FinishTo( VECTOR2I( x1 - deco_size, y1 ) );
        }
 
        aPlotter->MoveTo( VECTOR2I( MapX1 * deco_size * 2 + x1, MapY1 * deco_size * 2 + y1 ) );
        aPlotter->FinishTo( aPosition );
    }
    else
    {
        aPlotter->MoveTo( VECTOR2I( x1, y1 ) );
        aPlotter->FinishTo( aPosition );
    }
 
    if( m_shape == GRAPHIC_PINSHAPE::CLOCK
            || m_shape == GRAPHIC_PINSHAPE::INVERTED_CLOCK
            || m_shape == GRAPHIC_PINSHAPE::CLOCK_LOW )
    {
        const int deco_size = internalPinDecoSize( aPlotter->RenderSettings(), *this );
 
        if( MapY1 == 0 ) /* MapX1 = +- 1 */
        {
            aPlotter->MoveTo( VECTOR2I( x1, y1 + deco_size ) );
            aPlotter->LineTo( VECTOR2I( x1 - MapX1 * deco_size * 2, y1 ) );
            aPlotter->FinishTo( VECTOR2I( x1, y1 - deco_size ) );
        }
        else    /* MapX1 = 0 */
        {
            aPlotter->MoveTo( VECTOR2I( x1 + deco_size, y1 ) );
            aPlotter->LineTo( VECTOR2I( x1, y1 - MapY1 * deco_size * 2 ) );
            aPlotter->FinishTo( VECTOR2I( x1 - deco_size, y1 ) );
        }
    }
 
    if( m_shape == GRAPHIC_PINSHAPE::INPUT_LOW
            || m_shape == GRAPHIC_PINSHAPE::CLOCK_LOW ) /* IEEE symbol "Active Low Input" */
    {
        const int deco_size = externalPinDecoSize( aPlotter->RenderSettings(), *this );
 
        if( MapY1 == 0 )        /* MapX1 = +- 1 */
        {
            aPlotter->MoveTo( VECTOR2I( x1 + MapX1 * deco_size * 2, y1 ) );
            aPlotter->LineTo( VECTOR2I( x1 + MapX1 * deco_size * 2, y1 - deco_size * 2 ) );
            aPlotter->FinishTo( VECTOR2I( x1, y1 ) );
        }
        else    /* MapX1 = 0 */
        {
            aPlotter->MoveTo( VECTOR2I( x1, y1 + MapY1 * deco_size * 2 ) );
            aPlotter->LineTo( VECTOR2I( x1 - deco_size * 2, y1 + MapY1 * deco_size * 2 ) );
            aPlotter->FinishTo( VECTOR2I( x1, y1 ) );
        }
    }
 
    if( m_shape == GRAPHIC_PINSHAPE::OUTPUT_LOW ) /* IEEE symbol "Active Low Output" */
    {
        const int symbol_size = externalPinDecoSize( aPlotter->RenderSettings(), *this );
 
        if( MapY1 == 0 )        /* MapX1 = +- 1 */
        {
            aPlotter->MoveTo( VECTOR2I( x1, y1 - symbol_size * 2 ) );
            aPlotter->FinishTo( VECTOR2I( x1 + MapX1 * symbol_size * 2, y1 ) );
        }
        else    /* MapX1 = 0 */
        {
            aPlotter->MoveTo( VECTOR2I( x1 - symbol_size * 2, y1 ) );
            aPlotter->FinishTo( VECTOR2I( x1, y1 + MapY1 * symbol_size * 2 ) );
        }
    }
    else if( m_shape == GRAPHIC_PINSHAPE::NONLOGIC ) /* NonLogic pin symbol */
    {
        const int deco_size = externalPinDecoSize( aPlotter->RenderSettings(), *this );
        aPlotter->MoveTo( VECTOR2I( x1 - ( MapX1 + MapY1 ) * deco_size,
                                    y1 - ( MapY1 - MapX1 ) * deco_size ) );
        aPlotter->FinishTo( VECTOR2I( x1 + ( MapX1 + MapY1 ) * deco_size,
                                      y1 + ( MapY1 - MapX1 ) * deco_size ) );
        aPlotter->MoveTo( VECTOR2I( x1 - ( MapX1 - MapY1 ) * deco_size,
                                    y1 - ( MapY1 + MapX1 ) * deco_size ) );
        aPlotter->FinishTo( VECTOR2I( x1 + ( MapX1 - MapY1 ) * deco_size,
                                      y1 + ( MapY1 + MapX1 ) * deco_size ) );
    }
 
    if( GetType() == ELECTRICAL_PINTYPE::PT_NC ) // Draw a N.C. symbol
    {
        const int deco_size = TARGET_PIN_RADIUS;
        const int ex1 = aPosition.x;
        const int ey1 = aPosition.y;
        aPlotter->MoveTo( VECTOR2I( ex1 - deco_size, ey1 - deco_size ) );
        aPlotter->FinishTo( VECTOR2I( ex1 + deco_size, ey1 + deco_size ) );
        aPlotter->MoveTo( VECTOR2I( ex1 + deco_size, ey1 - deco_size ) );
        aPlotter->FinishTo( VECTOR2I( ex1 - deco_size, ey1 + deco_size ) );
    }
}
 
 
void SCH_PIN::PlotPinTexts( PLOTTER *aPlotter, const VECTOR2I &aPinPos, PIN_ORIENTATION aPinOrient,
                            int aTextInside, bool aDrawPinNum, bool aDrawPinName, bool aDimmed ) const
{
    RENDER_SETTINGS* settings = aPlotter->RenderSettings();
    KIFONT::FONT*    font = KIFONT::FONT::GetFont( settings->GetDefaultFont(), false, false );
    wxString         name = GetShownName();
    wxString         number = GetShownNumber();
 
    // Apply stacked pin display formatting (reuse helper from pin_layout_cache)
    if( aDrawPinNum && !number.IsEmpty() )
    {
        const KIFONT::METRICS& metrics = GetFontMetrics();
        number = FormatStackedPinForDisplay( number, GetLength(), GetNumberTextSize(), font, metrics );
    }
 
    if( name.IsEmpty() || m_nameTextSize == 0 )
        aDrawPinName = false;
 
    if( number.IsEmpty() || m_numTextSize == 0 )
        aDrawPinNum = false;
 
    if( !aDrawPinNum && !aDrawPinName )
        return;
 
    int namePenWidth = settings->GetDefaultPenWidth();
    int numPenWidth  = settings->GetDefaultPenWidth();
 
    // Include the painter's clearance (PIN_LAYOUT_CACHE::getPinTextOffset()) so plotted pin text
    // sits where it's drawn on screen, not a few mils closer to the pin.
    int pinTextOffset = schIUScale.MilsToIU( KiROUND( 24 * getRenderSettings( aPlotter )->m_TextOffsetRatio ) );
    int name_offset = pinTextOffset + schIUScale.MilsToIU( PIN_TEXT_MARGIN ) + namePenWidth;
    int num_offset  = pinTextOffset + schIUScale.MilsToIU( PIN_TEXT_MARGIN ) + numPenWidth;
 
    COLOR4D nameColor = settings->GetLayerColor( LAYER_PINNAM );
    COLOR4D numColor  = settings->GetLayerColor( LAYER_PINNUM );
    COLOR4D bg = settings->GetBackgroundColor();
 
    if( bg == COLOR4D::UNSPECIFIED || !aPlotter->GetColorMode() )
        bg = COLOR4D::WHITE;
 
    if( nameColor.m_text && Schematic() )
        nameColor = COLOR4D( ResolveText( *nameColor.m_text, &Schematic()->CurrentSheet() ) );
 
    if( numColor.m_text && Schematic() )
        numColor = COLOR4D( ResolveText( *numColor.m_text, &Schematic()->CurrentSheet() ) );
 
    if( aDimmed )
    {
        nameColor.Desaturate();
        numColor.Desaturate();
        nameColor = nameColor.Mix( bg, 0.5f );
        numColor = numColor.Mix( bg, 0.5f );
    }
 
    int x1 = aPinPos.x;
    int y1 = aPinPos.y;
 
    switch( aPinOrient )
    {
    case PIN_ORIENTATION::PIN_UP:    y1 -= GetLength(); break;
    case PIN_ORIENTATION::PIN_DOWN:  y1 += GetLength(); break;
    case PIN_ORIENTATION::PIN_LEFT:  x1 -= GetLength(); break;
    case PIN_ORIENTATION::PIN_RIGHT: x1 += GetLength(); break;
    default: break;
    }
 
    // Keep a multi-line stacked block on the authored side of a mirrored symbol (issue 24894)
    const bool flipStacked =
            number.Contains( wxT( "\n" ) ) && StackedTextSideFlipped( getRenderSettings( aPlotter )->m_Transform );
 
    auto plotSimpleText =
            [&]( int x, int y, const EDA_ANGLE& angle, GR_TEXT_H_ALIGN_T hJustify, GR_TEXT_V_ALIGN_T vJustify,
                 const wxString& txt, int size, int penWidth, const COLOR4D& col )
            {
                TEXT_ATTRIBUTES attrs;
                attrs.m_StrokeWidth = penWidth;
                attrs.m_Angle = angle;
                attrs.m_Size = VECTOR2I( size, size );
                attrs.m_Halign = hJustify;
                attrs.m_Valign = vJustify;
                attrs.m_Multiline = false; // we'll manage multi-line manually
                aPlotter->PlotText( VECTOR2I( x, y ), col, txt, attrs, font, GetFontMetrics() );
            };
 
    auto plotMultiLineWithBraces =
            [&]( int anchorX, int anchorY, EDA_ANGLE angle, GR_TEXT_V_ALIGN_T vAlign, bool aAllowFlip )
    {
        // If not multi-line formatted, just plot single line centered.
        if( !number.StartsWith( "[" ) || !number.EndsWith( "]" ) || !number.Contains( "\n" ) )
        {
            plotSimpleText( anchorX, anchorY, angle, GR_TEXT_H_ALIGN_CENTER, vAlign, number, GetNumberTextSize(),
                            numPenWidth, numColor );
            return;
        }
 
        wxString      content = number.Mid( 1, number.Length() - 2 );
        wxArrayString lines;
        wxStringSplit( content, lines, '\n' );
 
        if( lines.size() <= 1 )
        {
            plotSimpleText( anchorX, anchorY, angle, GR_TEXT_H_ALIGN_CENTER, vAlign, content, GetNumberTextSize(),
                            numPenWidth, numColor );
            return;
        }
 
        const int              textSize = GetNumberTextSize();
        const int              lineSpacing = KiROUND( textSize * 1.3 );
        const int              numLines = (int) lines.size();
        const bool             verticalText = ( angle == ANGLE_VERTICAL );
        const KIFONT::METRICS& metrics = GetFontMetrics();
 
        if( aAllowFlip && flipStacked )
        {
            // Reflect the anchor about the pin line
            if( verticalText )
                anchorX = 2 * aPinPos.x - anchorX;
            else
                anchorY = 2 * aPinPos.y - anchorY;
 
            if( vAlign == GR_TEXT_V_ALIGN_BOTTOM )
                vAlign = GR_TEXT_V_ALIGN_TOP;
            else if( vAlign == GR_TEXT_V_ALIGN_TOP )
                vAlign = GR_TEXT_V_ALIGN_BOTTOM;
        }
 
        // Centre each line and align the stacked block's edge to the anchor, matching the
        // on-screen painter (PIN_LAYOUT_CACHE) so stacked numbers plot where they're drawn.
        int firstLineCentre;
 
        switch( vAlign )
        {
        case GR_TEXT_V_ALIGN_BOTTOM: firstLineCentre = -( 2 * numLines - 1 ) * lineSpacing / 2; break;
        case GR_TEXT_V_ALIGN_TOP: firstLineCentre = lineSpacing / 2; break;
        default: // GR_TEXT_V_ALIGN_CENTER
            firstLineCentre = -( numLines - 1 ) * lineSpacing / 2;
            break;
        }
 
        firstLineCentre += verticalText ? anchorX : anchorY;
 
        // Plot each line centred; track the widest for brace spacing.
        int maxLineWidth = 0;
 
        for( int i = 0; i < numLines; ++i )
        {
            wxString l = lines[i];
            l.Trim( true ).Trim( false );
 
            VECTOR2I ext = font->StringBoundaryLimits( l, VECTOR2D( textSize, textSize ),
                                                       GetPenSizeForNormal( textSize ), false, false, metrics );
            maxLineWidth = std::max( maxLineWidth, ext.x );
 
            int stack = firstLineCentre + i * lineSpacing;
            int lx = verticalText ? stack : anchorX;
            int ly = verticalText ? anchorY : stack;
            plotSimpleText( lx, ly, angle, GR_TEXT_H_ALIGN_CENTER, GR_TEXT_V_ALIGN_CENTER, l, textSize, numPenWidth,
                            numColor );
        }
 
        // Now draw braces emulating SCH_PAINTER brace geometry
        auto plotBrace = [&]( const VECTOR2I& top, const VECTOR2I& bottom, bool leftOrTop, bool isVerticalText )
        {
            // Build 4 small segments approximating curly brace
            VECTOR2I mid = ( top + bottom ) / 2;
            int      braceWidth = textSize / 3; // same scale as painter
            VECTOR2I p1 = top;
            VECTOR2I p5 = bottom;
            VECTOR2I p2 = top;
            VECTOR2I p3 = mid;
            VECTOR2I p4 = bottom;
            int      offset = leftOrTop ? -braceWidth : braceWidth;
 
            if( isVerticalText )
            {
                // Text vertical => brace extends in Y (horizontal brace lines across X axis set)
                // For vertical orientation we offset Y for p2/p3/p4
                p2.y += offset / 2;
                p3.y += offset;
                p4.y += offset / 2;
            }
            else
            {
                // Horizontal text => brace extends in X
                p2.x += offset / 2;
                p3.x += offset;
                p4.x += offset / 2;
            }
 
            aPlotter->MoveTo( p1 );
            aPlotter->FinishTo( p2 );
            aPlotter->MoveTo( p2 );
            aPlotter->FinishTo( p3 );
            aPlotter->MoveTo( p3 );
            aPlotter->FinishTo( p4 );
            aPlotter->MoveTo( p4 );
            aPlotter->FinishTo( p5 );
        };
 
        aPlotter->SetCurrentLineWidth( numPenWidth );
 
        const int braceWidth = textSize / 3;
        const int extraHeight = textSize / 3; // extend beyond text block
        const int braceSpacing = maxLineWidth / 2 + braceWidth;
        const int blockSpan = ( numLines - 1 ) * lineSpacing;
 
        if( verticalText )
        {
            VECTOR2I braceStart( firstLineCentre - 2 * extraHeight, anchorY );
            VECTOR2I braceEnd( firstLineCentre + blockSpan, anchorY );
 
            VECTOR2I topStart = braceStart;
            topStart.y -= braceSpacing;
            VECTOR2I topEnd = braceEnd;
            topEnd.y -= braceSpacing;
            VECTOR2I bottomStart = braceStart;
            bottomStart.y += braceSpacing;
            VECTOR2I bottomEnd = braceEnd;
            bottomEnd.y += braceSpacing;
 
            plotBrace( topStart, topEnd, true, true ); // leftOrTop=true
            plotBrace( bottomStart, bottomEnd, false, true );
        }
        else
        {
            VECTOR2I braceStart( anchorX, firstLineCentre - 2 * extraHeight );
            VECTOR2I braceEnd( anchorX, firstLineCentre + blockSpan );
 
            VECTOR2I leftTop = braceStart;
            leftTop.x -= braceSpacing;
            VECTOR2I leftBot = braceEnd;
            leftBot.x -= braceSpacing;
            VECTOR2I rightTop = braceStart;
            rightTop.x += braceSpacing;
            VECTOR2I rightBot = braceEnd;
            rightBot.x += braceSpacing;
 
            plotBrace( leftTop, leftBot, true, false );
            plotBrace( rightTop, rightBot, false, false );
        }
    };
 
    // Logic largely mirrors original single-line placement but calls multi-line path for numbers
    if( aTextInside )
    {
        if( ( aPinOrient == PIN_ORIENTATION::PIN_LEFT ) || ( aPinOrient == PIN_ORIENTATION::PIN_RIGHT ) )
        {
            if( aDrawPinName )
            {
                if( aPinOrient == PIN_ORIENTATION::PIN_RIGHT )
                {
                    plotSimpleText( x1 + aTextInside, y1, ANGLE_HORIZONTAL, GR_TEXT_H_ALIGN_LEFT,
                                    GR_TEXT_V_ALIGN_CENTER, name, GetNameTextSize(), namePenWidth, nameColor );
                }
                else
                {
                    plotSimpleText( x1 - aTextInside, y1, ANGLE_HORIZONTAL, GR_TEXT_H_ALIGN_RIGHT,
                                    GR_TEXT_V_ALIGN_CENTER, name, GetNameTextSize(), namePenWidth, nameColor );
                }
            }
 
            if( aDrawPinNum )
            {
                plotMultiLineWithBraces( ( x1 + aPinPos.x ) / 2, y1 - num_offset, ANGLE_HORIZONTAL,
                                         GR_TEXT_V_ALIGN_BOTTOM, true );
            }
        }
        else
        {
            if( aPinOrient == PIN_ORIENTATION::PIN_DOWN )
            {
                if( aDrawPinName )
                {
                    plotSimpleText( x1, y1 + aTextInside, ANGLE_VERTICAL, GR_TEXT_H_ALIGN_RIGHT,
                                    GR_TEXT_V_ALIGN_CENTER, name, GetNameTextSize(), namePenWidth, nameColor );
                }
 
                if( aDrawPinNum )
                {
                    plotMultiLineWithBraces( x1 - num_offset, ( y1 + aPinPos.y ) / 2, ANGLE_VERTICAL,
                                             GR_TEXT_V_ALIGN_BOTTOM, true );
                }
            }
            else // PIN_UP
            {
                if( aDrawPinName )
                {
                    plotSimpleText( x1, y1 - aTextInside, ANGLE_VERTICAL, GR_TEXT_H_ALIGN_LEFT,
                                    GR_TEXT_V_ALIGN_CENTER, name, GetNameTextSize(), namePenWidth, nameColor );
                }
 
                if( aDrawPinNum )
                {
                    plotMultiLineWithBraces( x1 - num_offset, ( y1 + aPinPos.y ) / 2, ANGLE_VERTICAL,
                                             GR_TEXT_V_ALIGN_BOTTOM, true );
                }
            }
        }
    }
    else
    {
        if( ( aPinOrient == PIN_ORIENTATION::PIN_LEFT ) || ( aPinOrient == PIN_ORIENTATION::PIN_RIGHT ) )
        {
            if( aDrawPinName && aDrawPinNum )
            {
                plotSimpleText( ( x1 + aPinPos.x ) / 2, y1 - name_offset, ANGLE_HORIZONTAL,
                                GR_TEXT_H_ALIGN_CENTER, GR_TEXT_V_ALIGN_BOTTOM, name,
                                GetNameTextSize(), namePenWidth, nameColor );
                plotMultiLineWithBraces( ( x1 + aPinPos.x ) / 2, y1 + num_offset, ANGLE_HORIZONTAL, GR_TEXT_V_ALIGN_TOP,
                                         false );
            }
            else if( aDrawPinName )
            {
                plotSimpleText( ( x1 + aPinPos.x ) / 2, y1 - name_offset, ANGLE_HORIZONTAL,
                                GR_TEXT_H_ALIGN_CENTER, GR_TEXT_V_ALIGN_BOTTOM, name,
                                GetNameTextSize(), namePenWidth, nameColor );
            }
            else if( aDrawPinNum )
            {
                plotMultiLineWithBraces( ( x1 + aPinPos.x ) / 2, y1 - name_offset, ANGLE_HORIZONTAL,
                                         GR_TEXT_V_ALIGN_BOTTOM, true );
            }
        }
        else
        {
            if( aDrawPinName && aDrawPinNum )
            {
                plotSimpleText( x1 - name_offset, ( y1 + aPinPos.y ) / 2, ANGLE_VERTICAL,
                                GR_TEXT_H_ALIGN_CENTER, GR_TEXT_V_ALIGN_BOTTOM, name,
                                GetNameTextSize(), namePenWidth, nameColor );
                plotMultiLineWithBraces( x1 + num_offset, ( y1 + aPinPos.y ) / 2, ANGLE_VERTICAL, GR_TEXT_V_ALIGN_TOP,
                                         false );
            }
            else if( aDrawPinName )
            {
                plotSimpleText( x1 - name_offset, ( y1 + aPinPos.y ) / 2, ANGLE_VERTICAL,
                                GR_TEXT_H_ALIGN_CENTER, GR_TEXT_V_ALIGN_BOTTOM, name,
                                GetNameTextSize(), namePenWidth, nameColor );
            }
            else if( aDrawPinNum )
            {
                plotMultiLineWithBraces( x1 - num_offset, ( y1 + aPinPos.y ) / 2, ANGLE_VERTICAL,
                                         GR_TEXT_V_ALIGN_BOTTOM, true );
            }
        }
    }
}
 
 
PIN_ORIENTATION SCH_PIN::PinDrawOrient( const TRANSFORM& aTransform ) const
{
    PIN_ORIENTATION orient;
    VECTOR2I end; // position of pin end starting at 0,0 according to its orientation, length = 1
 
    switch( GetOrientation() )
    {
    default:
    case PIN_ORIENTATION::PIN_RIGHT:  end.x = 1;   break;
    case PIN_ORIENTATION::PIN_UP:     end.y = -1;  break;
    case PIN_ORIENTATION::PIN_DOWN:   end.y = 1;   break;
    case PIN_ORIENTATION::PIN_LEFT:   end.x = -1;  break;
    }
 
    // = pos of end point, according to the symbol orientation.
    end    = aTransform.TransformCoordinate( end );
    orient = PIN_ORIENTATION::PIN_UP;
 
    if( end.x == 0 )
    {
        if( end.y > 0 )
            orient = PIN_ORIENTATION::PIN_DOWN;
    }
    else
    {
        orient = PIN_ORIENTATION::PIN_RIGHT;
 
        if( end.x < 0 )
            orient = PIN_ORIENTATION::PIN_LEFT;
    }
 
    return orient;
}
 
 
bool SCH_PIN::StackedTextSideFlipped( const TRANSFORM& aTransform ) const
{
    // Side the number block is drawn on (above horizontal pins, left of vertical pins)
    auto ruleSide = []( PIN_ORIENTATION aOrient ) -> VECTOR2I
    {
        if( aOrient == PIN_ORIENTATION::PIN_UP || aOrient == PIN_ORIENTATION::PIN_DOWN )
            return VECTOR2I( -1, 0 );
 
        return VECTOR2I( 0, -1 );
    };
 
    VECTOR2I mapped = aTransform.TransformCoordinate( ruleSide( GetOrientation() ) );
 
    return mapped == -ruleSide( PinDrawOrient( aTransform ) );
}
 
 
EDA_ITEM* SCH_PIN::Clone() const
{
    //return new SCH_PIN( *this );
    SCH_ITEM* newPin = new SCH_PIN( *this );
    wxASSERT( newPin->GetUnit() == m_unit && newPin->GetBodyStyle() == m_bodyStyle );
    return newPin;
}
 
 
void SCH_PIN::ChangeLength( int aLength )
{
    int lengthChange = GetLength() - aLength;
    int offsetX = 0;
    int offsetY = 0;
 
    switch( GetOrientation() )
    {
    default:
    case PIN_ORIENTATION::PIN_RIGHT:
        offsetX = lengthChange;
        break;
    case PIN_ORIENTATION::PIN_LEFT:
        offsetX = -1 * lengthChange;
        break;
    case PIN_ORIENTATION::PIN_UP:
        offsetY = -1 * lengthChange;
        break;
    case PIN_ORIENTATION::PIN_DOWN:
        offsetY = lengthChange;
        break;
    }
 
    m_position += VECTOR2I( offsetX, offsetY );
    m_length = aLength;
}
 
 
void SCH_PIN::Move( const VECTOR2I& aOffset )
{
    m_position += aOffset;
}
 
 
void SCH_PIN::MirrorHorizontallyPin( int aCenter )
{
    m_position.x -= aCenter;
    m_position.x *= -1;
    m_position.x += aCenter;
 
    if( m_orientation == PIN_ORIENTATION::PIN_RIGHT )
        m_orientation = PIN_ORIENTATION::PIN_LEFT;
    else if( m_orientation == PIN_ORIENTATION::PIN_LEFT )
        m_orientation = PIN_ORIENTATION::PIN_RIGHT;
}
 
 
void SCH_PIN::MirrorHorizontally( int aCenter )
{
    if( dynamic_cast<LIB_SYMBOL*>( GetParentSymbol() ) )
        MirrorHorizontallyPin( aCenter );
}
 
 
void SCH_PIN::MirrorVerticallyPin( int aCenter )
{
    m_position.y -= aCenter;
    m_position.y *= -1;
    m_position.y += aCenter;
 
    if( m_orientation == PIN_ORIENTATION::PIN_UP )
        m_orientation = PIN_ORIENTATION::PIN_DOWN;
    else if( m_orientation == PIN_ORIENTATION::PIN_DOWN )
        m_orientation = PIN_ORIENTATION::PIN_UP;
}
 
 
void SCH_PIN::MirrorVertically( int aCenter )
{
    if( dynamic_cast<LIB_SYMBOL*>( GetParentSymbol() ) )
        MirrorVerticallyPin( aCenter );
}
 
 
void SCH_PIN::RotatePin( const VECTOR2I& aCenter, bool aRotateCCW )
{
    if( aRotateCCW )
    {
        RotatePoint( m_position, aCenter, ANGLE_90 );
 
        switch( GetOrientation() )
        {
        default:
        case PIN_ORIENTATION::PIN_RIGHT: m_orientation = PIN_ORIENTATION::PIN_UP;    break;
        case PIN_ORIENTATION::PIN_UP:    m_orientation = PIN_ORIENTATION::PIN_LEFT;  break;
        case PIN_ORIENTATION::PIN_LEFT:  m_orientation = PIN_ORIENTATION::PIN_DOWN;  break;
        case PIN_ORIENTATION::PIN_DOWN:  m_orientation = PIN_ORIENTATION::PIN_RIGHT; break;
        }
    }
    else
    {
        RotatePoint( m_position, aCenter, -ANGLE_90 );
 
        switch( GetOrientation() )
        {
        default:
        case PIN_ORIENTATION::PIN_RIGHT: m_orientation = PIN_ORIENTATION::PIN_DOWN;  break;
        case PIN_ORIENTATION::PIN_UP:    m_orientation = PIN_ORIENTATION::PIN_RIGHT; break;
        case PIN_ORIENTATION::PIN_LEFT:  m_orientation = PIN_ORIENTATION::PIN_UP;    break;
        case PIN_ORIENTATION::PIN_DOWN:  m_orientation = PIN_ORIENTATION::PIN_LEFT;  break;
        }
    }
}
 
 
void SCH_PIN::Rotate( const VECTOR2I& aCenter, bool aRotateCCW )
{
    if( dynamic_cast<LIB_SYMBOL*>( GetParentSymbol() ) )
        RotatePin( aCenter, aRotateCCW );
}
 
 
void SCH_PIN::Plot( PLOTTER* aPlotter, bool aBackground, const SCH_PLOT_OPTS& aPlotOpts,
                    int aUnit, int aBodyStyle, const VECTOR2I& aOffset, bool aDimmed )
{
    if( aBackground )
        return;
 
    SCH_RENDER_SETTINGS* renderSettings = getRenderSettings( aPlotter );
 
    if( !IsVisible() && !renderSettings->m_ShowHiddenPins )
        return;
 
    const SYMBOL*   part = GetParentSymbol();
    PIN_ORIENTATION orient = PinDrawOrient( renderSettings->m_Transform );
    VECTOR2I        pos = renderSettings->TransformCoordinate( m_position ) + aOffset;
 
    PlotPinType( aPlotter, pos, orient, aDimmed );
    PlotPinTexts( aPlotter, pos, orient, part->GetPinNameOffset(), part->GetShowPinNumbers(),
                  part->GetShowPinNames(), aDimmed );
}
 
 
void SCH_PIN::GetMsgPanelInfo( EDA_DRAW_FRAME* aFrame, std::vector<MSG_PANEL_ITEM>& aList )
{
    SYMBOL*  symbol = GetParentSymbol();
 
    aList.emplace_back( _( "Type" ), _( "Pin" ) );
 
    SCH_ITEM::GetMsgPanelInfo( aFrame, aList );
 
    aList.emplace_back( _( "Name" ), UnescapeString( GetShownName() ) );
    aList.emplace_back( _( "Number" ), GetShownNumber() );
    aList.emplace_back( _( "Type" ), ElectricalPinTypeGetText( GetType() ) );
    aList.emplace_back( _( "Style" ), PinShapeGetText( GetShape() ) );
 
    aList.emplace_back( _( "Visible" ), IsVisible() ? _( "Yes" ) : _( "No" ) );
 
    // Display pin length
    aList.emplace_back( _( "Length" ), aFrame->MessageTextFromValue( GetLength(), true ) );
 
    aList.emplace_back( _( "Orientation" ), PinOrientationName( GetOrientation() ) );
 
    if( dynamic_cast<LIB_SYMBOL*>( symbol ) )
    {
        aList.emplace_back( _( "Pos X" ), aFrame->MessageTextFromValue( GetPosition().x, true ) );
        aList.emplace_back( _( "Pos Y" ), aFrame->MessageTextFromValue( GetPosition().y, true ) );
    }
    else if( SCH_SYMBOL* schsymbol = dynamic_cast<SCH_SYMBOL*>( symbol ) )
    {
        SCH_EDIT_FRAME* schframe = dynamic_cast<SCH_EDIT_FRAME*>( aFrame );
        SCH_SHEET_PATH* currentSheet = schframe ? &schframe->GetCurrentSheet() : nullptr;
 
        // Don't use GetShownText(); we want to see the variable references here
        aList.emplace_back( symbol->GetRef( currentSheet ),
                            UnescapeString( schsymbol->GetField( FIELD_T::VALUE )->GetText() ) );
    }
 
#if defined(DEBUG)
    if( !IsConnectivityDirty() && dynamic_cast<SCH_EDIT_FRAME*>( aFrame ) )
    {
        SCH_CONNECTION* conn = Connection();
 
        if( conn )
            conn->AppendInfoToMsgPanel( aList );
    }
#endif
}
 
 
void SCH_PIN::ClearDefaultNetName( const SCH_SHEET_PATH* aPath )
{
    std::lock_guard<std::recursive_mutex> lock( m_netmap_mutex );
 
    if( aPath )
        m_net_name_map.erase( *aPath );
    else
        m_net_name_map.clear();
}
 
 
wxString SCH_PIN::GetDefaultNetName( const SCH_SHEET_PATH& aPath, bool aForceNoConnect )
{
    const SCH_SYMBOL* symbol = static_cast<const SCH_SYMBOL*>( GetParentSymbol() );
 
    // Need to check for parent as power symbol to make sure we aren't dealing
    // with legacy global power pins on non-power symbols
    if( IsGlobalPower() || IsLocalPower() )
    {
        SYMBOL* parent = GetLibPin() ? GetLibPin()->GetParentSymbol() : nullptr;
 
        if( parent && ( parent->IsGlobalPower() || parent->IsLocalPower() ) )
        {
            return EscapeString( symbol->GetValue( &aPath, FOR_NETNAME ), CTX_NETNAME );
        }
        else
        {
            wxString tmp = m_libPin ? m_libPin->GetName() : wxString( "??" );
 
            return EscapeString( tmp, CTX_NETNAME );
        }
    }
 
    std::lock_guard<std::recursive_mutex> lock( m_netmap_mutex );
 
    auto it = m_net_name_map.find( aPath );
 
    if( it != m_net_name_map.end() )
    {
        if( it->second.second == aForceNoConnect )
            return it->second.first;
    }
 
    SCH_CONNECTIVITY::PIN_NAME_FACT fact;
    fact.name = m_libPin ? m_libPin->GetShownName() : wxString( "??" );
    fact.shownNumber = m_libPin ? m_libPin->GetShownNumber() : wxString( "??" );
    fact.number = m_libPin ? m_libPin->GetNumber() : wxString( "??" );
    fact.padNumber = m_libPin ? m_libPin->GetSmallestStackedPadNumber() : fact.shownNumber;
    fact.noConnect = GetType() == ELECTRICAL_PINTYPE::PT_NC;
 
    if( !aForceNoConnect && !fact.noConnect )
    {
        for( const SCH_PIN* pin : symbol->GetPins( &aPath ) )
        {
            if( pin->GetShownName() == GetShownName()
                    && pin->GetShownNumber() != GetShownNumber()
                    && pin->GetType() != ELECTRICAL_PINTYPE::PT_NC )
            {
                fact.hasDuplicateName = true;
                break;
            }
        }
    }
 
    if( fact.padNumber != fact.shownNumber )
    {
        wxLogTrace( traceStackedPins,
                    wxString::Format( "GetDefaultNetName: stacked pin shown='%s' -> using smallest logical='%s'",
                                      fact.shownNumber, fact.padNumber ) );
    }
 
    const SCH_CONNECTIVITY::PIN_NAME_REFERENCE reference{
        symbol->GetRef( &aPath, false ), symbol->GetRef( &aPath, true ), symbol->m_Uuid.AsString()
    };
    const wxString name = SCH_CONNECTIVITY::RenderPinNetName( fact, reference, aForceNoConnect );
 
    if( !reference.reference.IsEmpty() && reference.reference.Last() != '?' )
        m_net_name_map[ aPath ] = std::make_pair( name, aForceNoConnect );
 
    return name;
}
 
 
const BOX2I SCH_PIN::ViewBBox() const
{
    return GetBoundingBox( false, true, m_flags & SHOW_ELEC_TYPE );
}
 
 
std::vector<int> SCH_PIN::ViewGetLayers() const
{
    return { LAYER_DANGLING,    LAYER_DEVICE, LAYER_SELECTION_SHADOWS,
             LAYER_OP_CURRENTS, LAYER_PINNAM, LAYER_PINNUM };
}
 
 
void SCH_PIN::validateExtentsCache( KIFONT::FONT* aFont, int aSize, const wxString& aText,
                                    EXTENTS_CACHE* aCache ) const
{
    if( aCache->m_Font == aFont
        && aCache->m_FontSize == aSize
        && aCache->m_Extents != VECTOR2I() )
    {
        return;
    }
 
    aCache->m_Font = aFont;
    aCache->m_FontSize = aSize;
 
    VECTOR2D fontSize( aSize, aSize );
    int      penWidth = GetPenSizeForNormal( aSize );
 
    aCache->m_Extents = aFont->StringBoundaryLimits( aText, fontSize, penWidth, false, false,
                                                       GetFontMetrics() );
}
 
 
BOX2I SCH_PIN::GetBoundingBox( bool aIncludeLabelsOnInvisiblePins, bool aIncludeNameAndNumber,
                               bool aIncludeElectricalType ) const
{
    // Just defer to the cache
    return GetLayoutCache().GetPinBoundingBox( aIncludeLabelsOnInvisiblePins,
                                               aIncludeNameAndNumber,
                                               aIncludeElectricalType );
}
 
 
PIN_LAYOUT_CACHE& SCH_PIN::GetLayoutCache() const
{
    if( !m_layoutCache )
        m_layoutCache = std::make_unique<PIN_LAYOUT_CACHE>( *this );
 
    return *m_layoutCache;
}
 
 
bool SCH_PIN::HasConnectivityChanges( const SCH_ITEM* aItem,
                                      const SCH_SHEET_PATH* aInstance ) const
{
    // Do not compare to ourself.
    if( aItem == this )
        return false;
 
    const SCH_PIN* pin = dynamic_cast<const SCH_PIN*>( aItem );
 
    // Don't compare against a different SCH_ITEM.
    wxCHECK( pin, false );
 
    if( GetPosition() != pin->GetPosition() )
        return true;
 
    if( GetNumber() != pin->GetNumber() )
        return true;
 
    if( GetName() != pin->GetName() )
        return true;
 
    // For power input pins, visibility changes affect IsGlobalPower() which changes
    // connectivity semantics. Hidden power pins create implicit global net connections.
    // Also check if a pin changed type to/from PT_POWER_IN.
    if( GetType() == ELECTRICAL_PINTYPE::PT_POWER_IN || pin->GetType() == ELECTRICAL_PINTYPE::PT_POWER_IN )
    {
        if( IsVisible() != pin->IsVisible() || GetType() != pin->GetType() )
            return true;
    }
 
    // Similarly, changing to/from PT_NC affects whether or not the pin participates
    // in the connectivity graph.
    if( GetType() == ELECTRICAL_PINTYPE::PT_NC || pin->GetType() == ELECTRICAL_PINTYPE::PT_NC )
    {
        if( GetType() != pin->GetType() )
            return true;
    }
 
    return false;
}
 
 
bool SCH_PIN::ConnectionPropagatesTo( const EDA_ITEM* aItem ) const
{
    return GetType() != ELECTRICAL_PINTYPE::PT_NC;
}
 
 
bool SCH_PIN::IsLocked() const
{
    if( const SYMBOL* parentSymbol = GetParentSymbol() )
    {
        if( parentSymbol->IsLocked() )
            return true;
    }
 
    return SCH_ITEM::IsLocked();
}
 
 
BITMAPS SCH_PIN::GetMenuImage() const
{
    if( m_libPin )
        return m_libPin->GetMenuImage();
 
    return ElectricalPinTypeGetBitmap( m_type );
}
 
 
wxString SCH_PIN::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, ALT* aAlt ) const
{
    return getItemDescription( aAlt );
}
 
 
wxString SCH_PIN::GetItemDescription( UNITS_PROVIDER* aUnitsProvider, bool aFull ) const
{
    if( m_libPin )
    {
        SCH_PIN::ALT  localStorage;
        SCH_PIN::ALT* alt = nullptr;
 
        if( !m_alt.IsEmpty() )
        {
            localStorage = m_libPin->GetAlt( m_alt );
            alt = &localStorage;
        }
 
        wxString itemDesc = m_libPin ? m_libPin->GetItemDescription( aUnitsProvider, alt )
                                     : wxString( wxS( "Undefined library pin." ) );
 
        const SCH_SYMBOL* symbol = static_cast<const SCH_SYMBOL*>( GetParentSymbol() );
 
        return wxString::Format( "Symbol %s %s",
                                 UnescapeString( symbol->GetField( FIELD_T::REFERENCE )->GetText() ),
                                 itemDesc );
    }
 
    return getItemDescription( nullptr );
}
 
 
wxString SCH_PIN::getItemDescription( ALT* aAlt ) const
{
    wxString name = UnescapeString( aAlt ? aAlt->m_Name : GetShownName() );
    wxString electricalTypeName = ElectricalPinTypeGetText( aAlt ? aAlt->m_Type : m_type );
    wxString pinShapeName = PinShapeGetText( aAlt ? aAlt->m_Shape : m_shape );
 
    if( IsVisible() )
    {
        if ( !name.IsEmpty() )
        {
            return wxString::Format( _( "Pin %s [%s, %s, %s]" ),
                                     GetShownNumber(),
                                     name,
                                     electricalTypeName,
                                     pinShapeName );
        }
        else
        {
            return wxString::Format( _( "Pin %s [%s, %s]" ),
                                     GetShownNumber(),
                                     electricalTypeName,
                                     pinShapeName );
        }
    }
    else
    {
        if( !name.IsEmpty() )
        {
            return wxString::Format( _( "Hidden pin %s [%s, %s, %s]" ),
                                     GetShownNumber(),
                                     name,
                                     electricalTypeName,
                                     pinShapeName );
        }
        else
        {
            return wxString::Format( _( "Hidden pin %s [%s, %s]" ),
                                     GetShownNumber(),
                                     electricalTypeName,
                                     pinShapeName );
        }
    }
}
 
 
namespace
{
struct PIN_COMPARISON_VIEW
{
    int unit;
    int bodyStyle;
    bool isPrivate;
    VECTOR2I position;
    const wxString& number;
    std::optional<int> length;
    PIN_ORIENTATION orientation;
    GRAPHIC_PINSHAPE shape;
    ELECTRICAL_PINTYPE type;
    std::optional<bool> hidden;
    std::optional<int> numberTextSize;
    std::optional<int> nameTextSize;
    const std::map<wxString, PIN_ALTERNATE>& alternates;
 
    int Compare( const PIN_COMPARISON_VIEW& aOther, int aCompareFlags ) const
    {
        if( aCompareFlags & SCH_ITEM::COMPARE_FLAGS::UNIT )
        {
            if( unit != aOther.unit )
                return unit - aOther.unit;
 
            if( bodyStyle != aOther.bodyStyle )
                return bodyStyle - aOther.bodyStyle;
        }
 
        if( isPrivate != aOther.isPrivate )
            return isPrivate ? 1 : -1;
 
        if( number != aOther.number )
            return StrNumCmp( number, aOther.number );
 
        if( position.x != aOther.position.x )
            return position.x - aOther.position.x;
 
        if( position.y != aOther.position.y )
            return position.y - aOther.position.y;
 
        if( length != aOther.length )
            return length.value_or( 0 ) - aOther.length.value_or( 0 );
 
        if( orientation != aOther.orientation )
            return static_cast<int>( orientation ) - static_cast<int>( aOther.orientation );
 
        if( shape != aOther.shape )
            return static_cast<int>( shape ) - static_cast<int>( aOther.shape );
 
        if( type != aOther.type )
            return static_cast<int>( type ) - static_cast<int>( aOther.type );
 
        if( ( aCompareFlags & SCH_ITEM::COMPARE_FLAGS::PIN_VISIBILITIES ) && hidden != aOther.hidden )
            return hidden.value_or( false ) - aOther.hidden.value_or( false );
 
        if( numberTextSize != aOther.numberTextSize )
            return numberTextSize.value_or( 0 ) - aOther.numberTextSize.value_or( 0 );
 
        if( nameTextSize != aOther.nameTextSize )
            return nameTextSize.value_or( 0 ) - aOther.nameTextSize.value_or( 0 );
 
        if( !( aCompareFlags & SCH_ITEM::COMPARE_FLAGS::PIN_ALT_DEFS ) )
            return 0;
 
        if( alternates.size() != aOther.alternates.size() )
            return static_cast<int>( alternates.size() - aOther.alternates.size() );
 
        auto lhsItem = alternates.begin();
        auto rhsItem = aOther.alternates.begin();
 
        while( lhsItem != alternates.end() )
        {
            const PIN_ALTERNATE& lhsAlt = lhsItem->second;
            const PIN_ALTERNATE& rhsAlt = rhsItem->second;
 
            int retv = lhsAlt.m_Name.Cmp( rhsAlt.m_Name );
 
            if( retv )
                return retv;
 
            if( lhsAlt.m_Type != rhsAlt.m_Type )
                return static_cast<int>( lhsAlt.m_Type ) - static_cast<int>( rhsAlt.m_Type );
 
            if( lhsAlt.m_Shape != rhsAlt.m_Shape )
                return static_cast<int>( lhsAlt.m_Shape ) - static_cast<int>( rhsAlt.m_Shape );
 
            ++lhsItem;
            ++rhsItem;
        }
 
        return 0;
    }
};
 
PIN_COMPARISON_VIEW pinComparisonView( const PIN_COMPARISON_DATA& aData )
{
    return { aData.unit, aData.bodyStyle, aData.isPrivate, aData.position, aData.number,
             aData.length, aData.orientation, aData.shape, aData.type, aData.hidden,
             aData.numberTextSize, aData.nameTextSize, aData.alternates };
}
}
 
int PIN_COMPARISON_DATA::Compare( const PIN_COMPARISON_DATA& aOther, int aCompareFlags ) const
{
    return pinComparisonView( *this ).Compare( pinComparisonView( aOther ), aCompareFlags );
}
 
PIN_COMPARISON_DATA SCH_PIN::ComparisonData() const
{
    wxASSERT( dynamic_cast<const LIB_SYMBOL*>( GetParentSymbol() ) );
    return { GetUnit(), GetBodyStyle(), IsPrivate(), m_position, m_number, m_name, m_length,
             m_orientation, m_shape, m_type, m_hidden, m_numTextSize, m_nameTextSize, m_alternates };
}
 
 
int SCH_PIN::compare( const SCH_ITEM& aOther, int aCompareFlags ) const
{
    // Ignore the UUID here
    // And the position, which we'll do after the number.
    int retv = SCH_ITEM::compare( aOther, aCompareFlags & ~( COMPARE_FLAGS::UUID | COMPARE_FLAGS::POSITION ) );
 
    if( retv )
        return retv;
 
    const SCH_PIN* tmp = static_cast<const SCH_PIN*>( &aOther );
 
    wxCHECK( tmp, -1 );
 
    if( dynamic_cast<const LIB_SYMBOL*>( GetParentSymbol() ) )
    {
        const PIN_COMPARISON_VIEW lhs{ GetUnit(), GetBodyStyle(), IsPrivate(), m_position, m_number,
                                       m_length, m_orientation, m_shape, m_type, m_hidden, m_numTextSize,
                                       m_nameTextSize, m_alternates };
        const PIN_COMPARISON_VIEW rhs{ tmp->GetUnit(), tmp->GetBodyStyle(), tmp->IsPrivate(), tmp->m_position,
                                       tmp->m_number, tmp->m_length, tmp->m_orientation, tmp->m_shape, tmp->m_type,
                                       tmp->m_hidden, tmp->m_numTextSize, tmp->m_nameTextSize, tmp->m_alternates };
        return lhs.Compare( rhs, aCompareFlags );
    }
 
    if( m_number != tmp->m_number )
    {
        // StrNumCmp: sort the same as the pads in the footprint file
        return StrNumCmp( m_number, tmp->m_number );
    }
 
    if( m_position.x != tmp->m_position.x )
        return m_position.x - tmp->m_position.x;
 
    if( m_position.y != tmp->m_position.y )
        return m_position.y - tmp->m_position.y;
 
    if( dynamic_cast<const SCH_SYMBOL*>( GetParentSymbol() ) )
    {
        if( m_libPin && !tmp->m_libPin )
            return 1;
        else if( !m_libPin && tmp->m_libPin )
            return -1;
        else if( m_libPin )
            retv = m_libPin->compare( *tmp->m_libPin, aCompareFlags );
 
        if( retv )
            return retv;
 
        retv = m_alt.Cmp( tmp->m_alt );
 
        if( retv )
            return retv;
    }
 
    return 0;
}
 
 
bool SCH_PIN::operator==( const SCH_ITEM& aOther ) const
{
    if( Type() != aOther.Type() )
        return false;
 
    return *this == static_cast<const SCH_PIN&>( aOther );
}
 
 
bool SCH_PIN::operator==( const SCH_PIN& aPin ) const
{
    // Compare local positions below.  SCH_ITEM's position compare uses global coordinates
    if( SCH_ITEM::compare( aPin, -1 & ~( COMPARE_FLAGS::UUID | COMPARE_FLAGS::POSITION ) ) != 0 )
        return false;
 
    if( m_libPin && aPin.m_libPin )
    {
        // Both have a libPin; pins are children of a SCH_SYMBOL.
        if( !m_libPin->operator==( *aPin.m_libPin ) )
            return false;
 
        if( m_alt != aPin.m_alt )
            return false;
    }
    else if( m_libPin != aPin.m_libPin )
    {
        // One has a libPin but the other doesn't.
        return false;
    }
    else
    {
        // Both libPins are nullptr; pins are children of a LIB_SYMBOL.  Alternates are valid here.
        if( m_alternates != aPin.m_alternates )
            return false;
    }
 
    if( GetName() != aPin.GetName() )
        return false;
 
    if( GetNumber() != aPin.GetNumber() )
        return false;
 
    // Don't use GetPosition(); it will return the global coordinates rather than the local ones
    if( m_position != aPin.m_position )
        return false;
 
    if( GetLength() != aPin.GetLength() )
        return false;
 
    if( GetOrientation() != aPin.GetOrientation() )
        return false;
 
    if( GetShape() != aPin.GetShape() )
        return false;
 
    if( GetType() != aPin.GetType() )       // Electrical type
        return false;
 
    if( IsVisible() != aPin.IsVisible() )
        return false;
 
    if( GetNumberTextSize() != aPin.GetNumberTextSize() )
        return false;
 
    if( GetNameTextSize() != aPin.GetNameTextSize() )
        return false;
 
    return true;
}
 
 
double SCH_PIN::Similarity( const SCH_ITEM& aOther ) const
{
    if( aOther.m_Uuid == m_Uuid )
        return 1.0;
 
    if( aOther.Type() != SCH_PIN_T )
        return 0.0;
 
    const SCH_PIN* other = static_cast<const SCH_PIN*>( &aOther );
 
    if( m_libPin && !other->m_libPin )
        return 0.0;
    else if( !m_libPin && other->m_libPin )
        return 0.0;
    else if( m_libPin )
        return m_libPin->Similarity( *other->m_libPin );
 
    double similarity = SimilarityBase( aOther );
 
    if( m_name != other->m_name )
        similarity *= 0.9;
 
    if( m_number != other->m_number )
        similarity *= 0.9;
 
    if( m_position != other->m_position )
        similarity *= 0.9;
 
    if( m_length != other->m_length )
        similarity *= 0.9;
 
    if( m_orientation != other->m_orientation )
        similarity *= 0.9;
 
    if( m_shape != other->m_shape )
        similarity *= 0.9;
 
    if( m_type != other->m_type )
        similarity *= 0.9;
 
    if( m_hidden != other->m_hidden )
        similarity *= 0.9;
 
    if( m_numTextSize != other->m_numTextSize )
        similarity *= 0.9;
 
    if( m_nameTextSize != other->m_nameTextSize )
        similarity *= 0.9;
 
    if( m_alternates.size() != other->m_alternates.size() )
        similarity *= 0.9;
 
    return similarity;
}
 
 
std::ostream& SCH_PIN::operator<<( std::ostream& aStream )
{
    aStream << "SCH_PIN:" << std::endl
            << "  Name: \"" << m_name << "\"" << std::endl
            << "  Number: \"" << m_number << "\"" << std::endl
            << "  Position: " << m_position << std::endl
            << "  Length: " << GetLength() << std::endl
            << "  Orientation: " << PinOrientationName( m_orientation ) << std::endl
            << "  Shape: " << PinShapeGetText( m_shape ) << std::endl
            << "  Type: " << ElectricalPinTypeGetText( m_type ) << std::endl
            << "  Name Text Size: " << GetNameTextSize() << std::endl
            << "  Number Text Size: " << GetNumberTextSize() << std::endl;
 
    return aStream;
}
 
 
#if defined(DEBUG)
 
void SCH_PIN::Show( int nestLevel, std::ostream& os ) const
{
    NestedSpace( nestLevel, os ) << '<' << GetClass().Lower().mb_str()
                                 << " num=\"" << m_number.mb_str()
                                 << '"' << "/>\n";
}
 
#endif
 
 
void SCH_PIN::CalcEdit( const VECTOR2I& aPosition )
{
    if( IsMoving() )
        SetPosition( aPosition );
}
 
 
static struct SCH_PIN_DESC
{
    SCH_PIN_DESC()
    {
        auto& pinTypeEnum = ENUM_MAP<ELECTRICAL_PINTYPE>::Instance();
 
        if( pinTypeEnum.Choices().GetCount() == 0 )
        {
            pinTypeEnum.Map( ELECTRICAL_PINTYPE::PT_INPUT,         _HKI( "Input" ) )
                       .Map( ELECTRICAL_PINTYPE::PT_OUTPUT,        _HKI( "Output" ) )
                       .Map( ELECTRICAL_PINTYPE::PT_BIDI,          _HKI( "Bidirectional" ) )
                       .Map( ELECTRICAL_PINTYPE::PT_TRISTATE,      _HKI( "Tri-state" ) )
                       .Map( ELECTRICAL_PINTYPE::PT_PASSIVE,       _HKI( "Passive" ) )
                       .Map( ELECTRICAL_PINTYPE::PT_NIC,           _HKI( "Free" ) )
                       .Map( ELECTRICAL_PINTYPE::PT_UNSPECIFIED,   _HKI( "Unspecified" ) )
                       .Map( ELECTRICAL_PINTYPE::PT_POWER_IN,      _HKI( "Power input" ) )
                       .Map( ELECTRICAL_PINTYPE::PT_POWER_OUT,     _HKI( "Power output" ) )
                       .Map( ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR, _HKI( "Open collector" ) )
                       .Map( ELECTRICAL_PINTYPE::PT_OPENEMITTER,   _HKI( "Open emitter" ) )
                       .Map( ELECTRICAL_PINTYPE::PT_NC,            _HKI( "Unconnected" ) );
        }
 
        auto& pinShapeEnum = ENUM_MAP<GRAPHIC_PINSHAPE>::Instance();
 
        if( pinShapeEnum.Choices().GetCount() == 0 )
        {
            pinShapeEnum.Map( GRAPHIC_PINSHAPE::LINE,               _HKI( "Line" ) )
                        .Map( GRAPHIC_PINSHAPE::INVERTED,           _HKI( "Inverted" ) )
                        .Map( GRAPHIC_PINSHAPE::CLOCK,              _HKI( "Clock" ) )
                        .Map( GRAPHIC_PINSHAPE::INVERTED_CLOCK,     _HKI( "Inverted clock" ) )
                        .Map( GRAPHIC_PINSHAPE::INPUT_LOW,          _HKI( "Input low" ) )
                        .Map( GRAPHIC_PINSHAPE::CLOCK_LOW,          _HKI( "Clock low" ) )
                        .Map( GRAPHIC_PINSHAPE::OUTPUT_LOW,         _HKI( "Output low" ) )
                        .Map( GRAPHIC_PINSHAPE::FALLING_EDGE_CLOCK, _HKI( "Falling edge clock" ) )
                        .Map( GRAPHIC_PINSHAPE::NONLOGIC,           _HKI( "NonLogic" ) );
        }
 
        auto& orientationEnum = ENUM_MAP<PIN_ORIENTATION>::Instance();
 
        if( orientationEnum.Choices().GetCount() == 0 )
        {
            orientationEnum.Map( PIN_ORIENTATION::PIN_RIGHT, _HKI( "Right" ) )
                           .Map( PIN_ORIENTATION::PIN_LEFT,  _HKI( "Left" ) )
                           .Map( PIN_ORIENTATION::PIN_UP,    _HKI( "Up" ) )
                           .Map( PIN_ORIENTATION::PIN_DOWN,  _HKI( "Down" ) );
        }
 
        auto isSymbolEditor =
                []( INSPECTABLE* aItem ) -> bool
                {
                    if( SCH_PIN* pin = dynamic_cast<SCH_PIN*>( aItem ) )
                        return dynamic_cast<LIB_SYMBOL*>( pin->GetParentSymbol() ) != nullptr;
 
                    return false;
                };
 
        PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();
        REGISTER_TYPE( SCH_PIN );
        propMgr.AddTypeCast( new TYPE_CAST<SCH_PIN, SCH_ITEM> );
        propMgr.InheritsAfter( TYPE_HASH( SCH_PIN ), TYPE_HASH( SCH_ITEM ) );
 
        // Lock state is inherited from parent symbol (no independent locking of child items)
        propMgr.Mask( TYPE_HASH( SCH_PIN ), TYPE_HASH( SCH_ITEM ), _HKI( "Locked" ) );
 
        propMgr.AddProperty( new PROPERTY<SCH_PIN, wxString>( _HKI( "Pin Name" ),
                    &SCH_PIN::SetName, &SCH_PIN::GetName ) )
                .SetWriteableFunc( isSymbolEditor );
 
        propMgr.AddProperty( new PROPERTY<SCH_PIN, wxString>( _HKI( "Pin Number" ),
                    &SCH_PIN::SetNumber, &SCH_PIN::GetNumber ) )
                .SetWriteableFunc( isSymbolEditor );
 
        propMgr.AddProperty( new PROPERTY_ENUM<SCH_PIN, ELECTRICAL_PINTYPE>( _HKI( "Electrical Type" ),
                    &SCH_PIN::SetType, &SCH_PIN::GetType ) )
                .SetWriteableFunc( isSymbolEditor );
 
        propMgr.AddProperty( new PROPERTY_ENUM<SCH_PIN, GRAPHIC_PINSHAPE>( _HKI( "Graphic Style" ),
                    &SCH_PIN::SetShape, &SCH_PIN::GetShape ) )
                .SetWriteableFunc( isSymbolEditor );
 
        propMgr.AddProperty( new PROPERTY<SCH_PIN, int>( _HKI( "Position X" ),
                    &SCH_PIN::SetX, &SCH_PIN::GetX, PROPERTY_DISPLAY::PT_COORD ) )
                .SetAvailableFunc( isSymbolEditor );
 
        propMgr.AddProperty( new PROPERTY<SCH_PIN, int>( _HKI( "Position Y" ),
                    &SCH_PIN::SetY, &SCH_PIN::GetY, PROPERTY_DISPLAY::PT_COORD ) )
                .SetAvailableFunc( isSymbolEditor );
 
        propMgr.AddProperty( new PROPERTY_ENUM<SCH_PIN, PIN_ORIENTATION>( _HKI( "Orientation" ),
                    &SCH_PIN::SetOrientation, &SCH_PIN::GetOrientation ) )
                .SetWriteableFunc( isSymbolEditor );
 
        propMgr.AddProperty( new PROPERTY<SCH_PIN, int>( _HKI( "Length" ),
                    &SCH_PIN::ChangeLength, &SCH_PIN::GetLength,
                    PROPERTY_DISPLAY::PT_SIZE ) )
                .SetWriteableFunc( isSymbolEditor );
 
        propMgr.AddProperty( new PROPERTY<SCH_PIN, int>( _HKI( "Name Text Size" ),
                    &SCH_PIN::SetNameTextSize, &SCH_PIN::GetNameTextSize,
                    PROPERTY_DISPLAY::PT_SIZE ) )
                .SetAvailableFunc( isSymbolEditor );
 
        propMgr.AddProperty( new PROPERTY<SCH_PIN, int>( _HKI( "Number Text Size" ),
                    &SCH_PIN::SetNumberTextSize, &SCH_PIN::GetNumberTextSize,
                    PROPERTY_DISPLAY::PT_SIZE ) )
                .SetAvailableFunc( isSymbolEditor );
 
        propMgr.AddProperty( new PROPERTY<SCH_PIN, bool>( _HKI( "Visible" ),
                    &SCH_PIN::SetVisible, &SCH_PIN::IsVisible ) )
                .SetAvailableFunc( isSymbolEditor );
 
    }
} _SCH_PIN_DESC;
 
 
ENUM_TO_WXANY( PIN_ORIENTATION )
ENUM_TO_WXANY( GRAPHIC_PINSHAPE )
ENUM_TO_WXANY( ELECTRICAL_PINTYPE )