sch_io_ltspice_parser.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2022 Chetan Subhash Shinde<[email protected]>
 * Copyright (C) 2023 CERN
 * 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 3 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 <core/map_helpers.h>
#include <sch_io/ltspice/sch_io_ltspice_parser.h>
#include <sch_io/ltspice/ltspice_schematic.h>
#include <schematic.h>
#include <sch_collectors.h>
#include <sch_line.h>
#include <sch_label.h>
#include <sch_text.h>
#include <sch_edit_frame.h>
#include <sch_shape.h>
#include <sch_sheet.h>
#include <sch_sheet_pin.h>
#include <sch_bus_entry.h>
#include <string_utils.h>
#include <trigo.h>
#include <wx/buffer.h>
#include <wx/ffile.h>
#include <wx/filename.h>
#include <wx/strconv.h>
#include <wx/tokenzr.h>
#include <wx/txtstrm.h>
#include <wx/wfstream.h>
#include <sim/spice_value.h>
#include <fmt/format.h>
#include <cmath>
#include <set>
 
 
// Split PWL argument strings on whitespace while keeping quoted spans intact.
// Example input: REPEAT FOREVER FILE="data 3.txt" ENDREPEAT
// Example tokens: [REPEAT] [FOREVER] [FILE="data 3.txt"] [ENDREPEAT]
static std::vector<wxString> tokenizeQuoted( const wxString& aText )
{
    std::vector<wxString> tokens;
    wxString              token;
    bool                  inQuotes = false;
 
    for( wxUniChar ch : aText )
    {
        if( ch == '"' )
            inQuotes = !inQuotes;
 
        if( !inQuotes && wxIsspace( ch ) )
        {
            if( !token.IsEmpty() )
            {
                tokens.push_back( token );
                token.clear();
            }
        }
        else
        {
            token += ch;
        }
    }
 
    if( !token.IsEmpty() )
        tokens.push_back( token );
 
    return tokens;
}
 
 
// LTspice .tran -> ngspice .tran. Tstep 0 or omitted -> (Tstop-Tstart)/10000.
// Time values are rewritten; trailing modifiers (uic, steady, ...) are kept as-is.
static wxString convertLtSpiceTextToNgspice( const wxString& aText )
{
    wxArrayString outLines;
 
    for( wxString line : wxSplit( aText, '\n', '\0' ) )
    {
        wxArrayString tok = wxSplit( line, ' ', '\0' );
 
        if( !tok.IsEmpty() && tok[0].IsSameAs( wxS( ".tran" ), false ) )
        {
            wxArrayString args;      // <Tstep> <Tstop> [Tstart [dTmax]] [modifiers]
            wxArrayString modifiers; // uic / LTspice-only flags, preserved
 
            const std::set<wxString> c_modifiers = { "UIC", "STEADY", "NODISCARD", "STARTUP", "STEP" };
 
            for( size_t i = 1; i < tok.size(); ++i )
            {
                if( tok[i].IsEmpty() )
                    continue;
 
                wxString u = tok[i].Upper();
 
                if( modifiers.IsEmpty() && !c_modifiers.contains( u ) )
                    args.Add( tok[i] );
                else
                    modifiers.Add( tok[i] );
            }
 
            if( !args.IsEmpty() )
            {
                // LTspice syntax:
                // .TRAN <Tstep> <Tstop> [Tstart [dTmax]] [modifiers]
                // .TRAN <Tstop> [modifiers]
 
                // ngspice syntax:
                // .tran tstep tstop <tstart <tmax>> <uic>
                const bool hasTstep = args.size() >= 2;
 
                wxString tstepStr = hasTstep ? args[0] : wxString();
                wxString tstopStr = hasTstep ? args[1] : args[0];
                wxString tstartStr = ( args.size() > 2 ) ? args[2] : wxString();
                wxString dtmaxStr = ( args.size() > 3 ) ? args[3] : wxString();
 
                double tstep = SPICE_VALUE( tstepStr ).ToDouble();
                double tstop = SPICE_VALUE( tstopStr ).ToDouble();
                double tstart = SPICE_VALUE( tstartStr ).ToDouble();
 
                if( tstep == 0.0 )
                    tstepStr = SPICE_VALUE( ( tstop - tstart ) / 10000.0 ).ToSpiceString();
 
                line = wxS( ".tran " ) + tstepStr + wxS( " " ) + tstopStr;
 
                if( !tstartStr.IsEmpty() )
                    line << wxS( " " ) << tstartStr;
 
                if( !dtmaxStr.IsEmpty() )
                    line << wxS( " " ) << dtmaxStr;
 
                for( const wxString& mod : modifiers )
                    line << wxS( " " ) << mod;
            }
        }
 
        outLines.Add( line );
    }
 
    return wxJoin( outLines, '\n', '\0' );
}
 
 
// Convert an LTspice PWL data file to an ngspice-friendly version.
// Input semantics: "+t" is relative and plain "t" is absolute time.
// Output semantics: emit relative step durations on every line.
static bool convertPwlFileToNgspice( const wxFileName& aSourceFile, const wxFileName& aDestFile )
{
    wxFFileInputStream inputStream( aSourceFile.GetFullPath() );
 
    if( !inputStream.IsOk() )
        return false;
 
    wxFFileOutputStream outputStream( aDestFile.GetFullPath() );
 
    if( !outputStream.IsOk() )
        return false;
 
    wxTextInputStream  textIn( inputStream, wxS( " \t" ), wxConvUTF8 );
    wxTextOutputStream textOut( outputStream, wxEOL_UNIX, wxConvUTF8 );
    double             prevAbsoluteTime = 0.0;
 
    while( inputStream.CanRead() )
    {
        wxString line = textIn.ReadLine();
        line.Trim( true ).Trim( false );
 
        // Convert comments to # format known by ngspice
        wxString commentRest;
        if( line.StartsWith( wxS( "*" ), &commentRest ) || line.StartsWith( wxS( ";" ), &commentRest ) )
        {
            textOut << wxS( "#" ) << commentRest << '\n';
            continue;
        }
 
        wxStringTokenizer pointTokenizer( line, wxS( " \t" ), wxTOKEN_STRTOK );
 
        if( pointTokenizer.CountTokens() < 2 )
        {
            textOut << line << '\n';
            continue;
        }
 
        wxString timeToken = pointTokenizer.GetNextToken();
        wxString valueToken = pointTokenizer.GetNextToken();
 
        // LTspice semantics: "+t" means offset from previous point, plain "t"
        // means absolute time from 0.
        // Example: 0 0, +100n 0, 300n 1  => absolute times 0, 100n, 300n.
        wxString timeRest = timeToken;
        bool     isRelative = timeToken.StartsWith( wxS( "+" ), &timeRest );
 
        if( timeRest.IsEmpty() )
        {
            textOut << line << '\n';
            continue;
        }
 
        // Parse LTspice time token to seconds
        SPICE_VALUE spiceValue( timeRest );
        double      timeValueSeconds = spiceValue.ToDouble();
 
        // Convert to relative time
        double absoluteTime = isRelative ? prevAbsoluteTime + timeValueSeconds : timeValueSeconds;
        double relativeTime = absoluteTime - prevAbsoluteTime;
        prevAbsoluteTime = absoluteTime;
 
        // Format seconds using explicit engineering notation (e.g. 1e-7 -> 100e-9).
        wxString relativeTimeStr = wxS( "0" );
 
        if( relativeTime != 0.0 )
        {
            double absSeconds = std::fabs( relativeTime );
            int    exp10 = static_cast<int>( std::floor( std::log10( absSeconds ) ) );
            int    engExp = exp10 - ( ( exp10 % 3 + 3 ) % 3 );
            double mantissa = relativeTime / std::pow( 10.0, engExp );
 
            relativeTimeStr = wxString::FromUTF8( fmt::format( "{:.9g}e{}", mantissa, engExp ) );
        }
 
        textOut << relativeTimeStr << '\t' << valueToken << '\n';
    }
 
    return outputStream.IsOk();
}
 
 
void SCH_IO_LTSPICE_PARSER::CreateItems( LTSPICE_SCHEMATIC::LT_ASC& aAscfile, SCH_SCREEN* aScreen,
                                         const std::vector<wxString>&     aUniqueAscNames,
                                         std::map<wxString, SCH_SCREEN*>& aMapOfScreens, VECTOR2I aOriginOffset )
{
    m_originOffset = aOriginOffset;
    
    CreateKicadSymbolsAndSubsheets( aAscfile, aScreen, aUniqueAscNames, aMapOfScreens );
    CreateKicadSCH_ITEMs( aAscfile, aScreen );
 
    SCHEMATIC* schematic = aScreen->Schematic();
 
    if( schematic && schematic->RootScreen() == aScreen )
    {
        // Convert LTspice standard device libs to UTF-8 into ltspice_cmp/ and .include them.
        wxString projectPath = schematic->Project().GetProjectPath();
        wxString includeText;
 
        if( !projectPath.IsEmpty() )
        {
            wxFileName cmpDir( m_lt_schematic->GetLTspiceDataDir().GetFullPath(), wxEmptyString );
            cmpDir.AppendDir( wxS( "cmp" ) );
 
            wxFileName outDir( projectPath, wxEmptyString );
            outDir.AppendDir( wxS( "ltspice_cmp" ) );
            outDir.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
 
            for( const wxString name :
                 { wxS( "standard.dio" ), wxS( "standard.bjt" ), wxS( "standard.jft" ), wxS( "standard.mos" ) } )
            {
                includeText << wxS( ".include ltspice_cmp/" ) << name << wxS( "\n" );
 
                wxFileName src = cmpDir;
                src.SetFullName( name );
 
                if( !src.FileExists() )
                    continue;
 
                wxFileName dst = outDir;
                dst.SetFullName( name );
 
                if( dst.FileExists() )
                    continue;
 
                wxFFile in( src.GetFullPath(), wxS( "rb" ) );
 
                if( !in.IsOpened() )
                    continue;
 
                wxFileOffset len = in.Length();
 
                if( len <= 0 )
                    continue;
 
                wxMemoryBuffer buffer( static_cast<size_t>( len ) );
                void*          writePtr = buffer.GetWriteBuf( static_cast<size_t>( len ) );
 
                if( !writePtr || in.Read( writePtr, len ) != static_cast<size_t>( len ) )
                    continue;
 
                buffer.UngetWriteBuf( static_cast<size_t>( len ) );
 
                const char* data = static_cast<const char*>( buffer.GetData() );
                wxString    text;
 
                // UTF-16 LE looks like c \0 c \0 ...; else try UTF-8, then CP1252.
                if( len >= 4 && ( len % 2 ) == 0 && data[1] == 0 && data[3] == 0 )
                    text = wxString( data, wxMBConvUTF16LE(), len );
                else
                    text = wxString::FromUTF8( data, len );
 
                if( text.empty() )
                    text = wxString( data, wxCSConv( wxFONTENCODING_CP1252 ), len );
 
                wxFFile out( dst.GetFullPath(), wxS( "wb" ) );
 
                if( !out.IsOpened() )
                    continue;
 
                out.Write( text, wxConvUTF8 );
            }
        }
 
        // Add filesource subcircuit template for PWL file sources
        includeText << wxS( "\n" );
        includeText << wxS( ".subckt pwl_file outp outn file=\"\" timerelative=1\n" );
        includeText << wxS( "Afs %vd([outp outn]) filesrc\n" );
        includeText << wxS( ".model filesrc filesource (file={file} amploffset=[0] amplscale=[1] timeoffset=0 "
                            "timescale=1 timerelative={timerelative})\n" );
        includeText << wxS( ".ends\n" );
 
        if( !includeText.IsEmpty() )
        {
            SCH_TEXT* textItem = new SCH_TEXT( VECTOR2I( 0, 0 ), includeText );
 
            textItem->SetVisible( true );
            textItem->SetMultilineAllowed( true );
            textItem->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
            textItem->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
 
            aScreen->Append( textItem );
        }
    }
}
 
 
void SCH_IO_LTSPICE_PARSER::CreateSymLine( LIB_SYMBOL* aSymbol, const LTSPICE_SCHEMATIC::LT_SYMBOL& aLTSymbol,
                                           int aIndex, SCH_SHAPE* shape )
{
    const LTSPICE_SCHEMATIC::LINE& lt_line = aLTSymbol.Lines[aIndex];
 
    shape->AddPoint( ToKicadCoords( lt_line.End ) );
    shape->AddPoint( ToKicadCoords( lt_line.Start ) );
    shape->SetStroke( getStroke( lt_line.LineWidth, lt_line.LineStyle ) );
}
 
 
void SCH_IO_LTSPICE_PARSER::CreateKicadSymbolsAndSubsheets( LTSPICE_SCHEMATIC::LT_ASC& aAscfile, SCH_SCREEN* aScreen,
                                                            const std::vector<wxString>&     aUniqueAscNames,
                                                            std::map<wxString, SCH_SCREEN*>& aMapOfScreens )
{
    std::map<wxString, LIB_SYMBOL*> existingSymbol;
 
    for( LTSPICE_SCHEMATIC::LT_SYMBOL& lt_symbol : aAscfile.Symbols )
    {
        wxString libName = m_lt_schematic->GetSymbolName( lt_symbol.Name );
 
        if( lt_symbol.AsyKey.IsEmpty() || !alg::contains( aUniqueAscNames, lt_symbol.AsyKey ) )
        {
            LIB_SYMBOL* lib_symbol;
 
            if( existingSymbol.count( libName ) == 0 )
            {
                lib_symbol = new LIB_SYMBOL( libName );
 
                CreateSymbol( lt_symbol, lib_symbol );
 
                existingSymbol.emplace( libName, lib_symbol );
            }
            else
            {
                lib_symbol = existingSymbol[libName];
            }
 
            LIB_ID      libId( wxS( "ltspice" ), libName );
            SCH_SYMBOL* sch_symbol = new SCH_SYMBOL( *lib_symbol, libId, nullptr, 1 );
 
            AddSymFields( lt_symbol, sch_symbol );
            AssignSymOrientation( lt_symbol, sch_symbol );
 
            sch_symbol->Move( ToKicadCoords( lt_symbol.Offset ) + m_originOffset );
 
            aScreen->Append( sch_symbol );
        }
        else
        {
            for( int j = 0; j < (int) lt_symbol.Lines.size(); j++ )
            {
                SCH_SHAPE* shape = new SCH_SHAPE( SHAPE_T::POLY );
 
                CreateSymLine( nullptr, lt_symbol, j, shape );
                RotateMirrorItem( lt_symbol, shape );
                shape->Move( ToKicadCoords( lt_symbol.Offset ) + m_originOffset );
 
                aScreen->Append( shape );
            }
 
            for( int j = 0; j < (int) lt_symbol.Circles.size(); j++ )
            {
                SCH_SHAPE* shape = new SCH_SHAPE( SHAPE_T::CIRCLE );
 
                CreateSymCircle( lt_symbol, j, shape );
                RotateMirrorItem( lt_symbol, shape );
                shape->Move( ToKicadCoords( lt_symbol.Offset ) + m_originOffset );
 
                aScreen->Append( shape );
            }
 
            for( int j = 0; j < (int) lt_symbol.Arcs.size(); j++ )
            {
                SCH_SHAPE* shape = new SCH_SHAPE( SHAPE_T::ARC );
 
                CreateSymArc( lt_symbol, j, shape );
                RotateMirrorItem( lt_symbol, shape );
                shape->Move( ToKicadCoords( lt_symbol.Offset ) + m_originOffset );
 
                aScreen->Append( shape );
            }
 
            for( int j = 0; j < (int) lt_symbol.Rectangles.size(); j++ )
            {
                SCH_SHAPE* shape = new SCH_SHAPE( SHAPE_T::RECTANGLE );
 
                CreateSymRect( lt_symbol, j, shape );
                RotateMirrorItem( lt_symbol, shape );
                shape->Move( ToKicadCoords( lt_symbol.Offset ) + m_originOffset );
 
                aScreen->Append( shape );
            }
 
            for( int j = 0; j < (int) lt_symbol.Texts.size(); j++ )
            {
                SCH_TEXT* text = new SCH_TEXT( VECTOR2I(), wxEmptyString );
 
                CreateSymText( lt_symbol, j, text );
                RotateMirrorItem( lt_symbol, text );
                text->Move( ToKicadCoords( lt_symbol.Offset ) + m_originOffset );
 
                aScreen->Append( text );
            }
 
            SCH_SHEET* sch_sheet = AddAscSymAsSubsheet( aAscfile, lt_symbol, aScreen );
 
            if( aMapOfScreens.contains( lt_symbol.AsyKey ) )
                sch_sheet->SetScreen( aMapOfScreens.at( lt_symbol.AsyKey ) );
        }
    }
}
 
 
void SCH_IO_LTSPICE_PARSER::CreateSymbol( LTSPICE_SCHEMATIC::LT_SYMBOL& aLtSymbol, LIB_SYMBOL* aLibSymbol )
{
    for( int j = 0; j < (int) aLtSymbol.Lines.size(); j++ )
    {
        SCH_SHAPE* line = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
 
        CreateSymLine( aLibSymbol, aLtSymbol, j, line );
        aLibSymbol->AddDrawItem( line );
    }
 
    for( int j = 0; j < (int) aLtSymbol.Circles.size(); j++ )
    {
        SCH_SHAPE* circle = new SCH_SHAPE( SHAPE_T::CIRCLE, LAYER_DEVICE );
 
        CreateSymCircle( aLtSymbol, j, circle );
        aLibSymbol->AddDrawItem( circle );
    }
 
    for( int j = 0; j < (int) aLtSymbol.Arcs.size(); j++ )
    {
        SCH_SHAPE* arc = new SCH_SHAPE( SHAPE_T::ARC, LAYER_DEVICE );
 
        CreateSymArc( aLtSymbol, j, arc );
        aLibSymbol->AddDrawItem( arc );
    }
 
    for( int j = 0; j < (int) aLtSymbol.Rectangles.size(); j++ )
    {
        SCH_SHAPE* rectangle = new SCH_SHAPE( SHAPE_T::RECTANGLE, LAYER_DEVICE );
 
        CreateSymRect( aLtSymbol, j, rectangle );
        aLibSymbol->AddDrawItem( rectangle );
    }
 
    for( int j = 0; j < (int) aLtSymbol.Texts.size(); j++ )
    {
        SCH_TEXT* text = new SCH_TEXT( VECTOR2I(), wxEmptyString, LAYER_DEVICE );
 
        CreateSymText( aLtSymbol, j, text );
        aLibSymbol->AddDrawItem( text );
    }
 
    for( int j = 0; j < (int) aLtSymbol.Pins.size(); j++ )
    {
        SCH_PIN* pin = new SCH_PIN( aLibSymbol );
 
        CreateSymPin( aLtSymbol, j, pin );
        aLibSymbol->AddDrawItem( pin );
    }
 
    aLibSymbol->SetShowPinNumbers( false );
}
 
 
int SCH_IO_LTSPICE_PARSER::ToKicadCoords( int aCoordinate )
{
    return schIUScale.MilsToIU( rescale( 50, aCoordinate, 16 ) );
}
 
 
VECTOR2I SCH_IO_LTSPICE_PARSER::ToKicadCoords( const VECTOR2I& aPos )
{
    return VECTOR2I( ToKicadCoords( aPos.x ), ToKicadCoords( aPos.y ) );
}
 
 
VECTOR2I SCH_IO_LTSPICE_PARSER::ToKicadFontSize( int aLTFontSize )
{
    auto MILS_SIZE =
            []( int mils )
            {
                return VECTOR2I( schIUScale.MilsToIU( mils ), schIUScale.MilsToIU( mils ) );
            };
 
    if( aLTFontSize == 0 )      return MILS_SIZE( 20 );
    else if( aLTFontSize == 1 ) return MILS_SIZE( 36 );
    else if( aLTFontSize == 2 ) return MILS_SIZE( 42 );
    else if( aLTFontSize == 3 ) return MILS_SIZE( 50 );
    else if( aLTFontSize == 4 ) return MILS_SIZE( 60 );
    else if( aLTFontSize == 5 ) return MILS_SIZE( 72 );
    else if( aLTFontSize == 6 ) return MILS_SIZE( 88 );
    else if( aLTFontSize == 7 ) return MILS_SIZE( 108 );
    else                        return ToKicadFontSize( 2 );
}
 
 
int SCH_IO_LTSPICE_PARSER::ToLtSpiceCoords( int aCoordinate )
{
    return schIUScale.IUToMils( rescale( 16, aCoordinate, 50 ) );
}
 
 
VECTOR2I SCH_IO_LTSPICE_PARSER::ToLtSpiceCoords( const VECTOR2I& aPos )
{
    return VECTOR2I( ToLtSpiceCoords( aPos.x ), ToLtSpiceCoords( aPos.y ) );
}
 
 
VECTOR2I SCH_IO_LTSPICE_PARSER::RotateMirror( const LTSPICE_SCHEMATIC::LT_SYMBOL& aLTSymbol, const VECTOR2I& aPoint )
{
    VECTOR2I p = aPoint;
 
    switch( aLTSymbol.SymbolOrientation )
    {
    case LTSPICE_SCHEMATIC::ORIENTATION::R90:
        RotatePoint( p, -ANGLE_90 );
        break;
 
    case LTSPICE_SCHEMATIC::ORIENTATION::R180:
        RotatePoint( p, -ANGLE_180 );
        break;
 
    case LTSPICE_SCHEMATIC::ORIENTATION::R270:
        RotatePoint( p, -ANGLE_270 );
        break;
 
    case LTSPICE_SCHEMATIC::ORIENTATION::M0:
        p.x = -p.x;
        break;
 
    case LTSPICE_SCHEMATIC::ORIENTATION::M90:
        p.y = -p.y;
        RotatePoint( p, -ANGLE_90 );
        break;
 
    case LTSPICE_SCHEMATIC::ORIENTATION::M180:
        p.y = -p.y;
        break;
 
    case LTSPICE_SCHEMATIC::ORIENTATION::M270:
        p.y = -p.y;
        RotatePoint( p, -ANGLE_270 );
        break;
 
    default:
        break;
    }
 
    return p;
}
 
 
void SCH_IO_LTSPICE_PARSER::RotateMirrorItem( const LTSPICE_SCHEMATIC::LT_SYMBOL& aLTSymbol, SCH_ITEM* aItem )
{
    if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::R90 )
    {
        aItem->Rotate( VECTOR2I(), false );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::R180 )
    {
        aItem->Rotate( VECTOR2I(), false );
        aItem->Rotate( VECTOR2I(), false );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::R270 )
    {
        aItem->Rotate( VECTOR2I(), true );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::M0 )
    {
        aItem->MirrorHorizontally( 0 );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::M90 )
    {
        aItem->MirrorVertically( 0 );
        aItem->Rotate( VECTOR2I(), false );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::M180 )
    {
        aItem->MirrorVertically( 0 );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::M270 )
    {
        aItem->MirrorVertically( 0 );
        aItem->Rotate( VECTOR2I(), true );
    }
}
 
 
void SCH_IO_LTSPICE_PARSER::AssignSymOrientation( const LTSPICE_SCHEMATIC::LT_SYMBOL& aLTSymbol, SCH_SYMBOL* aSchSymbol )
{
    if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::R0 )
    {
        aSchSymbol->SetOrientation( SYM_ORIENT_0 );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::R90 )
    {
        aSchSymbol->SetOrientation( SYM_ORIENT_180 );
        aSchSymbol->SetOrientation( SYM_ROTATE_COUNTERCLOCKWISE );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::R180 )
    {
        aSchSymbol->SetOrientation( SYM_ORIENT_180 );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::R270 )
    {
        aSchSymbol->SetOrientation( SYM_ROTATE_COUNTERCLOCKWISE );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::M0 )
    {
        aSchSymbol->SetOrientation( SYM_MIRROR_Y );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::M90 )
    {
        aSchSymbol->SetOrientation( SYM_MIRROR_Y );
        aSchSymbol->SetOrientation( SYM_ROTATE_COUNTERCLOCKWISE );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::M180 )
    {
        aSchSymbol->SetOrientation( SYM_MIRROR_X );
    }
    else if( aLTSymbol.SymbolOrientation == LTSPICE_SCHEMATIC::ORIENTATION::M270 )
    {
        aSchSymbol->SetOrientation( SYM_MIRROR_Y );
        aSchSymbol->SetOrientation( SYM_ROTATE_CLOCKWISE );
    }
}
 
 
void SCH_IO_LTSPICE_PARSER::CreateKicadSCH_ITEMs( LTSPICE_SCHEMATIC::LT_ASC& aAscfile, SCH_SCREEN* aScreen )
{
    for( int j = 0; j < (int) aAscfile.Lines.size(); j++ )
        AddAscLine( aAscfile, j, aScreen );
 
    for( int j = 0; j < (int) aAscfile.Circles.size(); j++ )
        AddAscCircle( aAscfile, j, aScreen );
 
    for( int j = 0; j < (int) aAscfile.Arcs.size(); j++ )
        AddAscArc( aAscfile, j, aScreen );
 
    for( int j = 0; j < (int) aAscfile.Rectangles.size(); j++ )
        AddAscRect( aAscfile, j, aScreen );
 
    for( int j = 0; j < (int) aAscfile.Bustap.size(); j++ )
        AddAscBusEntry( aAscfile, j, aScreen );
 
    for( int j = 0; j < (int) aAscfile.Wires.size(); j++ )
        AddAscWire( aAscfile, j, aScreen, SCH_LAYER_ID::LAYER_WIRE );
 
    for( int j = 0; j < (int) aAscfile.Iopins.size(); j++ )
        AddAscIopin( aAscfile, j, aScreen );
 
    for( const LTSPICE_SCHEMATIC::FLAG& lt_flag : aAscfile.Flags )
    {
        if( lt_flag.Value == wxS( "0" ) )
        {
            aScreen->Append(
                    CreatePowerSymbol( lt_flag.Offset, lt_flag.Value, lt_flag.FontSize, aScreen, aAscfile.Wires ) );
        }
        else
        {
            KICAD_T labelType = aScreen->Schematic()->RootScreen() == aScreen ? SCH_GLOBAL_LABEL_T : SCH_LABEL_T;
 
            aScreen->Append( CreateSCH_LABEL( labelType, lt_flag.Offset, lt_flag.Value, lt_flag.FontSize, aScreen ) );
        }
    }
 
    for( const LTSPICE_SCHEMATIC::TEXT& lt_text : aAscfile.Texts )
    {
        aScreen->Append( CreateSCH_TEXT( lt_text.Offset, convertLtSpiceTextToNgspice( lt_text.Value ), lt_text.FontSize,
                                         lt_text.Justification ) );
    }
 
    for( const LTSPICE_SCHEMATIC::DATAFLAG& lt_flag : aAscfile.DataFlags )
    {
        aScreen->Append( CreateSCH_LABEL( SCH_DIRECTIVE_LABEL_T, lt_flag.Offset, lt_flag.Expression, lt_flag.FontSize,
                                          aScreen ) );
    }
}
 
 
void SCH_IO_LTSPICE_PARSER::AddAscBusEntry( LTSPICE_SCHEMATIC::LT_ASC& aAscfile, int aIndex, SCH_SCREEN* aScreen )
{
    LTSPICE_SCHEMATIC::BUSTAP& bustap = aAscfile.Bustap[aIndex];
 
    for( int k = 0; k < (int) aAscfile.Wires.size(); k++ )
    {
        if( ( aAscfile.Wires[k].Start == bustap.Start ) || ( aAscfile.Wires[k].End == bustap.Start ) )
        {
            AddAscWire( aAscfile, k, aScreen, SCH_LAYER_ID::LAYER_BUS );
            aAscfile.Wires.erase( aAscfile.Wires.begin() + k );
        }
    }
 
    SCH_BUS_WIRE_ENTRY* busEntry = new SCH_BUS_WIRE_ENTRY( ToKicadCoords( { bustap.Start.x, bustap.Start.y - 16 } ) );
 
    busEntry->SetSize( { ToKicadCoords( 16 ), ToKicadCoords( 16 ) } );
 
    aScreen->Append( busEntry );
}
 
 
LABEL_FLAG_SHAPE getLabelShape( LTSPICE_SCHEMATIC::POLARITY aPolarity )
{
    if( aPolarity == LTSPICE_SCHEMATIC::POLARITY::PIN_INPUT )
        return LABEL_FLAG_SHAPE::L_INPUT;
    else if( aPolarity == LTSPICE_SCHEMATIC::POLARITY::OUTPUT )
        return LABEL_FLAG_SHAPE::L_OUTPUT;
    else if( aPolarity == LTSPICE_SCHEMATIC::POLARITY::BIDIR )
        return LABEL_FLAG_SHAPE::L_BIDI;
    else
        return LABEL_FLAG_SHAPE::L_UNSPECIFIED;
}
 
 
SPIN_STYLE autoLabelOrientation( SCH_SCREEN* aScreen, VECTOR2I aLabelPos, SPIN_STYLE aDefaultSpin )
{
    // Detect label orientation based on connections
    std::set<SPIN_STYLE> preferredSpins;
 
    SCH_COLLECTOR collector;
    collector.Collect( aScreen, { SCH_LINE_T, SCH_PIN_T, SCH_SHEET_PIN_T }, aLabelPos );
 
    for( EDA_ITEM* item : collector )
    {
        if( SCH_LINE* wire = dynamic_cast<SCH_LINE*>( item ) )
        {
            if( !wire->IsWire() )
                continue;
 
            BOX2I wireBox;
            wireBox.Merge( wire->GetStartPoint() );
            wireBox.Merge( wire->GetEndPoint() );
 
            VECTOR2I minPt = wireBox.GetOrigin();
            VECTOR2I maxPt = wireBox.GetEnd();
 
            if( wireBox.GetWidth() >= wireBox.GetHeight() ) // Mostly horizontal
            {
                if( aLabelPos == minPt )
                    preferredSpins.emplace( SPIN_STYLE::LEFT );
                else if( aLabelPos == maxPt )
                    preferredSpins.emplace( SPIN_STYLE::RIGHT );
                else
                    preferredSpins.emplace( SPIN_STYLE::UP );
            }
            else // Mostly vertical
            {
                if( aLabelPos == minPt )
                    preferredSpins.emplace( SPIN_STYLE::UP );
                else if( aLabelPos == maxPt )
                    preferredSpins.emplace( SPIN_STYLE::BOTTOM );
                else
                    preferredSpins.emplace( SPIN_STYLE::LEFT );
            }
        }
        else if( SCH_PIN* pin = dynamic_cast<SCH_PIN*>( item ) )
        {
            TRANSFORM transform;
 
            if( const SCH_SYMBOL* symbol = dynamic_cast<const SCH_SYMBOL*>( pin->GetParentSymbol() ) )
                transform = symbol->GetTransform();
 
            switch( pin->PinDrawOrient( transform ) )
            {
            case PIN_ORIENTATION::PIN_RIGHT: preferredSpins.emplace( SPIN_STYLE::LEFT ); break;
            case PIN_ORIENTATION::PIN_LEFT: preferredSpins.emplace( SPIN_STYLE::RIGHT ); break;
            case PIN_ORIENTATION::PIN_UP: preferredSpins.emplace( SPIN_STYLE::BOTTOM ); break;
            case PIN_ORIENTATION::PIN_DOWN: preferredSpins.emplace( SPIN_STYLE::UP ); break;
            default: break;
            }
        }
        else if( SCH_SHEET_PIN* sheetPin = dynamic_cast<SCH_SHEET_PIN*>( item ) )
        {
            switch( sheetPin->GetSpinStyle() )
            {
            case SPIN_STYLE::LEFT: preferredSpins.emplace( SPIN_STYLE::RIGHT ); break;
            case SPIN_STYLE::RIGHT: preferredSpins.emplace( SPIN_STYLE::LEFT ); break;
            case SPIN_STYLE::BOTTOM: preferredSpins.emplace( SPIN_STYLE::UP ); break;
            case SPIN_STYLE::UP: preferredSpins.emplace( SPIN_STYLE::BOTTOM ); break;
            default: break;
            }
        }
    }
 
    if( preferredSpins.size() == 1 )
    {
        return *preferredSpins.begin();
    }
    else if( preferredSpins.size() == 2 )
    {
        if( preferredSpins.contains( SPIN_STYLE::UP ) )
            return SPIN_STYLE::UP;
        else if( preferredSpins.contains( SPIN_STYLE::BOTTOM ) )
            return SPIN_STYLE::BOTTOM;
    }
    else if( preferredSpins.size() == 3 )
    {
        if( preferredSpins.contains( SPIN_STYLE::UP ) && preferredSpins.contains( SPIN_STYLE::BOTTOM ) )
        {
            if( preferredSpins.contains( SPIN_STYLE::LEFT ) )
                return SPIN_STYLE::LEFT;
            else if( preferredSpins.contains( SPIN_STYLE::RIGHT ) )
                return SPIN_STYLE::RIGHT;
        }
        else if( preferredSpins.contains( SPIN_STYLE::LEFT ) && preferredSpins.contains( SPIN_STYLE::RIGHT ) )
        {
            if( preferredSpins.contains( SPIN_STYLE::UP ) )
                return SPIN_STYLE::UP;
            else if( preferredSpins.contains( SPIN_STYLE::BOTTOM ) )
                return SPIN_STYLE::BOTTOM;
        }
    }
 
    return aDefaultSpin;
}
 
 
void SCH_IO_LTSPICE_PARSER::AddAscIopin( LTSPICE_SCHEMATIC::LT_ASC& aAscfile, int aIndex, SCH_SCREEN* aScreen )
{
    const LTSPICE_SCHEMATIC::IOPIN& iopin = aAscfile.Iopins[aIndex];
    wxString                        ioPinName;
 
    for( unsigned int k = 0; k < aAscfile.Flags.size(); k++ )
    {
        if( ( aAscfile.Flags[k].Offset.x == iopin.Location.x ) && ( aAscfile.Flags[k].Offset.y == iopin.Location.y ) )
        {
            ioPinName = aAscfile.Flags[k].Value;
            aAscfile.Flags.erase( aAscfile.Flags.begin() + k );
        }
    }
 
    VECTOR2I       pinLoc = ToKicadCoords( iopin.Location ) + m_originOffset;
    SCH_HIERLABEL* sheetPin = new SCH_HIERLABEL( pinLoc, ioPinName, SCH_HIER_LABEL_T );
    sheetPin->SetShape( getLabelShape( iopin.Polarity ) );
    sheetPin->SetSpinStyle( autoLabelOrientation( aScreen, pinLoc, SPIN_STYLE::RIGHT ) );
 
    sheetPin->AutoplaceFields( aScreen, AUTOPLACE_AUTO );
    sheetPin->SetFlags( IS_NEW );
 
    aScreen->Append( sheetPin );
}
 
 
void SCH_IO_LTSPICE_PARSER::AddAscLine( const LTSPICE_SCHEMATIC::LT_ASC& aAscfile, int aIndex, SCH_SCREEN* aScreen )
{
    const LTSPICE_SCHEMATIC::LINE& lt_line = aAscfile.Lines[aIndex];
    SCH_LINE*                      line = new SCH_LINE( ToKicadCoords( lt_line.Start ), SCH_LAYER_ID::LAYER_NOTES );
 
    line->SetEndPoint( ToKicadCoords( lt_line.End ) );
    line->SetStroke( getStroke( lt_line.LineWidth, lt_line.LineStyle ) );
    line->Move( m_originOffset );
 
    aScreen->Append( line );
}
 
 
void SCH_IO_LTSPICE_PARSER::AddAscCircle( const LTSPICE_SCHEMATIC::LT_ASC& aAscfile, int aIndex, SCH_SCREEN* aScreen )
{
    const LTSPICE_SCHEMATIC::CIRCLE& lt_circle = aAscfile.Circles[aIndex];
    SCH_SHAPE*                       circle = new SCH_SHAPE( SHAPE_T::CIRCLE );
 
    VECTOR2I c = ( lt_circle.TopLeft + lt_circle.BotRight ) / 2;
    int      r = ( lt_circle.TopLeft.x - lt_circle.BotRight.x ) / 2;
 
    circle->SetPosition( ToKicadCoords( c ) );
    circle->SetEnd( ToKicadCoords( c ) + VECTOR2I( abs( ToKicadCoords( r ) ), 0 ) );
    circle->SetStroke( getStroke( lt_circle.LineWidth, lt_circle.LineStyle ) );
    circle->Move( m_originOffset );
 
    aScreen->Append( circle );
}
 
 
void SCH_IO_LTSPICE_PARSER::AddAscArc( const LTSPICE_SCHEMATIC::LT_ASC& aAscfile, int aIndex, SCH_SCREEN* aScreen )
{
    const LTSPICE_SCHEMATIC::ARC& lt_arc = aAscfile.Arcs[aIndex];
    SCH_SHAPE*                    arc = new SCH_SHAPE( SHAPE_T::ARC );
 
    arc->SetCenter( ToKicadCoords( ( lt_arc.TopLeft + lt_arc.BotRight ) / 2 ) );
    arc->SetEnd( ToKicadCoords( lt_arc.ArcEnd ) );
    arc->SetStart( ToKicadCoords( lt_arc.ArcStart ) );
    arc->SetStroke( getStroke( lt_arc.LineWidth, lt_arc.LineStyle ) );
    arc->Move( m_originOffset );
 
    aScreen->Append( arc );
}
 
 
void SCH_IO_LTSPICE_PARSER::AddAscRect( const LTSPICE_SCHEMATIC::LT_ASC& aAscfile, int aIndex, SCH_SCREEN* aScreen )
{
    const LTSPICE_SCHEMATIC::RECTANGLE& lt_rect = aAscfile.Rectangles[aIndex];
    SCH_SHAPE*                          rectangle = new SCH_SHAPE( SHAPE_T::RECTANGLE );
 
    rectangle->SetPosition( ToKicadCoords( lt_rect.TopLeft ) );
    rectangle->SetEnd( ToKicadCoords( lt_rect.BotRight ) );
    rectangle->SetStroke( getStroke( lt_rect.LineWidth, lt_rect.LineStyle ) );
    rectangle->Move( m_originOffset );
 
    aScreen->Append( rectangle );
}
 
 
SCH_SHEET* SCH_IO_LTSPICE_PARSER::AddAscSymAsSubsheet( LTSPICE_SCHEMATIC::LT_ASC&          aAscfile,
                                                       const LTSPICE_SCHEMATIC::LT_SYMBOL& aLTSymbol,
                                                       SCH_SCREEN*                         aScreen )
{
    SCH_SHEET* sch_sheet = new SCH_SHEET( aScreen->Schematic() );
 
    sch_sheet->AddField( SCH_FIELD( sch_sheet, FIELD_T::SHEET_USER, SCH_IO_LTSPICE_PARSER::LT_INSTNAME_FIELD ) );
 
    SCH_FIELD* instNameField = sch_sheet->GetField( SCH_IO_LTSPICE_PARSER::LT_INSTNAME_FIELD );
    SCH_FIELD* sheetNameField = sch_sheet->GetField( FIELD_T::SHEET_NAME );
    SCH_FIELD* fileNameSheet = sch_sheet->GetField( FIELD_T::SHEET_FILENAME );
 
    wxString instName = get_def( aLTSymbol.SymAttributes, wxS( "INSTNAME" ), wxS( "_" ) );
    wxString sanitizedName = aLTSymbol.Name;
 
    ReplaceIllegalFileNameChars( sanitizedName, '_' );
 
    wxString sheetName = sanitizedName + ':' + instName;
 
    instNameField->SetText( instName );
    instNameField->SetVisible( false );
 
    sheetNameField->SetText( sheetName );
    sheetNameField->SetVisible( false );
 
    fileNameSheet->SetText( m_lt_schematic->GetSchematicFileName( aLTSymbol.AsyKey ) );
    fileNameSheet->SetVisible( false );
 
    BOX2I bboxLT;
 
    for( const LTSPICE_SCHEMATIC::LT_PIN& pin : aLTSymbol.Pins )
    {
        bboxLT.Merge( RotateMirror( aLTSymbol, pin.PinLocation ) );
    }
 
    for( const LTSPICE_SCHEMATIC::RECTANGLE& rect : aLTSymbol.Rectangles )
    {
        bboxLT.Merge( RotateMirror( aLTSymbol, rect.TopLeft ) );
        bboxLT.Merge( RotateMirror( aLTSymbol, rect.BotRight ) );
    }
 
    for( const LTSPICE_SCHEMATIC::CIRCLE& circle : aLTSymbol.Circles )
    {
        bboxLT.Merge( RotateMirror( aLTSymbol, circle.TopLeft ) );
        bboxLT.Merge( RotateMirror( aLTSymbol, circle.BotRight ) );
    }
 
    for( const LTSPICE_SCHEMATIC::ARC& arc : aLTSymbol.Arcs )
    {
        bboxLT.Merge( RotateMirror( aLTSymbol, arc.TopLeft ) );
        bboxLT.Merge( RotateMirror( aLTSymbol, arc.BotRight ) );
    }
 
    for( const LTSPICE_SCHEMATIC::LINE& line : aLTSymbol.Lines )
    {
        bboxLT.Merge( RotateMirror( aLTSymbol, line.Start ) );
        bboxLT.Merge( RotateMirror( aLTSymbol, line.End ) );
    }
 
    if( bboxLT.GetWidth() == 0 )
        bboxLT.Inflate( 16, 0 );
 
    if( bboxLT.GetHeight() == 0 )
        bboxLT.Inflate( 0, 16 );
 
    sch_sheet->SetPosition( ToKicadCoords( aLTSymbol.Offset + bboxLT.GetOrigin() ) + m_originOffset );
    sch_sheet->SetSize( ToKicadCoords( bboxLT.GetSize() ) );
    sch_sheet->SetBorderWidth( schIUScale.MilsToIU( 1 ) );
 
    for( const LTSPICE_SCHEMATIC::LT_PIN& pin : aLTSymbol.Pins )
    {
        wxString name = get_def( pin.PinAttribute, wxS( "PinName" ) );
        VECTOR2I absPinPosLT = aLTSymbol.Offset + RotateMirror( aLTSymbol, pin.PinLocation );
 
        SCH_SHEET_PIN* sheetPin = new SCH_SHEET_PIN( sch_sheet, absPinPosLT, name );
 
        if( pin.PinJustification != LTSPICE_SCHEMATIC::JUSTIFICATION::NONE )
            sheetPin->SetSchTextSize( schIUScale.MilsToIU( 40 ) ); // Match LTspice size
        else
            sheetPin->SetSchTextSize( schIUScale.MilsToIU( 10 ) ); // Supposed to be invisible
 
        sheetPin->ConstrainOnEdge( ToKicadCoords( absPinPosLT ) + m_originOffset, true );
        sch_sheet->AddPin( sheetPin );
 
        VECTOR2I absPinPosNewLT = ToLtSpiceCoords( sheetPin->GetPosition() - m_originOffset );
 
        // Reconnect wires/iopins/flags to the sheet pin
        for( LTSPICE_SCHEMATIC::WIRE& wire : aAscfile.Wires )
        {
            if( wire.Start == absPinPosLT )
                wire.Start = absPinPosNewLT;
            if( wire.End == absPinPosLT )
                wire.End = absPinPosNewLT;
        }
 
        for( LTSPICE_SCHEMATIC::IOPIN& iopin : aAscfile.Iopins )
        {
            if( iopin.Location == absPinPosLT )
                iopin.Location = absPinPosNewLT;
        }
 
        for( LTSPICE_SCHEMATIC::FLAG& flag : aAscfile.Flags )
        {
            if( flag.Offset == absPinPosLT )
                flag.Offset = absPinPosNewLT;
        }
    }
 
    aScreen->Append( sch_sheet );
 
    return sch_sheet;
}
 
 
int SCH_IO_LTSPICE_PARSER::getLineWidth( const LTSPICE_SCHEMATIC::LINEWIDTH& aLineWidth )
{
    if( aLineWidth == LTSPICE_SCHEMATIC::LINEWIDTH::Normal )
        return schIUScale.MilsToIU( 6 );
    else if( aLineWidth == LTSPICE_SCHEMATIC::LINEWIDTH::Wide )
        return schIUScale.MilsToIU( 12 );
    else
        return schIUScale.MilsToIU( 6 );
}
 
 
LINE_STYLE SCH_IO_LTSPICE_PARSER::getLineStyle( const LTSPICE_SCHEMATIC::LINESTYLE& aLineStyle )
{
    switch( aLineStyle )
    {
    case LTSPICE_SCHEMATIC::LINESTYLE::SOLID:      return LINE_STYLE::SOLID;
    case LTSPICE_SCHEMATIC::LINESTYLE::DOT:        return LINE_STYLE::DOT;
    case LTSPICE_SCHEMATIC::LINESTYLE::DASHDOTDOT: return LINE_STYLE::DASHDOTDOT;
    case LTSPICE_SCHEMATIC::LINESTYLE::DASHDOT:    return LINE_STYLE::DASHDOT;
    case LTSPICE_SCHEMATIC::LINESTYLE::DASH:       return LINE_STYLE::DASH;
    default:                                       return LINE_STYLE::SOLID;
    }
}
 
 
STROKE_PARAMS SCH_IO_LTSPICE_PARSER::getStroke( const LTSPICE_SCHEMATIC::LINEWIDTH& aLineWidth,
                                                const LTSPICE_SCHEMATIC::LINESTYLE& aLineStyle )
{
    return STROKE_PARAMS( getLineWidth( aLineWidth ), getLineStyle( aLineStyle ) );
}
 
 
void SCH_IO_LTSPICE_PARSER::setTextJustification( EDA_TEXT*                        aText,
                                                  LTSPICE_SCHEMATIC::JUSTIFICATION aJustification )
{
    switch( aJustification )
    {
    case LTSPICE_SCHEMATIC::JUSTIFICATION::INVISIBLE:
        aText->SetVisible( false );
        break;
 
    case LTSPICE_SCHEMATIC::JUSTIFICATION::LEFT:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VLEFT:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
        break;
 
    case LTSPICE_SCHEMATIC::JUSTIFICATION::CENTER:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VCENTER:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
        break;
 
    case LTSPICE_SCHEMATIC::JUSTIFICATION::RIGHT:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VRIGHT:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
        break;
 
    case LTSPICE_SCHEMATIC::JUSTIFICATION::BOTTOM:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VBOTTOM:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
        break;
 
    case LTSPICE_SCHEMATIC::JUSTIFICATION::TOP:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VTOP:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
        break;
 
    default: break;
    }
 
    switch( aJustification )
    {
    case LTSPICE_SCHEMATIC::JUSTIFICATION::LEFT:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::CENTER:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::RIGHT:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::BOTTOM:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::TOP:
        aText->SetTextAngle( ANGLE_HORIZONTAL );
        break;
 
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VLEFT:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VCENTER:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VRIGHT:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VBOTTOM:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VTOP:
        aText->SetTextAngle( ANGLE_VERTICAL );
        break;
 
    default: break;
    }
 
    // Center, Left, Right aligns by first line in multiline text
    if( wxSplit( aText->GetText(), '\n', '\0' ).size() > 1 )
    {
        switch( aJustification )
        {
        case LTSPICE_SCHEMATIC::JUSTIFICATION::LEFT:
        case LTSPICE_SCHEMATIC::JUSTIFICATION::CENTER:
        case LTSPICE_SCHEMATIC::JUSTIFICATION::RIGHT:
            aText->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
            aText->Offset( VECTOR2I( 0, -aText->GetTextHeight() / 2 ) );
            break;
 
        case LTSPICE_SCHEMATIC::JUSTIFICATION::VLEFT:
        case LTSPICE_SCHEMATIC::JUSTIFICATION::VCENTER:
        case LTSPICE_SCHEMATIC::JUSTIFICATION::VRIGHT:
            aText->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
            aText->Offset( VECTOR2I( -aText->GetTextHeight() / 2, 0 ) );
            break;
 
        default: break;
        }
    }
}
 
 
SCH_TEXT* SCH_IO_LTSPICE_PARSER::CreateSCH_TEXT( const VECTOR2I& aOffset, const wxString& aText, int aFontSize,
                                                 LTSPICE_SCHEMATIC::JUSTIFICATION aJustification )
{
    VECTOR2I  pos = ToKicadCoords( aOffset ) + m_originOffset;
    SCH_TEXT* textItem = new SCH_TEXT( pos, aText );
 
    textItem->SetTextSize( ToKicadFontSize( aFontSize ) );
    textItem->SetVisible( true );
    textItem->SetMultilineAllowed( true );
 
    setTextJustification( textItem, aJustification );
 
    return textItem;
}
 
 
void SCH_IO_LTSPICE_PARSER::AddAscWire( const LTSPICE_SCHEMATIC::LT_ASC& aAscfile, int aIndex, SCH_SCREEN* aScreen,
                                        SCH_LAYER_ID aLayer )
{
    SCH_LINE* segment = new SCH_LINE();
 
    segment->SetLineWidth( getLineWidth( LTSPICE_SCHEMATIC::LINEWIDTH::Normal ) );
    segment->SetLineStyle( LINE_STYLE::SOLID );
    segment->SetLayer( aLayer );
 
    segment->SetStartPoint( ToKicadCoords( aAscfile.Wires[aIndex].Start ) + m_originOffset );
    segment->SetEndPoint( ToKicadCoords( aAscfile.Wires[aIndex].End ) + m_originOffset );
 
    aScreen->Append( segment );
}
 
 
SCH_SYMBOL* SCH_IO_LTSPICE_PARSER::CreatePowerSymbol( const VECTOR2I& aOffset, const wxString& aValue, int aFontSize,
                                                      SCH_SCREEN*                           aScreen,
                                                      std::vector<LTSPICE_SCHEMATIC::WIRE>& aWires )
{
    LIB_SYMBOL* lib_symbol = new LIB_SYMBOL( wxS( "GND" ) );
    SCH_SHAPE*  shape = new SCH_SHAPE( SHAPE_T::POLY, LAYER_DEVICE );
 
    shape->AddPoint( ToKicadCoords( { 16, 0 } ) );
    shape->AddPoint( ToKicadCoords( { -16, 0 } ) );
    shape->AddPoint( ToKicadCoords( { 0, 15 } ) );
    shape->AddPoint( ToKicadCoords( { 16, 0 } ) );
    shape->AddPoint( ToKicadCoords( { -16, 0 } ) );
    shape->AddPoint( ToKicadCoords( { 0, 15 } ) );
 
    shape->SetStroke( STROKE_PARAMS( getLineWidth( LTSPICE_SCHEMATIC::LINEWIDTH::Normal ), LINE_STYLE::SOLID ) );
 
    lib_symbol->AddDrawItem( shape );
    lib_symbol->SetGlobalPower();
 
    SCH_PIN* pin = new SCH_PIN( lib_symbol );
 
    pin->SetType( ELECTRICAL_PINTYPE::PT_POWER_IN );
    pin->SetPosition( ToKicadCoords( { 0, 0 } ) );
    pin->SetLength( 5 );
    pin->SetShape( GRAPHIC_PINSHAPE::LINE );
    lib_symbol->AddDrawItem( pin );
 
    LIB_ID      libId( wxS( "ltspice" ), wxS( "GND" ) );
    SCH_SYMBOL* sch_symbol = new SCH_SYMBOL( *lib_symbol, libId, nullptr, 1 );
 
    sch_symbol->GetField( FIELD_T::REFERENCE )->SetText( wxString::Format( wxS( "#GND%03d" ), m_powerSymbolIndex++ ) );
    sch_symbol->GetField( FIELD_T::REFERENCE )->SetVisible( false );
    sch_symbol->SetValueFieldText( wxS( "0" ) );
    sch_symbol->GetField( FIELD_T::VALUE )->SetTextSize( ToKicadFontSize( aFontSize ) );
    sch_symbol->GetField( FIELD_T::VALUE )->SetVisible( false );
 
    VECTOR2I pos = ToKicadCoords( aOffset ) + m_originOffset;
    sch_symbol->Move( pos );
 
    switch( autoLabelOrientation( aScreen, pos, SPIN_STYLE::BOTTOM ) )
    {
    case SPIN_STYLE::BOTTOM: sch_symbol->SetOrientation( SYM_ORIENT_0 ); break;
    case SPIN_STYLE::RIGHT:  sch_symbol->SetOrientation( SYM_ORIENT_90 ); break;
    case SPIN_STYLE::UP:     sch_symbol->SetOrientation( SYM_ORIENT_180 ); break;
    case SPIN_STYLE::LEFT:   sch_symbol->SetOrientation( SYM_ORIENT_270 ); break;
    default: break;
    }
 
    return sch_symbol;
}
 
 
SCH_LABEL_BASE* SCH_IO_LTSPICE_PARSER::CreateSCH_LABEL( KICAD_T aType, const VECTOR2I& aOffset, const wxString& aValue,
                                                        int aFontSize, SCH_SCREEN* aScreen )
{
    SCH_LABEL_BASE* label = nullptr;
 
    if( aType == SCH_LABEL_T )
    {
        label = new SCH_LABEL();
 
        label->SetText( aValue );
        label->SetTextSize( ToKicadFontSize( aFontSize ) );
    }
    else
    if( aType == SCH_GLOBAL_LABEL_T )
    {
        label = new SCH_GLOBALLABEL();
 
        label->SetText( aValue );
        label->SetTextSize( ToKicadFontSize( aFontSize ) );
    }
    else if( aType == SCH_DIRECTIVE_LABEL_T )
    {
        label = new SCH_DIRECTIVE_LABEL();
 
        label->SetSpinStyle( SPIN_STYLE::RIGHT );
 
        SCH_FIELD field( label, FIELD_T::USER, wxS( "DATAFLAG" ) );
        field.SetText( aValue );
        field.SetTextSize( ToKicadFontSize( aFontSize ) );
        field.SetVisible( true );
 
        label->AddField( field );
    }
    else
    {
        UNIMPLEMENTED_FOR( wxString::Format( wxT( "Type not supported %d" ), (int)aType ) );
    }
 
    if( label )
    {
        label->SetPosition( ToKicadCoords( aOffset ) + m_originOffset );
        label->SetSpinStyle( autoLabelOrientation( aScreen, label->GetPosition(), SPIN_STYLE::RIGHT ) );
        label->AutoplaceFields( nullptr, AUTOPLACE_AUTO );
        label->SetVisible( true );
    }
 
    return label;
}
 
 
void SCH_IO_LTSPICE_PARSER::AddSymFields( const LTSPICE_SCHEMATIC::LT_SYMBOL& aLTSymbol, SCH_SYMBOL* aSymbol )
{
    wxString symbolName = aLTSymbol.Name.Upper();
    wxString type = get_def( aLTSymbol.SymAttributes, wxS( "TYPE" ) ).Upper();
    wxString prefix = get_def( aLTSymbol.SymAttributes, wxS( "PREFIX" ) ).Upper();
    wxString instName = get_def( aLTSymbol.SymAttributes, wxS( "INSTNAME" ) ).Upper();
    wxString value = get_def( aLTSymbol.SymAttributes, wxS( "VALUE" ) );
    wxString value2 = get_def( aLTSymbol.SymAttributes, wxS( "VALUE2" ) );
 
    if( value.IsEmpty() )
    {
        value = value2;
        value2 = wxEmptyString;
    }
 
    auto addField =
            [&]( const wxString& aFieldName, const wxString& aFieldValue )
            {
                SCH_FIELD newField( aSymbol, FIELD_T::USER, aFieldName );
                newField.SetVisible( false );
                newField.SetText( aFieldValue );
                aSymbol->AddField( newField );
            };
 
 
    auto setupNonInferredPassive =
            [&]( const wxString& aDevice, const wxString& aValueKey )
            {
                addField( wxS( "Sim.Device" ), aDevice );
                addField( wxS( "Sim.Params" ), aValueKey + wxS( "=${VALUE}" ) );
            };
 
    auto setupBehavioral =
            [&]( const wxString& aDevice, const wxString& aType )
            {
                aSymbol->SetValueFieldText( wxS( "${Sim.Params}" ) );
 
                addField( wxS( "Sim.Device" ), aDevice );
                addField( wxS( "Sim.Type" ), aType );
                addField( wxS( "Sim.Params" ), value );
            };
 
    static const std::set<wxString> prefixWithGain = { wxS( "E" ), wxS( "F" ), wxS( "G" ), wxS( "H" ) };
 
    if( prefix == wxS( "R" ) )
    {
        setupNonInferredPassive( prefix, wxS( "R" ) );
    }
    else if( prefix == wxS( "C" ) )
    {
        setupNonInferredPassive( prefix, wxS( "C" ) );
    }
    else if( prefix == wxS( "L" ) )
    {
        setupNonInferredPassive( prefix, wxS( "L" ) );
    }
    else if( prefixWithGain.count( prefix ) > 0 )
    {
        setupNonInferredPassive( prefix, wxS( "gain" ) );
    }
    else if( prefix == wxS( "B" ) )
    {
        if( symbolName.StartsWith( wxS( "BV" ) ) )
            setupBehavioral( wxS( "V" ), wxS( "=" ) );
        else if( symbolName.StartsWith( wxS( "BI" ) ) )
            setupBehavioral( wxS( "I" ), wxS( "=" ) );
    }
    else if( prefix == wxS( "T" ) )
    {
        aSymbol->SetValueFieldText( wxS( "${Sim.Params}" ) );
 
        addField( wxS( "Sim.Device" ), wxS( "TLINE" ) );
        addField( wxS( "Sim.Params" ), value );
    }
    else if( prefix == wxS( "V" ) || symbolName == wxS( "I" ) )
    {
        addField( wxS( "Sim.Device" ), wxS( "SPICE" ) );
 
        wxString simParams;
        wxString pwlArgs;
        wxString upperValue = value.Upper();
 
        if( upperValue.StartsWith( wxS( "PWL " ) ) && upperValue.Contains( wxS( "FILE=" ) ) )
        {
            // TODO: support REPEAT statements
 
            // Take the arguments from the original text so the data file path keeps its case
            pwlArgs = value.Mid( 4 );
 
            if( !value2.IsEmpty() )
                pwlArgs << wxS( " " ) << value2;
 
            pwlArgs.Trim( true ).Trim( false );
 
            std::vector<wxString> ltspiceArgs = tokenizeQuoted( pwlArgs );
            std::vector<wxString> ngspiceArgs;
            wxString              fileRef;
 
            for( wxString& arg : ltspiceArgs )
            {
                wxString argValue;
                wxString argKey = arg.BeforeFirst( '=', &argValue );
 
                // Unquote the arg value
                if( argValue.length() >= 2 && argValue.StartsWith( wxS( "\"" ) ) && argValue.EndsWith( wxS( "\"" ) ) )
                    argValue = argValue.Mid( 1, argValue.length() - 2 );
 
                if( argKey.Upper() == wxS( "FILE" ) )
                {
                    wxString fileValue = argValue;
 
                    if( fileValue.IsEmpty() )
                        continue;
 
                    // Convert the data file to ngspice format
                    wxFileName sourceFile( fileValue );
 
                    wxString sanitizedName = sourceFile.GetName();
                    sanitizedName.MakeLower();
                    sanitizedName.Replace( wxS( " " ), wxS( "_" ) );
 
                    wxFileName convertedFile = sourceFile;
                    convertedFile.SetName( sanitizedName + wxS( "_ngspice" ) );
                    convertedFile.SetExt( sourceFile.GetExt().Lower() );
 
                    if( sourceFile.FileExists() )
                    {
                        if( !convertPwlFileToNgspice( sourceFile, convertedFile ) )
                        {
                            wxLogWarning( wxS( "Failed to convert PWL data file to ngspice format: " )
                                          + sourceFile.GetFullPath() );
                        }
                    }
 
                    // Avoid \\ escape issues in Sim.Params quoted values.
                    fileRef = convertedFile.GetFullPath();
                    fileRef.Replace( wxS( "\\" ), wxS( "/" ) );
                }
            }
 
            // Use a subcircuit instance for the PWL data file
            prefix = "X";
            value2 = "";
            value = wxS( "pwl_file file=\\\"" ) + fileRef + wxS( "\\\" timerelative=1" );
        }
 
        simParams << "type=" << '"' << prefix << '"' << ' ';
 
        if( value2.IsEmpty() )
            simParams << "model=" << '"' << "${VALUE}" << '"' << ' ';
        else
            simParams << "model=" << '"' << "${VALUE} ${VALUE2}" << '"' << ' ';
 
        addField( wxS( "Sim.Params" ), simParams );
    }
    else
    {
        wxString libFile = get_def( aLTSymbol.SymAttributes, wxS( "MODELFILE" ) );
 
        if( prefix == wxS( "X" ) )
        {
            // A prefix of X overrides the simulation model for other symbols (npn, etc.)
            type = wxS( "X" );
        }
        else if( libFile.IsEmpty() )
        {
            if( type.IsEmpty() )
                type = symbolName;
        }
 
        if( !libFile.IsEmpty() )
        {
            addField( wxS( "Sim.Library" ), libFile );
            addField( wxS( "Sim.Name" ), symbolName );
        }
 
        wxString spiceLine = get_def( aLTSymbol.SymAttributes, wxS( "SPICELINE" ) );
 
        if( type == wxS( "X" ) )
        {
            addField( wxS( "Sim.Device" ), wxS( "SUBCKT" ) );
 
            if( !spiceLine.IsEmpty() )
                addField( wxS( "Sim.Params" ), spiceLine );
        }
        else
        {
            addField( wxS( "Sim.Device" ), wxS( "SPICE" ) );
 
            if( !spiceLine.IsEmpty() )
                addField( wxS( "Sim.Params" ), spiceLine );
            else
                addField( wxS( "Sim.Params" ), "model=\"" + value + "\"" );
        }
    }
 
    // Set this at the end, as we may have changed the variables
    aSymbol->GetField( FIELD_T::REFERENCE )->SetText( instName );
    aSymbol->SetValueFieldText( value );
 
    if( !value2.IsEmpty() )
        addField( wxS( "Value2" ), value2 );
 
    for( const LTSPICE_SCHEMATIC::LT_WINDOW& lt_window : aLTSymbol.Windows )
    {
        SCH_FIELD* field = nullptr;
 
        switch( lt_window.WindowNumber )
        {
        case -1: /* PartNum    */                                                     break;
        case 0:  /* InstName   */ field = aSymbol->GetField( FIELD_T::REFERENCE );    break;
        case 1:  /* Type       */                                                     break;
        case 2:  /* RefName    */                                                     break;
        case 3:  /* Value      */ field = aSymbol->GetField( FIELD_T::VALUE );        break;
 
        case 5:  /* QArea      */                                                     break;
 
        case 8:  /* Width      */                                                     break;
        case 9:  /* Length     */                                                     break;
        case 10: /* Multi      */                                                     break;
 
        case 16: /* Nec        */                                                     break;
 
        case 38: /* SpiceModel */ field = aSymbol->GetField( wxS( "Sim.Name" ) );     break;
        case 39: /* SpiceLine  */ field = aSymbol->GetField( wxS( "Sim.Params" ) );   break;
        case 40: /* SpiceLine2 */                                                     break;
 
        /*
           47   Def_Sub
 
           50   Digital_Timing_Model
           51   Digital_Extracts
           52   Digital_IO_Model
           53   Digital_Line
           54   Digital_Primitive
           55   Digital_MNTYMXDLY
           56   Digital_IO_LEVEL
           57   Digital_StdCell
           58   Digital_File
 
          105   Cell
          106   W/L
          107   PSIZE
          108   NSIZE
          109   sheets
          110   sh#
          111   Em_Scale
          112   Epi
          113   Sinker
          114   Multi5
 
          118   AQ
          119   AQSUB
          120   ZSIZE
          121   ESR
          123   Value2
          124   COUPLE
          125   Voltage
          126   Area1
          127   Area2
          128   Area3
          129   Area4
          130   Multi1
          131   Multi2
          132   Multi3
          133   Multi4
          134   DArea
          135   DPerim
          136   CArea
          137   CPerim
          138   Shrink
          139   Gate_Resize
 
          142   BP
          143   BN
          144   Sim_Level
 
          146   G_Voltage
 
          150   SpiceLine3
 
          153   D_VOLTAGES
 
          156   Version
          157   Comment
          158   XDef_Sub
          159   LVS_Area
 
          162   User1
          163   User2
          164   User3
          165   User4
          166   User5
          167   Root
          168   Class
          169   Geometry
          170   WL_Delimiter
 
          175   T1
          176   T2
 
          184   DsgnName
          185   Designer
 
          190   RTN
          191   PWR
          192   BW
 
          201   CAPROWS
          202   CAPCOLS
          203   NF
          204   SLICES
          205   CUR
          206   TEMPRISE
          207   STRIPS
          208   WEM
          209   LEM
          210   BASES
          211   COLS
          212   XDef_Tub
          */
        default: break;
        }
 
        if( field )
        {
            field->SetPosition( ToKicadCoords( lt_window.Position ) );
            field->SetTextSize( ToKicadFontSize( lt_window.FontSize ) );
 
            if( lt_window.Justification == LTSPICE_SCHEMATIC::JUSTIFICATION::NONE )
                field->SetVisible( false );
 
            setTextJustification( field, lt_window.Justification );
        }
    }
}
 
 
void SCH_IO_LTSPICE_PARSER::CreateSymRect( const LTSPICE_SCHEMATIC::LT_SYMBOL& aLTSymbol, int aIndex,
                                           SCH_SHAPE* aRectangle )
{
    const LTSPICE_SCHEMATIC::RECTANGLE& lt_rect = aLTSymbol.Rectangles[aIndex];
 
    aRectangle->SetPosition( ToKicadCoords( lt_rect.BotRight ) );
    aRectangle->SetEnd( ToKicadCoords( lt_rect.TopLeft ) );
    aRectangle->SetStroke( getStroke( lt_rect.LineWidth, lt_rect.LineStyle ) );
 
    if( get_def( aLTSymbol.SymAttributes, wxS( "PREFIX" ) ) == wxS( "X" ) )
        aRectangle->SetFillMode( FILL_T::FILLED_WITH_BG_BODYCOLOR );
}
 
 
void SCH_IO_LTSPICE_PARSER::CreateSymPin( const LTSPICE_SCHEMATIC::LT_SYMBOL& aLTSymbol, int aIndex, SCH_PIN* aPin )
{
    const LTSPICE_SCHEMATIC::LT_PIN& lt_pin = aLTSymbol.Pins[aIndex];
    wxString                         device = aLTSymbol.Name.Lower();
 
    if( aLTSymbol.Pins.size() == 2 && ( device == wxS( "res" )
                                     || device == wxS( "cap" )
                                     || device == wxS( "ind" ) ) )
    {
        // drop A/B pin names from simple LRCs as they're not terribly useful (and prevent
        // other pin names on the net from driving the net name).
    }
    else
    {
        aPin->SetName( get_def( lt_pin.PinAttribute, wxS( "PinName" ) ) );
 
        if( lt_pin.PinJustification == LTSPICE_SCHEMATIC::JUSTIFICATION::NONE )
            aPin->SetNameTextSize( 0 );
    }
 
    aPin->SetNumber( wxString::Format( wxS( "%d" ), aIndex + 1 ) );
 
    // Prefer LTspice SpiceOrder for pin numbers
    wxString spiceOrder = get_def( lt_pin.PinAttribute, wxS( "SpiceOrder" ) );
    long     spiceOrderNum = 0;
 
    if( spiceOrder.ToLong( &spiceOrderNum ) && spiceOrderNum > 0 )
        aPin->SetNumber( wxString::Format( wxS( "%ld" ), spiceOrderNum ) );
 
    aPin->SetType( ELECTRICAL_PINTYPE::PT_PASSIVE );
    aPin->SetShape( GRAPHIC_PINSHAPE::LINE );
    aPin->SetPosition( ToKicadCoords( lt_pin.PinLocation ) );
 
    int pinLen = std::max( schIUScale.MilsToIU( 10 ), ToKicadCoords( lt_pin.NameOffSet - 8 ) );
    aPin->SetLength( pinLen );
 
    switch( lt_pin.PinJustification )
    {
    case LTSPICE_SCHEMATIC::JUSTIFICATION::LEFT:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VTOP:
        aPin->SetOrientation( PIN_ORIENTATION::PIN_RIGHT );
        break;
 
    case LTSPICE_SCHEMATIC::JUSTIFICATION::RIGHT:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VBOTTOM:
        aPin->SetOrientation( PIN_ORIENTATION::PIN_LEFT );
        break;
 
    case LTSPICE_SCHEMATIC::JUSTIFICATION::BOTTOM:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VLEFT:
        aPin->SetOrientation( PIN_ORIENTATION::PIN_UP );
        break;
 
    case LTSPICE_SCHEMATIC::JUSTIFICATION::TOP:
    case LTSPICE_SCHEMATIC::JUSTIFICATION::VRIGHT:
        aPin->SetOrientation( PIN_ORIENTATION::PIN_DOWN );
        break;
 
    default:
        // Auto-detect based on connected lines
        for( const LTSPICE_SCHEMATIC::LINE& line : aLTSymbol.Lines )
        {
            BOX2I bbox;
            bbox.Merge( line.Start );
            bbox.Merge( line.End );
 
            if( bbox.GetWidth() >= bbox.GetHeight() ) // Mostly horizontal
            {
                if( lt_pin.PinLocation == bbox.GetOrigin() )
                    aPin->SetOrientation( PIN_ORIENTATION::PIN_RIGHT );
                else if( lt_pin.PinLocation == bbox.GetEnd() )
                    aPin->SetOrientation( PIN_ORIENTATION::PIN_LEFT );
            }
            else // Mostly vertical
            {
                if( lt_pin.PinLocation == bbox.GetOrigin() )
                    aPin->SetOrientation( PIN_ORIENTATION::PIN_DOWN );
                else if( lt_pin.PinLocation == bbox.GetEnd() )
                    aPin->SetOrientation( PIN_ORIENTATION::PIN_UP );
            }
        }
    }
}
 
 
void SCH_IO_LTSPICE_PARSER::CreateSymArc( const LTSPICE_SCHEMATIC::LT_SYMBOL& aLTSymbol, int aIndex, SCH_SHAPE* aArc )
{
    const LTSPICE_SCHEMATIC::ARC& lt_arc = aLTSymbol.Arcs[aIndex];
 
    aArc->SetCenter( ToKicadCoords( ( lt_arc.TopLeft + lt_arc.BotRight ) / 2 ) );
    aArc->SetStart( ToKicadCoords( lt_arc.ArcEnd ) );
    aArc->SetEnd( ToKicadCoords( lt_arc.ArcStart ) );
    aArc->SetStroke( getStroke( lt_arc.LineWidth, lt_arc.LineStyle ) );
}
 
 
void SCH_IO_LTSPICE_PARSER::CreateSymCircle( const LTSPICE_SCHEMATIC::LT_SYMBOL& aLTSymbol, int aIndex,
                                             SCH_SHAPE* aCircle )
{
    const LTSPICE_SCHEMATIC::CIRCLE& lt_circle = aLTSymbol.Circles[aIndex];
 
    VECTOR2I c = ( lt_circle.TopLeft + lt_circle.BotRight ) / 2;
    int      r = ( lt_circle.TopLeft.x - lt_circle.BotRight.x ) / 2;
 
    aCircle->SetPosition( ToKicadCoords( c ) );
    aCircle->SetEnd( ToKicadCoords( c ) + VECTOR2I( abs( ToKicadCoords( r ) ), 0 ) );
    aCircle->SetStroke( getStroke( lt_circle.LineWidth, lt_circle.LineStyle ) );
}
 
 
void SCH_IO_LTSPICE_PARSER::CreateSymText( const LTSPICE_SCHEMATIC::LT_SYMBOL& aLTSymbol, int aIndex, SCH_TEXT* aText )
{
    const LTSPICE_SCHEMATIC::TEXT& lt_text = aLTSymbol.Texts[aIndex];
 
    aText->SetText( lt_text.Value );
    aText->SetPosition( ToKicadCoords( lt_text.Offset ) );
    aText->SetTextSize( ToKicadFontSize( lt_text.FontSize ) );
    aText->SetVisible( true );
 
    setTextJustification( aText, lt_text.Justification );
}