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