Horizon
layers_id_colors_and_visibility.h
Go to the documentation of this file.
1 /*
2  * This program source code file is part of KiCad, a free EDA CAD application.
3  *
4  * Copyright (C) 2014 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
5  * Copyright (C) 2010 Jean-Pierre Charras, jp.charras at wanadoo.fr
6  * Copyright (C) 2007-2017 KiCad Developers, see AUTHORS.txt for contributors.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, you may find one here:
20  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
21  * or you may search the http://www.gnu.org website for the version 2 license,
22  * or you may write to the Free Software Foundation, Inc.,
23  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
24  */
25 
31 #ifndef LAYERS_ID_AND_VISIBILITY_H_
32 #define LAYERS_ID_AND_VISIBILITY_H_
33 
34 #include <vector>
35 #include <bitset>
36 //#include <wx/string.h>
37 //#include <macros.h>
38 
39 
46 typedef int LAYER_NUM;
47 
71 enum PCB_LAYER_ID: int
72 {
73  UNDEFINED_LAYER = -1,
74  UNSELECTED_LAYER = -2,
75 
76  F_Cu = 0, // 0
77  In1_Cu,
78  In2_Cu,
79  In3_Cu,
80  In4_Cu,
81  In5_Cu,
82  In6_Cu,
83  In7_Cu,
84  In8_Cu,
85  In9_Cu,
86  In10_Cu,
87  In11_Cu,
88  In12_Cu,
89  In13_Cu,
90  In14_Cu,
91  In15_Cu,
92  In16_Cu,
93  In17_Cu,
94  In18_Cu,
95  In19_Cu,
96  In20_Cu,
97  In21_Cu,
98  In22_Cu,
99  In23_Cu,
100  In24_Cu,
101  In25_Cu,
102  In26_Cu,
103  In27_Cu,
104  In28_Cu,
105  In29_Cu,
106  In30_Cu,
107  B_Cu, // 31
108 
109  B_Adhes,
110  F_Adhes,
111 
112  B_Paste,
113  F_Paste,
114 
115  B_SilkS,
116  F_SilkS,
117 
118  B_Mask,
119  F_Mask,
120 
121  Dwgs_User,
122  Cmts_User,
123  Eco1_User,
124  Eco2_User,
125  Edge_Cuts,
126  Margin,
127 
128  B_CrtYd,
129  F_CrtYd,
130 
131  B_Fab,
132  F_Fab,
133 
134  PCB_LAYER_ID_COUNT
135 };
136 
137 #define MAX_CU_LAYERS (B_Cu - F_Cu + 1)
138 
141 {
142 
143  NETNAMES_LAYER_ID_START = PCB_LAYER_ID_COUNT,
144 
146 
147  NETNAMES_LAYER_ID_RESERVED = NETNAMES_LAYER_ID_START + PCB_LAYER_ID_COUNT,
148 
150 
152  LAYER_PAD_BK_NETNAMES,
153  LAYER_PADS_NETNAMES,
154  LAYER_VIAS_NETNAMES,
155 
156  NETNAMES_LAYER_ID_END
157 };
158 
160 #define NETNAMES_LAYER_INDEX( layer ) ( NETNAMES_LAYER_ID_START + layer )
161 
164 enum GAL_LAYER_ID: int
165 {
166  GAL_LAYER_ID_START = NETNAMES_LAYER_ID_END,
167 
168  LAYER_VIAS = GAL_LAYER_ID_START,
173  LAYER_MOD_TEXT_FR,
174  LAYER_MOD_TEXT_BK,
179  LAYER_RATSNEST,
180  LAYER_GRID,
181  LAYER_GRID_AXES,
187  LAYER_TRACKS,
194 
198 
200 
202 };
203 
205 #define GAL_LAYER_INDEX( x ) ( x - GAL_LAYER_ID_START )
206 
207 inline GAL_LAYER_ID operator++( GAL_LAYER_ID& a )
208 {
209  a = GAL_LAYER_ID( int( a ) + 1 );
210  return a;
211 }
212 
214 inline GAL_LAYER_ID operator+( const GAL_LAYER_ID& a, int b )
215 {
216  GAL_LAYER_ID t = GAL_LAYER_ID( int( a ) + b );
217  // wxASSERT( t <= GAL_LAYER_ID_END );
218  return t;
219 }
220 
222 enum SCH_LAYER_ID: int
223 {
224  SCH_LAYER_ID_START = GAL_LAYER_ID_END,
225 
226  LAYER_WIRE = SCH_LAYER_ID_START,
227  LAYER_BUS,
228  LAYER_JUNCTION,
229  LAYER_LOCLABEL,
230  LAYER_GLOBLABEL,
231  LAYER_HIERLABEL,
232  LAYER_PINNUM,
233  LAYER_PINNAM,
234  LAYER_REFERENCEPART,
235  LAYER_VALUEPART,
236  LAYER_FIELDS,
237  LAYER_DEVICE,
238  LAYER_NOTES,
239  LAYER_NETNAM,
240  LAYER_PIN,
241  LAYER_SHEET,
242  LAYER_SHEETNAME,
243  LAYER_SHEETFILENAME,
244  LAYER_SHEETLABEL,
245  LAYER_NOCONNECT,
246  LAYER_ERC_WARN,
247  LAYER_ERC_ERR,
248  LAYER_DEVICE_BACKGROUND,
249  LAYER_SCHEMATIC_GRID,
250  LAYER_SCHEMATIC_BACKGROUND,
251  LAYER_BRIGHTENED,
252 
253  SCH_LAYER_ID_END
254 };
255 
256 #define SCH_LAYER_ID_COUNT ( SCH_LAYER_ID_END - SCH_LAYER_ID_START )
257 
258 #define SCH_LAYER_INDEX( x ) ( x - SCH_LAYER_ID_START )
259 
260 inline SCH_LAYER_ID operator++( SCH_LAYER_ID& a )
261 {
262  a = SCH_LAYER_ID( int( a ) + 1 );
263  return a;
264 }
265 
266 // number of draw layers in Gerbview
267 #define GERBER_DRAWLAYERS_COUNT 32
268 
271 {
272  GERBVIEW_LAYER_ID_START = SCH_LAYER_ID_END,
273 
275  GERBVIEW_LAYER_ID_RESERVED = GERBVIEW_LAYER_ID_START + GERBER_DRAWLAYERS_COUNT,
276 
277  LAYER_DCODES,
278  LAYER_NEGATIVE_OBJECTS,
279  LAYER_GERBVIEW_GRID,
280  LAYER_GERBVIEW_AXES,
281  LAYER_GERBVIEW_BACKGROUND,
282 
283  GERBVIEW_LAYER_ID_END
284 };
285 
287 #define LAYER_ID_COUNT GERBVIEW_LAYER_ID_END
288 
289 
290 // Some elements do not have yet a visibility control
291 // from a dialog, but have a visibility control flag.
292 // Here is a mask to set them visible, to be sure they are displayed
293 // after loading a board for instance
294 #define MIN_VISIBILITY_MASK int( (1 << GAL_LAYER_INDEX( LAYER_TRACKS ) ) +\
295  ( 1 << GAL_LAYER_INDEX( LAYER_PADS ) ) +\
296  ( 1 << GAL_LAYER_INDEX( LAYER_PADS_HOLES ) ) +\
297  ( 1 << GAL_LAYER_INDEX( LAYER_VIAS_HOLES ) ) +\
298  ( 1 << GAL_LAYER_INDEX( LAYER_DRC ) ) +\
299  ( 1 << GAL_LAYER_INDEX( LAYER_WORKSHEET ) ) +\
300  ( 1 << GAL_LAYER_INDEX( LAYER_GP_OVERLAY ) ) )
301 
302 
304 typedef std::vector<PCB_LAYER_ID> BASE_SEQ;
305 
306 
324 class LSEQ : public BASE_SEQ
325 {
326  unsigned m_index;
327 
328 public:
329 
330  LSEQ() :
331  m_index( 0 )
332  {}
333 
334  template <class InputIterator>
335  LSEQ( InputIterator aStart, InputIterator aEnd ) :
336  BASE_SEQ( aStart, aEnd ), m_index( 0 )
337  {}
338 
339  void Rewind() { m_index = 0; }
340 
341  void operator ++ () { ++m_index; } // returns nothing, used in simple statements only.
342 
343  void operator ++ (int) { ++m_index; }
344 
345  operator bool () { return m_index < size(); }
346 
347  PCB_LAYER_ID operator * () const
348  {
349  return at( m_index ); // throws std::out_of_range
350  }
351 };
352 
353 
354 typedef std::bitset<PCB_LAYER_ID_COUNT> BASE_SET;
355 
356 
364 class LSET : public BASE_SET
365 {
366 public:
367 
368  // The constructor flavors are carefully chosen to prevent LSET( int ) from compiling.
369  // That excludes "LSET s = 0;" and excludes "LSET s = -1;", etc.
370  // LSET s = 0; needs to be removed from the code, this accomplishes that.
371  // Remember LSET( PCB_LAYER_ID(0) ) sets bit 0, so "LSET s = 0;" is illegal
372  // to prevent that surprize. Therefore LSET's constructor suite is significantly
373  // different than the base class from which it is derived.
374 
375  // Other member functions (non-constructor functions) are identical to the base
376  // class's and therefore are re-used from the base class.
377 
382  LSET() :
383  BASE_SET() // all bits are set to zero in BASE_SET()
384  {
385  }
386 
387  LSET( const BASE_SET& aOther ) :
388  BASE_SET( aOther )
389  {
390  }
391 
407  LSET( PCB_LAYER_ID aLayer ) : // PCB_LAYER_ID deliberately exludes int and relatives
408  BASE_SET()
409  {
410  set( aLayer );
411  }
412 
417  LSET( const PCB_LAYER_ID* aArray, unsigned aCount );
418 
431  LSET( unsigned aIdCount, int aFirst, ... ); // args chosen to prevent LSET( int ) from compiling
432 
437  static const char* Name( PCB_LAYER_ID aLayerId );
438 
444  static LSET InternalCuMask();
445 
450  static LSET AllCuMask( int aCuLayerCount = MAX_CU_LAYERS );
451 
456  static LSET ExternalCuMask();
457 
462  static LSET AllNonCuMask();
463 
464  static LSET AllLayersMask();
465 
470  static LSET FrontTechMask();
471 
477  static LSET FrontBoardTechMask();
478 
483  static LSET BackTechMask();
484 
490  static LSET BackBoardTechMask();
491 
496  static LSET AllTechMask();
497 
502  static LSET AllBoardTechMask();
503 
508  static LSET FrontMask();
509 
514  static LSET BackMask();
515 
516  static LSET UserMask();
517 
518 
525  LSEQ CuStack() const;
526 
533  LSEQ Technicals( LSET aSubToOmit = LSET() ) const;
534 
536  LSEQ Users() const;
537 
538  LSEQ UIOrder() const;
539 
548  LSEQ Seq( const PCB_LAYER_ID* aWishListSequence, unsigned aCount ) const;
549 
557  LSEQ Seq() const;
558 
564  LSEQ SeqStackupBottom2Top() const;
565 
570  std::string FmtHex() const;
571 
580  int ParseHex( const char* aStart, int aCount );
581 
586  std::string FmtBin() const;
587 
592  PCB_LAYER_ID ExtractLayer() const;
593 
594 private:
595 
597  LSET( unsigned long __val )
598  {
599  // not usable, it's private.
600  }
601 };
602 
611 inline bool IsValidLayer( LAYER_NUM aLayerId )
612 {
613  return unsigned( aLayerId ) < PCB_LAYER_ID_COUNT;
614 }
615 
622 inline bool IsPcbLayer( LAYER_NUM aLayer )
623 {
624  return aLayer >= F_Cu && aLayer < PCB_LAYER_ID_COUNT;
625 }
626 
633 inline bool IsCopperLayer( LAYER_NUM aLayerId )
634 {
635  return aLayerId >= F_Cu && aLayerId <= B_Cu;
636 }
637 
644 inline bool IsNonCopperLayer( LAYER_NUM aLayerId )
645 {
646  return aLayerId > B_Cu && aLayerId <= PCB_LAYER_ID_COUNT;
647 }
648 
655 inline bool IsUserLayer( PCB_LAYER_ID aLayerId )
656 {
657  return aLayerId >= Dwgs_User && aLayerId <= Eco2_User;
658 }
659 
660 /* IMPORTANT: If a layer is not a front layer not necessarily is true
661  the converse. The same hold for a back layer.
662  So a layer can be:
663  - Front
664  - Back
665  - Neither (internal or auxiliary)
666 
667  The check most frequent is for back layers, since it involves flips */
668 
669 
673 inline bool IsFrontLayer( PCB_LAYER_ID aLayerId )
674 {
675  switch( aLayerId )
676  {
677  case F_Cu:
678  case F_Adhes:
679  case F_Paste:
680  case F_SilkS:
681  case F_Mask:
682  case F_CrtYd:
683  case F_Fab:
684  return true;
685  default:
686  ;
687  }
688 
689  return false;
690 }
691 
692 
696 inline bool IsBackLayer( PCB_LAYER_ID aLayerId )
697 {
698  switch( aLayerId )
699  {
700  case B_Cu:
701  case B_Adhes:
702  case B_Paste:
703  case B_SilkS:
704  case B_Mask:
705  case B_CrtYd:
706  case B_Fab:
707  return true;
708  default:
709  ;
710  }
711 
712  return false;
713 }
714 
715 
726 PCB_LAYER_ID FlipLayer( PCB_LAYER_ID aLayerId, int aCopperLayersCount = 0 );
727 
736 LSET FlipLayerMask( LSET aMask, int aCopperLayersCount = 0 );
737 
738 
742 inline int GetNetnameLayer( int aLayer )
743 {
744  if( IsCopperLayer( aLayer ) )
745  return NETNAMES_LAYER_INDEX( aLayer );
746  else if( aLayer == LAYER_PADS )
747  return LAYER_PADS_NETNAMES;
748  else if( aLayer == LAYER_PAD_FR )
749  return LAYER_PAD_FR_NETNAMES;
750  else if( aLayer == LAYER_PAD_BK )
751  return LAYER_PAD_BK_NETNAMES;
752  else if( aLayer >= LAYER_VIA_MICROVIA && aLayer <= LAYER_VIA_THROUGH )
753  return LAYER_VIAS_NETNAMES;
754 
755  // Fallback
756  return Cmts_User;
757 }
758 
765 inline bool IsNetnameLayer( LAYER_NUM aLayer )
766 {
767  return aLayer >= NETNAMES_LAYER_INDEX( F_Cu ) &&
768  aLayer < NETNAMES_LAYER_ID_END;
769 }
770 
771 
772 PCB_LAYER_ID ToLAYER_ID( int aLayer );
773 
774 #endif // LAYERS_ID_AND_VISIBILITY_H_
GAL_LAYER_ID_BITMASK_END
This is the end of the layers used for visibility bitmasks in Pcbnew There can be at most 32 layers a...
Definition: layers_id_colors_and_visibility.h:197
IsNetnameLayer
bool IsNetnameLayer(LAYER_NUM aLayer)
Function IsNetnameLayer tests whether a layer is a netname layer.
Definition: layers_id_colors_and_visibility.h:765
LAYER_WORKSHEET
worksheet frame
Definition: layers_id_colors_and_visibility.h:192
LAYER_VIA_BBLIND
to draw blind/buried vias
Definition: layers_id_colors_and_visibility.h:170
LSET::FrontMask
static LSET FrontMask()
Function FrontMask returns a mask holding all technical layers and the external CU layer on front sid...
LSEQ
Class LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
Definition: layers_id_colors_and_visibility.h:324
LSET::FmtBin
std::string FmtBin() const
Function FmtBin returns a binary string showing contents of this LSEQ.
LSET::Name
static const char * Name(PCB_LAYER_ID aLayerId)
Function Name returns the fixed name association with aLayerId.
GAL_LAYER_ID_END
Add new GAL layers here.
Definition: layers_id_colors_and_visibility.h:201
LAYER_MOD_BK
show modules on back
Definition: layers_id_colors_and_visibility.h:184
LAYER_NO_CONNECTS
show a marker on pads with no nets
Definition: layers_id_colors_and_visibility.h:182
LSET::LSET
LSET()
Constructor LSET() creates an empty (cleared) set.
Definition: layers_id_colors_and_visibility.h:382
LAYER_VIAS_HOLES
to draw via holes (pad holes do not use this layer)
Definition: layers_id_colors_and_visibility.h:190
LSET::BackTechMask
static LSET BackTechMask()
Function BackTechMask returns a mask holding all technical layers (no CU layer) on back side.
LSET::FmtHex
std::string FmtHex() const
Function FmtHex returns a hex string showing contents of this LSEQ.
LAYER_MOD_VALUES
show modules values (when texts are visibles)
Definition: layers_id_colors_and_visibility.h:185
GERBVIEW_LAYER_ID
GERBVIEW_LAYER_ID
GerbView draw layers.
Definition: layers_id_colors_and_visibility.h:270
LAYER_PAD_BK
smd pads, back layer
Definition: layers_id_colors_and_visibility.h:178
LSET::ExternalCuMask
static LSET ExternalCuMask()
Function ExternalCuMask returns a mask holding the Front and Bottom layers.
LAYER_DRC
drc markers
Definition: layers_id_colors_and_visibility.h:191
IsCopperLayer
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
Definition: layers_id_colors_and_visibility.h:633
IsBackLayer
bool IsBackLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a back layer.
Definition: layers_id_colors_and_visibility.h:696
LAYER_MOD_FR
show modules on front
Definition: layers_id_colors_and_visibility.h:183
LSET::InternalCuMask
static LSET InternalCuMask()
Function InternalCuMask() returns a complete set of internal copper layers, which is all Cu layers ex...
LSET::FrontTechMask
static LSET FrontTechMask()
Function FrontTechMask returns a mask holding all technical layers (no CU layer) on front side.
NETNAMES_LAYER_INDEX
#define NETNAMES_LAYER_INDEX(layer)
Macro for obtaining netname layer for a given PCB layer.
Definition: layers_id_colors_and_visibility.h:160
LSET::ExtractLayer
PCB_LAYER_ID ExtractLayer() const
Find the first set PCB_LAYER_ID.
IsPcbLayer
bool IsPcbLayer(LAYER_NUM aLayer)
Function IsPcbLayer tests whether a layer is a valid layer for pcbnew.
Definition: layers_id_colors_and_visibility.h:622
LAYER_PADS
multilayer pads, usually with holes
Definition: layers_id_colors_and_visibility.h:188
LAYER_VIA_THROUGH
to draw usual through hole vias
Definition: layers_id_colors_and_visibility.h:171
LSET::AllBoardTechMask
static LSET AllBoardTechMask()
Function AllTechMask returns a mask holding board technical layers (no CU layer) on both side.
LSET::ParseHex
int ParseHex(const char *aStart, int aCount)
Function ParseHex understands the output of FmtHex() and replaces this set's values with those given ...
LAYER_NUM
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
Definition: layers_id_colors_and_visibility.h:46
SCH_LAYER_ID
SCH_LAYER_ID
Eeschema drawing layers.
Definition: layers_id_colors_and_visibility.h:222
IsUserLayer
bool IsUserLayer(PCB_LAYER_ID aLayerId)
Function IsUserLayer tests whether a layer is a non copper and a non tech layer.
Definition: layers_id_colors_and_visibility.h:655
GetNetnameLayer
int GetNetnameLayer(int aLayer)
Returns a netname layer corresponding to the given layer.
Definition: layers_id_colors_and_visibility.h:742
LSET::AllNonCuMask
static LSET AllNonCuMask()
Function AllNonCuMask returns a mask holding all layer minus CU layers.
LSET::CuStack
LSEQ CuStack() const
Function CuStack returns a sequence of copper layers in starting from the front/top and extending to ...
IsNonCopperLayer
bool IsNonCopperLayer(LAYER_NUM aLayerId)
Function IsNonCopperLayer tests whether a layer is a non copper layer.
Definition: layers_id_colors_and_visibility.h:644
LAYER_PADS_HOLES
to draw pad holes (plated or not plated)
Definition: layers_id_colors_and_visibility.h:189
NETNAMES_LAYER_ID
NETNAMES_LAYER_ID
Dedicated layers for net names used in Pcbnew.
Definition: layers_id_colors_and_visibility.h:140
LSET::SeqStackupBottom2Top
LSEQ SeqStackupBottom2Top() const
Function SeqStackBottom2Top returns the sequence that is typical for a bottom-to-top stack-up.
FlipLayerMask
LSET FlipLayerMask(LSET aMask, int aCopperLayersCount=0)
Calculate the mask layer when flipping a footprint BACK and FRONT copper layers, mask,...
LSET::AllTechMask
static LSET AllTechMask()
Function AllTechMask returns a mask holding all technical layers (no CU layer) on both side.
LAYER_GP_OVERLAY
general purpose overlay
Definition: layers_id_colors_and_visibility.h:193
LSET::FrontBoardTechMask
static LSET FrontBoardTechMask()
Function FrontBoardTechMask returns a mask holding technical layers used in a board fabrication (no C...
LSET::Users
LSEQ Users() const
*_User layers.
FlipLayer
PCB_LAYER_ID FlipLayer(PCB_LAYER_ID aLayerId, int aCopperLayersCount=0)
Function FlippedLayerNumber.
operator+
GAL_LAYER_ID operator+(const GAL_LAYER_ID &a, int b)
Used for via types.
Definition: layers_id_colors_and_visibility.h:214
GERBVIEW_LAYER_ID_RESERVED
GerbView draw layers.
Definition: layers_id_colors_and_visibility.h:275
LAYER_NON_PLATED
handle color for not plated holes
Definition: layers_id_colors_and_visibility.h:172
IsFrontLayer
bool IsFrontLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a front layer.
Definition: layers_id_colors_and_visibility.h:673
LSET::Seq
LSEQ Seq() const
Function Seq returns a LSEQ from this LSET in ascending PCB_LAYER_ID order.
LSET::LSET
LSET(PCB_LAYER_ID aLayer)
Constructor LSET( PCB_LAYER_ID ) takes a PCB_LAYER_ID and sets that bit.
Definition: layers_id_colors_and_visibility.h:407
LSET::AllCuMask
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Function AllCuMask returns a mask holding the requested number of Cu PCB_LAYER_IDs.
LAYER_PAD_FR_NETNAMES
Additional netnames layers (not associated with a PCB layer)
Definition: layers_id_colors_and_visibility.h:151
LSET::BackBoardTechMask
static LSET BackBoardTechMask()
Function BackBoardTechMask returns a mask holding technical layers used in a board fabrication (no CU...
LAYER_MOD_TEXT_INVISIBLE
text marked as invisible
Definition: layers_id_colors_and_visibility.h:175
LSET
Class LSET is a set of PCB_LAYER_IDs.
Definition: layers_id_colors_and_visibility.h:364
LSET::BackMask
static LSET BackMask()
Function BackMask returns a mask holding all technical layers and the external CU layer on back side.
BASE_SEQ
std::vector< PCB_LAYER_ID > BASE_SEQ
A sequence of layers, a sequence provides a certain order.
Definition: layers_id_colors_and_visibility.h:304
NETNAMES_LAYER_ID_RESERVED
Reserved space for board layer netnames.
Definition: layers_id_colors_and_visibility.h:147
IsValidLayer
bool IsValidLayer(LAYER_NUM aLayerId)
Function IsValidLayer tests whether a given integer is a valid layer index, i.e.
Definition: layers_id_colors_and_visibility.h:611
LAYER_VIA_MICROVIA
to draw micro vias
Definition: layers_id_colors_and_visibility.h:169
LAYER_ANCHOR
anchor of items having an anchor point (texts, footprints)
Definition: layers_id_colors_and_visibility.h:176
PCB_LAYER_ID
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layers_id_colors_and_visibility.h:71
LSET::Technicals
LSEQ Technicals(LSET aSubToOmit=LSET()) const
Function Technicals returns a sequence of technical layers.
GAL_LAYER_ID
GAL_LAYER_ID
GAL layers are "virtual" layers, i.e.
Definition: layers_id_colors_and_visibility.h:164
LAYER_MOD_REFERENCES
show modules references (when texts are visibles)
Definition: layers_id_colors_and_visibility.h:186
LAYER_PAD_FR
smd pads, front layer
Definition: layers_id_colors_and_visibility.h:177