AcadObjectImpl.h

Go to the documentation of this file.

#pragma once
 
//
// (C) Copyright 2005-2024 by Graebert GmbH.
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted,
// provided that the above copyright notice appears in all copies and
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting
// documentation.
//
// GRAEBERT PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.
// GRAEBERT SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.  GRAEBERT GMBH
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
#include <comdef.h>
#include <comdefsp.h>
#include "./../axdb/Global Func.h"
#include "./../interfaces.h"
#include "./../acdb17/CAcAxOleLinkManager.h"
#ifdef _WIN64
#if FRX_MAJOR_VERSION >= 2024
#include "../_impl_include/include_x64/OdaX.h"
#else
#include "../_impl_include/include_x64/OdaX2.h"
#endif
#else
#if FRX_MAJOR_VERSION >= 2024
#include "../_impl_include/include_x86/OdaX.h"
#else
#include "../_impl_include/include_x86/OdaX2.h"
#endif
#endif
 
using namespace ATL;
template<class T>
class ATL_NO_VTABLE IOPMPropertyExtensionImpl
    : public ICategorizeProperties
    , public IPerPropertyBrowsing
    , public IOPMPropertyExtension
{
public:
    IOPMPropertyExtensionImpl( )
    {
    }
 
    virtual ~IOPMPropertyExtensionImpl( )
    {
    }
 
    virtual HINSTANCE GetResourceInstance( ) = 0;
 
    // ICategorizeProperties methods
    STDMETHODIMP MapPropertyToCategory( DISPID dispid , PROPCAT* ppropcat )
    {
        return ::AcOpmMapPropertyToCategory( reinterpret_cast<IUnknown*>( this ) , T::GetOPMPropertyMap( ) , dispid , ppropcat );
    }
 
    STDMETHODIMP GetCategoryName( PROPCAT propcat , LCID lcid , BSTR* pbstrName )
    {
        return ::AcOpmGetCategoryName( reinterpret_cast<IUnknown*>( this ) , GetResourceInstance( ) , T::GetOPMPropertyMap( ) , propcat , lcid , pbstrName );
    }
 
    // IPerPropertyBrowsing methods
    STDMETHODIMP GetDisplayString( DISPID dispID , BSTR *pBstr )
    {
        return ::AcOpmGetDisplayString( reinterpret_cast<IUnknown*>( this ) , T::GetOPMPropertyMap( ) , dispID , pBstr );
    }
 
    STDMETHODIMP MapPropertyToPage( DISPID dispID , CLSID *pClsid )
    {
        return ::AcOpmMapPropertyToPage( reinterpret_cast<IUnknown*>( this ) , T::GetOPMPropertyMap( ) , dispID , pClsid );
    }
 
    STDMETHODIMP GetPredefinedStrings( DISPID dispID , CALPOLESTR *pCaStringsOut , CADWORD *pCaCookiesOut )
    {
        return ::AcOpmGetPredefinedStrings( reinterpret_cast<IUnknown*>( this ) , GetResourceInstance( ) , T::GetOPMPropertyMap( ) , dispID , pCaStringsOut , pCaCookiesOut );
    }
 
    STDMETHODIMP GetPredefinedValue( DISPID dispID , DWORD dwCookie , VARIANT *pVarOut )
    {
        return ::AcOpmGetPredefinedValue( reinterpret_cast<IUnknown*>( this ) , T::GetOPMPropertyMap( ) , dispID , dwCookie , pVarOut );
    }
 
    // IOPMPropertyExtension methods
    STDMETHODIMP GetDisplayName( DISPID dispID , BSTR *pBstr )
    {
        return ::AcOpmGetDisplayName( reinterpret_cast<IUnknown*>( this ) , GetResourceInstance( ) , T::GetOPMPropertyMap( ) , dispID , pBstr );
    }
 
    STDMETHODIMP Editable(/*[in]*/ DISPID dispID , /*[out]*/ BOOL __RPC_FAR *bEditable )
    {
        return ::AcOpmEditable( reinterpret_cast<IUnknown*>( this ) , T::GetOPMPropertyMap( ) , dispID , bEditable );
    }
 
    STDMETHODIMP ShowProperty(/*[in]*/ DISPID dispID , /*[out]*/ BOOL *pShow )
    {
        return ::AcOpmShowProperty( reinterpret_cast<IUnknown*>( this ) , T::GetOPMPropertyMap( ) , dispID , pShow );
    }
};
 
#define ICategorizeProperties2Impl IAcPiCategorizePropertiesImpl
template<class T>
class ATL_NO_VTABLE IAcPiCategorizePropertiesImpl :
    public IAcPiCategorizeProperties
{
public:
    CATEGORY_VECTOR  m_CategoryVector;
    CATCMDBTN_VECTOR m_CatCmdBtnVector;
 
    CATEGORY_VECTOR & GetCategoryVector( )
    {
        return m_CategoryVector;
    }
 
    CATCMDBTN_VECTOR & GetCmdBtnVector( )
    {
        return m_CatCmdBtnVector;
    }
 
    bool IsDefaultCategoryEntry( CATEGORY_ENTRY in )
    {
        if ( in.m_CatID != -1 )
            return false;
 
        if ( in.m_nWeight != -1 )
            return false;
 
        if ( in.m_ParentCatID != -1 )
            return false;
 
        if ( in.m_nDescId != 0 )
            return false;
 
        if ( in.m_nNameId != 0 )
            return false;
 
        return true;
    }
 
    bool IsDefaultCmdBtnEntry( CATCMDBTN_ENTRY in )
    {
        if ( in.m_CatID != -1 )
            return false;
 
        if ( in.m_lpEnBtnBmpRes != NULL )
            return false;
 
        if ( in.m_nEnBtnBmpType != PICTYPE_UNINITIALIZED )
            return false;
 
        if ( in.m_lpDisBtnBmpRes != NULL )
            return false;
 
        if ( in.m_nDisBtnBmpType != PICTYPE_UNINITIALIZED )
            return false;
 
        if ( in.m_nStyle != NULL )
            return false;
 
        if ( in.m_pfnBtnProc != NULL )
            return false;
 
        if ( in.m_nBtnNameId != 0 )
            return false;
 
        return true;
    }
 
    IAcPiCategorizePropertiesImpl( )
    {
        m_CatCmdBtnVector.clear( );
        m_CategoryVector.clear( );
        int i = 0;
        while ( !IsDefaultCmdBtnEntry( T::GetCmdBtnArray( ) [ i ] ) )
        {
            m_CatCmdBtnVector.push_back( T::GetCmdBtnArray( ) [ i ] );
            i++;
        }
 
        i = 0;
        while ( !IsDefaultCategoryEntry( T::GetCatArray( ) [ i ] ) )
        {
            m_CategoryVector.push_back( T::GetCatArray( ) [ i ] );
            i++;
        }
    }
 
    virtual ~IAcPiCategorizePropertiesImpl( )
    {
    }
 
    virtual HINSTANCE GetResourceInstance( ) = 0;
 
    // IAcPiCategorizeProperties methods
    STDMETHODIMP MapPropertyToCategory( DISPID dispid , PROPCAT* ppropcat )
    {
        return AcOpmMapPropertyToCategory( reinterpret_cast< IUnknown* >( this ) , T::GetOPMPropertyMap( ) , dispid , ppropcat );
    }
 
    STDMETHODIMP GetCategoryName( PROPCAT propcat , LCID lcid , BSTR* pbstrName )
    {
        HRESULT hr;
        hr = AcOpmGetCategoryName( reinterpret_cast< IUnknown* >( this ) , GetResourceInstance( ) , T::GetOPMPropertyMap( ) , propcat , lcid , pbstrName );
        if ( hr == S_FALSE ) {
            hr = AcOpmGetCategoryName( reinterpret_cast< IUnknown* >( this ) , GetResourceInstance( ) , GetCategoryVector( ) , propcat , lcid , pbstrName );
        }
        return hr;
    }
 
    STDMETHODIMP GetCategoryDescription( PROPCAT propcat , LCID lcid , BSTR* pbstrDesc )
    {
        return AcOpmGetCategoryDescription( reinterpret_cast< IUnknown* >( this ) , GetResourceInstance( ) , GetCategoryVector( ) , propcat , lcid , pbstrDesc );
    }
 
    STDMETHODIMP GetCategoryWeight( PROPCAT CatID , long *pCategoryWeight )
    {
        return AcOpmGetCategoryWeight( reinterpret_cast< IUnknown* >( this ) , GetCategoryVector( ) , CatID , pCategoryWeight );
    }
 
    STDMETHODIMP GetParentCategory( PROPCAT CatID , PROPCAT *pParentCatID )
    {
        return AcOpmGetParentCategory( reinterpret_cast< IUnknown* >( this ) , GetCategoryVector( ) , CatID , pParentCatID );
    }
 
    STDMETHODIMP GetCommandButtons( PROPCAT CatID , VARIANT *pCatCmdBtns )
    {
        return AcOpmGetCategoryCommandButtons( reinterpret_cast< IUnknown* >( this ) , GetResourceInstance( ) , GetCmdBtnVector( ) , CatID , pCatCmdBtns );
    }
};
 
template<class T>
class ATL_NO_VTABLE IOPMPropertyExtensionImpl2 :
    public IPerPropertyBrowsing ,
    public IOPMPropertyExtension
{
public:
    IOPMPropertyExtensionImpl2( )
    {
    }
 
    virtual ~IOPMPropertyExtensionImpl2( )
    {
    }
 
    virtual HINSTANCE GetResourceInstance( ) = 0;
 
    // IPerPropertyBrowsing methods
    STDMETHODIMP GetDisplayString( DISPID dispID , BSTR *pBstr )
    {
        return ::AcOpmGetDisplayString( reinterpret_cast< IUnknown* >( this ) , T::GetOPMPropertyMap( ) , dispID , pBstr );
    }
 
    STDMETHODIMP MapPropertyToPage( DISPID dispID , CLSID *pClsid )
    {
        return ::AcOpmMapPropertyToPage( reinterpret_cast< IUnknown* >( this ) , T::GetOPMPropertyMap( ) , dispID , pClsid );
    }
 
    STDMETHODIMP GetPredefinedStrings( DISPID dispID , CALPOLESTR *pCaStringsOut , CADWORD *pCaCookiesOut )
    {
        return ::AcOpmGetPredefinedStrings( reinterpret_cast< IUnknown* >( this ) , GetResourceInstance( ) , T::GetOPMPropertyMap( ) , dispID , pCaStringsOut , pCaCookiesOut );
    }
 
    STDMETHODIMP GetPredefinedValue( DISPID dispID , DWORD dwCookie , VARIANT *pVarOut )
    {
        return ::AcOpmGetPredefinedValue( reinterpret_cast< IUnknown* >( this ) , T::GetOPMPropertyMap( ) , dispID , dwCookie , pVarOut );
    }
 
    // IOPMPropertyExtension methods
    STDMETHODIMP GetDisplayName( DISPID dispID , BSTR *pBstr )
    {
        return ::AcOpmGetDisplayName( reinterpret_cast< IUnknown* >( this ) , GetResourceInstance( ) , T::GetOPMPropertyMap( ) , dispID , pBstr );
    }
 
    STDMETHODIMP Editable(/*[in]*/ DISPID dispID , /*[out]*/ BOOL __RPC_FAR *bEditable )
    {
        return ::AcOpmEditable( reinterpret_cast< IUnknown* >( this ) , T::GetOPMPropertyMap( ) , dispID , bEditable );
    }
 
    STDMETHODIMP ShowProperty(/*[in]*/ DISPID dispID , /*[out]*/ BOOL *pShow )
    {
        return ::AcOpmShowProperty( reinterpret_cast< IUnknown* >( this ) , T::GetOPMPropertyMap( ) , dispID , pShow );
    }
};
 
template <class T>
class CProxy_AcadObjectEvents : public IConnectionPointImpl<T,&IID_IAcadObjectEvents,CComDynamicUnkArray>
{
public:
 
    void Fire_Modified( )
    {
        T* pT = static_cast<T*>( this );
        IAcadObject* pAcadObject = static_cast<IAcadObject*>( pT );
 
        pT->Lock( );
        IUnknown** pp = this->m_vec.begin( );
        while ( pp < this->m_vec.end( ) )
        {
            if ( *pp != NULL )
            {
                IAcadObjectEvents* pAcadObjectEvents = reinterpret_cast<IAcadObjectEvents*>( *pp );
                _ASSERTE( pAcadObjectEvents != NULL );
 
                pAcadObjectEvents->Modified( pAcadObject );
            }
            pp++;
        }
        pT->Unlock( );
    }
};
 
template <class T>
class CProxy_PropertyNotifySink
    : public IConnectionPointImpl<T , &IID_IPropertyNotifySink , CComDynamicUnkArray>
{
public:
    void Fire_OnChanged( )
    {
        Fire_OnChanged( DISPID_UNKNOWN );
    }
    void Fire_OnChanged( DISPID dispId )
    {
        T* pT = static_cast< T* >( this );
        pT->Lock( );
        IUnknown** pp = this->m_vec.begin( );
        while ( pp < this->m_vec.end( ) )
        {
            IPropertyNotifySink* pNotifySink = reinterpret_cast< IPropertyNotifySink* >( *pp );
            if ( pNotifySink )
                pNotifySink->OnChanged( dispId );
            pp++;
        }
        pT->Unlock( );
    }
};
 
//
// IAcadBaseObjectImpl is an abstract base class.
//
// Used to manage the AcDbObjectId and transient reactor of 
// the DB resident object. All event firing through the
// IAcadObjectEvents interface is handled here. The CreateNewObject 
// must be implemented by the client of this class.
//
template <class T , const CLSID* pclsid>
class ATL_NO_VTABLE IAcadBaseObjectImpl
    : public IAcadBaseObject
    , public IConnectionPointContainerImpl<T>
    , public CProxy_AcadObjectEvents<T>
    , public CProxy_PropertyNotifySink<T>
{
public:
    IAcadBaseObjectImpl( )
    {
    }
 
//     void FinalRelease( )
//     {
//         removeAllReactors( );
//     }
 
    virtual ~IAcadBaseObjectImpl( )
    {
    }
 
    void removeAllReactors( )
    {
        if ( m_objId == AcDbObjectId::kNull )
            return;
 
        AcDbObject* pObject = m_objId.openObject( AcDb::kForRead , true );
        if ( pObject ) // Not erased permanently
        {
            // get the OLE link manager and remove the link between the
            // database resident object and this COM wrapper.
            AcAxGetOleLinkManager( )->SetIUnknown( pObject , NULL );
        }
    }
 
    virtual HRESULT CreateNewObject( AcDbObjectId& /*objId*/ , AcDbObjectId& /*ownerId*/ , TCHAR* /*keyName*/ )
    {
        return E_NOTIMPL;
    }
 
    // IAcadBaseObject
    STDMETHOD( SetObjectId )( AcDbObjectId& objId , AcDbObjectId ownerId = AcDbObjectId::kNull , TCHAR* keyName = NULL )
    {
        HRESULT hr = NullObjectId( );
        if ( FAILED( hr ) )
            return hr;
 
        if ( objId == AcDbObjectId::kNull )
        {
            hr = CreateNewObject( objId , ownerId , keyName );
            if ( FAILED( hr ) )
                return hr;
        }
 
        if ( objId != AcDbObjectId::kNull )
        {
            m_objId = objId;
        }
        return S_OK;
    }
 
    STDMETHOD( GetObjectId )( AcDbObjectId* objId )
    {
        *objId = m_objId;
        return S_OK;
    }
 
    STDMETHOD( Clone )( AcDbObjectId ownerId , LPUNKNOWN* pUnkClone )
    {
       /* IRetrieveApplicationPtr pRApp = ( IAcadBaseObject* )this;
        LPDISPATCH app;
        pRApp->GetApplicationObject( &app );
        return AcAxCopy( m_objId , app , ( LPDISPATCH* ) pUnkClone , ownerId );*/
        return E_NOTIMPL;
    }
 
    STDMETHOD( GetClassID )( CLSID& clsid )
    {
        clsid = *pclsid;
        return S_OK;
    }
 
    STDMETHOD( NullObjectId )( void )
    {
        if ( m_objId == AcDbObjectId::kNull )
            return S_OK;
        m_objId.setNull( );
        return S_OK;
    }
 
    STDMETHOD( OnModified )( void )
    {
        this->Fire_Modified( );
        this->Fire_OnChanged( );
        return S_OK;
    }
 
    // IConnectionPointContainerImpl
    BEGIN_CONNECTION_POINT_MAP( T )
        CONNECTION_POINT_ENTRY( IID_IAcadObjectEvents )
        CONNECTION_POINT_ENTRY( IID_IPropertyNotifySink )
    END_CONNECTION_POINT_MAP( )
 
protected:
    AcDbObjectId m_objId;
};
template <class T , const CLSID* pclsid>
class ATL_NO_VTABLE IAcadBaseObject2Impl
    : public IAcadBaseObject2,
    public IAcadBaseObjectImpl<T , pclsid>
{
public:
    IAcadBaseObject2Impl( )
    {
    }
 
//     void FinalRelease( )
//     {
// 
//     }
 
    virtual ~IAcadBaseObject2Impl( )
    {
    }
    STDMETHOD( SetObject )( AcDbObject*& pObj )
    {
        if ( pObj->objectId( ).isNull( ) )
        {
            this->NullObjectId( );
            m_objRef.acquire( pObj );
            return S_OK;
        }
        else
        {
            m_objRef.acquire( pObj->objectId( ) );
            AcDbObjectId tmpId = pObj->objectId( );
            return this->SetObjectId( tmpId );
        }
    }
   
    void Fire_Notification( DISPID dispId = DISPID_UNKNOWN )
    {
        if ( m_objRef.objectId( ).isNull( ) )
        {
            this->Fire_Modified( );
            this->Fire_OnChanged( dispId );
        }
    }
 
    STDMETHOD( ForceDbResident )( VARIANT_BOOL* forceDbResident )
    {
 
        if ( NULL == forceDbResident )
            return E_POINTER;
 
        *forceDbResident = ACAX_VARIANT_TRUE;
        return S_OK;
    }
    STDMETHOD(AddToDb)(AcDbObjectId& objId, AcDbObjectId ownerId = AcDbObjectId::kNull, ACHAR* keyName = NULL)
    {
        return E_NOTIMPL;
    }
    STDMETHOD(CreateObject)(AcDbObjectId ownerId = AcDbObjectId::kNull, ACHAR* keyName = NULL)
    {
        return E_NOTIMPL;
    }
    STDMETHOD(ObjectExists)(VARIANT_BOOL* objectExists)
    {
        if ( NULL == objectExists )
            return E_POINTER;
 
        *objectExists = m_objRef.isNull( ) ? ACAX_VARIANT_FALSE : ACAX_VARIANT_TRUE;
        return S_OK;
    }
    STDMETHOD(GetObject)(AcDbObject*& pObj)
    {
        pObj = NULL;
        if ( !m_objRef.objectId( ).isNull( ) )
            return E_FAIL;
 
        AcDbObjectId tmpId;
        m_objRef.release( tmpId , pObj );
        _ASSERTE( this->m_objId.isNull( ) );
        _ASSERTE( tmpId.isNull( ) );
        return S_OK;
    }
 
protected:
    AcAxObjectRef m_objRef;
};
 
//
// IRetrieveApplicationImpl
//
// Used to manage the Application interface for the objects.
//
class ATL_NO_VTABLE IRetrieveApplicationImpl :
    public IRetrieveApplication
{
protected:
   /* AcDbHostAppServices* hostApp( ) const
    {
        AcDbHostAppServices* pHostApp = 0;
        IRetrieveHostAppServicesPtr pRetrieveHostApp = m_App;
        if ( pRetrieveHostApp )
        {
            pRetrieveHostApp->GetHostAppServices( &pHostApp );
        }
        return pHostApp;
    }
    */
public:
    IRetrieveApplicationImpl( )
    {
        m_App = NULL;
    }
 
    virtual ~IRetrieveApplicationImpl( )
    {
        if ( m_App != NULL )
            m_App->Release( );
    }
 
    STDMETHOD( SetApplicationObject )( LPDISPATCH pApp )
    {
        if ( m_App != NULL )
            return E_FAIL;
        m_App = pApp;
 
        // only addref if there is a valid pointer
        if ( m_App != NULL )
            m_App->AddRef( );
 
        return S_OK;
    }
 
    // not exported via
    STDMETHOD( GetApplicationObject )( LPDISPATCH* pApp )
    {
        *pApp = m_App;
        if ( m_App == NULL )
            return E_FAIL;
        m_App->AddRef( );
        return S_OK;
    }
 
protected:
    IDispatchPtr GetApplicationObject( )
    {
        IDispatchPtr pRes;
#ifdef _DEBUG
        HRESULT hr =
#endif
            GetApplicationObject( &pRes );
#ifdef _DEBUG
        if ( FAILED( hr ) )
            throw hr;
#endif
        return pRes;
    }
 
    LPDISPATCH m_App;
};
 
template <class C , const CLSID* pclsid , class T , const IID* piid , const GUID* plibid ,
    WORD wMajor = 1 , WORD wMinor = 0 , class tihclass = CComTypeInfoHolder>
    class ATL_NO_VTABLE IAcadObjectDispatchImpl
    : public IDispatchImpl<T , piid , plibid , wMajor , wMinor , tihclass>
    , public IAcadBaseObject2Impl<C , pclsid>
    , public IRetrieveApplicationImpl
{
protected:
    REFGUID defItf( ) const { return *piid; }
    AcDbHostAppServices* hostApp( ) const { return this->m_objId == AcDbObjectId::kNull ? 0 : this->m_objId.database( )->appServices( ); }
public:
 
    IAcadObjectDispatchImpl( )
    {
    }
 
    virtual ~IAcadObjectDispatchImpl( )
    {
    }
 
    STDMETHOD( get_Application )( LPDISPATCH* pVal )
    {
        return GetApplicationObject( pVal );
    }
 
    STDMETHOD( get_ObjectID )( LONG_PTR *pVal )
    {
        if ( this->m_objId == AcDbObjectId::kNull )
        {
            return E_FAIL;
        }
        *pVal = ( LONG_PTR ) ( AcDbStub* ) this->m_objId;
        return S_OK;
    }
 
    STDMETHOD( get_OwnerID )( LONG_PTR *pVal )
    {
        return ::AcAxGetOwnerId( this->m_objId , pVal );
    }
 
    STDMETHOD( Delete )( )
    {
        HRESULT hr = ::AcAxErase( this->m_objId );
        if ( SUCCEEDED( hr ) )
            this->removeAllReactors( );
        return hr;
    }
 
    STDMETHOD( SetXData )( VARIANT type , VARIANT data )
    {
        return ::AcAxSetXData( this->m_objId , type , data );
    }
 
    STDMETHOD( GetXData )( BSTR bstrName , VARIANT* type , VARIANT* data )
    {
        return ::AcAxGetXData( this->m_objId , bstrName , type , data );
    }
 
    STDMETHOD( get_ObjectName )( BSTR *pVal )
    {
        return ::AcAxGetObjectName( this->m_objId , pVal );
    }
 
    STDMETHOD( get_Handle )( BSTR *pVal )
    {
        return ::AcAxGetHandle( this->m_objId , pVal );
    }
 
    STDMETHOD( get_HasExtensionDictionary )( VARIANT_BOOL* bHasDictionary )
    {
        return ::AcAxHasExtensionDictionary( this->m_objId , bHasDictionary );
    }
 
    STDMETHOD( GetExtensionDictionary )( IAcadDictionary** pExtDictionary )
    {
        return ::AcAxGetExtensionDictionary( this->m_objId , m_App , pExtDictionary );
    }
 
    /*
    this properties for compatibilities only, it not be displayed in a user-oriented browser.
    */
    STDMETHOD( get_Database )( IAcadDatabase** pDatabase )
    {
       /* if ( this->m_objId.isNull( ) || this->m_objId.database( ) == NULL )
        {
            return E_FAIL;
        }
            IUnknownPtr pUnk = ::AcAxGetIUnknownOfDatabase( this->m_objId.database( ) , m_App );
        return pUnk->QueryInterface( IID_IAcadDatabase , ( void** ) pDatabase );*/
        return E_NOTIMPL;
    }
 
    STDMETHOD( get_Document )( LPDISPATCH* pDocument )
    {
        if ( this->m_objId == AcDbObjectId::kNull || this->m_objId.database( ) == NULL )
        {
            return E_FAIL;
        }
 
        AcAxOleLinkManager* pOleLinkManager = AcAxGetOleLinkManager( );
 
        _ASSERTE( pOleLinkManager != NULL );
 
        *pDocument = pOleLinkManager->GetDocIDispatch( this->m_objId.database( ) );
        if ( *pDocument == NULL )
        {
            return E_FAIL;
        }
 
        ( *pDocument )->AddRef( );
        return S_OK;
    }
 
    //
    // Provided for backwards compatibility; for future coding
    // use call Delete() instead of Erase()
    //
    STDMETHOD( Erase )( )
    {
        return Delete( );
    }
 
    STDMETHODIMP InterfaceSupportsErrorInfo( REFIID riid )
    {
        static const IID* arr [ ] =
        {
            piid,
            &IID_IAcadObject
        };
        for ( int i = 0; i < sizeof( arr ) / sizeof( arr [ 0 ] ); i++ )
        {
            if ( InlineIsEqualGUID( *arr [ i ] , riid ) )
                return S_OK;
        }
        return S_FALSE;
    }
};