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"
 
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;
 
 
class Dtk_DocElement : public Dtk_Object
{
protected: 
 
    enum { _typeID = DTK_TYPE_DOC_ELEMENT }; 
    struct Dtk_Handle;       // Not defined here
    Dtk_Handle *_Private;   // Handle
protected:
    void _Init();
    void _Reset();
    void _Copy(const Dtk_Node&s);
 
    Dtk_DocElement(const Dtk_ID& inID, Dtk_string inName);
 
    virtual ~Dtk_DocElement();
 
 
    void _AddChild(const Dtk_DocElementPtr& inChild);
 
    const Dtk_DocElementPtr _GetChild(const Dtk_Size_t& inPos) const;
 
    Dtk_ErrorStatus _ReplaceChild(const Dtk_Size_t& inPos, const Dtk_DocElementPtr& inNewChild);
 
    friend class Dtk_SmartPtr<Dtk_DocElement>;
    friend class Dtk_MainDoc;
 
public:
    Dtk_Int32 DtkDynamicType(const int& inId);
 
    static Dtk_DocElement* DtkDynamicCast(Dtk_Object *s);
 
    Dtk_Size_t GetNumChildren() const;
 
    const Dtk_string& Name() const;
    Dtk_string& Name();
 
    Dtk_ID GetID() const;
 
    Dtk_ID GetFatherID(Dtk_Size_t inIndex)const;
 
     Dtk_Size_t GetNumFathers()const;
 
    void GetReadID(Dtk_ID& outReadID) const;
    void SetReadID(const Dtk_ID & inNewID);
 
 
    Dtk_InfoPtr GetInfos() const;
    void SetInfos(const Dtk_InfoPtr& inInfos);
 
     Dtk_MaterialPtr GetMaterial() const;
     void SetMaterial(Dtk_MaterialPtr inMaterial);
 
 
     Dtk_PreviewPtr GetPreview() const;
    void SetPreview(Dtk_PreviewPtr inPreview);
    void ReleasePreview();
 
 
    void AddMetaData(const Dtk_MetaDataPtr& inMetaData);
 
     void AddMetaDataGroup(const Dtk_MetaDataGroupPtr& inMetaDataGroup, Dtk_bool inAddMetadata = DTK_FALSE);
 
    void AddProperty(const Dtk_PropertiesPtr & inProperty);
 
    Dtk_MetaDataPtr GetMetaData(const Dtk_Size_t& inPos) const;
 
     Dtk_MetaDataGroupPtr GetMetaDataGroup(const Dtk_Size_t& inPos) const;
 
    Dtk_Size_t GetNumMetaData() const;
 
     Dtk_Size_t GetNumMetaDataGroup() const;
};
 
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
    };
    class FullType
    {
    public: 
        friend class Dtk_Node;
    private:
        NodeDataTypeEnum                        _PrimaryType;
        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 inline 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 inline 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
    Dtk_Handle *_Private;   // Handle
    friend class Dtk_Component;
private:
    void _Init();
    void _Reset();
    void _Copy(const Dtk_Node&s);
 
    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();
 
    friend class Dtk_SmartPtr<Dtk_Node>;
 
public:
    Dtk_Int32 DtkDynamicType(const int& inId);
 
    static Dtk_Node* DtkDynamicCast(Dtk_Object *s);
 
    inline void AddChild(const Dtk_NodePtr& inChild) 
    { _AddChild( Dtk_DocElementPtr::DtkDynamicCast(inChild) ); }
 
    inline const Dtk_NodePtr GetChild(const Dtk_Size_t& inPos) const 
    { return Dtk_NodePtr::DtkDynamicCast( _GetChild(inPos) ); }
 
    inline Dtk_ErrorStatus ReplaceChildNode(const Dtk_Size_t& inPos, const Dtk_NodePtr& inNewChild)
    { return _ReplaceChild( inPos, Dtk_DocElementPtr::DtkDynamicCast(inNewChild) ); }
 
     //SetAsDeprecated("Undefined", "Use GetNodeFullType")
    NodeDataTypeEnum GetNodeType() const;
 
     //SetAsDeprecated("Undefined", "Use GetNodeFullType")
     type_detk GetNodeSubType() const;
 
    const Dtk_Node::FullType GetNodeFullType() const;
 
     Dtk_bool NodeHasPoints() const;
     Dtk_bool NodeHasCurves() const;
     Dtk_bool NodeHasSolids() const;
     Dtk_bool NodeHasSurfaces() const;
     Dtk_bool NodeHasMeshSurfaces() const;
     Dtk_bool NodeHasAxis() const;
     Dtk_bool NodeHasMesh() const;
 
 
    Dtk_BodyPtr GetDtk_BodyPtr();
 
     Dtk_MeshPtr GetDtk_MeshPtr();
 
     Dtk_FeaturePtr GetDtk_FeaturePtr();
     Dtk_ObjectPtr GetDtk_AdvancedFeaturePtr();
 
 
    Dtk_FdtPtr GetDtk_FdtPtr();
 
 
     Dtk_KinematicPtr GetDtk_KinematicPtr();
 
     Dtk_MetaDataPtr GetDtk_MetaDataPtr();
 
    Dtk_DrawingPtr GetDtk_DrawingPtr();
 
     Dtk_AxisSystemPtr GetDtk_AxisSystemPtr();
 
    Dtk_LayerInfosSetPtr GetDtk_LayerInfosSetPtr();
 
     Dtk_ColorInfosSetPtr GetDtk_ColorInfosSetPtr();
 
    Dtk_ModelDisplayPtr GetDtk_ModelDisplayPtr();
 
    Dtk_CameraPtr GetDtk_CameraPtr();  
     
    Dtk_ConstraintPtr GetDtk_ConstraintPtr();
 
     //Dtk_KinematicsPtr GetDtk_KinematicPtr();
 
    void AddAssociatedEntity ( const Dtk_NodeConnectorPtr& inAssociatedEntity );
 
    void AddAssociatedEntities ( const Dtk_tab< Dtk_NodeConnectorPtr >& inAssociatedEntities );
 
    Dtk_ErrorStatus GetAssociatedEntities ( Dtk_tab< Dtk_NodeConnectorPtr > &outAssociatedEntities );
    
    //Internal Use
     Dtk_StoredInfoPtr GetStoredInfos() const;
     void SetStoredInfos(const Dtk_StoredInfoPtr& inInfos);
 
     Dtk_NodeID GetEntityID() const;
};
 
class Dtk_Component : public Dtk_DocElement
{
public:
     enum ComponentAvailabilityEnum
     {
          ComponentMissing = 0,
          ComponentFound = 1,
          ComponentInternal = 2,
          ComponentPhantom = 4,
          ComponentAdditionnalReference = 8,
          ComponentAssemblyGeometry = 16,
          ComponentWithUnavailableReader = 32
     };
    enum ComponentTypeEnum
    {
        InstanceComponentType = 0,
        PrototypeComponentType,
        CatalogComponentType,
        VirtualComponentType
 
    };
 
    static inline 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";
 
        default:                            return L"Unknown";
        }
    }
 
     static inline 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 inline 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
    Dtk_Handle *_Private;   // Handle
    friend class Dtk_MainDoc;
    friend class Dtk_API;
    void _ReleaseNodes();
    void _ReleaseVolatileData();
private:
    void _Init();
    void _Reset();
    void _Copy(const Dtk_Component&s);
 
    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);
 
    ~Dtk_Component();
    friend class Dtk_SmartPtr<Dtk_Component>;
 
    void _CheckGlobalDataSet();
    void _CheckFdtDataSet();
public:
 
    Dtk_Int32 DtkDynamicType(const int& inId);
 
    static Dtk_Component* DtkDynamicCast(Dtk_Object *s);
 
     //InternalUse
     Dtk_ErrorStatus SetComponentAvailability(const ComponentAvailabilityEnum &inComponentAvailability);
 
 
    inline void AddChild(const Dtk_ComponentPtr& inChild) 
    { _AddChild( Dtk_DocElementPtr::DtkDynamicCast(inChild) ); }
 
    inline const Dtk_ComponentPtr GetChild(const Dtk_Size_t& inPos) const 
    { return Dtk_ComponentPtr::DtkDynamicCast( _GetChild(inPos) ); }
 
    inline Dtk_ErrorStatus ReplaceChildComponent(const Dtk_Size_t& inPos, const Dtk_ComponentPtr& inNewChild)
    { return _ReplaceChild( inPos, Dtk_DocElementPtr::DtkDynamicCast(inNewChild) ); }
 
    const ComponentTypeEnum& ComponentType() const;
 
     const ComponentAvailabilityEnum ComponentAvailability() const;
 
    const Dtk_string& FullPathName() const;
 
     const Dtk_string& OriginalPathName() const;
 
    const Dtk_transfo& TransformationMatrix() const;
 
    const Dtk_string& InstanceName() const;
 
    const DtkReaderType& GetAssociatedModuleType() const;
 
     Dtk_bool IsAssembly() const;
 
     Dtk_bool IsAdditionnalReference() const;
 
     Dtk_Int32 GetDefaultChildInCatalog() const;
 
     Dtk_tab<Dtk_Int32> GetActivatedChildrenInCatalog() const;
 
    Dtk_NodePtr CreateVirtualNode( Dtk_string inName, const type_detk inSubType = DTK_TYPE_NO_SUBTYPE );
 
     Dtk_NodePtr CreateBodyNode( Dtk_string inName, const Dtk_ID& inBodyID, const Dtk_Int32 inBodyFlag , const type_detk inSubType = DTK_TYPE_BODY);
 
     Dtk_NodePtr CreateMeshNode(
          Dtk_string inName,
          const Dtk_ID& inMeshID,
          const Dtk_Int32 inMeshFlag,
          const type_detk inSubType = DTK_TYPE_MESH );
 
    Dtk_NodePtr CreateFdtNode(
        Dtk_string inName, 
        const Dtk_ID& inFdtID, const type_detk inSubType = DTK_TYPE_FDT);
 
     Dtk_NodePtr CreateKinematicsNode(
          Dtk_string inName, 
          const Dtk_ID& inKinematicID);
 
     Dtk_NodePtr CreateDrawingNode( Dtk_string inName, const Dtk_ID& inDrawingID);
 
     Dtk_NodePtr CreateMetaDataNode( Dtk_string inName, const Dtk_ID& inMetaDataID, const type_detk inSubType = DTK_TYPE_METADATA);
 
     Dtk_NodePtr CreateConstraintNode( Dtk_string inName, const Dtk_ID& inConstraintID, const type_detk inSubType = DTK_TYPE_CONSTRAINT);
 
     Dtk_NodePtr CreateAxisSystemNode( Dtk_string inName, const Dtk_ID& inAxisSystemID, const type_detk inSubType = DTK_TYPE_AXIS_SYSTEM);
 
    Dtk_NodePtr CreateLayerInfosSetNode( Dtk_string inName, const Dtk_ID& inLayerInfosSetID);
 
     Dtk_NodePtr CreateColorInfosSetNode( Dtk_string inName, const Dtk_ID& inColorInfosSetID);
 
    Dtk_NodePtr CreateModelDisplayNode( Dtk_string inName, const Dtk_ID& inDisplayModelID, const type_detk inSubType = DTK_TYPE_NO_SUBTYPE );
 
    Dtk_NodePtr CreateCameraNode( Dtk_string inName, const Dtk_ID& inCameraID);
 
    Dtk_NodePtr GetNodeByID( const Dtk_NodeID& inNodeID ) const;
 
    Dtk_NodePtr GetFatherNode(const Dtk_NodePtr& inNode) const;
 
     Dtk_ErrorStatus GetConceptionUnitScale(Dtk_Double64 &outUnitScale)const;
     SetAsDeprecated("2022.1", "Use Dtk_Component::GetConceptionUnitScale(Dtk_Double64 &outUnitScale) method instead.")
     Dtk_Double64 GetConceptionUnitScale()const;
     void SetConceptionUnitScale(Dtk_Double64 inUnitScale);
 
     const Dtk_string & GetFileVersion()const;
     void SetFileVersion(const Dtk_string & inFileVersion);
 
     Dtk_Int32 GetCurrentLayer() const;
     void SetCurrentLayer(Dtk_Int32 inCurrentLayer);
 
     void GetVisibleLayers(Dtk_tab<Dtk_Int32> &outVisibleLayers)const;
     void SetVisibleLayers(const Dtk_tab<Dtk_Int32> & inVisibleLayers);
 
     void GetSelectableLayers(Dtk_tab<Dtk_Int32> &outSelectableLayers)const;
     void SetSelectableLayers(const Dtk_tab<Dtk_Int32> & inSelectableLayers);
 
     DtkErrorStatus GetSiblingName(Dtk_string &outSiblingName)const;
     DtkErrorStatus SetSiblingName(const Dtk_string & inSiblingName);
 
 
     Dtk_Size_t GetNumNodes() const;
 
    void SetSelectionDataSet( const Dtk_SelectionDataSetPtr& inSelectionDataSet);
 
    const Dtk_GlobalDataSetPtr GetGlobalDataSet() const;
 
 
    Dtk_ErrorStatus GetConnectorsPointingToThisComponent(Dtk_tab<Dtk_NodeConnectorPtr> &outConnectedEntities);
 
    Dtk_ErrorStatus DevalidateNode( const Dtk_NodeID& inNodeID );
 
     Dtk_ErrorStatus GetBoundingBox( Dtk_pnt& outMin, Dtk_pnt& outMax );
 
     DtkErrorStatus AddOverrideSet(const Dtk_OverrideSetPtr& inOverrideSet);
 
     Dtk_Size_t GetNumOverrideSets() const;
 
     DtkErrorStatus GetOverrideSets(Dtk_tab<Dtk_OverrideSetPtr>& outOverrideSet) const;
 
    DtkErrorStatus SetOverrideSets(const Dtk_tab<Dtk_OverrideSetPtr>& inOverrideSets);
};
 
class Dtk_MainDoc : public Dtk_Object
{
     friend class Dtk_MainDocWrapper;
public:
    struct Dtk_Handle;       // Not defined here
protected: 
    enum { _typeID = DTK_TYPE_DOCUMENT }; 
    Dtk_Handle *_Private;   // Handle
    friend class Dtk_API;
     void _ReleaseComponents();
     void _ReleaseNodeConnectors();
private:
    void _Init();
    void _Reset();
    void _Copy(const Dtk_MainDoc&s);
    
    Dtk_MainDoc();
    ~Dtk_MainDoc();
 
    void _AddComponentIntoPool(Dtk_ComponentPtr& outElt);
 
    friend class Dtk_SmartPtr<Dtk_MainDoc>;
public:
 
    static Dtk_MainDocPtr Create();
 
    Dtk_Int32 DtkDynamicType(const int& inId);
 
    static Dtk_MainDoc* DtkDynamicCast(Dtk_Object *s);
 
    void SetRootComponent(const Dtk_ComponentPtr& inRootComponent);
 
    const Dtk_ComponentPtr& RootComponent() const;
    
 
    Dtk_ComponentPtr CreateInstanceDtk_Component(
        const Dtk_ComponentPtr& inPrototype,
        Dtk_string inInstanceName,
        const Dtk_transfo& inTransformationMatrix);
 
    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());
 
    Dtk_ComponentPtr CreateVirtualDtk_Component(
        Dtk_string inComponentName,
        const DtkReaderType& inAssociatedModule,
          Dtk_string inComponentFullPath,
          const Dtk_Component::ComponentAvailabilityEnum& inAvailability);
 
     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());
 
 
     
    Dtk_ComponentPtr GetComponentByID( const Dtk_ComponentID& inComponentID ) const;
 
    Dtk_ComponentPtr GetFatherComponent(const Dtk_ComponentPtr& inComponent,Dtk_Size_t inIndex) const;
 
     Dtk_Size_t GetNumFatherComponent(const Dtk_ComponentPtr& inComponent);
 
     Dtk_Size_t GetNumComponents() const;
 
     Dtk_Int32 GetNumInstances() const;
 
    Dtk_bool IsMultiModel() const;
 
    void  SetMultiModelFlag(Dtk_bool inMultiModelFlag);
 
    Dtk_ErrorStatus DevalidateComponent( const Dtk_ComponentID& inComponentID );
 
     Dtk_ErrorStatus GetMissingComponentList(Dtk_tab<Dtk_string> &outFileList) const;
 
     Dtk_ErrorStatus GetAdditionalReferenceList(Dtk_tab<Dtk_string> &outFileList) const;
 
};
 
class Dtk_NodeConnector : public Dtk_Object
{
public:
     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
          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 inline 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 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";
        }
    }
 
    enum ReasonCategoryEnum
    {
        UnknownCategory = 0,
        PlacementCategory,          //General Placement Category gathering all Placement Reasons
          GeneralAssociationCategory,
        VisibilityCategory,
 
        FirstRefBlockSituationCategory,
        SecondRefBlockSituationCategory,
        ThirdRefBlockSituationCategory,
    };
    static inline Dtk_string ReasonCategoryEnumToString(const ReasonCategoryEnum& inEnum)
    {
        switch( inEnum )
        {
        case PlacementCategory:                     return L"PlacementCategory";
          case GeneralAssociationCategory:            return L"GeneralAssociationCategory";
          case VisibilityCategory:                     return L"VisibilityCategory";
          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( const SubEntity& inTobeCopied ) : _SubEntityID(inTobeCopied._SubEntityID), _SubEntityType(inTobeCopied._SubEntityType){}
        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
    Dtk_Handle *_Private; // Handle
 
    enum
    {
        _typeID = DTK_TYPE_NODE_CONNECTOR
    }; 
 
    Dtk_NodeConnector();
 
    Dtk_NodeConnector(const Dtk_NodeConnector & in);
 
    ~Dtk_NodeConnector();
 
    inline virtual Dtk_Object* Clone() { return new Dtk_NodeConnector(*this); }
 
protected: 
    void _Init();
    void _Reset();
    void _Copy(const Dtk_NodeConnector &s);
    friend class Dtk_SmartPtr<Dtk_NodeConnector>;
public:
    friend class Dtk_Node;
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    static Dtk_NodeConnector* DtkDynamicCast(Dtk_Object *s);
 
    static Dtk_NodeConnectorPtr Create();
 
    static Dtk_NodeConnectorPtr Create(const Dtk_NodeConnector &in);
 
    type_detk get_type_detk() const { return DTK_TYPE_NODE_CONNECTOR; }
 
    Dtk_ID GetAssociatedComponentID() const ;
    void SetAssociatedComponentID (const Dtk_ID &inComponentID);
 
    const Dtk_tab<Dtk_ID>& GetAssociatedPathComponentID() const ;
    void GetAssociatedPathComponentID(Dtk_tab<Dtk_ID>& outAssociatedPathComponentID) const ;
    void SetAssociatedPathComponentID (const Dtk_tab<Dtk_ID> &inPathComponentID);
    Dtk_Int32 CheckAssociatedPathComponentID (const Dtk_MainDocPtr& inMainDocPtr);
 
    Dtk_ID GetNodeId() const ;
    void SetNodeId(const Dtk_ID &inNodeId);
 
 
    Dtk_Size_t GetSubEntitiesNb() const;
 
    Dtk_ErrorStatus GetSubEntities(Dtk_tab <Dtk_ID>& outEntitiesIDs, Dtk_tab <type_detk> & outEntitiesTypes) const;
 
    Dtk_ErrorStatus SetSubEntities(const Dtk_tab <Dtk_ID> &inEntitiesIDs, const Dtk_tab <type_detk> & inEntitiesTypes);
 
    Dtk_ErrorStatus SetSubEntities(const Dtk_tab <SubEntity> &inSubEntities);
 
    Dtk_ErrorStatus AddSubEntities(const Dtk_tab <SubEntity> &inSubEntities);
 
    Dtk_ErrorStatus AddSubEntity(const SubEntity& inSubEntity);
 
    Dtk_ErrorStatus GetSubEntities(Dtk_tab <SubEntity>& outSubEntities) const;
 
    Dtk_Node::FullType GetPointingEntityType() const;
 
    void SetPointingEntityType( const Dtk_Node::FullType inPointingEntityType );
 
    void SetPointedEntityType( const type_detk inPointedEntityType);
 
    type_detk GetPointedEntityType() const;
 
    void SetReasonLink( const ReasonLinkEnum inReasonLink );
 
    Dtk_NodeConnector::ReasonLinkEnum GetReasonLink( ReasonCategoryEnum& outReasonCategory ) const;
 
};
 
 
 
 
#endif