//========= Copyright 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/utlsymbol.h" #include "appframework/IAppSystem.h" #include "datamodel/dmattributetypes.h" //----------------------------------------------------------------------------- // Forward declarations: //----------------------------------------------------------------------------- class CDmAttribute; class CDmElement; class IDmeOperator; class IElementForKeyValueCallback; struct DmValueBase_t; class CUtlBuffer; class KeyValues; class CUtlSymbolTable; class CUtlCharConversion; //----------------------------------------------------------------------------- // data file format info //----------------------------------------------------------------------------- #define DMX_LEGACY_VERSION_STARTING_TOKEN "<!-- DMXVersion" #define DMX_LEGACY_VERSION_ENDING_TOKEN "-->" #define DMX_VERSION_STARTING_TOKEN "<!-- dmx" #define DMX_VERSION_ENDING_TOKEN "-->" #define GENERIC_DMX_FORMAT "dmx" enum { DMX_MAX_FORMAT_NAME_MAX_LENGTH = 64, DMX_MAX_HEADER_LENGTH = 40 + 2 * DMX_MAX_FORMAT_NAME_MAX_LENGTH, }; struct DmxHeader_t { char encodingName[ DMX_MAX_FORMAT_NAME_MAX_LENGTH ]; int nEncodingVersion; char formatName[ DMX_MAX_FORMAT_NAME_MAX_LENGTH ]; int nFormatVersion; DmxHeader_t() : nEncodingVersion( -1 ), nFormatVersion( -1 ) { encodingName[ 0 ] = formatName[ 0 ] = '\0'; } }; //----------------------------------------------------------------------------- // element framework phases //----------------------------------------------------------------------------- enum DmPhase_t { PH_EDIT, PH_EDIT_APPLY, PH_EDIT_RESOLVE, PH_DEPENDENCY, PH_OPERATE, PH_OPERATE_RESOLVE, PH_OUTPUT, }; //----------------------------------------------------------------------------- // file id - also used to refer to elements that don't have file associations //----------------------------------------------------------------------------- enum DmFileId_t { DMFILEID_INVALID = 0xffffffff }; //----------------------------------------------------------------------------- // 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; }; //----------------------------------------------------------------------------- // 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 void GetInputAttributes ( CUtlVector< CDmAttribute * > &attrs ) = 0; virtual void GetOutputAttributes( CUtlVector< CDmAttribute * > &attrs ) = 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; }; //----------------------------------------------------------------------------- // 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, xml, xml_flat, 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; }; // convert legacy elements to non-legacy elements // legacy formats include: sfm_vN, binary_vN, keyvalues2_v1, keyvalues2_flat_v1, xml, xml_flat // 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_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( const char *pElementTypeName, IDmElementFactory *pFactory ) = 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( UtlSymId_t typeSymbol, const char *pElementName, DmFileId_t fileid = DMFILEID_INVALID, const DmObjectId_t *pObjectID = NULL ) = 0; virtual DmElementHandle_t CreateElement( const char *pTypeName, const char *pElementName, DmFileId_t fileid = DMFILEID_INVALID, 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 UtlSymId_t 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 *pSourceFormatName, const char *pFormatHint, 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 *pFormatHint, 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 UtlSymId_t GetSymbol( const char *pString ) = 0; virtual const char * GetString( UtlSymId_t sym ) const = 0; // 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 UtlSymId_t GetUndoDescInternal( const char *context ) = 0; virtual UtlSymId_t 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 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 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( UtlSymId_t sym ) = 0; virtual bool HasElementFactory( const char *pElementType ) const = 0; // Call before you make any undo records virtual void SetUndoDepth( int nSize ) = 0; // Displats memory stats to the console virtual void DisplayMemoryStats() = 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; CUtlSymbol m_UndoDesc; CUtlSymbol 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