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 (C) 2022-2023 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.
 };
 
 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 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 wxString& aBase = wxEmptyString );
 
 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 );
 
 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