dtk_maindoc.hpp

Go to the documentation of this file.

#ifndef __UTIL_DTK_DOCUMENT_HPP__
#define __UTIL_DTK_DOCUMENT_HPP__
 
#include "def/define.h"
#include "util/BaseTypes/dtk_metadata.hpp"
#include "util/BaseTypes/dtk_object.hpp"
#include "util/BaseTypes/dtk_pnt.hpp"
#include "util/BaseTypes/dtk_string.hpp"
#include "util/BaseTypes/dtk_transfo.hpp"
#include "util/dtk_global_data_set_ptr.hpp"
#include "util/dtk_maindoc_ptr.hpp"
#include "util/dtk_override_ptr.hpp"
#include "util/error_dtk.hpp"
#include "util/util_draw_ptr_dtk.hpp"
#include "util/util_ent_dtk.hpp"
#include "util/util_ptr_dtk.hpp"
#include "util/util_stl_dtk.hpp"
#include "util/util_topology_ptr_dtk.hpp"
#include <memory>
 
class Dtk_mesh;
typedef Dtk_SmartPtr<Dtk_mesh>                         Dtk_MeshPtr;
class Dtk_feat;
typedef Dtk_SmartPtr<Dtk_feat> Dtk_FeaturePtr;
class Dtk_Kinematic;
typedef Dtk_SmartPtr<Dtk_Kinematic> Dtk_KinematicPtr;
 
 
enum DtkReaderType
{
     V5ReaderModule = 0,      // CatiaV5 
     VdaReaderModule = 1,     // VdaFS 
     InvReaderModule = 2,     // Inventor
     V4ReaderModule = 3,      // CatiaV4
     UgReaderModule = 4,      // Unigraphics NX
     XmtReaderModule = 5,     // Parasolid using parasolid kernel
     SwReaderModule = 6,      // Solidworks
     SeReaderModule = 7,      // Solidedge
     IgesReaderModule = 8,    // Iges
     StepReaderModule = 9,    // Step
     PsReaderModule = 10,     // Parasolid via datakit
     ProeReaderModule = 11,   // Pro/Engineer - Creo Parametric 
     SatReaderModule = 12,    // Internal Use Only
     JtReaderModule = 13,     // Jt 
     CgrReaderModule = 14,    // Cgr
     CaddsReaderModule = 15,  // Cadds 
     AcisReaderModule = 16,   // Acis
     ProCeraReaderModule = 17,// ProCera dental format
     CerconReaderModule = 18, // Cercon dental format
     CerecReaderModule = 19,  // Cerec Sirona dental format
     DcmReaderModule = 20,    // Dcm 3Shape dental format 
     _3dXmlReaderModule = 21, // Internal Use Only
     XmlReaderModule = 22,    // Internal Use Only
     V6ReaderModule = 23,     // 3DEXPERIENCE CatiaV6
     DxfReaderModule = 24,    // Dxf
     PlmXmlReaderModule = 25, // PlmXml
     Lava3mReaderModule = 26, // Lava 3M dental format
     U3dReaderModule = 27,    // Internal Use Only
     PdfReaderModule = 28,    // Internal Use Only
     RnXmlReaderModule = 29,  // Internal Use Only
     _3dmReaderModule = 30,   // Rhino 
     DwgReaderModule = 31,    // Dwg
     ObjReaderModule = 32,    // Obj  
     IfcReaderModule = 33,    // Ifc
     BRepOccReaderModule = 34,// Brep Open Cascade
     RevitReaderModule = 35,  // Revit
     CreoviewReaderModule = 36,// Creo View 
     StlReaderModule = 37,    // Stl
     FbxReaderModule = 38,    // Fbx
     CgmReaderModule = 39,    // Computer Graphics Metafile
     SdnfReaderModule = 40,    // Computer Graphics Metafile
     ArtReaderModule = 41,    // Art
     SmgReaderModule = 42,    // Smg
     PrcReaderModule = 43,    // Prc
     F3dReaderModule = 44,    // F3d
     DstvReaderModule = 45,   // DSTV
     GltfReaderModule = 46,    // Gltf
     NavisReaderModule = 47,   // Navis
     QifReaderModule = 48,    // QIF
     DwgDtkReaderModule = 49, // Dwg via datakit
     Zw3dReaderModule = 50,   // Zw3d
    UsdReaderModule = 51,    // USD
 
    UnknownModule,
  MaxReaderModules
};
 
typedef Dtk_ID Dtk_ComponentID;
typedef Dtk_ID Dtk_NodeID;
 
 
class Dtk_MainDoc;
 
 
/////////////////////////////////////////////////////////////////////////////
//! \ingroup DtkAPIGroup
//! \class Dtk_DocElement 
//! \brief This is the Main Doc Element Class
//! The Dtk_DocElement object is common parent class of the Dtk_Node and the Dtk_Component classes
//! It typically used as geometry into a Part.
//! \SmartPtr{Dtk_DocElementPtr}
class Dtk_DocElement : public Dtk_Object
{
protected: 
 
    enum { _typeID = DTK_TYPE_DOC_ELEMENT }; 
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
protected:
 
    //! \internal
    Dtk_DocElement(const Dtk_ID& inID, Dtk_string inName);
 
    //! \BaseDestructor 
    virtual ~Dtk_DocElement();
 
 
    //! \brief Adds a child Dtk_DocElement to main Element.
    //! \param inChild The Dtk_DocElement to be added as a child.
    void _AddChild(const Dtk_DocElementPtr& inChild);
 
    //! \brief Retrieves the ith Dtk_DocElement - read only -
    //! \param inPos Child element index.
    //! \return the inPos'th Dtk_DocElement
    const Dtk_DocElementPtr _GetChild(const Dtk_Size_t& inPos) const;
 
    //! \brief Replaces a child by another one. Also update father lists.
    //! \param inPos Old Child element index.
    //! \param inNewChild The Dtk_DocElement replacing the old one
    //! \DtkInternal
    //! \return the DtkNoerrror if success.
    //! \return the dtkErrorOutOfRange if bad inPos parameter.
    //! \return the dtkErrorNullPointer if inNewChild is NULL.
    Dtk_ErrorStatus _ReplaceChild(const Dtk_Size_t& inPos, const Dtk_DocElementPtr& inNewChild);
 
    friend class Dtk_SmartPtr<Dtk_DocElement>;
    friend class Dtk_MainDoc;
 
public:
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const int& inId);
 
    //! \DtkDynamicCast
    static Dtk_DocElement* DtkDynamicCast(Dtk_Object *s);
 
    //! \brief Retrieves the number of the Dtk_DocElement children - read only -
    //! \return The Children number.
    Dtk_Size_t GetNumChildren() const;
 
    //! \brief Retrieves the Dtk_DocElement Name - read only -
    //! \return The Element Name.
    const Dtk_string& Name() const;
    Dtk_string& Name();
 
    //! \brief Retrieves the Dtk_DocElement ID - read only -
    //! \return The element ID.
    Dtk_ID GetID() const;
 
    //! \brief Retrieves Dtk_DocElement ith FatherID - read only -
    //! \return The ith FatherID.
    Dtk_ID GetFatherID(Dtk_Size_t inIndex)const;
 
     //! \brief GetNumFather
     //! \return Number of fathers
     Dtk_Size_t GetNumFathers()const;
 
    void GetReadID(Dtk_ID& outReadID) const;
    void SetReadID(const Dtk_ID & inNewID);
 
 
    //! \brief Retrieves the Dtk_DocElement Dtk_InfoPtr - read only -
    //! \return The element Dtk_InfoPtr.
    Dtk_InfoPtr GetInfos() const;
    void SetInfos(const Dtk_InfoPtr& inInfos);
 
 
     //! \brief Retrieves the Dtk_DocElement Dtk_MaterialPtr - read only -
     //! \return The element Dtk_MaterialPtrif if exists
     //!\deprecated use GetInfos()->GetRenderInfos and GetInfos()->GetPhysicalMaterialInfos methods instead
     SetAsDeprecated( "2026.3", "use GetInfos()->GetRenderInfos and GetInfos()->GetPhysicalMaterialInfos methods instead." )
     Dtk_MaterialPtr GetMaterial() const;
     //!\deprecated use  GetInfos()->AddRenderInfos and GetInfos()->AddMaterialInfos methods instead
     SetAsDeprecated( "2026.3", "use GetInfos()->AddRenderInfos and GetInfos()->AddMaterialInfos methods instead." )
     void SetMaterial(Dtk_MaterialPtr inMaterial);
 
 
     //! \brief Retrieves the Dtk_DocElement Dtk_PreviewPtr - read only -
     //! \return The element Dtk_PreviewPtr if exists.
     Dtk_PreviewPtr GetPreview() const;
    void SetPreview(Dtk_PreviewPtr inPreview);
    void ReleasePreview();
 
 
    //! \brief Adds a Dtk_MetaDataPtr to the Dtk_DocElement.
    //! \param inMetaData The Dtk_MetaDataPtr to be added.
    void AddMetaData(const Dtk_MetaDataPtr& inMetaData);
 
     //! \brief Adds a Dtk_MetaDataGroupPtr to the Dtk_DocElement.
     //! \param inMetaDataGroup The Dtk_MetaDataGroupPtr to be added.
     //! \param inAddMetadata If we also add the metadata of the group to the Dtk_DocElement
     void AddMetaDataGroup(const Dtk_MetaDataGroupPtr& inMetaDataGroup, Dtk_bool inAddMetadata = DTK_FALSE);
 
    //! \brief Adds a Dtk_PropertiesPtr to the Dtk_DocElement.
    //! \param inProperty The Dtk_PropertiesPtr to be added.
    void AddProperty(const Dtk_PropertiesPtr & inProperty);
 
    //! \brief Retrieves the ith Dtk_MetaDataPtr - read only -
    //! \param inPos Metadata index.
    //! \return the inPos'th Dtk_MetaDataPtr
    Dtk_MetaDataPtr GetMetaData(const Dtk_Size_t& inPos) const;
 
     //! \brief Retrieves the ith Dtk_MetaDataGrouplPtr - read only -
     //! \param inPos Group index.
     //! \return the inPos'th Dtk_MetaDataGrouplPtr
     Dtk_MetaDataGroupPtr GetMetaDataGroup(const Dtk_Size_t& inPos) const;
 
    //! \brief Retrieves the number of the Dtk_MetaDataPtr - read only -
    //! \return The Metadata number.
    Dtk_Size_t GetNumMetaData() const;
 
     //! \brief Retrieves the number of the Dtk_MetaDataGroupPtr - read only -
     //! \return The Group number.
     Dtk_Size_t GetNumMetaDataGroup() const;
};
 
/////////////////////////////////////////////////////////////////////////////
//! \ingroup DtkAPIGroup
//! \class Dtk_Node 
//! \brief This is the Node Class
//! \brief The Dtk_Node is used to retrieve information from a Dtk_Component.
//! \details It is typically used as geometry into a Part.
//! \SmartPtr{Dtk_NodePtr}
class Dtk_Node : public Dtk_DocElement
{
public:
 
     enum BodyNodeDataTypeEnum
     {
          UnknownType = 0,
          HasPoints     = 1,                         
          HasCurves     = 2,                         
          HasSurfaces   = 4,                          
          HasSolids     = 8,                
          HasAxis = 16,
          HasMesh = 32,
          HasMeshSurfaces = 64
     };
 
    enum NodeDataTypeEnum
    {
        NullType = 0,
          BodyType,                           // for 3D
          MeshType,                           // for 3D Tesselated
        AnnotationSetType,                  // for FdtAnnotationSet -- Obsolete 
        FdtType,                            // for Fdt
        DrawingType,                        // for 2D
          KinematicsType,                              // Kinematics
          AxisSystemType,                             // AxisPlacement
          LayerInfosSetType,                      // LayerInfosSet
          ColorInfosSetType,                      // ColorInfosSet
          MetaDataType,                       // MetaData 
        ModelDisplayType,                         // Model Display 
        CameraType,                             // Camera
          VirtualType,                        // just for containing children
          ConstraintType,                     // ConstraintType
        MaxNodeDataType
    };
    //! \ingroup DtkAPIGroup
    //! \class Dtk_Node::FullType
    //! \brief This is the Node FullType Class
    //! The Dtk_Node::FullType object is used to retrieve the full informations about Dtk_Node Type - Primary and SubType -
    class FullType
    {
    public: 
        friend class Dtk_Node;
    private:
        //! \brief Primary Node Type
        NodeDataTypeEnum                        _PrimaryType;
        //! \brief SubType - if relevant -
        type_detk                               _SubType;
    public:
        FullType( const NodeDataTypeEnum inPrimaryType, const type_detk inSubType ) : _PrimaryType(inPrimaryType), _SubType(inSubType) {}
        ~FullType() {}
        FullType() : _PrimaryType(NullType), _SubType(DTK_TYPE_UNKNOWN) {}
        inline NodeDataTypeEnum PrimaryType() const {return _PrimaryType;}
        inline type_detk SubType() const {return _SubType;}
    };
     
 
    static Dtk_string NodeDataTypeEnumToString(const NodeDataTypeEnum& inEnum)
    {
        switch( inEnum )
        {
        case NullType: return L"NullType";
          case BodyType: return L"BodyType";
          case MeshType: return L"MeshType";
        case AnnotationSetType: return L"AnnotationSetType";
        case FdtType: return L"FdtType";
        case DrawingType: return L"DrawingType";
          case KinematicsType: return L"KinematicsType";
          case AxisSystemType: return L"AxisSystemType";
          case LayerInfosSetType: return L"LayerInfosSetType";
          case ColorInfosSetType: return L"ColorInfosSetType";
          case MetaDataType: return L"MetaDataType";
        case VirtualType: return L"VirtualType";
        case ModelDisplayType : return L"ModelDisplayType";
        case CameraType : return L"CameraType";
        case ConstraintType: return L"Constraint";
        default: return L"Unknown";
        }
    }
 
     static Dtk_Int32 NodeDataStringToEnumType( const Dtk_string &type )
     {
          if( type == L"NullType" )
               return NullType;
          else if( type == L"BodyType" )
               return BodyType;
          else if( type == L"MeshType" )
               return MeshType;
          else if( type == L"AnnotationSetType" )
               return AnnotationSetType;
          else if( type == L"FdtType" )
               return FdtType;
          else if( type == L"DrawingType" )
               return DrawingType;
          else if( type == L"KinematicsType" )
               return KinematicsType;
          else if( type == L"AxisSystemType" )
               return AxisSystemType;
          else if (type == L"LayerInfosSetType")
               return LayerInfosSetType;
          else if (type == L"ColorInfosSetType")
               return ColorInfosSetType;
          else if( type == L"MetaDataType" )
               return MetaDataType;
          else if( type == L"VirtualType" )
               return VirtualType;
        else if (type == L"ModelDisplayType")
            return ModelDisplayType;
        else if (type == L"CameraType")
            return CameraType;
        else if (type == L"ConstraintType")
            return ConstraintType;
          else return -1;          
     }
 
protected: 
 
    enum { _typeID = DTK_TYPE_NODE }; 
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    friend class Dtk_Component;
private:
    //! \sa Dtk_Component::CreateVirtualNode( const Dtk_string& )
     //! \sa Dtk_Component::CreateMeshNode(const Dtk_string&, const Dtk_ID&);
     //! \sa Dtk_Component::CreateBodyNode(const Dtk_string&, const Dtk_ID&);
     //! \sa Dtk_Component::CreateKinematicsNode(const Dtk_string&, const Dtk_KinematicsPtr&);
    //! \sa Dtk_Component::CreateDrawingNode(const Dtk_string&, const Dtk_DrawingPtr&);
    Dtk_Node(const Dtk_NodeID& inID, 
        const Dtk_ComponentID inOwningComponentId,
        Dtk_string inName, const NodeDataTypeEnum& inDataNodeType, const Dtk_ID inEntityID, const Dtk_Int32 inBodyFlag = UnknownType, const type_detk inSubType = DTK_TYPE_NO_SUBTYPE);
 
     Dtk_Node( const Dtk_Node& ) = delete;
     Dtk_Node& operator=( const Dtk_Node& ) = delete;
     Dtk_Node( Dtk_Node&& ) = delete;
     Dtk_Node& operator=( Dtk_Node&& ) = delete;
    //! \BaseDestructor 
    ~Dtk_Node();
 
    friend class Dtk_SmartPtr<Dtk_Node>;
 
public:
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const int& inId);
 
    //! \DtkDynamicCast
    static Dtk_Node* DtkDynamicCast(Dtk_Object *s);
 
    //! \brief Adds a child Dtk_Node to main Node.
    //! \param inChild The Dtk_Node to be added as a child.
    inline void AddChild(const Dtk_NodePtr& inChild) 
    { _AddChild( Dtk_DocElementPtr::DtkDynamicCast(inChild) ); }
 
    //! \brief Retrieves the ith Dtk_Node - read only -
    //! \param inPos Child node index.
    //! \return the inPos'th Dtk_Node
    inline const Dtk_NodePtr GetChild(const Dtk_Size_t& inPos) const 
    { return Dtk_NodePtr::DtkDynamicCast( _GetChild(inPos) ); }
 
    //! \brief Replaces a child Dtk_NodePtr by another one. Also updates father lists.
    //! \param inPos Old Child Dtk_NodePtr element index.
    //! \param inNewChild The Dtk_NodePtr replacing the old one
    //! \DtkInternal
    //! \return the DtkNoerrror if success.
    //! \return the dtkErrorOutOfRange if bad inPos parameter.
    //! \return the dtkErrorNullPointer if inNewChild is NULL.
    inline Dtk_ErrorStatus ReplaceChildNode(const Dtk_Size_t& inPos, const Dtk_NodePtr& inNewChild)
    { return _ReplaceChild( inPos, Dtk_DocElementPtr::DtkDynamicCast(inNewChild) ); }
 
    //! \brief Retrieves the Dtk_Node Node Type - read only -
    //! \return The Node Type.
    //! \deprecated
    //! \sa Dtk_Node::GetNodeFullType()
     //SetAsDeprecated("Undefined", "Use GetNodeFullType")
    NodeDataTypeEnum GetNodeType() const;
 
    //! \brief Retrieves the Node SubType - if relevant - - read only -
    //! \return The Node SubType.
    //! \deprecated
    //! \sa Dtk_Node::GetNodeFullType()
     //SetAsDeprecated("Undefined", "Use GetNodeFullType")
     type_detk GetNodeSubType() const;
 
    //! \brief Retrieves the Node FullType - Primary ans Sub Type - - read only -
    //! \return The Node FullType.
    const Dtk_Node::FullType GetNodeFullType() const;
 
     //! \brief Return DTK_TRUE if Dtk_Node Type Body or Mesh contains points entity
     Dtk_bool NodeHasPoints() const;
     //! \brief Return DTK_TRUE if Dtk_Node Type Body or Mesh contains curves entity
     Dtk_bool NodeHasCurves() const;
     //! \brief Return DTK_TRUE if Dtk_Node Type Body contains solid entity
     Dtk_bool NodeHasSolids() const;
     //! \brief Return DTK_TRUE if Dtk_Node Type Body contains surfacic entity
     Dtk_bool NodeHasSurfaces() const;
     //! \brief Return DTK_TRUE if Dtk_Node Type Body contains mesh surface entity
     Dtk_bool NodeHasMeshSurfaces() const;
     //! \brief Return DTK_TRUE if Dtk_Node Type Body contains axis entity
     Dtk_bool NodeHasAxis() const;
     //! \brief Return DTK_TRUE if Dtk_Node Type Body or Mesh contains mesh entity
     Dtk_bool NodeHasMesh() const;
 
 
    //! \brief Retrieves the Dtk_Node as a Dtk_BodyPtr - if exists -
    //! \return The Dtk_Node as a Dtk_BodyPtr if exists. Null Dtk_BodyPtr else.
    //! \remark This method is used to retrieve the body  
    //! informations - if GetNodeType() method returns BodyType -.
    Dtk_BodyPtr GetDtk_BodyPtr();
 
     //! \brief Retrieves the Dtk_Node as a Dtk_meshPtr - if exists -
     //! \return The Dtk_Node as a Dtk_meshPtr if exists. Null Dtk_meshPtr else.
     //! \remark This method is used to retrieve the mesh  
     //! informations - if GetNodeType() method returns MeshType -.
     Dtk_MeshPtr GetDtk_MeshPtr();
 
     //! \brief Retrieves the Dtk_Node as a Dtk_FeaturePtr - if exists -
     //! \return The Dtk_Node as a Dtk_FeaturePtr if exists. Null Dtk_FeaturePtr else.
     //! \remark This method is used to retrieve the feature  
     //! informations - if GetNodeType() method returns Virtual Type or Body Type-.
     Dtk_FeaturePtr GetDtk_FeaturePtr();
    //! \brief Retrieves the Dtk_Node as a Dtk_AdvancedFeaturePtr - if exists - Internal Use !!!
    //! \return The Dtk_Node as a Dtk_FeaturePtr if exists. Null Dtk_FeaturePtr else.
    //! \remark 
     Dtk_ObjectPtr GetDtk_AdvancedFeaturePtr();
 
 
    //! \brief Retrieves the Dtk_Node as a Dtk_FdtPtr - if exists -
    //! \return The Dtk_Node as a Dtk_FdtPtr if exists. Null Dtk_FdtPtr else.
    //! \remark This method is used to retrieve the FDT  
    //! informations - if GetNodeType() method returns FdtType -.
    Dtk_FdtPtr GetDtk_FdtPtr();
 
 
     //! \brief Retrieves the Dtk_Node as a Dtk_KinematicPtr - if exists -
     //! \return The Dtk_Node as a Dtk_KinematicsPtr if exists. Null Dtk_KinematicPtr else.
     //! \remark This method is used to retrieve the Kinematics  
     //! informations - if GetNodeType() method returns KinematicsType -.
     Dtk_KinematicPtr GetDtk_KinematicPtr();
 
     //! \brief Retrieves the Dtk_Node as a Dtk_MetaDataPtr - if exists -
     //! \return The Dtk_Node as a MetaDataPtr if exists. Null MetaDataPtr else.
     //! \remark This method is used to retrieve the MetaData  
     //! informations - if GetNodeType() method returns MetaDataType -.
     Dtk_MetaDataPtr GetDtk_MetaDataPtr();
 
    //! \brief Retrieves the Dtk_Node as a Dtk_DrawingPtr - if exists -
    //! \return The Dtk_Node as a Dtk_DrawingPtr if exists. Null Dtk_DrawingPtr else.
    //! \remark This method is used to retrieve the drawing  
    //! informations - if GetNodeType() method returns DrawingType -.
    Dtk_DrawingPtr GetDtk_DrawingPtr();
 
     //! \brief Retrieves the Dtk_Node as a Dtk_AxisSystemPtr - if exists -
     //! \return The Dtk_Node as a Dtk_AxisSystemPtr if exists. Null Dtk_AxisSystemPtr else.
     //! \remark This method is used to retrieve the axis placement 
     //! informations - if GetNodeType() method returns AxisSystemType -.
     Dtk_AxisSystemPtr GetDtk_AxisSystemPtr();
 
    //! \brief Retrieves the Dtk_Node as a Dtk_LayerInfosSetPtr - if exists -
    //! \return The Dtk_Node as a Dtk_LayerInfosSetPtr if exists. Null Dtk_LayerInfosSetPtr else.
    //! \remark This method is used to retrieve the layer infos set
    //! informations - if GetNodeType() method returns LayerInfosSetType -.
    Dtk_LayerInfosSetPtr GetDtk_LayerInfosSetPtr();
 
     //! \brief Retrieves the Dtk_Node as a Dtk_ColorInfosSetPtr - if exists -
     //! \return The Dtk_Node as a Dtk_ColorInfosSetPtr if exists. Null Dtk_ColorInfosSetPtr else.
     //! \remark This method is used to retrieve the color infos set
     //! informations - if GetNodeType() method returns ColorInfosSetType -.    
     Dtk_ColorInfosSetPtr GetDtk_ColorInfosSetPtr();
 
    //! \brief Retrieves the Dtk_Node as a Dtk_ModelDisplayPtr - if exists -
    //! \return The Dtk_Node as a Dtk_ModelDisplayPtr if exists. Null Dtk_ModelDisplayPtr else.
    //! \remark This method is used to retrieve the display model entity (camera capture)
    //! informations - if GetNodeType() method returns ModelDisplayType -.
    Dtk_ModelDisplayPtr GetDtk_ModelDisplayPtr();
 
    //! \brief Retrieves the Dtk_Node as a Dtk_CameraPtr - if exists -
    //! \return The Dtk_Node as a Dtk_CameraPtr if exists. Null Dtk_CameraPtr else.
    //! \remark This method is used to retrieve the camera entity
    //! informations - if GetNodeType() method returns CameraType -.
    Dtk_CameraPtr GetDtk_CameraPtr();  
     
     //! \brief Retrieves the Dtk_Node as a Dtk_ConstraintPtr - if exists -
    //! \return The Dtk_Node as a Dtk_ConstraintPtr if exists. Null Dtk_ConstraintPtr else.
    //! \remark This method is used to retrieve the Constraint entity
    //! informations - if GetNodeType() method returns ConstraintType -.
    Dtk_ConstraintPtr GetDtk_ConstraintPtr();
 
    //! \brief Retrieves the Dtk_Node as a Dtk_KinematicsPtr - if exists -
     //! \return The Dtk_Node as a Dtk_Kinematic if exists. Null Dtk_Kinematics else.
     //! \remark This method is used to retrieve the kinematic info 
     //! informations - if GetNodeType() method returns KinematicFilterType -.
     //Dtk_KinematicsPtr GetDtk_KinematicPtr();
 
    //! \brief Adds associated entity - Dtk_NodeConnectorPtr - to the Dtk_Node.
    //! \return DtkNoError if success.
    //! \param inAssociatedEntity AssociatedEntity to be added.
    void AddAssociatedEntity ( const Dtk_NodeConnectorPtr& inAssociatedEntity );
 
    //! \brief Adds associated entities - Dtk_NodeConnectorPtr - to the Dtk_Node.
    //! \return DtkNoError if success.
    //! \param inAssociatedEntities AssociatedEntities to be added.
    void AddAssociatedEntities ( const Dtk_tab< Dtk_NodeConnectorPtr >& inAssociatedEntities );
 
    //! \brief Retrieves the entities associated to the Dtk_Node. They are retrieved via Dtk_NodeConnectorPtr.
    //! \return DtkNoError if success.
    //! \param outAssociatedEntities The associatedEntities to be retrieved.
    Dtk_ErrorStatus GetAssociatedEntities ( Dtk_tab< Dtk_NodeConnectorPtr > &outAssociatedEntities );
    
    //Internal Use
     Dtk_StoredInfoPtr GetStoredInfos() const;
     void SetStoredInfos(const Dtk_StoredInfoPtr& inInfos);
 
     //! \brief Retrieves the Dtk_Node EntityID - read only -
     //! \return The Entity ID of Node.
     Dtk_NodeID GetEntityID() const;
};
/////////////////////////////////////////////////////////////////////////////
 
/////////////////////////////////////////////////////////////////////////////
//! \ingroup DtkAPIGroup
//! \class Dtk_Component 
//! \brief This is the Component Class.\n
//! The Dtk_ComponentPtr object is used as element into an assembly tree.\n
//! Is typically used as a Part into an Assembly Tree.\n
//! \SmartPtr{Dtk_ComponentPtr}
class Dtk_Component : public Dtk_DocElement
{
public:
     enum ComponentAvailabilityEnum
     {
          ComponentMissing = 0x1,
          ComponentFound = 0x2,
          ComponentInternal = 0x4,
          ComponentPhantom = 0x8,
          ComponentAdditionnalReference = 0x10,
          ComponentAssemblyGeometry = 0x20,
          ComponentWithUnavailableReader = 0x40,
          ComponentNotRequired = 0x80
     };
    enum ComponentTypeEnum
    {
        InstanceComponentType = 0,
        PrototypeComponentType,
        CatalogComponentType,
        VirtualComponentType
 
    };
 
    static Dtk_string ComponentAvailabilityEnumToString(const ComponentAvailabilityEnum& inEnum)
    {
        switch( inEnum )
        {
          case ComponentMissing:          return L"ComponentMissing";
        case ComponentFound:          return L"ComponentFound";
        case ComponentInternal:         return L"ComponentInternal";
          case ComponentPhantom:        return L"ComponentPhantom";
          case ComponentAdditionnalReference:        return L"ComponentAdditionnalReference";
          case ComponentAssemblyGeometry:        return L"ComponentAssemblyGeometry";
          case ComponentWithUnavailableReader:        return L"ComponentWithUnavailableReader";
          case ComponentNotRequired:        return L"ComponentNotRequired";
        default:                            return L"Unknown";
        }
    }
 
     static Dtk_string ComponentTypeEnumToString(const ComponentTypeEnum& inEnum)
     {
          switch( inEnum )
          {
          case CatalogComponentType:          return L"CatalogComponentType";
          case VirtualComponentType:          return L"VirtualComponentType";
          case InstanceComponentType:         return L"InstanceComponentType";
          case PrototypeComponentType:        return L"PrototypeComponentType";
 
          default:                            return L"Unknown";
          }
     }
 
     static Dtk_Int32 ComponentTypeStringToInt( const Dtk_string &name )
     {
          Dtk_Int32 result = -1;
 
          if( name.len() > 0 )
          {
               if( name == L"CatalogComponentType" )
                    result = CatalogComponentType;
               else if( name == L"VirtualComponentType" )
                    result = VirtualComponentType;
               else if( name == L"InstanceComponentType" )
                    result = InstanceComponentType;
               else if( name == L"PrototypeComponentType" )
                    result = PrototypeComponentType;
          }
          
          return result;
     }
 
protected: 
    enum { _typeID = DTK_TYPE_COMPONENT }; 
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    friend class Dtk_MainDoc;
    friend class Dtk_API;
    void _ReleaseNodes();
    void _ReleaseVolatileData();
private:
    //! \sa Dtk_MainDoc::CreatePhysicalDtk_Component()
    //! \sa Dtk_MainDoc::CreateVirtualDtk_Component()
    Dtk_Component( const Dtk_ComponentID& inID,
        const ComponentTypeEnum& inComponentType,
          const ComponentAvailabilityEnum& inComponentAvailability,
          const Dtk_Int32& inAdditionnalReferenceFlag,
        Dtk_string inComponentName,
        Dtk_string inComponentFullPath,
        Dtk_string inComponentInstanceName,
        const Dtk_transfo& inTransformationMatrix,
        const DtkReaderType& inAssociatedModule,
         Dtk_string inComponentOriginalName);
 
    //! \BaseDestructor 
    ~Dtk_Component();
    friend class Dtk_SmartPtr<Dtk_Component>;
 
    void _CheckGlobalDataSet();
    void _CheckFdtDataSet();
public:
 
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const int& inId);
 
    //! \DtkDynamicCast
    static Dtk_Component* DtkDynamicCast(Dtk_Object *s);
 
     //InternalUse
     Dtk_ErrorStatus SetComponentAvailability( ComponentAvailabilityEnum inComponentAvailability );
     Dtk_ErrorStatus AddComponentAvailability( ComponentAvailabilityEnum inComponentAvailability );
 
 
    //! \brief Adds a child Dtk_Component to main Component.
    //! \param inChild The Dtk_Component to be added as a child.
    inline void AddChild(const Dtk_ComponentPtr& inChild) 
    { _AddChild( Dtk_DocElementPtr::DtkDynamicCast(inChild) ); }
 
    //! \brief Retrieves the ith Dtk_ComponentPtr - read only -
    //! \param inPos Child component index.
    //! \return the inPos'th Dtk_ComponentPtr
    inline const Dtk_ComponentPtr GetChild(const Dtk_Size_t& inPos) const 
    { return Dtk_ComponentPtr::DtkDynamicCast( _GetChild(inPos) ); }
 
    //! \brief Replaces a child Dtk_ComponentPtr by another one. Also updates father lists.
    //! \param inPos Old Child Dtk_ComponentPtr element index.
    //! \param inNewChild The Dtk_ComponentPtr replacing the old one
    //! \DtkInternal
    //! \return the DtkNoerrror if success.
    //! \return the dtkErrorOutOfRange if bad inPos parameter.
    //! \return the dtkErrorNullPointer if inNewChild is NULL.
    inline Dtk_ErrorStatus ReplaceChildComponent(const Dtk_Size_t& inPos, const Dtk_ComponentPtr& inNewChild)
    { return _ReplaceChild( inPos, Dtk_DocElementPtr::DtkDynamicCast(inNewChild) ); }
 
    //! \brief Retrieves the Dtk_Component Type - read only -
    //! \return The component Type.
    const ComponentTypeEnum& ComponentType() const;
 
     //! \brief Gives Dtk_Component availability - read only -
     //! \deprecated "Use Use Dtk_Component::IsAvailabilityFlaggedAs method instead.")
     //! \return The component availability.
     SetAsDeprecated( "2026.3", "Use Dtk_Component::IsAvailabilityFlaggedAs method instead." )
     const ComponentAvailabilityEnum ComponentAvailability() const;
 
     //! \brief Check Dtk_Component availability - read only -
     //!  Each Dtk_Component can have several status  (ex :  AdditionnalReference and Missing) 
     //! \return DTK_TRUE if inStatusToCheck is activated on this component.
     bool IsAvailabilityFlaggedAs( Dtk_Component::ComponentAvailabilityEnum inStatusToCheck ) const;
 
 
    //! \brief Retrieves the Dtk_Component FullPathName - read only -
    //! \return The component FullPathName.
    const Dtk_string& FullPathName() const;
 
     //! \brief Retrieves the Dtk_Component OriginalPathName (read in file) - read only -
     //! \return The component OriginalPathName.
     const Dtk_string& OriginalPathName() const;
 
    //! \brief Retrieves the Dtk_Component TransformationMatrix - read only -
    //! \return The component TransformationMatrix.
    const Dtk_transfo& TransformationMatrix() const;
 
    //! \brief Retrieves the Dtk_Component InstanceName - read only -
    //! \return The component InstanceName.
    const Dtk_string& InstanceName() const;
 
    //! \brief Retrieves the Dtk_Component AssociatedModuleType - read only -
    //! \return The component AssociatedModuleType.
    const DtkReaderType& GetAssociatedModuleType() const;
 
     //! \brief Returns DTK_TRUE if Dtk_Component is an assembly.
     Dtk_bool IsAssembly() const;
 
     //! \brief Returns DTK_TRUE if Dtk_Component is Additionnal Reference.
     Dtk_bool IsAdditionnalReference() const;
 
     //! \brief  Returns Default Child Index or -1 if Component isn't a catalog
     Dtk_Int32 GetDefaultChildInCatalog() const;
 
     //! \brief  Returns Activated Children Index or empty array if Component isn't a catalog
     Dtk_tab<Dtk_Int32> GetActivatedChildrenInCatalog() const;
 
    //! \brief Creates a Virtual Dtk_NodePtr
    //! \param inName Node name.
    //! \return the constructed Dtk_NodePtr.
    Dtk_NodePtr CreateVirtualNode( Dtk_string inName, const type_detk inSubType = DTK_TYPE_NO_SUBTYPE );
 
     //! \brief Creates a Body Dtk_NodePtr from a body ID.
     //! \param inName Node name.
     //! \param inBodyID Body Id.
     //! \param inBodyFlag Body Info : Wire,Solid, MeshSurface and/or Surface.
     //! \return the constructed Dtk_NodePtr.
     Dtk_NodePtr CreateBodyNode( Dtk_string inName, const Dtk_ID& inBodyID, const Dtk_Int32 inBodyFlag , const type_detk inSubType = DTK_TYPE_BODY);
 
     //! \brief Creates a Mesh Dtk_NodePtr from a Mesh ID.
     //! \param inName Node name.
     //! \param inMeshID Mesh Id.
     //! \return the constructed Dtk_NodePtr.
     Dtk_NodePtr CreateMeshNode(
          Dtk_string inName,
          const Dtk_ID& inMeshID,
          const Dtk_Int32 inMeshFlag,
          const type_detk inSubType = DTK_TYPE_MESH );
 
    //! \brief Creates a Fdt Dtk_NodePtr from a Dtk_FdtPtr ID.
    //! \param inName Node name.
    //! \param inFdtID Dtk_FdtPtr ID.
    //! \return the constructed Dtk_NodePtr.
    Dtk_NodePtr CreateFdtNode(
        Dtk_string inName, 
        const Dtk_ID& inFdtID, const type_detk inSubType = DTK_TYPE_FDT);
 
     //! \brief Creates a Kinematic Dtk_NodePtr from a Dtk_KinematicPtr.
     //! \param inName Node name.
     //! \param inKinematicData Dtk_KinematicPtr data.
     //! \return the constructed Dtk_NodePtr.
     Dtk_NodePtr CreateKinematicsNode(
          Dtk_string inName, 
          const Dtk_ID& inKinematicID);
 
     //! \brief Creates a Drawing Dtk_NodePtr from a Dtk_DrawingPtr.
     //! \param inName Node name.
     //! \param inDrawingID Dtk_DrawingPtr ID.
     //! \return the constructed Dtk_NodePtr.
     Dtk_NodePtr CreateDrawingNode( Dtk_string inName, const Dtk_ID& inDrawingID);
 
     //! \brief Creates a MetaData Dtk_NodePtr from a Dtk_MetaDataPtr.
     //! \param inName Node name.
     //! \param inMetaDataID Dtk_MetaDataPtr ID.
     //! \return the constructed Dtk_NodePtr.
     Dtk_NodePtr CreateMetaDataNode( Dtk_string inName, const Dtk_ID& inMetaDataID, const type_detk inSubType = DTK_TYPE_METADATA);
 
     //! \brief Creates a Constraint Dtk_NodePtr from a Dtk_ConstraintPtr.
     //! \param inName Node name.
     //! \param inConstraintID Dtk_ConstraintPtr ID.
     //! \return the constructed Dtk_NodePtr.
     Dtk_NodePtr CreateConstraintNode( Dtk_string inName, const Dtk_ID& inConstraintID, const type_detk inSubType = DTK_TYPE_CONSTRAINT);
 
     //! \brief Creates a AxisSystem Dtk_NodePtr from a AxisSystemPtr.
     //! \param inName Node name.
     //! \param inAxisSystemID AxisPlacementPtr ID.
     //! \return the constructed Dtk_NodePtr.
     Dtk_NodePtr CreateAxisSystemNode( Dtk_string inName, const Dtk_ID& inAxisSystemID, const type_detk inSubType = DTK_TYPE_AXIS_SYSTEM);
 
    //! \brief Creates a LayerInfosSet Dtk_NodePtr from a LayerInfosSetPtr.
    //! \param inName Node name.
    //! \param inLayerInfosSetID LayerInfosSetPtr ID.
    //! \return the constructed Dtk_NodePtr.
    Dtk_NodePtr CreateLayerInfosSetNode( Dtk_string inName, const Dtk_ID& inLayerInfosSetID);
 
     //! \brief Creates a ColorInfosSet Dtk_NodePtr from a ColorInfosSetPtr.
      //! \param inName Node name.
      //! \param inColorInfosSetID ColorInfosSetPtr ID.
      //! \return the constructed Dtk_NodePtr.
     Dtk_NodePtr CreateColorInfosSetNode( Dtk_string inName, const Dtk_ID& inColorInfosSetID);
 
    //! \brief Creates a ModelDisplay Dtk_NodePtr from a DisplayModel.
    //! \param inName Node name.
    //! \param inModelDisplayID DisplayModel ID.
    //! \return the constructed Dtk_NodePtr.
    Dtk_NodePtr CreateModelDisplayNode( Dtk_string inName, const Dtk_ID& inDisplayModelID, const type_detk inSubType = DTK_TYPE_NO_SUBTYPE );
 
    //! \brief Creates a Camera Dtk_NodePtr from a Camera.
    //! \param inName Node name.
    //! \param inCameraID Camera ID.
    //! \return the constructed Dtk_NodePtr.
    Dtk_NodePtr CreateCameraNode( Dtk_string inName, const Dtk_ID& inCameraID);
 
    //! \brief Retrieves a Dtk_NodePtr from the Dtk_Component NodesPool giving his Id.
    //! \param inNodeID Wanted Dtk_NodePtr Id.
    //! \return The wanted Dtk_NodePtr.
    Dtk_NodePtr GetNodeByID( const Dtk_NodeID& inNodeID ) const;
 
    //! \brief Retrieves the father Dtk_NodePtr of the given Dtk_NodePtr.
    //! \param inNode The Dtk_NodePtr from which we want the father.
    //! \return The wanted Dtk_NodePtr.
    Dtk_NodePtr GetFatherNode(const Dtk_NodePtr& inNode) const;
 
     //! \brief Get the Original Units for documents - geometrical data are given in MM (Scale to MM) 
     //! \param [out] outUnitScale : Unit Scale (1.0 for MM)
     //! \return dtkNoError if unit is correctly read.  
     //! \return dtkWarningDefaultValue if unit was not read and default value is used (1.0).
     //! \return dtkErrorFileNotExist if the component is flagged as missing (file not found).
     Dtk_ErrorStatus GetConceptionUnitScale(Dtk_Double64 &outUnitScale)const;
 
     void SetConceptionUnitScale(Dtk_Double64 inUnitScale);
 
     //! \brief Gets File Version 
     const Dtk_string & GetFileVersion()const;
     void SetFileVersion(const Dtk_string & inFileVersion);
 
     //! \brief Current layer for Component 
     SetAsDeprecated( "2026.2", "Use Dtk_LayerInfoSet::GetCurrentLayer instead")
     Dtk_Int32 GetCurrentLayer() const;
     SetAsDeprecated( "2026.2", "Use Dtk_LayerInfoSet::SetCurrentLayer instead")
     void SetCurrentLayer(Dtk_Int32 inCurrentLayer);
 
     //! \brief Visible layer for Component 
     SetAsDeprecated( "2026.2", "Use GetLayerInfosSet() then Dtk_LayerInfosSet::GetLayersFlaggedAs( Dtk_LayerInfosSet::Layer::Status::Visible ) instead")
     void GetVisibleLayers(Dtk_tab<Dtk_Int32> &outVisibleLayers)const;
     SetAsDeprecated( "2026.2", "Use Dtk_LayerInfosSet::AddLayer instead" )
     void SetVisibleLayers(const Dtk_tab<Dtk_Int32> & inVisibleLayers);
 
     //! \brief Selectable layer for Component 
     SetAsDeprecated( "2026.2", "Use GetLayerInfosSet() then Dtk_LayerInfosSet::GetLayersFlaggedAs( Dtk_LayerInfosSet::Layer::Status::Selectable ) instead")
     void GetSelectableLayers(Dtk_tab<Dtk_Int32> &outSelectableLayers)const;
     SetAsDeprecated( "2026.2", "Use Dtk_LayerInfosSet::AddLayer instead" )
     void SetSelectableLayers(const Dtk_tab<Dtk_Int32> & inSelectableLayers);
 
     //! \brief Retrieves the Dtk_LayerInfosSet of this component
     //! \remark Dtk_API::ReadComponent has to be called for the layer set to be available.
    //! \return The Dtk_LayerInfosSet of this component.
     Dtk_LayerInfosSetPtr GetLayerInfosSet() const;
 
     //! \brief SiblingName for Component
     DtkErrorStatus GetSiblingName(Dtk_string &outSiblingName)const;
     DtkErrorStatus SetSiblingName(const Dtk_string & inSiblingName);
 
 
     //! \brief Gives number of Nodes in the Component (useful if you want to handle progress bar). 
     //! \return number of Nodes. 
     Dtk_Size_t GetNumNodes() const;
 
    //! \brief Attaches SelectionDataSet infos to the Dtk_Component - through the Dtk_GlobalDataSetPtr -. 
    void SetSelectionDataSet( const Dtk_SelectionDataSetPtr& inSelectionDataSet);
 
    //! \brief Retrieves the Dtk_GlobalDataSetPtr attached to the Dtk_Component - get only -. 
    //! \return The attached Dtk_GlobalDataSetPtr - can be null - 
    const Dtk_GlobalDataSetPtr GetGlobalDataSet() const;
 
 
     //! \brief Retrieves the connectors pointing on this component.
     //! \return The pointing connectors.
    Dtk_ErrorStatus GetConnectorsPointingToThisComponent(Dtk_tab<Dtk_NodeConnectorPtr> &outConnectedEntities);
 
    //! \brief Devalidates Component into MainDoc.
    //! \param inNodeID The NodeID to devalidate.
    //! \return DtkNoError if success.
    //! \remark Internal Use only.
    Dtk_ErrorStatus DevalidateNode( const Dtk_NodeID& inNodeID );
 
     //! \brief Gets BoundingBox on Prototype Component if it can be read in original file
     //! \param [out] outMin Resulting minimum coordinates
     //! \param [out] outMax Resulting maximum coordinates
     //! \return DtkNoError if success.
     Dtk_ErrorStatus GetBoundingBox( Dtk_pnt& outMin, Dtk_pnt& outMax ) const;
 
     //! \brief Adds Override set to a prototype component 
    //! \return dtkNoError if ok.
     DtkErrorStatus AddOverrideSet(const Dtk_OverrideSetPtr& inOverrideSet);
 
     //! \brief Gives number of Override sets in a prototype component 
    //! \return Override sets. 
     Dtk_Size_t GetNumOverrideSets() const;
 
     //! \brief Gives array of Override sets in a prototype component 
    //! \return dtkNoError if ok.
     DtkErrorStatus GetOverrideSets(Dtk_tab<Dtk_OverrideSetPtr>& outOverrideSet) const;
 
    //! \brief Sets array of Override sets in a prototype component
    //! \return dtkNoError if ok.
    DtkErrorStatus SetOverrideSets(const Dtk_tab<Dtk_OverrideSetPtr>& inOverrideSets);
};
/////////////////////////////////////////////////////////////////////////////
 
/////////////////////////////////////////////////////////////////////////////
//! \ingroup DtkAPIGroup
//! \class Dtk_MainDoc 
//! \brief This is the Document Class.\n
//! The Dtk_MainDocPtr object is used as root element produced by a translation.\n
//! It contains the root Dtk_ComponentPtr.
//! \SmartPtr{Dtk_MainDocPtr}
class Dtk_MainDoc : public Dtk_Object
{
     friend class Dtk_MainDocWrapper;
public:
    struct Dtk_Handle;       // Not defined here
protected: 
    enum { _typeID = DTK_TYPE_DOCUMENT }; 
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    friend class Dtk_API;
     void _ReleaseComponents();
     void _ReleaseNodeConnectors();
private:
    //! \sa Create
    Dtk_MainDoc();
    //! \BaseDestructor 
    ~Dtk_MainDoc();
 
    void _AddComponentIntoPool(Dtk_ComponentPtr& outElt);
 
    friend class Dtk_SmartPtr<Dtk_MainDoc>;
public:
 
    //! \CreateBase 
    static Dtk_MainDocPtr Create();
 
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const int& inId);
 
    //! \DtkDynamicCast
    static Dtk_MainDoc* DtkDynamicCast(Dtk_Object *s);
 
    //! \brief Set the root Dtk_ComponentPtr.
    //! \param inRootComponent The root Ccomponent 
    void SetRootComponent(const Dtk_ComponentPtr& inRootComponent);
 
    //! \brief Retrieves the root Dtk_ComponentPtr of the Dtk_MainDoc.
    //! \return The root Dtk_ComponentPtr.
    const Dtk_ComponentPtr& RootComponent() const;
    
    //! \brief Creates a physical Dtk_ComponentPtr.
    //! \param inComponentType Component type - Part or Assembly -.
    //! \param inComponentFullPath Component full path.
    //! \param inComponentName Component name.
    //! \param inInstanceName Instance name.
    //! \param inTransformationMatrix Transformation matrix.
    //! \param inAssociatedModule Associated module - Unknown by default -.
    //! \return the constructed Dtk_ComponentPtr.
 
    //! \brief Creates an Instance Dtk_ComponentPtr.
    //! \param inPrototype The Prototype Dtk_ComponentPtr used to create instance.
    //! \param inInstanceName Instance name.
    //! \param inTransformationMatrix Transformation matrix.
    //! \return the constructed InstanceDtk_ComponentPtr.
    //! \remark The Prototype is automatically linked to the instance.
    Dtk_ComponentPtr CreateInstanceDtk_Component(
        const Dtk_ComponentPtr& inPrototype,
        Dtk_string inInstanceName,
        const Dtk_transfo& inTransformationMatrix);
 
    //! \brief Creates a Prototype Dtk_ComponentPtr.
    //! This type handles Assemblies and part components.
    //! \param inComponentFullPath Component full path.
    //! \param inComponentName Component name.
     //! \param inAssociatedModule Associated module - Unknown by default -.
    //! \param inAvailability : Is component found/missing or internal
     //! \param inAdditionnalReferenceFlag : Is component an additionnal reference ( not part of assembly) or not
    //! \return the constructed Prototype Dtk_ComponentPtr.
    Dtk_ComponentPtr CreatePrototypeDtk_Component(
        Dtk_string inComponentFullPath,
        Dtk_string inComponentName,
        const DtkReaderType& inAssociatedModule,
          const Dtk_Component::ComponentAvailabilityEnum& inAvailability,
          const int inAdditionnalReferenceFlag = 0,
          Dtk_string inOriginalName=Dtk_string());
 
    //! \brief Creates a virtual Dtk_ComponentPtr.
    //! \param inComponentName Component name.
    //! \param inAssociatedModule Associated module - Unknown by default -.
    //! \return the constructed Dtk_ComponentPtr.
    //! \remark A virtual Dtk_ComponentPtr hasn't any full path.
    Dtk_ComponentPtr CreateVirtualDtk_Component(
        Dtk_string inComponentName,
        const DtkReaderType& inAssociatedModule,
          Dtk_string inComponentFullPath,
          const Dtk_Component::ComponentAvailabilityEnum& inAvailability);
 
     //! \brief Creates a Catalog Dtk_ComponentPtr.
     //! \param inComponentFullPath Component full path.
     //! \param inComponentName Component name.
     //! \param inInstanceName Instance name.
     //! \param inTransformationMatrix Transformation matrix.
     //! \param inAssociatedModule Associated module - Unknown by default -.
     //! \return the constructed Dtk_ComponentPtr.
     Dtk_ComponentPtr CreateCatalogDtk_Component(
          Dtk_string inComponentFullPath,
          Dtk_string inComponentName,
          Dtk_string inInstanceName,
          const Dtk_transfo& inTransformationMatrix,
          const DtkReaderType& inAssociatedModule = UnknownModule,
          const Dtk_Component::ComponentAvailabilityEnum& inAvailability = Dtk_Component::ComponentInternal,
          Dtk_string inOriginalName = Dtk_string());
 
 
     
     //! \brief Retrieves a Dtk_ComponentPtr giving its ID.
    //! \param inComponentID The component ID 
    //! \return The wanted Dtk_ComponentPtr.
    Dtk_ComponentPtr GetComponentByID( const Dtk_ComponentID& inComponentID ) const;
 
    //! \brief Retrieves the inIndexth father of the giving Dtk_ComponentPtr.
     //! \param inComponent The component from which we want the father.
    //! \param inIndex index of father wanted.
    //! \return The wanted Dtk_ComponentPtr.
    Dtk_ComponentPtr GetFatherComponent(const Dtk_ComponentPtr& inComponent,Dtk_Size_t inIndex) const;
 
     //! \brief Retrieves the inIndexth father of the giving Dtk_ComponentPtr.
     //! \param inComponent The component from which we want the number of fathers.
     //! \return The number of father.
     Dtk_Size_t GetNumFatherComponent(const Dtk_ComponentPtr& inComponent);
 
     //! \brief Give number of Components in the Dtk_MainDoc (useful if you want to handle progress bar). 
     //! \return number of Components. 
     Dtk_Size_t GetNumComponents() const;
 
     //! \brief Give number of InstanceComponents in the Dtk_MainDoc 
     //! \return number of Instance Components. 
     Dtk_Int32 GetNumInstances() const;
 
    //! \brief Indicate that document contains several independant models
    //! \return DTK_TRUE if the MainDoc represent a multi model document. 
    Dtk_bool IsMultiModel() const;
 
    //! \brief Set flag to indicate that document contains several independant models
    void  SetMultiModelFlag(Dtk_bool inMultiModelFlag);
 
    //! \brief Devalidates Component into MainDoc.
    //! \param inComponentID The ComponentID to devalidate.
    //! \return DtkNoError if success.
    //! \remark Internal Use only.
    Dtk_ErrorStatus DevalidateComponent( const Dtk_ComponentID& inComponentID );
 
     //! \brief return list of missing files into MainDoc.
     //! \param outFileList : list of missing files
     //! \return DtkNoError if success.
     Dtk_ErrorStatus GetMissingComponentList(Dtk_tab<Dtk_string> &outFileList) const;
 
     //! \brief return list of additional reference files into MainDoc.
     //! \param outFileList : list of additionnal reference files
     //! \return DtkNoError if success.
     Dtk_ErrorStatus GetAdditionalReferenceList(Dtk_tab<Dtk_string> &outFileList) const;
 
};
 
/////////////////////////////////////////////////////////////////////////////
//! \ingroup DtkAPIGroup
//! \class Dtk_NodeConnector 
//! \brief This is the Dtk_NodeConnector Class.\n
//! \SmartPtr{Dtk_NodeConnectorPtr}
class Dtk_NodeConnector : public Dtk_Object
{
public:
     //! \brief Reason - Type of the Dtk_NodeConnector -. It's used to filter connectors to same elements.
     enum ReasonLinkEnum
     {
          Unknown = 0,
          //Placement Reasons
          VerticallyAligned,      //the pointing entity is bound to the the position of pointed one, so that they stay vertically aligned
          HorizontallyAligned,    //the pointing entity is bound to the the position of pointed one, so that they stay horizontally aligned
          StackedLeft,            //the pointing entity is bound to the the position of pointed one, so that it is kept to the left
          StackedRight,           //the pointing entity is bound to the the position of pointed one, so that it is kept to the right
          StackedAbove,           //the pointing entity is bound to the the position of pointed one, so that it is kept above
          StackedBelow,           //the pointing entity is bound to the the position of pointed one, so that it is kept below
          PositionallyFixed,      //the pointing entity positon is constrained by the pointed one
          OrientationallyFixed,   //the pointing entity direction is constrained by the pointed one
          ForceHidden,            //the pointed entity is forced to be hidden
          ForceVisible,           //the pointed entity is forced to be visible
          ForceColor,                   //the pointed entity is forced to change color
          ForceRender,             //the pointed entity is forced to change render info
          ForceClipped,           //the pointed entity is forced to be clipped by light section view
          KeepOnlyFdt,            //keep only pmi
 
          //Category used to qualify links from the 1st Dtk_ReferenceBlockPtr - [PT] / [SL] / [PL] -
          //These links can apply to a reference into Dtk_ReferenceBlockPtr - 3 1st references handled - or to the common datum - the whole Dtk_ReferenceBlockPtr
          FirstRefBlockSituation_Common,
          FirstRefBlockSituation_1,
          FirstRefBlockSituation_2,
          FirstRefBlockSituation_3,
 
          //Category used to qualify links from the 2nd Dtk_ReferenceBlockPtr - [PT] / [SL] / [PL] -
          //These links can apply to a reference into Dtk_ReferenceBlockPtr - 3 1st references handled - or to the common datum - the whole Dtk_ReferenceBlockPtr
          SecondRefBlockSituation_Common,
          SecondRefBlockSituation_1,
          SecondRefBlockSituation_2,
          SecondRefBlockSituation_3,
 
          //Category used to qualify links from the 3rd Dtk_ReferenceBlockPtr - [PT] / [SL] / [PL] -
          //These links can apply to a reference into Dtk_ReferenceBlockPtr - 3 1st references handled - or to the common datum - the whole Dtk_ReferenceBlockPtr
          ThirdRefBlockSituation_Common,
          ThirdRefBlockSituation_1,
          ThirdRefBlockSituation_2,
          ThirdRefBlockSituation_3,
 
          //General Associations
          AssociatedGeometry,
          AssociatedFeature,
          SubPMI,
          DefaultAnnotationLink,
          HighlightedGeometry,
          Support,
          AssociatedAxisSystem,
          AssociatedXDirection,
          AssociatedYDirection,
          AssociatedZDirection,
          AssociatedCenterPoint,
 
          Context,
 
     };
    static Dtk_string ReasonLinkEnumToString(const ReasonLinkEnum& inEnum)
    {
        switch( inEnum )
        {
        case VerticallyAligned:         return L"VerticallyAligned";
        case HorizontallyAligned:       return L"HorizontallyAligned";
        case StackedLeft:               return L"StackedLeft";
        case StackedRight:              return L"StackedRight";
        case StackedAbove:              return L"StackedAbove";
        case StackedBelow:              return L"StackedBelow";
        case PositionallyFixed:         return L"PositionallyFixed";
        case OrientationallyFixed:      return L"OrientationallyFixed";
          case ForceHidden:               return L"ForceHidden";
          case ForceVisible:              return L"ForceVisible";
          case ForceClipped:              return L"ForceClipped";
        case KeepOnlyFdt:               return L"KeepOnlyFdt";
          case ForceColor:                   return L"ForceColor";
          case ForceRender:                  return L"ForceRender";
 
          case AssociatedGeometry:        return L"AssociatedGeometry";
          case AssociatedFeature:         return L"AssociatedFeature";
          case SubPMI:                    return L"SubPMI";
          case DefaultAnnotationLink:     return L"DefaultAnnotationLink";
          case HighlightedGeometry:       return L"HighlightedGeometry";
        case Support:                   return L"Support";
        case AssociatedAxisSystem:      return L"AssociatedAxisSystem";
          case AssociatedXDirection:      return L"AssociatedXDirection";
          case AssociatedYDirection:      return L"AssociatedYDirection";
          case AssociatedZDirection:      return L"AssociatedZDirection";
          case AssociatedCenterPoint:      return L"AssociatedCenterPoint";
 
        case Context:                   return L"Context";
 
        case FirstRefBlockSituation_Common:         return L"FirstRefBlockSituation_Common";
        case FirstRefBlockSituation_1:              return L"FirstRefBlockSituation_1";
        case FirstRefBlockSituation_2:              return L"FirstRefBlockSituation_2";
        case FirstRefBlockSituation_3:              return L"FirstRefBlockSituation_3";
 
        case SecondRefBlockSituation_Common:        return L"SecondRefBlockSituation_Common";
        case SecondRefBlockSituation_1:             return L"SecondRefBlockSituation_1";
        case SecondRefBlockSituation_2:             return L"SecondRefBlockSituation_2";
        case SecondRefBlockSituation_3:             return L"SecondRefBlockSituation_3";
 
        case ThirdRefBlockSituation_Common:         return L"ThirdRefBlockSituation_Common";
        case ThirdRefBlockSituation_1:              return L"ThirdRefBlockSituation_1";
        case ThirdRefBlockSituation_2:              return L"ThirdRefBlockSituation_2";
        case ThirdRefBlockSituation_3:              return L"ThirdRefBlockSituation_3";
 
        default: return L"Unknown";
        }
    }
 
    //! \brief Reason Category. Global Category of the NodeConnector uesed to gather Reason into families.
    enum ReasonCategoryEnum
    {
        UnknownCategory = 0,
        PlacementCategory,          //General Placement Category gathering all Placement Reasons
          GeneralAssociationCategory,
          VisibilityCategory,
          AppearanceCategory,
 
        FirstRefBlockSituationCategory,
        SecondRefBlockSituationCategory,
        ThirdRefBlockSituationCategory,
    };
    static Dtk_string ReasonCategoryEnumToString(const ReasonCategoryEnum& inEnum)
    {
        switch( inEnum )
        {
        case PlacementCategory:                     return L"PlacementCategory";
          case GeneralAssociationCategory:            return L"GeneralAssociationCategory";
          case VisibilityCategory:                     return L"VisibilityCategory";
          case AppearanceCategory:                     return L"AppearanceCategory";
          case FirstRefBlockSituationCategory:        return L"FirstRefBlockSituationCategory";
        case SecondRefBlockSituationCategory:       return L"SecondRefBlockSituationCategory";
        case ThirdRefBlockSituationCategory:        return L"ThirdRefBlockSituationCategory";
        default:                                    return L"UnknownCategory";
        }
    }
 
    class SubEntity
    {
    private:
        Dtk_ID                _SubEntityID;  // optional: Set of IDs (in case the connector links to a geometric entity (construction) 
        type_detk             _SubEntityType;     // optional: The list of entities types      
    public:
        inline SubEntity( ) : _SubEntityID(0), _SubEntityType(DTK_TYPE_UNKNOWN){}
        inline SubEntity( const Dtk_ID inSubEntityID, const type_detk inSubEntityType ) : _SubEntityID(inSubEntityID), _SubEntityType(inSubEntityType){}
        inline ~SubEntity() {}
 
        inline Dtk_ID GetSubEntityId()      const {return _SubEntityID;}
        inline type_detk GetSubEntityType() const {return _SubEntityType;}
          friend Dtk_bool operator==(const SubEntity&, const SubEntity&);
 
    };
 
protected:
    struct Dtk_Handle; // Not defined here
    std::unique_ptr<Dtk_Handle> _Private; // Handle
 
    enum
    {
        _typeID = DTK_TYPE_NODE_CONNECTOR
    }; 
 
    //! \BaseConstructor
    Dtk_NodeConnector();
     //! \sa Create(const Dtk_NodeConnector &in)
    Dtk_NodeConnector(const Dtk_NodeConnector & );
     Dtk_NodeConnector( Dtk_NodeConnector&& s ) DTK_NOEXCEPT;
    //! \BaseDestructor
    ~Dtk_NodeConnector();
 
    inline virtual Dtk_Object* Clone() { return new Dtk_NodeConnector(*this); }
 
protected: 
    friend class Dtk_SmartPtr<Dtk_NodeConnector>;
public:
    friend class Dtk_Node;
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    //! \DtkDynamicCast
    static Dtk_NodeConnector* DtkDynamicCast(Dtk_Object *s);
 
    //! \CreateBase
    static Dtk_NodeConnectorPtr Create();
 
    //! \CreateCopy{in}
    static Dtk_NodeConnectorPtr Create(const Dtk_NodeConnector &in);
 
    //! \return The type of the entity type - DTK_TYPE_FDT - 
    type_detk get_type_detk() const { return DTK_TYPE_NODE_CONNECTOR; }
 
    //! \brief Returns the Component ID referenced by the connector
    Dtk_ID GetAssociatedComponentID() const ;
    //! \brief Sets the component ID
    void SetAssociatedComponentID (const Dtk_ID &inComponentID);
 
    //! \brief Returns the Path Component ID referenced by the connector from Root to Target
    const Dtk_tab<Dtk_ID>& GetAssociatedPathComponentID() const ;
    void GetAssociatedPathComponentID(Dtk_tab<Dtk_ID>& outAssociatedPathComponentID) const ;
    //! \brief Sets the Path Component ID from Root to Target
    void SetAssociatedPathComponentID (const Dtk_tab<Dtk_ID> &inPathComponentID);
    //! \brief Checks if the Path Component ID exist into Dtk_MainDocPtr
    //! \brief Returns true if path connector exists else returns false
    Dtk_Int32 CheckAssociatedPathComponentID (const Dtk_MainDocPtr& inMainDocPtr);
 
    //! \brief Returns the Node id referenced by the connector
    Dtk_ID GetNodeId() const ;
    //! \brief Sets the Node id
    void SetNodeId(const Dtk_ID &inNodeId);
 
 
    //! \brief Returns the number of the geometric entities
    Dtk_Size_t GetSubEntitiesNb() const;
 
    //! \brief Retrieves The connected SubEntities - IDs and types -
    //! \param outEntitiesIDs SubEntities Ids
    //! \param outEntitiesTypes SubEntities types
    //! \remark Sizes of the 2 arrays are equal
    //! \return DtkNoError if no error.
    Dtk_ErrorStatus GetSubEntities(Dtk_tab <Dtk_ID>& outEntitiesIDs, Dtk_tab <type_detk> & outEntitiesTypes) const;
 
    //! \brief Returns the set of Additional Entities defined by their IDs and Types 
    //! \param inEntitiesIDs SubEntities Ids
    //! \param inEntitiesTypes SubEntities types
    //! \remark The size of the 2 arrays must be equal
    //! \return DtkNoError if no error.
    Dtk_ErrorStatus SetSubEntities(const Dtk_tab <Dtk_ID> &inEntitiesIDs, const Dtk_tab <type_detk> & inEntitiesTypes);
 
    //! \brief Sets of SubEntities - defined by their IDs and Types -
    //! \param inSubEntities SubEntities array
    //! \return DtkNoError if no error.
    Dtk_ErrorStatus SetSubEntities(const Dtk_tab <SubEntity> &inSubEntities);
 
    //! \brief Add a set of SubEntities - defined by their IDs and Types - to the SubEntities list
    //! \param inSubEntities SubEntities array
    //! \return DtkNoError if no error.
    Dtk_ErrorStatus AddSubEntities(const Dtk_tab <SubEntity> &inSubEntities);
 
    //! \brief Add a SubEntity - defined by their IDs and Types - to the SubEntities list
    //! \param inSubEntity SubEntity
    //! \return DtkNoError if no error.
    Dtk_ErrorStatus AddSubEntity(const SubEntity& inSubEntity);
 
    //! \brief Retrieves the SubEntities array - defined by their IDs and Types -
    //! \param outSubEntities The resulting SubEntities array
    //! \return DtkNoError if no error.
    Dtk_ErrorStatus GetSubEntities(Dtk_tab <SubEntity>& outSubEntities) const;
 
    //! \brief Retrieves the pointing entity FullType. Should be the FullType of the Dtk_Node containing the Dtk_NodeConnector
    //! \return The pointing entity FullType.
    Dtk_Node::FullType GetPointingEntityType() const;
 
    //! \brief Sets the pointing entity Type.
    //! \param inPointingEntityType The pointing entity Type.
    void SetPointingEntityType( const Dtk_Node::FullType inPointingEntityType );
 
    //! \brief Sets the pointed entity Type.
    //! \param inPointedEntityType The pointed entity Type.
    void SetPointedEntityType( const type_detk inPointedEntityType);
 
    //! \brief Retrieves the pointed entity Type.
    //! \return The pointed entity Type.
    type_detk GetPointedEntityType() const;
 
    //! \brief Sets the Reason Link of the Dtk_NodeConnector to specify the reason of the connection.
    //! \param inReasonLink The Reason Link
    void SetReasonLink( const ReasonLinkEnum inReasonLink );
 
    //! \brief Gets the Reason Link of the Dtk_NodeConnector to specify the reason of the connection.
    //! \param outReasonCategory The Reason Category - processed from the ReasonLink -
    //! \return The Reason Link.
    Dtk_NodeConnector::ReasonLinkEnum GetReasonLink( ReasonCategoryEnum& outReasonCategory ) const;
 
     //! \brief Set the Color Id for ForceColor connectors
     //! \param inColorId The Color Id
     void SetColorId( Dtk_ID  inColorId) ;
 
     //! \brief Retrieves the Color Id for ForceColor connectors
     //! \return The Color Id ( > 0 if exists, 0 otherwise).
     Dtk_Int32 GetColorId() const;
 
     //! \brief Set the Render Id for ForceRender connectors
     //! \param inRenderId The Render Id
     void SetRenderId( Dtk_ID  inRenderId );
 
     //! \brief Retrieves the Render Id for ForceRender connectors
     //! \return The Render Id ( > 0 if exists, 0 otherwise).
     Dtk_ID GetRenderId() const;
};
 
 
/////////////////////////////////////////////////////////////////////////////
 
 
#endif