
 // -*- C++ -*-


 namespace Hurricane {

 /*! \class        BasicLayer
  *  \brief        BasicLayer description (\b API)
  *
  *                For a more complete description of the Layers object, please refer
  *                to \ref secLayerIntro "Layer Introduction".
  *
  *                For purpose of BasicLayers, also see BasicLayer::Material.
  */


 /*! \function     BasicLayer* BasicLayer::create(Technology* technology,const Name& name,const BasicLayer::Material& material,unsigned extractNumber,const DbU::Unit& minimalSize = 0,const DbU::Unit& minimalSpacing = 0);
  *                creates and returns a new basic layer named \c \<name\>, of 
  *                type \c \<material\> for the given technology (some geometrical 
  *                characteristics can also be specified). 
  *
  *  \caution      Throws an exception if the technology is null, if the name is 
  *                empty, if a layer of same name already exists or if we 
  *                overflow the capacity of the bit field associated to the 
  *                layer mask. 
  *
  *  \remark       The extract number is a kind of logic number. In example the 
  *                CP layer which represent a poly layer should have the same 
  *                extract number as the CPG layer which represent a poly layer 
  *                used to realize the transistor gates. While extractions 
  *                process, layers which have the same extract number are 
  *                considered as equivalents. A null value indicates that the 
  *                extraction should ignore this layer. 
  */


 /*! \function     const BasicLayer::Type& BasicLayer::getMaterial() const;
  *  \Return       the basic layer material. 
  */

 /*! \function     unsigned BasicLayer::getExtractNumber() const;
  *  \Return       the extract number. 
  */

 /*  \function     const string& BasicLayer::getFillPattern() const;
  *                Basic layers have graphic display characteristics which are 
  *                defined by both a color and a filling pattern. The above 
  *                methods provide the corresponding accessor functions. 
  *
  *                <b>Color :</b> 
  *
  *                A color is defined by its three RGB components (whose values 
  *                lies in the 0, 255). 
  *
  *                <b>Pattern :</b> 
  *
  *                A filling pattern is a stiple (transparent bitmap) of 8 by 8 
  *                pixels. The 64 bits of this stiple are defined by a string of 
  *                16 characters (allowed characters are 0123456789ABCDEF and 
  *                abcdef). The 2 first characters describe the first line, the 
  *                following 2 the second line and so forth. Pixels set to 1 
  *                will be drawn with the color layer while pixels set to 0 are 
  *                transparent. So the string "A5A5A5A5A5A5A5A5" represents a 
  *                stipple with staggered pixel each two ones, while the 
  *                "FFFFFFFFFFFFFFFF" stipple fills all the pixels (default 
  *                value). 
  */

 /*  \function     double BasicLayer::getDisplayThreshold() const;
  *                In order to get an efficient graphic display we need : 
  *
  *                On one hand, when we are in close view, quickly filter 
  *                objects which don't intersect the visible area. This is done 
  *                by a quadtree geometrical access structure and also by the 
  *                hierachy of cell assembly. 
  *
  *                On the other hand, when we are in an overview, not display 
  *                very small objects (it is useless to display the internals of 
  *                cells which represent few pixels on screen) and not display 
  *                components laying on deep layers (because this doesn't help 
  *                and probably the drawing will be hidden by upper layers). 
  *
  *                There is not a clear-cut between those two modes, so we 
  *                change progressively the display behaviour. 
  *
  *                For that purpose we introduce for each basic layer a display 
  *                threshold with shifting values, this makes appear 
  *                progresively the different deep layers while we get closer 
  *                and closer to the basic components 
  */

 /*! \function     const Name& BasicLayer::getRealName() const;
  *  \Return       the real (process) layer name, for GDS.
  */


 /*  \function     void BasicLayer::SetColor(unsigned short redValue, unsigned short greenValue, unsigned short blueValue);
  *                Sets the color of a basic layer. 
  */

 /*  \function     void BasicLayer::SetFillPattern(const string& fillPattern);
  *                Sets the filling pattern of a basic layer. 
  *
  *  \caution      Throws an exception if the string does't obey to the rules 
  *                described above. 
  */

 /*  \function     void BasicLayer::SetDisplayThreshold(double threshold);
  *                Sets the display threshold of a basic layer. 
  */

 /*! \function     void BasicLayer::setBlockageLayer(BasicLayer* layer);
  *                Associate a blockage layer to this one. This is only meaningful
  *                for routing layers (RegularLayer).
  */

 /*! \function     void BasicLayer::setExtractNumber(unsigned int);
  *                Set the extract number, for GDS.
  */

 /*! \function     void BasicLayer::setRealName(const char*);
  *                Set the real (process) layer name, for GDS.
  */


 /*! \name         BasicLayer Collection
  */
 //  \{

 /*! \typedef      BasicLayers
  *                Generic collection representing a set of basic layers. 
  */

 /*! \typedef      BasicLayerLocator
  *                Generic locator for traversing a collection of basic layers. 
  */

 /*! \typedef      BasicLayerFilter
  *                Generic filter allowing to select a subset of basic layers 
  *                matching some criteria. 
  */

 /*! \def          for_each_basic_layer(basicLayer, basicLayers)
  *                Macro for visiting all the layers of a collection of basic 
  *                layers. 
  */

 //  \}

 /*! \class        BasicLayer::Material
  *                Encapsulate the BasicLayer::Material::Code enumeration that defines the
  *                BasicLayer purpose.
  */

 /*! \enum         BasicLayer::Material::Code
  *                This enumeration defines the layer purpose inside the BasicLayer::Material.
  */
 /*! \var          BasicLayer::Material::Code BasicLayer::Material::nWell
  *                This is a NWELL layer.
  */
 /*! \var          BasicLayer::Material::Code BasicLayer::Material::pWell
  *                This is a PWELL layer.
  */
 /*! \var          BasicLayer::Material::Code BasicLayer::Material::nImplant
  *                This is a N implant layer, for transistor source & drain.
  */
 /*! \var          BasicLayer::Material::Code BasicLayer::Material::pImplant
  *                This is a P implant layer, for transistor source & drain.
  */
 /*! \var          BasicLayer::Material::Code BasicLayer::Material::active
  *                For active area, for transistor gates.
  */
 /*! \var          BasicLayer::Material::Code BasicLayer::Material::poly
  *                Polysilicium, for short connections & transistor gates. 
  */
 /*! \var          BasicLayer::Material::Code BasicLayer::Material::cut
  *                For the \e hole part of VIAs.
  */
 /*! \var          BasicLayer::Material::Code BasicLayer::Material::metal
  *                For routing layers.
  */
 /*! \var          BasicLayer::Material::Code BasicLayer::Material::blockage
  *                For blockages, associated to metals.
  */
 /*! \var          BasicLayer::Material::Code BasicLayer::Material::other
  *                Fallback for any other purposes.
  */


 }
