mirror of
https://github.com/alliedmodders/hl2sdk.git
synced 2025-09-19 12:06:07 +08:00
Added original SDK code for Alien Swarm.
This commit is contained in:
Scott Ehlert
32
public/datamodel/attributeflags.h
Normal file
32
public/datamodel/attributeflags.h
Normal file
@ -0,0 +1,32 @@
|
||||
//====== Copyright <20> 1996-2004, Valve Corporation, All rights reserved. =======
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
//=============================================================================
|
||||
|
||||
#ifndef ATTRIBUTEFLAGS_H
|
||||
#define ATTRIBUTEFLAGS_H
|
||||
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
enum
|
||||
{
|
||||
// NOTE: The first 5 flags bits are reserved for attribute type
|
||||
FATTRIB_TYPEMASK = 0x1F,
|
||||
|
||||
FATTRIB_READONLY = (1<<5), // Don't allow editing value in editors
|
||||
FATTRIB_DONTSAVE = (1<<6), // Don't persist to .dmx file
|
||||
FATTRIB_DIRTY = (1<<7), // Indicates the attribute has been changed since the resolve phase
|
||||
FATTRIB_HAS_CALLBACK = (1<<8), // Indicates that this will notify its owner and/or other elements when it changes
|
||||
FATTRIB_EXTERNAL = (1<<9), // Indicates this attribute's data is externally owned (in a CDmElement somewhere)
|
||||
FATTRIB_TOPOLOGICAL = (1<<10), // Indicates this attribute effects the scene's topology (ie it's an attribute name or element)
|
||||
FATTRIB_MUSTCOPY = (1<<11), // parent element must make a new copy during CopyInto, even for shallow copy
|
||||
FATTRIB_NEVERCOPY = (1<<12), // parent element shouldn't make a new copy during CopyInto, even for deep copy
|
||||
FATTRIB_USERDEFINED = (1<<13), // This flag WAS used to sort attributes. Now it's used to guess whether vmtdoc and vmfentity attributes are shaderparams or entitykeys. TODO - remove this
|
||||
FATTRIB_OPERATOR_DIRTY = (1<<14), // Used and cleared only by operator phase of datamodel
|
||||
FATTRIB_HIDDEN = (1<<15), // shouldn't be shown in ui
|
||||
};
|
||||
|
||||
#endif // ATTRIBUTEFLAGS_H
|
||||
440
public/datamodel/dmattribute.h
Normal file
440
public/datamodel/dmattribute.h
Normal file
@ -0,0 +1,440 @@
|
||||
//====== Copyright <20> 1996-2004, Valve Corporation, All rights reserved. =======
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
//=============================================================================
|
||||
|
||||
#ifndef DMATTRIBUTE_H
|
||||
#define DMATTRIBUTE_H
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include "datamodel/attributeflags.h"
|
||||
#include "datamodel/idatamodel.h"
|
||||
#include "datamodel/dmattributetypes.h"
|
||||
#include "datamodel/dmvar.h"
|
||||
#include "tier1/utlhash.h"
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Forward declarations
|
||||
//-----------------------------------------------------------------------------
|
||||
class CDmElement;
|
||||
class CUtlBuffer;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Used for in-place modification
|
||||
//-----------------------------------------------------------------------------
|
||||
typedef void *DmAttributeModifyHandle_t;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: A general purpose pAttribute. Eventually will be extensible to arbitrary user types
|
||||
//-----------------------------------------------------------------------------
|
||||
class CDmAttribute
|
||||
{
|
||||
public:
|
||||
// Returns the type
|
||||
DmAttributeType_t GetType() const;
|
||||
const char *GetTypeString() const;
|
||||
template< class T > bool IsA() const;
|
||||
|
||||
// ChangeType fails (and returns false) for external attributes (ones who's data is owned by their element)
|
||||
bool ChangeType_UNSAFE( DmAttributeType_t type );
|
||||
|
||||
bool IsStandard() const;
|
||||
|
||||
// Returns the name. NOTE: The utlsymbol
|
||||
// can be turned into a string by using g_pDataModel->String();
|
||||
const char *GetName() const;
|
||||
CUtlSymbolLarge GetNameSymbol() const;
|
||||
void SetName( const char *newName );
|
||||
|
||||
// Gets the attribute value
|
||||
// NOTE: GetValueUntyped is used with GetType() for use w/ SetValue( type, void* )
|
||||
template< class T > const T& GetValue() const;
|
||||
template< class T > const T& GetValue( const T& defaultValue ) const;
|
||||
const char *GetValueString() const;
|
||||
template< class E > E *GetValueElement() const;
|
||||
const void *GetValueUntyped() const;
|
||||
|
||||
// Sets the attribute value
|
||||
template< class T > void SetValue( const T &value );
|
||||
template< class E > void SetValue( E* pValue );
|
||||
void SetValue( const void *pValue, size_t nSize );
|
||||
|
||||
// Copies w/ type conversion (if possible) from another attribute
|
||||
void SetValue( const CDmAttribute *pAttribute );
|
||||
void SetValue( CDmAttribute *pAttribute );
|
||||
void SetValue( DmAttributeType_t valueType, const void *pValue );
|
||||
|
||||
// Sets the attribute to its default value based on its type
|
||||
void SetToDefaultValue();
|
||||
|
||||
// Convert to and from string
|
||||
void SetValueFromString( const char *pValue );
|
||||
const char *GetValueAsString( char *pBuffer, size_t nBufLen ) const;
|
||||
|
||||
// Used for in-place modification of the data; preferable to set value
|
||||
// for large data like arrays or binary blocks
|
||||
template< class T > T& BeginModifyValueInPlace( DmAttributeModifyHandle_t *pHandle );
|
||||
template< class T > void EndModifyValueInPlace( DmAttributeModifyHandle_t handle );
|
||||
|
||||
// Used for element and element array attributes; it specifies which type of
|
||||
// elements are valid to be referred to by this attribute
|
||||
void SetElementTypeSymbol( CUtlSymbolLarge typeSymbol );
|
||||
CUtlSymbolLarge GetElementTypeSymbol() const;
|
||||
|
||||
// Returns the next attribute
|
||||
CDmAttribute *NextAttribute();
|
||||
const CDmAttribute *NextAttribute() const;
|
||||
|
||||
// Returns the owner
|
||||
CDmElement *GetOwner();
|
||||
|
||||
// Methods related to flags
|
||||
void AddFlag( int flags );
|
||||
void RemoveFlag( int flags );
|
||||
void ClearFlags();
|
||||
int GetFlags() const;
|
||||
bool IsFlagSet( int flags ) const;
|
||||
|
||||
// Serialization
|
||||
bool Serialize( CUtlBuffer &buf ) const;
|
||||
bool Unserialize( CUtlBuffer &buf );
|
||||
bool IsIdenticalToSerializedValue( CUtlBuffer &buf ) const;
|
||||
|
||||
// Serialization of a single element.
|
||||
// First version of UnserializeElement adds to tail if it worked
|
||||
// Second version overwrites, but does not add, the element at the specified index
|
||||
bool SerializeElement( int nElement, CUtlBuffer &buf ) const;
|
||||
bool UnserializeElement( CUtlBuffer &buf );
|
||||
bool UnserializeElement( int nElement, CUtlBuffer &buf );
|
||||
|
||||
// Does this attribute serialize on multiple lines?
|
||||
bool SerializesOnMultipleLines() const;
|
||||
|
||||
// Get the attribute/create an attribute handle
|
||||
DmAttributeHandle_t GetHandle( bool bCreate = true );
|
||||
|
||||
// estimate memory overhead
|
||||
int EstimateMemoryUsage( TraversalDepth_t depth ) const;
|
||||
|
||||
private:
|
||||
// Class factory
|
||||
static CDmAttribute *CreateAttribute( CDmElement *pOwner, DmAttributeType_t type, const char *pAttributeName );
|
||||
static CDmAttribute *CreateExternalAttribute( CDmElement *pOwner, DmAttributeType_t type, const char *pAttributeName, void *pExternalMemory );
|
||||
static void DestroyAttribute( CDmAttribute *pAttribute );
|
||||
|
||||
// Constructor, destructor
|
||||
CDmAttribute( CDmElement *pOwner, DmAttributeType_t type, const char *pAttributeName );
|
||||
CDmAttribute( CDmElement *pOwner, DmAttributeType_t type, const char *pAttributeName, void *pMemory );
|
||||
~CDmAttribute();
|
||||
|
||||
// Used when constructing CDmAttributes
|
||||
void Init( CDmElement *pOwner, DmAttributeType_t type, const char *pAttributeName );
|
||||
|
||||
// Used when shutting down, indicates DmAttributeHandle_t referring to this are invalid
|
||||
void InvalidateHandle();
|
||||
|
||||
// Called when the attribute changes
|
||||
void OnChanged( bool bArrayCountChanged = false, bool bIsTopological = false );
|
||||
|
||||
// Is modification allowed in this phase?
|
||||
bool ModificationAllowed() const;
|
||||
|
||||
// Mark the attribute as being dirty
|
||||
bool MarkDirty();
|
||||
|
||||
// Is the data inline in a containing element class?
|
||||
bool IsDataInline() const;
|
||||
|
||||
// Allocates, frees internal data storage
|
||||
void CreateAttributeData();
|
||||
void DeleteAttributeData();
|
||||
|
||||
// Gets at the internal data storage
|
||||
void* GetAttributeData();
|
||||
const void* GetAttributeData() const;
|
||||
template < class T > typename CDmAttributeInfo< T >::StorageType_t* GetData();
|
||||
template < class T > const typename CDmAttributeInfo< T >::StorageType_t* GetData() const;
|
||||
template < class T > typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* GetArrayData();
|
||||
template < class T > const typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* GetArrayData() const;
|
||||
|
||||
// Used by CDmElement to manage the list of attributes it owns
|
||||
CDmAttribute **GetNextAttributeRef();
|
||||
|
||||
// Implementational function used for memory consumption estimation computation
|
||||
int EstimateMemoryUsageInternal( CUtlHash< DmElementHandle_t > &visited, TraversalDepth_t depth, int *pCategories ) const;
|
||||
|
||||
// Called by elements after unserialization of their attributes is complete
|
||||
void OnUnserializationFinished();
|
||||
|
||||
template< class T > bool IsTypeConvertable() const;
|
||||
template< class T > bool ShouldModify( const T& src );
|
||||
template< class T > void CopyData( const T& src );
|
||||
template< class T > void CopyDataOut( T& dest ) const;
|
||||
|
||||
private:
|
||||
CDmAttribute *m_pNext;
|
||||
void *m_pData;
|
||||
CDmElement *m_pOwner;
|
||||
DmAttributeHandle_t m_Handle;
|
||||
uint16 m_nFlags;
|
||||
CUtlSymbolLarge m_Name;
|
||||
|
||||
friend class CDmElement;
|
||||
friend class CDmAttributeAccessor;
|
||||
template< class T > friend class CDmrElementArray;
|
||||
template< class E > friend class CDmrElementArrayConst;
|
||||
template< class T > friend class CDmaArrayAccessor;
|
||||
template< class T, class B > friend class CDmrDecorator;
|
||||
template< class T, class B > friend class CDmrDecoratorConst;
|
||||
template< class T > friend class CDmArrayAttributeOp;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Inline methods
|
||||
//-----------------------------------------------------------------------------
|
||||
inline DmAttributeType_t CDmAttribute::GetType() const
|
||||
{
|
||||
return (DmAttributeType_t)( m_nFlags & FATTRIB_TYPEMASK );
|
||||
}
|
||||
|
||||
template< class T > inline bool CDmAttribute::IsA() const
|
||||
{
|
||||
return GetType() == CDmAttributeInfo< T >::AttributeType();
|
||||
}
|
||||
|
||||
inline const char *CDmAttribute::GetName() const
|
||||
{
|
||||
return m_Name.String();
|
||||
}
|
||||
|
||||
inline CUtlSymbolLarge CDmAttribute::GetNameSymbol() const
|
||||
{
|
||||
return m_Name;
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Iteration
|
||||
//-----------------------------------------------------------------------------
|
||||
inline CDmAttribute *CDmAttribute::NextAttribute()
|
||||
{
|
||||
return m_pNext;
|
||||
}
|
||||
|
||||
inline const CDmAttribute *CDmAttribute::NextAttribute() const
|
||||
{
|
||||
return m_pNext;
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Returns the owner
|
||||
//-----------------------------------------------------------------------------
|
||||
inline CDmElement *CDmAttribute::GetOwner()
|
||||
{
|
||||
return m_pOwner;
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Value getting methods
|
||||
//-----------------------------------------------------------------------------
|
||||
template< class T >
|
||||
inline const T& CDmAttribute::GetValue( const T& defaultValue ) const
|
||||
{
|
||||
if ( (int)GetType() == (int)CDmAttributeInfo< T >::ATTRIBUTE_TYPE )
|
||||
return *reinterpret_cast< const T* >( m_pData );
|
||||
|
||||
if ( IsTypeConvertable< T >() )
|
||||
{
|
||||
static T tempVal;
|
||||
CopyDataOut( tempVal );
|
||||
return tempVal;
|
||||
}
|
||||
|
||||
Assert( 0 );
|
||||
return defaultValue;
|
||||
}
|
||||
|
||||
template< class T >
|
||||
inline const T& CDmAttribute::GetValue() const
|
||||
{
|
||||
static CDmaVar< T > defaultVal;
|
||||
return GetValue( defaultVal.Get() );
|
||||
}
|
||||
|
||||
inline const char *CDmAttribute::GetValueString() const
|
||||
{
|
||||
Assert( GetType() == AT_STRING );
|
||||
if ( GetType() != AT_STRING )
|
||||
return NULL;
|
||||
|
||||
CUtlSymbolLarge symbol = GetValue< CUtlSymbolLarge >();
|
||||
return symbol.String();
|
||||
}
|
||||
|
||||
// used with GetType() for use w/ SetValue( type, void* )
|
||||
inline const void* CDmAttribute::GetValueUntyped() const
|
||||
{
|
||||
return m_pData;
|
||||
}
|
||||
|
||||
#ifndef POSIX
|
||||
template< class E >
|
||||
inline E* CDmAttribute::GetValueElement() const
|
||||
{
|
||||
Assert( GetType() == AT_ELEMENT );
|
||||
if ( GetType() == AT_ELEMENT )
|
||||
return GetElement<E>( this->GetValue<DmElementHandle_t>( ) );
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Value setting methods
|
||||
//-----------------------------------------------------------------------------
|
||||
template< class E >
|
||||
inline void CDmAttribute::SetValue( E* pValue )
|
||||
{
|
||||
Assert( GetType() == AT_ELEMENT );
|
||||
if ( GetType() == AT_ELEMENT )
|
||||
{
|
||||
SetValue( pValue ? pValue->GetHandle() : DMELEMENT_HANDLE_INVALID );
|
||||
}
|
||||
}
|
||||
|
||||
template<>
|
||||
inline void CDmAttribute::SetValue( const char *pValue )
|
||||
{
|
||||
CUtlSymbolLarge symbol = g_pDataModel->GetSymbol( pValue );
|
||||
return SetValue( symbol );
|
||||
}
|
||||
|
||||
template<>
|
||||
inline void CDmAttribute::SetValue( char *pValue )
|
||||
{
|
||||
return SetValue( (const char *)pValue );
|
||||
}
|
||||
|
||||
inline void CDmAttribute::SetValue( const void *pValue, size_t nSize )
|
||||
{
|
||||
CUtlBinaryBlock buf( pValue, nSize );
|
||||
return SetValue( buf );
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Methods related to flags
|
||||
//-----------------------------------------------------------------------------
|
||||
inline void CDmAttribute::AddFlag( int nFlags )
|
||||
{
|
||||
m_nFlags |= ( nFlags & ~FATTRIB_TYPEMASK );
|
||||
}
|
||||
|
||||
inline void CDmAttribute::RemoveFlag( int nFlags )
|
||||
{
|
||||
m_nFlags &= ~nFlags | FATTRIB_TYPEMASK;
|
||||
}
|
||||
|
||||
inline void CDmAttribute::ClearFlags()
|
||||
{
|
||||
RemoveFlag( 0xffffffff );
|
||||
}
|
||||
|
||||
inline int CDmAttribute::GetFlags() const
|
||||
{
|
||||
return m_nFlags & ~FATTRIB_TYPEMASK;
|
||||
}
|
||||
|
||||
inline bool CDmAttribute::IsFlagSet( int nFlags ) const
|
||||
{
|
||||
return ( nFlags & GetFlags() ) != 0;
|
||||
}
|
||||
|
||||
inline bool CDmAttribute::IsDataInline() const
|
||||
{
|
||||
return !IsFlagSet( FATTRIB_EXTERNAL );
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Gets at the internal data storage
|
||||
//-----------------------------------------------------------------------------
|
||||
inline void* CDmAttribute::GetAttributeData()
|
||||
{
|
||||
return m_pData;
|
||||
}
|
||||
|
||||
inline const void* CDmAttribute::GetAttributeData() const
|
||||
{
|
||||
return m_pData;
|
||||
}
|
||||
|
||||
template < class T >
|
||||
inline typename CDmAttributeInfo< T >::StorageType_t* CDmAttribute::GetData()
|
||||
{
|
||||
return ( typename CDmAttributeInfo< T >::StorageType_t* )m_pData;
|
||||
}
|
||||
|
||||
template < class T >
|
||||
inline typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* CDmAttribute::GetArrayData()
|
||||
{
|
||||
return ( typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* )m_pData;
|
||||
}
|
||||
|
||||
template < class T >
|
||||
inline const typename CDmAttributeInfo< T >::StorageType_t* CDmAttribute::GetData() const
|
||||
{
|
||||
return ( const typename CDmAttributeInfo< T >::StorageType_t* )m_pData;
|
||||
}
|
||||
|
||||
template < class T >
|
||||
inline const typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* CDmAttribute::GetArrayData() const
|
||||
{
|
||||
return ( const typename CDmAttributeInfo< CUtlVector< T > >::StorageType_t* )m_pData;
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Used by CDmElement to manage the list of attributes it owns
|
||||
//-----------------------------------------------------------------------------
|
||||
inline CDmAttribute **CDmAttribute::GetNextAttributeRef()
|
||||
{
|
||||
return &m_pNext;
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// helper function for determining which attributes/elements to traverse during copy/find/save/etc.
|
||||
//-----------------------------------------------------------------------------
|
||||
inline bool ShouldTraverse( const CDmAttribute *pAttr, TraversalDepth_t depth )
|
||||
{
|
||||
switch ( depth )
|
||||
{
|
||||
case TD_NONE:
|
||||
return false;
|
||||
|
||||
case TD_SHALLOW:
|
||||
if ( !pAttr->IsFlagSet( FATTRIB_MUSTCOPY ) )
|
||||
return false;
|
||||
// fall-through intentional
|
||||
case TD_DEEP:
|
||||
if ( pAttr->IsFlagSet( FATTRIB_NEVERCOPY ) )
|
||||
return false;
|
||||
// fall-through intentional
|
||||
case TD_ALL:
|
||||
return true;
|
||||
}
|
||||
|
||||
Assert( 0 );
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif // DMATTRIBUTE_H
|
||||
351
public/datamodel/dmattributetypes.h
Normal file
351
public/datamodel/dmattributetypes.h
Normal file
@ -0,0 +1,351 @@
|
||||
//====== Copyright <20> 1996-2004, Valve Corporation, All rights reserved. =======
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
//=============================================================================
|
||||
|
||||
#ifndef DMATTRIBUTETYPES_H
|
||||
#define DMATTRIBUTETYPES_H
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include "tier1/utlvector.h"
|
||||
#include "tier1/utlstring.h"
|
||||
#include "tier1/uniqueid.h"
|
||||
#include "Color.h"
|
||||
#include "mathlib/vector2d.h"
|
||||
#include "mathlib/vector.h"
|
||||
#include "mathlib/vector4d.h"
|
||||
#include "mathlib/vmatrix.h"
|
||||
#include "datamodel/dmelementhandle.h"
|
||||
#include "tier1/utlsymbollarge.h"
|
||||
#include "tier1/timeutils.h"
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Object Id
|
||||
//-----------------------------------------------------------------------------
|
||||
typedef UniqueId_t DmObjectId_t;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Necessary for template specialization for AT_UNKNOWN
|
||||
//-----------------------------------------------------------------------------
|
||||
struct DmUnknownAttribute_t
|
||||
{
|
||||
bool operator==( const DmUnknownAttribute_t& src ) const { return true; }
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Element array
|
||||
//-----------------------------------------------------------------------------
|
||||
struct DmElementAttribute_t
|
||||
{
|
||||
DmElementAttribute_t() : m_ElementType( UTL_INVAL_SYMBOL_LARGE ) {}
|
||||
|
||||
operator DmElementHandle_t&() { return m_Handle; }
|
||||
operator const DmElementHandle_t&() const { return m_Handle; }
|
||||
|
||||
DmElementHandle_t m_Handle;
|
||||
CUtlSymbolLarge m_ElementType;
|
||||
};
|
||||
|
||||
struct DmElementArray_t : public CUtlVector< DmElementHandle_t >
|
||||
{
|
||||
DmElementArray_t() : m_ElementType( UTL_INVAL_SYMBOL_LARGE ) {}
|
||||
|
||||
CUtlSymbolLarge m_ElementType;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Attribute chunk type enum
|
||||
//-----------------------------------------------------------------------------
|
||||
enum DmAttributeType_t
|
||||
{
|
||||
AT_UNKNOWN = 0,
|
||||
|
||||
AT_FIRST_VALUE_TYPE,
|
||||
|
||||
AT_ELEMENT = AT_FIRST_VALUE_TYPE,
|
||||
AT_INT,
|
||||
AT_FLOAT,
|
||||
AT_BOOL,
|
||||
AT_STRING,
|
||||
AT_VOID,
|
||||
AT_TIME,
|
||||
AT_COLOR, //rgba
|
||||
AT_VECTOR2,
|
||||
AT_VECTOR3,
|
||||
AT_VECTOR4,
|
||||
AT_QANGLE,
|
||||
AT_QUATERNION,
|
||||
AT_VMATRIX,
|
||||
|
||||
AT_FIRST_ARRAY_TYPE,
|
||||
|
||||
AT_ELEMENT_ARRAY = AT_FIRST_ARRAY_TYPE,
|
||||
AT_INT_ARRAY,
|
||||
AT_FLOAT_ARRAY,
|
||||
AT_BOOL_ARRAY,
|
||||
AT_STRING_ARRAY,
|
||||
AT_VOID_ARRAY,
|
||||
AT_TIME_ARRAY,
|
||||
AT_COLOR_ARRAY,
|
||||
AT_VECTOR2_ARRAY,
|
||||
AT_VECTOR3_ARRAY,
|
||||
AT_VECTOR4_ARRAY,
|
||||
AT_QANGLE_ARRAY,
|
||||
AT_QUATERNION_ARRAY,
|
||||
AT_VMATRIX_ARRAY,
|
||||
AT_TYPE_COUNT,
|
||||
|
||||
AT_TYPE_INVALID,
|
||||
};
|
||||
|
||||
const char *GetTypeString( DmAttributeType_t type );
|
||||
|
||||
inline bool IsValueType( DmAttributeType_t type )
|
||||
{
|
||||
return type >= AT_FIRST_VALUE_TYPE && type < AT_FIRST_ARRAY_TYPE;
|
||||
}
|
||||
|
||||
inline bool IsArrayType( DmAttributeType_t type )
|
||||
{
|
||||
return type >= AT_FIRST_ARRAY_TYPE && type < AT_TYPE_COUNT;
|
||||
}
|
||||
|
||||
inline bool IsTopological( DmAttributeType_t type )
|
||||
{
|
||||
return type == AT_ELEMENT || type == AT_ELEMENT_ARRAY;
|
||||
}
|
||||
|
||||
inline DmAttributeType_t ValueTypeToArrayType( DmAttributeType_t type )
|
||||
{
|
||||
Assert( IsValueType( type ) );
|
||||
return ( DmAttributeType_t )( ( type - AT_FIRST_VALUE_TYPE ) + AT_FIRST_ARRAY_TYPE );
|
||||
}
|
||||
|
||||
inline DmAttributeType_t ArrayTypeToValueType( DmAttributeType_t type )
|
||||
{
|
||||
Assert( IsArrayType( type ) );
|
||||
return ( DmAttributeType_t )( ( type - AT_FIRST_ARRAY_TYPE ) + AT_FIRST_VALUE_TYPE );
|
||||
}
|
||||
|
||||
inline int NumComponents( DmAttributeType_t type )
|
||||
{
|
||||
switch ( type )
|
||||
{
|
||||
case AT_BOOL:
|
||||
case AT_INT:
|
||||
case AT_FLOAT:
|
||||
case AT_TIME:
|
||||
return 1;
|
||||
|
||||
case AT_VECTOR2:
|
||||
return 2;
|
||||
|
||||
case AT_VECTOR3:
|
||||
case AT_QANGLE:
|
||||
return 3;
|
||||
|
||||
case AT_COLOR: //rgba
|
||||
case AT_VECTOR4:
|
||||
case AT_QUATERNION:
|
||||
return 4;
|
||||
|
||||
case AT_VMATRIX:
|
||||
return 16;
|
||||
|
||||
case AT_ELEMENT:
|
||||
case AT_STRING:
|
||||
case AT_VOID:
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
template< typename T >
|
||||
inline float GetComponent( const T &value, int i )
|
||||
{
|
||||
Assert( 0 );
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
template <> inline float GetComponent( const bool &value, int i )
|
||||
{
|
||||
Assert( i == 0 );
|
||||
return value ? 1.0f : 0.0f;
|
||||
}
|
||||
|
||||
template <> inline float GetComponent( const int &value, int i )
|
||||
{
|
||||
Assert( i == 0 );
|
||||
return float( value );
|
||||
}
|
||||
|
||||
template <> inline float GetComponent( const float &value, int i )
|
||||
{
|
||||
Assert( i == 0 );
|
||||
return value;
|
||||
}
|
||||
|
||||
template <> inline float GetComponent( const DmeTime_t &value, int i )
|
||||
{
|
||||
Assert( i == 0 );
|
||||
return value.GetSeconds();
|
||||
}
|
||||
|
||||
template <> inline float GetComponent( const Vector2D &value, int i )
|
||||
{
|
||||
return value[ i ];
|
||||
}
|
||||
|
||||
template <> inline float GetComponent( const Vector &value, int i )
|
||||
{
|
||||
return value[ i ];
|
||||
}
|
||||
|
||||
template <> inline float GetComponent( const QAngle &value, int i )
|
||||
{
|
||||
return value[ i ];
|
||||
}
|
||||
|
||||
template <> inline float GetComponent( const Color &value, int i )
|
||||
{
|
||||
return value[ i ];
|
||||
}
|
||||
|
||||
template <> inline float GetComponent( const Vector4D &value, int i )
|
||||
{
|
||||
return value[ i ];
|
||||
}
|
||||
|
||||
template <> inline float GetComponent( const Quaternion &value, int i )
|
||||
{
|
||||
return value[ i ];
|
||||
}
|
||||
|
||||
template <> inline float GetComponent( const VMatrix &value, int i )
|
||||
{
|
||||
return value.Base()[ i ];
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Attribute info...
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
template <typename T>
|
||||
class CDmAttributeInfo
|
||||
{
|
||||
private:
|
||||
enum { ATTRIBUTE_TYPE = AT_TYPE_INVALID };
|
||||
|
||||
typedef T StorageType_t;
|
||||
|
||||
static DmAttributeType_t AttributeType()
|
||||
{
|
||||
return AT_TYPE_INVALID;
|
||||
}
|
||||
|
||||
static const char *AttributeTypeName()
|
||||
{
|
||||
return "invalid";
|
||||
}
|
||||
|
||||
static void SetDefaultValue( T& value )
|
||||
{
|
||||
Assert(0);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <>
|
||||
class CDmAttributeInfo< DmUnknownAttribute_t >
|
||||
{
|
||||
public:
|
||||
enum { ATTRIBUTE_TYPE = AT_UNKNOWN };
|
||||
|
||||
typedef DmUnknownAttribute_t StorageType_t;
|
||||
|
||||
static DmAttributeType_t AttributeType()
|
||||
{
|
||||
return AT_UNKNOWN;
|
||||
}
|
||||
|
||||
static const char *AttributeTypeName()
|
||||
{
|
||||
return "unknown";
|
||||
}
|
||||
|
||||
static void SetDefaultValue( DmUnknownAttribute_t& value )
|
||||
{
|
||||
Assert(0);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#define DECLARE_ATTRIBUTE_TYPE_INTERNAL( _className, _storageType, _attributeType, _attributeName, _defaultSetStatement ) \
|
||||
template< > class CDmAttributeInfo< _className > \
|
||||
{ \
|
||||
public: \
|
||||
enum { ATTRIBUTE_TYPE = _attributeType }; \
|
||||
typedef _storageType StorageType_t; \
|
||||
static DmAttributeType_t AttributeType() { return _attributeType; } \
|
||||
static const char *AttributeTypeName() { return _attributeName; } \
|
||||
static void SetDefaultValue( _className& value ) { _defaultSetStatement } \
|
||||
}; \
|
||||
|
||||
#define DECLARE_ATTRIBUTE_ARRAY_TYPE_INTERNAL( _className, _storageType, _attributeType, _attributeName ) \
|
||||
template< > class CDmAttributeInfo< CUtlVector<_className> > \
|
||||
{ \
|
||||
public: \
|
||||
enum { ATTRIBUTE_TYPE = _attributeType }; \
|
||||
typedef _storageType StorageType_t; \
|
||||
static DmAttributeType_t AttributeType() { return _attributeType; } \
|
||||
static const char *AttributeTypeName() { return _attributeName; } \
|
||||
static void SetDefaultValue( CUtlVector< _className >& value ) { value.RemoveAll(); } \
|
||||
}; \
|
||||
|
||||
#define DECLARE_ATTRIBUTE_TYPE( _className, _attributeType, _attributeName, _defaultSetStatement ) \
|
||||
DECLARE_ATTRIBUTE_TYPE_INTERNAL( _className, _className, _attributeType, _attributeName, _defaultSetStatement )
|
||||
|
||||
#define DECLARE_ATTRIBUTE_ARRAY_TYPE( _className, _attributeType, _attributeName )\
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE_INTERNAL( _className, CUtlVector< _className >, _attributeType, _attributeName )
|
||||
|
||||
// NOTE: If you add an attribute type here, also add it to the list of DEFINE_ATTRIBUTE_TYPES in dmattribute.cpp
|
||||
DECLARE_ATTRIBUTE_TYPE( int, AT_INT, "int", value = 0; )
|
||||
DECLARE_ATTRIBUTE_TYPE( float, AT_FLOAT, "float", value = 0.0f; )
|
||||
DECLARE_ATTRIBUTE_TYPE( bool, AT_BOOL, "bool", value = false; )
|
||||
DECLARE_ATTRIBUTE_TYPE( Color, AT_COLOR, "color", value.SetColor( 0, 0, 0, 255 ); )
|
||||
DECLARE_ATTRIBUTE_TYPE( Vector2D, AT_VECTOR2, "vector2", value.Init( 0.0f, 0.0f ); )
|
||||
DECLARE_ATTRIBUTE_TYPE( Vector, AT_VECTOR3, "vector3", value.Init( 0.0f, 0.0f, 0.0f ); )
|
||||
DECLARE_ATTRIBUTE_TYPE( Vector4D, AT_VECTOR4, "vector4", value.Init( 0.0f, 0.0f, 0.0f, 0.0f ); )
|
||||
DECLARE_ATTRIBUTE_TYPE( QAngle, AT_QANGLE, "qangle", value.Init( 0.0f, 0.0f, 0.0f ); )
|
||||
DECLARE_ATTRIBUTE_TYPE( Quaternion, AT_QUATERNION, "quaternion", value.Init( 0.0f, 0.0f, 0.0f, 1.0f ); )
|
||||
DECLARE_ATTRIBUTE_TYPE( VMatrix, AT_VMATRIX, "matrix", MatrixSetIdentity( value ); )
|
||||
DECLARE_ATTRIBUTE_TYPE( CUtlSymbolLarge, AT_STRING, "string", value = UTL_INVAL_SYMBOL_LARGE; )
|
||||
DECLARE_ATTRIBUTE_TYPE( CUtlBinaryBlock, AT_VOID, "binary", value.Set( NULL, 0 ); )
|
||||
DECLARE_ATTRIBUTE_TYPE( DmeTime_t, AT_TIME, "time", value.SetTenthsOfMS( 0 ); )
|
||||
DECLARE_ATTRIBUTE_TYPE_INTERNAL( DmElementHandle_t, DmElementAttribute_t, AT_ELEMENT, "element", value = DMELEMENT_HANDLE_INVALID; )
|
||||
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( int, AT_INT_ARRAY, "int_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( float, AT_FLOAT_ARRAY, "float_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( bool, AT_BOOL_ARRAY, "bool_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( Color, AT_COLOR_ARRAY, "color_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( Vector2D, AT_VECTOR2_ARRAY, "vector2_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( Vector, AT_VECTOR3_ARRAY, "vector3_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( Vector4D, AT_VECTOR4_ARRAY, "vector4_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( QAngle, AT_QANGLE_ARRAY, "qangle_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( Quaternion, AT_QUATERNION_ARRAY, "quaternion_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( VMatrix, AT_VMATRIX_ARRAY, "matrix_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( CUtlSymbolLarge, AT_STRING_ARRAY, "string_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( CUtlBinaryBlock, AT_VOID_ARRAY, "binary_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE( DmeTime_t, AT_TIME_ARRAY, "time_array" )
|
||||
DECLARE_ATTRIBUTE_ARRAY_TYPE_INTERNAL( DmElementHandle_t, DmElementArray_t, AT_ELEMENT_ARRAY, "element_array" )
|
||||
|
||||
|
||||
#endif // DMATTRIBUTETYPES_H
|
||||
1518
public/datamodel/dmattributevar.h
Normal file
1518
public/datamodel/dmattributevar.h
Normal file
File diff suppressed because it is too large
Load Diff
263
public/datamodel/dmehandle.h
Normal file
263
public/datamodel/dmehandle.h
Normal file
@ -0,0 +1,263 @@
|
||||
//========= Copyright <20> 1996-2005, Valve LLC, All rights reserved. ============
|
||||
//
|
||||
// The copyright to the contents herein is the property of Valve, L.L.C.
|
||||
// The contents may be used and/or copied only with the written permission of
|
||||
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
|
||||
// the agreement/contract under which the contents have been supplied.
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//=============================================================================
|
||||
|
||||
#ifndef DMEHANDLE_H
|
||||
#define DMEHANDLE_H
|
||||
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
|
||||
#include "datamodel/idatamodel.h"
|
||||
#include "datamodel/dmelement.h"
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: CDmeHandle is a templatized wrapper around DmElementHandle_t
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
template< class DmeType, HandleType_t HandleType = HT_WEAK >
|
||||
class CDmeHandle : public CDmeElementRefHelper
|
||||
{
|
||||
public:
|
||||
CDmeHandle() : m_handle( DMELEMENT_HANDLE_INVALID )
|
||||
{
|
||||
}
|
||||
|
||||
explicit CDmeHandle( CDmElement *pObject ) : m_handle( DMELEMENT_HANDLE_INVALID )
|
||||
{
|
||||
Set( pObject );
|
||||
}
|
||||
|
||||
CDmeHandle( DmElementHandle_t h ) : m_handle( DMELEMENT_HANDLE_INVALID )
|
||||
{
|
||||
Set( h );
|
||||
}
|
||||
|
||||
CDmeHandle( const CDmeHandle< DmeType, HandleType > &handle ) : m_handle( DMELEMENT_HANDLE_INVALID )
|
||||
{
|
||||
Set( handle.m_handle );
|
||||
}
|
||||
|
||||
template < class T, HandleType_t HT >
|
||||
CDmeHandle( const CDmeHandle< T, HT > &handle ) : m_handle( DMELEMENT_HANDLE_INVALID )
|
||||
{
|
||||
DmeType *p = ( T* )NULL; // triggers compiler error if converting from invalid handle type
|
||||
NOTE_UNUSED( p );
|
||||
|
||||
Set( handle.GetHandle() );
|
||||
}
|
||||
|
||||
~CDmeHandle()
|
||||
{
|
||||
if ( !g_pDataModel )
|
||||
return; // some handles are static, and don't get destroyed until program termination
|
||||
|
||||
Unref( m_handle, HandleType );
|
||||
}
|
||||
|
||||
template < class T, HandleType_t HT >
|
||||
CDmeHandle& operator=( const CDmeHandle< T, HT > &handle )
|
||||
{
|
||||
DmeType *p = ( T* )NULL; // triggers compiler error if converting from invalid handle type
|
||||
NOTE_UNUSED( p );
|
||||
|
||||
Set( handle.GetHandle() );
|
||||
return *this;
|
||||
}
|
||||
|
||||
DmeType *Get()
|
||||
{
|
||||
return static_cast< DmeType* >( g_pDataModel->GetElement( m_handle ) );
|
||||
}
|
||||
|
||||
const DmeType *Get() const
|
||||
{
|
||||
return static_cast< DmeType* >( g_pDataModel->GetElement( m_handle ) );
|
||||
}
|
||||
|
||||
DmElementHandle_t GetHandle() const
|
||||
{
|
||||
return m_handle;
|
||||
}
|
||||
|
||||
void Set( CDmElement *pObject )
|
||||
{
|
||||
Set( pObject ? pObject->GetHandle() : DMELEMENT_HANDLE_INVALID );
|
||||
}
|
||||
|
||||
void Set( DmElementHandle_t h )
|
||||
{
|
||||
if ( h == m_handle )
|
||||
return;
|
||||
|
||||
Unref( m_handle, HandleType );
|
||||
|
||||
m_handle = h;
|
||||
if ( h != DMELEMENT_HANDLE_INVALID )
|
||||
{
|
||||
CDmElement *pElement = g_pDataModel->GetElement( m_handle );
|
||||
Assert( pElement );
|
||||
if ( pElement && !pElement->IsA( DmeType::GetStaticTypeSymbol() ) )
|
||||
{
|
||||
m_handle = DMELEMENT_HANDLE_INVALID;
|
||||
}
|
||||
}
|
||||
|
||||
Ref( m_handle, HandleType );
|
||||
}
|
||||
|
||||
operator DmeType*()
|
||||
{
|
||||
return Get();
|
||||
}
|
||||
|
||||
operator const DmeType*() const
|
||||
{
|
||||
return Get();
|
||||
}
|
||||
|
||||
operator DmElementHandle_t() const
|
||||
{
|
||||
return m_handle;
|
||||
}
|
||||
|
||||
DmeType* operator->()
|
||||
{
|
||||
return Get();
|
||||
}
|
||||
|
||||
const DmeType* operator->() const
|
||||
{
|
||||
return Get();
|
||||
}
|
||||
|
||||
CDmeHandle& operator=( DmElementHandle_t h )
|
||||
{
|
||||
Set( h );
|
||||
return *this;
|
||||
}
|
||||
|
||||
CDmeHandle& operator=( CDmElement *pObject )
|
||||
{
|
||||
Set( pObject );
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator==( const CDmeHandle< DmeType > &h ) const
|
||||
{
|
||||
return m_handle == h.m_handle;
|
||||
}
|
||||
|
||||
bool operator!=( const CDmeHandle< DmeType > &h ) const
|
||||
{
|
||||
return !operator==( h );
|
||||
}
|
||||
|
||||
bool operator<( const CDmeHandle< DmeType > &h ) const
|
||||
{
|
||||
return m_handle < h.m_handle;
|
||||
}
|
||||
|
||||
bool operator==( DmeType *pObject ) const
|
||||
{
|
||||
DmElementHandle_t h = pObject ? pObject->GetHandle() : DMELEMENT_HANDLE_INVALID;
|
||||
return m_handle == h;
|
||||
}
|
||||
|
||||
bool operator!=( DmeType *pObject ) const
|
||||
{
|
||||
return !operator==( pObject );
|
||||
}
|
||||
|
||||
bool operator==( DmElementHandle_t h ) const
|
||||
{
|
||||
return ( m_handle == h );
|
||||
}
|
||||
|
||||
bool operator!=( DmElementHandle_t h ) const
|
||||
{
|
||||
return ( m_handle != h );
|
||||
}
|
||||
|
||||
operator bool() const
|
||||
{
|
||||
return ( Get() != NULL );
|
||||
}
|
||||
|
||||
bool operator!() const
|
||||
{
|
||||
return ( Get() == NULL );
|
||||
}
|
||||
|
||||
private:
|
||||
DmElementHandle_t m_handle;
|
||||
};
|
||||
|
||||
typedef CDmeHandle< CDmElement, HT_STRONG > CDmeCountedHandle;
|
||||
typedef CDmeHandle< CDmElement, HT_UNDO > CDmeUndoHandle;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Vector of element handles
|
||||
//-----------------------------------------------------------------------------
|
||||
typedef CUtlVector< CDmeHandle<CDmElement> > DmeHandleVec_t;
|
||||
|
||||
// NOTE: these methods only append, so if there is already data in the list, it will remain
|
||||
template< typename T >
|
||||
inline void ConvertHandleToPtrVector( const CUtlVector< CDmeHandle< T > > &in, CUtlVector< T * > &out )
|
||||
{
|
||||
int c = in.Count();
|
||||
for ( int i = 0; i < c; ++i )
|
||||
{
|
||||
out.AddToTail( in[ i ].Get() );
|
||||
}
|
||||
}
|
||||
|
||||
template< typename T >
|
||||
inline void ConvertPtrToHandleVector( const CUtlVector< T * > &in, CUtlVector< CDmeHandle< T > > &out )
|
||||
{
|
||||
int c = in.Count();
|
||||
for ( int i = 0; i < c; ++i )
|
||||
{
|
||||
out.AddToTail( CDmeHandle< T >( in[ i ] ) );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// helper class for undo classes to allow them to hold onto refcounted element handles
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
template< typename T >
|
||||
class CDmAttributeUndoStorageType
|
||||
{
|
||||
public:
|
||||
typedef T UndoStorageType;
|
||||
};
|
||||
|
||||
template<>
|
||||
class CDmAttributeUndoStorageType< DmElementHandle_t >
|
||||
{
|
||||
public:
|
||||
typedef CDmeUndoHandle UndoStorageType;
|
||||
};
|
||||
|
||||
template<>
|
||||
class CDmAttributeUndoStorageType< CUtlVector< DmElementHandle_t > >
|
||||
{
|
||||
public:
|
||||
typedef CUtlVector< CDmeUndoHandle > UndoStorageType;
|
||||
};
|
||||
|
||||
#endif // DMEHANDLE_H
|
||||
1210
public/datamodel/dmelement.h
Normal file
1210
public/datamodel/dmelement.h
Normal file
File diff suppressed because it is too large
Load Diff
248
public/datamodel/dmelementfactoryhelper.h
Normal file
248
public/datamodel/dmelementfactoryhelper.h
Normal file
@ -0,0 +1,248 @@
|
||||
//====== Copyright <20> 1996-2004, Valve Corporation, All rights reserved. =======
|
||||
//http://www.nfl.com/gamecenter/2010010900/2009/POST18/eagles@cowboys#tab:watch
|
||||
// Purpose:
|
||||
//
|
||||
//=============================================================================
|
||||
|
||||
#ifndef DMELEMENTFACTORYHELPER_H
|
||||
#define DMELEMENTFACTORYHELPER_H
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include "datamodel/idatamodel.h"
|
||||
#include "datamodel/dmelement.h"
|
||||
#include "datamodel/dmattribute.h"
|
||||
#include "datamodel/dmattributevar.h"
|
||||
#include "tier1/utlvector.h"
|
||||
#include "tier1/utlsymbollarge.h"
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Internal interface for IDmElementFactory
|
||||
//-----------------------------------------------------------------------------
|
||||
class CDmElementFactoryInternal : public IDmElementFactory
|
||||
{
|
||||
public:
|
||||
virtual void SetElementTypeSymbol( CUtlSymbolLarge sym ) = 0;
|
||||
virtual bool IsAbstract() const = 0;
|
||||
|
||||
virtual CUtlSymbolLarge GetElementTypeSymbol() const = 0;
|
||||
virtual CUtlSymbolLarge GetParentElementTypeSymbol() const = 0;
|
||||
|
||||
virtual void AddOnElementCreatedCallback( IDmeElementCreated *pCallback );
|
||||
virtual void RemoveOnElementCreatedCallback( IDmeElementCreated *pCallback );
|
||||
virtual void OnElementCreated( CDmElement* pElement );
|
||||
|
||||
private:
|
||||
CUtlVector< IDmeElementCreated* > m_CallBackList;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Class used to register factories into a global list
|
||||
//-----------------------------------------------------------------------------
|
||||
class CDmElementFactoryHelper
|
||||
{
|
||||
public:
|
||||
// Static list of helpers
|
||||
static CDmElementFactoryHelper *s_pHelpers[2];
|
||||
|
||||
// Create all the hud elements
|
||||
static void InstallFactories( );
|
||||
|
||||
public:
|
||||
// Construction
|
||||
CDmElementFactoryHelper( const char *pClassName, CDmElementFactoryInternal *pFactory, bool bIsStandardFactory );
|
||||
|
||||
// Accessors
|
||||
CDmElementFactoryHelper *GetNext () { return m_pNext; }
|
||||
CDmElementFactoryHelper *GetParent () { return m_pParent; }
|
||||
CDmElementFactoryHelper *GetChild () { return m_pChild; }
|
||||
CDmElementFactoryHelper *GetSibling() { return m_pSibling; }
|
||||
|
||||
const char *GetClassname();
|
||||
CDmElementFactoryInternal *GetFactory();
|
||||
|
||||
private:
|
||||
CDmElementFactoryHelper() {}
|
||||
|
||||
// Next factory in list
|
||||
CDmElementFactoryHelper *m_pNext;
|
||||
|
||||
// class hierarchy links
|
||||
CDmElementFactoryHelper *m_pParent;
|
||||
CDmElementFactoryHelper *m_pChild;
|
||||
CDmElementFactoryHelper *m_pSibling;
|
||||
|
||||
// Creation function to use for this technology
|
||||
CDmElementFactoryInternal *m_pFactory;
|
||||
const char *m_pszClassname;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Inline methods
|
||||
//-----------------------------------------------------------------------------
|
||||
inline const char *CDmElementFactoryHelper::GetClassname()
|
||||
{
|
||||
return m_pszClassname;
|
||||
}
|
||||
|
||||
inline CDmElementFactoryInternal *CDmElementFactoryHelper::GetFactory()
|
||||
{
|
||||
return m_pFactory;
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Helper Template factory for simple creation of factories
|
||||
//-----------------------------------------------------------------------------
|
||||
template < class T >
|
||||
class CDmElementFactory : public CDmElementFactoryInternal
|
||||
{
|
||||
public:
|
||||
CDmElementFactory( const char *pLookupName ) : m_pLookupName( pLookupName ) {}
|
||||
|
||||
// Creation, destruction
|
||||
virtual CDmElement* Create( DmElementHandle_t handle, const char *pElementType, const char *pElementName, DmFileId_t fileid, const DmObjectId_t &id )
|
||||
{
|
||||
return new T( handle, m_pLookupName, id, pElementName, fileid );
|
||||
}
|
||||
|
||||
virtual void Destroy( DmElementHandle_t hElement )
|
||||
{
|
||||
CDmElement *pElement = g_pDataModel->GetElement( hElement );
|
||||
if ( pElement )
|
||||
{
|
||||
T *pActualElement = static_cast< T* >( pElement );
|
||||
delete pActualElement;
|
||||
}
|
||||
}
|
||||
|
||||
// Sets the type symbol, used for "isa" implementation
|
||||
virtual void SetElementTypeSymbol( CUtlSymbolLarge sym )
|
||||
{
|
||||
T::SetTypeSymbol( sym );
|
||||
}
|
||||
|
||||
virtual bool IsAbstract() const { return false; }
|
||||
|
||||
virtual CUtlSymbolLarge GetElementTypeSymbol() const
|
||||
{
|
||||
return T::GetStaticTypeSymbol();
|
||||
}
|
||||
virtual CUtlSymbolLarge GetParentElementTypeSymbol() const
|
||||
{
|
||||
CUtlSymbolLarge baseClassSym = T::BaseClass::GetStaticTypeSymbol();
|
||||
if ( baseClassSym == T::GetStaticTypeSymbol() )
|
||||
return UTL_INVAL_SYMBOL_LARGE; // only CDmElement has itself as it's BaseClass - this lets us know we're at the top of the hierarchy
|
||||
return baseClassSym;
|
||||
}
|
||||
|
||||
private:
|
||||
const char *m_pLookupName;
|
||||
};
|
||||
|
||||
|
||||
template < class T >
|
||||
class CDmAbstractElementFactory : public CDmElementFactoryInternal
|
||||
{
|
||||
public:
|
||||
CDmAbstractElementFactory() {}
|
||||
|
||||
// Creation, destruction
|
||||
virtual CDmElement* Create( DmElementHandle_t handle, const char *pElementType, const char *pElementName, DmFileId_t fileid, const DmObjectId_t &id )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
virtual void Destroy( DmElementHandle_t hElement )
|
||||
{
|
||||
}
|
||||
|
||||
// Sets the type symbol, used for "isa" implementation
|
||||
virtual void SetElementTypeSymbol( CUtlSymbolLarge sym )
|
||||
{
|
||||
T::SetTypeSymbol( sym );
|
||||
}
|
||||
|
||||
virtual bool IsAbstract() const { return true; }
|
||||
|
||||
virtual CUtlSymbolLarge GetElementTypeSymbol() const
|
||||
{
|
||||
return T::GetStaticTypeSymbol();
|
||||
}
|
||||
virtual CUtlSymbolLarge GetParentElementTypeSymbol() const
|
||||
{
|
||||
CUtlSymbolLarge baseClassSym = T::BaseClass::GetStaticTypeSymbol();
|
||||
if ( baseClassSym == T::GetStaticTypeSymbol() )
|
||||
return UTL_INVAL_SYMBOL_LARGE; // only CDmElement has itself as it's BaseClass - this lets us know we're at the top of the hierarchy
|
||||
return baseClassSym;
|
||||
}
|
||||
|
||||
private:
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Helper macro to create the class factory
|
||||
//-----------------------------------------------------------------------------
|
||||
#if defined( MOVIEOBJECTS_LIB ) || defined ( DATAMODEL_LIB ) || defined ( DMECONTROLS_LIB ) || defined ( MDLOBJECTS_LIB )
|
||||
|
||||
#define IMPLEMENT_ELEMENT_FACTORY( lookupName, className ) \
|
||||
IMPLEMENT_ELEMENT( className ) \
|
||||
CDmElementFactory< className > g_##className##_Factory( #lookupName ); \
|
||||
CDmElementFactoryHelper g_##className##_Helper( #lookupName, &g_##className##_Factory, true ); \
|
||||
className *g_##className##LinkerHack = NULL;
|
||||
|
||||
#define IMPLEMENT_ABSTRACT_ELEMENT( lookupName, className ) \
|
||||
IMPLEMENT_ELEMENT( className ) \
|
||||
CDmAbstractElementFactory< className > g_##className##_Factory; \
|
||||
CDmElementFactoryHelper g_##className##_Helper( #lookupName, &g_##className##_Factory, true ); \
|
||||
className *g_##className##LinkerHack = NULL;
|
||||
|
||||
#else
|
||||
|
||||
#define IMPLEMENT_ELEMENT_FACTORY( lookupName, className ) \
|
||||
IMPLEMENT_ELEMENT( className ) \
|
||||
CDmElementFactory< className > g_##className##_Factory( #lookupName ); \
|
||||
CDmElementFactoryHelper g_##className##_Helper( #lookupName, &g_##className##_Factory, false ); \
|
||||
className *g_##className##LinkerHack = NULL;
|
||||
|
||||
#define IMPLEMENT_ABSTRACT_ELEMENT( lookupName, className ) \
|
||||
IMPLEMENT_ELEMENT( className ) \
|
||||
CDmAbstractElementFactory< className > g_##className##_Factory; \
|
||||
CDmElementFactoryHelper g_##className##_Helper( #lookupName, &g_##className##_Factory, false ); \
|
||||
className *g_##className##LinkerHack = NULL;
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
// Used by classes defined in movieobjects or scenedatabase that must be explicitly installed
|
||||
#define IMPLEMENT_ELEMENT_FACTORY_INSTALL_EXPLICITLY( lookupName, className ) \
|
||||
IMPLEMENT_ELEMENT( className ) \
|
||||
CDmElementFactory< className > g_##className##_Factory( #lookupName ); \
|
||||
CDmElementFactoryHelper g_##className##_Helper( #lookupName, &g_##className##_Factory, false ); \
|
||||
className *g_##className##LinkerHack = NULL;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Used to instantiate classes in libs from dlls/exes
|
||||
//-----------------------------------------------------------------------------
|
||||
#define USING_ELEMENT_FACTORY( className ) \
|
||||
extern C##className *g_##C##className##LinkerHack; \
|
||||
C##className *g_##C##className##PullInModule = g_##C##className##LinkerHack;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Installs dm element factories
|
||||
//-----------------------------------------------------------------------------
|
||||
void InstallDmElementFactories( );
|
||||
|
||||
|
||||
#endif // DMELEMENTFACTORYHELPER_H
|
||||
47
public/datamodel/dmelementhandle.h
Normal file
47
public/datamodel/dmelementhandle.h
Normal file
@ -0,0 +1,47 @@
|
||||
//====== Copyright <20> 1996-2004, Valve Corporation, All rights reserved. =======
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
//=============================================================================
|
||||
|
||||
#ifndef DMELEMENTHANDLE_H
|
||||
#define DMELEMENTHANDLE_H
|
||||
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// handle to an CDmElement
|
||||
//-----------------------------------------------------------------------------
|
||||
#define PERFORM_HANDLE_TYPECHECKING 0
|
||||
#if PERFORM_HANDLE_TYPECHECKING
|
||||
|
||||
// this is here to make sure we're being type-safe about element handles
|
||||
// otherwise, the compiler lets us cast to bool incorrectly
|
||||
// the other solution would be to redefine DmElementHandle_t s.t. DMELEMENT_HANDLE_INVALID==0
|
||||
struct DmElementHandle_t
|
||||
{
|
||||
DmElementHandle_t() : handle( 0xffffffff ) {}
|
||||
explicit DmElementHandle_t( int h ) : handle( h ) {}
|
||||
inline bool operator==( const DmElementHandle_t &h ) const { return handle == h.handle; }
|
||||
inline bool operator!=( const DmElementHandle_t &h ) const { return handle != h.handle; }
|
||||
inline bool operator<( const DmElementHandle_t &h ) const { return handle < h.handle; }
|
||||
// inline operator int() const { return handle; } // if we're okay with implicit int casts, uncomment this method
|
||||
int handle;
|
||||
};
|
||||
const DmElementHandle_t DMELEMENT_HANDLE_INVALID;
|
||||
|
||||
#else // PERFORM_HANDLE_TYPECHECKING
|
||||
|
||||
enum DmElementHandle_t
|
||||
{
|
||||
DMELEMENT_HANDLE_INVALID = 0xffffffff
|
||||
};
|
||||
|
||||
#endif // PERFORM_HANDLE_TYPECHECKING
|
||||
|
||||
|
||||
|
||||
#endif // DMELEMENTHANDLE_H
|
||||
95
public/datamodel/dmvar.h
Normal file
95
public/datamodel/dmvar.h
Normal file
@ -0,0 +1,95 @@
|
||||
//====== Copyright <20> 1996-2004, Valve Corporation, All rights reserved. =======
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
//=============================================================================
|
||||
|
||||
#ifndef DMVAR_H
|
||||
#define DMVAR_H
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
|
||||
class CDmAttribute;
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Helper template for external attributes
|
||||
//-----------------------------------------------------------------------------
|
||||
template< typename T >
|
||||
class CDmaVar
|
||||
{
|
||||
typedef typename CDmAttributeInfo< T >::StorageType_t D;
|
||||
|
||||
public:
|
||||
CDmaVar( );
|
||||
|
||||
// Setup to be used in OnConstruction methods of DmElements
|
||||
void Init( CDmElement *pOwner, const char *pAttributeName, int flags = 0 );
|
||||
void InitAndSet( CDmElement *pOwner, const char *pAttributeName, const T &value, int flags = 0 );
|
||||
|
||||
// Set/get
|
||||
const T& Set( const T &val );
|
||||
const T& Get() const;
|
||||
|
||||
// Cast operators
|
||||
operator const T&() const;
|
||||
const T* operator->() const;
|
||||
|
||||
// Assignment operator
|
||||
const CDmaVar<T>& operator=( const CDmaVar<T>& src );
|
||||
|
||||
// Math utility operations
|
||||
const T& operator=( const T &val );
|
||||
const T& operator+=( const T &val );
|
||||
const T& operator-=( const T &val );
|
||||
const T& operator/=( const T &val );
|
||||
const T& operator*=( const T &val );
|
||||
const T& operator^=( const T &val );
|
||||
const T& operator|=( const T &val );
|
||||
const T& operator&=( const T &val );
|
||||
T operator++();
|
||||
T operator--();
|
||||
T operator++( int ); // postfix version..
|
||||
T operator--( int ); // postfix version..
|
||||
|
||||
// Returns the attribute associated with the var
|
||||
CDmAttribute *GetAttribute();
|
||||
const CDmAttribute *GetAttribute() const;
|
||||
|
||||
// Is the attribute dirty?
|
||||
bool IsDirty() const;
|
||||
|
||||
protected:
|
||||
const T& Value() const;
|
||||
T& Value();
|
||||
const D& Storage() const;
|
||||
D& Storage();
|
||||
|
||||
private:
|
||||
D m_Storage;
|
||||
|
||||
protected:
|
||||
CDmAttribute *m_pAttribute;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Specialization for string
|
||||
//-----------------------------------------------------------------------------
|
||||
class CDmaString : public CDmaVar< CUtlSymbolLarge >
|
||||
{
|
||||
public:
|
||||
const char *Get( ) const;
|
||||
operator const char*() const;
|
||||
|
||||
void InitAndSet( CDmElement *pOwner, const char *pAttributeName, const char *pValue, int flags = 0 );
|
||||
void Set( const char *pValue );
|
||||
CDmaString &operator=( const char *src );
|
||||
const CDmaString& operator=( const CDmaString& src );
|
||||
|
||||
// Returns strlen
|
||||
int Length() const;
|
||||
bool IsEmpty() const;
|
||||
};
|
||||
|
||||
#endif // DMVAR_H
|
||||
942
public/datamodel/idatamodel.h
Normal file
942
public/datamodel/idatamodel.h
Normal file
@ -0,0 +1,942 @@
|
||||
//====== Copyright <20> 1996-2004, Valve Corporation, All rights reserved. =======
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
//=============================================================================
|
||||
|
||||
#ifndef IDATAMODEL_H
|
||||
#define IDATAMODEL_H
|
||||
#ifdef _WIN32
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include "tier1/interface.h"
|
||||
#include "tier1/utlvector.h"
|
||||
#include "tier1/utlsymbollarge.h"
|
||||
#include "appframework/IAppSystem.h"
|
||||
#include "datamodel/dmattributetypes.h"
|
||||
#include "datamodel/dmxheader.h"
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Forward declarations:
|
||||
//-----------------------------------------------------------------------------
|
||||
class CDmAttribute;
|
||||
class CDmElement;
|
||||
class IDmeOperator;
|
||||
class IElementForKeyValueCallback;
|
||||
class CDmElementFactoryHelper;
|
||||
|
||||
struct DmValueBase_t;
|
||||
class CUtlBuffer;
|
||||
class KeyValues;
|
||||
class CUtlCharConversion;
|
||||
class CElementIdHash;
|
||||
|
||||
// Use this for profiling dmx binary unserialization times
|
||||
//#define DMX_PROFILE_UNSERIALIZE 2
|
||||
// If you set it to 2, then SFM will exit(-1) right after the first session is loaded (so you can see the PROFILE_SCOPE counters)
|
||||
|
||||
#if defined( DMX_PROFILE_UNSERIALIZE )
|
||||
#define DMX_PROFILE_SCOPE( name ) PROFILE_SCOPE( name )
|
||||
#else
|
||||
#define DMX_PROFILE_SCOPE( name )
|
||||
#endif
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// element framework phases
|
||||
//-----------------------------------------------------------------------------
|
||||
enum DmPhase_t
|
||||
{
|
||||
PH_EDIT,
|
||||
PH_EDIT_APPLY,
|
||||
PH_EDIT_RESOLVE,
|
||||
PH_DEPENDENCY,
|
||||
PH_OPERATE,
|
||||
PH_OPERATE_RESOLVE,
|
||||
PH_OUTPUT,
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Handle to an CDmAttribute
|
||||
//-----------------------------------------------------------------------------
|
||||
enum DmAttributeHandle_t
|
||||
{
|
||||
DMATTRIBUTE_HANDLE_INVALID = 0xffffffff
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Handle to an DmAttributeList_t
|
||||
//-----------------------------------------------------------------------------
|
||||
enum DmAttributeReferenceIterator_t
|
||||
{
|
||||
DMATTRIBUTE_REFERENCE_ITERATOR_INVALID = 0
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// element framework interface
|
||||
//-----------------------------------------------------------------------------
|
||||
abstract_class IDmElementFramework : public IAppSystem
|
||||
{
|
||||
public:
|
||||
// Methods of IAppSystem
|
||||
virtual bool Connect( CreateInterfaceFn factory ) = 0;
|
||||
virtual void Disconnect() = 0;
|
||||
virtual void *QueryInterface( const char *pInterfaceName ) = 0;
|
||||
virtual InitReturnVal_t Init() = 0;
|
||||
virtual void Shutdown() = 0;
|
||||
|
||||
virtual DmPhase_t GetPhase() = 0;
|
||||
|
||||
virtual void SetOperators( const CUtlVector< IDmeOperator* > &operators ) = 0;
|
||||
|
||||
virtual void BeginEdit() = 0; // ends in edit phase, forces apply/resolve if from edit phase
|
||||
virtual void Operate( bool bResolve ) = 0; // ends in output phase
|
||||
virtual void Resolve() = 0;
|
||||
|
||||
virtual const CUtlVector< IDmeOperator* > &GetSortedOperators() const = 0;
|
||||
};
|
||||
|
||||
|
||||
|
||||
abstract_class IDmeElementCreated
|
||||
{
|
||||
public:
|
||||
virtual void OnElementCreated( CDmElement *pElement ) = 0;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Used only by aplpications to hook in the element framework
|
||||
//-----------------------------------------------------------------------------
|
||||
#define VDMELEMENTFRAMEWORK_VERSION "VDmElementFrameworkVersion001"
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Main interface
|
||||
//-----------------------------------------------------------------------------
|
||||
extern IDmElementFramework *g_pDmElementFramework;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// datamodel operator interface - for all elements that need to be sorted in the operator dependency graph
|
||||
//-----------------------------------------------------------------------------
|
||||
abstract_class IDmeOperator
|
||||
{
|
||||
public:
|
||||
virtual bool IsDirty() = 0; // ie needs to operate
|
||||
virtual void Operate() = 0;
|
||||
virtual const char* GetOperatorName() const { return "Unknown"; }
|
||||
|
||||
virtual void GetInputAttributes ( CUtlVector< CDmAttribute * > &attrs ) = 0;
|
||||
virtual void GetOutputAttributes( CUtlVector< CDmAttribute * > &attrs ) = 0;
|
||||
|
||||
virtual void SetSortKey( int key ) = 0;
|
||||
virtual int GetSortKey() const = 0;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Class factory methods:
|
||||
//-----------------------------------------------------------------------------
|
||||
class IDmElementFactory
|
||||
{
|
||||
public:
|
||||
// Creation, destruction
|
||||
virtual CDmElement* Create( DmElementHandle_t handle, const char *pElementType, const char *pElementName, DmFileId_t fileid, const DmObjectId_t &id ) = 0;
|
||||
virtual void Destroy( DmElementHandle_t hElement ) = 0;
|
||||
virtual void AddOnElementCreatedCallback( IDmeElementCreated *callback ) = 0;
|
||||
virtual void RemoveOnElementCreatedCallback( IDmeElementCreated *callback ) = 0;
|
||||
virtual void OnElementCreated( CDmElement* pElement ) = 0;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Various serialization methods can be installed into the data model factory
|
||||
//-----------------------------------------------------------------------------
|
||||
enum DmConflictResolution_t
|
||||
{
|
||||
CR_DELETE_NEW,
|
||||
CR_DELETE_OLD,
|
||||
CR_COPY_NEW,
|
||||
CR_FORCE_COPY,
|
||||
};
|
||||
|
||||
// convert files to elements and back
|
||||
// current file encodings supported: binary, keyvalues2, keyvalues2_flat, keyvalues (vmf/vmt/actbusy), text? (qc/obj)
|
||||
class IDmSerializer
|
||||
{
|
||||
public:
|
||||
virtual const char *GetName() const = 0;
|
||||
virtual const char *GetDescription() const = 0;
|
||||
virtual bool IsBinaryFormat() const = 0;
|
||||
virtual bool StoresVersionInFile() const = 0;
|
||||
virtual int GetCurrentVersion() const = 0;
|
||||
|
||||
// Write into the UtlBuffer, return true if successful
|
||||
// if we decide to implement non-identity conversions between formats on write, then the source and dest format will need to be passed in here
|
||||
virtual bool Serialize( CUtlBuffer &buf, CDmElement *pRoot ) = 0;
|
||||
|
||||
// Read from the UtlBuffer, return true if successful, and return the read-in root in ppRoot.
|
||||
virtual bool Unserialize( CUtlBuffer &buf, const char *pEncodingName, int nEncodingVersion,
|
||||
const char *pSourceFormatName, int nSourceFormatVersion,
|
||||
DmFileId_t fileid, DmConflictResolution_t idConflictResolution, CDmElement **ppRoot ) = 0;
|
||||
|
||||
// Methods used for importing (only should return non-NULL for serializers that return false from StoresVersionInFile)
|
||||
virtual const char *GetImportedFormat() const = 0;
|
||||
virtual int GetImportedVersion() const = 0;
|
||||
};
|
||||
|
||||
// convert legacy elements to non-legacy elements
|
||||
// legacy formats include: sfm_vN, binary_vN, keyvalues2_v1, keyvalues2_flat_v1
|
||||
// where N is a version number (1..9 for sfm, 1..2 for binary)
|
||||
class IDmLegacyUpdater
|
||||
{
|
||||
public:
|
||||
virtual const char *GetName() const = 0;
|
||||
virtual bool IsLatestVersion() const = 0;
|
||||
|
||||
// Updates ppRoot to first non-legacy generic dmx format, returns false if the conversion fails
|
||||
virtual bool Update( CDmElement **ppRoot ) = 0;
|
||||
};
|
||||
|
||||
// converts old elements to new elements
|
||||
// current formats include: sfm session, animset presets, particle definitions, exported maya character, etc.
|
||||
class IDmFormatUpdater
|
||||
{
|
||||
public:
|
||||
virtual const char *GetName() const = 0;
|
||||
virtual const char *GetDescription() const = 0;
|
||||
virtual const char *GetExtension() const = 0;
|
||||
virtual int GetCurrentVersion() const = 0;
|
||||
virtual const char *GetDefaultEncoding() const = 0;
|
||||
|
||||
// Converts pSourceRoot from nSourceVersion to the current version, returns false if the conversion fails
|
||||
virtual bool Update( CDmElement **pRoot, int nSourceVersion ) = 0;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Interface for callbacks to supply element types for specific keys inside keyvalues files
|
||||
//-----------------------------------------------------------------------------
|
||||
class IElementForKeyValueCallback
|
||||
{
|
||||
public:
|
||||
virtual const char *GetElementForKeyValue( const char *pszKeyName, int iNestingLevel ) = 0;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Optional helper passed in with clipboard data which is called when it's time to clean up the clipboard data in case the application
|
||||
// had some dynamically allocated data attached to a KV SetPtr object...
|
||||
//-----------------------------------------------------------------------------
|
||||
abstract_class IClipboardCleanup
|
||||
{
|
||||
public:
|
||||
virtual void ReleaseClipboardData( CUtlVector< KeyValues * >& list ) = 0;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Can be installed to be called back when data changes
|
||||
//-----------------------------------------------------------------------------
|
||||
enum DmNotifySource_t
|
||||
{
|
||||
// Sources
|
||||
NOTIFY_SOURCE_APPLICATION = 0,
|
||||
NOTIFY_SOURCE_UNDO,
|
||||
NOTIFY_SOURCE_FIRST_DME_CONTROL_SOURCE = 4, // Sources from dme_controls starts here
|
||||
NOTIFY_SOURCE_FIRST_APPLICATION_SOURCE = 8, // Sources from applications starts here
|
||||
};
|
||||
|
||||
enum DmNotifyFlags_t
|
||||
{
|
||||
// Does this dirty the document?
|
||||
NOTIFY_SOURCE_BITS = 8,
|
||||
NOTIFY_SETDIRTYFLAG = (1<<NOTIFY_SOURCE_BITS),
|
||||
|
||||
// Type of change (note NOTIFY_CHANGE_TOPOLOGICAL/NOTIFY_CHANGE_ATTRIBUTE_VALUE/NOTIFY_CHANGE_ATTRIBUTE_ARRAY_SIZE
|
||||
// are set by the Datamodel itself)
|
||||
NOTIFY_CHANGE_TOPOLOGICAL = (1<<(NOTIFY_SOURCE_BITS+4)), // Element created, destroyed, element attribute or element array attribute value changed
|
||||
NOTIFY_CHANGE_ATTRIBUTE_VALUE = (1<<(NOTIFY_SOURCE_BITS+5)), // Non-element attribute value changed
|
||||
NOTIFY_CHANGE_ATTRIBUTE_ARRAY_SIZE = (1<<(NOTIFY_SOURCE_BITS+6)), // Non-element array attribute added or removed
|
||||
NOTIFY_CHANGE_OTHER = (1<<(NOTIFY_SOURCE_BITS+7)), // Non attribute related change (a change in UI, for example)
|
||||
NOTIFY_FLAG_FIRST_APPLICATION_BIT = NOTIFY_SOURCE_BITS+8, // First bit # the app can use for its own notify flags
|
||||
|
||||
NOTIFY_CHANGE_MASK = ( NOTIFY_CHANGE_TOPOLOGICAL | NOTIFY_CHANGE_ATTRIBUTE_VALUE | NOTIFY_CHANGE_ATTRIBUTE_ARRAY_SIZE | NOTIFY_CHANGE_OTHER ),
|
||||
|
||||
};
|
||||
|
||||
abstract_class IDmNotify
|
||||
{
|
||||
public:
|
||||
// See DmNotifySource_t and DmNotifyFlags_t
|
||||
virtual void NotifyDataChanged( const char *pReason, int nNotifySource, int nNotifyFlags ) = 0;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Helper for debugging undo system
|
||||
//-----------------------------------------------------------------------------
|
||||
struct UndoInfo_t
|
||||
{
|
||||
bool terminator;
|
||||
const char *desc;
|
||||
const char *undo;
|
||||
const char *redo;
|
||||
int numoperations;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Interface for undo
|
||||
//-----------------------------------------------------------------------------
|
||||
abstract_class IUndoElement
|
||||
{
|
||||
public:
|
||||
virtual void Undo() = 0;
|
||||
virtual void Redo() = 0;
|
||||
|
||||
virtual const char *UndoDesc() const = 0;
|
||||
virtual const char *RedoDesc() const = 0;
|
||||
virtual const char *GetDesc() const = 0;
|
||||
virtual void Release() = 0;
|
||||
|
||||
protected:
|
||||
virtual bool IsEndOfStream() const = 0;
|
||||
virtual void SetEndOfStream( bool end ) = 0;
|
||||
virtual ~IUndoElement() { }
|
||||
|
||||
friend class CUndoManager;
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// traversal depth for copy, search, and other element/attribute traversals
|
||||
//-----------------------------------------------------------------------------
|
||||
enum TraversalDepth_t
|
||||
{
|
||||
TD_ALL, // traverse all attributes
|
||||
TD_DEEP, // traverse attributes with FATTRIB_NEVERCOPY clear
|
||||
TD_SHALLOW, // traverse attributes with FATTRIB_MUSTCOPY set
|
||||
TD_NONE, // don't traverse any attributes
|
||||
};
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Main interface for creation of all IDmeElements:
|
||||
//-----------------------------------------------------------------------------
|
||||
class IDataModel : public IAppSystem
|
||||
{
|
||||
public:
|
||||
// Installs factories used to instance elements
|
||||
virtual void AddElementFactory( CDmElementFactoryHelper *pFactoryHelper ) = 0;
|
||||
virtual CDmElementFactoryHelper *GetElementFactoryHelper( const char *pClassName ) = 0;
|
||||
|
||||
// This factory will be used to instance all elements whose type name isn't found.
|
||||
virtual void SetDefaultElementFactory( IDmElementFactory *pFactory ) = 0;
|
||||
|
||||
virtual int GetFirstFactory() const = 0;
|
||||
virtual int GetNextFactory( int index ) const = 0;
|
||||
virtual bool IsValidFactory( int index ) const = 0;
|
||||
virtual const char *GetFactoryName( int index ) const = 0;
|
||||
|
||||
// create/destroy element methods - proxies to installed element factories
|
||||
virtual DmElementHandle_t CreateElement( CUtlSymbolLarge typeSymbol, const char *pElementName, DmFileId_t fileid, const DmObjectId_t *pObjectID = NULL ) = 0;
|
||||
virtual DmElementHandle_t CreateElement( const char *pTypeName, const char *pElementName, DmFileId_t fileid, const DmObjectId_t *pObjectID = NULL ) = 0;
|
||||
virtual void DestroyElement( DmElementHandle_t hElement ) = 0;
|
||||
|
||||
// element handle related methods
|
||||
virtual CDmElement* GetElement ( DmElementHandle_t hElement ) const = 0;
|
||||
virtual CUtlSymbolLarge GetElementType ( DmElementHandle_t hElement ) const = 0;
|
||||
virtual const char* GetElementName ( DmElementHandle_t hElement ) const = 0;
|
||||
virtual const DmObjectId_t& GetElementId ( DmElementHandle_t hElement ) const = 0;
|
||||
|
||||
virtual const char* GetAttributeNameForType( DmAttributeType_t attType ) const = 0;
|
||||
virtual DmAttributeType_t GetAttributeTypeForName( const char *name ) const = 0;
|
||||
|
||||
// Adds various serializers and updaters
|
||||
virtual void AddSerializer( IDmSerializer *pSerializer ) = 0;
|
||||
virtual void AddLegacyUpdater( IDmLegacyUpdater *pUpdater ) = 0;
|
||||
virtual void AddFormatUpdater( IDmFormatUpdater *pUpdater ) = 0;
|
||||
|
||||
// file format methods
|
||||
virtual const char* GetFormatExtension( const char *pFormatName ) = 0;
|
||||
virtual const char* GetFormatDescription( const char *pFormatName ) = 0;
|
||||
virtual int GetFormatCount() const = 0;
|
||||
virtual const char * GetFormatName( int i ) const = 0;
|
||||
virtual const char * GetDefaultEncoding( const char *pFormatName ) = 0;
|
||||
|
||||
// file encoding methods
|
||||
virtual int GetEncodingCount() const = 0;
|
||||
virtual const char * GetEncodingName( int i ) const = 0;
|
||||
virtual bool IsEncodingBinary( const char *pEncodingName ) const = 0;
|
||||
virtual bool DoesEncodingStoreVersionInFile( const char *pEncodingName ) const = 0;
|
||||
|
||||
// For serialization, set the delimiter rules
|
||||
// These methods are meant to be used by importer/exporters
|
||||
virtual void SetSerializationDelimiter( CUtlCharConversion *pConv ) = 0;
|
||||
virtual void SetSerializationArrayDelimiter( const char *pDelimiter ) = 0;
|
||||
|
||||
// used to skip auto-creation of child elements during unserialization
|
||||
virtual bool IsUnserializing() = 0;
|
||||
|
||||
// Serialization of a element tree into a utlbuffer
|
||||
virtual bool Serialize( CUtlBuffer &outBuf, const char *pEncodingName, const char *pFormatName, DmElementHandle_t hRoot ) = 0;
|
||||
|
||||
// Unserializes, returns the root of the unserialized tree in hRoot
|
||||
// The file name passed in is simply for error messages and fileid creation
|
||||
virtual bool Unserialize( CUtlBuffer &inBuf, const char *pEncodingName, const char *pRequiredFormat, const char *pUnused,
|
||||
const char *pFileName, DmConflictResolution_t idConflictResolution, DmElementHandle_t &hRoot ) = 0;
|
||||
|
||||
// converts from elements from old file formats to elements for the current file format
|
||||
virtual bool UpdateUnserializedElements( const char *pSourceFormatName, int nSourceFormatVersion,
|
||||
DmFileId_t fileid, DmConflictResolution_t idConflictResolution, CDmElement **ppRoot ) = 0;
|
||||
|
||||
// force creation of untyped elements, ignoring type
|
||||
virtual void OnlyCreateUntypedElements( bool bEnable ) = 0;
|
||||
|
||||
// Finds a serializer by name
|
||||
virtual IDmSerializer* FindSerializer( const char *pEncodingName ) const = 0;
|
||||
virtual IDmLegacyUpdater* FindLegacyUpdater( const char *pLegacyFormatName ) const = 0;
|
||||
virtual IDmFormatUpdater* FindFormatUpdater( const char *pFormatName ) const = 0;
|
||||
|
||||
// saves element tree to a file
|
||||
virtual bool SaveToFile( const char *pFileName, const char *pPathID, const char *pEncodingName, const char *pFormatName, CDmElement *pRoot ) = 0;
|
||||
|
||||
// restores file into an element tree
|
||||
// NOTE: Format name is only used here for those formats which don't store
|
||||
// the format name in the file. Use NULL for those formats which store the
|
||||
// format name in the file.
|
||||
virtual DmFileId_t RestoreFromFile( const char *pFileName, const char *pPathID, const char *pEncodingHint, CDmElement **ppRoot, DmConflictResolution_t idConflictResolution = CR_DELETE_NEW, DmxHeader_t *pHeaderOut = NULL ) = 0;
|
||||
|
||||
// Sets the name of the DME element to create in keyvalues serialization
|
||||
virtual void SetKeyValuesElementCallback( IElementForKeyValueCallback *pCallbackInterface ) = 0;
|
||||
virtual const char *GetKeyValuesElementName( const char *pszKeyName, int iNestingLevel ) = 0;
|
||||
|
||||
// Global symbol table for the datamodel system
|
||||
virtual CUtlSymbolLarge GetSymbol( const char *pString ) = 0;
|
||||
// Once you have a CUtlSymbolLarge, don't need an external API to get the char *, just use the String() method.
|
||||
|
||||
// Returns the total number of elements allocated at the moment
|
||||
virtual int GetMaxNumberOfElements() = 0;
|
||||
virtual int GetElementsAllocatedSoFar() = 0;
|
||||
virtual int GetAllocatedAttributeCount() = 0;
|
||||
virtual int GetAllocatedElementCount() = 0;
|
||||
virtual DmElementHandle_t FirstAllocatedElement() = 0;
|
||||
virtual DmElementHandle_t NextAllocatedElement( DmElementHandle_t it ) = 0;
|
||||
|
||||
// estimate memory usage
|
||||
virtual int EstimateMemoryUsage( DmElementHandle_t hElement, TraversalDepth_t depth ) = 0;
|
||||
|
||||
// Undo/Redo support
|
||||
virtual void SetUndoEnabled( bool enable ) = 0;
|
||||
virtual bool IsUndoEnabled() const = 0;
|
||||
virtual bool UndoEnabledForElement( const CDmElement *pElement ) const = 0;
|
||||
virtual bool IsDirty() const = 0;
|
||||
virtual bool CanUndo() const = 0;
|
||||
virtual bool CanRedo() const = 0;
|
||||
// If chaining ID is != 0 and the next StartUndo uses the same ID, then the operations will be chained together into a single undo operation
|
||||
virtual void StartUndo( char const *undodesc, char const *redodesc, int nChainingID = 0 ) = 0;
|
||||
virtual void FinishUndo() = 0;
|
||||
virtual void AbortUndoableOperation() = 0; // called instead of FinishUndo, essentially performs and Undo() and WipeRedo() if any undo items have been added to the stack
|
||||
virtual void ClearRedo() = 0;
|
||||
virtual const char *GetUndoDesc() = 0;
|
||||
virtual const char *GetRedoDesc() = 0;
|
||||
// From the UI, perform the Undo operation
|
||||
virtual void Undo() = 0;
|
||||
virtual void Redo() = 0;
|
||||
virtual void TraceUndo( bool state ) = 0; // if true, undo records spew as they are added
|
||||
|
||||
// Wipes out all Undo data
|
||||
virtual void ClearUndo() = 0;
|
||||
|
||||
virtual void GetUndoInfo( CUtlVector< UndoInfo_t >& list ) = 0;
|
||||
|
||||
virtual void AddUndoElement( IUndoElement *pElement ) = 0;
|
||||
virtual CUtlSymbolLarge GetUndoDescInternal( const char *context ) = 0;
|
||||
virtual CUtlSymbolLarge GetRedoDescInternal( const char *context ) = 0;
|
||||
|
||||
virtual void EmptyClipboard() = 0;
|
||||
virtual void SetClipboardData( CUtlVector< KeyValues * >& data, IClipboardCleanup *pfnOptionalCleanuFunction = 0 ) = 0;
|
||||
virtual void AddToClipboardData( KeyValues *add ) = 0;
|
||||
virtual void GetClipboardData( CUtlVector< KeyValues * >& data ) = 0;
|
||||
virtual bool HasClipboardData() const = 0;
|
||||
|
||||
// Handles to attributes
|
||||
virtual CDmAttribute * GetAttribute( DmAttributeHandle_t h ) = 0;
|
||||
virtual bool IsAttributeHandleValid( DmAttributeHandle_t h ) const = 0;
|
||||
|
||||
// file id reference methods
|
||||
virtual int NumFileIds() = 0;
|
||||
virtual DmFileId_t GetFileId( int i ) = 0;
|
||||
virtual DmFileId_t FindOrCreateFileId( const char *pFilename ) = 0;
|
||||
virtual void RemoveFileId( DmFileId_t fileid ) = 0;
|
||||
virtual DmFileId_t GetFileId( const char *pFilename ) = 0;
|
||||
virtual const char * GetFileName( DmFileId_t fileid ) = 0;
|
||||
virtual void SetFileName( DmFileId_t fileid, const char *pFileName ) = 0;
|
||||
virtual const char * GetFileFormat( DmFileId_t fileid ) = 0;
|
||||
virtual void SetFileFormat( DmFileId_t fileid, const char *pFormat ) = 0;
|
||||
virtual DmElementHandle_t GetFileRoot( DmFileId_t fileid ) = 0;
|
||||
virtual void SetFileRoot( DmFileId_t fileid, DmElementHandle_t hRoot ) = 0;
|
||||
virtual long GetFileModificationUTCTime( DmFileId_t fileid ) = 0;
|
||||
virtual long GetCurrentUTCTime() = 0;
|
||||
virtual void UTCTimeToString( char *pString, int maxChars, long fileTime ) = 0;
|
||||
virtual bool IsFileLoaded( DmFileId_t fileid ) = 0;
|
||||
virtual void MarkFileLoaded( DmFileId_t fileid ) = 0;
|
||||
virtual void UnloadFile( DmFileId_t fileid ) = 0;
|
||||
virtual int NumElementsInFile( DmFileId_t fileid ) = 0;
|
||||
|
||||
virtual void DontAutoDelete( DmElementHandle_t hElement ) = 0;
|
||||
|
||||
// handle validity methods - these shouldn't really be here, but the undo system needs them...
|
||||
virtual void MarkHandleInvalid( DmElementHandle_t hElement ) = 0;
|
||||
virtual void MarkHandleValid( DmElementHandle_t hElement ) = 0;
|
||||
|
||||
virtual DmElementHandle_t FindElement( const DmObjectId_t &id ) = 0;
|
||||
virtual void GetExistingElements( CElementIdHash &hash ) const = 0;
|
||||
|
||||
virtual DmAttributeReferenceIterator_t FirstAttributeReferencingElement( DmElementHandle_t hElement ) = 0;
|
||||
virtual DmAttributeReferenceIterator_t NextAttributeReferencingElement( DmAttributeReferenceIterator_t hAttrIter ) = 0;
|
||||
virtual CDmAttribute * GetAttribute( DmAttributeReferenceIterator_t hAttrIter ) = 0;
|
||||
|
||||
// Install, remove notify callbacks associated w/ undo contexts
|
||||
virtual bool InstallNotificationCallback( IDmNotify *pNotify ) = 0;
|
||||
virtual void RemoveNotificationCallback( IDmNotify *pNotify ) = 0;
|
||||
virtual bool IsSuppressingNotify( ) const = 0;
|
||||
virtual void SetSuppressingNotify( bool bSuppress ) = 0;
|
||||
virtual void PushNotificationScope( const char *pReason, int nNotifySource, int nNotifyFlags ) = 0;
|
||||
virtual void PopNotificationScope( bool bAbort = false ) = 0;
|
||||
virtual const char *GetUndoString( CUtlSymbolLarge sym ) = 0;
|
||||
|
||||
virtual bool HasElementFactory( const char *pElementType ) const = 0;
|
||||
|
||||
// Call before you make any undo records
|
||||
virtual void SetUndoDepth( int nSize ) = 0;
|
||||
|
||||
// Displays memory stats to the console (passing in invalid handle causes memory for all elements to be estimated, otherwise it's only
|
||||
// the element and it's recursive children)
|
||||
virtual void DisplayMemoryStats( DmElementHandle_t hElement = DMELEMENT_HANDLE_INVALID ) = 0;
|
||||
|
||||
// Is this file a DMX file?
|
||||
virtual bool IsDMXFormat( CUtlBuffer &buf ) const = 0;
|
||||
|
||||
// Dump the symbol table to the console
|
||||
virtual void DumpSymbolTable() = 0;
|
||||
|
||||
virtual void AddOnElementCreatedCallback( const char *pElementType, IDmeElementCreated *callback ) = 0;
|
||||
virtual void RemoveOnElementCreatedCallback( const char *pElementType, IDmeElementCreated *callback ) = 0;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Used only by applications to hook in the data model
|
||||
//-----------------------------------------------------------------------------
|
||||
#define VDATAMODEL_INTERFACE_VERSION "VDataModelVersion001"
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Main interface accessor
|
||||
//-----------------------------------------------------------------------------
|
||||
extern IDataModel *g_pDataModel;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Allows clients to implement customized undo elements
|
||||
//-----------------------------------------------------------------------------
|
||||
class CUndoElement : public IUndoElement
|
||||
{
|
||||
public:
|
||||
CUndoElement( const char *pDesc )
|
||||
{
|
||||
m_UndoDesc = g_pDataModel->GetUndoDescInternal( pDesc );
|
||||
m_RedoDesc = g_pDataModel->GetRedoDescInternal( pDesc );
|
||||
m_pDesc = pDesc;
|
||||
m_bEndOfStream = false;
|
||||
}
|
||||
|
||||
virtual void Release()
|
||||
{
|
||||
delete this;
|
||||
}
|
||||
|
||||
virtual const char *UndoDesc() const
|
||||
{
|
||||
return g_pDataModel->GetUndoString( m_UndoDesc );
|
||||
}
|
||||
|
||||
virtual const char *RedoDesc() const
|
||||
{
|
||||
return g_pDataModel->GetUndoString( m_RedoDesc );
|
||||
}
|
||||
|
||||
virtual const char *GetDesc() const
|
||||
{
|
||||
return m_pDesc;
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual bool IsEndOfStream() const
|
||||
{
|
||||
return m_bEndOfStream;
|
||||
}
|
||||
|
||||
virtual void SetEndOfStream( bool end )
|
||||
{
|
||||
m_bEndOfStream = end;
|
||||
}
|
||||
|
||||
const char *m_pDesc;
|
||||
CUtlSymbolLarge m_UndoDesc;
|
||||
CUtlSymbolLarge m_RedoDesc;
|
||||
bool m_bEndOfStream;
|
||||
|
||||
private:
|
||||
friend class CUndoManager;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Simple helper class
|
||||
//-----------------------------------------------------------------------------
|
||||
class CUndoScopeGuard
|
||||
{
|
||||
public:
|
||||
explicit CUndoScopeGuard( const char *udesc, const char *rdesc = NULL )
|
||||
{
|
||||
m_bReleased = false;
|
||||
m_bNotify = false;
|
||||
m_pNotify = NULL;
|
||||
g_pDataModel->StartUndo( udesc, rdesc ? rdesc : udesc );
|
||||
}
|
||||
|
||||
explicit CUndoScopeGuard( int nChainingID, char const *udesc )
|
||||
{
|
||||
m_bReleased = false;
|
||||
m_bNotify = false;
|
||||
m_pNotify = NULL;
|
||||
g_pDataModel->StartUndo( udesc, udesc, nChainingID );
|
||||
}
|
||||
|
||||
explicit CUndoScopeGuard( int nNotifySource, int nNotifyFlags, const char *udesc, const char *rdesc = NULL, int nChainingID = 0 )
|
||||
{
|
||||
m_bReleased = false;
|
||||
m_bNotify = true;
|
||||
m_pNotify = NULL;
|
||||
g_pDataModel->StartUndo( udesc, rdesc ? rdesc : udesc, nChainingID );
|
||||
g_pDataModel->PushNotificationScope( udesc, nNotifySource, nNotifyFlags );
|
||||
}
|
||||
|
||||
explicit CUndoScopeGuard( int nNotifySource, int nNotifyFlags, IDmNotify *pNotify, const char *udesc, const char *rdesc = NULL, int nChainingID = 0 )
|
||||
{
|
||||
m_bReleased = false;
|
||||
m_bNotify = true;
|
||||
m_pNotify = NULL;
|
||||
g_pDataModel->StartUndo( udesc, rdesc ? rdesc : udesc, nChainingID );
|
||||
if ( pNotify )
|
||||
{
|
||||
if ( g_pDataModel->InstallNotificationCallback( pNotify ) )
|
||||
{
|
||||
m_pNotify = pNotify;
|
||||
}
|
||||
}
|
||||
g_pDataModel->PushNotificationScope( udesc, nNotifySource, nNotifyFlags );
|
||||
}
|
||||
|
||||
~CUndoScopeGuard()
|
||||
{
|
||||
Release();
|
||||
}
|
||||
|
||||
void Release()
|
||||
{
|
||||
if ( !m_bReleased )
|
||||
{
|
||||
g_pDataModel->FinishUndo();
|
||||
if ( m_bNotify )
|
||||
{
|
||||
g_pDataModel->PopNotificationScope( );
|
||||
m_bNotify = false;
|
||||
}
|
||||
if ( m_pNotify )
|
||||
{
|
||||
g_pDataModel->RemoveNotificationCallback( m_pNotify );
|
||||
m_pNotify = NULL;
|
||||
}
|
||||
m_bReleased = true;
|
||||
}
|
||||
}
|
||||
|
||||
void Abort()
|
||||
{
|
||||
if ( !m_bReleased )
|
||||
{
|
||||
g_pDataModel->AbortUndoableOperation();
|
||||
if ( m_bNotify )
|
||||
{
|
||||
g_pDataModel->PopNotificationScope( true );
|
||||
m_bNotify = false;
|
||||
}
|
||||
if ( m_pNotify )
|
||||
{
|
||||
g_pDataModel->RemoveNotificationCallback( m_pNotify );
|
||||
m_pNotify = NULL;
|
||||
}
|
||||
m_bReleased = true;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
IDmNotify *m_pNotify;
|
||||
bool m_bReleased;
|
||||
bool m_bNotify;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Simple helper class to disable Undo/Redo operations when in scope
|
||||
//-----------------------------------------------------------------------------
|
||||
class CChangeUndoScopeGuard
|
||||
{
|
||||
public:
|
||||
CChangeUndoScopeGuard( bool bNewState )
|
||||
{
|
||||
m_bReleased = false;
|
||||
m_bNotify = false;
|
||||
m_pNotify = NULL;
|
||||
m_bOldValue = g_pDataModel->IsUndoEnabled();
|
||||
g_pDataModel->SetUndoEnabled( bNewState );
|
||||
};
|
||||
|
||||
CChangeUndoScopeGuard( bool bNewState, const char *pDesc, int nNotifySource, int nNotifyFlags, IDmNotify *pNotify = NULL )
|
||||
{
|
||||
m_bReleased = false;
|
||||
m_bOldValue = g_pDataModel->IsUndoEnabled();
|
||||
g_pDataModel->SetUndoEnabled( bNewState );
|
||||
|
||||
m_bNotify = true;
|
||||
m_pNotify = NULL;
|
||||
if ( pNotify )
|
||||
{
|
||||
if ( g_pDataModel->InstallNotificationCallback( pNotify ) )
|
||||
{
|
||||
m_pNotify = pNotify;
|
||||
}
|
||||
}
|
||||
g_pDataModel->PushNotificationScope( pDesc, nNotifySource, nNotifyFlags );
|
||||
};
|
||||
|
||||
~CChangeUndoScopeGuard()
|
||||
{
|
||||
Release();
|
||||
}
|
||||
|
||||
void Release()
|
||||
{
|
||||
// Releases the guard...
|
||||
if ( !m_bReleased )
|
||||
{
|
||||
g_pDataModel->SetUndoEnabled( m_bOldValue );
|
||||
m_bReleased = true;
|
||||
if ( m_bNotify )
|
||||
{
|
||||
g_pDataModel->PopNotificationScope( );
|
||||
m_bNotify = false;
|
||||
}
|
||||
if ( m_pNotify )
|
||||
{
|
||||
g_pDataModel->RemoveNotificationCallback( m_pNotify );
|
||||
m_pNotify = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
IDmNotify *m_pNotify;
|
||||
bool m_bOldValue;
|
||||
bool m_bReleased;
|
||||
bool m_bNotify;
|
||||
};
|
||||
|
||||
class CDisableUndoScopeGuard : public CChangeUndoScopeGuard
|
||||
{
|
||||
typedef CChangeUndoScopeGuard BaseClass;
|
||||
|
||||
public:
|
||||
CDisableUndoScopeGuard() : BaseClass( false ) { }
|
||||
CDisableUndoScopeGuard( const char *pDesc, int nNotifySource, int nNotifyFlags, IDmNotify *pNotify = NULL ) :
|
||||
BaseClass( false, pDesc, nNotifySource, nNotifyFlags, pNotify ) {}
|
||||
};
|
||||
|
||||
class CEnableUndoScopeGuard : public CChangeUndoScopeGuard
|
||||
{
|
||||
typedef CChangeUndoScopeGuard BaseClass;
|
||||
|
||||
public:
|
||||
CEnableUndoScopeGuard( ) : BaseClass( true ) { }
|
||||
CEnableUndoScopeGuard( const char *pDesc, int nNotifySource, int nNotifyFlags, IDmNotify *pNotify = NULL ) :
|
||||
BaseClass( true, pDesc, nNotifySource, nNotifyFlags, pNotify ) {}
|
||||
};
|
||||
|
||||
|
||||
#define DEFINE_SOURCE_UNDO_SCOPE_GUARD( _classnameprefix, _source ) \
|
||||
class C ## _classnameprefix ## UndoScopeGuard : public CUndoScopeGuard \
|
||||
{ \
|
||||
typedef CUndoScopeGuard BaseClass; \
|
||||
\
|
||||
public: \
|
||||
C ## _classnameprefix ## UndoScopeGuard( int nNotifyFlags, const char *pUndoDesc, const char *pRedoDesc = NULL, int nChainingID = 0 ) : \
|
||||
BaseClass( _source, nNotifyFlags, pUndoDesc, pRedoDesc, nChainingID ) \
|
||||
{ \
|
||||
} \
|
||||
C ## _classnameprefix ## UndoScopeGuard( int nNotifyFlags, IDmNotify *pNotify, const char *pUndoDesc, const char *pRedoDesc = NULL, int nChainingID = 0 ) : \
|
||||
BaseClass( _source, nNotifyFlags, pNotify, pUndoDesc, pRedoDesc, nChainingID ) \
|
||||
{ \
|
||||
} \
|
||||
C ## _classnameprefix ## UndoScopeGuard( int nNotifyFlags, const char *pUndoDesc, int nChainingID ) : \
|
||||
BaseClass( _source, nNotifyFlags, pUndoDesc, pUndoDesc, nChainingID ) \
|
||||
{ \
|
||||
} \
|
||||
}; \
|
||||
class C ## _classnameprefix ## DisableUndoScopeGuard : public CDisableUndoScopeGuard \
|
||||
{ \
|
||||
typedef CDisableUndoScopeGuard BaseClass; \
|
||||
\
|
||||
public: \
|
||||
C ## _classnameprefix ## DisableUndoScopeGuard( const char *pDesc, int nNotifyFlags, IDmNotify *pNotify = NULL ) : \
|
||||
BaseClass( pDesc, _source, nNotifyFlags, pNotify ) \
|
||||
{ \
|
||||
} \
|
||||
}; \
|
||||
class C ## _classnameprefix ## EnableUndoScopeGuard : public CEnableUndoScopeGuard \
|
||||
{ \
|
||||
typedef CEnableUndoScopeGuard BaseClass; \
|
||||
\
|
||||
public: \
|
||||
C ## _classnameprefix ## EnableUndoScopeGuard( const char *pDesc, int nNotifyFlags, IDmNotify *pNotify = NULL ) : \
|
||||
BaseClass( pDesc, _source, nNotifyFlags, pNotify ) \
|
||||
{ \
|
||||
} \
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Simple helper class to disable NotifyDataChanged from current scope
|
||||
//-----------------------------------------------------------------------------
|
||||
class CNotifyScopeGuard
|
||||
{
|
||||
public:
|
||||
CNotifyScopeGuard( const char *pReason, int nNotifySource, int nNotifyFlags, IDmNotify *pNotify = NULL )
|
||||
{
|
||||
m_bReleased = false;
|
||||
m_pNotify = NULL;
|
||||
g_pDataModel->PushNotificationScope( pReason, nNotifySource, nNotifyFlags );
|
||||
if ( pNotify )
|
||||
{
|
||||
if ( g_pDataModel->InstallNotificationCallback( pNotify ) )
|
||||
{
|
||||
m_pNotify = pNotify;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
~CNotifyScopeGuard()
|
||||
{
|
||||
Release();
|
||||
}
|
||||
|
||||
void Release()
|
||||
{
|
||||
// Releases the guard...
|
||||
if ( !m_bReleased )
|
||||
{
|
||||
g_pDataModel->PopNotificationScope( );
|
||||
if ( m_pNotify )
|
||||
{
|
||||
g_pDataModel->RemoveNotificationCallback( m_pNotify );
|
||||
m_pNotify = NULL;
|
||||
}
|
||||
m_bReleased = true;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
CNotifyScopeGuard( const CNotifyScopeGuard& g );
|
||||
|
||||
private:
|
||||
IDmNotify *m_pNotify;
|
||||
bool m_bReleased;
|
||||
};
|
||||
|
||||
|
||||
#define DEFINE_SOURCE_NOTIFY_SCOPE_GUARD( _classnameprefix, _source ) \
|
||||
class C ## _classnameprefix ## NotifyScopeGuard : public CNotifyScopeGuard \
|
||||
{ \
|
||||
typedef CNotifyScopeGuard BaseClass; \
|
||||
\
|
||||
public: \
|
||||
C ## _classnameprefix ## NotifyScopeGuard( const char *pReason, int nNotifyFlags, IDmNotify *pNotify = NULL ) : \
|
||||
BaseClass( pReason, _source, nNotifyFlags, pNotify )\
|
||||
{ \
|
||||
} \
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: Simple helper class to disable notifications when in scope
|
||||
//-----------------------------------------------------------------------------
|
||||
class CChangeNotifyScopeGuard
|
||||
{
|
||||
public:
|
||||
CChangeNotifyScopeGuard( bool bNewState )
|
||||
{
|
||||
m_bReleased = false;
|
||||
m_bOldValue = g_pDataModel->IsSuppressingNotify();
|
||||
g_pDataModel->SetSuppressingNotify( bNewState );
|
||||
};
|
||||
|
||||
~CChangeNotifyScopeGuard()
|
||||
{
|
||||
Release();
|
||||
}
|
||||
|
||||
void Release()
|
||||
{
|
||||
// Releases the guard...
|
||||
if ( !m_bReleased )
|
||||
{
|
||||
g_pDataModel->SetSuppressingNotify( m_bOldValue );
|
||||
m_bReleased = true;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
bool m_bOldValue;
|
||||
bool m_bReleased;
|
||||
};
|
||||
|
||||
class CDisableNotifyScopeGuard : public CChangeNotifyScopeGuard
|
||||
{
|
||||
typedef CChangeNotifyScopeGuard BaseClass;
|
||||
|
||||
public:
|
||||
CDisableNotifyScopeGuard() : BaseClass( true ) { }
|
||||
|
||||
private:
|
||||
CDisableNotifyScopeGuard( const CDisableNotifyScopeGuard& g );
|
||||
};
|
||||
|
||||
class CEnableNotifyScopeGuard : public CChangeNotifyScopeGuard
|
||||
{
|
||||
typedef CChangeNotifyScopeGuard BaseClass;
|
||||
|
||||
public:
|
||||
CEnableNotifyScopeGuard( ) : BaseClass( false ) { }
|
||||
|
||||
private:
|
||||
CEnableNotifyScopeGuard( const CEnableNotifyScopeGuard& g );
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Standard undo/notify guards for the application
|
||||
//-----------------------------------------------------------------------------
|
||||
DEFINE_SOURCE_UNDO_SCOPE_GUARD( App, NOTIFY_SOURCE_APPLICATION );
|
||||
DEFINE_SOURCE_NOTIFY_SCOPE_GUARD( App, NOTIFY_SOURCE_APPLICATION );
|
||||
|
||||
|
||||
#endif // IDATAMODEL_H
|
||||
Reference in New Issue
Block a user