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,
    RECT,
    LINE,
    ARC,
    ELLIPSE,
    POLYGON,
    POLYLINE,
    BEZIER,
    TEXT,
    IMAGE
};
 

enum class ORCAD_PORT_TYPE : int
{
    INPUT          = 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                 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
{
    int                             x = 0;
    int                             y = 0;
    uint32_t                        wordA = 0;   
    uint32_t                        wordB = 0;
    std::vector<ORCAD_DISPLAY_PROP> displayProps;
};
 

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; 
    ORCAD_BBOX                         bbox;           
    std::string                        sourcePackage;  
    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;   
};
 

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;
    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;
};
 

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;
};
 

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

struct ORCAD_DRAWN_INSTANCE
{
    uint32_t                        dbId = 0;
    std::string                     reference;
    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;   
    std::string face;
    bool        italic = false;
    bool        bold = false;  
};
 

struct ORCAD_PAGE_SETTINGS
{
    uint32_t width = 0;
    uint32_t height = 0;
    uint32_t pinToPin = 100;
    bool     isMetric = 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;
    std::vector<ORCAD_FONT>                          fonts;
    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
{
    // Move-only: the graphic-instance lists hold unique_ptrs, and the netmap's
    // non-noexcept move would otherwise make vector growth fall back to the
    // (deleted) copy constructor via move_if_noexcept.
    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;    
    uint32_t                           width = 0;   
    uint32_t                           height = 0;
    bool                               isMetric = 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::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::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                             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;

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