ltspice_schematic.h

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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef LTSPICE_SCHEMATIC_LOADER_H
#define LTSPICE_SCHEMATIC_LOADER_H
 
#include <sch_io/sch_io_mgr.h>
#include <sch_sheet_path.h>
#include <pin_type.h>
#include <layer_ids.h>
#include <math/box2.h>
#include <wx/filename.h>
#include <wx/dir.h>
 
 
struct LTSPICE_FILE
{
    wxString       ElementName;
    VECTOR2I       Offset;
    int            ParentIndex;
    SCH_SHEET*     Sheet;
    SCH_SCREEN*    Screen;
    SCH_SHEET_PATH SheetPath;
 
    LTSPICE_FILE( const wxString& aElementName, const VECTOR2I& aOffset ) :
            ElementName( aElementName.Lower() ),
            Offset( aOffset ),
            ParentIndex( 0 ),
            Sheet( nullptr ),
            Screen( nullptr )
    { }
 
    bool operator<( const LTSPICE_FILE& t ) const
    {
        return ElementName < t.ElementName;
    }
};
 
 
class LTSPICE_SCHEMATIC
{
public:
    enum class LINESTYLE
    {
        SOLID = 0,
        DASH = 1,
        DOT = 2,
        DASHDOT = 3,
        DASHDOTDOT = 4
    };
 
    enum class LINEWIDTH
    {
        Normal = 5,
        Wide = 10
    };
 
    enum class POLARITY
    {
        INPUT,  // IN POLARITY
        OUTPUT, // OUT POLARITY
        BIDIR   // BI-DIRECTIONAL POLARITY
    };
 
    enum class SYMBOLTYPE
    {
        CELL,
        BLOCK
    };
 
    enum class JUSTIFICATION
    {
        NONE,
        BOTTOM,
        LEFT,
        RIGHT,
        CENTER,
        TOP,
        VBOTTOM,  // Vertical Bottom Justification
        VLEFT,    // Vertical Left Justification
        VRIGHT,   // Vertical Right Justification
        VCENTER,  // Vertical Center Justification
        VTOP,      // Vertical Top Justification.
        INVISIBLE
    };
 
    enum class ORIENTATION
    {
        R0,     // 0 degree rotation
        R90,    // 90 degree rotatioin.
        R180,   // 180 degree rotation.
        R270,   // 270 degree rotation.
        M0,     // 0 degree mirror
        M90,    // 90 degree mirror
        M180,   // 180 degree mirror
        M270    // 270 degree mirror
    };
 
    struct LINE
    {
        VECTOR2I  Start;
        VECTOR2I  End;
        LINEWIDTH LineWidth;
        LINESTYLE LineStyle;
    };
 
    struct LT_PIN
    {
        VECTOR2I                     PinLocation;
        JUSTIFICATION                PinJustification;
        int                          NameOffSet;
        std::map<wxString, wxString> PinAttribute;
    };
 
    struct CIRCLE
    {
        VECTOR2I  TopLeft;
        VECTOR2I  BotRight;
        LINEWIDTH LineWidth;
        LINESTYLE LineStyle;
    };
 
    struct LT_WINDOW
    {
        int           WindowNumber;
        int           FontSize;
        VECTOR2I      Position;
        JUSTIFICATION Justification;
    };
 
    struct ARC
    {
        VECTOR2I  TopLeft;
        VECTOR2I  BotRight;
        VECTOR2I  ArcStart;
        VECTOR2I  ArcEnd;
        LINEWIDTH LineWidth;
        LINESTYLE LineStyle;
    };
 
    struct RECTANGLE
    {
        VECTOR2I  TopLeft;
        VECTOR2I  BotRight;
        LINEWIDTH LineWidth;
        LINESTYLE LineStyle;
    };
 
    struct WIRE
    {
        VECTOR2I Start;
        VECTOR2I End;
    };
 
    struct FLAG
    {
        VECTOR2I Offset;
        int      FontSize;
        wxString Value;
    };
 
    struct DATAFLAG
    {
        VECTOR2I Offset;
        int      FontSize;
        wxString Expression;
    };
 
    struct TEXT
    {
        VECTOR2I      Offset;
        JUSTIFICATION Justification;
        int           FontSize;
        wxString      Value;
    };
 
    struct IOPIN
    {
        VECTOR2I Location;
        POLARITY Polarity;
    };
 
    struct BUSTAP
    {
        VECTOR2I Start;
        VECTOR2I End;
    };
 
    struct LT_SYMBOL
    {
        wxString                     Name;
        SYMBOLTYPE                   SymbolType;
        VECTOR2I                     Offset;
        std::map<wxString, wxString> SymAttributes;
        std::vector<LT_PIN>          Pins;
        std::vector<LINE>            Lines;
        std::vector<CIRCLE>          Circles;
        std::vector<LT_WINDOW>       Windows;
        std::vector<ARC>             Arcs;
        std::vector<RECTANGLE>       Rectangles;
        std::vector<WIRE>            Wires;
        ORIENTATION                  SymbolOrientation;
    };
 
    struct LT_ASC
    {
        VECTOR2I               SheetSize;
        int                    Version;
        int                    VersionMinor;
        int                    SheetNumber;
        std::vector<LT_SYMBOL> Symbols;
        std::vector<LINE>      Lines;
        std::vector<CIRCLE>    Circles;
        std::vector<LT_WINDOW> Windows;
        std::vector<ARC>       Arcs;
        std::vector<RECTANGLE> Rectangles;
        std::vector<WIRE>      Wires;
        std::vector<FLAG>      Flags;
        std::vector<DATAFLAG>  DataFlags;
        std::vector<IOPIN>     Iopins;
        std::vector<BUSTAP>    Bustap;
        std::vector<TEXT>      Texts;
        BOX2I                  BoundingBox;
    };
 
    explicit LTSPICE_SCHEMATIC( const wxString& aFilename, const wxFileName& aLTspiceDataDir,
                                REPORTER* aReporter, PROGRESS_REPORTER* aProgressReporter ) :
            m_reporter( aReporter ),
            m_schematic( nullptr ),
            m_ltspiceDataDir( aLTspiceDataDir ),
            m_progressReporter( aProgressReporter )
    {}
 
    ~LTSPICE_SCHEMATIC() {}
 
    void Load( SCHEMATIC* aSchematic, SCH_SHEET* aRootSheet, const wxFileName& aLibraryFileName,
               REPORTER* aReporter );
 
    void GetAscAndAsyFilePaths( const wxDir& aDir, bool aRecursive,
                                std::map<wxString, wxString>& aMapOfAscFiles,
                                std::map<wxString, wxString>& aMapOfAsyFiles,
                                const std::vector<wxString>&  aBaseDirs = {} );
 
    std::vector<LTSPICE_FILE> GetSchematicElements( const wxString& aAscFile );
 
    bool IsAsySubsheet( const wxString& aAsyFile );
 
    std::map<wxString, wxString> ReadAsyFiles( const std::vector<LTSPICE_FILE>& aSourceFiles,
                                               const std::map<wxString, wxString>& aAsyFileMap );
 
    std::map<wxString, wxString> ReadAsyFile( const LTSPICE_FILE& aSourceFile,
                                              const std::map<wxString, wxString>& aAsyFileMap );
 
    std::vector<LT_ASC> StructureBuilder();
 
    LT_SYMBOL SymbolBuilder( const wxString& aAscFileName, LT_ASC& aAscFile );
 
    LT_SYMBOL SymbolBuilder( const wxString& aAscFileName, const wxString& aAsyFileContent,
                             LT_ASC& aAscFile );
 
    LT_SYMBOL MakeDummySymbol( const wxString& aAscFileName );
 
    const wxFileName& GetLTspiceDataDir() { return m_ltspiceDataDir; }
 
private:
    static void aggregateAttributeValue( wxArrayString& aTokens, int aIndex );
 
    static int integerCheck( const wxString& aToken, int aLineNumber, const wxString& aFileName );
 
    static VECTOR2I pointCheck( const wxString& aTokenX, const wxString& aTokenY, int aLineNumber,
                                const wxString& aFileName );
    static void tokensSizeRangeCheck( size_t aActualSize, int aExpectedMin, int aExpectedMax,
                                      int aLineNumber, const wxString& aFileName );
 
    static void removeCarriageReturn( wxString& elementFromLine );
 
    static LINESTYLE getLineStyle( int aValue );
 
    static LINEWIDTH getLineWidth( const wxString& aValue );
 
    static POLARITY getPolarity( const wxString& aValue );
 
    static ORIENTATION getSymbolRotationOrMirror( const wxString& aValue );
 
    static JUSTIFICATION getTextJustification( const wxString& aValue );
 
    static JUSTIFICATION getPinJustification( const wxString& aValue );
 
    static SYMBOLTYPE getSymbolType( const wxString& aValue );
 
private:
    REPORTER*            m_reporter;
    SCHEMATIC*           m_schematic;
    wxFileName           m_ltspiceDataDir;
    PROGRESS_REPORTER*   m_progressReporter;  // optional; may be nullptr
 
    std::map<wxString, std::map<wxString, wxString>> m_fileCache;
};
 
#endif // LTSPICE_SCHEMATIC_LOADER_H