sch_io_geda.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * 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/>.
 *
 * This file contains file format knowledge derived from the gEDA and
 * Lepton EDA projects:
 *
 *   gEDA/gaf  - Copyright (C) 1998-2010 Ales Hvezda
 *               Copyright (C) 1998-2016 gEDA Contributors
 *   Lepton EDA - Copyright (C) 2017-2024 Lepton EDA Contributors
 *
 * Both projects are licensed under the GNU General Public License v2 or later.
 * See https://github.com/lepton-eda/lepton-eda and
 *     https://github.com/rlutz/geda-gaf
 */
 
#ifndef SCH_IO_GEDA_H_
#define SCH_IO_GEDA_H_
 
#include <sch_io/sch_io.h>
#include <sch_io/sch_io_mgr.h>
 
#include <eda_shape.h>
#include <stroke_params.h>
 
#include <wx/filename.h>
#include <wx/textfile.h>
 
#include <map>
#include <set>
#include <vector>
#include <memory>
 
class LIB_SYMBOL;
class SCH_SHEET;
class SCH_SCREEN;
class SCH_SYMBOL;
class SCH_LINE;
class SCH_TEXT;
class SCH_SHAPE;
class SCH_JUNCTION;
class SCH_NO_CONNECT;
class SCH_PIN;
class SCHEMATIC;
 

class SCH_IO_GEDA : public SCH_IO
{
public:
    SCH_IO_GEDA();
    ~SCH_IO_GEDA() override;
 
    const IO_BASE::IO_FILE_DESC GetSchematicFileDesc() const override
    {
        return IO_BASE::IO_FILE_DESC( _HKI( "gEDA / Lepton EDA schematic files" ), { "sch" } );
    }
 
    const IO_BASE::IO_FILE_DESC GetLibraryDesc() const override
    {
        return IO_BASE::IO_FILE_DESC( wxEmptyString, {} );
    }
 
    bool CanReadSchematicFile( const wxString& aFileName ) const override;
 
    int GetModifyHash() const override { return 0; }
 
    SCH_SHEET* LoadSchematicFile( const wxString& aFileName, SCHEMATIC* aSchematic,
                                  SCH_SHEET*                            aAppendToMe = nullptr,
                                  const std::map<std::string, UTF8>*    aProperties = nullptr ) override;
 
    bool IsLibraryWritable( const wxString& aLibraryPath ) override { return false; }

    static const std::map<wxString, wxString>& getBuiltinSymbols();
 
private:
    // -----------------------------------------------------------------------
    // Data types
    // -----------------------------------------------------------------------

    struct GEDA_ATTR
    {
        wxString name;
        wxString value;
        int      x        = 0;
        int      y        = 0;
        int      size     = 10;
        int      angle    = 0;
        int      align    = 0;
        bool     visible  = false;
        int      showNV   = 0;   
    };

    struct PENDING_COMPONENT
    {
        wxString                basename;
        int                     x           = 0;
        int                     y           = 0;
        int                     angle       = 0;
        int                     mirror      = 0;
        int                     selectable  = 1;
        std::vector<GEDA_ATTR>  attrs;
        bool                    embedded    = false;
        std::unique_ptr<LIB_SYMBOL> embeddedSym;
    };

    struct SYM_CACHE_ENTRY
    {
        wxString                    path;       
        std::unique_ptr<LIB_SYMBOL> symbol;     
        wxString                    symversion;  
        wxString                    netAttr;    
    };
 
    // -----------------------------------------------------------------------
    // Coordinate transformation
    // -----------------------------------------------------------------------

    static constexpr int MILS_TO_IU = 254;

    int toKiCadDist( int aMils ) const;

    VECTOR2I toKiCad( int aGedaX, int aGedaY ) const;
 
    // -----------------------------------------------------------------------
    // File parsing
    // -----------------------------------------------------------------------

    bool parseVersionLine( const wxString& aLine );

    std::vector<GEDA_ATTR> parseAttributes( wxTextFile& aFile, size_t& aLineIdx );

    wxString findAttr( const std::vector<GEDA_ATTR>& aAttrs, const wxString& aName ) const;

    const GEDA_ATTR* findAttrStruct( const std::vector<GEDA_ATTR>& aAttrs,
                                      const wxString& aName ) const;

    std::vector<GEDA_ATTR> maybeParseAttributes( wxTextFile& aFile, size_t& aLineIdx );
 
    // -----------------------------------------------------------------------
    // Object parsers - schematics
    // -----------------------------------------------------------------------
 
    void parseComponent( const wxString& aLine, wxTextFile& aFile, size_t& aLineIdx );
    void parseNet( const wxString& aLine, wxTextFile& aFile, size_t& aLineIdx );
    void parseBus( const wxString& aLine, wxTextFile& aFile, size_t& aLineIdx );
    void parseText( const wxString& aLine, wxTextFile& aFile, size_t& aLineIdx );
    void parseLine( const wxString& aLine, wxTextFile& aFile, size_t& aLineIdx );
    void parseBox( const wxString& aLine, wxTextFile& aFile, size_t& aLineIdx );
    void parseCircle( const wxString& aLine, wxTextFile& aFile, size_t& aLineIdx );
    void parseArc( const wxString& aLine, wxTextFile& aFile, size_t& aLineIdx );
    void parsePath( const wxString& aLine, wxTextFile& aFile, size_t& aLineIdx );
    void parsePicture( const wxString& aLine, wxTextFile& aFile, size_t& aLineIdx );
    void parsePin( const wxString& aLine, wxTextFile& aFile, size_t& aLineIdx );
    void parseEmbeddedComponent( wxTextFile& aFile, size_t& aLineIdx );
 
    // -----------------------------------------------------------------------
    // Symbol loading
    // -----------------------------------------------------------------------

    void initSymbolLibrary();

    void scanSymbolDir( const wxString& aDir, int aDepth = 0 );

    void parseRcFileForLibraries( const wxString& aPath, const wxString& aBaseDir );

    std::unique_ptr<LIB_SYMBOL> loadSymbolFile( const wxString& aPath,
                                                 wxString* aSymversion = nullptr,
                                                 wxString* aNetAttr = nullptr );

    void parseSymbolObjects( wxTextFile& aFile, size_t& aLineIdx, LIB_SYMBOL& aSymbol,
                             size_t aEndLine );

    void addSymbolPin( LIB_SYMBOL& aSymbol, int aX1, int aY1, int aX2, int aY2,
                       int aWhichEnd, const std::vector<GEDA_ATTR>& aAttrs );

    void addSymbolGraphic( LIB_SYMBOL& aSymbol, const wxString& aLine, wxTextFile& aFile,
                           size_t& aLineIdx, wxChar aType );

    void flushPendingComponent();

    void importHierarchicalSheet( const wxString& aSourceFile );

    LIB_SYMBOL* getOrLoadSymbol( const wxString& aBasename );

    std::unique_ptr<LIB_SYMBOL> loadBuiltinSymbol( const wxString& aBasename );

    std::unique_ptr<LIB_SYMBOL> createFallbackSymbol( const wxString& aBasename );

    int toKiCadOrientation( int aAngle, int aMirror ) const;

    wxString getLibName() const;
 
    // -----------------------------------------------------------------------
    // Style mapping
    // -----------------------------------------------------------------------

    static LINE_STYLE toLineStyle( int aDashStyle );

    static FILL_T toFillType( int aFillType );
 
    // -----------------------------------------------------------------------
    // Post-processing
    // -----------------------------------------------------------------------

    void trackEndpoint( int aGedaX, int aGedaY );

    void postProcess();

    void processNetAttributes();

    void addJunctions();

    void addBusEntries();

    void loadDeferredSheets();

    void fitPageToContent();
 
    // -----------------------------------------------------------------------
    // State
    // -----------------------------------------------------------------------
 
    SCH_SCREEN*  m_screen;
    SCH_SHEET*   m_rootSheet;
    SCHEMATIC*   m_schematic;
    wxFileName   m_filename;

    int m_maxY;

    long m_releaseVersion;
    long m_fileFormatVersion;

    std::unique_ptr<PENDING_COMPONENT> m_pendingComp;

    std::map<wxString, SYM_CACHE_ENTRY> m_symLibrary;
    bool m_symLibraryInitialized;

    std::map<wxString, std::unique_ptr<LIB_SYMBOL>> m_libSymbols;

    int m_powerCounter;

    std::map<std::pair<int,int>, int> m_netEndpoints;

    struct NET_ATTR_RECORD
    {
        wxString netname;
        wxString pinnumber;
        SCH_SYMBOL* symbol;
    };
 
    std::vector<NET_ATTR_RECORD> m_netAttrRecords;

    struct BUS_SEGMENT
    {
        VECTOR2I start;
        VECTOR2I end;
        int      ripperDir;  
    };
 
    std::vector<BUS_SEGMENT> m_busSegments;

    struct DEFERRED_SHEET
    {
        SCH_SHEET* sheet;
        wxString   sourceFile;  
    };
 
    std::vector<DEFERRED_SHEET> m_deferredSheets;

    std::set<wxString> m_importStack;

    const std::map<std::string, UTF8>* m_properties;
};
 
#endif // SCH_IO_GEDA_H_