orcad_converter.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.
 *
 * Based on the dsn2kicad reference implementation and on OrCAD file format
 * documentation from the OpenOrCadParser project (MIT licensed).
 *
 * 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/>.
 */

 
#ifndef ORCAD_CONVERTER_H_
#define ORCAD_CONVERTER_H_
 
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include <wx/string.h>
 
#include <geometry/seg.h>
#include <math/box2.h>
#include <math/vector2d.h>
#include <gal/color4d.h>
#include <eda_shape.h>
#include <kiid.h>
 
#include <sch_io/orcad/orcad_orient.h>
#include <sch_io/orcad/orcad_records.h>
 
class LIB_SYMBOL;
class SCH_LINE;
class EDA_TEXT;
class PROGRESS_REPORTER;
class REPORTER;
class SCHEMATIC;
class SCH_FIELD;
class SCH_ITEM;
class SCH_LABEL_BASE;
class SCH_LABEL;
class SCH_SCREEN;
class SCH_SHEET;
class SCH_SHEET_PIN;
class SCH_SHEET_PATH;
class SCH_SYMBOL;
class SCH_TEXT;
class SPIN_STYLE;
class wxMemoryBuffer;
 

inline constexpr int ORCAD_IU_PER_DBU = 2540;
 
KIGFX::COLOR4D OrcadColor( int aColorIndex );
int            OrcadLineWidthIu( int aWidth );
int            OrcadPageGraphicLineWidthIu( int aWidth );
LINE_STYLE     OrcadLineStyle( int aStyle );
std::pair<double, double> OrcadDashRatios( int aFormatVersionMajor );
FILL_T         OrcadFillType( int aFillStyle, int aHatchStyle );
int            OrcadHatchPitchIu( uint32_t aModifyTimestamp );
int            OrcadHatchLineWidthIu( uint32_t aModifyTimestamp );
std::vector<SEG> OrcadHatchLines( const EDA_SHAPE& aShape, int aHatchStyle, int aPitch );
int            OrcadTextBaselineOffset( int aTextSize );
int            OrcadDisplayType( const ORCAD_DISPLAY_PROP& aProp );
bool           OrcadDisplayPropVisible( const ORCAD_DISPLAY_PROP& aProp );
bool           OrcadDisplayPropShowsName( const ORCAD_DISPLAY_PROP& aProp );
bool           OrcadDisplayPropShowsValue( const ORCAD_DISPLAY_PROP& aProp );
int            OrcadDisplayFontId( const ORCAD_DISPLAY_PROP& aProp );
int            OrcadPageOrder( wxString& aName );
VECTOR2I       OrcadStretchedImageSize( int aWidth, int aHeight, int aBoxWidth, int aBoxHeight );
wxString       OrcadPinNameMarkup( const wxString& aName );
 
inline VECTOR2I OrcadDbuToIu( int aX, int aY )
{
    return VECTOR2I( aX * ORCAD_IU_PER_DBU, aY * ORCAD_IU_PER_DBU );
}
 

void OrcadTransformPrimitivePoints( ORCAD_PRIMITIVE&                                        aPrim,
                                    const std::function<ORCAD_POINT( const ORCAD_POINT& )>& aMap );

void OrcadOffsetPrimitive( ORCAD_PRIMITIVE& aPrim, int aDx, int aDy );

void OrcadForEachLeafPrimitive( const std::vector<ORCAD_PRIMITIVE>&                            aPrimitives,
                                const std::function<void( const ORCAD_PRIMITIVE&, int, int )>& aVisit );
 

inline ORCAD_POINT OrcadInverseOrient( int aOrient, int aX, int aY )
{
    const ORCAD_ORIENT_ENTRY& e = ORCAD_ORIENT_TABLE[aOrient & 7];
    int                       det = e.a * e.d - e.b * e.c;
 
    return { ( e.d * aX - e.b * aY ) / det, ( -e.c * aX + e.a * aY ) / det };
}
 
 
class ORCAD_CONVERTER
{
public:
    ORCAD_CONVERTER( ORCAD_DESIGN& aDesign, SCHEMATIC* aSchematic, REPORTER* aReporter,
                     PROGRESS_REPORTER* aProgressReporter = nullptr );

    ~ORCAD_CONVERTER();

    SCH_SHEET* Convert( SCH_SHEET* aRootSheet );

    std::vector<LIB_SYMBOL*> BuildSymbolLibrary();

    static constexpr const char* LIB_NICK = "orcad_import";
 
private:

    struct UNIT_INFO
    {
        std::string              letter; 
        const ORCAD_SYMBOL_DEF*  symbol = nullptr;
        const ORCAD_SYMBOL_DEF*  convert = nullptr; 
        std::vector<std::string> pinNumbers; 
        std::vector<bool>        pinNumberVisible; 
        std::vector<bool>        pinIgnore;  
        std::vector<int>         pinOffsets; 
        std::vector<bool>        explicitPinNets; 
 
        bool operator==( const UNIT_INFO& ) const = default;
    };

    struct LIB_ENTRY
    {
        std::string                 name;  
        std::vector<UNIT_INFO>      units; 
        bool                        isPower = false;
        std::string                 powerNet; 
        std::string                 refPrefix = "U";
        std::string                 footprint;
        std::unique_ptr<LIB_SYMBOL> kicadSymbol; 
    };

    struct OFFPAGE_NET
    {
        int         index = 0;
        std::string net;
        int         x = 0; 
        int         y = 0;
    };

    using PKG_KEY = std::tuple<std::string, std::string, int, std::string>;

    struct PAGE_SCOPE
    {
        const ORCAD_OCC_SCOPE*             occ = nullptr; 
        std::string                        flatNetSuffix;
        bool                               namedFlatNets = false;
        bool                               generatedFlatNets = false;
        std::map<std::string, std::string> unconnectedInterfaceNetNames;
        std::map<std::string, std::string> interfaceNetAliases;
        std::map<std::string, std::string> occurrenceNetAliases;
        std::set<std::string>              connectorInterfaceNetAliases;
        std::map<std::string, size_t>      electricalKeyCounts;
    };

    struct PAGE_NET_INDEX
    {
        const ORCAD_RAW_PAGE*                                          page = nullptr;
        std::map<std::pair<int, int>, std::vector<const ORCAD_WIRE*>> wireEndpoints;
        std::map<const ORCAD_PIN_INST*, std::set<uint32_t>>           pinNets;
        std::vector<VECTOR2I>                                          junctions;

        std::map<uint32_t, std::set<const std::string*>> occurrenceNamesByNetId;

        mutable std::map<const ORCAD_GRAPHIC_INST*, std::string> powerNets;
    };

    struct POWER_ALIAS_EVIDENCE
    {
        size_t                                                placements = 0;
        std::map<std::string, std::pair<std::string, size_t>> targets;
    };

    struct FOLDER_WALK
    {
        int    pageIndex = 1;
        size_t sourcePageIndex = 0;
        size_t sourcePageCount = 0;
        bool   numberSourcePages = true;    
        bool   occurrenceAliases = true;    
        bool   interfaceAliases = false;    
        bool   nestedFlatSuffix = true;     
        bool   folderSheetNames = true;     
        bool   rootSharedFolderPage = true; 
    };
 
    struct PLACED_PACKAGE_UNIT
    {
        SCH_SYMBOL*    symbol;
        const void*    scope;
        wxString       reference;
        const PKG_KEY* sourceUnit;
        UNIT_INFO      unit;
    };


    static constexpr int PIN_LEN_DBU = 10;

    static constexpr int MARGIN_L_DBU = 60;
    static constexpr int MARGIN_T_DBU = 60;
    static constexpr int MARGIN_R_DBU = 60;
    static constexpr int MARGIN_B_DBU = 100;


    void warn( const wxString& aMsg );

    void note( const wxString& aMsg );

    void prepareGlobalNetNames();

    std::string canonicalGlobalNetName( const std::string& aName ) const;

    std::string canonicalGlobalNetKey( const std::string& aName ) const;
 
    std::string effectiveInterfaceNetName( const std::string& aName ) const;
 
    void        enterScope( PAGE_SCOPE aScope );
    std::string occurrenceBaseNetName( const std::string& aName ) const;
    std::string occurrenceElectricalNetName( uint32_t aOccurrenceId, const std::string& aName ) const;
    bool        isPowerNetName( const std::string& aName ) const;
    bool        isOffpageNetName( const std::string& aName ) const;
 
 
    void prepareSymbols();

    LIB_ENTRY buildPackageEntry( const ORCAD_PACKAGE& aPackage ) const;

    ORCAD_SYMBOL_DEF synthesizeSymbol( const std::string&                               aPkgName,
                                       const std::vector<const ORCAD_PLACED_INSTANCE*>& aInstances ) const;

    std::string unitLetter( const ORCAD_PLACED_INSTANCE& aInst ) const;

    std::pair<const ORCAD_SYMBOL_DEF*, int> pickVariant( const ORCAD_PLACED_INSTANCE& aInst ) const;

    std::pair<std::string, int> libForInstance( const ORCAD_PLACED_INSTANCE& aInst,
                                              const PKG_KEY** aSourceUnit = nullptr );
    void finalizeNativePowerPackages();

    std::optional<uint32_t> occurrenceNetIdFor( const std::string* aName ) const;

    void finishConversion();

    std::string powerLibFor( const std::string& aSymbolName, const std::string& aNetName );
 
 
    LIB_SYMBOL* kicadSymbolFor( const std::string& aLibName );
 
 
    void addSymbolPrimitive( LIB_SYMBOL* aSymbol, const ORCAD_PRIMITIVE& aPrim, int aUnit, int aColor,
                             int aOffsetX = 0, int aOffsetY = 0 );

    void addSymbolArc( LIB_SYMBOL* aSymbol, const ORCAD_PRIMITIVE& aPrim, int aUnit, int aColor, int aOffsetX = 0,
                       int aOffsetY = 0 );
 

    struct PIN_EMIT
    {
        wxString    number;
        int         unit = 1;
        bool        power = false;
        std::string nameOverride;
        bool        nameVisible = false;
        bool        showPinNumbers = false;
        bool        numberVisible = true;
        bool        hidden = false;
        bool        explicitNet = false;
    };
 
    void addSymbolPin( LIB_SYMBOL* aSymbol, const ORCAD_SYMBOL_PIN& aPin, const BOX2I& aBodyBox, PIN_EMIT aEmit );

    std::string uniqueLibName( const std::string&                             aBase,
                               const std::function<bool( const LIB_ENTRY& )>& aReusable ) const;

    SCH_SYMBOL* instantiateSymbol( const LIB_SYMBOL& aLibSymbol, const std::string& aLibName, int aUnit, int aOrient,
                                   const VECTOR2I& aPos, const SCH_SHEET_PATH& aSheetPath ) const;
 
 
    void placeInstance( ORCAD_RAW_PAGE& aPage, const ORCAD_PLACED_INSTANCE& aInst, SCH_SCREEN* aScreen,
                        const SCH_SHEET_PATH& aSheetPath );

    void applyCisVariants( SCH_SYMBOL* aSymbol, const ORCAD_PLACED_INSTANCE& aInst,
                           const SCH_SHEET_PATH& aSheetPath, const std::string& aValue );

    wxString resolveReference( const ORCAD_PLACED_INSTANCE& aInst ) const;
 
 
    void placePowerSymbol( ORCAD_RAW_PAGE& aPage, const ORCAD_GRAPHIC_INST& aInst, const std::string& aNet,
                           SCH_SCREEN* aScreen, const SCH_SHEET_PATH& aSheetPath );
 
 
    void placeSymbolFields( SCH_SYMBOL* aSymbol, const ORCAD_PLACED_INSTANCE& aInst, const ORCAD_SYMBOL_DEF& aDef,
                            int aOrient, const std::string& aValue, const std::string& aFootprint );

    const ORCAD_PACKAGE* packageFor( const ORCAD_PLACED_INSTANCE& aInst ) const;

    std::map<std::string, std::string> effectiveProps( const ORCAD_PLACED_INSTANCE& aInst,
                                                       const ORCAD_SYMBOL_DEF&      aDef ) const;
 
 
    static int toKicadOrientation( int aOrient );
 
    void computeFontBaseline();
 
    int displayFontId( const ORCAD_DISPLAY_PROP& aProp ) const;
    bool displayUsesTemplateFont( const ORCAD_DISPLAY_PROP& aProp ) const;

    VECTOR2I displayPropPosition( const ORCAD_DISPLAY_PROP& aDisplay, const VECTOR2I& aAnchorIu ) const;

    void applyDisplayProp( SCH_FIELD& aField, const ORCAD_DISPLAY_PROP& aDisplay, const VECTOR2I& aAnchorIu,
                           bool aSymbolFlips, bool aApplyVisibility = true ) const;
    int wireAliasFontId( const ORCAD_ALIAS& aAlias ) const;
    int textBaselineOffset( int aTextSize, int aFontIdx, bool aTemplateFont = true ) const;

    int resolveFontIndex( int aFontIdx ) const;

    int fontHeightDbu( int aFontIdx, bool aTemplateFont = true ) const;
 
 
    int textSizeIU( int aFontIdx, bool aTemplateFont = true ) const;

    VECTOR2I textSize( int aFontIdx, bool aTemplateFont = true ) const;
 
    void applyFont( EDA_TEXT* aText, int aFontIdx, bool aTemplateFont = true ) const;
    void applyMultilineSpacing( SCH_TEXT* aText, int aFontIdx, bool aTemplateFont = true ) const;

    static std::string SymbolId( const std::string& aName );
 
 
    void convertPage( ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen, const SCH_SHEET_PATH& aSheetPath,
                      bool aContainerPage = false, bool aSharedFolderPage = false );
    void placeHierarchicalBlockFields( SCH_SHEET* aSheet, const ORCAD_DRAWN_INSTANCE& aBlock,
                                       const std::string& aChildFolder );
    void placeHierarchicalBlockPinFill( SCH_SCREEN* aScreen, SCH_SHEET_PIN* aPin );
    void appendNetIntent( SCH_SCREEN* aScreen, SCH_LABEL* aLabel, bool aExplicitName, uint32_t aNetId = 0 );
    void minimizeNetLabels();
    void finalizeNetNames();
    void recordNetNameMap();
    void convertUnreferencedPages();


    void prepareOccurrenceNets();

    PAGE_SCOPE occurrenceScope( const ORCAD_OCC_SCOPE& aOcc ) const;

    std::map<std::string, std::string> unconnectedInterfaceNetNames( const ORCAD_DRAWN_INSTANCE& aBlock,
                                                                     const std::string& aFlatNetSuffix ) const;

    SCH_SHEET* createBlockSheet( SCH_SHEET* aParentSheet, const ORCAD_RAW_PAGE& aParentPage,
                                 const ORCAD_DRAWN_INSTANCE& aBlock, const ORCAD_OCC_BLOCK& aOccurrence,
                                 const wxString& aName, const std::string& aFilePageName, int aPageIndex );

    std::vector<SCH_SHEET*> createTopLevelSheets( const std::vector<std::pair<wxString, wxString>>& aNamesAndFiles,
                                                  bool aReuseRoot, bool aOrdinalSheetUuids );
 
    void recordPowerAlias( std::map<std::string, POWER_ALIAS_EVIDENCE>& aCandidates, const std::string& aSourceName,
                           const std::string& aElectricalName ) const;

    void acceptPowerAliases( const std::map<std::string, POWER_ALIAS_EVIDENCE>& aCandidates );

    bool canBuildNativeHierarchy( const ORCAD_RAW_PAGE& aPage, const ORCAD_OCC_SCOPE& aScope ) const;

    bool canBuildFolderHierarchy( const std::vector<ORCAD_RAW_PAGE>& aPages, const ORCAD_OCC_SCOPE& aScope ) const;
    void convertFolderHierarchy( const SCH_SHEET_PATH& aRootPath, bool aNative );
    void addChildOccurrenceAliases( const ORCAD_RAW_PAGE& aParentPage, const ORCAD_OCC_SCOPE& aParentScope,
                                    const ORCAD_DRAWN_INSTANCE& aDrawn, const ORCAD_OCC_SCOPE& aChildScope );
    void collectFolderPowerAliases( std::map<std::string, POWER_ALIAS_EVIDENCE>& aCandidates,
                                    std::vector<ORCAD_RAW_PAGE>& aPages, const ORCAD_OCC_SCOPE& aScope );
    void placeFolder( FOLDER_WALK& aWalk, std::vector<ORCAD_RAW_PAGE>& aPages, const ORCAD_OCC_SCOPE& aScope,
                      SCH_SHEET* aFolderSheet, const SCH_SHEET_PATH& aFolderPath,
                      const std::string& aOccurrenceSuffix, bool aRepeatedFolder,
                      const std::map<std::string, std::string>& aUnconnectedInterfaceNetNames,
                      std::map<std::string, std::string>        aInterfaceNetAliases );

    void convertFlatPages( const SCH_SHEET_PATH& aRootPath );

    void forEachDesignPage( const std::function<void( const ORCAD_RAW_PAGE& )>& aVisit,
                            bool aUnreferenced = false ) const;

    wxString uniqueSheetName( const wxString& aBase );

    std::set<const std::string*> pinOccurrenceTargets( const ORCAD_RAW_PAGE& aPage, const ORCAD_BLOCK_PIN& aPin,
                                                       const std::map<uint32_t, std::string>& aScopeNets,
                                                       bool aSkipGenerated,
                                                       std::set<std::string>* aSourceKeys = nullptr ) const;

    SCH_SHEET_PATH topLevelPath( SCH_SHEET* aSheet, size_t aPageNumber ) const;
 
    KIID deterministicUuid( const std::string& aRole, size_t aOrdinal ) const;

    void assignPinUuids( SCH_SYMBOL* aSymbol, const std::string& aRole ) const;

    SCH_SCREEN* newScreen();

    void assignRemainingUuids();
    void appendPageItem( SCH_SCREEN* aScreen, SCH_ITEM* aItem );
    void assignPageItemUuids( size_t aPageOrdinal );
 
 
    static wxString MakePageFileName( int aPageIndex, const std::string& aPageName );

    void applyPageSettings( ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );
    void placePageFrame( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );

    static BOX2I pageExtentDbu( const ORCAD_RAW_PAGE& aPage );

    static void offsetPage( ORCAD_RAW_PAGE& aPage, int aDx, int aDy );
 
 
    void applyTitleBlock( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );

    void buildNetLookup( const ORCAD_RAW_PAGE& aPage );

    const std::set<uint32_t>& pinNetIds( const ORCAD_PIN_INST& aPin ) const;

    std::string netAt( const ORCAD_RAW_PAGE& aPage, int aX, int aY ) const;
 

    std::string powerNet( const ORCAD_RAW_PAGE& aPage, const ORCAD_GRAPHIC_INST& aInst ) const;
    std::string resolvePowerNet( const ORCAD_RAW_PAGE& aPage, const ORCAD_GRAPHIC_INST& aInst ) const;

    const ORCAD_SYMBOL_DEF* graphicDefinition( const ORCAD_GRAPHIC_INST& aInst ) const;

    VECTOR2I graphicPinPos( const ORCAD_GRAPHIC_INST& aInst ) const;

    VECTOR2I namedGraphicPinPos( const ORCAD_RAW_PAGE& aPage, const ORCAD_GRAPHIC_INST& aInst ) const;

    VECTOR2I powerPinPos( const ORCAD_RAW_PAGE& aPage, const ORCAD_GRAPHIC_INST& aInst ) const;
 
    std::vector<int> placedStackedPinOffsets( const ORCAD_PLACED_INSTANCE& aInstance ) const;
    VECTOR2I placedPinElectricalPosition( const ORCAD_PLACED_INSTANCE& aInstance, size_t aPinIndex ) const;
    bool hasImplicitPowerPinName( const ORCAD_PLACED_INSTANCE& aInstance, size_t aPinIndex,
                                  const std::string& aNetName ) const;

    std::vector<OFFPAGE_NET> offpageNets( const ORCAD_RAW_PAGE& aPage ) const;

    std::vector<VECTOR2I> computeJunctions( const ORCAD_RAW_PAGE& aPage ) const;

    void placeJunctions( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );
 
 
    void placeWires( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen, bool aHierarchical,
                     bool aNestedHierarchy, bool aSharedFolderPage );

    void placeBusEntries( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );

    void placeGraphicDisplayText( const ORCAD_GRAPHIC_INST& aGraphic, const ORCAD_DISPLAY_PROP& aDisplay,
                                  const std::string& aText, SCH_SCREEN* aScreen );

    void placeOffpageConnectors( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen,
                                 const SCH_SHEET_PATH& aSheetPath, bool aHierarchical );
 
 
    void placePorts( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen, bool aHierarchical );

    SPIN_STYLE spinAwayFromWire( const VECTOR2I& aPosDbu ) const;

    const ORCAD_DISPLAY_PROP* finishInterfaceLabel( const ORCAD_GRAPHIC_INST& aGraphic, SCH_LABEL_BASE* aLabel,
                                                    const std::vector<SEG>& aSourceWires, SCH_SCREEN* aScreen );
 
 
    void placeGraphics( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );

    void placeBitmap( const ORCAD_PRIMITIVE& aPrim, SCH_SCREEN* aScreen, int aOrient = 0,
                      bool* aUsedEmbeddedEmf = nullptr );
 
    void placeDefinitionImages( const ORCAD_SYMBOL_DEF& aDefinition, int aBaseX, int aBaseY, int aOrient,
                                SCH_SCREEN* aScreen );
 
    void placeDefinitionVectors( const ORCAD_SYMBOL_DEF& aDefinition, int aBaseX, int aBaseY, int aOrient,
                                 SCH_SCREEN* aScreen, double aTextScaleX = 1.0, double aTextScaleY = 1.0,
                                 bool aUseGenericTextBaseline = false );

    static VECTOR2I snapToWire( int aX, int aY, const ORCAD_WIRE& aWire );

    static bool onSegment( int aX, int aY, const ORCAD_WIRE& aWire );
 
 
    static wxString SanitizeFileName( const std::string& aName );
 
private:
    ORCAD_DESIGN&      m_design;
    SCHEMATIC*         m_schematic;
    REPORTER*          m_reporter;
    PROGRESS_REPORTER* m_progressReporter;
    SCH_SHEET*         m_rootSheet;
 
    std::map<std::string, LIB_ENTRY>               m_libSymbols; 
    std::map<PKG_KEY, std::pair<std::string, int>> m_pkgToLib;
    std::map<PKG_KEY, std::pair<std::string, int>> m_preparedPkgToLib;
    std::map<std::string, std::vector<UNIT_INFO>> m_preparedLibUnits;
    std::vector<PLACED_PACKAGE_UNIT>             m_placedPackageUnits;
    std::set<std::string>                       m_nativePowerFamilies;
    std::map<std::string, std::string>             m_globalNetNames;
    std::map<std::string, std::string>             m_globalNetAliases;
    std::set<std::string>                          m_powerNetNames;
    std::set<std::string>                          m_offpageNetNames;
    std::set<std::string>                          m_connectedBlockInterfaceNames;
    std::map<std::string, size_t>                  m_occurrenceNetNameScopeCounts;
    std::map<std::string, size_t>                  m_occurrenceNetNameMinDepth;
    std::map<std::string, size_t>                  m_occurrenceFolderCounts;
    bool                                           m_simpleRepeatedLeafDesign = false;

    std::map<std::string, std::string>                                                   m_baseOccurrenceNetAliases;
    std::map<const std::map<uint32_t, std::string>*, std::map<std::string, std::string>> m_occurrenceAliasesByScope;
    int                                            m_powerCount;      
    int                                            m_fontBaselineDbu; 
    size_t                                         m_pageOrdinal = 0;
    size_t                                         m_screenOrdinal = 1;
    SCH_SCREEN*                                    m_pageItemScreen = nullptr;
    std::vector<SCH_ITEM*>                         m_pageItems;
    std::set<SCH_SCREEN*>                          m_importedScreens;
    std::set<const SCH_ITEM*>                      m_preExistingItems; 
 
    PAGE_SCOPE                                                m_scope;
    std::set<const ORCAD_PIN_INST*>                            m_currentImplicitPowerPins;
    std::map<std::string, std::map<std::string, std::string>> m_hierBusNamesByScreen;
 
    struct NET_LABEL_INTENT
    {
        SCH_SCREEN* screen;
        SCH_LABEL_BASE* label;
        bool explicitName;
    };
 
    struct INTERFACE_LABEL_SOURCE
    {
        SCH_SCREEN* screen;
        SCH_LABEL_BASE* label;
        std::vector<SCH_LINE*> wires;
    };
 
    void rememberInterfaceLabelSource( SCH_SCREEN* aScreen, SCH_LABEL_BASE* aLabel,
                                       const std::vector<SEG>& aSourceWires );
 
    std::vector<INTERFACE_LABEL_SOURCE> m_interfaceLabelSources;
    std::vector<NET_LABEL_INTENT> m_netLabelIntents;
    std::vector<std::pair<SCH_LABEL_BASE*, std::pair<SCH_SCREEN*, uint32_t>>> m_labelSourceNets;
    std::map<SCH_SCREEN*, const ORCAD_RAW_PAGE*> m_sourcePages;
    std::map<std::pair<SCH_SCREEN*, uint32_t>, std::vector<SCH_ITEM*>> m_sourceNetItems;
    std::map<std::pair<SCH_SCREEN*, uint32_t>, std::set<std::string>> m_sourceNetNames;
    std::map<std::pair<SCH_SCREEN*, uint32_t>, std::string> m_sourceGeneratedNetNames;
    struct SOURCE_PIN_IDENTITY
    {
        wxString number;
        VECTOR2I position;
        std::optional<KIID> libraryPin;
        bool ignored = false;
    };
 
    std::map<SCH_SYMBOL*, std::vector<SOURCE_PIN_IDENTITY>> m_sourcePinIdentities;
    std::map<SCH_SYMBOL*, const ORCAD_PLACED_INSTANCE*> m_sourceInstances;
    std::map<SCH_SCREEN*, std::vector<wxString>> m_sourceOccurrences;
    std::map<std::tuple<SCH_SCREEN*, const ORCAD_PLACED_INSTANCE*, size_t>, std::pair<uint32_t, std::string>> m_wirelessNetNames;

    std::set<wxString> m_usedSheetNames;
 
    PAGE_NET_INDEX m_netIndex;
};
 
#endif // ORCAD_CONVERTER_H_