layer_ids.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2014 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * Copyright (C) 2010 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2007-2021 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 LAYER_IDS_H
#define LAYER_IDS_H

#include <set>
#include <vector>
#include <bitset>
#include <stdexcept>
#include <wx/string.h>


typedef int LAYER_NUM;

enum PCB_LAYER_ID: int
{
 UNDEFINED_LAYER = -1,
 UNSELECTED_LAYER = -2,

 PCBNEW_LAYER_ID_START = 0,
 F_Cu = PCBNEW_LAYER_ID_START,
 In1_Cu,
 In2_Cu,
 In3_Cu,
 In4_Cu,
 In5_Cu,
 In6_Cu,
 In7_Cu,
 In8_Cu,
 In9_Cu,
 In10_Cu,
 In11_Cu,
 In12_Cu,
 In13_Cu,
 In14_Cu,
 In15_Cu,
 In16_Cu,
 In17_Cu,
 In18_Cu,
 In19_Cu,
 In20_Cu,
 In21_Cu,
 In22_Cu,
 In23_Cu,
 In24_Cu,
 In25_Cu,
 In26_Cu,
 In27_Cu,
 In28_Cu,
 In29_Cu,
 In30_Cu,
 B_Cu, // 31

 B_Adhes,
 F_Adhes,

 B_Paste,
 F_Paste,

 B_SilkS,
 F_SilkS,

 B_Mask,
 F_Mask, // 39

 Dwgs_User,
 Cmts_User,
 Eco1_User,
 Eco2_User,
 Edge_Cuts,
 Margin, // 45

 B_CrtYd,
 F_CrtYd,

 B_Fab,
 F_Fab, // 49

 // User definable layers.
 User_1,
 User_2,
 User_3,
 User_4,
 User_5,
 User_6,
 User_7,
 User_8,
 User_9,

 Rescue, // 59

 // Four reserved layers (60 - 63) for future expansion within the 64 bit integer limit.

 PCB_LAYER_ID_COUNT
};

#define MAX_CU_LAYERS (B_Cu - F_Cu + 1)

enum NETNAMES_LAYER_ID: int
{

 NETNAMES_LAYER_ID_START = PCB_LAYER_ID_COUNT,


 NETNAMES_LAYER_ID_RESERVED = NETNAMES_LAYER_ID_START + PCB_LAYER_ID_COUNT,


 LAYER_PAD_FR_NETNAMES,
 LAYER_PAD_BK_NETNAMES,
 LAYER_PAD_NETNAMES,
 LAYER_VIA_NETNAMES,

 NETNAMES_LAYER_ID_END
};

#define NETNAMES_LAYER_INDEX( layer ) ( NETNAMES_LAYER_ID_START + layer )

enum GAL_LAYER_ID: int
{
 GAL_LAYER_ID_START = NETNAMES_LAYER_ID_END,

 LAYER_VIAS = GAL_LAYER_ID_START + 0, 
 LAYER_VIA_MICROVIA = GAL_LAYER_ID_START + 1, 
 LAYER_VIA_BBLIND = GAL_LAYER_ID_START + 2, 
 LAYER_VIA_THROUGH = GAL_LAYER_ID_START + 3, 
 LAYER_NON_PLATEDHOLES = GAL_LAYER_ID_START + 4, 
 LAYER_MOD_TEXT = GAL_LAYER_ID_START + 5,
// LAYER_MOD_TEXT_BK deprecated + 6,
 LAYER_MOD_TEXT_INVISIBLE = GAL_LAYER_ID_START + 7, 
 LAYER_ANCHOR = GAL_LAYER_ID_START + 8, 
 LAYER_PAD_FR = GAL_LAYER_ID_START + 9, 
 LAYER_PAD_BK = GAL_LAYER_ID_START + 10, 
 LAYER_RATSNEST = GAL_LAYER_ID_START + 11,
 LAYER_GRID = GAL_LAYER_ID_START + 12,
 LAYER_GRID_AXES = GAL_LAYER_ID_START + 13,
 LAYER_NO_CONNECTS = GAL_LAYER_ID_START + 14, 
 LAYER_MOD_FR = GAL_LAYER_ID_START + 15, 
 LAYER_MOD_BK = GAL_LAYER_ID_START + 16, 
 LAYER_MOD_VALUES = GAL_LAYER_ID_START + 17, 
 LAYER_MOD_REFERENCES = GAL_LAYER_ID_START + 18, 
 LAYER_TRACKS = GAL_LAYER_ID_START + 19,
 LAYER_PADS_TH = GAL_LAYER_ID_START + 20, 
 LAYER_PAD_PLATEDHOLES = GAL_LAYER_ID_START + 21, 
 LAYER_VIA_HOLES = GAL_LAYER_ID_START + 22, 
 LAYER_DRC_ERROR = GAL_LAYER_ID_START + 23, 
 LAYER_DRAWINGSHEET = GAL_LAYER_ID_START + 24, 
 LAYER_GP_OVERLAY = GAL_LAYER_ID_START + 25, 
 LAYER_SELECT_OVERLAY = GAL_LAYER_ID_START + 26, 
 LAYER_PCB_BACKGROUND = GAL_LAYER_ID_START + 27, 
 LAYER_CURSOR = GAL_LAYER_ID_START + 28, 
 LAYER_AUX_ITEMS = GAL_LAYER_ID_START + 29, 
 LAYER_DRAW_BITMAPS = GAL_LAYER_ID_START + 30, 

 GAL_LAYER_ID_BITMASK_END = GAL_LAYER_ID_START + 31,

 // Layers in this section have visibility controls but were not present in legacy board files.

 LAYER_PADS = GAL_LAYER_ID_START + 32, 
 LAYER_ZONES = GAL_LAYER_ID_START + 33, 

 LAYER_PAD_HOLEWALLS = GAL_LAYER_ID_START + 34,
 LAYER_VIA_HOLEWALLS = GAL_LAYER_ID_START + 35,
 LAYER_DRC_WARNING = GAL_LAYER_ID_START + 36, 
 LAYER_DRC_EXCLUSION = GAL_LAYER_ID_START + 37, 
 LAYER_MARKER_SHADOWS = GAL_LAYER_ID_START + 38, 

 // Add layers below this point that do not have visibility controls, so don't need explicit
 // enum values

 LAYER_DRAWINGSHEET_PAGE1, 
 LAYER_DRAWINGSHEET_PAGEn, 

 LAYER_ZONE_START,
 LAYER_ZONE_END = LAYER_ZONE_START + PCB_LAYER_ID_COUNT,

 GAL_LAYER_ID_END
};

#define GAL_LAYER_INDEX( x ) ( x - GAL_LAYER_ID_START )

#define ZONE_LAYER_FOR( copperLayer ) ( LAYER_ZONE_START + copperLayer )

constexpr int GAL_LAYER_ID_COUNT = GAL_LAYER_ID_END - GAL_LAYER_ID_START;

inline GAL_LAYER_ID operator++( GAL_LAYER_ID& a )
{
 a = GAL_LAYER_ID( int( a ) + 1 );
 return a;
}

inline GAL_LAYER_ID ToGalLayer( int aInteger )
{
 wxASSERT( aInteger >= GAL_LAYER_ID_START && aInteger <= GAL_LAYER_ID_END );
 return static_cast<GAL_LAYER_ID>( aInteger );
}

inline GAL_LAYER_ID operator+( const GAL_LAYER_ID& a, int b )
{
 GAL_LAYER_ID t = GAL_LAYER_ID( int( a ) + b );
 wxASSERT( t <= GAL_LAYER_ID_END );
 return t;
}

typedef std::bitset<GAL_LAYER_ID_COUNT> GAL_BASE_SET;

class GAL_SET : public GAL_BASE_SET
{
private:
 static constexpr int start = static_cast<int>( GAL_LAYER_ID_START );

public:
 GAL_SET() : std::bitset<GAL_LAYER_ID_COUNT>()
 {
 }

 GAL_SET( const GAL_SET& aOther ) : std::bitset<GAL_LAYER_ID_COUNT>( aOther )
 {
 }

 GAL_SET( const GAL_LAYER_ID* aArray, unsigned aCount );

 GAL_SET& set()
 {
 GAL_BASE_SET::set();
 return *this;
 }

 GAL_SET& set( int aPos, bool aVal = true )
 {
 GAL_BASE_SET::set( aPos, aVal );
 return *this;
 }

 GAL_SET& set( GAL_LAYER_ID aPos, bool aVal = true )
 {
 GAL_BASE_SET::set( static_cast<std::size_t>( aPos ) - start, aVal );
 return *this;
 }

 bool Contains( GAL_LAYER_ID aPos )
 {
 return test( static_cast<std::size_t>( aPos ) - start );
 }

 std::vector<GAL_LAYER_ID> Seq() const;

 static GAL_SET DefaultVisible();
};

enum SCH_LAYER_ID: int
{
 SCH_LAYER_ID_START = GAL_LAYER_ID_END,

 LAYER_WIRE = SCH_LAYER_ID_START,
 LAYER_BUS,
 LAYER_JUNCTION,
 LAYER_LOCLABEL,
 LAYER_GLOBLABEL,
 LAYER_HIERLABEL,
 LAYER_PINNUM,
 LAYER_PINNAM,
 LAYER_REFERENCEPART,
 LAYER_VALUEPART,
 LAYER_FIELDS,
 LAYER_DEVICE,
 LAYER_NOTES,
 LAYER_PIN,
 LAYER_SHEET,
 LAYER_SHEETNAME,
 LAYER_SHEETFILENAME,
 LAYER_SHEETFIELDS,
 LAYER_SHEETLABEL,
 LAYER_NOCONNECT,
 LAYER_DANGLING,
 LAYER_ERC_WARN,
 LAYER_ERC_ERR,
 LAYER_DEVICE_BACKGROUND,
 LAYER_SHEET_BACKGROUND,
 LAYER_SCHEMATIC_GRID,
 LAYER_SCHEMATIC_GRID_AXES,
 LAYER_SCHEMATIC_BACKGROUND,
 LAYER_SCHEMATIC_CURSOR,
 LAYER_BRIGHTENED,
 LAYER_HIDDEN,
 LAYER_SELECTION_SHADOWS,
 LAYER_SCHEMATIC_DRAWINGSHEET,
 LAYER_BUS_JUNCTION,
 LAYER_SCHEMATIC_AUX_ITEMS,
 LAYER_SCHEMATIC_ANCHOR,

 SCH_LAYER_ID_END
};

#define SCH_LAYER_ID_COUNT ( SCH_LAYER_ID_END - SCH_LAYER_ID_START )

#define SCH_LAYER_INDEX( x ) ( x - SCH_LAYER_ID_START )

inline SCH_LAYER_ID operator++( SCH_LAYER_ID& a )
{
 a = SCH_LAYER_ID( int( a ) + 1 );
 return a;
}

// number of draw layers in Gerbview
#define GERBER_DRAWLAYERS_COUNT PCB_LAYER_ID_COUNT

enum GERBVIEW_LAYER_ID: int
{
 GERBVIEW_LAYER_ID_START = SCH_LAYER_ID_END,

 GERBVIEW_LAYER_ID_RESERVED = GERBVIEW_LAYER_ID_START + ( 2 * GERBER_DRAWLAYERS_COUNT ),

 LAYER_DCODES,
 LAYER_NEGATIVE_OBJECTS,
 LAYER_GERBVIEW_GRID,
 LAYER_GERBVIEW_AXES,
 LAYER_GERBVIEW_BACKGROUND,
 LAYER_GERBVIEW_DRAWINGSHEET,

 GERBVIEW_LAYER_ID_END
};

#define GERBER_DRAW_LAYER( x ) ( GERBVIEW_LAYER_ID_START + x )

#define GERBER_DCODE_LAYER( x ) ( GERBER_DRAWLAYERS_COUNT + x )

#define GERBER_DRAW_LAYER_INDEX( x ) ( x - GERBVIEW_LAYER_ID_START )


enum LAYER_3D_ID : int
{
 LAYER_3D_START = GERBVIEW_LAYER_ID_END,

 LAYER_3D_BACKGROUND_BOTTOM,
 LAYER_3D_BACKGROUND_TOP,
 LAYER_3D_BOARD,
 LAYER_3D_COPPER,
 LAYER_3D_SILKSCREEN_BOTTOM,
 LAYER_3D_SILKSCREEN_TOP,
 LAYER_3D_SOLDERMASK_BOTTOM,
 LAYER_3D_SOLDERMASK_TOP,
 LAYER_3D_SOLDERPASTE,

 LAYER_3D_END = LAYER_3D_SOLDERPASTE
};

#define LAYER_ID_COUNT LAYER_3D_END


wxString LayerName( int aLayer );


// Some elements do not have yet a visibility control
// from a dialog, but have a visibility control flag.
// Here is a mask to set them visible, to be sure they are displayed
// after loading a board for instance
#define MIN_VISIBILITY_MASK int( ( 1 << GAL_LAYER_INDEX( LAYER_PAD_PLATEDHOLES ) ) +\
 ( 1 << GAL_LAYER_INDEX( LAYER_VIA_HOLES ) ) +\
 ( 1 << GAL_LAYER_INDEX( LAYER_SELECT_OVERLAY ) ) +\
 ( 1 << GAL_LAYER_INDEX( LAYER_GP_OVERLAY ) ) +\
 ( 1 << GAL_LAYER_INDEX( LAYER_RATSNEST ) ) )


typedef std::vector<PCB_LAYER_ID> BASE_SEQ;


class LSEQ : public BASE_SEQ
{
 unsigned m_index;

public:

 LSEQ() :
 m_index( 0 )
 {}

 template <class InputIterator>
 LSEQ( InputIterator aStart, InputIterator aEnd ) :
 BASE_SEQ( aStart, aEnd ), m_index( 0 )
 {}

 void Rewind() { m_index = 0; }

 void operator ++ () { ++m_index; } // returns nothing, used in simple statements only.

 void operator ++ (int) { ++m_index; }

 operator bool () { return m_index < size(); }

 PCB_LAYER_ID operator * () const
 {
 return at( m_index ); // throws std::out_of_range
 }
};


typedef std::bitset<PCB_LAYER_ID_COUNT> BASE_SET;


class LSET : public BASE_SET
{
public:

 // The constructor flavors are carefully chosen to prevent LSET( int ) from compiling.
 // That excludes "LSET s = 0;" and excludes "LSET s = -1;", etc.
 // LSET s = 0; needs to be removed from the code, this accomplishes that.
 // Remember LSET( PCB_LAYER_ID(0) ) sets bit 0, so "LSET s = 0;" is illegal
 // to prevent that surprise. Therefore LSET's constructor suite is significantly
 // different than the base class from which it is derived.

 // Other member functions (non-constructor functions) are identical to the base
 // class's and therefore are re-used from the base class.

 LSET() :
 BASE_SET() // all bits are set to zero in BASE_SET()
 {
 }

 LSET( const BASE_SET& aOther ) :
 BASE_SET( aOther )
 {
 }

 LSET( PCB_LAYER_ID aLayer ) : // PCB_LAYER_ID deliberately excludes int and relatives
 BASE_SET()
 {
 set( aLayer );
 }

 LSET( const PCB_LAYER_ID* aArray, unsigned aCount );

 LSET( unsigned aIdCount, int aFirst, ... ); // args chosen to prevent LSET( int ) from compiling

 bool Contains( PCB_LAYER_ID aLayer )
 {
 try
 {
 return test( aLayer );
 }
 catch( std::out_of_range& )
 {
 return false;
 }
 }

 static const wxChar* Name( PCB_LAYER_ID aLayerId );

 static LSET InternalCuMask();

 static LSET FrontAssembly();

 static LSET BackAssembly();

 static LSET AllCuMask( int aCuLayerCount = MAX_CU_LAYERS );

 static LSET ExternalCuMask();

 static LSET AllNonCuMask();

 static LSET AllLayersMask();

 static LSET FrontTechMask();

 static LSET FrontBoardTechMask();

 static LSET BackTechMask();

 static LSET BackBoardTechMask();

 static LSET AllTechMask();

 static LSET AllBoardTechMask();

 static LSET FrontMask();

 static LSET BackMask();

 static LSET UserMask();

 static LSET PhysicalLayersMask();

 static LSET UserDefinedLayers();

 static LSET ForbiddenFootprintLayers();

 LSEQ CuStack() const;

 LSEQ Technicals( LSET aSubToOmit = LSET() ) const;

 LSEQ Users() const;

 LSEQ TechAndUserUIOrder() const;

 LSEQ UIOrder() const;

 LSEQ Seq( const PCB_LAYER_ID* aWishListSequence, unsigned aCount ) const;

 LSEQ Seq() const;

 LSEQ SeqStackupBottom2Top() const;

 std::string FmtHex() const;

 int ParseHex( const char* aStart, int aCount );

 std::string FmtBin() const;

 PCB_LAYER_ID ExtractLayer() const;

private:

 LSET( unsigned long __val )
 {
 // not usable, it's private.
 }
};


inline bool IsValidLayer( LAYER_NUM aLayerId )
{
 return unsigned( aLayerId ) < PCB_LAYER_ID_COUNT;
}

inline bool IsPcbLayer( LAYER_NUM aLayer )
{
 return aLayer >= F_Cu && aLayer < PCB_LAYER_ID_COUNT;
}

inline bool IsCopperLayer( LAYER_NUM aLayerId )
{
 return aLayerId >= F_Cu && aLayerId <= B_Cu;
}

inline bool IsNonCopperLayer( LAYER_NUM aLayerId )
{
 return aLayerId > B_Cu && aLayerId <= PCB_LAYER_ID_COUNT;
}

inline bool IsCopperLayer( LAYER_NUM aLayerId, bool aIncludeSyntheticCopperLayers )
{
 if( aIncludeSyntheticCopperLayers )
 return !IsNonCopperLayer( aLayerId );
 else
 return IsCopperLayer( aLayerId );
}

inline bool IsViaPadLayer( LAYER_NUM aLayer )
{
 return aLayer == LAYER_VIA_THROUGH
 || aLayer == LAYER_VIA_MICROVIA
 || aLayer == LAYER_VIA_BBLIND;
}

inline bool IsHoleLayer( LAYER_NUM aLayer )
{
 return aLayer == LAYER_VIA_HOLES
 || aLayer == LAYER_VIA_HOLEWALLS
 || aLayer == LAYER_PAD_PLATEDHOLES
 || aLayer == LAYER_PAD_HOLEWALLS
 || aLayer == LAYER_NON_PLATEDHOLES;
}

inline bool IsUserLayer( PCB_LAYER_ID aLayerId )
{
 return aLayerId >= Dwgs_User && aLayerId <= Eco2_User;
}

/*
 @todo Where does this comment actually belong?

 IMPORTANT: If a layer is not a front layer not necessarily is true
 the converse. The same hold for a back layer.
 So a layer can be:
 - Front
 - Back
 - Neither (internal or auxiliary)

 The check most frequent is for back layers, since it involves flips
*/


inline bool IsFrontLayer( PCB_LAYER_ID aLayerId )
{
 switch( aLayerId )
 {
 case F_Cu:
 case F_Adhes:
 case F_Paste:
 case F_SilkS:
 case F_Mask:
 case F_CrtYd:
 case F_Fab:
 return true;
 default:
 ;
 }

 return false;
}


inline bool IsBackLayer( PCB_LAYER_ID aLayerId )
{
 switch( aLayerId )
 {
 case B_Cu:
 case B_Adhes:
 case B_Paste:
 case B_SilkS:
 case B_Mask:
 case B_CrtYd:
 case B_Fab:
 return true;
 default:
 ;
 }

 return false;
}


PCB_LAYER_ID FlipLayer( PCB_LAYER_ID aLayerId, int aCopperLayersCount = 0 );

LSET FlipLayerMask( LSET aMask, int aCopperLayersCount = 0 );


inline int GetNetnameLayer( int aLayer )
{
 if( IsCopperLayer( aLayer ) )
 return NETNAMES_LAYER_INDEX( aLayer );
 else if( aLayer == LAYER_PADS_TH )
 return LAYER_PAD_NETNAMES;
 else if( aLayer == LAYER_PAD_FR )
 return LAYER_PAD_FR_NETNAMES;
 else if( aLayer == LAYER_PAD_BK )
 return LAYER_PAD_BK_NETNAMES;
 else if( IsViaPadLayer( aLayer ) )
 return LAYER_VIA_NETNAMES;

 // Fallback
 return Cmts_User;
}

inline bool IsNetnameLayer( LAYER_NUM aLayer )
{
 return aLayer >= NETNAMES_LAYER_INDEX( F_Cu ) &&
 aLayer < NETNAMES_LAYER_ID_END;
}


inline bool IsZoneLayer( LAYER_NUM aLayer )
{
 return aLayer >= LAYER_ZONE_START && aLayer <= LAYER_ZONE_END;
}


inline bool IsDCodeLayer( int aLayer )
{
 return aLayer >= (GERBVIEW_LAYER_ID_START + GERBER_DRAWLAYERS_COUNT) &&
 aLayer < (GERBVIEW_LAYER_ID_START + (2 * GERBER_DRAWLAYERS_COUNT));
}


inline bool IsNetCopperLayer( LAYER_NUM aLayer )
{
 static std::set<LAYER_NUM> netCopperLayers =
 {
 LAYER_PAD_FR,
 LAYER_PAD_BK,
 LAYER_PADS_TH,
 LAYER_PAD_HOLEWALLS,
 LAYER_VIA_THROUGH,
 LAYER_VIA_BBLIND,
 LAYER_VIA_MICROVIA,
 LAYER_VIA_HOLEWALLS
 };

 return IsCopperLayer( aLayer ) || netCopperLayers.count( aLayer );
}


PCB_LAYER_ID ToLAYER_ID( int aLayer );

#endif // LAYER_IDS_H