dtk_fdt_set.hpp

Go to the documentation of this file.

#ifndef __DTK_FDT_SET_HPP__
#define __DTK_FDT_SET_HPP__
#include "def/define.h"
#include "util/BaseTypes/dtk_object.hpp"
#include "util/BaseTypes/dtk_string.hpp"
#include "util/BaseTypes/dtk_transfo.hpp"
#include "util/dtk_maindoc_ptr.hpp"
#include "util/util_draw_ptr_dtk.hpp"
#include "util/util_ptr_dtk.hpp"
#include "util/util_stl_dtk.hpp"
 
typedef Dtk_ID Dtk_FdtId;
 
namespace Dtk_FdtSetPackage
{
    //forward declarations
    class FdtInfos;
    class View;
    class Capture;
    class Dtk_FdtSet;
    typedef Dtk_SmartPtr< FdtInfos >            FdtInfosPtr;
    typedef Dtk_SmartPtr< View >                ViewPtr;
    typedef Dtk_SmartPtr< Capture >             CapturePtr;
    typedef Dtk_SmartPtr< Dtk_FdtSet >          Dtk_FdtSetPtr;
 
    class FdtInfos : Dtk_Object
    {
    protected:
        Dtk_FdtId                               _Id;
        Dtk_NodePtr                             _Fdt;
        Dtk_tab <Dtk_NodeConnectorPtr>          _AssociatedFDTs;
        //Dtk_tab <Dtk_NodeConnectorPtr>          _AssociatedConstructionGeometries;
        Dtk_tab <Dtk_NodeConnectorPtr>          _AssociatedGeometries; 
    protected:
        void _Init();
        void _Reset();
        void _Copy( const FdtInfos& inToBeCopied);
        FdtInfos( const Dtk_FdtId inFdtId, const Dtk_NodePtr& inFdt );
        inline FdtInfos( const FdtInfos& inToBeCopied ) : Dtk_Object(inToBeCopied) { _Init(); _Copy(inToBeCopied); }
        inline virtual ~FdtInfos() { _Reset(); }
 
        enum { _typeID = DTK_TYPE_FDT_SET_FDT_INFOS }; 
        friend class Dtk_SmartPtr<FdtInfos>;
        friend class Dtk_FdtSet;
    public:
        inline Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
        { 
            if(inId == _typeID)
                return 1; 
            return Dtk_Object::DtkDynamicType(inId); 
        } 
 
        inline static FdtInfos * DtkDynamicCast(Dtk_Object *s)
        { 
            if(s->DtkDynamicType(_typeID)) 
                return static_cast<FdtInfos*>(s); 
            return NULL; 
        } 
 
        type_detk get_type_detk() const { return DTK_TYPE_FDT_SET_FDT_INFOS; }
        void AddAssociatedFdt( const Dtk_NodeConnectorPtr& inAssociatedFdt);
        void AddAssociatedGeometry( const Dtk_NodeConnectorPtr& inAssociatedGeometry);
        void SetAssociatedGeometries( const Dtk_tab< Dtk_NodeConnectorPtr >& inAssociatedGeometries);
 
        inline const Dtk_tab <Dtk_NodeConnectorPtr>& GetAssociatedFdts() const {return _AssociatedFDTs;}
        inline const Dtk_tab <Dtk_NodeConnectorPtr>& GetAssociatedGeometries() const {return _AssociatedGeometries;}
        inline const Dtk_NodePtr& GetFdt() const {return _Fdt;}
        inline const Dtk_FdtId& GetFdtId() const {return _Id;}
    };
    class View : Dtk_Object
    {
    protected:
        Dtk_InfoPtr             _Infos;
        Dtk_transfo             _Matrix;
        Dtk_tab< Dtk_FdtId >    _FdtIds;
        const Dtk_FdtSet*             _FdtSetRef;
    protected:
        void _Init();
        void _Reset();
        void _Copy( const View& inToBeCopied);
        View(const Dtk_string& inViewName, 
            const Dtk_transfo& inPlacementMatrix,
            const Dtk_FdtSet* inOwningFdtSet);
        inline View(const View& inToBeCopied) : Dtk_Object(inToBeCopied) { _Init(); _Copy(inToBeCopied); }
        inline virtual ~View() { _Reset(); }
 
        enum { _typeID = DTK_TYPE_FDT_SET_VIEW }; 
        friend class Dtk_SmartPtr<View>;
        friend class Dtk_FdtSet;
    public:
        inline Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
        { 
            if(inId == _typeID)
                return 1; 
            return Dtk_Object::DtkDynamicType(inId); 
        } 
 
        inline static View * DtkDynamicCast(Dtk_Object *s)
        { 
            if(s->DtkDynamicType(_typeID)) 
                return static_cast<View*>(s); 
            return NULL; 
        } 
        type_detk get_type_detk() const { return DTK_TYPE_FDT_SET_VIEW; }
 
        inline Dtk_InfoPtr get_info() const {return _Infos;}
        inline Dtk_InfoPtr& info() {return _Infos;}
 
        inline const Dtk_transfo& GetPlacementMatrix() const {return _Matrix;}
        inline const Dtk_tab< Dtk_FdtId >& GetFdtIds() const {return _FdtIds;}
        void AddFdt(const Dtk_FdtId& inFdtID);
    };
    class Capture : Dtk_Object
    {
    protected:
        Dtk_InfoPtr                             _Infos;
        Dtk_EntityPtr                           _ClippingEntity;
        Dtk_CameraPtr                           _Camera;
        Dtk_tab <Dtk_NodeConnectorPtr>          _VisibleFDTs;
        Dtk_tab <Dtk_NodeConnectorPtr>          _VisibleGeoms;
    protected:
        void _Init();
        void _Reset();
        void _Copy( const Capture& inToBeCopied);
        Capture(const Dtk_CameraPtr& inCamera, const Dtk_EntityPtr& inClippingEntity);
        inline Capture(const Capture& inToBeCopied) : Dtk_Object(inToBeCopied) { _Init(); _Copy(inToBeCopied); }
        inline virtual ~Capture() { _Reset(); }
 
        enum { _typeID = DTK_TYPE_FDT_SET_CAPTURE }; 
        friend class Dtk_SmartPtr<Capture>;
        friend class Dtk_FdtSet;
    public:
        inline Dtk_InfoPtr get_info() const {return _Infos;}
        inline Dtk_InfoPtr& info()          {return _Infos;}
 
        inline Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
        { 
            if(inId == _typeID)
                return 1; 
            return Dtk_Object::DtkDynamicType(inId); 
        } 
 
        inline static Capture * DtkDynamicCast(Dtk_Object *s)
        { 
            if(s->DtkDynamicType(_typeID)) 
                return static_cast<Capture*>(s); 
            return NULL; 
        } 
        inline type_detk get_type_detk() const { return DTK_TYPE_FDT_SET_CAPTURE; }
 
 
        inline const Dtk_CameraPtr& GetCamera() const {return _Camera;}
 
        inline const Dtk_EntityPtr& GetClippingEntity() const {return _ClippingEntity;}
 
        void AddVisibleFdtId(const Dtk_NodeConnectorPtr& inConnectorToVisibleFdt);
 
        void AddVisibleGeometry(const Dtk_NodeConnectorPtr& inConnectorToVisibleGeometry);
 
        inline const Dtk_tab <Dtk_NodeConnectorPtr> GetVisibleFdts()     const   { return _VisibleFDTs; }
        inline const Dtk_tab <Dtk_NodeConnectorPtr> GetVisibleGeometry() const   { return _VisibleGeoms; }
 
        
        inline const Dtk_tab <Dtk_NodeConnectorPtr>& GetArrayVisibleFdts()     const   { return _VisibleFDTs; }
        inline const Dtk_tab <Dtk_NodeConnectorPtr>& GetArrayVisibleGeometry() const   { return _VisibleGeoms; }
        void AddArrayVisibleFdtId( Dtk_tab < Dtk_NodeConnectorPtr> inConnectorToVisibleFdt );
        void AddArrayVisibleGeometry( Dtk_tab < Dtk_NodeConnectorPtr> inConnectorToVisibleGeometry );
        void AddFdtId( const Dtk_NodeConnectorPtr& inConnectorToVisibleFdt );
        void AddGeometry( const Dtk_NodeConnectorPtr& inConnectorToVisibleGeometry );
 
 
    };
    class Dtk_FdtSet : Dtk_Object
    {
    protected:
        Dtk_tab< FdtInfosPtr >     _Fdts;
        Dtk_tab< ViewPtr >         _Views;
        Dtk_tab< CapturePtr >      _Captures;
    protected:
        enum { _typeID = DTK_TYPE_FDT_SET }; 
        void _Init();
        void _Reset();
        void _Copy( const Dtk_FdtSet& inToBeCopied);
        friend class Dtk_SmartPtr<Dtk_FdtSet>;
 
        Dtk_FdtSet(const Dtk_string& inStandard, const Dtk_bool inIsActivated);
        inline Dtk_FdtSet(const Dtk_FdtSet& inToBeCopied) : Dtk_Object(inToBeCopied) { _Init(); _Copy(inToBeCopied); }
        inline virtual ~Dtk_FdtSet() { _Reset(); }
    public:
        inline Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
        { 
            if(inId == _typeID)
                return 1; 
            return Dtk_Object::DtkDynamicType(inId); 
        } 
 
        inline static Dtk_FdtSet * DtkDynamicCast(Dtk_Object *s)
        { 
            if(s->DtkDynamicType(_typeID)) 
                return static_cast<Dtk_FdtSet*>(s); 
            return NULL; 
        } 
        inline type_detk get_type_detk() const { return DTK_TYPE_FDT_SET; }
 
        static Dtk_FdtSetPtr Create(const Dtk_string& inStandard, const Dtk_bool inisActivated);
 
        //sub classes constructors
        ViewPtr CreateView(const Dtk_string& inViewName, const Dtk_transfo& inPlacementMatrix);
        //sub classes constructors
        CapturePtr CreateCapture(const Dtk_CameraPtr& inCamera, const Dtk_EntityPtr& inClippingEntity);
        //sub classes constructors
        FdtInfosPtr CreateFdtInfos( const Dtk_NodePtr& inFdt );
 
        inline Dtk_Size_t GetNumFdtInfos() const {return _Fdts.size() - 1;}
        inline const FdtInfosPtr GetFdtInfos(const Dtk_FdtId inFdtId) const 
        { if( inFdtId == 0 || inFdtId >= _Fdts.size() ) return NULL; else return _Fdts[inFdtId];}
        const FdtInfosPtr SearchFdtInfosByFdtNode(const Dtk_NodePtr& inFdtNode) const;
 
        inline const Dtk_tab< ViewPtr >& GetViews()        const {return _Views;};
        inline const Dtk_tab< CapturePtr >& GetCaptures()  const {return _Captures;}
 
    };
} //namespace Dtk_FdtSetPackage
 
#endif