fbxproperty.h

Go to the documentation of this file.

/****************************************************************************************
 
   Copyright (C) 2013 Autodesk, Inc.
   All rights reserved.
 
   Use of this software is subject to the terms of the Autodesk license agreement
   provided at the time of installation or download, or which otherwise accompanies
   this software in either electronic or hard copy form.
 
****************************************************************************************/

#ifndef _FBXSDK_CORE_PROPERTY_H_
#define _FBXSDK_CORE_PROPERTY_H_

#include <fbxsdk/fbxsdk_def.h>

#include <fbxsdk/core/fbxquery.h>
#include <fbxsdk/core/fbxpropertydef.h>
#include <fbxsdk/core/fbxpropertytypes.h>
#include <fbxsdk/core/fbxdatatypes.h>
#include <fbxsdk/core/base/fbxmap.h>
#include <fbxsdk/core/base/fbxset.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

class FbxObject;
class FbxAnimLayer;
class FbxAnimCurveNode;
class FbxAnimCurve;

class FBXSDK_DLL FbxProperty
{
public:
        static FbxProperty Create(const FbxProperty& pCompoundProperty, const FbxDataType& pDataType, const char* pName, const char* pLabel="", bool pCheckForDup=true, bool* pWasFound=NULL);

        static FbxProperty Create(FbxObject* pObject, const FbxDataType& pDataType, const char* pName, const char* pLabel="", bool pCheckForDup=true, bool* pWasFound=NULL);

        static FbxProperty CreateFrom(const FbxProperty& pCompoundProperty, FbxProperty& pFromProperty, bool pCheckForDup=true);

        static FbxProperty CreateFrom(FbxObject* pObject, FbxProperty& pFromProperty, bool pCheckForDup=true);

        void Destroy();

        void DestroyRecursively();

        void DestroyChildren();

        FbxProperty();

        FbxProperty(const FbxProperty& pProperty);

        FbxProperty(const FbxPropertyHandle& pPropertyHandle);

        ~FbxProperty();

        FbxDataType GetPropertyDataType() const;

        FbxString GetName() const;

        const char* GetNameAsCStr() const;

        FbxString GetHierarchicalName() const;

        FbxString GetLabel(bool pReturnNameIfEmpty=true) const;


        void SetLabel(const FbxString& pLabel);

        FbxObject* GetFbxObject() const;

        void SetUserTag(int pTag);
            
        int GetUserTag();

        void SetUserDataPtr(void* pUserData);

        void* GetUserDataPtr();

        void ModifyFlag(FbxPropertyAttr::EFlags pFlag, bool pValue);

        bool GetFlag(FbxPropertyAttr::EFlags pFlag) const;

        FbxPropertyAttr::EFlags GetFlags() const;

        FbxPropertyAttr::EInheritType GetFlagInheritType( FbxPropertyAttr::EFlags pFlag ) const;

        bool SetFlagInheritType( FbxPropertyAttr::EFlags pFlag, FbxPropertyAttr::EInheritType pType );

        bool ModifiedFlag( FbxPropertyAttr::EFlags pFlag ) const;

        FbxProperty& operator= (const FbxProperty& pProperty);

        bool operator== (const FbxProperty& pProperty) const;

        bool operator!= (const FbxProperty& pProperty) const;

        inline bool operator== (int pValue) const { return (pValue == 0) ? !IsValid() : IsValid(); }

        inline bool operator!= (int pValue) const { return (pValue != 0) ? !IsValid() : IsValid(); }

        bool CompareValue(const FbxProperty& pProperty) const;

    bool CopyValue(const FbxProperty& pProperty);

        template <class T> inline T Get() const { T lValue; Get(&lValue, FbxTypeOf(lValue)); return lValue; }

        template <class T> inline bool Set(const T& pValue){ return Set(&pValue, FbxTypeOf(pValue)); }

        bool IsValid() const;

        static bool HasDefaultValue(FbxProperty& pProperty);

        FbxPropertyAttr::EInheritType GetValueInheritType() const;

        bool SetValueInheritType( FbxPropertyAttr::EInheritType pType );

        bool Modified() const;

        void SetMinLimit(double pMin);

        bool HasMinLimit() const;

        double GetMinLimit() const;

        bool HasMaxLimit() const;

        void SetMaxLimit(double pMax);

        double GetMaxLimit() const;

        void SetLimits(double pMin, double pMax);

        int AddEnumValue(const char* pStringValue);

        void InsertEnumValue(int pIndex, const char* pStringValue);

        int GetEnumCount() const;

        void SetEnumValue(int pIndex, const char* pStringValue);

        void RemoveEnumValue(int pIndex);

        const char* GetEnumValue(int pIndex) const;

        inline bool IsRoot() const { return mPropertyHandle.IsRoot(); }

        inline bool IsChildOf(const FbxProperty& pParent) const { return mPropertyHandle.IsChildOf(pParent.mPropertyHandle); }

        inline bool IsDescendentOf(const FbxProperty& pAncestor) const { return mPropertyHandle.IsDescendentOf(pAncestor.mPropertyHandle); }

        inline FbxProperty GetParent() const { return FbxProperty(mPropertyHandle.GetParent());  }

        bool SetParent(const FbxProperty& pOther);

        inline FbxProperty GetChild() const { return FbxProperty(mPropertyHandle.GetChild());   }

        inline FbxProperty GetSibling() const { return FbxProperty(mPropertyHandle.GetSibling()); }

        inline FbxProperty GetFirstDescendent() const { return FbxProperty(mPropertyHandle.GetFirstDescendent());   }

        inline FbxProperty GetNextDescendent(const FbxProperty& pProperty) const { return FbxProperty(mPropertyHandle.GetNextDescendent(pProperty.mPropertyHandle)); }

        inline FbxProperty Find (const char* pName, bool pCaseSensitive = true) const { return FbxProperty(mPropertyHandle.Find(pName,pCaseSensitive));  }

        inline FbxProperty Find (const char* pName, const FbxDataType& pDataType, bool pCaseSensitive = true) const { return FbxProperty(mPropertyHandle.Find(pName,pDataType.GetTypeInfoHandle(),pCaseSensitive));  }

        inline FbxProperty FindHierarchical (const char* pName, bool pCaseSensitive = true) const { return FbxProperty(mPropertyHandle.Find(pName,sHierarchicalSeparator,pCaseSensitive));  }

        inline FbxProperty FindHierarchical (const char* pName, const FbxDataType& pDataType, bool pCaseSensitive = true) const { return FbxProperty(mPropertyHandle.Find(pName,sHierarchicalSeparator,pDataType.GetTypeInfoHandle(),pCaseSensitive));  }


        inline void BeginCreateOrFindProperty(){ mPropertyHandle.BeginCreateOrFindProperty(); }

        inline void EndCreateOrFindProperty(){ mPropertyHandle.EndCreateOrFindProperty(); }

        class FbxPropertyNameCache
        {
        public:
            FbxPropertyNameCache(const FbxProperty& prop) : mProp(const_cast<FbxProperty&>(prop)){ mProp.BeginCreateOrFindProperty(); }

            ~FbxPropertyNameCache(){ mProp.EndCreateOrFindProperty(); }

        private:
            FbxProperty& mProp;
            FbxPropertyNameCache& operator=(const FbxPropertyNameCache& pOther){ mProp = pOther.mProp; mProp.BeginCreateOrFindProperty(); return *this; }
        };

        bool    SetArraySize( int pSize, bool pVariableArray );

        int     GetArraySize() const;

        FbxProperty GetArrayItem(int pIndex) const;

        inline FbxProperty operator[](int pIndex) const { return GetArrayItem(pIndex); }

        FbxAnimCurveNode* CreateCurveNode(FbxAnimLayer* pAnimLayer);

        FbxAnimCurveNode* GetCurveNode(FbxAnimLayer* pAnimLayer, bool pCreateAsNeeded=false);

        FbxAnimCurveNode* GetCurveNode(bool pCreateAsNeeded=false, const char* pAnimStackName = NULL);

        inline FbxAnimCurve* GetCurve(FbxAnimLayer* pAnimLayer, bool pCreateAsNeeded=false)
        {
            return GetCurve(pAnimLayer, GetName(), NULL, pCreateAsNeeded);
        }

        inline FbxAnimCurve* GetCurve(FbxAnimLayer* pAnimLayer, const char* pChannel, bool pCreateAsNeeded=false)
        {
            return GetCurve(pAnimLayer, GetName(), pChannel, pCreateAsNeeded);
        }

        FbxAnimCurve* GetCurve(FbxAnimLayer* pAnimLayer, const char* pName, const char* pChannel, bool pCreateAsNeeded);

        bool ConnectSrcObject(FbxObject* pObject, FbxConnection::EType pType=FbxConnection::eNone);

        bool IsConnectedSrcObject(const FbxObject* pObject) const;

        bool DisconnectSrcObject(FbxObject* pObject);

        bool DisconnectAllSrcObject();

        bool DisconnectAllSrcObject(const FbxCriteria& pCriteria);

        FBX_DEPRECATED bool DisconnectAllSrcObject(const FbxClassId& pClassId);

        int  GetSrcObjectCount() const;

        int GetSrcObjectCount(const FbxCriteria& pCriteria) const;

        FBX_DEPRECATED int GetSrcObjectCount(const FbxClassId& pClassId) const;

        FbxObject* GetSrcObject(const int pIndex=0) const;

        FbxObject* GetSrcObject(const FbxCriteria& pCriteria, const int pIndex=0) const;

        FBX_DEPRECATED FbxObject* GetSrcObject(const FbxClassId& pClassId, const int pIndex=0) const;

        FbxObject* FindSrcObject(const char* pName, const int pStartIndex=0) const;

        FbxObject* FindSrcObject(const FbxCriteria& pCriteria, const char* pName, const int pStartIndex=0) const;

        FBX_DEPRECATED FbxObject* FindSrcObject(const FbxClassId& pClassId, const char* pName, const int pStartIndex=0) const;

        template <class T> FBX_DEPRECATED inline bool DisconnectAllSrcObject (const T*){ return DisconnectAllSrcObject(T::ClassId);}

        template <class T> inline bool DisconnectAllSrcObject(){ return DisconnectAllSrcObject(FbxCriteria::ObjectType(T::ClassId)); }

        template <class T> FBX_DEPRECATED inline bool DisconnectAllSrcObject (const T*, const FbxCriteria& pCriteria)  { return DisconnectAllSrcObject(T::ClassId,pCriteria);  }

        template <class T> inline bool DisconnectAllSrcObject(const FbxCriteria& pCriteria){ return DisconnectAllSrcObject(FbxCriteria::ObjectType(T::ClassId) && pCriteria); }

        template <class T> FBX_DEPRECATED inline int  GetSrcObjectCount(const T*) const{ return GetSrcObjectCount(T::ClassId); }

        template <class T> inline int GetSrcObjectCount() const { return GetSrcObjectCount(FbxCriteria::ObjectType(T::ClassId)); }

        template <class T> FBX_DEPRECATED inline int GetSrcObjectCount(const T*, const FbxCriteria& pCriteria) const { return GetSrcObjectCount(T::ClassId,pCriteria); }

        template <class T> inline int GetSrcObjectCount(const FbxCriteria& pCriteria) const { return GetSrcObjectCount(FbxCriteria::ObjectType(T::ClassId) && pCriteria); }

        template <class T> FBX_DEPRECATED inline T* GetSrcObject(const T*, int pIndex=0) const { return (T*)GetSrcObject(T::ClassId,pIndex); }

        template <class T> inline T* GetSrcObject(const int pIndex=0) const { return (T*)GetSrcObject(FbxCriteria::ObjectType(T::ClassId), pIndex); }

        template <class T> FBX_DEPRECATED inline T* GetSrcObject(const T*, const FbxCriteria& pCriteria,int pIndex=0) const { return (T*)GetSrcObject(T::ClassId,pCriteria,pIndex); }

        template <class T> inline T* GetSrcObject(const FbxCriteria& pCriteria, const int pIndex=0) const { return (T*)GetSrcObject(FbxCriteria::ObjectType(T::ClassId) && pCriteria, pIndex); }

        template <class T> FBX_DEPRECATED inline T* FindSrcObject(const T*, const char* pName, int pStartIndex=0) const { return (T*)FindSrcObject(T::ClassId,pName,pStartIndex); }

        template <class T> inline T* FindSrcObject(const char* pName, const int pStartIndex=0) const { return (T*)FindSrcObject(FbxCriteria::ObjectType(T::ClassId), pName, pStartIndex); }

        template <class T> FBX_DEPRECATED inline T* FindSrcObject(const T*, const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const { return (T*)FindSrcObject(T::ClassId,pCriteria,pName,pStartIndex); }

        template <class T> inline T* FindSrcObject(const FbxCriteria& pCriteria, const char* pName, const int pStartIndex=0) const { return (T*)FindSrcObject(FbxCriteria::ObjectType(T::ClassId) && pCriteria, pName, pStartIndex); }

        bool ConnectDstObject(FbxObject* pObject, FbxConnection::EType pType=FbxConnection::eNone);

        bool IsConnectedDstObject(const FbxObject* pObject) const;

        bool DisconnectDstObject(FbxObject* pObject);

        bool DisconnectAllDstObject();

        bool DisconnectAllDstObject(const FbxCriteria& pCriteria);

        FBX_DEPRECATED bool DisconnectAllDstObject(const FbxClassId& pClassId);

        int GetDstObjectCount() const;

        int GetDstObjectCount(const FbxCriteria& pCriteria) const;

        FBX_DEPRECATED int GetDstObjectCount(const FbxClassId& pClassId) const;

        FbxObject* GetDstObject(const int pIndex=0) const;

        FbxObject* GetDstObject(const FbxCriteria& pCriteria, const int pIndex=0) const;

        FBX_DEPRECATED FbxObject* GetDstObject(const FbxClassId& pClassId, const int pIndex=0) const;

        FbxObject* FindDstObject(const char* pName, const int pStartIndex=0) const;

        FbxObject* FindDstObject(const FbxCriteria& pCriteria, const char* pName, const int pStartIndex=0) const;

        FBX_DEPRECATED FbxObject* FindDstObject(const FbxClassId& pClassId, const char* pName, const int pStartIndex=0) const;

        template <class T> FBX_DEPRECATED inline bool DisconnectAllDstObject (const T*){ return DisconnectAllDstObject(T::ClassId);    }

        template <class T> inline bool DisconnectAllDstObject(){ return DisconnectAllDstObject(FbxCriteria::ObjectType(T::ClassId)); }

        template <class T> FBX_DEPRECATED inline bool DisconnectAllDstObject (const T*, const FbxCriteria& pCriteria)  { return DisconnectAllDstObject(T::ClassId,pCriteria);  }

        template <class T> inline bool DisconnectAllDstObject(const FbxCriteria& pCriteria){ return DisconnectAllDstObject(FbxCriteria::ObjectType(T::ClassId) && pCriteria); }

        template <class T> FBX_DEPRECATED inline int GetDstObjectCount(const T*) const { return GetDstObjectCount(T::ClassId); }

        template <class T> inline int GetDstObjectCount() const { return GetDstObjectCount(FbxCriteria::ObjectType(T::ClassId)); }

        template <class T> FBX_DEPRECATED inline int  GetDstObjectCount(const T*, const FbxCriteria& pCriteria) const { return GetDstObjectCount(T::ClassId,pCriteria); }

        template <class T> inline int GetDstObjectCount(const FbxCriteria& pCriteria) const { return GetDstObjectCount(FbxCriteria::ObjectType(T::ClassId) && pCriteria); }

        template <class T> FBX_DEPRECATED inline T* GetDstObject(const T*, int pIndex=0) const { return (T*)GetDstObject(T::ClassId,pIndex); }

        template <class T> inline T* GetDstObject(const int pIndex=0) const { return (T*)GetDstObject(FbxCriteria::ObjectType(T::ClassId), pIndex); }

        template <class T> FBX_DEPRECATED inline T* GetDstObject(const T*, const FbxCriteria& pCriteria, int pIndex=0) const { return (T*)GetDstObject(T::ClassId,pCriteria,pIndex); }

        template <class T> inline T* GetDstObject(const FbxCriteria& pCriteria, const int pIndex=0) const { return (T*)GetDstObject(FbxCriteria::ObjectType(T::ClassId) && pCriteria, pIndex); }

        template <class T> FBX_DEPRECATED inline T* FindDstObject(const T*, const char* pName, int pStartIndex=0) const { return (T*)FindDstObject(T::ClassId,pName,pStartIndex); }

        template <class T> inline T* FindDstObject(const char* pName, const int pStartIndex=0) const { return (T*)FindDstObject(FbxCriteria::ObjectType(T::ClassId), pName, pStartIndex); }

        template <class T> FBX_DEPRECATED inline T* FindDstObject(const T*, const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const { return (T*)FindDstObject(T::ClassId,pCriteria,pName,pStartIndex); }

        template <class T> inline T* FindDstObject(const FbxCriteria& pCriteria, const char* pName, const int pStartIndex=0) const { return (T*)FindDstObject(FbxCriteria::ObjectType(T::ClassId) && pCriteria, pName, pStartIndex); }

        // Properties
        bool ConnectSrcProperty(const FbxProperty& pProperty);

        bool IsConnectedSrcProperty(const FbxProperty& pProperty);

        bool DisconnectSrcProperty(const FbxProperty& pProperty);

        int GetSrcPropertyCount() const;            

        bool ConnectDstProperty(const FbxProperty&  pProperty);

        bool IsConnectedDstProperty(const FbxProperty& pProperty);

        bool DisconnectDstProperty(const FbxProperty& pProperty);

        int GetDstPropertyCount() const;

        void ClearConnectCache();

        FbxProperty GetSrcProperty(const int pIndex=0) const;

        FbxProperty FindSrcProperty(const char* pName, const int pStartIndex=0) const;

        FbxProperty GetDstProperty(const int pIndex=0) const;

        FbxProperty FindDstProperty(const char* pName, const int pStartIndex=0) const;

    static const char* sHierarchicalSeparator;

/*****************************************************************************************************************************
** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
*****************************************************************************************************************************/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    FbxProperty(FbxObject* pObject, char const* pName, const FbxDataType& pDataType=FbxDataType(), const char* pLabel="");
    FbxProperty(const FbxProperty& pParent, const char* pName, const FbxDataType& pDataType, const char* pLabel);

    bool Set(const void* pValue, const EFbxType& pValueType, bool pCheckForValueEquality=true);
    bool Get(void* pValue, const EFbxType& pValueType) const;

    bool NotifySetRequest();
    bool NotifySet();
    bool NotifyGet() const;

private:
    inline void*    Get() const { FBX_ASSERT_NOW("Cannot get property value as void!"); return NULL; }
    inline bool     Set(const void* &){ FBX_ASSERT_NOW("Cannot set property value as void!"); return false; }

    bool            ConnectSrc(const FbxProperty& pProperty, FbxConnection::EType pType=FbxConnection::eNone);
    bool            DisconnectSrc(const FbxProperty& pProperty);
    bool            DisconnectAllSrc();
    bool            DisconnectAllSrc(const FbxCriteria& pCriteria);
    bool            IsConnectedSrc(const FbxProperty& pProperty) const;
    int             GetSrcCount() const;
    int             GetSrcCount(const FbxCriteria& pCriteria) const;
    FbxProperty     GetSrc(int pIndex=0) const;
    FbxProperty     GetSrc(const FbxCriteria& pCriteria, int pIndex=0) const;
    FbxProperty     FindSrc(const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const;

    bool            ConnectDst(const FbxProperty& pProperty, FbxConnection::EType pType=FbxConnection::eNone);
    bool            DisconnectDst(const FbxProperty& pProperty);
    bool            DisconnectAllDst();
    bool            DisconnectAllDst(const FbxCriteria& pCriteria);
    bool            IsConnectedDst(const FbxProperty& pProperty) const;
    int             GetDstCount() const;
    int             GetDstCount(const FbxCriteria& pCriteria) const;
    FbxProperty     GetDst(int pIndex=0) const;
    FbxProperty     GetDst(const FbxCriteria& pCriteria, int pIndex=0) const;
    FbxProperty     FindDst(const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const;

    mutable FbxPropertyHandle mPropertyHandle;

    friend class FbxObject;
    friend class FbxIOSettings;
    friend class FbxBindingOperator;
    friend class FbxAnimEvalClassic;
    friend void FbxMarkObject(FbxObject* pObject, FbxMap<FbxObject*, int>& pObjectDstDisconnectCount, FbxSet2<FbxObject*>& pObjectsToDeleted, FbxArray<FbxObject*>& pObjectToDeletedInSequence);
    friend void FbxCleanUpConnectionsAtDestructionBoundary(FbxScene* pObject, FbxArray<FbxObject*>& pObjectToDeletedInSequence);
#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
};

template <class T> class FbxPropertyT : public FbxProperty
{
public:
        FbxProperty& StaticInit(FbxObject* pObject, const char* pName, const T& pValue, bool pForceSet, FbxPropertyAttr::EFlags pFlags=FbxPropertyAttr::eNone)
        {
            return StaticInit(pObject, pName, FbxGetDataTypeFromEnum(FbxTypeOf(*((T*)0))), pValue, pForceSet, pFlags);
        }

        FbxProperty& StaticInit(FbxObject* pObject, const char* pName, const FbxDataType& pDataType, const T& pValue, bool pForceSet, FbxPropertyAttr::EFlags pFlags=FbxPropertyAttr::eNone)
        {
            bool lWasFound = false;
            *this = Create(pObject, pDataType, pName, "", true, &lWasFound);
            if( pForceSet || !lWasFound )
            {
                ModifyFlag(pFlags, true);   // modify the flags before we set the value
                FbxProperty::Set(&pValue, FbxTypeOf(pValue), false);
            }
            ModifyFlag(FbxPropertyAttr::eStatic, true);
            return *this;
        }

        FbxProperty& StaticInit(FbxProperty pCompound, const char* pName, const FbxDataType& pDataType, const T& pValue, bool pForceSet=true, FbxPropertyAttr::EFlags pFlags=FbxPropertyAttr::eNone)
        {
            bool lWasFound = false;
            *this = Create(pCompound, pDataType, pName, "", true, &lWasFound);
            if( pForceSet || !lWasFound )
            {
                ModifyFlag(pFlags, true);   // modify the flags before we set the value
                FbxProperty::Set(&pValue, FbxTypeOf(pValue), false);
            }
            ModifyFlag(FbxPropertyAttr::eStatic, true);
            return *this;
        }

        FbxPropertyT& Set(const T& pValue){ FbxProperty::Set(&pValue, FbxTypeOf(pValue)); return *this; }

        T Get() const { T lValue; FbxProperty::Get(&lValue, FbxTypeOf(lValue)); return lValue; }

        FbxPropertyT& operator=(const T& pValue){ return Set(pValue); }

        operator T() const { return Get(); }

/*****************************************************************************************************************************
** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
*****************************************************************************************************************************/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    FbxPropertyT() : FbxProperty(){}
    FbxPropertyT(const FbxProperty& pProperty) : FbxProperty(pProperty){}
    ~FbxPropertyT(){}
#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
};

/*****************************************************************************************************************************
** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
*****************************************************************************************************************************/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <> class FbxPropertyT<FbxReference> : public FbxProperty
{
public:
    FbxPropertyT() : FbxProperty(){}
    FbxPropertyT(const FbxProperty& pProperty) : FbxProperty(pProperty){}
    ~FbxPropertyT(){}

    const FbxProperty& StaticInit(FbxObject* pObject, const char* pName, const FbxReference& pValue, bool pForceSet, FbxPropertyAttr::EFlags pFlags=FbxPropertyAttr::eNone)
    {
        return StaticInit(pObject, pName, FbxGetDataTypeFromEnum(FbxTypeOf(*((FbxReference*)0))), pValue, pForceSet, pFlags);
    }

    const FbxProperty& StaticInit(FbxObject* pObject, const char* pName, const FbxDataType& pDataType, const FbxReference& pValue, bool pForceSet, FbxPropertyAttr::EFlags pFlags=FbxPropertyAttr::eNone)
    {
        bool lWasFound = false;
        *this = Create(pObject, pDataType, pName, "", true, &lWasFound);
        if( pForceSet || !lWasFound )
        {
            ModifyFlag(pFlags, true);   // modify the flags before we set the value
            Set(pValue);            // since we will trigger callbacks in there!
        }
        ModifyFlag(FbxPropertyAttr::eStatic, true);
        return *this;
    }

    FbxReference Get() const
    {
        FbxProperty::NotifyGet();
        return GetSrcObject();
    }

    FbxPropertyT& Set(const FbxReference& pValue)
    {
        bool Result = FbxProperty::NotifySetRequest();
        if( Result )
        {
            DisconnectAllSrcObject();
            ConnectSrcObject(pValue);
            FbxProperty::NotifySet();
        }
        return *this;
    }

    operator FbxReference() const
    {
        return Get();
    }

    FbxPropertyT& operator=(const FbxReference& pValue)
    {
        return Set(pValue);
    }
};
#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_CORE_PROPERTY_H_ */