diptrace_sch_parser.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 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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#ifndef DIPTRACE_SCH_PARSER_H_
#define DIPTRACE_SCH_PARSER_H_
 
#include <io/diptrace/diptrace_binary_reader.h>
 
#include <map>
#include <memory>
#include <set>
#include <vector>
#include <set>
 
#include <math/vector2d.h>
#include <wx/string.h>
 
 
class LIB_SYMBOL;
class PROGRESS_REPORTER;
class REPORTER;
class SCH_IO;
class SCH_LABEL;
class SCH_LINE;
class SCH_PIN;
class SCH_SCREEN;
class SCH_SHEET;
class SCH_SYMBOL;
class SCHEMATIC;
 
 
namespace DIPTRACE
{
 
// ---------------------------------------------------------------------------
// Intermediate data structures for parsed .dch data
// ---------------------------------------------------------------------------

struct DCH_SHEET_DEF
{
    wxString name;
    int      field_a = 0;
};
 

struct DCH_SHEET_SHAPE
{
    int                   kindCode = 0; 
    int                   sheetIndex = 0;
    int                   lineWidth = 0;
    uint8_t               color[3] = {};
    std::vector<VECTOR2I> points; 
};
 

struct DCH_PIN
{
    int      index = 0;
    bool     hasHeader = false;
    int      headerA = 0;
    int      headerB = 0;
    int      headerC = 0;
    int      typeCode = 0;
    int      x = 0; 
    int      y = 0;
    int      length = 0;
    wxString name;
    wxString number;
    int      netFlagA = 0;
    int      netFlagB = 0; 
    int      labelXOff = 0;
    int      labelYOff = 0;
    int      numXOff = 0;
    int      numYOff = 0;
    wxString midTailText;
    int      stubDx = 0;
    int      stubDy = 0;
    int      tailByte = 0;
};
 

struct DCH_SHAPE
{
    uint8_t               flags[3] = {};
    int                   shapeField = 0;
    int                   lineWidth = 0;
    std::vector<VECTOR2I> points; 
    int                   fontX = 0;
    int                   fontY = 0;
    int kindCode = 0;
    int kindFlag = 0;
};
 

struct DCH_COMPONENT_TEXT
{
    uint8_t  flags[3] = {};
    int      type = 0;
    wxString fontName;
    wxString text;
    int      fontSize = 0;
    int      fieldA = 0;
    int      coordX = 0;
    int      coordY = 0;
    int      fieldB = 0;
    int      fieldC = 0;
    uint8_t  flagA = 0;
    uint8_t  flagB = 0;
    int      fieldD = 0;
    int      fieldE = 0;
    int      fieldF = 0;
    int      fieldG = 0;
    uint8_t  flags2[4] = {};
    int      fieldH = 0;
};
 

struct DCH_COMPONENT
{
    size_t   fileOffset = 0;
    int      bboxX1 = 0;
    int      bboxY1 = 0;
    int      bboxX2 = 0;
    int      bboxY2 = 0;
    wxString compName;
    wxString refdes;
    wxString value;
    wxString prefix;
    wxString nameDup;
    wxString partName;
    wxString partNumber;
    bool     isMultiPart = false;
    wxString partId;
    int      sheetIndex = 0;
    int      rotationE4 = 0; 
    wxString libPath;
    wxString patternName; 
    wxString datasheet;   

    std::vector<std::pair<wxString, wxString>> additionalFields;
 
    std::vector<DCH_PIN>            pins;
    std::vector<DCH_SHAPE>          shapes;
    std::vector<DCH_COMPONENT_TEXT> texts;
};
 

struct DCH_BUS_ENTRY
{
    int      coordX = 0;
    int      coordY = 0;
    int      sheetIndex = 0;
    int      busType = 0;
    int      instanceId = 0;
    int      signalCount = 0;
    wxString name;
};
 

struct DCH_NET_ENTRY
{
    wxString name;
    int      coordX = 0;
    int      coordY = 0;
    int      field1 = 0;
};
 

struct DCH_PAGE
{
    bool   found = false; 
    double widthMM = 0.0;
    double heightMM = 0.0;
};
 

struct DCH_WIRE
{
    int                   sheetIndex = 0; 
    std::vector<VECTOR2I> points;         
    int                   object1 = 0;    
    int                   subObject1 = 0; 
    int                   bus1 = -1;      
    int                   object2 = 0;
    int                   subObject2 = 0;
    int                   bus2 = -1;
};
 
 
// ---------------------------------------------------------------------------
// Parser class
// ---------------------------------------------------------------------------

class SCH_PARSER
{
public:
    SCH_PARSER( const wxString& aFileName, SCHEMATIC* aSchematic, SCH_SHEET* aRootSheet,
                PROGRESS_REPORTER* aProgressReporter = nullptr, REPORTER* aReporter = nullptr );
 
    ~SCH_PARSER();

    void Parse();
 
    int ComponentBoundaryScanCount() const { return m_componentBoundaryScanCount; }
 
private:
    // -- Binary format parsing ------------------------------------------------
 
    void parseHeader();
    void parseSheetDefinitions();
    void parseDisplaySettings();
    void parseTextStyles();
    void parsePreComponentSettings();
    void parseComponents( size_t aBusSectionOffset );
    void parseOneComponent( size_t aCompEnd, bool aUseCompEnd = true );
    void parsePin( int aPinIndex, DCH_COMPONENT& aComp );
    void parseShape( DCH_COMPONENT& aComp );
    void parseFontBearingShape( DCH_COMPONENT& aComp );
    bool parseComponentTextField( DCH_COMPONENT& aComp, size_t aCompEnd );
    void parseEmbeddedPattern( DCH_COMPONENT& aComp, size_t aCompEnd );
    void parseBusSection();
    void parseNetSection();
    void parseWireSection();
    void parseSheetShapes();

    void findPageGeometry();

    VECTOR2I applyPageOffset( const VECTOR2I& aPos ) const;
 
    // -- Structural scanning --------------------------------------------------

    size_t findBusSection( size_t aSearchStart ) const;

    size_t findTailStart() const;

    std::vector<size_t> scanComponentBoundaries( size_t aFirstComp, size_t aBusSectionOffset ) const;
 
    // -- Shape detection helpers -----------------------------------------------

    bool isShapeStart( size_t aOffset ) const;
    bool isFontBearingShapeStart( size_t aOffset ) const;
 
    // -- KiCad object creation ------------------------------------------------

    void createKiCadObjects();

    SCH_SCREEN* getOrCreateSheet( int aSheetIndex );
    void        finalizeFlatSheetOrder();
    void        assignSheetPageNumbers();

    LIB_SYMBOL* getOrCreateLibSymbol( const DCH_COMPONENT& aComp, int aUnit );
    void        populateLibSymbolUnit( LIB_SYMBOL* aLibSymbol, const DCH_COMPONENT& aComp, int aUnit );
    void        syncEmbeddedLibrarySymbols();

    wxString componentSymbolName( const DCH_COMPONENT& aComp ) const;
    wxString normalizedRefdes( const DCH_COMPONENT& aComp ) const;

    void createSymbolInstance( const DCH_COMPONENT& aComp, SCH_SCREEN* aFallbackScreen );

    void createNetPortLabels();

    int sheetForNearestWire( const VECTOR2I& aPos ) const;

    void createWires();
    void createSheetShapes();

    void createJunctions();

    void buildWirePointSheets();

    void buildComponentPartIds();

    bool isComponentHeaderAt( size_t aOffset ) const;

    int sheetForPositions( const std::vector<VECTOR2I>& aPositions, int aFallback ) const;

    int sheetForComponentPins( const std::vector<VECTOR2I>& aConnectionPoints );

    int resolveSheetTally( const std::map<std::pair<int, int>, int>& aTally );

    static int pinOrientationFromOffset( int aOffsetX, int aOffsetY, int aHalfWidth, int aHalfHeight );

    static int toKiCadCoordX( int aDipTraceCoord );
    static int toKiCadCoordY( int aDipTraceCoord );

    static int toKiCadSize( int aDipTraceCoord );

    wxString getLibName() const;
 
    // -- Member data ----------------------------------------------------------
 
    BINARY_READER      m_reader;
    SCHEMATIC*         m_schematic;
    SCH_SHEET*         m_rootSheet;
    PROGRESS_REPORTER* m_progressReporter;
    REPORTER*          m_reporter;
    int                m_version;
    int                m_magicMajor;
    int                m_componentCount;
    int                m_componentBoundaryScanCount = 0;
    wxString           m_fileName;
 
    // Parsed intermediate data
    int                          m_numSheets;
    std::vector<DCH_SHEET_DEF>   m_sheetDefs;
    std::vector<DCH_COMPONENT>   m_components;
    std::vector<DCH_BUS_ENTRY>   m_buses;
    std::vector<DCH_NET_ENTRY>   m_nets;
    std::vector<DCH_WIRE>        m_wires;
    std::vector<DCH_SHEET_SHAPE> m_sheetShapes;

    std::map<std::pair<int, int>, std::set<int>> m_wirePointSheets;

    std::map<std::pair<int, int>, std::vector<std::pair<int, int>>> m_pointPartSheets;

    int m_lastSymbolPartId = -1;

    DCH_PAGE m_page;
    VECTOR2I m_pageOffset;

    size_t m_componentSectionStart = 0;

    size_t m_wireSectionEnd = 0;

    std::map<size_t, int> m_offsetToPartId;

    std::map<int, int> m_partIdSheet;

    std::set<wxString> m_netPortNames;

    size_t m_netPortLabelCount = 0;
 
    // KiCad object management
    std::vector<SCH_SHEET*>                         m_sheets;     
    std::map<wxString, std::unique_ptr<LIB_SYMBOL>> m_libSymbols; 
    std::map<wxString, std::vector<SCH_SYMBOL*>>    m_placedSymbolsByLibName;

    std::map<wxString, int> m_refdesUnitMap;
 
    size_t m_busSectionOffset;
    size_t m_tailOffset;
};
 
} // namespace DIPTRACE
 
#endif // DIPTRACE_SCH_PARSER_H_