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-2022 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>
 
 
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 class FLASHING
{
 DEFAULT, // Flashing follows connectivity
 ALWAYS_FLASHED, // Always flashed for connectivity
 NEVER_FLASHED, // Never flashed for connectivity
};
 
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 deprecated + 14, ///< show a marker on pads with no nets
 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, 
 
 LAYER_LOCKED_ITEM_SHADOW = GAL_LAYER_ID_START + 39, 
 
 LAYER_CONFLICTS_SHADOW = GAL_LAYER_ID_START + 40, 
 
 // 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_PAGE_LIMITS, 
 
 LAYER_ZONE_START,
 LAYER_ZONE_END = LAYER_ZONE_START + PCB_LAYER_ID_COUNT,
 
 LAYER_BITMAP_START,
 LAYER_BITMAP_END = LAYER_BITMAP_START + PCB_LAYER_ID_COUNT,
 
 GAL_LAYER_ID_END
};
 
#define GAL_LAYER_INDEX( x ) ( x - GAL_LAYER_ID_START )
 
#define BITMAP_LAYER_FOR( boardLayer ) ( LAYER_BITMAP_START + boardLayer )
#define ZONE_LAYER_FOR( boardLayer ) ( LAYER_ZONE_START + boardLayer )
 
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_INTERSHEET_REFS,
 LAYER_NETCLASS_REFS,
 LAYER_DEVICE,
 LAYER_NOTES,
 LAYER_PRIVATE_NOTES,
 LAYER_NOTES_BACKGROUND,
 LAYER_PIN,
 LAYER_SHEET,
 LAYER_SHEETNAME,
 LAYER_SHEETFILENAME,
 LAYER_SHEETFIELDS,
 LAYER_SHEETLABEL,
 LAYER_NOCONNECT,
 LAYER_DANGLING,
 LAYER_ERC_WARN,
 LAYER_ERC_ERR,
 LAYER_ERC_EXCLUSION,
 LAYER_DEVICE_BACKGROUND,
 LAYER_SHEET_BACKGROUND,
 LAYER_SCHEMATIC_GRID,
 LAYER_SCHEMATIC_GRID_AXES,
 LAYER_SCHEMATIC_BACKGROUND,
 LAYER_SCHEMATIC_CURSOR,
 LAYER_HOVERED,
 LAYER_BRIGHTENED,
 LAYER_HIDDEN,
 LAYER_SELECTION_SHADOWS,
 LAYER_SCHEMATIC_DRAWINGSHEET,
 LAYER_SCHEMATIC_PAGE_LIMITS,
 LAYER_BUS_JUNCTION,
 LAYER_SCHEMATIC_AUX_ITEMS,
 LAYER_SCHEMATIC_ANCHOR,
 LAYER_OP_VOLTAGES,
 LAYER_OP_CURRENTS,
 
 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,
 LAYER_GERBVIEW_PAGE_LIMITS,
 
 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 SideSpecificMask();
 
 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& aSequence ) 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( int aLayerId )
{
 return unsigned( aLayerId ) < PCB_LAYER_ID_COUNT;
}
 
inline bool IsPcbLayer( int aLayer )
{
 return aLayer >= F_Cu && aLayer < PCB_LAYER_ID_COUNT;
}
 
inline bool IsCopperLayer( int aLayerId )
{
 return aLayerId >= F_Cu && aLayerId <= B_Cu;
}
 
inline bool IsNonCopperLayer( int aLayerId )
{
 return aLayerId > B_Cu && aLayerId <= PCB_LAYER_ID_COUNT;
}
 
inline bool IsCopperLayer( int aLayerId, bool aIncludeSyntheticCopperLayers )
{
 if( aIncludeSyntheticCopperLayers )
 return !IsNonCopperLayer( aLayerId );
 else
 return IsCopperLayer( aLayerId );
}
 
inline bool IsViaPadLayer( int aLayer )
{
 return aLayer == LAYER_VIA_THROUGH
 || aLayer == LAYER_VIA_MICROVIA
  || aLayer == LAYER_VIA_BBLIND;
}
 
inline bool IsHoleLayer( int 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;
}
 
 
/*
 * IMPORTANT: If a layer is not a front layer that doesn't necessarily mean it's 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( int aLayer )
{
 return aLayer >= NETNAMES_LAYER_INDEX( F_Cu ) && aLayer < NETNAMES_LAYER_ID_END;
}
 
 
inline bool IsZoneFillLayer( int 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( int aLayer )
{
 static std::set<int> 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