#include <fbxpropertypage.h>

Public Types
enum	EValueIndex { eValueMin, eValueSoftMin, eValueMax, eValueSoftMax, eValueCount }

Public Member Functions
void	Destroy ()

template<class T >
T *	GetPropertyItem (const T pItemType, FbxInt pIndex, FbxPropertyPage *pFoundIn=0) const

template<class T >
T *	ChangePropertyItemState (const T *pItemType, FbxInt pIndex, FbxPropertyFlags::EInheritType pInheritType)

template<class T >
FbxPropertyPage *	GetFirstPropertyItem (FbxInt pId, const T *pItem) const

const char *	GetName (FbxInt pId=0)

const char *	GetLabel (FbxInt pId=0)

bool	SetLabel (FbxInt pId=0, const char *pLabel="")

void *	GetUserData (FbxInt pId=0)

bool	SetUserData (FbxInt pId=0, const void *pUserData=0)

int	GetUserTag (FbxInt pId=0)

bool	SetUserTag (FbxInt pId=0, int pUserTag=0)

EFbxType	GetType (FbxInt pId=0) const

FbxInt	GetParent (FbxInt pId=0) const

FbxPropertyPage *	GetTypeInfo (FbxInt pId=0)

FbxInt	Add (FbxInt pParentId, const char *pName, EFbxType pType)

FbxInt	Add (FbxInt pParentId, const char pName, FbxPropertyPage pTypeInfo)

bool	Reparent (FbxInt, FbxInt)

bool	IsChildOf (FbxInt pId, FbxInt pParentId) const

bool	IsDescendentOf (FbxInt pId, FbxInt pAncestorId) const

FbxInt	GetChild (FbxInt pParentId=0) const
	Retrieves the first child property id of a specified property id. More...

FbxInt	GetSibling (FbxInt pId) const
	Retrieves the next sibling property id of a specified property id. More...

FbxInt	GetFirstDescendent (FbxInt pAnscestorId=0) const
	Retrieves the first descendent property id of a specified property id. More...

FbxInt	GetNextDescendent (FbxInt pAnscestorId, FbxInt pId) const
	Retrieves the next descendent property id of a specified property id, with given a descendent property id. More...

FbxInt	FastFind (FbxInt pId, const char pName, FbxPropertyPage pTypeInfo, bool pCaseSensitive)

FbxInt	Find (FbxInt pId, const char pName, FbxPropertyPage pTypeInfo, bool pCaseSensitive, const char *pChildrenSeparators)

int	AddEnumValue (FbxInt pId, const char *pStringValue)

void	InsertEnumValue (FbxInt pId, int pIndex, const char *pStringValue)

int	GetEnumCount (FbxInt pId)

void	SetEnumValue (FbxInt pId, int pIndex, const char *pStringValue)

void	RemoveEnumValue (FbxInt pId, int pIndex)

char *	GetEnumValue (FbxInt pId, int pIndex)

void	ClearConnectCache (FbxInt pId)

void	WipeAllConnections (FbxInt pId)

bool	ConnectSrc (FbxInt pDstId, FbxPropertyPage *pSrcPage, FbxInt pSrcId, FbxConnection::EType pType)

bool	DisconnectSrc (FbxInt pDstId, FbxPropertyPage *pSrcPage, FbxInt pSrcId)

bool	IsConnectedSrc (FbxInt pDstId, FbxPropertyPage *pSrcPage, FbxInt pSrcId)

int	GetSrcCount (FbxInt pId, FbxConnectionPointFilter *pFilter)

bool	GetSrc (FbxInt pId, int pIndex, FbxConnectionPointFilter pFilter, FbxPropertyPage pSrcPage, FbxInt pSrcId)

bool	ConnectDst (FbxInt pSrcId, FbxPropertyPage *pDstPage, FbxInt pDstId, FbxConnection::EType pType)

bool	DisconnectDst (FbxInt pSrcId, FbxPropertyPage *pDstPage, FbxInt pDstId)

bool	IsConnectedDst (FbxInt pSrcId, FbxPropertyPage *pDstPage, FbxInt pDstId)

int	GetDstCount (FbxInt pId, FbxConnectionPointFilter *pFilter)

bool	GetDst (FbxInt pId, int pIndex, FbxConnectionPointFilter pFilter, FbxPropertyPage pDstPage, FbxInt pDstId)

bool	HasMinMax (FbxInt pId, FbxPropertyInfo::EValueIndex pValueId) const

bool	GetMinMax (FbxInt pId, FbxPropertyInfo::EValueIndex pValueId, void *pValue, EFbxType pValueType)

bool	SetMinMax (FbxInt pId, FbxPropertyInfo::EValueIndex pValueId, const void *pValue, EFbxType pValueType)

bool	Get (FbxInt pId, void *pValue, EFbxType pValueType)

bool	Set (FbxInt pId, const void *pValue, EFbxType pValueType, bool pCheckValueEquality)

FbxPropertyFlags::EInheritType	GetValueInherit (FbxInt pId, bool pCheckInstanceOf) const

bool	SetValueInherit (FbxInt pId, FbxPropertyFlags::EInheritType pType)

bool	GetDefaultValue (FbxInt pId, void *pValue, EFbxType pValueType) const

template<class T >
bool	Set (FbxInt pId, const T &pValue)

template<class T >
T	Get (FbxInt pId, const T *pFBX_TYPE)

void	SetDataPtr (void *pDataPtr)

void *	GetDataPtr () const

void	PushPropertiesToParentInstance ()

const FbxPropertyPage *	GetInstanceOf () const

FbxPropertyPage *	GetInstanceOf ()

const FbxSet< FbxPropertyPage * > &	GetInstances () const

FbxPropertyFlags::EFlags	GetFlags (FbxInt pId=0) const

bool	ModifyFlags (FbxInt pId=0, FbxPropertyFlags::EFlags pFlags=FbxPropertyFlags::eNone, bool pValue=true, bool pCheckFlagEquality=true)

FbxPropertyFlags::EInheritType	GetFlagsInheritType (FbxPropertyFlags::EFlags pFlags, bool pCheckInstanceOf, FbxInt pId=0) const

bool	SetFlagsInheritType (FbxPropertyFlags::EInheritType pInheritType, FbxPropertyFlags::EFlags pFlags, FbxInt pId=0)

void	BeginCreateOrFindProperty ()

void	EndCreateOrFindProperty ()

Static Public Member Functions
static FbxPropertyPage *	Create (FbxPropertyPage *pInstanceOf=0)

static FbxPropertyPage *	Create (const char pName, FbxPropertyPage pTypeInfo)

static FbxPropertyPage *	Create (const char *pName, EFbxType pType=eFbxUndefined)

Protected Member Functions
	FbxPropertyPage (FbxPropertyPage *pInstanceOf=0)

	FbxPropertyPage (const char *pName, EFbxType pType)

	FbxPropertyPage (const char pName, FbxPropertyPage pTypeInfo)

	~FbxPropertyPage ()

bool	Is (FbxPropertyPage *pPage)

Friends
class	FbxPropertyHandle

template<typename T >
T *	fbxsdk::FbxNew ()

template<typename T , typename T1 >
T *	fbxsdk::FbxNew (T1 &p1)

template<typename T , typename T1 >
T *	fbxsdk::FbxNew (const T1 &p1)

template<typename T , typename T1 , typename T2 >
T *	fbxsdk::FbxNew (T1 &p1, T2 &p2)

template<typename T , typename T1 , typename T2 >
T *	fbxsdk::FbxNew (T1 &p1, const T2 &p2)

template<typename T , typename T1 , typename T2 >
T *	fbxsdk::FbxNew (const T1 &p1, T2 &p2)

template<typename T , typename T1 , typename T2 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2)

template<typename T , typename T1 , typename T2 , typename T3 >
T *	fbxsdk::FbxNew (T1 &p1, T2 &p2, T3 &p3)

template<typename T , typename T1 , typename T2 , typename T3 >
T *	fbxsdk::FbxNew (T1 &p1, T2 &p2, const T3 &p3)

template<typename T , typename T1 , typename T2 , typename T3 >
T *	fbxsdk::FbxNew (T1 &p1, const T2 &p2, T3 &p3)

template<typename T , typename T1 , typename T2 , typename T3 >
T *	fbxsdk::FbxNew (T1 &p1, const T2 &p2, const T3 &p3)

template<typename T , typename T1 , typename T2 , typename T3 >
T *	fbxsdk::FbxNew (const T1 &p1, T2 &p2, T3 &p3)

template<typename T , typename T1 , typename T2 , typename T3 >
T *	fbxsdk::FbxNew (const T1 &p1, T2 &p2, const T3 &p3)

template<typename T , typename T1 , typename T2 , typename T3 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, T3 &p3)

template<typename T , typename T1 , typename T2 , typename T3 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (T1 &p1, T2 &p2, T3 &p3, T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (T1 &p1, T2 &p2, T3 &p3, const T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (T1 &p1, T2 &p2, const T3 &p3, T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (T1 &p1, T2 &p2, const T3 &p3, const T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (T1 &p1, const T2 &p2, T3 &p3, T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (T1 &p1, const T2 &p2, T3 &p3, const T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (T1 &p1, const T2 &p2, const T3 &p3, T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (const T1 &p1, T2 &p2, T3 &p3, T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (const T1 &p1, T2 &p2, T3 &p3, const T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (const T1 &p1, T2 &p2, const T3 &p3, T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (const T1 &p1, T2 &p2, const T3 &p3, const T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, T3 &p3, T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, T3 &p3, const T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (const T1 &p1, T2 &p2, T3 &p3, T4 &p4, T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, T3 &p3, T4 &p4, T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (const T1 &p1, T2 &p2, const T3 &p3, T4 &p4, T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (const T1 &p1, T2 &p2, T3 &p3, const T4 &p4, T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (const T1 &p1, T2 &p2, T3 &p3, T4 &p4, const T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, T4 &p4, T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, T3 &p3, const T4 &p4, T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, T3 &p3, T4 &p4, const T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, T4 &p4, const T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8)

template<typename T , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
T *	fbxsdk::FbxNew (const T1 &p1, const T2 &p2, const T3 &p3, const T4 &p4, const T5 &p5, const T6 &p6, const T7 &p7, const T8 &p8, const T9 &p9)

template<typename T >
void	fbxsdk::FbxDelete (T *p)

template<typename T >
void	fbxsdk::FbxDelete (const T *p)

template<typename T >
T *	fbxsdk::FbxNewArray (const int n)

template<typename T >
void	fbxsdk::FbxDeleteArray (T *p)

Detailed Description

Definition at line 433 of file fbxpropertypage.h.

Member Enumeration Documentation

enum EValueIndex

Enumerator
eValueMin
eValueSoftMin
eValueMax
eValueSoftMax
eValueCount

Definition at line 1103 of file fbxpropertypage.h.

1103 { eValueMin,eValueSoftMin,eValueMax,eValueSoftMax,eValueCount };

FbxPropertyPage::eValueSoftMax

Definition: fbxpropertypage.h:1103

FbxPropertyPage::eValueMax

Definition: fbxpropertypage.h:1103

FbxPropertyPage::eValueCount

Definition: fbxpropertypage.h:1103

FbxPropertyPage::eValueMin

Definition: fbxpropertypage.h:1103

FbxPropertyPage::eValueSoftMin

Definition: fbxpropertypage.h:1103

Constructor & Destructor Documentation

FbxPropertyPage ( FbxPropertyPage * pInstanceOf = 0 )

inlineprotected

Definition at line 1468 of file fbxpropertypage.h.

         : mInstanceOf(0)
         , mDataPtr(0)
         , mPropNextId(0)
     {
         mEntryMap.Reserve(32);
         mNameMap.mFirst = 0;
 
         // instances don't need to create a root property
         if( !pInstanceOf )
         {
             mPropNextId = FbxNew< FbxPropertyIdGenerator >();
             mPropNextId->IncRef();
 
             // First item is the root information
             Add(FBXSDK_PROPERTY_ID_NULL,"",eFbxUndefined);
         }
 
         // Hook the instances
         // ------------------------
         mInstanceOf = pInstanceOf;
         if (mInstanceOf) {
             mInstanceOf->mInstances.Insert(this);
 
             mPropNextId = mInstanceOf->mPropNextId;
             mPropNextId->IncRef();
         }
     }

FbxPropertyPage	(	const char *	pName,
		EFbxType	pType
	)

inlineprotected

Definition at line 1496 of file fbxpropertypage.h.

         : mInstanceOf(0)
         , mDataPtr(0)
         , mPropNextId(0)
     {
         mEntryMap.Reserve(32);
         mNameMap.mFirst = 0;
 
         mPropNextId = FbxNew< FbxPropertyIdGenerator >();
         mPropNextId->IncRef();
 
         // First item is the root information
         Add(FBXSDK_PROPERTY_ID_NULL,pName,pType);
     }

FbxPropertyPage	(	const char *	pName,
		FbxPropertyPage *	pTypeInfo
	)

inlineprotected

Definition at line 1510 of file fbxpropertypage.h.

         : mInstanceOf(0)
         , mDataPtr(0)
         , mPropNextId(0)
     {
         mEntryMap.Reserve(32);
         mNameMap.mFirst = 0;
 
         mPropNextId = FbxNew< FbxPropertyIdGenerator >();
         mPropNextId->IncRef();
 
         // First item is the root information
         Add(FBXSDK_PROPERTY_ID_NULL,pName,pTypeInfo);
     }

~FbxPropertyPage ( )

inlineprotected

Definition at line 1524 of file fbxpropertypage.h.

     {
         // Propagate our property entries.
         for (FbxSet<FbxPropertyPage*>::Iterator iter = mInstances.Begin(); iter != mInstances.End(); ++iter)
         {
             FbxPropertyPage* lPage = iter->GetValue();
             for (int j = 0; j < GetPropertyEntryCount(); ++j)
             {
                 if (lPage->ChangePropertyEntryState((FbxInt)j, FbxPropertyFlags::eOverride))
                 {
                     // Clone the info and values. Don't clone the connections,
                     // since they aren't propagated.
                     lPage->ChangePropertyItemState(FBX_TYPE(FbxPropertyInfo), (FbxInt)j, FbxPropertyFlags::eOverride);
                     lPage->ChangePropertyItemState(FBX_TYPE(FbxPropertyValue), (FbxInt)j, FbxPropertyFlags::eOverride);
 
                     // Since all entries have their own flags, just override the ones in the instance.
                     lPage->SetFlagsInheritType(FbxPropertyFlags::eOverride, FbxPropertyFlags::eAllFlags, (FbxInt)j);
                 }
             }
 
             // Instances become their own copies.
             lPage->mInstanceOf = NULL;
         }
 
         FbxMapDestroy(mEntryMap);
         
         if (mInstanceOf)
         {
             mInstanceOf->mInstances.Remove(this);
         }
 
         mPropNextId->DecRef();
         mPropNextId = NULL;
 
         mInstanceOf = NULL;
         mInstances.Clear();
     }

Member Function Documentation

static FbxPropertyPage* Create ( FbxPropertyPage * pInstanceOf = 0 )

inlinestatic

Definition at line 438 of file fbxpropertypage.h.

438 { return FbxNew< FbxPropertyPage >(pInstanceOf); }

static FbxPropertyPage* Create	(	const char *	pName,
		FbxPropertyPage *	pTypeInfo
	)

inlinestatic

Definition at line 439 of file fbxpropertypage.h.

439 { return FbxNew< FbxPropertyPage >(pName,pTypeInfo); }

static FbxPropertyPage* Create	(	const char *	pName,
		EFbxType	pType = `eFbxUndefined`
	)

inlinestatic

Definition at line 440 of file fbxpropertypage.h.

440 { return FbxNew< FbxPropertyPage >(pName,pType); }

void Destroy ( )

inline

Definition at line 441 of file fbxpropertypage.h.

441 { FbxDelete(this); }

FbxDelete

void FbxDelete(T *p)

Deletion policy for pointer template classes that uses the FbxDelete() function.

Definition: fbxnew.h:341

T* GetPropertyItem	(	const T *	pItemType,
		FbxInt	pIndex,
		FbxPropertyPage **	pFoundIn = `0`
	)		const

inline

Definition at line 443 of file fbxpropertypage.h.

     {
       FbxPropertyPage*     lReferencePage = 0;
       FbxPropertyEntry*    lReferenceEntry = GetPropertyEntry(pIndex,&lReferencePage);
         if (pFoundIn) *pFoundIn = 0;
         if (lReferenceEntry) {
           T* lItem = lReferenceEntry->Get( FBX_TYPE(T) );
             if (lItem) {
                 if (pFoundIn) *pFoundIn = lReferencePage;
                 return lItem;
             } else {
                 return lReferencePage->mInstanceOf ? lReferencePage->mInstanceOf->GetPropertyItem(pItemType,pIndex,pFoundIn) : 0 ;
             }
         }
         return 0;
     }

T* ChangePropertyItemState	(	const T *	pItemType,
		FbxInt	pIndex,
		FbxPropertyFlags::EInheritType	pInheritType
	)

inline

Definition at line 460 of file fbxpropertypage.h.

     {
         FbxPropertyPage*    lReferencePage = NULL;
         T*                  lItem = GetPropertyItem(pItemType, pIndex, &lReferencePage);
         if( pInheritType == FbxPropertyFlags::eOverride )
         {
             if( lReferencePage == this )
             {
                 return lItem;
             }
             else if( lItem )
             {
                 FbxPropertyEntry* lEntry = ChangePropertyEntryState(pIndex, FbxPropertyFlags::eOverride);
                 lEntry->Set(lItem->Clone(this));
                 return lEntry->Get(FBX_TYPE(T));
             }
         }
         else
         {
             // can't inherit entries that were created on our page.
             bool lOwnEntry = !mInstanceOf || (mInstanceOf->GetPropertyItem(pItemType, pIndex) == NULL);
             if( lOwnEntry && FbxPropertyFlags::eInherit == pInheritType) return 0;
 
             if( lItem && (lReferencePage == this) )
             {
                 FbxPropertyEntry* lEntry = GetPropertyEntry(pIndex);
                 lEntry->Set((T*)0);
                 if( lEntry->IsEmpty() )
                 {
                     ChangePropertyEntryState(pIndex, FbxPropertyFlags::eInherit);
                 }
             }
             return 0;
         }
         return 0;
     }

FbxPropertyPage* GetFirstPropertyItem	(	FbxInt	pId,
		const T *	pItem
	)		const

inline

Definition at line 497 of file fbxpropertypage.h.

     {
         FbxPropertyPage* lReferencePage = NULL;
         GetPropertyItem(FBX_TYPE(T), pId, &lReferencePage);
         if( lReferencePage && lReferencePage->mInstanceOf )
         {
             FbxPropertyPage* lReferencePage2 = lReferencePage->mInstanceOf->GetFirstPropertyItem(pId, pItem);
             return lReferencePage2 ? lReferencePage2 : lReferencePage;
         }
         return lReferencePage;
     }

const char* GetName ( FbxInt pId = 0 )

inline

Definition at line 509 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? ((const char*)lPropertyInfo->GetName()) : "";
     }

const char* GetLabel ( FbxInt pId = 0 )

inline

Definition at line 515 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? ((const char*)lPropertyInfo->GetLabel()) : "";
     }

bool SetLabel	(	FbxInt	pId = `0`,
		const char *	pLabel = `""`
	)

inline

Definition at line 521 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         if (lPropertyInfo) {
             lPropertyInfo->SetLabel(pLabel);
             return true;
         } else {
             return false;
         }
     }

void* GetUserData ( FbxInt pId = 0 )

inline

Definition at line 533 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? lPropertyInfo->GetUserData() : 0;
     }

bool SetUserData	(	FbxInt	pId = `0`,
		const void *	pUserData = `0`
	)

inline

Definition at line 539 of file fbxpropertypage.h.

     {
       FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
           // Don't make it writeable (Keep it shared)
           if (lPropertyInfo) {
               lPropertyInfo->SetUserData(pUserData);
               return true;
           } else {
               return false;
           }
     }

int GetUserTag ( FbxInt pId = 0 )

inline

Definition at line 551 of file fbxpropertypage.h.

     {
       FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? lPropertyInfo->GetUserTag() : 0;
     }

bool SetUserTag	(	FbxInt	pId = `0`,
		int	pUserTag = `0`
	)

inline

Definition at line 557 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
           // Don't make it writeable (Keep it shared)
         if (lPropertyInfo) {
             lPropertyInfo->SetUserTag(pUserTag);
             return true;
         } else {
             return false;
         }
     }

EFbxType GetType ( FbxInt pId = 0 ) const

inline

Definition at line 569 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? lPropertyInfo->GetType() : eFbxUndefined;
     }

FbxInt GetParent ( FbxInt pId = 0 ) const

inline

Definition at line 575 of file fbxpropertypage.h.

     {
         FbxPropertyEntry* lPropertyEntry = GetPropertyEntry( pId );
         return lPropertyEntry ? lPropertyEntry->GetParentId() : FBXSDK_PROPERTY_ID_NULL;
     }

FbxPropertyPage* GetTypeInfo ( FbxInt pId = 0 )

inline

Definition at line 581 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? lPropertyInfo->GetTypeInfo() : 0;
     }

FbxInt Add	(	FbxInt	pParentId,
		const char *	pName,
		EFbxType	pType
	)

inline

Definition at line 586 of file fbxpropertypage.h.

     {
         return Add(pParentId,FbxPropertyInfo::Create(pName,pType),FbxPropertyValue::Create(0,pType),0);
     }

FbxInt Add	(	FbxInt	pParentId,
		const char *	pName,
		FbxPropertyPage *	pTypeInfo
	)

inline

Definition at line 590 of file fbxpropertypage.h.

     {
         return Add(pParentId,FbxPropertyInfo::Create(pName,pTypeInfo),FbxPropertyValue::Create(0,pTypeInfo->GetType()),0);
     }

bool Reparent	(	FbxInt	,
		FbxInt
	)

inline

Definition at line 595 of file fbxpropertypage.h.

     {
         // Not implemented.
         /*
         if( GetParent(pChildId) != pNewParentId  && pChildId < mEntries.GetCount() )
         {
             FbxPropertyEntry* lChildEntry = mEntries[pChildId];
             lChildEntry->mParentId = pNewParentId;
 
             //@@@@@ TODO: propagate to instances
 
             return true;
         }
         */
         return false;
     }

bool IsChildOf	(	FbxInt	pId,
		FbxInt	pParentId
	)		const

inline

Definition at line 612 of file fbxpropertypage.h.

     {
         return GetParent(pId)==pParentId;
 
     }

bool IsDescendentOf	(	FbxInt	pId,
		FbxInt	pAncestorId
	)		const

inline

Definition at line 618 of file fbxpropertypage.h.

     {
         if (pAncestorId>0) {
             FbxInt lParentId = GetParent(pId);
             while (lParentId != FBXSDK_PROPERTY_ID_NULL ) {
                 if (lParentId==pAncestorId) {
                     return true;
                 }
                 lParentId = GetParent(lParentId);
             }
             return false;
         } else {
             return true;
         }
 
     }

FbxInt GetChild ( FbxInt pParentId = 0 ) const

inline

Retrieves the first child property id of a specified property id.

Parameters

pParentId The specified property id

Returns: the first child property id

Definition at line 641 of file fbxpropertypage.h.

     {
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
             if (pParentId!=FBXSDK_PROPERTY_ID_NULL) {
             FbxInt       lId        = GetMinimumPropertyId(pParentId);
             FbxInt       lParentId  = GetParent(lId);
             const FbxInt lLastId    = GetPropertyEntryCount();
 
             while (lId<lLastId && lParentId!=pParentId) lParentId=GetParent(++lId);
             ret0 = lId<lLastId ? lId : FBXSDK_PROPERTY_ID_NULL;
         } else {
             ret0 = FBXSDK_PROPERTY_ID_NULL;
         }
     #endif
         FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
         if (pParentId != FBXSDK_PROPERTY_ID_NULL)
         {
             FbxPropertyEntry* lEntry;
             FbxInt lId = pParentId;
             do 
             {
                 lId = GetMinimumPropertyIdAndEntry(lId, &lEntry);
             } while (lId != FBXSDK_PROPERTY_ID_NULL && lEntry->GetParentId() != pParentId);
             ret1 = lId;
         }
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FBX_ASSERT(ret0==ret1);
     #endif
         return ret1;
     }

FbxInt GetSibling ( FbxInt pId ) const

inline

Retrieves the next sibling property id of a specified property id.

Parameters

pId	The specified property id

Returns: the next sibling property id

Definition at line 677 of file fbxpropertypage.h.

     {
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FbxInt pIdBackup = pId;
         FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
         if (pId!=FBXSDK_PROPERTY_ID_NULL) {
             FbxInt       lReferenceParentId = GetParent(pId);
             FbxInt       lParentId          = GetParent(++pId);
             const FbxInt lLastId            = GetPropertyEntryCount();
 
             while (pId<lLastId && lReferenceParentId!=FBXSDK_PROPERTY_ID_NULL && lParentId!=lReferenceParentId)
                 lParentId=GetParent(++pId);
             ret0 = pId<lLastId ? pId : FBXSDK_PROPERTY_ID_NULL;
         } else {
             ret0 = FBXSDK_PROPERTY_ID_NULL;
         }
         pId = pIdBackup;
     #endif
         FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
         if (pId != FBXSDK_PROPERTY_ID_NULL)
         {
             FbxInt lReferenceParentId = GetParent(pId);
 
             if (lReferenceParentId != FBXSDK_PROPERTY_ID_NULL)
             {
                 FbxPropertyEntry *lEntry;
                 do 
                 {
                     pId = GetMinimumPropertyIdAndEntry(pId, &lEntry);
                 } while (pId != FBXSDK_PROPERTY_ID_NULL && lEntry->GetParentId() != lReferenceParentId);
 
                 ret1 = pId;
             }
         }
 
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FBX_ASSERT(ret0==ret1);
     #endif
         return ret1;
     }

FbxInt GetFirstDescendent ( FbxInt pAnscestorId = 0 ) const

inline

Retrieves the first descendent property id of a specified property id.

Parameters

pAnscestorId The specified property id

Returns: the first descendent property id

Definition at line 722 of file fbxpropertypage.h.

     {
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
         if (pAnscestorId!=FBXSDK_PROPERTY_ID_NULL) {
             FbxInt       lId        = GetMinimumPropertyId(pAnscestorId);
             FbxInt       lParentId  = GetParent(lId);
             const FbxInt lLastId    = GetPropertyEntryCount();
 
             while (lId<lLastId) {
                 if( lParentId!=FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(lId,pAnscestorId) )
                 {
                     ret0 = lId;
                     break;
                 }
                 lParentId = GetParent(++lId);
             }
         }
     #endif
         FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
         FbxInt lId = pAnscestorId;
         FbxPropertyEntry* lEntry;
         if (pAnscestorId != FBXSDK_PROPERTY_ID_NULL)
         {
             for(;;)
             {
                 lId  = GetMinimumPropertyIdAndEntry(lId, &lEntry);
                 if (lId == FBXSDK_PROPERTY_ID_NULL)
                     break;
                 if(lEntry->GetParentId() != FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(lId, pAnscestorId))
                 {
                     ret1 = lId;
                     break;
                 }
             }
         }
 
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FBX_ASSERT(ret0==ret1);
     #endif
         return ret1;
     }

FbxInt GetNextDescendent	(	FbxInt	pAnscestorId,
		FbxInt	pId
	)		const

inline

Retrieves the next descendent property id of a specified property id, with given a descendent property id.

Parameters

pAnscestorId	The specified property id
pId	The descendent property id

Returns: the next descendent property id

Definition at line 770 of file fbxpropertypage.h.

     {
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FbxInt pIdBackup = pId;
         FbxInt ret0 = FBXSDK_PROPERTY_ID_NULL;
         if (pId!=FBXSDK_PROPERTY_ID_NULL) {
             FbxInt       lParentId  = GetParent(++pId);
             const FbxInt lLastId    = GetPropertyEntryCount();
 
             while (pId<lLastId) {
                 // GetParent returns null when the given id isn't in our page,
                 // or our ancestor's page.
                 if( lParentId != FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(pId, pAnscestorId) )
                 {
                     ret0 = pId;
                     break;
                 }
 
                 lParentId = GetParent(++pId);
             }
         }
         
         pId = pIdBackup;
     #endif
         FbxInt ret1 = FBXSDK_PROPERTY_ID_NULL;
         if (pId != FBXSDK_PROPERTY_ID_NULL)
         {
             FbxPropertyEntry* lEntry;
             for(;;)
             {
                 pId = GetMinimumPropertyIdAndEntry(pId, &lEntry);
                 if (pId == FBXSDK_PROPERTY_ID_NULL)
                     break;
                 if(lEntry->GetParentId() != FBXSDK_PROPERTY_ID_NULL && IsDescendentOf(pId, pAnscestorId) )
                 {
                     ret1 = pId;
                     break;
                 }
             }
 
         }
     #ifdef PROPERTY_PAGE_SANITY_CHECK
         FBX_ASSERT(ret0==ret1);
     #endif
         return ret1;
 
     }

FbxInt FastFind	(	FbxInt	pId,
		const char *	pName,
		FbxPropertyPage *	pTypeInfo,
		bool	pCaseSensitive
	)

inline

Definition at line 818 of file fbxpropertypage.h.

     {
         FbxInt lId = FBXSDK_PROPERTY_ID_NULL;
 
         bool lSlowQuery = true;
         if( mNameMap.mSecond.GetSize() > 0 )
         {
             lSlowQuery = false;
             // try to use the map if we've got it
             NameMap::RecordType* lIterator = mNameMap.mSecond.Find( FbxNameMapKey( pId, pName ) );
             if( !lIterator )
             {
                 lId = FBXSDK_PROPERTY_ID_NULL;
             }
             else
             {
                 lId = lIterator->GetValue();
                 if (lId != FBXSDK_PROPERTY_ID_NULL && pTypeInfo)
                 {
                     lSlowQuery = true;
 
                     // Try to match types.
                     // If they are mismatched, fall back to the slow query,
                     // since we might have multiple property with the same name but different types
                     FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo), lId );
                     if (lPropertyInfo)
                     {
                         FbxPropertyPage* lTypeInfo2 = lPropertyInfo->GetTypeInfo();
                         if ( lTypeInfo2 && lTypeInfo2->Is(pTypeInfo) )
                         {
                             lSlowQuery = false;
                         }
                     }
                 }
             }
         }
 
         if (!lSlowQuery)
             return lId;
 
         // fall back if there's no map or we got one with a different type
 
         lId = GetChild(pId);
         FbxStringSymbol lSearchSymbol( pName );
         while( lId != FBXSDK_PROPERTY_ID_NULL ) {
             FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo), lId );
             if  ( (!pTypeInfo || lPropertyInfo->GetTypeInfo()->Is(pTypeInfo)) &&
                 ((!pCaseSensitive && FBXSDK_stricmp(lPropertyInfo->GetName(),pName)==0) ||
                 (pCaseSensitive && lPropertyInfo->GetName() == lSearchSymbol)) ) {
                 return lId;
             }
             lId = GetSibling(lId);
         }
 
         return FBXSDK_PROPERTY_ID_NULL;
     }

FbxInt Find	(	FbxInt	pId,
		const char *	pName,
		FbxPropertyPage *	pTypeInfo,
		bool	pCaseSensitive,
		const char *	pChildrenSeparators
	)

inline

Definition at line 875 of file fbxpropertypage.h.

     {
         if (pChildrenSeparators) 
         {
             FbxInt  lId;
             size_t  lFoundIndex = strcspn(pName,pChildrenSeparators);
 
             // Strip the first part of the name and search
             if (lFoundIndex<strlen(pName)) 
             {
                 FbxString   pRootName;
                 pRootName.Append(pName,lFoundIndex);
                 lId = FastFind(pId,pRootName.Buffer(),NULL,pCaseSensitive);
                 return lId != FBXSDK_PROPERTY_ID_NULL ? Find(lId,pName+lFoundIndex+1,pTypeInfo,pCaseSensitive,pChildrenSeparators) : lId;
             } else {
                 return FastFind(pId,pName,pTypeInfo,pCaseSensitive);
             }
         } else {
             return FastFind(pId,pName,pTypeInfo,pCaseSensitive);
         }
     }

int AddEnumValue	(	FbxInt	pId,
		const char *	pStringValue
	)

inline

Definition at line 898 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         return lPropertyInfo ? lPropertyInfo->AddEnumValue(pStringValue) : - 1;
     }

void InsertEnumValue	(	FbxInt	pId,
		int	pIndex,
		const char *	pStringValue
	)

inline

Definition at line 905 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         if (lPropertyInfo) lPropertyInfo->InsertEnumValue(pIndex,pStringValue);
     }

int GetEnumCount ( FbxInt pId )

inline

Definition at line 912 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         return lPropertyInfo ? lPropertyInfo->GetEnumCount() : 0;
     }

void SetEnumValue	(	FbxInt	pId,
		int	pIndex,
		const char *	pStringValue
	)

inline

Definition at line 919 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         if (lPropertyInfo) lPropertyInfo->SetEnumValue(pIndex,pStringValue);
     }

void RemoveEnumValue	(	FbxInt	pId,
		int	pIndex
	)

inline

Definition at line 926 of file fbxpropertypage.h.

     {
          FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         if (lPropertyInfo) lPropertyInfo->RemoveEnumValue(pIndex);
     }

char* GetEnumValue	(	FbxInt	pId,
		int	pIndex
	)

inline

Definition at line 933 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         return lPropertyInfo ? lPropertyInfo->GetEnumValue(pIndex) : (char*)"";
     }

void ClearConnectCache ( FbxInt pId )

inline

Definition at line 941 of file fbxpropertypage.h.

     {
         FbxPropertyPage*     lReferencePage = 0;
         FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         // Connections are not considered propagated so
         // make sure that we own the FbxPropertyConnect objects
         if (lPropertyConnect) {
             lPropertyConnect->ClearConnectCache();
         }
     }

void WipeAllConnections ( FbxInt pId )

inline

Definition at line 953 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lReferencePage = 0;
         FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         if (lPropertyConnect) {
             lPropertyConnect->WipeAllConnections();
         }
     }

bool ConnectSrc	(	FbxInt	pDstId,
		FbxPropertyPage *	pSrcPage,
		FbxInt	pSrcId,
		FbxConnection::EType	pType
	)

inline

Definition at line 963 of file fbxpropertypage.h.

     {
         FbxPropertyEntry*    lDstEntry = ChangePropertyEntryState(pDstId,FbxPropertyFlags::eOverride);
         FbxPropertyEntry*    lSrcEntry = pSrcPage->ChangePropertyEntryState(pSrcId,FbxPropertyFlags::eOverride);
 
         // Make sure we have a connection point on both sides of the connection.
         //
         // In the case lDstEntry == lSrcEntry, we don't want to create different
         // connection points (FbxPropertyConnect) since the call to lSrcEntry->Set(...) 
         // would delete the lDstConnect and we can't test for the validity of lDstConnect
         // because the pointer is != nullptr but its content have already been destroyed.
         // 
         // Having lDstEntry == lSrcEntry is not a valid operation anyway and is "trapped" 
         // by the call lDstConnect->ConnectSrc(lSrcConnect, pType); so we just need to
         // make sure we can call it!
 
         FbxPropertyConnect*  lDstConnect= lDstEntry->Get( FBX_TYPE(FbxPropertyConnect) );
         if (!lDstConnect) {
             lDstConnect = FbxPropertyConnect::Create( this,pDstId );
             lDstEntry->Set( lDstConnect );
         }
 
         FbxPropertyConnect* lSrcConnect = lSrcEntry->Get(FBX_TYPE(FbxPropertyConnect));
         if (!lSrcConnect) {
             lSrcConnect = FbxPropertyConnect::Create( pSrcPage,pSrcId );
             lSrcEntry->Set( lSrcConnect );
         }
 
         // Must @@@@@@@ Propagate to inherited children
         return (lDstConnect) ? lDstConnect->ConnectSrc(lSrcConnect, pType) : false;
 
     }

bool DisconnectSrc	(	FbxInt	pDstId,
		FbxPropertyPage *	pSrcPage,
		FbxInt	pSrcId
	)

inline

Definition at line 996 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lDstReferencePage   = 0;
         FbxPropertyConnect* lDstConnect         = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pDstId,&lDstReferencePage );
         FbxPropertyPage*        lSrcReferencePage   = 0;
         FbxPropertyConnect* lSrcConnect         = pSrcPage->GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pSrcId,&lSrcReferencePage );
 
         // Make sure we have a connection point on both sides of the connection
         if (lDstConnect && lSrcConnect && lDstReferencePage==this && lSrcReferencePage==pSrcPage) {
             // Must @@@@@@@ Remove unused connections
             return lDstConnect->DisconnectSrc(lSrcConnect);
         }
         return false;
     }

bool IsConnectedSrc	(	FbxInt	pDstId,
		FbxPropertyPage *	pSrcPage,
		FbxInt	pSrcId
	)

inline

Definition at line 1011 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lDstReferencePage   = 0;
         FbxPropertyConnect* lDstConnect         = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pDstId,&lDstReferencePage );
         FbxPropertyPage*        lSrcReferencePage   = 0;
         FbxPropertyConnect* lSrcConnect         = pSrcPage->GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pSrcId,&lSrcReferencePage );
 
         // Make sure we have a connection point on both sides of the connection
         if (lDstConnect && lSrcConnect && lDstReferencePage==this && lSrcReferencePage==pSrcPage) {
             // Must @@@@@@@ Remove unused connections
             return lDstConnect->IsConnectedSrc(lSrcConnect);
         }
         return false;
     }

int GetSrcCount	(	FbxInt	pId,
		FbxConnectionPointFilter *	pFilter
	)

inline

Definition at line 1026 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lReferencePage      = 0;
         FbxPropertyConnect* lPropertyConnect    = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         // Connections are not considered propagated so
         // make sure that we own the FbxPropertyConnect objects
         return (lPropertyConnect && lReferencePage==this) ? lPropertyConnect->GetSrcCount(pFilter) : 0;
     }

bool GetSrc	(	FbxInt	pId,
		int	pIndex,
		FbxConnectionPointFilter *	pFilter,
		FbxPropertyPage **	pSrcPage,
		FbxInt *	pSrcId
	)

inline

Definition at line 1036 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lReferencePage      = 0;
         FbxPropertyConnect* lPropertyConnect    = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         // Connections are always overridden
         // make sure that we own the FbxPropertyConnect Item
         if (lPropertyConnect && lReferencePage==this) 
         {
             FbxPropertyConnect* lSrc = lPropertyConnect->GetSrc(pFilter,pIndex);
             if (lSrc) 
             {
                 if (pSrcPage)   *pSrcPage = lSrc->GetPage();
                 if (pSrcId)     *pSrcId   = lSrc->GetPropertyId();
                 return true;
             }
         }
         return false;
     }

bool ConnectDst	(	FbxInt	pSrcId,
		FbxPropertyPage *	pDstPage,
		FbxInt	pDstId,
		FbxConnection::EType	pType
	)

inline

Definition at line 1056 of file fbxpropertypage.h.

     {
         return pDstPage->ConnectSrc(pDstId,this,pSrcId,pType);
     }

bool DisconnectDst	(	FbxInt	pSrcId,
		FbxPropertyPage *	pDstPage,
		FbxInt	pDstId
	)

inline

Definition at line 1061 of file fbxpropertypage.h.

     {
         return pDstPage->DisconnectSrc(pDstId,this,pSrcId);
     }

bool IsConnectedDst	(	FbxInt	pSrcId,
		FbxPropertyPage *	pDstPage,
		FbxInt	pDstId
	)

inline

Definition at line 1066 of file fbxpropertypage.h.

     {
         return pDstPage->IsConnectedSrc(pDstId,this,pSrcId);
     }

int GetDstCount	(	FbxInt	pId,
		FbxConnectionPointFilter *	pFilter
	)

inline

Definition at line 1071 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lReferencePage   = 0;
         FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         // Connections are not considered propagated so
         // make sure that we own the FbxPropertyConnect objects
         return (lPropertyConnect && lReferencePage==this) ? lPropertyConnect->GetDstCount(pFilter) : 0;
     }

bool GetDst	(	FbxInt	pId,
		int	pIndex,
		FbxConnectionPointFilter *	pFilter,
		FbxPropertyPage **	pDstPage,
		FbxInt *	pDstId
	)

inline

Definition at line 1081 of file fbxpropertypage.h.

     {
         FbxPropertyPage*        lReferencePage   = 0;
         FbxPropertyConnect* lPropertyConnect = GetPropertyItem( FBX_TYPE(FbxPropertyConnect),pId,&lReferencePage );
 
         // Connections are always overridden
         // make sure that we own the FbxPropertyConnect Item
         if (lPropertyConnect && lReferencePage==this)
         {
             FbxPropertyConnect* lDst = lPropertyConnect->GetDst(pFilter,pIndex);
             if (lDst) 
             {
                 if (pDstPage)   *pDstPage = lDst->GetPage();
                 if (pDstId)     *pDstId   = lDst->GetPropertyId();
                 return true;
             }
         }
         return false;
     }

bool HasMinMax	(	FbxInt	pId,
		FbxPropertyInfo::EValueIndex	pValueId
	)		const

inline

Definition at line 1105 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
     
         return lPropertyInfo ? lPropertyInfo->HasMinMax(pValueId) : false;
     }

bool GetMinMax	(	FbxInt	pId,
		FbxPropertyInfo::EValueIndex	pValueId,
		void *	pValue,
		EFbxType	pValueType
	)

inline

Definition at line 1112 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         return lPropertyInfo ? lPropertyInfo->GetMinMax(pValueId,pValue,pValueType) : false;
     }

bool SetMinMax	(	FbxInt	pId,
		FbxPropertyInfo::EValueIndex	pValueId,
		const void *	pValue,
		EFbxType	pValueType
	)

inline

Definition at line 1119 of file fbxpropertypage.h.

     {
         FbxPropertyInfo* lPropertyInfo = GetPropertyItem( FBX_TYPE(FbxPropertyInfo),pId );
         // Don't make it writeable (Keep it shared)
         return lPropertyInfo ? lPropertyInfo->SetMinMax(pValueId,pValue,pValueType) : false;
     }

bool Get	(	FbxInt	pId,
		void *	pValue,
		EFbxType	pValueType
	)

inline

Definition at line 1128 of file fbxpropertypage.h.

     {
         FbxPropertyValue* lPropertyValue = GetPropertyItem( FBX_TYPE(FbxPropertyValue),pId );
         return lPropertyValue ? lPropertyValue->Get(pValue,pValueType) : 0;
     }

bool Set	(	FbxInt	pId,
		const void *	pValue,
		EFbxType	pValueType,
		bool	pCheckValueEquality
	)

inline

Definition at line 1134 of file fbxpropertypage.h.

     {
         if( pCheckValueEquality )
         {
             FbxPropertyPage*   lReferencePage  = NULL;
             FbxPropertyValue*  lPropertyValue  = GetPropertyItem( FBX_TYPE(FbxPropertyValue),pId,&lReferencePage );
             union {
                 void* lCurrentValue;
                 char buffer[sizeof(FbxDouble4x4)];
             };
             FBX_ASSERT(sizeof(buffer) >= FbxTypeSizeOf(pValueType));
             bool lValuesEqual = false;
             bool lValueChanged = false;
             if( lReferencePage && lReferencePage != this )
             {
                 // this page inherits, so check if we have to override the value.
                 if( lPropertyValue )
                 {
                     FbxTypeAllocate(pValueType, lCurrentValue, sizeof(buffer));
                     lPropertyValue->Get( &lCurrentValue, pValueType );
                     lValuesEqual = FbxTypeCompare( pValue, &lCurrentValue, pValueType );
                     FbxTypeDeallocate(pValueType, lCurrentValue, sizeof(buffer));
                 }
             }
             else
             {
                 FbxPropertyPage* lReferencePage2 = NULL;
                 FbxPropertyValue*  lPropertyValue2 = mInstanceOf ? mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyValue),pId,&lReferencePage2 ) : NULL;
                 if( lReferencePage2 && lPropertyValue2 )
                 {
                     FbxTypeAllocate(pValueType, lCurrentValue, sizeof(buffer));
                     // this page is an override, but there is another page before us that overrides the value
                     lPropertyValue2->Get( &lCurrentValue, pValueType );
                     lValuesEqual = FbxTypeCompare( pValue, &lCurrentValue, pValueType );
                     FbxTypeDeallocate(pValueType, lCurrentValue, sizeof(buffer));
 
                     if( lValuesEqual )
                     {
                         ChangePropertyItemState( FBX_TYPE(FbxPropertyValue), pId, FbxPropertyFlags::eInherit );
                         lValueChanged = true;
                     }
 
                 }
                 // else this page is the originator of the property, so no need to check,
             }
 
             if( lValuesEqual )
                 return lValueChanged;
         }
 
         FbxPropertyValue* lPropertyValue = ChangePropertyItemState( FBX_TYPE(FbxPropertyValue),pId,FbxPropertyFlags::eOverride );
         return lPropertyValue ? lPropertyValue->Set(pValue,pValueType) : false;
     }

FbxPropertyFlags::EInheritType GetValueInherit	(	FbxInt	pId,
		bool	pCheckInstanceOf
	)		const

inline

Definition at line 1188 of file fbxpropertypage.h.

     {
         FbxPropertyPage* lReferencePage = NULL;
         GetPropertyItem(FBX_TYPE(FbxPropertyValue), pId, &lReferencePage);
 
         // check one level
         if( !pCheckInstanceOf )
         {
             return lReferencePage == this ? FbxPropertyFlags::eOverride : FbxPropertyFlags::eInherit;
         }
         else
         {
             if( lReferencePage == this ) return FbxPropertyFlags::eOverride;            // this page is either an override, or the originator
             else if( !lReferencePage->mInstanceOf ) return FbxPropertyFlags::eInherit;  // the reference is the class root, so we must be inheriting
 
             // The reference page is not the class root, might be another override, or the originator.
             FbxPropertyValue* lPropertyValue = lReferencePage->mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyValue), pId );
 
             // if lReferencePage->mInstanceOf has the property value,
             //      lReferencePage is an override
             //  else
             //      its the originator, so this page inherits from it.
             return lPropertyValue ? FbxPropertyFlags::eOverride : FbxPropertyFlags::eInherit;
         }
     }

bool SetValueInherit	(	FbxInt	pId,
		FbxPropertyFlags::EInheritType	pType
	)

inline

Definition at line 1214 of file fbxpropertypage.h.

     {
         // no support for this mode yet
         if( FbxPropertyFlags::eDeleted == pType )
             return false;
 
         ChangePropertyItemState( FBX_TYPE(FbxPropertyValue), pId, pType );
 
         // Above call doesn't return error codes, so just check that we match types.
         return GetValueInherit(pId, false) == pType;
     }

bool GetDefaultValue	(	FbxInt	pId,
		void *	pValue,
		EFbxType	pValueType
	)		const

inline

Definition at line 1226 of file fbxpropertypage.h.

     {
         FbxPropertyPage*    lReferencePage = GetFirstPropertyItem( pId, FBX_TYPE(FbxPropertyValue) );
         FbxPropertyValue*   lPropertyValue = lReferencePage ? lReferencePage->GetPropertyItem( FBX_TYPE(FbxPropertyValue), pId ) : NULL;
 
         return lPropertyValue ? lPropertyValue->Get( pValue, pValueType ) : false;
     }

bool Set	(	FbxInt	pId,
		const T &	pValue
	)

inline

Definition at line 1236 of file fbxpropertypage.h.

1236 { return Set( pId,&pValue,FbxTypeOf(pValue),true ); }

FbxTypeOf

EFbxType FbxTypeOf(const FbxChar &)

Definition: fbxpropertytypes.h:533

FbxPropertyPage::Set

bool Set(FbxInt pId, const void *pValue, EFbxType pValueType, bool pCheckValueEquality)

Definition: fbxpropertypage.h:1134

T Get	(	FbxInt	pId,
		const T *	pFBX_TYPE
	)

inline

Definition at line 1237 of file fbxpropertypage.h.

1237 { T lValue; Get( pId,&lValue,FbxTypeOf(lValue) ); return lValue; }

FbxPropertyPage::Get

bool Get(FbxInt pId, void *pValue, EFbxType pValueType)

Definition: fbxpropertypage.h:1128

FbxTypeOf

EFbxType FbxTypeOf(const FbxChar &)

Definition: fbxpropertytypes.h:533

void SetDataPtr ( void * pDataPtr )

inline

Definition at line 1240 of file fbxpropertypage.h.

1240 { mDataPtr = pDataPtr; }

void* GetDataPtr ( ) const

inline

Definition at line 1241 of file fbxpropertypage.h.

1241 { return mDataPtr; }

void PushPropertiesToParentInstance ( )

inline

Definition at line 1245 of file fbxpropertypage.h.

     {
         if (mInstanceOf) {
             const int lCount = GetPropertyEntryCount();
             // push the existing properties into the parent
             // ----------------------------------------------
             for( int i = 0; i < lCount; ++i )
             {
               FbxPropertyEntry* lParentEntry = mInstanceOf->ChangePropertyEntryState( (FbxInt)i,FbxPropertyFlags::eOverride );
               FbxPropertyEntry* lEntry       = GetPropertyEntry( (FbxInt)i );
 
                 if( !lParentEntry )
                 {
                     lParentEntry = FbxPropertyEntry::Create( lEntry->GetParentId(), 0, 0, 0 );
                     mInstanceOf->mEntryMap.Insert( i, lParentEntry );
 
                     //mInstanceOf->AddChild(i);
 
                 }
 
                 FBX_ASSERT( lParentEntry );
 
                 // Add it to the parent
                 // Don't touch the connections
                 // -----------------------------------------
                 if (lParentEntry) {
                     lParentEntry->Set( lEntry->Get(FBX_TYPE(FbxPropertyInfo))  );
                     lParentEntry->Set( lEntry->Get(FBX_TYPE(FbxPropertyValue)) );
                     lParentEntry->Set( lEntry->Get(FBX_TYPE(FbxPropertyFlags)) );
                 }
 
                 /*
                 else {
                     mInstanceOf->Add(
                         lEntry->GetParentId(),
                         lEntry->Get(FBX_TYPE(FbxPropertyInfo)),        // The info
                         lEntry->Get(FBX_TYPE(FbxPropertyValue)),       // The Value
                         0,                                              // The connections
                         false,
                         false
                     );
                 }
                 */
 
                 // Empty the current entry
                 // Don't touch the connections
                 // -----------------------------------------
                 ChangePropertyItemState(FBX_TYPE(FbxPropertyInfo),  i,FbxPropertyFlags::eInherit);
                 ChangePropertyItemState(FBX_TYPE(FbxPropertyValue), i,FbxPropertyFlags::eInherit);
                 ChangePropertyItemState(FBX_TYPE(FbxPropertyFlags), i,FbxPropertyFlags::eInherit);
             }
         }
     }

const FbxPropertyPage* GetInstanceOf ( ) const

inline

Definition at line 1299 of file fbxpropertypage.h.

1299 { return mInstanceOf; }

FbxPropertyPage* GetInstanceOf ( )

inline

Definition at line 1300 of file fbxpropertypage.h.

1300 { return mInstanceOf; }

const FbxSet<FbxPropertyPage*>& GetInstances ( ) const

inline

Definition at line 1302 of file fbxpropertypage.h.

1302 { return mInstances; }

FbxPropertyFlags::EFlags GetFlags ( FbxInt pId = 0 ) const

inline

Definition at line 1306 of file fbxpropertypage.h.

     {
         FbxPropertyPage* lFoundIn = NULL;
         FbxPropertyFlags*  lPropertyFlags = GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn );
         FbxPropertyFlags::EFlags lFlags = FbxPropertyFlags::eNone;
 
         if( lPropertyFlags )
         {
             if( !mInstanceOf ) // no inheritance.
                 lFlags = lPropertyFlags->GetFlags();
             else
             {
                 lFlags = mInstanceOf->GetFlags(pId);
                 lFlags = lPropertyFlags->GetMergedFlags(lFlags);
             }
         }
         return lFlags;
     }

bool ModifyFlags	(	FbxInt	pId = `0`,
		FbxPropertyFlags::EFlags	pFlags = `FbxPropertyFlags::eNone`,
		bool	pValue = `true`,
		bool	pCheckFlagEquality = `true`
	)

inline

Definition at line 1325 of file fbxpropertypage.h.

     {
         if( pCheckFlagEquality )
         {
             FbxPropertyPage* lFoundIn = NULL;
             FbxPropertyFlags* lFlag = GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn );
 
             if( lFlag )
             {
                 if( lFoundIn == this )
                 {
                     // set them in us.
                     lFlag->ModifyFlags( pFlags, pValue );
 
                      // we override this entry, check if we need to revert
                     FbxPropertyFlags* lInheritedFlags = mInstanceOf ? mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId ) : NULL;
                     if( lInheritedFlags && lInheritedFlags->Equal( *lFlag, pFlags ) )
                     {
                         lFlag->UnsetMask( pFlags );
 
                         if( lFlag->GetMask() == 0 )
                             ChangePropertyItemState( FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eInherit );
 
                         return true;
                     }
                 }
                 else
                 {
                     // its not us. Just check if we need to set.
                     FbxPropertyFlags lNewValues( pFlags );
                     if( lFlag->Equal( lNewValues, pFlags ) )
                         return true;
                 }
             }
         }
 
         FbxPropertyFlags* lPropertyFlags = ChangePropertyItemState(FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eOverride);
         return lPropertyFlags ? lPropertyFlags->ModifyFlags( pFlags, pValue ) : false;
     }

FbxPropertyFlags::EInheritType GetFlagsInheritType	(	FbxPropertyFlags::EFlags	pFlags,
		bool	pCheckInstanceOf,
		FbxInt	pId = `0`
	)		const

inline

Definition at line 1365 of file fbxpropertypage.h.

     {
         FbxPropertyPage* lFoundIn = NULL;
         FbxPropertyFlags*  lPropertyFlags = GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn );
 
         if( !pCheckInstanceOf )
             return lFoundIn != this ? FbxPropertyFlags::eInherit : ( lPropertyFlags ? lPropertyFlags->GetFlagsInheritType(pFlags) : FbxPropertyFlags::eInherit );
         else
         {
             // This code basically counts the number of overrides for the
             // given flags. The original entry is always considered an override.
             // so if we see more than one, something overrode the original.
             // and thus we are an override.
             FbxPropertyPage* lRefPage = lFoundIn;
             bool lFoundOverride = false;
             while( lRefPage )
             {
                 lPropertyFlags = lRefPage->GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId );
 
                 if( !lPropertyFlags )
                     break;  // gone too far, break.
 
                 if( lPropertyFlags->GetFlagsInheritType( pFlags ) == FbxPropertyFlags::eOverride )
                 {
                     if( this == lRefPage || lFoundOverride )
                         return FbxPropertyFlags::eOverride;    // found two overrides or this page is the override.
                     else
                         lFoundOverride = true;  // signal that we found the first override.
                 }
                 lRefPage = lRefPage->mInstanceOf;
             }
 
             return FbxPropertyFlags::eInherit;
         }
     }

bool SetFlagsInheritType	(	FbxPropertyFlags::EInheritType	pInheritType,
		FbxPropertyFlags::EFlags	pFlags,
		FbxInt	pId = `0`
	)

inline

Definition at line 1401 of file fbxpropertypage.h.

     {
         FbxPropertyPage* lFoundIn = NULL;
         FbxPropertyFlags* lPropertyFlags = NULL;
 
         if( FbxPropertyFlags::eOverride == pInheritType )
         {
             lPropertyFlags = ChangePropertyItemState( FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eOverride );
 
             // we should initialize our flag to the inherited value, if any.
             FbxPropertyFlags* lParentFlags = mInstanceOf ? mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyFlags), pId ) : NULL;
             if( lParentFlags && lPropertyFlags )
             {
                 FbxPropertyFlags::EFlags lParentValues = lParentFlags->GetFlags();
                 lPropertyFlags->SetFlags( pFlags, lParentValues );
                 return lPropertyFlags->SetMask( pFlags );
             }
 
             return false;
         }
         else if( FbxPropertyFlags::eInherit == pInheritType )
         {
             lPropertyFlags = GetPropertyItem(FBX_TYPE(FbxPropertyFlags), pId, &lFoundIn);
             if( !lPropertyFlags ) return false;
             if( lFoundIn != this ) return true; // not us
             lPropertyFlags->UnsetMask( pFlags );
             if( lPropertyFlags->GetMask() == 0 )    // revert
                 ChangePropertyItemState( FBX_TYPE(FbxPropertyFlags), pId, FbxPropertyFlags::eInherit );
 
             return true;
         }
         return false;
     }

void BeginCreateOrFindProperty ( )

inline

Definition at line 1435 of file fbxpropertypage.h.

     {
         if( 0 == mNameMap.mFirst )
         {
             mNameMap.mSecond.Reserve(20);
 
             // push the existing properties into the map. Note: this includes the root property!
             FbxInt lFoundId = FBXSDK_PROPERTY_ID_ROOT;
             FbxPropertyEntry* lEntry = GetPropertyEntry(lFoundId);
             while(lFoundId != FBXSDK_PROPERTY_ID_NULL)
             {
                 FbxPropertyInfo* lInfo = lEntry->Get(FBX_TYPE(FbxPropertyInfo));
                 //FBX_ASSERT( lInfo );
                 if (lInfo)
                 {
                     mNameMap.mSecond.Insert(FbxNameMapKey(lEntry->GetParentId(), lInfo->GetName()), lFoundId);
                 }
                 lFoundId = GetMinimumPropertyIdAndEntry(lFoundId, &lEntry);
             }
             mNameMap.mFirst++;
         }
     }

void EndCreateOrFindProperty ( )

inline

Definition at line 1458 of file fbxpropertypage.h.

     {
         if( mNameMap.mFirst > 0 )
         {
             if( --(mNameMap.mFirst) == 0 )
                 mNameMap.mSecond.Clear();
         }
     }

bool Is ( FbxPropertyPage * pPage )

inlineprotected

Definition at line 1562 of file fbxpropertypage.h.

     {
         // @@@@@@@@@@@@@@@ Must complete for sub types
         return this==pPage;
     }

Friends And Related Function Documentation

friend class FbxPropertyHandle

friend

Definition at line 1754 of file fbxpropertypage.h.

T* fbxsdk::FbxNew ( )

friend

T* fbxsdk::FbxNew ( T1 & p1 )

friend

T* fbxsdk::FbxNew ( const T1 & p1 )

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		T2 &	p2
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		const T2 &	p2
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		T2 &	p2
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		T2 &	p2,
		T3 &	p3
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		T2 &	p2,
		const T3 &	p3
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		const T2 &	p2,
		T3 &	p3
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		const T2 &	p2,
		const T3 &	p3
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		T2 &	p2,
		T3 &	p3
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		T2 &	p2,
		const T3 &	p3
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		T3 &	p3
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		const T3 &	p3
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		T2 &	p2,
		T3 &	p3,
		T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		T2 &	p2,
		T3 &	p3,
		const T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		T2 &	p2,
		const T3 &	p3,
		T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		T2 &	p2,
		const T3 &	p3,
		const T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		const T2 &	p2,
		T3 &	p3,
		T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		const T2 &	p2,
		T3 &	p3,
		const T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		const T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		T2 &	p2,
		T3 &	p3,
		T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		T2 &	p2,
		T3 &	p3,
		const T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		T2 &	p2,
		const T3 &	p3,
		T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		T2 &	p2,
		const T3 &	p3,
		const T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		T3 &	p3,
		T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		T3 &	p3,
		const T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		const T4 &	p4
	)

friend

T* fbxsdk::FbxNew	(	T1 &	p1,
		T2 &	p2,
		T3 &	p3,
		T4 &	p4,
		T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		T2 &	p2,
		T3 &	p3,
		T4 &	p4,
		T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		T3 &	p3,
		T4 &	p4,
		T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		T2 &	p2,
		const T3 &	p3,
		T4 &	p4,
		T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		T2 &	p2,
		T3 &	p3,
		const T4 &	p4,
		T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		T2 &	p2,
		T3 &	p3,
		T4 &	p4,
		const T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		T4 &	p4,
		T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		T3 &	p3,
		const T4 &	p4,
		T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		T3 &	p3,
		T4 &	p4,
		const T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		const T4 &	p4,
		T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		T4 &	p4,
		const T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		const T4 &	p4,
		const T5 &	p5
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		const T4 &	p4,
		const T5 &	p5,
		const T6 &	p6
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		const T4 &	p4,
		const T5 &	p5,
		const T6 &	p6,
		const T7 &	p7
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		const T4 &	p4,
		const T5 &	p5,
		const T6 &	p6,
		const T7 &	p7,
		const T8 &	p8
	)

friend

T* fbxsdk::FbxNew	(	const T1 &	p1,
		const T2 &	p2,
		const T3 &	p3,
		const T4 &	p4,
		const T5 &	p5,
		const T6 &	p6,
		const T7 &	p7,
		const T8 &	p8,
		const T9 &	p9
	)

friend

void fbxsdk::FbxDelete ( T * p )

friend

void fbxsdk::FbxDelete ( const T * p )

friend

T* fbxsdk::FbxNewArray ( const int n )

friend

void fbxsdk::FbxDeleteArray ( T * p )

friend

The documentation for this class was generated from the following file:

fbxsdk/core/fbxpropertypage.h

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation