C / C++ / MFC

class CXmlInternetFileManager : public CXmlFileManager, public IBindStatusCallback
{
	// Members
	//
protected:
	long m_cRef; // object life cycle

	char		m_szProxy[MAX_PATH];
	int			m_nProxyPort;

	// IBindStatusCallback control
	IBinding*   m_pBinding;       // ptr to current IBinding
	IStream*    m_pStream;        // ptr to data stream
	
	HWND        m_hwndStatus;     // status line window
	FILE		*m_tmpFile;		  // temporary buffer

	BOOL		m_bStop_EvrythingIsReceived;
	DWORD       m_dwLoadedSoFar;  // num bytes transferred so far
	DWORD		m_dwOffsetReadByClient; // begin bytes in stream where client should collect data


	// Constructor
	//
public:
	CXmlInternetFileManager();
	virtual ~CXmlInternetFileManager();

	// Methods
	//
	virtual BOOL Open(char *szURL);
	virtual BOOL Read(char *szInputBuffer, int nMaxLength, int &nActualLength);
	virtual BOOL Close();


public:

	// IUnknown implementation
	virtual HRESULT __stdcall	QueryInterface(const IID& iid, void** ppv) ;			
	virtual ULONG __stdcall		AddRef() ;
	virtual ULONG __stdcall		Release() ;

	// NOTE: Not all IBindStatusCallback functions are shown
   //
        virtual HRESULT STDMETHODCALLTYPE OnStartBinding( 
            /* [in] */ DWORD dwReserved,
            /* [in] */ IBinding __RPC_FAR *pib);
        
        virtual HRESULT STDMETHODCALLTYPE GetPriority( 
            /* [out] */ LONG __RPC_FAR *pnPriority);
        
        virtual HRESULT STDMETHODCALLTYPE OnLowResource( 
            /* [in] */ DWORD reserved);
        
        virtual HRESULT STDMETHODCALLTYPE OnProgress( 
            /* [in] */ ULONG ulProgress,
            /* [in] */ ULONG ulProgressMax,
            /* [in] */ ULONG ulStatusCode,
            /* [in] */ LPCWSTR szStatusText);
        
        virtual HRESULT STDMETHODCALLTYPE OnStopBinding( 
            /* [in] */ HRESULT hresult,
            /* [unique][in] */ LPCWSTR szError);
        
        virtual /* [local] */ HRESULT STDMETHODCALLTYPE GetBindInfo( 
            /* [out] */ DWORD __RPC_FAR *grfBINDF,
            /* [unique][out][in] */ BINDINFO __RPC_FAR *pbindinfo);
        
        virtual /* [local] */ HRESULT STDMETHODCALLTYPE OnDataAvailable( 
            /* [in] */ DWORD grfBSCF,
            /* [in] */ DWORD dwSize,
            /* [in] */ FORMATETC __RPC_FAR *pformatetc,
            /* [in] */ STGMEDIUM __RPC_FAR *pstgmed);
        
        virtual HRESULT STDMETHODCALLTYPE OnObjectAvailable( 
            /* [in] */ REFIID riid,
            /* [iid_is][in] */ IUnknown __RPC_FAR *punk);

/*
   STDMETHODIMP OnStartBinding(IBinding* pbinding);
   STDMETHODIMP OnProgress(ULONG ulProgress, ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR pwzStatusText);
   STDMETHODIMP OnDataAvailable(DWORD grfBSCF, DWORD dwSize, 
                                FORMATETC *pFmtetc, REFIID riid, 
                                IUnknown* punk);
   STDMETHODIMP OnStopBinding(HRESULT hrResult);
*/

	// Prohibited use
	//
private:
	CXmlInternetFileManager& operator=(const CXmlInternetFileManager &obj);
};


#include "stdafx.h"
#include "XmlFileManager.h"

////////////////////////////////////////////////////////////////////////////////////////
//
//
// CXmlInternetFileManager class : access to a internet streamed XML resource
//
// packets are read and processed as they come in
// nothing is kept in memory to ensure that large XML files can be processed
//
// protocols supported : WINDOWS => HTTP, Authenticated HTTP, FTP
//							UNIX => HTTP, Authenticated HTTP
//
//
////////////////////////////////////////////////////////////////////////////////////////
//
//
CXmlInternetFileManager::CXmlInternetFileManager() :  m_cRef(0)
{
}
CXmlInternetFileManager::~CXmlInternetFileManager()
{
	Close();
}

CXmlInternetFileManager& CXmlInternetFileManager::operator=(const CXmlInternetFileManager &obj)
{
	// prohibited use
	return *this;
}



HRESULT CXmlInternetFileManager::QueryInterface(const IID& iid, void** ppv) // IBindStatusCallback interface support
{ 	
	if (iid == IID_IUnknown)
	{
		*ppv = static_cast<IBindStatusCallback*>(this) ;
	} 
	else if (iid == IID_IBindStatusCallback)
	{
		*ppv = static_cast<IBindStatusCallback*>(this) ;
	}
	else
	{  	   
		*ppv = NULL ;
		return E_NOINTERFACE;
	}
	reinterpret_cast<IUnknown*>(*ppv)->AddRef() ; 
	return S_OK ;
}

ULONG CXmlInternetFileManager::AddRef()
{
	return InterlockedIncrement(&m_cRef) ;
}

ULONG CXmlInternetFileManager::Release() 
{
	if (InterlockedDecrement(&m_cRef) == 0)
	{
		delete this ;
		return 0 ;
	}
	return m_cRef ;
}

// Methods
//

BOOL CXmlInternetFileManager::Open(char *szURL)
{
	HRESULT hr;

	if (!szURL || strlen(szURL)==0)
		return FALSE;

	m_dwLoadedSoFar=0;  // num bytes transferred so far
	m_dwOffsetReadByClient=0; 
	m_bStop_EvrythingIsReceived = FALSE; // init

	strcpy(m_szURL, szURL);

	m_tmpFile = fopen("c:\\test.txt","w+b"); 

	// Create async bind context
	IBindCtx *pbc=NULL;
	hr = CreateAsyncBindCtx(0, this /*IBindStatusCallback*/, NULL, &pbc);
	if (FAILED(hr))
		return FALSE;

	// Create a moniker for the URL
	IMoniker *pmk=NULL;

	WCHAR *swzURL = new WCHAR[strlen(szURL)+1];
    ::MultiByteToWideChar(CP_ACP, 0, szURL, -1, swzURL, strlen(szURL)+1);

	hr = CreateURLMoniker(NULL, swzURL, &pmk);
	if (FAILED(hr))
		return FALSE;

	// Register the moniker with the bind context. 
	// (Required for async monikers.)
	// RegisterObjectParam is a generic facility that monikers can use
	// to register stuff they need.
	//
	hr = pbc->RegisterObjectParam(SZ_ASYNC_CALLEE, pmk);
	if (FAILED(hr))
		return FALSE;

	// Transfer the image to disk.
	//
	// This initiates an HTTP transaction with the server 
	// to retrieve the file (e.g. barney.gif). 
	//
	// The call returns immediately and the data arrives later. As it does, 
	// the system calls your IBindStatusCallback::OnDataAvailable.
	//
	IStream* pStream;
	hr = pmk->BindToStorage(pbc, NULL, IID_IStream, (void**) &pStream);
	if (FAILED(hr))
		return FALSE;


	delete [] swzURL;

	return TRUE;
}

BOOL CXmlInternetFileManager::Read(char *szInputBuffer, int nMaxLength, int &nActualLength)
{
	while(1)
	{
		peekMessage();
	
		nActualLength = 0; // default

		if ( m_dwOffsetReadByClient < m_dwLoadedSoFar)  // num bytes transferred so far
		{
			long nAvailable = m_dwLoadedSoFar - m_dwOffsetReadByClient;
			if (nAvailable>nMaxLength-1)
				nAvailable = nMaxLength-1;

			fseek(m_tmpFile,m_dwOffsetReadByClient,SEEK_SET);
			nActualLength = fread(szInputBuffer, 1, nAvailable, m_tmpFile);
			szInputBuffer[nActualLength]='\0';

			m_dwOffsetReadByClient += nAvailable;

			return TRUE;
		}

		if (m_bStop_EvrythingIsReceived)
			return TRUE;  // cut down the while(1) loop if all data packets have been received

	} // end while

}

BOOL CXmlInternetFileManager::Close()
{
	if (m_tmpFile)
	{
		fclose(m_tmpFile);
		m_tmpFile=NULL;
	}


	return TRUE;
}


//////////////////
// Handle start of binding.
//

HRESULT STDMETHODCALLTYPE CXmlInternetFileManager::OnStartBinding( 
            /* [in] */ DWORD dwReserved,
            /* [in] */ IBinding __RPC_FAR *pib)
{
    m_pBinding = pib;       // save ptr to binding
    m_pBinding->AddRef();        // inc ref count
    m_pStream = NULL;
    return S_OK;
}
        
HRESULT STDMETHODCALLTYPE CXmlInternetFileManager::GetPriority( 
            /* [out] */ LONG __RPC_FAR *pnPriority)
{
	return S_OK;
}
        
HRESULT STDMETHODCALLTYPE CXmlInternetFileManager::OnLowResource( 
            /* [in] */ DWORD reserved)
{
	return S_OK;
}
        
HRESULT STDMETHODCALLTYPE CXmlInternetFileManager::OnProgress( 
            /* [in] */ ULONG ulProgress,
            /* [in] */ ULONG ulProgressMax,
            /* [in] */ ULONG ulStatusCode,
            /* [in] */ LPCWSTR szStatusText)
{
    return(NOERROR);
}
        
HRESULT STDMETHODCALLTYPE CXmlInternetFileManager::OnStopBinding( 
            /* [in] */ HRESULT hresult,
            /* [unique][in] */ LPCWSTR szError)
{
   m_pBinding->Release();  // done with binding
   m_pBinding = NULL;
   m_pStream  = NULL;

   m_bStop_EvrythingIsReceived = TRUE;
   return S_OK;
}
        
HRESULT STDMETHODCALLTYPE CXmlInternetFileManager::GetBindInfo( 
            /* [out] */ DWORD __RPC_FAR *grfBINDF,
            /* [unique][out][in] */ BINDINFO __RPC_FAR *pbindinfo)
{
	return S_OK;
}
        
HRESULT STDMETHODCALLTYPE CXmlInternetFileManager::OnDataAvailable( 
            /* [in] */ DWORD grfBSCF,
            /* [in] */ DWORD dwSize,
            /* [in] */ FORMATETC __RPC_FAR *pformatetc,
            /* [in] */ STGMEDIUM __RPC_FAR *pstgmed)
{
   if (m_pStream==NULL)
      // Note: this is the same stream returned from BindToStorage
      // but it's more convenient to use punk, which is a pointer
      // to whatever interface you requested in BindToStorage, which
      // in this case is IStream.
      //
      m_pStream = (IStream*) pstgmed->pstm;

   if (0) /*UserPressedCancel())*/ 
   {
      m_pBinding->Abort();  // abort the binding (download).
      // ...cleanup
   } 
   else 
   {
      // dwSize is total number of bytes of object retrieved
      if (dwSize > m_dwLoadedSoFar) 
	  {
         DWORD dwRead = dwSize - m_dwLoadedSoFar;
         DWORD dwActuallyRead;
         char *buf = new char[dwRead];
         m_pStream->Read(buf, dwRead, &dwActuallyRead);

         //
         // .. do something with new bytes, like append to file...
         //
		 fseek(m_tmpFile,0,SEEK_END);
		 fwrite(buf,1,dwActuallyRead,m_tmpFile);

         delete buf;

         m_dwLoadedSoFar = dwSize;
         //TRACE("Loaded another %d bytes\n", dwActuallyRead);
      }
   }
   return S_OK;
}
        
HRESULT STDMETHODCALLTYPE CXmlInternetFileManager::OnObjectAvailable( 
            /* [in] */ REFIID riid,
            /* [iid_is][in] */ IUnknown __RPC_FAR *punk)
{
	return S_OK;
}

m_Log.Create("Log window", WS_CHILD | WS_VISIBLE | SS_SUNKEN | SS_CENTERIMAGE | SS_NOTIFY| WS_CLIPSIBLINGS, CRect(10, 10, 100, 100), this, IDC_EDIT1) ;
m_WhizWheel.Create("Wheel", WS_CHILD | WS_VISIBLE | SS_BITMAP | SS_NOTIFY | WS_CLIPSIBLINGS, CRect(0, 0, 20, 20), this, IDC_WHIZ_WHEEL) ;
m_WhizWheel.SetBitmap(m_WheelBitmap[m_BitmapIndex]) ;
m_TrayProgress.Create(WS_CHILD | WS_VISIBLE | PBS_SMOOTH | SS_NOTIFY | WS_CLIPSIBLINGS, CRect(10, 10, 15, 100), this, IDC_TRAY_PROGRESS) ;
m_SampleProgress[0].Create(WS_CHILD | WS_VISIBLE | PBS_SMOOTH | SS_NOTIFY | WS_CLIPSIBLINGS, CRect(20, 10, 25, 100), this, IDC_SAMPLE_PROGRESS1) ;
m_SampleProgress[1].Create(WS_CHILD | WS_VISIBLE | PBS_SMOOTH | SS_NOTIFY | WS_CLIPSIBLINGS, CRect(20, 10, 25, 100), this, IDC_SAMPLE_PROGRESS2) ;
m_SampleProgress[2].Create(WS_CHILD | WS_VISIBLE | PBS_SMOOTH | SS_NOTIFY | WS_CLIPSIBLINGS, CRect(20, 10, 25, 100), this, IDC_SAMPLE_PROGRESS3) ;
m_SampleProgress[3].Create(WS_CHILD | WS_VISIBLE | PBS_SMOOTH | SS_NOTIFY | WS_CLIPSIBLINGS, CRect(20, 10, 25, 100), this, IDC_SAMPLE_PROGRESS4) ;

m_ValveStatus.Create("?", WS_CHILD | WS_VISIBLE | SS_NOTIFY | WS_CLIPSIBLINGS, CRect(0, 0, 15, 15), this, IDC_VALVE_LED) ;
m_DadStatus.Create("?", WS_CHILD | WS_VISIBLE | SS_NOTIFY | WS_CLIPSIBLINGS, CRect(0, 0, 15, 15), this, IDC_DAD_LED) ;
m_LampStatus.Create("?", WS_CHILD | WS_VISIBLE | SS_NOTIFY | WS_CLIPSIBLINGS, CRect(0, 0, 15, 15), this, IDC_LAMP_LED) ;
m_DeviceStatus[0].Create("?", WS_CHILD | WS_VISIBLE | SS_NOTIFY | WS_CLIPSIBLINGS, CRect(0, 0, 15, 15), this, IDC_DEVICE1_LED) ;
m_DeviceStatus[1].Create("?", WS_CHILD | WS_VISIBLE | SS_NOTIFY | WS_CLIPSIBLINGS, CRect(0, 0, 15, 15), this, IDC_DEVICE2_LED) ;