orcad_records.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_RECORDS_H_
#define ORCAD_RECORDS_H_
 
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
#include <wx/string.h>

using ORCAD_WARN_FN = std::function<void( const wxString& aMsg )>;
 
 
enum ORCAD_ST : int
{
    ORCAD_ST_STH_IN_PAGES0 = 2, 
    ORCAD_ST_DSN_STREAM = 4,
    ORCAD_ST_PART_CELL = 6,
    ORCAD_ST_SCH_LIB = 9,
    ORCAD_ST_PAGE = 10,
    ORCAD_ST_PART_INSTANCE = 11,
    ORCAD_ST_DRAWN_INSTANCE = 12, 
    ORCAD_ST_PLACED_INSTANCE = 13,
    ORCAD_ST_T0X10 = 16, 
    ORCAD_ST_T0X11 = 17, 
    ORCAD_ST_WIRE_SCALAR = 20,
    ORCAD_ST_WIRE_BUS = 21,
    ORCAD_ST_PORT = 23,
    ORCAD_ST_LIBRARY_PART = 24,
    ORCAD_ST_SYMBOL_PIN_SCALAR = 26,
    ORCAD_ST_SYMBOL_PIN_BUS = 27,
    ORCAD_ST_BUS_ENTRY = 29,
    ORCAD_ST_PACKAGE = 31,
    ORCAD_ST_DEVICE = 32,
    ORCAD_ST_GLOBAL_SYMBOL = 33, 
    ORCAD_ST_PORT_SYMBOL = 34,
    ORCAD_ST_OFFPAGE_SYMBOL = 35,
    ORCAD_ST_GLOBAL = 37, 
    ORCAD_ST_OFFPAGE_CONNECTOR = 38,
    ORCAD_ST_SYMBOL_DISPLAY_PROP = 39,
    ORCAD_ST_SYMBOL_VECTOR = 48,
    ORCAD_ST_ALIAS = 49, 
    ORCAD_ST_T0X34 = 52, 
    ORCAD_ST_T0X35 = 53, 
    ORCAD_ST_GRAPHIC_BOX_INST = 55,
    ORCAD_ST_GRAPHIC_LINE_INST = 56,
    ORCAD_ST_GRAPHIC_ARC_INST = 57,
    ORCAD_ST_GRAPHIC_ELLIPSE_INST = 58,
    ORCAD_ST_GRAPHIC_POLYGON_INST = 59,
    ORCAD_ST_GRAPHIC_POLYLINE_INST = 60,
    ORCAD_ST_GRAPHIC_COMMENT_TEXT_INST = 61,
    ORCAD_ST_GRAPHIC_BITMAP_INST = 62,
    ORCAD_ST_TITLEBLOCK_SYMBOL = 64,
    ORCAD_ST_TITLEBLOCK = 65,
    ORCAD_ST_HIERARCHY_LINK = 66, 
    ORCAD_ST_ERC_SYMBOL = 75,
    ORCAD_ST_BOOKMARK_SYMBOL = 76,
    ORCAD_ST_ERC_OBJECT = 77, 
    ORCAD_ST_BOOKMARK_INST = 78,
    ORCAD_ST_GRAPHIC_BEZIER_INST = 88,
    ORCAD_ST_GRAPHIC_OLE_INST = 89,
    ORCAD_ST_PIN_SHAPE_SYMBOL = 98,
    ORCAD_ST_NET_GROUP = 103
};
 

enum ORCAD_PRIM : int
{
    ORCAD_PRIM_RECT = 40,
    ORCAD_PRIM_LINE = 41,
    ORCAD_PRIM_ARC = 42,
    ORCAD_PRIM_ELLIPSE = 43,
    ORCAD_PRIM_POLYGON = 44,
    ORCAD_PRIM_POLYLINE = 45,
    ORCAD_PRIM_COMMENT_TEXT = 46,
    ORCAD_PRIM_BITMAP = 47,        
    ORCAD_PRIM_SYMBOL_VECTOR = 48, 
    ORCAD_PRIM_BEZIER = 87,
    ORCAD_PRIM_OLE_IMAGE = 90 
};
 

enum class ORCAD_PRIM_KIND
{
    GROUP_PRIM,
    RECTANGLE,
    LINE,
    ARC,
    ELLIPSE,
    POLYGON,
    POLYLINE,
    BEZIER,
    TEXT,
    IMAGE
};
 

enum class ORCAD_PORT_TYPE : int
{
    INPUT_TYPE = 0,
    BIDIRECTIONAL = 1,
    OUTPUT = 2,
    OPEN_COLLECTOR = 3,
    PASSIVE = 4,
    TRI_STATE = 5,
    OPEN_EMITTER = 6,
    POWER_IN = 7
};
 

struct ORCAD_POINT
{
    int x = 0;
    int y = 0;
 
    bool operator==( const ORCAD_POINT& aOther ) const { return x == aOther.x && y == aOther.y; }
    bool operator!=( const ORCAD_POINT& aOther ) const { return !( *this == aOther ); }
};
 

struct ORCAD_BBOX
{
    int x1 = 0;
    int y1 = 0;
    int x2 = 0;
    int y2 = 0;
};
 

struct ORCAD_DISPLAY_PROP
{
    uint32_t    nameIdx = 0;
    std::string name; 
    int         x = 0;
    int         y = 0;
    int         rotation = 0; 
    int         fontIdx = 0;  
    int         color = 0;
    int         dispMode = 0;
};
 

struct ORCAD_ALIAS
{
    std::string name;
    int         x = 0;
    int         y = 0;
    int         rotation = 0; 
    int         color = 0;
    int         fontIdx = 0;
};
 

struct ORCAD_WIRE
{
    uint32_t                 dbId = 0;
    uint32_t                 id = 0;
    int                      x1 = 0;
    int                      y1 = 0;
    int                      x2 = 0;
    int                      y2 = 0;
    bool                     isBus = false; 
    int                      color = 0;
    int                      lineWidth = 3;
    int                      lineStyle = 5;
    std::vector<ORCAD_ALIAS> aliases;
};
 

struct ORCAD_PIN_INST
{
    int16_t                         pinIndex = 0;
    int                             x = 0;
    int                             y = 0;
    uint32_t                        wordA = 0; 
    uint32_t                        wordB = 0;
    std::vector<ORCAD_DISPLAY_PROP> displayProps;
 
    bool IsNoConnect() const { return pinIndex < 0; }
};
 

struct ORCAD_PLACED_INSTANCE
{
    std::string                        pkgName;
    uint32_t                           dbId = 0;
    int                                x = 0;
    int                                y = 0;
    std::string                        reference;
    std::string                        value; 
    std::map<std::string, std::string> props; 
    std::vector<ORCAD_DISPLAY_PROP>    displayProps;
    int                                color = 0;
    int                                rotation = 0;   
    bool                               mirror = false; 
    uint8_t                            partIndex = 0;
    uint8_t                            partByte = 0;
    ORCAD_BBOX                         bbox;          
    std::string                        sourcePackage; 
    std::string                        sourceLibrary; 
    uint16_t                           unitIndex = 0; 
    std::vector<ORCAD_PIN_INST>        pins;          
};
 
 
struct ORCAD_SYMBOL_DEF; // defined below (ORCAD_GRAPHIC_INST holds one by pointer)
 

struct ORCAD_GRAPHIC_INST
{
    int                                typeId = 0; 
    std::string                        name;       
    uint32_t                           dbId = 0;
    int                                x = 0;
    int                                y = 0;
    ORCAD_BBOX                         bbox;
    int                                color = 0;
    std::map<std::string, std::string> props;
    std::vector<ORCAD_DISPLAY_PROP>    displayProps;
    std::unique_ptr<ORCAD_SYMBOL_DEF>  nested;       
    int                                rotation = 0; 
    bool                               mirror = false;
    std::string                        logicalName; 
    double                             textScaleX = 1.0;
    double                             textScaleY = 1.0;
    bool                               useGenericTextBaseline = false;
    bool                               useSymbolLineWidths = false;
    std::string                        textFaceOverride;
};
 

struct ORCAD_PRIMITIVE
{
    ORCAD_PRIM_KIND              kind = ORCAD_PRIM_KIND::LINE;
    int                          x1 = 0;
    int                          y1 = 0;
    int                          x2 = 0;
    int                          y2 = 0;
    std::optional<ORCAD_POINT>   start;  
    std::optional<ORCAD_POINT>   end;    
    std::vector<ORCAD_POINT>     points; 
    std::string                  text;   
    int                          fontIdx = 0;
    std::optional<ORCAD_POINT>   textBoundsStart;
    int                          lineStyle = 5; 
    int                          lineWidth = 3; 
    int                          fillStyle = 1; 
    int                          hatchStyle = 0;
    std::vector<uint8_t>         data;     
    std::vector<ORCAD_PRIMITIVE> children; 
};
 

struct ORCAD_SYMBOL_PIN
{
    std::string     name;
    int             position = -1; 
    int             startX = 0;
    int             startY = 0;
    int             hotptX = 0;
    int             hotptY = 0;
    ORCAD_PORT_TYPE portType = ORCAD_PORT_TYPE::PASSIVE;
    int             shapeBits = 0;
    std::vector<ORCAD_DISPLAY_PROP> displayProps;
};
 

struct ORCAD_SYMBOL_DEF
{
    int                                typeId = 0; 
    std::string                        name;       
    std::string                        sourceLib;
    int                                color = 0;
    std::vector<ORCAD_PRIMITIVE>       primitives;
    std::vector<ORCAD_SYMBOL_PIN>      pins;
    std::optional<ORCAD_BBOX>          bbox; 
    std::map<std::string, std::string> props;

    std::vector<ORCAD_SYMBOL_DEF> variants;

    int generalFlags = -1;
 
    bool synthesized = false; 
};
 

struct ORCAD_DEVICE
{
    std::string              unitRef;
    std::string              refDes;
    std::vector<std::string> pinNumbers;
    std::vector<bool>        pinIgnore;
};
 
 
struct ORCAD_PACKAGE
{
    std::string                name;
    std::string                sourceLib;
    std::string                refDes;
    std::string                pcbFootprint;
    std::vector<ORCAD_DEVICE>  devices;
    std::vector<ORCAD_PACKAGE> variants; 

    std::map<std::string, std::string> props;
};
 

struct ORCAD_BLOCK_PIN
{
    std::string     name;
    ORCAD_PORT_TYPE portType = ORCAD_PORT_TYPE::PASSIVE;
    int             x = 0;
    int             y = 0;
    bool            noConnect = false;
};
 

struct ORCAD_DRAWN_INSTANCE
{
    uint32_t                        dbId = 0;
    std::string                     name;      
    std::string                     reference;
    std::map<std::string, std::string> props;
    int                             x1 = 0; 
    int                             y1 = 0;
    int                             w = 0;
    int                             h = 0;
    std::vector<ORCAD_BLOCK_PIN>    pins;
    std::vector<ORCAD_DISPLAY_PROP> displayProps;
    std::string                     childName; 
};
 
 
struct ORCAD_BUS_ENTRY
{
    int x1 = 0;
    int y1 = 0;
    int x2 = 0;
    int y2 = 0;
    int color = 0;
};
 

struct ORCAD_FONT
{
    int         height = 0; 
    int         width = 0;  
    int         escapement = 0;  
    int         orientation = 0; 
    uint8_t     pitchAndFamily = 0;
    std::string face;
    bool        italic = false;
    bool        bold = false; 
};
 

struct ORCAD_PAGE_SETTINGS
{
    uint32_t createTimestamp = 0;
    uint32_t modifyTimestamp = 0;
    uint32_t width = 0;
    uint32_t height = 0;
    uint32_t pinToPin = 100;
    uint16_t horizontalCount = 0;
    uint16_t verticalCount = 0;
    uint32_t horizontalWidth = 0;
    uint32_t verticalWidth = 0;
    bool     horizontalChar = false;
    bool     horizontalAscending = false;
    bool     verticalChar = false;
    bool     verticalAscending = false;
    bool     isMetric = false;
    bool     borderDisplayed = false;
    bool     borderPrinted = false;
    bool     gridRefDisplayed = false;
    bool     gridRefPrinted = false;
    bool     titleblockDisplayed = false;
    bool     titleblockPrinted = false;
    bool     ansiGridRefs = false;
};
 
 
struct ORCAD_NET_GROUP
{
    uint32_t              id = 0;
    std::string           name;
    std::vector<uint32_t> members;
};
 
 
struct ORCAD_LIBRARY_INFO
{
    std::string                                      introduction; 
    int                                              versionMajor = 0;
    int                                              versionMinor = 0;
    uint32_t                                         createTimestamp = 0;
    uint32_t                                         modifyTimestamp = 0;
    std::vector<ORCAD_FONT>                          fonts;
    std::vector<int>                                 templateFonts; 
    int                                              pinNameFont = 0; 
    int                                              pinNumberFont = 0; 
    std::vector<std::string>                         partFields; 
    std::vector<std::string>                         strings;    
    std::vector<std::pair<std::string, std::string>> partAliases;
    std::string                                      schematicName; 
    uint32_t                                         pinToPin = 100;
};
 

struct ORCAD_RAW_PAGE
{
    ORCAD_RAW_PAGE() = default;
    ORCAD_RAW_PAGE( const ORCAD_RAW_PAGE& ) = delete;
    ORCAD_RAW_PAGE& operator=( const ORCAD_RAW_PAGE& ) = delete;
    ORCAD_RAW_PAGE( ORCAD_RAW_PAGE&& ) = default;
    ORCAD_RAW_PAGE& operator=( ORCAD_RAW_PAGE&& ) = default;
 
    std::string                                  name;
    std::string                                  pageSize;  
    size_t                                       sourcePageNumber = 0; 
    size_t                                       sourcePageCount = 0;  
    std::map<std::string, std::string>            props;
    uint32_t                                     createTimestamp = 0;
    uint32_t                                     modifyTimestamp = 0;
    uint32_t                                     width = 0; 
    uint32_t                                     height = 0;
    bool                                         isMetric = false;
    uint16_t                                     horizontalCount = 0;
    uint16_t                                     verticalCount = 0;
    uint32_t                                     horizontalWidth = 0;
    uint32_t                                     verticalWidth = 0;
    bool                                         horizontalChar = false;
    bool                                         horizontalAscending = false;
    bool                                         verticalChar = false;
    bool                                         verticalAscending = false;
    bool                                         borderPrinted = false;
    bool                                         gridRefPrinted = false;
    std::vector<ORCAD_GRAPHIC_INST>              titleBlocks;
    std::vector<ORCAD_WIRE>                      wires;
    std::vector<ORCAD_PLACED_INSTANCE>           instances;
    std::vector<ORCAD_GRAPHIC_INST>              ports;
    std::vector<ORCAD_GRAPHIC_INST>              globals;    
    std::vector<ORCAD_GRAPHIC_INST>              offpage;    
    std::vector<ORCAD_GRAPHIC_INST>              ercObjects; 
    std::vector<ORCAD_BUS_ENTRY>                 busEntries;
    std::vector<ORCAD_GRAPHIC_INST>              graphics;   
    std::map<uint32_t, std::string>              netmap;     
    std::map<uint32_t, std::vector<std::string>> netAliases; 
    std::vector<ORCAD_NET_GROUP>                 netGroups;  
    std::vector<ORCAD_DRAWN_INSTANCE>            blocks;     
};
 
 
struct ORCAD_OCC_BLOCK; // defined below (a scope owns child block occurrences)
 

struct ORCAD_OCC_SCOPE
{
    std::map<uint32_t, std::string>                        partRefs; 
    std::map<uint32_t, std::string>                        partUnitRefs; 
    std::map<uint32_t, std::map<std::string, std::string>> partProps; 
    std::map<uint32_t, std::string>                        netNames; 
    std::vector<ORCAD_OCC_BLOCK>                           blocks; 
};
 

struct ORCAD_OCC_BLOCK
{
    uint32_t        targetDbId = 0; 
    std::string     childFolder;    
    ORCAD_OCC_SCOPE scope;          
};
 

struct ORCAD_DESIGN
{
    std::string                             sourceId; 
    std::string                             name;     
    ORCAD_LIBRARY_INFO                      library;
    std::map<std::string, ORCAD_SYMBOL_DEF> symbols;  
    std::map<std::string, ORCAD_PACKAGE>    packages; 
    std::vector<ORCAD_RAW_PAGE>             pages;    

    std::map<std::string, std::vector<ORCAD_RAW_PAGE>> childFolderPages;

    std::map<std::string, std::vector<ORCAD_RAW_PAGE>> unreferencedFolderPages;

    ORCAD_OCC_SCOPE occurrenceRoot;
 
    bool hasHierarchyBlocks = false;
};
 
#endif // ORCAD_RECORDS_H_