util_ent_dtk.hpp

Go to the documentation of this file.

#ifndef _UTIL_ENT_DTK_HPP_
#define _UTIL_ENT_DTK_HPP_
 
#include "util/BaseTypes/dtk_metadata.hpp"
#include "util/BaseTypes/dtk_object.hpp"
#include "util/BaseTypes/dtk_transfo.hpp"
#include "util/dtk_maindoc_ptr.hpp"
#include "util/error_dtk.hpp"
#include "util/util_draw_ptr_dtk.hpp"
#include "util/util_ptr_dtk.hpp"
#include "util/util_stl_dtk.hpp"
#include "def/define.h"
#include "util/dtk_val.hpp"
#include "util/dtk/span.hpp"
#include <iosfwd>
#include <memory>
 
class Dtk_Entity;
class Dtk_material;
class Dtk_MetaData;
 
template <class T> class Dtk_SmartPtr;
 
typedef Dtk_SmartPtr<Dtk_material>              Dtk_MaterialPtr;
 
enum Dtk_PointType {
    DTK_PT_UNSPECIFIED = 0,
    DTK_PT_CROSS,           // a cross which looks like a "X"
    DTK_PT_PLUS,              // a cross which looks like a "+"
    DTK_PT_CONCENTRIC,      // an unfilled circle
    DTK_PT_COINCIDENT,      // two unfilled concentric circles
    DTK_PT_FULLCIRCLE,      // a filled circle
    DTK_PT_FULLSQUARE,      // a filled square
    DTK_PT_STAR,            // a star which is the union of a 2D marker CROSS, a 2D marker PLUS and a 2D marker DOT
    DTK_PT_DOT,             // a dot
    DTK_PT_SMALLDOT,        // a small dot whose size is one pixel
    DTK_PT_BIGFULLCIRCLE,   // a big filled circle
    DTK_PT_BIGFULLSQUARE,   // a big filled square
     DTK_PT_SQUARE,          // an unfilled square
     DTK_PT_UP_TRIANGLE,     // a triangle pointing up
     DTK_PT_DIAMOND          // a square rotated by 90 degrees
};
 
//! \enum Dtk_FontLineType
//! \brief This is a set of line styles
enum Dtk_FontLineType {
    DTK_NO_PATTERN = 0,
    // ________________________________
    DTK_SOLIDLINE,
    // _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
    DTK_DASHED,
    // ________ _ _ _________ _ _ _____
    DTK_PHANTOM,
    // ________ _ _________ _ _________
    DTK_CENTERLINE,
    // ................................
    DTK_DOTTED,
    // ___ ___ ___ ___ ___ ___ ___ ___
    DTK_LONG_DASHED,
    // ___ . ___ . ___ . ___ . ___ . __
    DTK_DOTTED_DASHED,
    // --'\,-----'\,-----'\,-----'\,---
    DTK_BREAKLINE,
    DTK_NUM_FONT_LINE_TYPES
};
 
extern   int dtk_AddColorInTable(const Dtk_RGB&);
 
class Dtk_Object;
template <class T>
class Dtk_SmartPtr;
class Dtk_Val;
struct Dtk_string_compare;
class Dtk_Info;
 
 
class Dtk_UUID;
class Dtk_pnt;
class Dtk_dir;
class Dtk_RGB;
class Dtk_string;
 
 
struct Dtk_string_compare
{
  bool operator()(const Dtk_string& s1, const Dtk_string& s2) const
  {
    return s1.cmp(s2) < 0;
  }
};
 
struct Dtk_string_compare_case_insensitive
{
     bool operator()(const Dtk_string& s1, const Dtk_string& s2) const
     {
          return s1.icmp(s2) < 0;
     }
};
//! \ingroup base_types
//! \class Dtk_Info
//! \brief This is the generic Info class.
//!
//!    This class provides informations about Color/Layer/BlankedStatus/Name etc...
//!    This class also provides additionnal information specific to the owning entity
//! \SmartPtr{Dtk_InfoPtr}
class Dtk_Info : public Dtk_Object
{
 
protected:
    enum { _typeID = DTK_TYPE_INFO };
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    Dtk_MaterialPtr _Material;
    Dtk_Info();
    Dtk_Info(const Dtk_Info& s);
    Dtk_Info( Dtk_Info&& s) DTK_NOEXCEPT;
    friend class Dtk_SmartPtr<Dtk_Info>;
    virtual Dtk_Object* Clone() { return new Dtk_Info(*this); }
public:
     enum MandatoryFlag
     {
          NotMandatory = 0,
          XYPlane,
          YZPlane,
          ZXPlane,
          OriginPoint
     };
 
    //downcasting
    int DtkDynamicType(const Dtk_Int32& inId);
    static Dtk_Info* DtkDynamicCast(Dtk_Object * s);
 
     //! \CreateCopy{in}
     static Dtk_SmartPtr<Dtk_Info> Create( const Dtk_Info& in );
     //! \deprecated use Create instead
     SetAsDeprecated( "2026.4", "Use Create instead." )
     static Dtk_SmartPtr<Dtk_Info> create( const Dtk_Info& in );
     //! \CreateBase
     static Dtk_SmartPtr<Dtk_Info> Create();
     //! \deprecated use Create instead
     SetAsDeprecated( "2026.4", "Use Create instead." )
     static Dtk_SmartPtr<Dtk_Info> create();
    ~Dtk_Info();
 
     Dtk_ErrorStatus AddAttribute(Dtk_string name, Dtk_Val val);
     Dtk_ErrorStatus AddCustomerDefinedAttribute(Dtk_string name, Dtk_Val val);
 
    Dtk_ErrorStatus FindAttribute(const Dtk_string& name, Dtk_Val& val) const;
    Dtk_Val const * FindAttribute(const Dtk_string& name) const; // If not found, returns nullptr.
    Dtk_ErrorStatus ListAttributes(const Dtk_string& substring, Dtk_tab<Dtk_string>& tab_keys) const;
    Dtk_ErrorStatus ListAllAttributes(Dtk_tab<Dtk_string>& tab_keys) const;
     Dtk_ErrorStatus ListAllAttributesWithVal(Dtk_tab<Dtk_pair<Dtk_string,Dtk_Val> >& tab) const;
     Dtk_ErrorStatus ListAllCustomerDefinedAttributesWithVal(Dtk_tab<Dtk_pair<Dtk_string, Dtk_Val> >& tab) const;
     Dtk_ErrorStatus RemoveAttribute(const Dtk_string& name);
 
     Dtk_ErrorStatus SetAdditionnalGeometryFlag(const Dtk_Int32& inAdditionnalGeom);
     Dtk_ErrorStatus SetUse(const Dtk_Int32& inUse);
     Dtk_ErrorStatus SetActivationFlag(const Dtk_Int32& inActivation);
     Dtk_ErrorStatus SetFlexibleFlag(const Dtk_Int32& inIsFlexible);
     Dtk_ErrorStatus SetActiveChildren(const Dtk_tab<Dtk_Int32> &inIndices);
     Dtk_ErrorStatus SetDefaultChildIndex(const Dtk_Int32& inIndex);
     Dtk_ErrorStatus SetHierarchy(const Dtk_Int32& inHierarchy);
     Dtk_ErrorStatus SetHierarchyColorFlag(const Dtk_Int32& inHierarchy);
    Dtk_ErrorStatus SetFontId(const Dtk_Int32& inFontId);
    Dtk_ErrorStatus SetFormFlag(const Dtk_Int32& inFormFlag);
    Dtk_ErrorStatus SetMatId(const Dtk_Int32& inMatId);
    Dtk_ErrorStatus SetSubordFlag(const Dtk_Int32& inSubordFlag);
    Dtk_ErrorStatus SetId(const Dtk_Int32& inId);
    Dtk_ErrorStatus SetViewId(const Dtk_Int32& inViewId);
     Dtk_ErrorStatus SetColor( const int&R, const int&G, const int&B );// {return SetColorId( dtk_AddColorInTable( Dtk_RGB( R, G, B ) ) ); }
     Dtk_ErrorStatus SetColor( const Dtk_RGB & inColor );// {return SetColorId( dtk_AddColorInTable( inColor ) ); }
 
 
    Dtk_ErrorStatus SetColorId(const Dtk_Int32& inColorId);
     Dtk_ErrorStatus SetName( Dtk_string inName);
     Dtk_ErrorStatus SetPersistentName( Dtk_string inName);
    Dtk_ErrorStatus SetLayer(const Dtk_Int32 & inLayer);
    Dtk_ErrorStatus SetBlankedStatus(const Dtk_Int32 &inBlankedStatus);
     //!\deprecated use SetCurveThickNessInMM() methods instead
     SetAsDeprecated( "2020.1", "use SetCurveThickNessInMM() methods instead." )
     Dtk_ErrorStatus SetCurveThickNess(const Dtk_Int32 &inCurveThickNess);
     Dtk_ErrorStatus SetDisplayLineWidth(const Dtk_Double64& inDisplayLineWidth);
     //! \brief Add a Dtk_LineTypeDefinition to Dtk_API and set it to current object.
     Dtk_ErrorStatus AddCurveLineTypeDefinition( const Dtk_LineTypeDefinitionPtr & inLineTypeDefinition );
     //! \brief Set Dtk_LineTypeDefinition of current object via it's id in Dtk_API table.
     Dtk_ErrorStatus SetCurveLineTypeDefinitionId( const Dtk_ID & inLineTypeDefinitionId );
     //! \brief Set line type of current object thanks to Dtk_FontLineType enumeration.
     Dtk_ErrorStatus SetCurveLineType(const Dtk_Int32 &inCurveLineType);
    Dtk_ErrorStatus SetCurveThickNessInMM(const Dtk_Double64 inCurveThickNessInMM);
    Dtk_ErrorStatus SetPointSymbolType(const Dtk_PointType inPointSymbolType);
     Dtk_ErrorStatus SetInfiniteGeometryFlag(const Dtk_Int32 &inInfiniteGeometryFlag);
     Dtk_ErrorStatus SetRefEntityFlag( const Dtk_Int32 &inRefEntityFlag );
     Dtk_ErrorStatus SetMandatoryFlag(const enum MandatoryFlag &inMandatoryFlag);
     Dtk_ErrorStatus SetUuid(const Dtk_UUID &inUuid);
     Dtk_ErrorStatus SetAddedItemFlag(const Dtk_Int32 &inAddedItem);
     Dtk_ErrorStatus SetMetaData(Dtk_tab<Dtk_MetaDataPtr>& inArray) ;
     Dtk_ErrorStatus AddLayer(const Dtk_Int32 & inLayer);
 
     //!\deprecated use AddRenderInfos and AddMaterialInfos methods instead
     SetAsDeprecated( "2026.3", "use AddRenderInfos and AddMaterialInfos methods instead." )
     Dtk_ErrorStatus AddMaterial( const Dtk_MaterialPtr &inMaterial );
 
     Dtk_ErrorStatus AddPhysicalMaterialInfos( const Dtk_PhysicalMaterialInfosPtr &inMaterial );
     Dtk_ErrorStatus SetPhysicalMaterialInfosId( const Dtk_ID &inMaterialId );
     Dtk_ErrorStatus AddRenderInfos( const Dtk_RenderInfosPtr &inRender );
     Dtk_ErrorStatus SetRenderInfosId( const Dtk_ID &inRenderId );
     Dtk_ErrorStatus SetOccurrenceDataFlag();
 
 
     int         GetActivationFlag() const;
     int            GetFlexibleFlag() const;
     Dtk_tab<Dtk_Int32> GetActiveChildren() const;
     int         GetDefaultChildIndex() const;
     int         GetAdditionnalGeometryFlag() const;
     int         GetUse() const;
     int         GetAddedItemFlag() const;
     int         GetHierarchy() const;
     int         GetHierarchyColorFlag() const;
    int         GetFontId() const;
    int         GetFormFlag() const;
    int         GetMatId() const;
    int         GetSubordFlag() const;
    int         GetId() const;
    int         GetViewId() const;
 
     //! \brief Retrieves the layers in which the entity is assigned.
     //! \return The list of layer numbers.
     //! \remark The list can be empty.
     //! \sa AddLayer(const Dtk_Int32 & inLayer);
     Dtk_tab<Dtk_Int32> GetlayerList() const;
 
    //! \brief Retrieves the entity color as Dtk_RGBA values.
    //! \return the Dtk_RGBA value is succeeds. Dtk_RGB(-1,-1,-1) otherwise - no color found for example -.
    //!
    //! \b Sample:
    //! \code
    //! //Get Dtk_InfoPtr class
    //! Dtk_InfoPtr infos = inNode->GetInfos(); //inNode is a Dtk_Node in this sample
    //! Dtk_RGB MyColor = infos->GetColor(); //returned RGB is (-1,-1,-1,-1)
    //! infos->SetColor( Dtk_RGB( 128, 50, 255, 255 ) ); //Red=128 / Green=50 / Blue=255 / Alpha = 255
    //! MyColor = infos->GetColor(); // no RGB is (128,50,255,255)
    //! \endcode
    //! \sa SetColor(const Dtk_RGB & inColor)
    //! \sa SetColor(const int&R,const int&G,const int&B)
    Dtk_RGB     GetColor() const;
     //!\brief Retrieves the entity color index in Dtk_API color table.
     //! \return the color index 
    int         GetColorId() const;
 
     //! \brief Retrieves the entity name.
     //! \return the name if succeeds, empty string otherwise.
     //! \sa SetName( const Dtk_string &inName )
     Dtk_string  GetName() const;
     //!\brief Retrieves the entity persistent name.
     //!\return the persistent name if succeeds, empty string otherwise.
     Dtk_string  GetPersistentName() const;
 
     //! \brief Retrieves the entity layer.
     //! \return The layer ID if succeed or -1 otherwise - If Undefined or no layer set -.
    //! \sa SetLayer(const Dtk_Int32 & inLayer);
    int         GetLayer() const;
 
     //! \brief Retrieves the entity Blanked Status.
     //! \return -1 If Undefined - or no blanked status set - .
     //! \return  0 If Visible.
     //! \return  1 If Invisible
     //! \return  2 If Construction Geometry
     //! \sa SetBlankedStatus(const int &inBlankedStatus)
    int         GetBlankedStatus() const;
 
 
     //! \brief Retrieves if all wireframe is displayed with same width
     //! \return The curve width in millimeter if succeeds, 0.0 otherwise.
     //! \sa SetDisplayLineWidth( const Dtk_Double64   inDisplayLineWidth )
     Dtk_Double64 GetDisplayLineWidth() const;
 
     //! \deprecated Use GetCurveThickNessInMM() const method instead.
     SetAsDeprecated( "2020.1", "use GetCurveThickNessInMM() methods instead." )
     int         GetCurveThickNess() const;
 
     //! \brief Retrieves the curve thickness - if exists and relevant -.
     //! \return The curve thickness in millimeters if succeeds, -1.0 otherwise.
     //! \sa SetCurveThickNessInMM( const Dtk_Double64      inCurveThickNessInMM )
     Dtk_Double64  GetCurveThickNessInMM() const;
 
     //! \brief Retrieves the curve LineType - for curve entities -
    //! \return The curve LineType - Dtk_FontLineType::DTK_SOLIDLINE if not type set -.
     Dtk_FontLineType      GetCurveLineType() const;
 
     //! \brief Retrieves the definition of the curve LineType - for curve entities -
     //! \return null pointer if not set.
     Dtk_LineTypeDefinitionPtr GetCurveLineTypeDefinition() const;
 
     //! \brief Retrieves the Id of Dtk_LineTypeDefinition of the entity in The Dtk_API table.
     //! \return The id or 0 if None.
     Dtk_ID GetCurveLineTypeDefinitionId() const;
 
     //! \brief Retrieves the Symbol Type - for point only -.
     //! \return The Symbol Type - Dtk_PointType::DTK_PT_UNSPECIFIED if no type set -.
     Dtk_PointType         GetPointSymbolType() const;
 
     //! \brief Retrieves the Mandatory Flag 
     //! \return Mandatory flag
     enum MandatoryFlag GetMandatoryFlag() const;
 
     //!\brief Retrieves the Flag for Infinite Geometry
     //! \return 1 if infinite geometr, 0 otherwise.
     int         GetInfiniteGeometryFlag() const;
     //! \brief Retrieves the Flag for Reference Entity (Reference planes , axis, point
     //! \return 1 if reference entity, 0 otherwise.
     int         GetRefEntityFlag() const;
     //! \brief Retrieves the entity UniqueID if any.
     Dtk_UUID    GetUuid() const;
     Dtk_ErrorStatus GetMetaData(Dtk_tab<Dtk_MetaDataPtr>& outArray) const;
 
     //!\deprecated use GetRenderInfos and GetPhysicalMaterialInfos methods instead
     SetAsDeprecated( "2026.3", "use GetRenderInfos and GetPhysicalMaterialInfos methods instead." )
     Dtk_MaterialPtr GetMaterial() const;
 
     //! \brief Retrieves the entity RenderInfos of the entity.
     //! \return the Dtk_RenderInfosPtr or NULL if None.
     //! \sa GetRenderInfos()
     Dtk_RenderInfosPtr GetRenderInfos() const;
 
     //! \brief Retrieves the Id of RenderInfos of the entity in The Dtk_API table.
     //! \return the id or 0 if None.
     //! \sa GetRenderInfosId()
     Dtk_ID GetRenderInfosId() const;
 
     //! \brief Retrieves the entity MaterialInfos.
     //! \return the Dtk_MaterialInfosPtr if succeeds or NULL otherwise.
     Dtk_PhysicalMaterialInfosPtr GetPhysicalMaterialInfos() const;
 
     //! \brief Retrieves the Id of MaterialInfos of the entity in The Dtk_API table.
     //! \return the id or 0 if None.
     Dtk_ID GetPhysicalMaterialInfosId() const;
 
     //! \brief Retrieves the OccurrenceData flag.
     //! \return true if the instance references a modified version of the prototype.
     bool GetOccurrenceDataFlag() const;
 
     Dtk_ErrorStatus SetBuildingInfosIds(const Dtk_tab<Dtk_Int32> inBuildingInfos);
     Dtk_tab<Dtk_Int32> GetBuildingInfosIds() const;
 
 
     //! \deprecated Use GetMetaData() const method instead.
     SetAsDeprecated( "2026.2", "use GetMetaData() methods instead." )
     Dtk_ErrorStatus GetProperties(Dtk_tab<Dtk_PropertiesPtr>& outArray) const;
     Dtk_ErrorStatus GetReferenceSet(Dtk_tab<Dtk_string>& outArray, Dtk_Int32 inRemovePrefix=DTK_FALSE ) const;
     Dtk_string      GetConfigurationName() const;
     Dtk_ErrorStatus SetConfigurationName( const Dtk_string &inName );
 
     //! \brief Retrieves up to date state of current object.
     //! \return -1 if unknown, DTK_TRUE if object is up to date, DTK_FALSE if not up to date. Default is unknown.
     Dtk_bool GetIsUpToDate() const;
     //! \brief Set if current object is up to date or not.
     //! \param isUpToDate DTK_TRUE if object is up to date, DTK_FALSE if not. Anything else will set state to unknown.
     void SetIsUpToDate( const Dtk_bool isUpToDate );
 
 
     virtual Dtk_Size_t GetSize() const;
     virtual Dtk_ErrorStatus _Store(void*);
};
 
 
class Dtk_Entity : public Dtk_Object
{
protected:
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_ENTITY };
 
    virtual Dtk_Object* Clone() = 0;
    friend class Dtk_SmartPtr<Dtk_Entity>;
public:
    Dtk_Entity();
     Dtk_Entity(const Dtk_Entity& s);
     Dtk_Entity( Dtk_Entity&& s) DTK_NOEXCEPT;
     Dtk_Entity& operator=( const Dtk_Entity& s );
     Dtk_Entity& operator=( Dtk_Entity&& s ) DTK_NOEXCEPT;
 
     virtual ~Dtk_Entity();
     //! \brief Get Internal UniqueID
     //! \return InternalID
     const Dtk_ID& GetID() const;
 
    virtual enum type_detk get_type_detk() const=0;
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Entity* DtkDynamicCast(Dtk_Object * s);
 
    Dtk_InfoPtr get_info() const;
    Dtk_InfoPtr& info();
     //virtual Dtk_status Transform(const Dtk_transfo& inTransfo)=0;
     virtual Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo)=0;
 
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
 
     virtual void PrepareTransfo ();
};
 
/////////////////////////////////////////
 
class Dtk_LayerInfosSet;
class Dtk_ColorInfosSet;
class Dtk_LayerFilterInfos;
class Dtk_AxisSystem;
class Dtk_ModelDisplay;
class Dtk_Constraint;
class Dtk_ConstraintReference;
typedef Dtk_SmartPtr<Dtk_LayerInfosSet> Dtk_LayerInfosSetPtr;
typedef Dtk_SmartPtr<Dtk_ColorInfosSet> Dtk_ColorInfosSetPtr;
typedef Dtk_SmartPtr<Dtk_LayerFilterInfos> Dtk_LayerFilterInfosPtr;
typedef Dtk_SmartPtr<Dtk_AxisSystem> Dtk_AxisSystemPtr;
typedef Dtk_SmartPtr<Dtk_ModelDisplay> Dtk_ModelDisplayPtr;
typedef Dtk_SmartPtr<Dtk_Constraint> Dtk_ConstraintPtr;
typedef Dtk_SmartPtr<Dtk_ConstraintReference> Dtk_ConstraintReferencePtr;
 
 
 
 
//! \class Dtk_LayerFilterInfos
//! \brief This class is used by Dtk_LayerInfosSet to represent a layer filter : its name, description, and selected layers of the set it is contained in.
//! \remark The layer indexes used by Dtk_LayerFilterInfos are those of the Dtk_LayerInfosSet it is contained in.
//! \see Dtk_LayerInfosSet::CreateLayerFilterInfos
class Dtk_LayerFilterInfos: public Dtk_Object
{
protected:
    struct Dtk_Handle; // Not defined here
    std::unique_ptr<Dtk_Handle> _Private; // Handle
    enum { _typeID = DTK_TYPE_LAYER_FILTER_INFOS };
 
    Dtk_LayerFilterInfos(const Dtk_Size_t inNumLayers, Dtk_string inName = L"", Dtk_string inDescription = L"", const Dtk_bool inAreLayersActivatedByDefault = DTK_FALSE);
 
     //! \CopyConstructor{s}
     Dtk_LayerFilterInfos(const Dtk_LayerFilterInfos& s);
     virtual ~Dtk_LayerFilterInfos();
    inline virtual Dtk_Object* Clone() { return new Dtk_LayerFilterInfos(*this); }
 
     friend class Dtk_LayerInfosSet;
private:
    friend class Dtk_SmartPtr< Dtk_LayerFilterInfos >;
public:
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    //! \DtkDynamicCast
    static Dtk_LayerFilterInfos * DtkDynamicCast(Dtk_Object *s);
 
    //! \return The type of the entity type - DTK_TYPE_LAYER_FILTER_INFOS -
    type_detk get_type_detk() const { return DTK_TYPE_LAYER_FILTER_INFOS; }
 
    //! \brief Selects a given layer in the layer filter.
    //! \param inLayerIndex the layer index to be selected.
     //! \return dtkNoError if the layer has been selected
     //! \return dtkErrorOutOfRange if the index is out of layer set range.
    Dtk_ErrorStatus SelectLayer(const Dtk_Size_t inLayerIndex);
 
    //! \brief Selects given layers in the layer filter.
    //! \param inLayerIndexes An array of layer indexes to be selected.
     //! \return dtkNoError if all the desired layers has been selected.
     //! \return dtkErrorOutOfRange if one of the indices is out of layer set range. Valid indices will still be processed.
     Dtk_ErrorStatus SelectLayers(const Dtk_tab< Dtk_Size_t >& inLayerIndexes );
 
    //! \brief Unselects the given layer in the layer filter.
    //! \param inLayerIndex the layer index to be unselected.
     //! \return dtkNoError if the layer has been unselected.
     //! \return dtkErrorOutOfRange if the index is out of layer set range.
     Dtk_ErrorStatus UnselectLayer(const Dtk_Size_t inLayerIndex);
 
    //! \brief Unselects the given layers in the layer filter.
    //! \param inLayerIndexes An array of layer indexes to be unselected.
     //! \return dtkNoError if all the desired layers has been unselected.
     //! \return dtkErrorOutOfRange if one of the indices is out of layer set range. Valid indices will still be processed.
     Dtk_ErrorStatus UnselectLayers(const Dtk_tab< Dtk_Size_t >& inLayerIndexes);
 
 
    //! \brief Tells if the layer is selected or not giving its index.
    //! \param inLayerIndex the layer index in Dtk_LayerInfosSet layers.
    //! \return DTK_FALSE if layer is not selected, DTK_TRUE otherwise.
    Dtk_bool IsLayerSelected(const Dtk_Size_t inLayerIndex ) const;
 
    //! \brief Retrieves all the selected layers into the layer filter.
    //! \param outSelectedLayers the selected layer indexes.
    void GetSelectedLayers(Dtk_tab< Dtk_Size_t >& outSelectedLayerIndexes) const;
 
    //! \brief Retrieves layer filter name.
    //! \param outLayerFilterName the layer filter name.
    void GetName(Dtk_string& outLayerFilterName) const;
 
    //! \brief Retrieves layer filter description.
    //! \param outLayerFilterDescription the layer filter description.
    void GetDescription(Dtk_string& outLayerFilterDescription) const;
};
 
//! \class Dtk_LayerInfosSet
//! \brief This class represents a set of layer information, such as their name and identifier, as well as a list of layer filters. \n
//! \details The set allows to extend the definition of legacy layers, that previously were only represented by an identifier. It lists all layers used in a given context (Dtk_Component), and allows to assign a name to each of them.\n
//! \details It also allows to define one of the layer as being the default one (note that this can be the same concept as the current one, depending on the format).\n
//! \details Creation of layer filters are also done through this set, representing a group of specific layers. \n
//! \details One of the filter can be defined as being the default one, similarly to individual layer.
//! \see Dtk_LayerFilterInfos for more information about layer filters.
//! \see \ref attribsample_layerinfoset for a sample on how to use it.
//! \SmartPtr{Dtk_LayerInfosSetPtr}
class Dtk_LayerInfosSet : public Dtk_Object
{
public:
 
     struct Layer
     {
          enum class Status
          {
               Visible = 1,//Describes the layer elements visibility : if set, the elements in the layer are visible, otherwise they are invisible.
               Selectable = 2,//Describes the layer elements selectability: if set, the elements in the layer are selectable, otherwise they aren't.
          };
 
     protected:
          Dtk_string m_Name;
          Dtk_ID m_ID;
          Dtk_ID m_FatherID;
          Dtk_UShort16 m_Status;
 
     public:
 
          Layer() : m_Name(), m_ID( static_cast< Dtk_ID >( -1 ) ), m_FatherID( static_cast< Dtk_ID >( -1 ) ), m_Status( 0 )
          {
               FlagAs( Status::Visible );
               FlagAs( Status::Selectable );
          }
          Layer( Dtk_ID id, Dtk_string name = Dtk_string(), Dtk_ID fatherID = static_cast< Dtk_ID >( -1 ) ) : m_Name( std::move( name ) ), m_ID( id ), m_FatherID( fatherID ), m_Status( 0 )
          {
               FlagAs( Status::Visible );
               FlagAs( Status::Selectable );
          }
          Dtk_string const& GetName() const { return m_Name; };
          Dtk_ID GetID() const { return m_ID; };
          Dtk_ID GetFatherID() const { return m_FatherID; };
          bool IsFlaggedAs( Status in ) const { return m_Status & 1 << static_cast< Dtk_UShort16 >( in ); }
          void FlagAs( Status in ) { m_Status |= 1 << static_cast< Dtk_UShort16 >( in ); }
          void Unflag( Status in ) { m_Status &= ~( 1 << static_cast< Dtk_UShort16 >( in ) ); }
 
          friend class Dtk_LayerInfosSet;
 
     };
 
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum { _typeID = DTK_TYPE_LAYER_INFOS_SET };
 
     Dtk_LayerInfosSet();
     Dtk_LayerInfosSet( const Dtk_LayerInfosSet &s );
     Dtk_LayerInfosSet( Dtk_LayerInfosSet &&s ) DTK_NOEXCEPT;
 
     virtual Dtk_Object* Clone() { return new Dtk_LayerInfosSet( *this ); }
 
     //! \BaseDestructor
     virtual ~Dtk_LayerInfosSet();
private:
    friend class Dtk_SmartPtr<Dtk_LayerInfosSet>;
public:
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    //! \DtkDynamicCast
    static Dtk_LayerInfosSet * DtkDynamicCast(Dtk_Object *s);
 
    //! \return The type of the entity type - DTK_TYPE_LAYER_INFOS_SET -
    type_detk get_type_detk() const { return DTK_TYPE_LAYER_INFOS_SET; }
     
     //! \brief Calls a constructor to allocate a new object.
    //! \param[in] inNumLayers the number of desired layers.
     //! \details The desired number of layer will be added in the set using AddLayer( Layer ). Layers identifier will be set as their index in the set.
     //! \deprecated
     SetAsDeprecated( "2026.2", "Use Create then Dtk_LayerInfoSet::AddLayers instead." )
     static Dtk_LayerInfosSetPtr Create( const Dtk_Size_t inNumLayers );
 
     //! \CreateBase
     static Dtk_LayerInfosSetPtr Create();
     //! \\CreateCopy{in}
     static Dtk_LayerInfosSetPtr Create( const Dtk_LayerInfosSet& in );
 
    //! \brief Creates a layer filter.
    //! \param[in] inName the layer filter name - Empty name by default -.
    //! \param[in] inDescription the layer filter description - Empty name by default -.
    //! \param[in] inAreLayersActivatedByDefault The default value of the layer selection. DTK_TRUE means that all layers are selected. DTK_FALSE means that no layer is selected - DTK_FALSE by default -.
    //! \param[in] IsDefaultLayerFilter Tells if the new layer filter is the default one - DTK_FALSE by default -.
    //! \return the newly created layer filter.
    //! \remark The newly created layer filter is automatically stored into the Dtk_LayerInfosSet.
     Dtk_LayerFilterInfosPtr CreateLayerFilterInfos( Dtk_string inName = L"", Dtk_string inDescription = L"", const Dtk_bool inAreLayersSelectedByDefault = DTK_FALSE, const Dtk_bool IsDefaultLayerFilter = DTK_FALSE );
 
    //! \brief Retrieves the number of layers.
    //! \return the number of layers.
    Dtk_Size_t GetNumLayers() const;
 
    //! \brief Retrieves the number of layer filters.
    //! \return the number of layer filters.
    Dtk_Size_t GetNumLayerFilters() const;
 
    //! \brief Sets the layer name giving its index.
    //! \param[in] inIndex the layer index.
    //! \param[in] inLayerName the layer name.
    //! \return dtkNoError if success.
    //! \return dtkErrorOutOfRange if bad layer index. 
     //! \deprecated
     SetAsDeprecated( "2026.2", "Use AddLayer instead." )
    Dtk_ErrorStatus SetLayerName(const Dtk_Size_t inIndex, const Dtk_string& inLayerName);
 
     //! \brief Gets the LayerName giving its index.
     //! \param[in] inLayerPos the layer index.
     //! \param[out] outLayerName the layer name or empty string if any error.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if bad layer index.
     //! \return dtkErrorNullPointer if no layer name.
     //! \deprecated
     SetAsDeprecated( "2026.2", "Use GetLayers instead." )
     Dtk_ErrorStatus GetLayerName( const Dtk_Size_t inIndex, Dtk_string& outLayerName ) const;
 
     //! \brief Gets the LayerName giving the ID found by infos->GetLayer().
     //! \param[in] inLayerID the layer ID.
     //! \param[out] outLayerName the layer name or empty string if any error.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if bad layer ID.
     //! \return dtkErrorNullPointer if no layer name.
     //! \deprecated
     SetAsDeprecated( "2026.2", "Use GetLayerByID instead." )
     Dtk_ErrorStatus GetLayerNameById( const Dtk_ID inLayerID, Dtk_string& outLayerName ) const;
 
    //! \brief Sets the default layer index.
    //! \param inDefaultLayer the layer index.
    //! \return dtkNoError if success.
    //! \return dtkErrorOutOfRange if bad layer index.
     //! \deprecated
     SetAsDeprecated( "2026.2", "Use SetCurrentLayer instead." )
    Dtk_ErrorStatus SetDefaultLayer(const Dtk_Size_t inDefaultLayerIndex);
     
     //! \brief Sets the current layer index.
    //! \param inCurrentLayerIndex the layer index.
    //! \return dtkNoError if success.
    //! \return dtkErrorOutOfRange if bad layer index.
    Dtk_ErrorStatus SetCurrentLayer(const Dtk_Size_t inCurrentLayerIndex);
 
    //! \brief Gets the default layer index.
    //! \param outDefaultLayer the layer index or -1 if any error.
    //! \return dtkNoError if success.
    //! \return dtkErrorOutOfRange if no current layer.
     //! \deprecated
     SetAsDeprecated( "2026.2", "Use GetCurrentLayer instead.")
    Dtk_ErrorStatus GetDefaultLayer(Dtk_Size_t& outDefaultLayerIndex) const;
 
     //! \brief Gets the current layer index.
     //! \param outCurrentLayerIndex the layer index or -1 if any error.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if no current layer.
    Dtk_ErrorStatus GetCurrentLayer(Dtk_Size_t& outCurrentLayerIndex) const;
 
    //! \brief Gets the default layer filter index.
    //! \param outDefaultLayerFilterIndex the layer filter index or -1 if any error.
    //! \return dtkNoError if success.
    //! \return dtkErrorOutOfRange if no default layer filter.
    Dtk_ErrorStatus GetDefaultLayerFilter(Dtk_Size_t& outDefaultLayerFilterIndex) const;
 
    //! \brief Gets a layer filter giving its index.
    //! \param inLayerFilterIndex the layer filter index.
    //! \return the asked layer filter if success or a NULL Dtk_LayerFilterInfosPtr if any error.
    Dtk_LayerFilterInfosPtr GetLayerFilterByPos(const Dtk_Size_t inLayerFilterIndex) const;
 
     //! \brief Sets the LayerID giving its index.
     //! \param[in] inLayerPos the layer index.
     //! \param[in] inLayerID the layer id.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if bad layer index.
     //! \deprecated
     SetAsDeprecated( "2026.2", "Use GetLayers instead." )
     Dtk_ErrorStatus SetLayerID(const Dtk_Size_t inLayerIndex, const Dtk_ID& inLayerID);
 
     //! \brief Gets the LayerID giving its index.
     //! \param[in] inLayerPos the layer index.
     //! \param[out] outLayerID the layer id or inLayerPos if not given.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if bad layer index.
     //! \deprecated
     SetAsDeprecated( "2026.2", "Use GetLayers instead.")
     Dtk_ErrorStatus GetLayerID(const Dtk_Size_t inLayerIndex, Dtk_ID& outLayerID) const;
 
     //! \brief Adds a layer in the set.
     //! \param[in] inLayer the layer to be added.
     //! \details The Dtk_LayerInfoSet expects layer being added to have an initialized identifier ( with a value different from static_cast< Dtk_ID >( -1 ) ).
     //! If the layer identifier is uninitialized, this function will set the identifier as being the layer index in the layer set.
     //! \return dtkNoError if success.
     Dtk_ErrorStatus AddLayer( Layer inLayer );
 
     //! \brief Retrieves a layer in the set using its identifier.
     //! \param[in] inLayerID the layer identifier.
     //! \param[out] out the layer with the provided identifier if found.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if layer identifier was not found in the set.
     Dtk_ErrorStatus GetLayerByID( Dtk_ID inLayerID, Layer& out );
 
     //! \brief Retrieves layers in the set as a dtk::Span.
     //! \return the layers in the set as a dtk::Span.
     dtk::Span<Layer const> GetLayers() const;
 
     //! \brief Retrieves the identifiers of layers in the set that are flagged a certain way.
     //! \param[in] inStatus the flag to check to retrieve layers identifiers.
     //! \return the identifiers of layers in the set that are flagged a certain way.
     Dtk_tab< Dtk_ID > GetLayersFlaggedAs( Dtk_LayerInfosSet::Layer::Status inStatus ) const;
 
     friend class Dtk_LayerFilterInfos;
};
 
 
//! \class Dtk_ColorInfosSet
//! \brief This is the Color Info Set class. This is the read color definition Class.\n
//! It gathers all information about colors in the component.
//! \SmartPtr{Dtk_ColorInfosSetPtr}
class Dtk_ColorInfosSet : public Dtk_Object
{
public:
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum { _typeID = DTK_TYPE_COLOR_INFOS_SET};
 
     Dtk_ColorInfosSet(const Dtk_Size_t inNumColors);
     //! \sa Create(const Dtk_ColorInfosSet &)
     Dtk_ColorInfosSet(const Dtk_ColorInfosSet &s); 
     Dtk_ColorInfosSet( Dtk_ColorInfosSet&& s ) DTK_NOEXCEPT;
     virtual Dtk_Object* Clone() { return new Dtk_ColorInfosSet(*this); }
 
     //! \BaseDestructor
     virtual ~Dtk_ColorInfosSet();
private:
     friend class Dtk_SmartPtr<Dtk_ColorInfosSet>;
public:
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_ColorInfosSet * DtkDynamicCast(Dtk_Object *s);
 
     //! \return The type of the entity type - DTK_TYPE_COLOR_INFOS_SET -
     type_detk get_type_detk() const { return DTK_TYPE_COLOR_INFOS_SET; }
 
     //! \brief Calls a constructor to allocate a new object.
     static Dtk_ColorInfosSetPtr Create(const Dtk_Size_t inNumColors);
     //! \\CreateCopy{in}
     static Dtk_ColorInfosSetPtr Create(const Dtk_ColorInfosSet & in );
 
     //! \brief Retrieves the number of colors.
     //! \return the number of colors.
     Dtk_Size_t GetNumColors() const;
 
     //! \brief Add Color definition.
    //! \param inColorReadId the color number.
     //! \param inColorName the color name.
     //! \param inColorDef the color RGB definition.
    //! \return dtkNoError if success.
     Dtk_Size_t AddColor(const Dtk_ID inColorReadId, const Dtk_string& inColorName,const Dtk_RGB& inColorDef);
 
 
     //! \brief Sets the Color Name giving its number.
     //! \param inColorPos the color number.
     //! \param inColorName the color name.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if bad color number.
     Dtk_ErrorStatus SetColorName(const Dtk_Size_t inColorPos, const Dtk_string& inColorName);
 
     //! \brief Gets the Color Name giving its number.
     //! \param inColorPos the color number.
     //! \param inColorName the color name or empty string if any error.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if bad color number.
     //! \return dtkErrorNullPointer if no color name.
     Dtk_ErrorStatus GetColorName(const Dtk_Size_t inColorPos, Dtk_string& outColorName) const;
 
     //! \brief Gets the Color Name giving the ID found iby infos->GetColorID().
     //! \param inColorReadId the color ID.
     //! \param outColorName the color name or empty string if any error.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if bad color ID.
     //! \return dtkErrorNullPointer if no color name.
     Dtk_ErrorStatus GetColorNameById(const Dtk_ID inColorReadId, Dtk_string& outColorName) const;
 
     //! \brief Sets the default color number.
     //! \param inDefaultColor the color number.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if bad color number.
     Dtk_ErrorStatus SetDefaultColor(const Dtk_Int32 inDefaultColor);
 
     //! \brief Gets the default color number.
     //! \param outDefaultColor the color number or -1 if any error.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if no default color.
     Dtk_ErrorStatus GetDefaultColor(Dtk_Int32& outDefaultColor) const;
 
     //! \brief Sets the ColorID giving its number.
     //! \param inColorPos the color number.
     //! \param inColorReadID the color id.
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if bad color number.
     Dtk_ErrorStatus SetColorID(const Dtk_Size_t inColorPos, const Dtk_ID& inColorReadID);
 
     //! \brief Gets the ColorID giving its number.
     //! \param inColorPos the color number.
     //! \param outColorReadID the color id 
     //! \return dtkNoError if success.
     //! \return dtkErrorOutOfRange if bad color number.
     Dtk_ErrorStatus GetColorID(const Dtk_Size_t inColorPos, Dtk_ID& outColorReadID) const;
 
     //! \brief Gets the ColorID giving its number.
    //! \param inColorPos the color number.
    //! \param outColorDef the color id 
    //! \return dtkNoError if success.
    //! \return dtkErrorOutOfRange if bad color number.
     Dtk_ErrorStatus GetColorDefinition(const Dtk_Size_t inColorPos, Dtk_RGB& outColorDef) const;
 
};
 
 
class Dtk_Preview;
typedef Dtk_SmartPtr<Dtk_Preview> Dtk_PreviewPtr;
 
//! \ingroup base_types
//! \class Dtk_Preview
//! \brief This is the Dtk_Preview class.
//! \brief A Dtk_Preview contains Stream representing picture data
//!  This class lets you use Dtk_Preview.
//! \SmartPtr{Dtk_PreviewPtr}
class Dtk_Preview: public Dtk_Object
{
public:
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Preview * DtkDynamicCast(Dtk_Object * s);
 
    //constructors
     //! \CreateCopy{in}
    static Dtk_PreviewPtr Create(const Dtk_Preview& in);
     //! \brief Calls full featured constructor to allocate a new object.
    static Dtk_PreviewPtr Create(const char* inStream,const Dtk_Int32 inSizeStream);
    char *GetStream() const;
    Dtk_Int32 GetStreamSize() const;
    preview_type_detk GetType() const;
    void SetType(preview_type_detk inPreviewType);
 
protected:
    Dtk_Preview();
    Dtk_Preview( Dtk_Preview const& in );
    Dtk_Preview( Dtk_Preview && in ) DTK_NOEXCEPT;
 
     //! \sa Create(const char*,const Dtk_Int32 )
    Dtk_Preview(const char* inStream,const Dtk_Int32 inSizeStream);
    virtual ~Dtk_Preview();
    struct Dtk_Handle;
     std::unique_ptr<Dtk_Handle> _Private;
    friend class Dtk_SmartPtr<Dtk_Preview>;
};
 
 
//! \ingroup base_types
//! \class Dtk_AxisSystem
//! \brief This is the Dtk_AxisSystem class.
//! \brief A Dtk_AxisSystem contains the AxisSystem definition which is defined by its name, status and a matrix
//!
//!  This class lets you use Dtk_AxisSystem.
//! \SmartPtr{Dtk_AxisSystemPtr}
class Dtk_AxisSystem : public Dtk_Entity
{
protected:
     struct Dtk_Handle;
     std::unique_ptr<Dtk_Handle> _Private;
 
     Dtk_AxisSystem();
     //! \sa Create(const Dtk_AxisSystem &)
    Dtk_AxisSystem(const Dtk_AxisSystem& p);
     virtual ~Dtk_AxisSystem();
     inline virtual Dtk_Object* Clone(){     return new Dtk_AxisSystem( *this );     }
     friend class Dtk_SmartPtr<Dtk_AxisSystem>;
 
public:
     //! \return The type of the entity type - DTK_TYPE_AXIS_SYSTEM -
     type_detk get_type_detk() const
     {
          return DTK_TYPE_AXIS_SYSTEM;
     }
 
     //! \CreateBase
     static Dtk_SmartPtr<Dtk_AxisSystem> Create();
     ////! \deprecated Use Create instead.
     SetAsDeprecated( "2026.4", "Use Create instead" )
     static Dtk_SmartPtr<Dtk_AxisSystem> create();
 
     int DtkDynamicType( const int& inId );
     static Dtk_AxisSystem* DtkDynamicCast( Dtk_Object* inObject );
 
    //! \brief Get the Name of the AxisSystem.
    //! \return the Name of this AxisSystem  .
    //!
    Dtk_string GetName() const;
    //! \brief Set the Name of the AxisSystem.
    //! \return the Name of this AxisSystem  .
    //!
    void SetName(const Dtk_string& in) ;
 
    //! \brief Get the Matrix of the AxisSystem.
    //! \return the Matrix of this AxisSystem  .
    const Dtk_transfo& GetMatrix() const;
 
    //! \brief Get the Matrix of the AxisSystem.
    //! \param[in] in :  Matrix of the AxisSystem
    //! \return the Matrix of this AxisSystem  .
    //!
    void SetMatrix(const Dtk_transfo& in) ;
 
    //! \brief Get the visibility status.
    //! \return DTK_TRUE if it is visible  .
    //!
    int GetIsVisible() const;
    //! \brief Set the visibility status.
    //! \return DTK_TRUE if it is visible  .
    //!
    void SetIsVisible() ;
 
    //! \brief Get the hidden status.
    //! \return DTK_TRUE if it is hidden  .
    //!
    int GetIsHidden() const;
    //! \brief Set the hidden status.
    //! \return DTK_TRUE if it is hidden  .
    //!
    void SetIsHidden() ;
 
    //! \brief Get the default status.
    //! \return DTK_TRUE if it is Default Axis  .
    //!
    Dtk_bool IsDefault() const;
    //! \brief Set the default status.
    //! \return DTK_TRUE if it is hidden  .
    //!
    void SetDefaultStatus(Dtk_bool inDefaultStatus) ;
 
    //! \Transform{inTransfo}
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
};
 
//! \ingroup base_types
//! \class Dtk_ModelDisplay
//! \brief This is the Dtk_ModelDisplay class.
//! \SmartPtr{Dtk_ModelDisplayPtr}
class Dtk_ModelDisplay : public Dtk_Entity
{
protected:
    struct Dtk_Handle; // Not defined here
    std::unique_ptr<Dtk_Handle> _Private; // Handle
    enum { _typeID = DTK_TYPE_MODEL_DISPLAY };
 
    //! \sa Create()
    Dtk_ModelDisplay();
     //! \sa Create(const Dtk_ModelDisplay &)
    Dtk_ModelDisplay(const Dtk_ModelDisplay &);
    Dtk_ModelDisplay(Dtk_ModelDisplay&&) DTK_NOEXCEPT;
 
    //! \sa Create(const Dtk_CameraPtr& , const Dtk_EntityPtr&, const Dtk_bool)
    Dtk_ModelDisplay(
        const Dtk_CameraPtr& inCamera,
        const Dtk_EntityPtr& inClippingEntity,
        const Dtk_bool inIsActivated);
 
    inline virtual Dtk_Object* Clone() { return new Dtk_ModelDisplay(*this); }
 
    //! \BaseDestructor
    virtual ~Dtk_ModelDisplay();
private:
    friend class Dtk_SmartPtr<Dtk_ModelDisplay>;
 
public:
     enum RenderingModeEnum
     {
          rendering_mode_shaded_only=0,
          rendering_mode_shaded_with_visible_edges,
          rendering_mode_wireframe_with_all_edges,
          rendering_mode_wireframe_with_only_visible_edges,
          rendering_mode_static_wireframe,
          rendering_mode_wireframe_face_analysis,
          rendering_mode_wireframe_partially_shade,
          rendering_mode_studio,
          rendering_mode_unknown
     };
     enum SectionTypeEnum {
          SectionPlane = 0,
          SectionPlaneList,
          SectionParallelePlane,
          SectionBox,
          SectionBody,
          SectionUndefined
     };
 
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    //! \DtkDynamicCast
    static Dtk_ModelDisplay * DtkDynamicCast(Dtk_Object *s);
 
    //! \return The type of the entity type - DTK_TYPE_MODEL_DISPLAY -
    type_detk get_type_detk() const { return DTK_TYPE_MODEL_DISPLAY; }
 
     //! \brief Calls full featured constructor to allocate a new object.
    //! \param inCamera The included Dtk_Camera.
    //! \param inClipping The included clipping entity.
    //! \param inIsActivated Tells if the Capture is activated or not.
    //! \return The created Dtk_ModelDisplayPtr
    static Dtk_ModelDisplayPtr Create(
        const Dtk_CameraPtr& inCamera,
        const Dtk_EntityPtr& inClippingEntity,
        const Dtk_bool inIsActivated);
     //! \\CreateCopy{in}
     static Dtk_ModelDisplayPtr Create( const Dtk_ModelDisplay& in );
 
    //! \brief Retrieves the Dtk_ModelDisplay camera - read only -.
    //! \return The camera.
    const Dtk_CameraPtr& GetCamera() const;
 
    //! \brief Retrieves the Dtk_ModelDisplay clipping entity - read only -.
    //! \return The clipping entity.
    Dtk_EntityPtr GetClippingEntity() const;
 
    //! \brief Tells if the Dtk_ModelDisplay is activated or not - read only -.
    //! \return DTK_TRUE if capture is visible when opening the document (several can be activated ) DTK_FALSE else.
    Dtk_bool IsActivated() const;
 
     //! \brief Set the rendering mode shaded , shaded with edge , ...
     void SetRenderingMode(RenderingModeEnum inMode) const;
 
     //! \brief Get the rendering mode shaded , shaded with edge , ...
     RenderingModeEnum GetRenderingMode() const;
 
     //! \brief Set if this Dtk_ModelDisplay is a Standard View other case it is a user defined view
     void SetIsStandardView() const;
 
     //! \brief Get DTK_TRUE if this Dtk_ModelDisplay is a Standard View , DTK_FALSE if it is a user defined view .
     Dtk_bool GetIsStandardView() const;
 
     //! \brief Set the type of the section on the Dtk_ModelDisplay.
     //! \param inSectionType the section type.
     //! \param inIsLocked if section distance is locked.
     //! \param inThickness in case of a SectionParallelePlane, define the distance between the two parallel plane.
     void SetSectionInformation(const SectionTypeEnum& inSectionType, const Dtk_Int32& inIsLocked = DTK_FALSE, const Dtk_Double64& inThickness=0.0) const;
 
     //! \brief Get the type of the Section on the Dtk_Capture.
     //! \brief
     //! \brief SectionPlane : clipping by one plane , GetClippingEntity() return a Dtk_PlaneSurfacePtr .
     //! \image html SectionPlane.png
     //! \brief
     //! \brief SectionParallelePlane : clipping by two plane ,first one , GetClippingEntity() return a Dtk_PlaneSurfacePtr ,and the second is defined by a thickness from this plane.
     //! \image html SectionParallelePlane.png
     //! \brief
     //! \brief SectionBox : clipping by a box defined by six planes , GetClippingEntity() return a Dtk_BodyPtr with six plane surface.
     //! \image html SectionBox.png
     //! \brief
     //! \brief SectionBox : clipping by a Dtk_BodyPtr , GetClippingEntity() return a Dtk_BodyPtr .
     //! \image html SectionBody.png
     //! \param outSectionType the section type , outIsLocked if Section distance is locked and outThickness for SectionParallelePlane.
     void GetSectionInformation(SectionTypeEnum& outSectionType, Dtk_Int32& outIsLocked, Dtk_Double64& outThickness) const;
 
    //! \Transform{inTransfo}
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     //! \brief Visible layer for Dtk_ModelDisplay 
     void GetVisibleLayers( Dtk_tab<Dtk_Int32> &outVisibleLayers )const;
     void SetVisibleLayers( const Dtk_tab<Dtk_Int32> & inVisibleLayers );
 
};
 
 
//! \ingroup base_types
//! \class Dtk_ConstraintReference
//! \brief This is the Dtk_ConstraintReference class.
//! \brief A Dtk_ConstraintReference contains the AxisSystem definition which defines by its Name, statut and the Matrix
//!
//!  This class lets you use Dtk_ConstraintReference.
//! \SmartPtr{Dtk_ConstraintReferencePtr}
class Dtk_ConstraintReference : public Dtk_Entity
{
protected:
     Dtk_ConstraintReference();
     //! \sa Create( const Dtk_ConstraintReference &)
     Dtk_ConstraintReference( const Dtk_ConstraintReference& p );
     virtual ~Dtk_ConstraintReference();
     struct Dtk_Handle;
     std::unique_ptr<Dtk_Handle> _Private;
     inline virtual Dtk_Object* Clone(){     return new Dtk_ConstraintReference( *this ); }
     friend class Dtk_SmartPtr<Dtk_ConstraintReference>;
 
public:
 
     //! \brief Get the Dtk_NodeConnectorPtr of the ConstraintReference .
     //! \return the Dtk_NodeConnectorPtr of this ConstraintReference  .
     //!
     const Dtk_NodeConnectorPtr& GetNodeConnector() const;
     //! \brief Set the type of the Constraint .
     //!
     void SetNodeConnector(const Dtk_NodeConnectorPtr& in);
 
 
     //! \brief Get the Position of the ConstraintReference .
     //! \return the Position of this ConstraintReference  .
     //!
     const Dtk_pnt& GetPosition(Dtk_bool & outHasPosition) const;
     //! \brief Set the Position of the ConstraintReference .
     //!
     void SetPosition(const Dtk_pnt& in);
 
 
     //! \return The type of the entity type - DTK_TYPE_CONSTRAINT_REFERENCE -
     type_detk get_type_detk() const { return DTK_TYPE_CONSTRAINT_REFERENCE; }
 
     //! \CreateBase
     static Dtk_SmartPtr<Dtk_ConstraintReference> Create();
     //! \\CreateCopy{in}
     static Dtk_ConstraintReferencePtr Create( const Dtk_ConstraintReference& in );
     int DtkDynamicType(const int& inId);
     static Dtk_ConstraintReference* DtkDynamicCast(Dtk_Object * inObject);
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
};
 
 
//! \ingroup base_types
//! \class Dtk_Constraint
//! \brief This is the Dtk_Constraint class.
//! \brief A Dtk_Constraint contains the AxisSystem definition which defines by its Name, statut and the Matrix
//!
//!  This class lets you use Dtk_Constraint.
//!  \SmartPtr{Dtk_ConstraintPtr}
class Dtk_Constraint : public Dtk_Entity
{
protected:
     Dtk_Constraint();
     //! \sa Create( const Dtk_Constraint &)
     Dtk_Constraint( const Dtk_Constraint& p );
     Dtk_Constraint( Dtk_Constraint&& p ) DTK_NOEXCEPT;
     virtual ~Dtk_Constraint();
     struct Dtk_Handle;
     std::unique_ptr<Dtk_Handle> _Private;
     inline virtual Dtk_Object* Clone(){     return new Dtk_Constraint( *this );     }
     friend class Dtk_SmartPtr<Dtk_Constraint>;
 
public:
 
     //! \return The type of the entity type - DTK_TYPE_CONSTRAINT -
     type_detk get_type_detk() const { return DTK_TYPE_CONSTRAINT; }
 
     //! \CreateBase
     static Dtk_SmartPtr<Dtk_Constraint> Create();
     //! \\CreateCopy{in}
     static Dtk_SmartPtr<Dtk_Constraint> Create( const Dtk_Constraint& in );
     int DtkDynamicType(const int& inId);
     static Dtk_Constraint* DtkDynamicCast(Dtk_Object * inObject);
 
     enum ConstraintOrientationTypeEnum
     {
          ValueTypeUndefined = 0,
          ValueTypeSame,
          ValueTypeOpposite,
          ValueTypeInternal,
          ValueTypeExternal,
     };
     static Dtk_string ConstraintOrientationTypeEnumToString( const ConstraintOrientationTypeEnum &inEnum )
     {
          switch( inEnum )
          {
               case ValueTypeSame:      return L"TypeSame";
               case ValueTypeOpposite:  return L"TypeOpposite";
               case ValueTypeInternal:  return L"TypeInternal";
               case ValueTypeExternal:  return L"TypeExternal";
               default:
               case ValueTypeUndefined: return L"TypeUndefined";
          }
     }
 
     enum ConstraintValueTypeEnum
     {
          ValueTypeUnknown = 0,
          ValueTypeAngle,
          ValueTypeDistance,
          ValueTypePosition,
          ValueTypeRotation,
          ValueTypeOrientation,
     };
     static Dtk_string ConstraintValueTypeEnumToString( const ConstraintValueTypeEnum &inEnum )
     {
          switch( inEnum )
          {
               case ValueTypeAngle:                    return L"Angle";
               case ValueTypeDistance:                 return L"Distance";
               case ValueTypePosition:                 return L"Position";
               case ValueTypeRotation:                 return L"Rotation";
               case ValueTypeOrientation:              return L"Orientation";
               default:
               case ValueTypeUnknown: return L"TypeUnknown";
          }
     }
 
     class _ConstraintValue
     {
     public:
          _ConstraintValue();
          ~_ConstraintValue(){};
 
          _ConstraintValue(const ConstraintValueTypeEnum& inValueType, Dtk_Val inValue, const Dtk_Int32& inEnableLowerLimit, const Dtk_Double64& inLowerLimit, const Dtk_Int32& inEnableUpperLimit, const Dtk_Double64& inUpperLimit);
          _ConstraintValue(const ConstraintValueTypeEnum& inValueType, Dtk_Val inValue);
 
          ConstraintValueTypeEnum _ValueType;
          Dtk_Val _Value;
          Dtk_Int32 _EnableLower;
          Dtk_Int32 _EnableUpper;
          Dtk_Double64 _ValueLower;
          Dtk_Double64 _ValueUpper;
     private:
 
     };
 
     enum ConstraintTypeEnum
     {
          TypeUnknown = 0,
          //! \image html align.png
          TypeAlign,
          //! \image html angle.png
          TypeAngle,
          //! \image html bond.png
          TypeBond,
          TypeCam,
          //! \image html center.png
          TypeCenter,
          //! \image html concentric.png
          TypeConcentric,
          //! \image html coincidence.png
          TypeCoincidence,
          //! \image html distance.png
          TypeDistance,
          //! \image html fit.png
          TypeFit,
          //! \image html fix.png
          TypeFix,
          TypeGear,
          TypeHinge,
          TypeLimit,
          TypeLinear,
          TypeLinearCoupler,
          //! \image html lock.png
          TypeLock,
          //! \image html orientangle.png
          TypeOrientAngle,
          //! \image html parallel.png
          TypeParallel,
          TypePathMate,
          //! \image html perpendicular.png
          TypePerpendicular,
          TypeProfileCenter,
          TypeRackPinion,
          TypeScrew,
          TypeSlot,
          //! \image html symmetric.png
          TypeSymmetric,
          //! \image html tangent.png
          TypeTangent,
          //! \image html touch.png
          TypeTouch,
          TypeUniversalJoint,
          TypeWidth
     };
     static Dtk_string ConstraintTypeEnumToString(const ConstraintTypeEnum& inEnum)
     {
          switch (inEnum)
          {
          case TypeAlign:                return L"TypeAlign";
          case TypeAngle:                return L"TypeAngle";
          case TypeBond:                 return L"TypeBond";
          case TypeCam:                  return L"TypeCam";
          case TypeCenter:               return L"TypeCenter";
          case TypeConcentric:           return L"TypeConcentric";
          case TypeCoincidence:          return L"TypeCoincidence";
          case TypeDistance:             return L"TypeDistance";
          case TypeFit:                  return L"TypeFit";
          case TypeFix:                  return L"TypeFix";
          case TypeGear:                 return L"TypeGear";
          case TypeHinge:                return L"TypeHinge";
          case TypeLimit:                return L"TypeLimit";
          case TypeLinear:               return L"TypeLinear";
          case TypeLinearCoupler:        return L"TypeLinearCoupler";
          case TypeLock:                 return L"TypeLock";
          case TypeOrientAngle:          return L"TypeOrientAngle";
          case TypeParallel:             return L"TypeParallel";
          case TypePathMate:             return L"TypePathMate";
          case TypePerpendicular:        return L"TypePerpendicular";
          case TypeProfileCenter:        return L"TypeProfileCenter";
          case TypeRackPinion:           return L"TypeRackPinion";
          case TypeScrew:                return L"TypeScrew";
          case TypeSlot:                 return L"TypeSlot";
          case TypeSymmetric:            return L"TypeSymmetric";
          case TypeTangent:              return L"TypeTangent";
          case TypeTouch:                return L"TypeTouch";
          case TypeUniversalJoint:       return L"TypeUniversalJoint";
          case TypeWidth:                return L"TypeWidth";
          default:
          case TypeUnknown:              return L"Unknown";
          }
     }
 
     //! \brief Get the type of the Constraint .
     //! \return the type of this Constraint  .
     const ConstraintTypeEnum& GetConstraintType() const;
     //! \brief Set the type of the Constraint .
     void SetConstraintType(const ConstraintTypeEnum& in);
 
     //! \brief Get the number of Dtk_Constraint::_ConstraintValue in the constraint.
     //! \return The number of Dtk_Constraint::_ConstraintValue in the constraint.
     //!
     Dtk_Size_t GetNumberOfConstraintValues();
 
     //! \brief Get the Dtk_Constraint::_ConstraintValue at the specified index.
     //! \return A Dtk_Constraint::_ConstraintValue.
     //!
     const _ConstraintValue& GetConstraintValue( const Dtk_Size_t &index ) const;
 
     //! \brief Get a Value of the Constraint .
     //! \return a Value of this Constraint  .
     Dtk_ErrorStatus GetValue( const ConstraintValueTypeEnum& inValue, Dtk_Val& outValue, Dtk_Int32& outEnableLowerLimit, Dtk_Double64& outLowerLimit, Dtk_Int32& outEnableUpperLimit, Dtk_Double64& outUpperLimit ) const;
     Dtk_ErrorStatus GetValue( const ConstraintValueTypeEnum& inValue, Dtk_Val& outValue ) const;
 
     //! \brief Get all types of values in the Constraint.
     //! \return All types of values contained in the Constraint.
     Dtk_tab< ConstraintValueTypeEnum > GetValuesTypes() const;
 
     //! \brief Set a Value of the Constraint .
     void SetValue( const ConstraintValueTypeEnum& inValueType, Dtk_Val inValue, const Dtk_Int32& inEnableLowerLimit, const Dtk_Double64& inLowerLimit, const Dtk_Int32& inEnableUpperLimit, const Dtk_Double64& inUpperLimit );
     void SetValue( const ConstraintValueTypeEnum& inValueType, Dtk_Val inValue );
 
     //! \brief Get the number of Dtk_ConstraintReference in the constraint.
     //! \return The number of Dtk_ConstraintReference in the constraint.
     Dtk_Size_t GetNumberOfConstraintReferences() const;
 
     //! \brief Get the Dtk_ConstraintReference at the specified index.
     //! \param The index to retrieve the Dtk_ConstraintReference from.
     //! \return A Dtk_ConstraintReference.
     const Dtk_ConstraintReferencePtr& GetConstraintReference( const Dtk_Size_t &index ) const;
 
     //! \brief Get all ConstraintReferences of the Constraint.
     //! \return A tab with all the ConstraintReferences of this Constraint.
     const Dtk_tab<Dtk_ConstraintReferencePtr>& GetConstraintReference() const;
 
     //! \brief Add a ConstraintReference to this Constraint .
     void AddConstraintReference( const Dtk_ConstraintReferencePtr& in );
 
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
};
 
#endif