#include <fbxpropertypage.h>

Class Description

Definition at line 432 of file 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 FbxArray< FbxPropertyPage * > &	GetInstances () const

FbxArray< FbxPropertyPage * > &	GetInstances ()

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)

Member Enumeration Documentation

enum EValueIndex

Enumerator
eValueMin
eValueSoftMin
eValueMax
eValueSoftMax
eValueCount

Definition at line 1091 of file fbxpropertypage.h.

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

FbxPropertyPage::eValueSoftMax

Definition: fbxpropertypage.h:1091

FbxPropertyPage::eValueMax

Definition: fbxpropertypage.h:1091

FbxPropertyPage::eValueCount

Definition: fbxpropertypage.h:1091

FbxPropertyPage::eValueMin

Definition: fbxpropertypage.h:1091

FbxPropertyPage::eValueSoftMin

Definition: fbxpropertypage.h:1091

Constructor & Destructor Documentation

FbxPropertyPage ( FbxPropertyPage * pInstanceOf = 0 )

inlineprotected

Definition at line 1453 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.Add(this);
 
             mPropNextId = mInstanceOf->mPropNextId;
             mPropNextId->IncRef();
         }
     }

FbxPropertyPage	(	const char *	pName,
		EFbxType	pType
	)

inlineprotected

Definition at line 1481 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 1495 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 1509 of file fbxpropertypage.h.

     {
         // Propagate our property entries.
         int i = 0, j = 0;
         for( i = 0; i < mInstances.GetCount(); ++i )
         {
             for( j = 0; j < GetPropertyEntryCount(); ++j )
             {
                 if( mInstances[i]->ChangePropertyEntryState((FbxInt)j, FbxPropertyFlags::eOverride) )
                 {
                     // Clone the info and values. Don't clone the connections,
                     // since they aren't propagated.
                     mInstances[i]->ChangePropertyItemState( FBX_TYPE(FbxPropertyInfo), (FbxInt)j, FbxPropertyFlags::eOverride );
                     mInstances[i]->ChangePropertyItemState( FBX_TYPE(FbxPropertyValue), (FbxInt)j, FbxPropertyFlags::eOverride );
 
                     // Since all entries have their own flags, just override the ones in the instance.
                     mInstances[i]->SetFlagsInheritType(FbxPropertyFlags::eOverride, FbxPropertyFlags::eAllFlags, (FbxInt)j );
                 }
             }
 
             // Instances become their own copies.
             mInstances[i]->mInstanceOf = NULL;
         }
 
         FbxMapDestroy(mEntryMap);
 
         if (mInstanceOf) {
             int lIndex = mInstanceOf->mInstances.Find(this);
             mInstanceOf->mInstances.SetAt(lIndex, mInstanceOf->mInstances[mInstanceOf->mInstances.GetCount()-1]);
             mInstanceOf->mInstances.RemoveAt(mInstanceOf->mInstances.GetCount()-1);
 
             //mInstanceOf->mInstances.RemoveIt(this);
         }
 
         mPropNextId->DecRef();
         mPropNextId = NULL;
 
         mInstanceOf = NULL;
         mInstances.Clear();
     }

Member Function Documentation

static FbxPropertyPage* Create ( FbxPropertyPage * pInstanceOf = 0 )

inlinestatic

Definition at line 437 of file fbxpropertypage.h.

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

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

inlinestatic

Definition at line 438 of file fbxpropertypage.h.

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

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

inlinestatic

Definition at line 439 of file fbxpropertypage.h.

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

void Destroy ( )

inline

Definition at line 440 of file fbxpropertypage.h.

440 { 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 442 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 459 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 496 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 508 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 514 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 520 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 532 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 538 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 550 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 556 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 568 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 574 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 580 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 585 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 589 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 594 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 611 of file fbxpropertypage.h.

     {
         return GetParent(pId)==pParentId;
 
     }

bool IsDescendentOf	(	FbxInt	pId,
		FbxInt	pAncestorId
	)		const

inline

Definition at line 617 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 640 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 676 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 721 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 769 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 817 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 874 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 897 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 904 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 911 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 918 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 925 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 932 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 940 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 952 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 962 of file fbxpropertypage.h.

     {
         FbxPropertyEntry*    lDstEntry = ChangePropertyEntryState(pDstId,FbxPropertyFlags::eOverride);
         FbxPropertyEntry*    lSrcEntry = pSrcPage->ChangePropertyEntryState(pSrcId,FbxPropertyFlags::eOverride);
         FbxPropertyConnect*  lDstConnect= lDstEntry->Get( FBX_TYPE(FbxPropertyConnect) );
         FbxPropertyConnect*  lSrcConnect= lSrcEntry->Get( FBX_TYPE(FbxPropertyConnect) );
 
         // Make sure we have a connection point on both sides of the connection
         if (!lDstConnect) {
             lDstConnect = FbxPropertyConnect::Create( this,pDstId );
             lDstEntry->Set( lDstConnect );
         }
         if (!lSrcConnect) {
             lSrcConnect = FbxPropertyConnect::Create( pSrcPage,pSrcId );
             lSrcEntry->Set( lSrcConnect );
         }
 
         // Must @@@@@@@ Propagate to inherited children
         return lDstConnect->ConnectSrc(lSrcConnect,pType);
 
     }

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

inline

Definition at line 984 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 999 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 1014 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 1024 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 1044 of file fbxpropertypage.h.

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

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

inline

Definition at line 1049 of file fbxpropertypage.h.

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

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

inline

Definition at line 1054 of file fbxpropertypage.h.

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

int GetDstCount	(	FbxInt	pId,
		FbxConnectionPointFilter *	pFilter
	)

inline

Definition at line 1059 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 1069 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 1093 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 1100 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 1107 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 1116 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 1122 of file fbxpropertypage.h.

     {
         if( pCheckValueEquality )
         {
             FbxPropertyPage*   lReferencePage  = NULL;
             FbxPropertyValue*  lPropertyValue  = GetPropertyItem( FBX_TYPE(FbxPropertyValue),pId,&lReferencePage );
             void* lCurrentValue = FbxTypeAllocate( 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 )
                 {
                     lPropertyValue->Get( lCurrentValue, pValueType );
                     lValuesEqual = FbxTypeCompare( pValue, lCurrentValue, pValueType );
                 }
             }
             else
             {
                 FbxPropertyPage* lReferencePage2 = NULL;
                 FbxPropertyValue*  lPropertyValue2 = mInstanceOf ? mInstanceOf->GetPropertyItem( FBX_TYPE(FbxPropertyValue),pId,&lReferencePage2 ) : NULL;
                 if( lReferencePage2 && lPropertyValue2 )
                 {
                     // 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 );
 
                     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,
             }
 
             FbxTypeDeallocate(pValueType, lCurrentValue);
             lCurrentValue = NULL;
 
             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 1171 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 1197 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 1209 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 1219 of file fbxpropertypage.h.

1219 { 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:1122

T Get	(	FbxInt	pId,
		const T *	pFBX_TYPE
	)

inline

Definition at line 1220 of file fbxpropertypage.h.

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

FbxPropertyPage::Get

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

Definition: fbxpropertypage.h:1116

FbxTypeOf

EFbxType FbxTypeOf(const FbxChar &)

Definition: fbxpropertytypes.h:533

void SetDataPtr ( void * pDataPtr )

inline

Definition at line 1223 of file fbxpropertypage.h.

1223 { mDataPtr = pDataPtr; }

void* GetDataPtr ( ) const

inline

Definition at line 1224 of file fbxpropertypage.h.

1224 { return mDataPtr; }

void PushPropertiesToParentInstance ( )

inline

Definition at line 1228 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 1282 of file fbxpropertypage.h.

1282 { return mInstanceOf; }

FbxPropertyPage* GetInstanceOf ( )

inline

Definition at line 1283 of file fbxpropertypage.h.

1283 { return mInstanceOf; }

const FbxArray<FbxPropertyPage*>& GetInstances ( ) const

inline

Definition at line 1285 of file fbxpropertypage.h.

1285 { return mInstances; }

FbxArray<FbxPropertyPage*>& GetInstances ( )

inline

Definition at line 1286 of file fbxpropertypage.h.

1286 { return mInstances; }

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

inline

Definition at line 1291 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 1310 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 1350 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 1386 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 1420 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 1443 of file fbxpropertypage.h.

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

bool Is ( FbxPropertyPage * pPage )

inlineprotected

Definition at line 1550 of file fbxpropertypage.h.

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

Friends And Related Function Documentation

friend class FbxPropertyHandle

friend

Definition at line 1742 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

FbxPropertyPage Class Reference

Class Description

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation