altium_parser_pcb.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2020 Thomas Pointhuber <[email protected]>
 * 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, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef ALTIUM_PARSER_PCB_H
#define ALTIUM_PARSER_PCB_H
 
#include <cstdint>
#include <cstring>
#include <limits>
#include <map>
#include <memory>
#include <set>
#include <vector>
 
#include <wx/gdicmn.h>
 
#include <math/vector2d.h>
#include <math/vector3.h>
 
 
// tthis constant specifies an unconnected net
const uint16_t ALTIUM_NET_UNCONNECTED = std::numeric_limits<uint16_t>::max();
 
// this constant specifies a item which is not inside an component
const uint16_t ALTIUM_COMPONENT_NONE = std::numeric_limits<uint16_t>::max();
 
// this constant specifies a item which does not define a polygon
const uint16_t ALTIUM_POLYGON_NONE = std::numeric_limits<uint16_t>::max();
 
// 65534 seems to be belonging to board outline
const uint16_t ALTIUM_POLYGON_BOARD = std::numeric_limits<uint16_t>::max() - 1;
 
 
enum class ALTIUM_UNIT
{
    UNKNOWN = 0,
 
    INCH    = 1,
    MILS    = 2,
    MM      = 3,
    CM      = 4
};
 
enum class ALTIUM_CLASS_KIND
{
    UNKNOWN = -1,
 
    NET_CLASS              = 0,
    SOURCE_SCHEMATIC_CLASS = 1,
    FROM_TO                = 2,
    PAD_CLASS              = 3,
    LAYER_CLASS            = 4,
    UNKNOWN_CLASS          = 5,
    DIFF_PAIR_CLASS        = 6,
    POLYGON_CLASS          = 7
};
 
enum class ALTIUM_DIMENSION_KIND
{
    UNKNOWN = 0,
 
    LINEAR = 1,
    ANGULAR = 2,
    RADIAL = 3,
    LEADER = 4,
    DATUM = 5,
    BASELINE = 6,
    CENTER = 7,
    UNKNOWN_2 = 8,
    LINEAR_DIAMETER = 9,
    RADIAL_DIAMETER = 10
};
 
enum class ALTIUM_REGION_KIND
{
    UNKNOWN = -1,
 
    COPPER            = 0, // KIND=0
    POLYGON_CUTOUT    = 1, // KIND=1
    DASHED_OUTLINE    = 2, // KIND=2
    UNKNOWN_3         = 3, // KIND=3
    CAVITY_DEFINITION = 4, // KIND=4
    BOARD_CUTOUT      = 5, // KIND=0 AND ISBOARDCUTOUT=TRUE
};
 
enum class ALTIUM_RULE_KIND
{
    UNKNOWN = 0,
 
    CLEARANCE              = 1,
    DIFF_PAIR_ROUTINGS     = 2,
    HEIGHT                 = 3,
    HOLE_SIZE              = 4,
    HOLE_TO_HOLE_CLEARANCE = 5,
    WIDTH                  = 6,
    PASTE_MASK_EXPANSION   = 7,
    SOLDER_MASK_EXPANSION  = 8,
    PLANE_CLEARANCE        = 9,
    POLYGON_CONNECT        = 10,
    ROUTING_VIAS           = 11
};
 
enum class ALTIUM_CONNECT_STYLE
{
    UNKNOWN = 0,
    DIRECT  = 1,
    RELIEF  = 2,
    NONE    = 3
};
 
enum class ALTIUM_RECORD
{
    UNKNOWN = -1,
 
    ARC = 1,
    PAD = 2,
    VIA = 3,
    TRACK = 4,
    TEXT = 5,
    FILL = 6,
    REGION = 11,
    MODEL = 12
};
 
enum class ALTIUM_PAD_SHAPE
{
    UNKNOWN   = 0,
    CIRCLE    = 1,
    RECT      = 2,
    OCTAGONAL = 3
};
 
enum class ALTIUM_PAD_SHAPE_ALT
{
    UNKNOWN   = 0,
    CIRCLE    = 1,
    RECT      = 2, // TODO: valid?
    OCTAGONAL = 3, // TODO: valid?
    ROUNDRECT = 9
};
 
enum class ALTIUM_PAD_HOLE_SHAPE
{
    UNKNOWN = -1,
    ROUND   = 0,
    SQUARE  = 1,
    SLOT    = 2
};
 
enum class ALTIUM_PAD_MODE
{
    SIMPLE            = 0,
    TOP_MIDDLE_BOTTOM = 1,
    FULL_STACK        = 2
};
 
enum class ALTIUM_MODE
{
    UNKNOWN = -1,
    NONE = 0, // TODO: correct ID?
    RULE = 1,
    MANUAL = 2
};
 
enum class ALTIUM_POLYGON_HATCHSTYLE
{
    UNKNOWN = 0,
 
    SOLID      = 1,
    DEGREE_45  = 2,
    DEGREE_90  = 3,
    HORIZONTAL = 4,
    VERTICAL   = 5,
    NONE       = 6
};
 
enum class ALTIUM_TEXT_POSITION
{
    MANUAL        = 0, // only relevant for NAMEAUTOPOSITION and COMMENTAUTOPOSITION
    LEFT_TOP      = 1,
    LEFT_CENTER   = 2,
    LEFT_BOTTOM   = 3,
    CENTER_TOP    = 4,
    CENTER_CENTER = 5,
    CENTER_BOTTOM = 6,
    RIGHT_TOP     = 7,
    RIGHT_CENTER  = 8,
    RIGHT_BOTTOM  = 9
};
 
enum class ALTIUM_TEXT_TYPE
{
    UNKNOWN = -1,
 
    STROKE   = 0,
    TRUETYPE = 1,
    BARCODE  = 2
};
 
enum class ALTIUM_BARCODE_TYPE
{
    CODE39  = 0,
    CODE128 = 1
};
 
struct ALTIUM_VERTICE
{
    const bool    isRound;
    const int32_t radius;
    const double  startangle;
    const double  endangle;
    const VECTOR2I position;
    const VECTOR2I center;
 
    explicit ALTIUM_VERTICE( const VECTOR2I& aPosition )
            : isRound( false ),
              radius( 0 ),
              startangle( 0. ),
              endangle( 0. ),
              position( aPosition ),
              center( VECTOR2I( 0, 0 ) )
    {
    }
 
    explicit ALTIUM_VERTICE( bool aIsRound, int32_t aRadius, double aStartAngle, double aEndAngle,
                             const VECTOR2I aPosition, const VECTOR2I aCenter )
            : isRound( aIsRound ),
              radius( aRadius ),
              startangle( aStartAngle ),
              endangle( aEndAngle ),
              position( aPosition ),
              center( aCenter )
    {
    }
};
 
enum class ALTIUM_LAYER : uint32_t
{
    UNKNOWN = 0,
 
    TOP_LAYER    = 1,
    MID_LAYER_1  = 2,
    MID_LAYER_2  = 3,
    MID_LAYER_3  = 4,
    MID_LAYER_4  = 5,
    MID_LAYER_5  = 6,
    MID_LAYER_6  = 7,
    MID_LAYER_7  = 8,
    MID_LAYER_8  = 9,
    MID_LAYER_9  = 10,
    MID_LAYER_10 = 11,
    MID_LAYER_11 = 12,
    MID_LAYER_12 = 13,
    MID_LAYER_13 = 14,
    MID_LAYER_14 = 15,
    MID_LAYER_15 = 16,
    MID_LAYER_16 = 17,
    MID_LAYER_17 = 18,
    MID_LAYER_18 = 19,
    MID_LAYER_19 = 20,
    MID_LAYER_20 = 21,
    MID_LAYER_21 = 22,
    MID_LAYER_22 = 23,
    MID_LAYER_23 = 24,
    MID_LAYER_24 = 25,
    MID_LAYER_25 = 26,
    MID_LAYER_26 = 27,
    MID_LAYER_27 = 28,
    MID_LAYER_28 = 29,
    MID_LAYER_29 = 30,
    MID_LAYER_30 = 31,
    BOTTOM_LAYER = 32,
 
    TOP_OVERLAY    = 33,
    BOTTOM_OVERLAY = 34,
    TOP_PASTE      = 35,
    BOTTOM_PASTE   = 36,
    TOP_SOLDER     = 37,
    BOTTOM_SOLDER  = 38,
 
    INTERNAL_PLANE_1  = 39,
    INTERNAL_PLANE_2  = 40,
    INTERNAL_PLANE_3  = 41,
    INTERNAL_PLANE_4  = 42,
    INTERNAL_PLANE_5  = 43,
    INTERNAL_PLANE_6  = 44,
    INTERNAL_PLANE_7  = 45,
    INTERNAL_PLANE_8  = 46,
    INTERNAL_PLANE_9  = 47,
    INTERNAL_PLANE_10 = 48,
    INTERNAL_PLANE_11 = 49,
    INTERNAL_PLANE_12 = 50,
    INTERNAL_PLANE_13 = 51,
    INTERNAL_PLANE_14 = 52,
    INTERNAL_PLANE_15 = 53,
    INTERNAL_PLANE_16 = 54,
 
    DRILL_GUIDE    = 55,
    KEEP_OUT_LAYER = 56,
 
    MECHANICAL_1  = 57,
    MECHANICAL_2  = 58,
    MECHANICAL_3  = 59,
    MECHANICAL_4  = 60,
    MECHANICAL_5  = 61,
    MECHANICAL_6  = 62,
    MECHANICAL_7  = 63,
    MECHANICAL_8  = 64,
    MECHANICAL_9  = 65,
    MECHANICAL_10 = 66,
    MECHANICAL_11 = 67,
    MECHANICAL_12 = 68,
    MECHANICAL_13 = 69,
    MECHANICAL_14 = 70,
    MECHANICAL_15 = 71,
    MECHANICAL_16 = 72,
 
    DRILL_DRAWING     = 73,
    MULTI_LAYER       = 74,
    CONNECTIONS       = 75,
    BACKGROUND        = 76,
    DRC_ERROR_MARKERS = 77,
    SELECTIONS        = 78,
    VISIBLE_GRID_1    = 79,
    VISIBLE_GRID_2    = 80,
    PAD_HOLES         = 81,
    VIA_HOLES         = 82,
 
    // V7 format layers
    V7_START = 0x01000000,
 
    V7_COPPER_BASE  = 0x01000000,
    V7_TOP_LAYER    = V7_COPPER_BASE + 1,
    V7_BOTTOM_LAYER = V7_COPPER_BASE + 65535,
 
    V7_MECHANICAL_BASE = 0x01020000,
    V7_MECHANICAL_1    = V7_MECHANICAL_BASE + 1,
    V7_MECHANICAL_17   = V7_MECHANICAL_BASE + 17,
    V7_MECHANICAL_LAST = V7_MECHANICAL_BASE + 65535,
 
    // V8 format layers
    V8_OTHER_BASE         = 0x01030000,
    V8_TOP_OVERLAY        = V8_OTHER_BASE + 6,
    V8_BOTTOM_OVERLAY     = V8_OTHER_BASE + 7,
    V8_TOP_PASTE          = V8_OTHER_BASE + 8,
    V8_BOTTOM_PASTE       = V8_OTHER_BASE + 9,
    V8_TOP_SOLDER         = V8_OTHER_BASE + 10,
    V8_BOTTOM_SOLDER      = V8_OTHER_BASE + 11,
    V8_DRILL_GUIDE        = V8_OTHER_BASE + 12,
    V8_KEEP_OUT_LAYER     = V8_OTHER_BASE + 13,
    V8_DRILL_DRAWING      = V8_OTHER_BASE + 14,
    V8_MULTI_LAYER        = V8_OTHER_BASE + 15,
    V8_CONNECTIONS        = V8_OTHER_BASE + 16,
    V8_BACKGROUND         = V8_OTHER_BASE + 17,
    V8_DRC_ERROR_MARKERS  = V8_OTHER_BASE + 18,
    V8_SELECTIONS         = V8_OTHER_BASE + 19,
    V8_VISIBLE_GRID_1     = V8_OTHER_BASE + 20,
    V8_VISIBLE_GRID_2     = V8_OTHER_BASE + 21,
    V8_PAD_HOLES          = V8_OTHER_BASE + 22,
    V8_VIA_HOLES          = V8_OTHER_BASE + 23,
    V8_TOP_PAD_MASTER     = V8_OTHER_BASE + 24,
    V8_BOTTOM_PAD_MASTER  = V8_OTHER_BASE + 25,
    V8_DRC_DETAIL_MARKERS = V8_OTHER_BASE + 26,
};
 
// Specifies values from LayerKindMapping
enum class ALTIUM_MECHKIND
{
    UNKNOWN = 0,
 
    ASSEMBLY_TOP = 0x01,
    ASSEMBLY_BOT = 0x02,
 
    ASSEMBLY_NOTES = 0x03,
    BOARD = 0x04,
 
    COATING_TOP = 0x05,
    COATING_BOT = 0x06,
 
    COMPONENT_CENTER_TOP = 0x07,
    COMPONENT_CENTER_BOT = 0x08,
 
    COMPONENT_OUTLINE_TOP = 0x09,
    COMPONENT_OUTLINE_BOT = 0x0A,
 
    COURTYARD_TOP = 0x0B,
    COURTYARD_BOT = 0x0C,
 
    DESIGNATOR_TOP = 0x0D,
    DESIGNATOR_BOT = 0x0E,
 
    DIMENSIONS = 0x0F,
    DIMENSIONS_TOP = 0x10,
    DIMENSIONS_BOT = 0x11,
 
    FAB_NOTES = 0x12,
 
    GLUE_POINTS_TOP = 0x13,
    GLUE_POINTS_BOT = 0x14,
 
    GOLD_PLATING_TOP = 0x15,
    GOLD_PLATING_BOT = 0x16,
 
    VALUE_TOP = 0x17,
    VALUE_BOT = 0x18,
 
    V_CUT = 0x19,
 
    BODY_3D_TOP = 0x1A,
    BODY_3D_BOT = 0x1B,
 
    ROUTE_TOOL_PATH = 0x1C,
    SHEET = 0x1D,
    BOARD_SHAPE = 0x1E
};
 
class ALTIUM_BINARY_PARSER;
 
enum class AEXTENDED_PRIMITIVE_INFORMATION_TYPE
{
    UNKNOWN = -1,
 
    MASK
};
 
struct AEXTENDED_PRIMITIVE_INFORMATION
{
    int           primitiveIndex;
    ALTIUM_RECORD primitiveObjectId;
 
    AEXTENDED_PRIMITIVE_INFORMATION_TYPE type;
 
    // Type == Mask
    ALTIUM_MODE pastemaskexpansionmode;
    int32_t     pastemaskexpansionmanual;
    ALTIUM_MODE soldermaskexpansionmode;
    int32_t     soldermaskexpansionmanual;
 
    explicit AEXTENDED_PRIMITIVE_INFORMATION( ALTIUM_BINARY_PARSER& aReader );
};
 
struct ABOARD6_LAYER_STACKUP
{
    uint32_t layerId = 0;
    wxString name;
 
    size_t nextId;
    size_t prevId;
 
    int32_t copperthick;
 
    double   dielectricconst;
    int32_t  dielectricthick;
    wxString dielectricmaterial;
    double   dielectriclosstangent = 0.;
 
    bool            mechenabled = false;
    ALTIUM_MECHKIND mechkind = ALTIUM_MECHKIND::UNKNOWN;
 
    explicit ABOARD6_LAYER_STACKUP( const std::map<wxString, wxString>& aProps, const wxString& aPrefix,
                                    uint32_t aLayerIdFallback );
};
 
struct ALIBRARY
{
    int                                layercount;
    std::vector<ABOARD6_LAYER_STACKUP> stackup;
    std::set<wxString>                 layerNames;
 
    explicit ALIBRARY( ALTIUM_BINARY_PARSER& aReader );
};
 
struct ABOARD6
{
    VECTOR2I sheetpos;
    wxSize   sheetsize;
 
    int                                layercount;
    std::vector<ABOARD6_LAYER_STACKUP> stackup;
    std::set<wxString>                 layerNames;
 
    std::vector<ALTIUM_VERTICE> board_vertices;
 
    explicit ABOARD6( ALTIUM_BINARY_PARSER& aReader );
};
 
struct ACLASS6
{
    wxString name;
    wxString uniqueid;
 
    ALTIUM_CLASS_KIND kind;
 
    std::vector<wxString> names;
 
    explicit ACLASS6( ALTIUM_BINARY_PARSER& aReader );
};
 
struct ACOMPONENT6
{
    ALTIUM_LAYER layer;
    VECTOR2I     position;
    double       rotation;
    bool         locked;
    bool         nameon;
    bool         commenton;
    wxString     sourceUniqueID;
    wxString     sourceHierachicalPath;
    wxString     sourcedesignator;
    wxString     sourcefootprintlibrary;
    wxString     pattern;
    wxString     sourcecomponentlibrary;
    wxString     sourcelibreference;
 
    ALTIUM_TEXT_POSITION nameautoposition;
    ALTIUM_TEXT_POSITION commentautoposition;
 
    explicit ACOMPONENT6( ALTIUM_BINARY_PARSER& aReader );
};
 
struct ADIMENSION6
{
    ALTIUM_LAYER          layer_v6 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER          layer_v7 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER          layer = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_DIMENSION_KIND kind;
 
    wxString textformat;
    wxString textprefix;
    wxString textsuffix;
 
    int32_t height;
    double  angle;
 
    uint32_t linewidth;
    uint32_t textheight;
    uint32_t textlinewidth;
    int32_t  textprecision;
    uint32_t textgap;
    bool     textbold;
    bool     textitalic;
 
    int32_t arrowsize;
 
    ALTIUM_UNIT textunit;
 
    VECTOR2I xy1;
 
    std::vector<VECTOR2I> referencePoint;
    std::vector<VECTOR2I> textPoint;
 
    explicit ADIMENSION6( ALTIUM_BINARY_PARSER& aReader );
};
 
struct AMODEL
{
    wxString name;
    wxString id;
    bool     isEmbedded;
 
    VECTOR3D rotation;
    double   z_offset;
    int32_t  checksum;
 
    explicit AMODEL( ALTIUM_BINARY_PARSER& aReader );
};
 
struct ANET6
{
    wxString name;
 
    explicit ANET6( ALTIUM_BINARY_PARSER& aReader );
};
 
struct APOLYGON6
{
    ALTIUM_LAYER layer_v6 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer_v7 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer = ALTIUM_LAYER::UNKNOWN;
    uint16_t     net;
    bool         locked;
 
    ALTIUM_POLYGON_HATCHSTYLE hatchstyle;
 
    int32_t gridsize;
    int32_t trackwidth;
    int32_t minprimlength;
    bool    useoctagons;
 
    // Note: Altium pour index is the opposite of KiCad zone priority!
    int32_t pourindex;
 
    std::vector<ALTIUM_VERTICE> vertices;
 
    explicit APOLYGON6( ALTIUM_BINARY_PARSER& aReader );
};
 
 
struct ARULE6
{
    wxString name;
    int      priority = 0;
 
    ALTIUM_RULE_KIND kind = ALTIUM_RULE_KIND::UNKNOWN;
 
    wxString scope1expr;
    wxString scope2expr;
 
    // ALTIUM_RULE_KIND::CLEARANCE
    // ALTIUM_RULE_KIND::HOLE_TO_HOLE_CLEARANCE
    int clearanceGap = 0;
 
    // ALTIUM_RULE_KIND::WIDTH
    // ALTIUM_RULE_KIND::HOLE_SIZE
    int minLimit = 0;
    int maxLimit = 0;
 
    // ALTIUM_RULE_KIND::WIDTH
    int preferredWidth = 0;
 
    // ALTIUM_RULE_KIND::ROUTING_VIAS
    int width        = 0;
    int minWidth     = 0;
    int maxWidth     = 0;
    int holeWidth    = 0;
    int minHoleWidth = 0;
    int maxHoleWidth = 0;
 
    // ALTIUM_RULE_KIND::PLANE_CLEARANCE
    int planeclearanceClearance = 0;
 
    // ALTIUM_RULE_KIND::SOLDER_MASK_EXPANSION
    int soldermaskExpansion = 0;
 
    // ALTIUM_RULE_KIND::PASTE_MASK_EXPANSION
    int pastemaskExpansion = 0;
 
    // ALTIUM_RULE_KIND::POLYGON_CONNECT
    int32_t              polygonconnectAirgapwidth          = 0;
    int32_t              polygonconnectReliefconductorwidth = 0;
    int                  polygonconnectReliefentries        = 0;
    ALTIUM_CONNECT_STYLE polygonconnectStyle                = ALTIUM_CONNECT_STYLE::UNKNOWN;
 
    // TODO: implement different types of rules we need to parse
 
    ARULE6() = default;
    explicit ARULE6( ALTIUM_BINARY_PARSER& aReader );
};
 
struct AREGION6
{
    bool is_locked;
    bool is_teardrop;
    bool is_keepout;
 
    bool is_shapebased;
 
    ALTIUM_LAYER layer_v6 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer_v7 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer = ALTIUM_LAYER::UNKNOWN;
    uint16_t     net;
    uint16_t     component;
    uint16_t     polygon;
    uint16_t     subpolyindex;
    uint8_t      keepoutrestrictions;
    uint16_t     holecount;
 
    ALTIUM_REGION_KIND kind; // I assume this means if normal or keepout?
 
    std::vector<ALTIUM_VERTICE>              outline;
    std::vector<std::vector<ALTIUM_VERTICE>> holes;
 
    explicit AREGION6( ALTIUM_BINARY_PARSER& aReader, bool aExtendedVertices );
};
 
struct AARC6
{
    bool is_locked;
    bool is_keepout;
    bool is_polygonoutline;
 
    ALTIUM_LAYER layer_v6 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer_v7 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer = ALTIUM_LAYER::UNKNOWN;
    uint16_t     net;
    uint16_t     component;
    uint16_t     polygon;
    uint16_t     subpolyindex;
    uint8_t      keepoutrestrictions;
    uint32_t     unionindex = 0;
 
    VECTOR2I center;
    uint32_t radius;
    double   startangle;
    double   endangle;
    uint32_t width;
 
    explicit AARC6( ALTIUM_BINARY_PARSER& aReader );
};
 
struct ACOMPONENTBODY6
{
    uint16_t             component = 0;
 
    wxString             body_name;
    int                  kind             = 0;
    int                  subpolyindex     = 0;
    int                  unionindex       = 0;
    int                  arc_resolution   = 0;
    bool                 is_shape_based   = false;
    int                  cavity_height    = 0;
    int                  standoff_height  = 0;
    int                  overall_height   = 0;
    int                  body_projection  = 0;
    int                  body_color_3d    = 0;
    double               body_opacity_3d  = 0.0;
    wxString             identifier;
    wxString             texture;
    int                  texture_center_x = 0;
    int                  texture_center_y = 0;
    int                  texture_size_x   = 0;
    int                  texture_size_y   = 0;
    int                  texture_rotation = 0;
 
    wxString             modelId;
    wxString             modelChecksum;
    bool                 modelIsEmbedded = false;
    wxString             modelName;
    int                  modelType       = 0;
    int                  modelSource     = 0;
    int                  modelSnapCount  = 0;
 
    VECTOR3D             modelPosition;
    VECTOR3D             modelRotation;
    double               rotation = 0.0;
 
    explicit ACOMPONENTBODY6( ALTIUM_BINARY_PARSER& aReader );
};
 
struct APAD6_SIZE_AND_SHAPE
{
    ALTIUM_PAD_HOLE_SHAPE holeshape;
    uint32_t              slotsize;
    double                slotrotation;
 
    wxSize               inner_size[29];
    ALTIUM_PAD_SHAPE     inner_shape[29];
    VECTOR2I             holeoffset[32];
    ALTIUM_PAD_SHAPE_ALT alt_shape[32];
    uint8_t              cornerradius[32];
};
 
struct APAD6
{
    bool is_locked;
    bool is_tent_top;
    bool is_tent_bottom;
    bool is_test_fab_top;
    bool is_test_fab_bottom;
 
    wxString name;
 
    ALTIUM_LAYER layer_v6 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer_v7 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer = ALTIUM_LAYER::UNKNOWN;
    uint16_t     net;
    uint16_t     component;
 
    VECTOR2I position;
    VECTOR2I topsize;
    VECTOR2I midsize;
    VECTOR2I botsize;
    uint32_t holesize;
 
    ALTIUM_PAD_SHAPE topshape;
    ALTIUM_PAD_SHAPE midshape;
    ALTIUM_PAD_SHAPE botshape;
 
    ALTIUM_PAD_MODE padmode;
 
    double          direction;
    bool            plated;
    ALTIUM_MODE     pastemaskexpansionmode;
    int32_t         pastemaskexpansionmanual;
    ALTIUM_MODE     soldermaskexpansionmode;
    int32_t         soldermaskexpansionmanual;
    double          holerotation;
 
    ALTIUM_LAYER tolayer;
    ALTIUM_LAYER fromlayer;
 
    int32_t pad_to_die_length;
    int32_t pad_to_die_delay;
 
    std::unique_ptr<APAD6_SIZE_AND_SHAPE> sizeAndShape;
 
    explicit APAD6( ALTIUM_BINARY_PARSER& aReader );
};
 
struct AVIA6
{
    bool is_locked          = false;
    bool is_tent_top        = false;
    bool is_tent_bottom     = false;
    bool is_test_fab_top    = false;
    bool is_test_fab_bottom = false;
 
    uint16_t net = 0;
 
    VECTOR2I position;
    uint32_t pos_tolerance = 2147483640; // 2147483640 is N/A
    uint32_t neg_tolerance = 2147483640; // 2147483640 is N/A
    uint32_t diameter      = 0;
    uint32_t holesize      = 0;
 
    int32_t  thermal_relief_airgap         = 0;
    uint32_t thermal_relief_conductorcount = 0;
    uint32_t thermal_relief_conductorwidth = 0;
 
    int32_t soldermask_expansion_front  = 0;
    int32_t soldermask_expansion_back   = 0;
    bool    soldermask_expansion_manual = false;
    bool    soldermask_expansion_linked = false;
 
    // When true, the manual solder mask expansion is measured outward from the hole edge rather
    // than from the via land (copper) edge.  Altium "Solder Mask Expansion From The Hole Edge".
    bool    soldermask_expansion_from_hole = false;
 
    ALTIUM_LAYER    layer_start;
    ALTIUM_LAYER    layer_end;
    ALTIUM_PAD_MODE viamode;
 
    // In PAD_MODE::SIMPLE, this is the same as the diameter
    // In PAD_MODE::TOP_MIDDLE_BOTTOM, layer 0 is top, layer 1 is middle, layer 31 is bottom
    // In PAD_MODE::FULL_STACK, layers correspond to the layer number
    uint32_t diameter_by_layer[32]{ 0 };
 
    explicit AVIA6( ALTIUM_BINARY_PARSER& aReader );
};
 
struct ATRACK6
{
    bool is_locked;
    bool is_keepout;
    bool is_polygonoutline;
 
    ALTIUM_LAYER layer_v6 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer_v7 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer = ALTIUM_LAYER::UNKNOWN;
    uint16_t     net;
    uint16_t     component;
    uint16_t     polygon;
    uint16_t     subpolyindex;
    uint8_t      keepoutrestrictions;
    uint32_t     unionindex = 0;
 
    VECTOR2I start;
    VECTOR2I end;
    uint32_t width;
 
    explicit ATRACK6( ALTIUM_BINARY_PARSER& aReader );
};
 
// Interactive length-tuning meander, stored in the SmartUnions stream and referenced by
// copper primitives through their union index.  Altium commits the tuned copper as ordinary
// tracks and arcs, keeping the parametric meander definition here.
struct ASMARTUNION6
{
    int      unionindex = 0;
    bool     is_tuning = false;
    bool     is_diffpair = false;
 
    int      style = 0;
    int32_t  gap = 0;
    int32_t  amplitude = 0;
    int32_t  minamplitude = 0;
    double   mitterradiusratio = 0.0;
    bool     singleside = false;
 
    explicit ASMARTUNION6( ALTIUM_BINARY_PARSER& aReader );
};
 
struct ATEXT6
{
    enum class STROKE_FONT_TYPE
    {
        DEFAULT = 1,
        SANSSERIF = 2,
        SERIF = 3
    };
 
 
    ALTIUM_LAYER layer_v6 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer_v7 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer = ALTIUM_LAYER::UNKNOWN;
    uint16_t     component = 0;
 
    VECTOR2I             position;
    uint32_t             height       = 0;
    double               rotation     = 0.0;
    uint32_t             strokewidth  = 0;
    STROKE_FONT_TYPE     strokefonttype;
 
    bool isBold               = false;
    bool isItalic             = false;
    bool isMirrored           = false;
    bool isInverted           = false;
    bool isInvertedRect       = false;
    bool isFrame              = false;
    bool isOffsetBorder       = false;
    bool isJustificationValid = false;
 
    uint32_t margin_border_width = 0;
    uint32_t textbox_rect_width  = 0;
    uint32_t textbox_rect_height = 0;
    uint32_t text_offset_width   = 0;
 
    // Justification only applies when there is a text box size specified
    // Then, the text is justified within the box
    ALTIUM_TEXT_POSITION textbox_rect_justification = ALTIUM_TEXT_POSITION::CENTER_CENTER;
 
    uint32_t widestring_index = 0;
 
    bool isComment    = false;
    bool isDesignator = false;
 
    ALTIUM_TEXT_TYPE    fonttype;
    wxString            fontname;
    wxString            barcode_fontname;
 
    // Barcode specific parameters
    VECTOR2I            barcode_margin     = VECTOR2I( 0, 0 );
    ALTIUM_BARCODE_TYPE barcode_type       = ALTIUM_BARCODE_TYPE::CODE39;
    bool                barcode_inverted   = false;
    wxString            barcode_name;
    bool                barcode_show_text  = false;
 
    wxString            text;
 
    explicit ATEXT6( ALTIUM_BINARY_PARSER& aReader, std::map<uint32_t, wxString>& aStringTable );
};
 
struct AFILL6
{
    bool is_locked;
    bool is_keepout;
 
    ALTIUM_LAYER layer_v6 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer_v7 = ALTIUM_LAYER::UNKNOWN;
    ALTIUM_LAYER layer = ALTIUM_LAYER::UNKNOWN;
    uint16_t     component;
    uint16_t     net;
    uint8_t      keepoutrestrictions;
 
    VECTOR2I pos1;
    VECTOR2I pos2;
    double   rotation;
 
    explicit AFILL6( ALTIUM_BINARY_PARSER& aReader );
};
 

bool altiumScopeExprMatchesPolygon( const wxString& aExpr );
 

const ARULE6* selectAltiumPolygonRule( const std::vector<ARULE6>& aRulesByPriorityAsc );
 

bool altiumViaSideIsTented( bool aTentFlag, bool aManual, bool aFromHole, uint32_t aHoleSize,
                            int32_t aMaskExpansion, int aLandDiameter );
 
 
#endif //ALTIUM_PARSER_PCB_H