home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / mfc / src / oleasmon.cpp < prev    next >
C/C++ Source or Header  |  1998-06-16  |  17KB  |  629 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #include "stdafx.h"
  12.  
  13. #ifdef AFX_OLE_SEG
  14. #pragma code_seg(AFX_OLE_SEG)
  15. #endif
  16.  
  17. #ifdef _DEBUG
  18. #undef THIS_FILE
  19. static char THIS_FILE[] = __FILE__;
  20. #endif
  21.  
  22. #define new DEBUG_NEW
  23.  
  24. #pragma inline_depth(0)
  25.  
  26. /////////////////////////////////////////////////////////////////////////////
  27. // _AfxBindStatusCallback for CAsyncMonikerFile implementation
  28.  
  29. class _AfxBindStatusCallback: public IBindStatusCallback
  30. {
  31. private:
  32.     class CInnerUnknown : public IUnknown
  33.     {
  34.     protected:
  35.         _AfxBindStatusCallback* m_pThis;
  36.         friend class _AfxBindStatusCallback;
  37.  
  38.     public:
  39.         inline CInnerUnknown() { }
  40.         inline void SetpThis(_AfxBindStatusCallback* pThis) { ASSERT(pThis != NULL); m_pThis = pThis; }
  41.  
  42.         STDMETHOD_(ULONG, AddRef)()
  43.         {
  44.             return InterlockedIncrement((long*)&m_pThis->m_dwRef);
  45.         }
  46.  
  47.         STDMETHOD_(ULONG, Release)()
  48.         {
  49.             unsigned long lResult = InterlockedDecrement((long*)&m_pThis->m_dwRef);
  50.             if (lResult == 0)
  51.                 delete m_pThis;
  52.             return lResult;
  53.         }
  54.  
  55.         STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
  56.         {
  57.             if (!ppvObject)
  58.                 return E_POINTER;
  59.  
  60.             // check for the interfaces this object knows about
  61.             if (iid == IID_IUnknown)
  62.             {
  63.                 *ppvObject = (IUnknown*)this;
  64.                 AddRef();
  65.                 return S_OK;
  66.             }
  67.             if (iid == IID_IBindStatusCallback)
  68.             {
  69.                 *ppvObject = (IBindStatusCallback*)m_pThis;
  70.                 m_pThis->AddRef();
  71.                 return S_OK;
  72.             }
  73.  
  74.             // otherwise, incorrect IID, and thus error
  75.             return E_NOINTERFACE;
  76.         }
  77.     };
  78.  
  79. public:
  80.     inline _AfxBindStatusCallback(CAsyncMonikerFile* pOwner, IUnknown* pUnkControlling)
  81.         : m_pOwner(pOwner), m_dwRef(0)
  82.     {
  83.         m_UnkInner.SetpThis(this);
  84.         ASSERT(pOwner);
  85. #ifdef _AFXDLL
  86.         m_pModuleState = AfxGetModuleState();
  87.         ASSERT(m_pModuleState != NULL);
  88. #endif
  89.         m_pUnkControlling = pUnkControlling ? pUnkControlling : (IUnknown*)&m_UnkInner;
  90.  
  91.         AfxOleLockApp();
  92.     }
  93.  
  94.     inline ~_AfxBindStatusCallback()
  95.     {
  96.         AFX_MANAGE_STATE(m_pModuleState);
  97.         AfxOleUnlockApp();
  98.     }
  99.  
  100.     inline void Orphan() { m_pOwner = NULL; }
  101.  
  102.     STDMETHOD_(ULONG, AddRef)()
  103.         { return m_pUnkControlling->AddRef(); }
  104.     STDMETHOD_(ULONG, Release)()
  105.         { return m_pUnkControlling->Release(); }
  106.     STDMETHOD(QueryInterface)(REFIID iid, void** ppvObject)
  107.         { return m_pUnkControlling->QueryInterface(iid, ppvObject); }
  108.  
  109.  
  110.     const CAsyncMonikerFile* GetOwner() const{ return m_pOwner; }
  111.     DWORD GetRefcount() const { return m_dwRef; }
  112.     const IUnknown* GetControllingUnknown() const { return m_pUnkControlling; }
  113.     IUnknown* GetControllingUnknown() { return m_pUnkControlling; }
  114.     const IUnknown* GetInnerUnknown() const { return &m_UnkInner; }
  115.     IUnknown* GetInnerUnknown() { return &m_UnkInner; }
  116.     const _AfxBindStatusCallback* GetpThisOfInnerUnknown() const { return m_UnkInner.m_pThis; }
  117. #ifdef _AFXDLL
  118.     const AFX_MODULE_STATE* GetModuleState() const { return m_pModuleState; }
  119. #endif
  120. protected:
  121.     friend class CInnerUnknown;
  122.     DWORD m_dwRef;
  123. private:
  124.     IUnknown* m_pUnkControlling;
  125.     CInnerUnknown m_UnkInner;
  126.     CAsyncMonikerFile* m_pOwner;
  127. #ifdef _AFXDLL
  128.     AFX_MODULE_STATE* m_pModuleState;
  129. #endif
  130.  
  131.     STDMETHOD(GetBindInfo)(
  132.         DWORD __RPC_FAR *pgrfBINDF, BINDINFO __RPC_FAR *pbindinfo)
  133.     {
  134.         ASSERT(m_pOwner);
  135.         if (!pgrfBINDF || !pbindinfo)
  136.             return E_POINTER;
  137.         if (pbindinfo->cbSize<sizeof(BINDINFO))
  138.             return E_INVALIDARG;
  139.         if (!m_pOwner)
  140.             return E_FAIL;
  141.  
  142.         AFX_MANAGE_STATE(m_pModuleState);
  143.         pbindinfo->szExtraInfo = NULL;
  144.         TRY
  145.         {
  146.             *pgrfBINDF = m_pOwner->GetBindInfo();
  147.         }
  148.         CATCH_ALL(e)
  149.         {
  150.             HRESULT hr = ResultFromScode(COleException::Process(e));
  151.             DELETE_EXCEPTION(e);
  152.             return hr;
  153.         }
  154.         END_CATCH_ALL
  155.         return S_OK;
  156.     }
  157.  
  158.     STDMETHOD(OnStartBinding)(
  159.         DWORD dwReserved, IBinding __RPC_FAR *pBinding)
  160.     {
  161.         ASSERT(m_pOwner);
  162.         UNUSED_ALWAYS(dwReserved);
  163.         if (!pBinding)
  164.             return E_POINTER;
  165.         if (!m_pOwner)
  166.             return E_FAIL;
  167.  
  168.         AFX_MANAGE_STATE(m_pModuleState);
  169.         TRY
  170.         {
  171.             m_pOwner->SetBinding(pBinding);
  172.             m_pOwner->OnStartBinding();
  173.         }
  174.         CATCH_ALL(e)
  175.         {
  176.             HRESULT hr = ResultFromScode(COleException::Process(e));
  177.             DELETE_EXCEPTION(e);
  178.             return hr;
  179.         }
  180.         END_CATCH_ALL
  181.         return S_OK;
  182.     }
  183.  
  184.     STDMETHOD(GetPriority)(LONG __RPC_FAR *pnPriority)
  185.     {
  186.         ASSERT(m_pOwner);
  187.         if (!pnPriority)
  188.             return E_POINTER;
  189.         if (!m_pOwner)
  190.             return E_FAIL;
  191.         AFX_MANAGE_STATE(m_pModuleState);
  192.         TRY
  193.         {
  194.             *pnPriority = m_pOwner->GetPriority();
  195.         }
  196.         CATCH_ALL(e)
  197.         {
  198.             HRESULT hr = ResultFromScode(COleException::Process(e));
  199.             DELETE_EXCEPTION(e);
  200.             return hr;
  201.         }
  202.         END_CATCH_ALL
  203.         return S_OK;
  204.     }
  205.  
  206.     STDMETHOD(OnProgress)(
  207.         ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode,
  208.         LPCOLESTR szStatusText)
  209.     {
  210.         ASSERT(m_pOwner);
  211.         if (!m_pOwner)
  212.             return E_FAIL;
  213.         USES_CONVERSION;
  214.         AFX_MANAGE_STATE(m_pModuleState);
  215.         TRY
  216.         {
  217.             m_pOwner->OnProgress(ulProgress, ulProgressMax, ulStatusCode, OLE2CT(szStatusText));
  218.         }
  219.         CATCH_ALL(e)
  220.         {
  221.             HRESULT hr = ResultFromScode(COleException::Process(e));
  222.             DELETE_EXCEPTION(e);
  223.             return hr;
  224.         }
  225.         END_CATCH_ALL
  226.         return S_OK;
  227.     }
  228.  
  229.     STDMETHOD(OnDataAvailable)(
  230.         DWORD grfBSCF, DWORD dwSize, FORMATETC __RPC_FAR *pformatetc,
  231.         STGMEDIUM __RPC_FAR *pstgmed)
  232.     {
  233.         ASSERT(m_pOwner);
  234.         if (!m_pOwner)
  235.             return E_FAIL;
  236.         AFX_MANAGE_STATE(m_pModuleState);
  237.         TRY
  238.         {
  239.             m_pOwner->SetFormatEtc(pformatetc);
  240.             if (grfBSCF&BSCF_FIRSTDATANOTIFICATION)
  241.             {
  242.                 if (!pstgmed || !pformatetc)
  243.                     return E_POINTER;
  244.                 if ((pstgmed->tymed != TYMED_ISTREAM) ||
  245.                     !pstgmed->pstm)
  246.                     return E_UNEXPECTED;
  247.                 ASSERT(!m_pOwner->GetStream());
  248.                 m_pOwner->COleStreamFile::Attach(pstgmed->pstm);
  249.                 pstgmed->pstm->AddRef();
  250.             }
  251.  
  252.             m_pOwner->OnDataAvailable(dwSize, grfBSCF);
  253.         }
  254.         CATCH_ALL(e)
  255.         {
  256.             m_pOwner->SetFormatEtc(NULL);
  257.             HRESULT hr = ResultFromScode(COleException::Process(e));
  258.             DELETE_EXCEPTION(e);
  259.             return hr;
  260.         }
  261.         END_CATCH_ALL
  262.         m_pOwner->SetFormatEtc(NULL);
  263.         return S_OK;
  264.     }
  265.  
  266.     STDMETHOD(OnLowResource)(DWORD dwReserved)
  267.     {
  268.         ASSERT(m_pOwner);
  269.         if (!m_pOwner)
  270.             return E_FAIL;
  271.         AFX_MANAGE_STATE(m_pModuleState);
  272.         UNUSED_ALWAYS(dwReserved);
  273.         TRY
  274.         {
  275.             m_pOwner->OnLowResource();
  276.         }
  277.         CATCH_ALL(e)
  278.         {
  279.             HRESULT hr = ResultFromScode(COleException::Process(e));
  280.             DELETE_EXCEPTION(e);
  281.             return hr;
  282.         }
  283.         END_CATCH_ALL
  284.         return S_OK;
  285.     }
  286.  
  287.     STDMETHOD(OnStopBinding)(HRESULT hresult, LPCOLESTR szError)
  288.     {
  289.         //Does not ASSERT(m_pOwner) because this can be called
  290.         //after it has been Orphan()ed.
  291.         if (!m_pOwner)
  292.             return E_FAIL;
  293.         USES_CONVERSION;
  294.         AFX_MANAGE_STATE(m_pModuleState);
  295.         ASSERT(m_pOwner->GetBinding());
  296.         TRY
  297.         {
  298.             m_pOwner->m_bStopBindingReceived = TRUE;
  299.             m_pOwner->OnStopBinding(hresult, OLE2CT(szError));
  300.  
  301.             if (m_pOwner)
  302.             {
  303.                 // Calling EndCallbacks will result in a inner Release. Our
  304.                 // caller has an inner refcount on us, possibly through the
  305.                 // controlling unknown, and we have an inner refcount from
  306.                 // m_pOwner, so m_dwRef > 1 and it's safe to call EndCallbacks.
  307.                 ASSERT(m_dwRef > 1);
  308.                 m_pOwner->EndCallbacks();
  309.             }
  310.         }
  311.         CATCH_ALL(e)
  312.         {
  313.             HRESULT hr = ResultFromScode(COleException::Process(e));
  314.             DELETE_EXCEPTION(e);
  315.             return hr;
  316.         }
  317.         END_CATCH_ALL
  318.         return S_OK;
  319.     }
  320.  
  321.     STDMETHOD(OnObjectAvailable)(REFIID riid, IUnknown __RPC_FAR *punk)
  322.     {
  323. #ifdef _DEBUG
  324.         AFX_MANAGE_STATE(m_pModuleState);
  325.         ASSERT(FALSE);  // This function should never be called.
  326. #endif //_DEBUG
  327.         UNUSED_ALWAYS(riid);
  328.         UNUSED_ALWAYS(punk);
  329.         return E_UNEXPECTED;
  330.     }
  331. };
  332.  
  333. /////////////////////////////////////////////////////////////////////////////
  334. // Helper functions for CAsyncMonikerFile implementation
  335.  
  336. AFX_STATIC inline IBindHost* AFXAPI _AfxTrySPForBindHost(IServiceProvider* pServiceProvider)
  337. {
  338.     ASSERT(pServiceProvider);
  339.     IBindHost* pBindHost;
  340.     HRESULT hr=pServiceProvider->QueryService(SID_IBindHost, IID_IBindHost,
  341.         (void**)&pBindHost);
  342.     if (SUCCEEDED(hr))
  343.         return pBindHost;
  344.     else
  345.         return NULL;
  346. }
  347.  
  348. AFX_STATIC inline IBindHost* AFXAPI _AfxTryQIForBindHost(IUnknown* pUnk)
  349. {
  350.     ASSERT(pUnk);
  351.     IPTR(IBindHost) pBindHost;
  352.     HRESULT hr = pBindHost.QueryInterface(pUnk);
  353.     if (SUCCEEDED(hr))
  354.         return pBindHost;
  355.     else
  356.         return NULL;
  357. }
  358.  
  359. /////////////////////////////////////////////////////////////////////////////
  360. // CAsyncMonikerFile implementation
  361.  
  362. CAsyncMonikerFile::CAsyncMonikerFile() : m_pFormatEtc(NULL),
  363.     m_pAfxBSCCurrent(NULL)
  364. {
  365. }
  366.  
  367. CAsyncMonikerFile::~CAsyncMonikerFile()
  368. {
  369.     CAsyncMonikerFile::Close();
  370. }
  371.  
  372. void CAsyncMonikerFile::EndCallbacks()
  373. {
  374.     if (m_pAfxBSCCurrent)
  375.     {
  376.         m_pAfxBSCCurrent->Orphan();
  377.         IUnknown* pUnkInner = m_pAfxBSCCurrent->GetInnerUnknown();
  378.         ASSERT(pUnkInner != NULL);
  379.         pUnkInner->Release();
  380.         m_pAfxBSCCurrent = NULL;
  381.     }
  382. }
  383.  
  384. UINT CAsyncMonikerFile::Read(void* lpBuf, UINT nCount)
  385. {
  386.     ASSERT_VALID(this);
  387.     ASSERT(m_lpStream != NULL);
  388.  
  389.     DWORD dwBytesRead;
  390.     HRESULT hr = _AfxReadFromStream(m_lpStream, lpBuf, nCount, dwBytesRead);
  391.  
  392.     if ((hr != S_OK) && (hr != S_ASYNCHRONOUS) && (hr != E_PENDING))
  393.         _AfxThrowOleFileException(hr);
  394.  
  395.     // always return number of bytes read
  396.     return (UINT)dwBytesRead;
  397. }
  398.  
  399. void CAsyncMonikerFile::Close()
  400. {
  401.     ASSERT_VALID(this);
  402.     if (m_Binding.GetInterfacePtr())
  403.     {
  404.         if (!m_bStopBindingReceived)
  405.             m_Binding->Abort();
  406.         m_Binding.Release();
  407.     }
  408.     EndCallbacks();
  409.     CMonikerFile::Close();
  410. }
  411.  
  412. BOOL CAsyncMonikerFile::Open(IMoniker* pMoniker, IBindHost* pBindHost, CFileException* pError)
  413. {
  414.     if (!pBindHost)
  415.         return CAsyncMonikerFile::Open(pMoniker, pError);
  416.     Close();
  417.     IPTR(IBindCtx) pBindCtx(CreateBindContext(pError), FALSE);
  418.     if (pError && (pError->m_cause != CFileException::none))
  419.         return FALSE;
  420.     IPTR(IUnknown) pBSCUnk(CreateBindStatusCallback(NULL), FALSE);
  421.     IPTR(IBindStatusCallback) pBSC;
  422.     pBSC.QueryInterface(pBSCUnk);
  423.  
  424.     m_bStopBindingReceived = FALSE;
  425.     return Attach(pMoniker, pBindHost, pBSC, pBindCtx, pError);
  426. }
  427.  
  428. BOOL CAsyncMonikerFile::Open(LPCTSTR lpszURL, IBindHost* pBindHost, CFileException* pError)
  429. {
  430.     if (!pBindHost)
  431.         return CAsyncMonikerFile::Open(lpszURL, pError);
  432.     Close();
  433.     IPTR(IBindCtx) pBindCtx(CreateBindContext(pError), FALSE);
  434.     if (pError && (pError->m_cause != CFileException::none))
  435.         return FALSE;
  436.     IPTR(IUnknown) pBSCUnk(CreateBindStatusCallback(NULL), FALSE);
  437.     IPTR(IBindStatusCallback) pBSC;
  438.     pBSC.QueryInterface(pBSCUnk);
  439.  
  440.     m_bStopBindingReceived = FALSE;
  441.     return Attach(lpszURL, pBindHost, pBSC, pBindCtx, pError);
  442. }
  443.  
  444. BOOL CAsyncMonikerFile::Open(LPCTSTR lpszURL, CFileException* pError)
  445. {
  446.     IPTR(IBindHost) pBindHost(CreateBindHost(), FALSE);
  447.  
  448.     return Open(lpszURL, static_cast<IBindHost*>(pBindHost), pError);
  449. }
  450.  
  451. BOOL CAsyncMonikerFile::Open(IMoniker* pMoniker, CFileException* pError)
  452. {
  453.     IPTR(IBindHost) pBindHost(CreateBindHost(), FALSE);
  454.  
  455.     return Open(pMoniker, (IBindHost*)pBindHost, pError);
  456. }
  457.  
  458. BOOL CAsyncMonikerFile::Open(LPCTSTR lpszURL,
  459.     IServiceProvider* pServiceProvider, CFileException* pError)
  460. {
  461.     if (!pServiceProvider)
  462.         return CAsyncMonikerFile::Open(lpszURL, pError);
  463.     IPTR(IBindHost) pBindHost;
  464.     pBindHost = _AfxTrySPForBindHost(pServiceProvider);
  465.     if (!pBindHost.GetInterfacePtr())
  466.         pBindHost = _AfxTryQIForBindHost(pServiceProvider);
  467.     if (pBindHost.GetInterfacePtr())
  468.         return Open(lpszURL, (IBindHost*)pBindHost, pError);
  469.     return CAsyncMonikerFile::Open(lpszURL, pError);
  470. }
  471.  
  472. BOOL CAsyncMonikerFile::Open(LPCTSTR lpszURL,
  473.     IUnknown* pUnknown, CFileException* pError)
  474. {
  475.     if (!pUnknown)
  476.         return CAsyncMonikerFile::Open(lpszURL, pError);
  477.     IPTR(IBindHost) pBindHost;
  478.     IPTR(IServiceProvider) pServiceProvider;
  479.     HRESULT hr=pServiceProvider.QueryInterface(pUnknown);
  480.     if (SUCCEEDED(hr) && pServiceProvider.GetInterfacePtr())
  481.         pBindHost = _AfxTrySPForBindHost(pServiceProvider);
  482.     if (!pBindHost.GetInterfacePtr())
  483.         pBindHost = _AfxTryQIForBindHost(pUnknown);
  484.     if (pBindHost.GetInterfacePtr())
  485.         return Open(lpszURL, (IBindHost*)pBindHost, pError);
  486.  
  487.     return CAsyncMonikerFile::Open(lpszURL, pError);
  488. }
  489.  
  490. BOOL CAsyncMonikerFile::Open(IMoniker* pMoniker,
  491.     IServiceProvider* pServiceProvider, CFileException* pError)
  492. {
  493.     if (!pServiceProvider)
  494.         return Open(pMoniker, pError);
  495.     IPTR(IBindHost) pBindHost;
  496.     pBindHost = _AfxTrySPForBindHost(pServiceProvider);
  497.     if (!pBindHost.GetInterfacePtr())
  498.         pBindHost = _AfxTryQIForBindHost(pServiceProvider);
  499.     if (pBindHost.GetInterfacePtr())
  500.         return Open(pMoniker, (IBindHost*)pBindHost, pError);
  501.     return Open(pMoniker, pError);
  502. }
  503.  
  504. BOOL CAsyncMonikerFile::Open(IMoniker* pMoniker,
  505.     IUnknown* pUnknown, CFileException* pError)
  506. {
  507.     if (!pUnknown)
  508.         return Open(pMoniker, pError);
  509.     IPTR(IBindHost) pBindHost;
  510.     IPTR(IServiceProvider) pServiceProvider;
  511.     HRESULT hr=pServiceProvider.QueryInterface(pUnknown);
  512.     if (SUCCEEDED(hr) && pServiceProvider.GetInterfacePtr())
  513.         pBindHost = _AfxTrySPForBindHost(pServiceProvider);
  514.     if (!pBindHost.GetInterfacePtr())
  515.         pBindHost = _AfxTryQIForBindHost(pServiceProvider);
  516.     if (pBindHost.GetInterfacePtr())
  517.         return Open(pMoniker, (IBindHost*)pBindHost, pError);
  518.     return Open(pMoniker, pError);
  519. }
  520.  
  521. BOOL CAsyncMonikerFile::PostBindToStream(CFileException* pError)
  522. {
  523.     if (S_OK == IsAsyncMoniker(GetMoniker()))
  524.         return TRUE;
  525.     return CMonikerFile::PostBindToStream(pError);
  526. }
  527.  
  528. IUnknown* CAsyncMonikerFile::CreateBindStatusCallback(IUnknown* pUnkControlling)
  529. {
  530.     ASSERT(NULL == m_pAfxBSCCurrent); // Set by Close()
  531.     m_pAfxBSCCurrent = new _AfxBindStatusCallback(this, pUnkControlling);
  532.     IUnknown* pUnkInner = m_pAfxBSCCurrent->GetInnerUnknown();
  533.     ASSERT(pUnkInner != NULL);
  534.     //Reference inner unknown for m_pAfxBSCCurrent
  535.     pUnkInner->AddRef();
  536.     //Reference inner unknown for return value.
  537.     pUnkInner->AddRef();
  538.     return pUnkInner;
  539. }
  540.  
  541. DWORD CAsyncMonikerFile::GetBindInfo() const
  542. {
  543.     return BINDF_ASYNCHRONOUS|BINDF_ASYNCSTORAGE;
  544. }
  545.  
  546. LONG CAsyncMonikerFile::GetPriority() const
  547. {
  548.     return THREAD_PRIORITY_NORMAL;
  549. }
  550.  
  551. void CAsyncMonikerFile::OnDataAvailable(DWORD dwSize, DWORD bscfFlag)
  552. {
  553.     UNUSED_ALWAYS(dwSize);
  554.     UNUSED_ALWAYS(bscfFlag);
  555. }
  556.  
  557. void CAsyncMonikerFile::OnLowResource()
  558. {
  559. }
  560.  
  561. void CAsyncMonikerFile::OnStartBinding()
  562. {
  563. }
  564.  
  565. void CAsyncMonikerFile::OnStopBinding(HRESULT hresult, LPCTSTR szError)
  566. {
  567.     UNUSED_ALWAYS(hresult);
  568.     UNUSED_ALWAYS(szError);
  569. }
  570.  
  571. void CAsyncMonikerFile::OnProgress(ULONG ulProgress, ULONG ulProgressMax,
  572.         ULONG ulStatusCode, LPCTSTR szStatusText)
  573. {
  574.     UNUSED_ALWAYS(ulProgress);
  575.     UNUSED_ALWAYS(ulProgressMax);
  576.     UNUSED_ALWAYS(ulStatusCode);
  577.     UNUSED_ALWAYS(szStatusText);
  578. }
  579.  
  580. /////////////////////////////////////////////////////////////////////////////
  581. // CAsyncMonikerFile diagnostics
  582.  
  583. #ifdef _DEBUG
  584. void CAsyncMonikerFile::AssertValid() const
  585. {
  586.     if (m_pAfxBSCCurrent)
  587.     {
  588.         ASSERT(m_pAfxBSCCurrent->GetOwner() == this);
  589.         ASSERT(m_pAfxBSCCurrent->GetRefcount() > 0);
  590. #ifdef _AFXDLL
  591.         ASSERT(m_pAfxBSCCurrent->GetModuleState() == AfxGetModuleState());
  592. #endif
  593.         ASSERT(m_pAfxBSCCurrent->GetpThisOfInnerUnknown() == m_pAfxBSCCurrent);
  594.     }
  595.     CMonikerFile::AssertValid();
  596. }
  597.  
  598. void CAsyncMonikerFile::Dump(CDumpContext& dc) const
  599. {
  600.     CMonikerFile::Dump(dc);
  601.  
  602.     dc << "\nm_Binding = " << m_Binding.GetInterfacePtr();
  603.     dc << "\nm_pFormatEtc = " << m_pFormatEtc;
  604.     dc << "\nm_pAfxBSCCurrent = " << m_pAfxBSCCurrent;
  605.     if (m_pAfxBSCCurrent)
  606.     {
  607.         dc << "\nm_pAfxBSCCurrent->GetOwner() = " << m_pAfxBSCCurrent->GetOwner();
  608.         dc << "\nm_pAfxBSCCurrent->GetRefcount() = " << m_pAfxBSCCurrent->GetRefcount();
  609.         dc << "\nm_pAfxBSCCurrent->GetControllingUnknown() = " << m_pAfxBSCCurrent->GetControllingUnknown();
  610.         dc << "\nm_pAfxBSCCurrent->GetInnerUnknown() = " << m_pAfxBSCCurrent->GetInnerUnknown();
  611.         dc << "\nm_pAfxBSCCurrent->GetpThisOfInnerUnknown() = " << m_pAfxBSCCurrent->GetpThisOfInnerUnknown();
  612. #ifdef _AFXDLL
  613.         dc << "\nm_pAfxBSCCurrent->GetModuleState() = " << m_pAfxBSCCurrent->GetModuleState();
  614. #endif
  615.     }
  616.     dc << "\n";
  617. }
  618. #endif
  619.  
  620. ////////////////////////////////////////////////////////////////////////////
  621.  
  622. #ifdef AFX_INIT_SEG
  623. #pragma code_seg(AFX_INIT_SEG)
  624. #endif
  625.  
  626. IMPLEMENT_DYNAMIC(CAsyncMonikerFile, CMonikerFile)
  627.  
  628. ////////////////////////////////////////////////////////////////////////////
  629.