camnet.cpp

Go to the documentation of this file.

// $Id: camnet.cpp 1282 2006-06-09 09:46:49Z alex $
/* @@tag:xara-cn@@ DO NOT MODIFY THIS LINE
================================XARAHEADERSTART===========================
 
               Xara LX, a vector drawing and manipulation program.
                    Copyright (C) 1993-2006 Xara Group Ltd.
       Copyright on certain contributions may be held in joint with their
              respective authors. See AUTHORS file for details.

LICENSE TO USE AND MODIFY SOFTWARE
----------------------------------

This file is part of Xara LX.

Xara LX is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as published
by the Free Software Foundation.

Xara LX and its component source files are distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with Xara LX (see the file GPL in the root directory of the
distribution); if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA  02110-1301 USA


ADDITIONAL RIGHTS
-----------------

Conditional upon your continuing compliance with the GNU General Public
License described above, Xara Group Ltd grants to you certain additional
rights. 

The additional rights are to use, modify, and distribute the software
together with the wxWidgets library, the wxXtra library, and the "CDraw"
library and any other such library that any version of Xara LX relased
by Xara Group Ltd requires in order to compile and execute, including
the static linking of that library to XaraLX. In the case of the
"CDraw" library, you may satisfy obligation under the GNU General Public
License to provide source code by providing a binary copy of the library
concerned and a copy of the license accompanying it.

Nothing in this section restricts any of the rights you have under
the GNU General Public License.


SCOPE OF LICENSE
----------------

This license applies to this program (XaraLX) and its constituent source
files only, and does not necessarily apply to other Xara products which may
in part share the same code base, and are subject to their own licensing
terms.

This license does not apply to files in the wxXtra directory, which
are built into a separate library, and are subject to the wxWindows
license contained within that directory in the file "WXXTRA-LICENSE".

This license does not apply to the binary libraries (if any) within
the "libs" directory, which are subject to a separate license contained
within that directory in the file "LIBS-LICENSE".


ARRANGEMENTS FOR CONTRIBUTION OF MODIFICATIONS
----------------------------------------------

Subject to the terms of the GNU Public License (see above), you are
free to do whatever you like with your modifications. However, you may
(at your option) wish contribute them to Xara's source tree. You can
find details of how to do this at:
  http://www.xaraxtreme.org/developers/

Prior to contributing your modifications, you will need to complete our
contributor agreement. This can be found at:
  http://www.xaraxtreme.org/developers/contribute/

Please note that Xara will not accept modifications which modify any of
the text between the start and end of this header (marked
XARAHEADERSTART and XARAHEADEREND).


MARKS
-----

Xara, Xara LX, Xara X, Xara X/Xtreme, Xara Xtreme, the Xtreme and Xara
designs are registered or unregistered trademarks, design-marks, and/or
service marks of Xara Group Ltd. All rights in these marks are reserved.


      Xara Group Ltd, Gaddesden Place, Hemel Hempstead, HP2 6EX, UK.
                        http://www.xara.com/

=================================XARAHEADEREND============================
 */
#include "camtypes.h"
#include <fstream.h>
#include <io.h>
#include <stdlib.h>
#include <direct.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <process.h>
#include "sglcart.h"
#include "pathnmex.h"
#include "camnet.h"
#include "sgliboil.h"
//#include "webster.h"
//#include "thumb.h" - in camtypes.h [AUTOMATICALLY REMOVED]
#include "registry.h"
//#include "resource.h"
//#include "simon.h"
//#include "tim.h"
//#include "app.h" - in camtypes.h [AUTOMATICALLY REMOVED]
//#include "helpdownload.h"

using namespace InetUtils;

CC_IMPLEMENT_DYNAMIC(AsynchDownload, CCObject);
CC_IMPLEMENT_MEMDUMP(DownloadQueue, CCObject);
CC_IMPLEMENT_MEMDUMP(DownloadCache, CCObject);
CC_IMPLEMENT_MEMDUMP(InternetManager, CCObject);

#define new CAM_DEBUG_NEW

#define MAX_ATTEMPTS    5 // maximum no. of attempts made to download a file
#define ICON_ANIMATION      101 // timer event for icon animation
#define ICON_UPDATE_INTERVAL    300


// static members
CTypedPtrMap<CMapPtrToPtr, HWND, AsynchDownload::AsynchBindStatusCallback*> AsynchDownload::AsynchBindStatusCallback::m_CallbackTable; 
HWND AsynchDownload::AsynchBindStatusCallback::m_hNormalPriorityProgressDlg = NULL;
UINT32 AsynchDownload::AsynchBindStatusCallback::m_nNormalPriorityIconID = _R(IDI_DOWNLOADING);
INT32 AsynchDownload::m_nNormalPriorityInstanceCount = 0;
INT32 AsynchDownload::m_nHighPriorityInstanceCount = 0;
HICON AsynchDownload::AsynchBindStatusCallback::m_hiconProgress = 0;

// Matt 15/02/2001
typedef BOOL (WINAPI *P_GDFSE)(LPCTSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER);
                                                  
                                                  
// AsynchDownload
                                                  
/********************************************************************************************

  > AsynchDownload::AsynchDownload(DOWNLOAD_HANDLE hDownload, LPDOWNLOADINFO pDownloadInfo)

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:     hDownload - handle of download as assigned by the InternetManager
                    pDownloadInfo - pointer to DOWNLOADINFO struct
                                
    Purpose:    Constructor
                     
    Notes:      This constructor is not meant to be called directly  - use InternetManager::RegisterDownload()
                    if you want to download a file

********************************************************************************************/

AsynchDownload::AsynchDownload(DOWNLOAD_HANDLE hDownload, LPDOWNLOADINFO pDownloadInfo)
{
    m_Handle = hDownload;
    m_bSuccess = FALSE;
    m_ulFileSize = 0;
    m_ulDownloaded = 0;
    m_nPercentageDownloaded = 0;
    m_bAbort = FALSE;
    m_pMoniker = NULL;
    m_pBindContext = NULL;
    m_pCallback = NULL;
    m_strTargetURL = pDownloadInfo->strURL;
    m_strLocalFilePath = pDownloadInfo->strLocalFile;
    m_nFileType = (FileType) pDownloadInfo->nFileType;
    m_nAttempts = 0;
    m_Priority = (Priority) pDownloadInfo->nPriority;
    m_bHasProgressDlg = pDownloadInfo->bHasProgressDlg;
    if (m_bHasProgressDlg = pDownloadInfo->bHasProgressDlg)
        m_strDescription = pDownloadInfo->strDescription;
    if (m_Priority == PRIORITY_NORMAL)
        m_nNormalPriorityInstanceCount++;
    else if (m_Priority == PRIORITY_HIGH)
        m_nHighPriorityInstanceCount++;

    m_hwndNotifyWindow = pDownloadInfo->hwndNotifyWindow;
    m_lNotifyToken = pDownloadInfo->lNotifyToken;

    AfxOleLockApp();
}

AsynchDownload::~AsynchDownload()
{
    // Deallocate whatever resources were alocated during the binding operation
    Cleanup();
    if (m_Priority == PRIORITY_NORMAL)
        m_nNormalPriorityInstanceCount--;
    else if (m_Priority == PRIORITY_HIGH)
        m_nHighPriorityInstanceCount--;
    AfxOleUnlockApp();
}



/********************************************************************************************

  > HRESULT AsynchDownload::DoBind()

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:     none 
    Return:     S_OK if successful, E_FAIL otherwise
    Purpose:    Binds asynchronously an URL moniker to local storage (a file in the Internet cache)
                    The function returns immediately an HRESULT indicating merely whether the bind was started successfuly,
                    or failed due to invalid data, insufficient memory, etc., not waiting for the bind to complete. The result of the
                    started bind operation is returned by AsynchBindCallback::OnStopBind().
                     
    
********************************************************************************************/



HRESULT AsynchDownload::DoBind()
{
    if (m_strTargetURL.IsEmpty() || m_strLocalFilePath.IsEmpty())
    {
        ERROR3("Invalid (empty) URL or file path");
        return E_FAIL;
    }
#ifdef _DEBUG
    String_256 strErrorMsg(m_strTargetURL); // we keep a non-wide copy of the URL for error reporting purposes
#endif
    WCHAR wchURL[INTERNET_MAX_PATH_LENGTH];
    MultiByteToWideChar(CP_ACP, 0,  (TCHAR*) m_strTargetURL, -1, wchURL, INTERNET_MAX_PATH_LENGTH);
    if (IsValidURL(NULL, wchURL, 0) == S_FALSE)
    {
#ifdef _DEBUG
        strErrorMsg += _T(" is not a valid URL");
        ERROR3(strErrorMsg);
#endif
        return E_FAIL;
    }
    IStream* pStream = NULL;
    m_pCallback = new AsynchBindStatusCallback(this);
    if (!m_pCallback)
    { 
        ERROR3("Memory allocation error");
        return E_OUTOFMEMORY;
    }
    HRESULT hr = CreateURLMoniker(NULL, wchURL, &m_pMoniker);
    if (FAILED(hr))
    {
        ERROR3("Could not create URL Moniker");
        Cleanup();
        return hr;
    }
    hr = CreateBindCtx(0, &m_pBindContext);
    if (FAILED(hr))
    {
        ERROR3("Could not create bind context");
        Cleanup();
        return hr;
    }
    hr = RegisterBindStatusCallback(m_pBindContext, m_pCallback, 0, 0L);
    if (FAILED(hr))
    {
        ERROR3("Failed to register callback object");
        Cleanup();
        return hr;
    }
    hr = m_pMoniker->BindToStorage(m_pBindContext, 0, IID_IStream, (void**)&pStream);
    m_nAttempts++;
    return hr;
}



/********************************************************************************************
>   void AsynchDownload::Cleanup()

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:         -
    Returns:    -
    Purpose:    Releases COM objects allocated during the binding process.


********************************************************************************************/
void AsynchDownload::Cleanup()
{
    if (m_pCallback)
    {
        m_pCallback->Release();
        m_pCallback = NULL;
    }
    if (m_pMoniker)
    {
        m_pMoniker->Release();
        m_pMoniker = NULL;
    }
    if (m_pBindContext)
    {
        m_pBindContext->Release();
        m_pBindContext = NULL;
    }
}

/********************************************************************************************
>   HRESULT AsynchDownload::Retry()

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:         -
    Returns:    - always S_OK               

    Purpose:    called in case of network error to retry the download

********************************************************************************************/
HRESULT AsynchDownload::Retry()
{
    if (m_nAttempts <= MAX_ATTEMPTS) // try another bind if we're allowed
    {
        TRACEUSER( "adrian", _T("\n\nRetrying the %d time to download %s\n\n"), m_nAttempts, (TCHAR*) m_strTargetURL);
        Cleanup();
        DoBind();
    }
    else // just inform the download manager that we're done
    {
        TRACEUSER( "adrian", _T("\n\nGiving up on %s\n\n"), (TCHAR*) m_strTargetURL);
        InternetManager::OnDownloadComplete(this);
    }
    return S_OK;
}


/********************************************************************************************
>   HRESULT AsynchDownload::AbortDownload()

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:         -
    Returns:    - S_OK if the download operation operation was successfully aborted.
                    - S_FALSE if the download was already aborted.
                    - E_FAIL if the download operation could not be aborted.

    Purpose:    cancels this download.


********************************************************************************************/


HRESULT AsynchDownload::AbortDownload()
 {
    if (m_bAbort)
        return S_FALSE;
    else
        m_bAbort = TRUE;
    if (m_pCallback)
    {
        if (m_pCallback->m_pBinding)
            return m_pCallback->m_pBinding->Abort();
        else
            return E_FAIL;
    }
    return E_FAIL;
}


/********************************************************************************************
>   void AsynchDownload::Release()

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:         -
    Returns:    - 

    Purpose:    Provides a safe way to free memory and resources allocated to this download
                    Should be used in preference to the delete operator which may cause access
                    violations if the download is still in progress

********************************************************************************************/

void AsynchDownload::Release()
{
    if (m_pCallback && m_pCallback->m_pBinding)
        m_pCallback->m_pBinding->Abort();
    else
        delete this;
}



/********************************************************************************************
>  AsynchDownload::AsynchBindStatusCallback::AsynchBindStatusCallback(AsynchDownload* pDownload)

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:       pDownload     - pointer to the AsynchDownload object owning the callback
    Returns:    none
    Purpose:   callback object constructor.

********************************************************************************************/


AsynchDownload::AsynchBindStatusCallback::AsynchBindStatusCallback(AsynchDownload* pDownload)
{
    m_dwRef = 1;
    m_pDownload = pDownload;
    m_pBinding = NULL;
    m_hProgressDlg = NULL;
    m_nIconID = _R(IDI_DOWNLOADING); 
}


/********************************************************************************************
>   AsynchDownload::AsynchBindStatusCallback::~AsynchBindStatusCallback()

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:       none
    Returns:    none
    Purpose:   callback object destructor.

********************************************************************************************/

AsynchDownload::AsynchBindStatusCallback::~AsynchBindStatusCallback()
{
    if (m_pBinding) // download still in progress
    {
        // this will almost certainly result in an access violation
        ERROR3("AsynchDownload deleted while still in progress");
    }
}

/********************************************************************************************
>   HRESULT _stdcall AsynchDownload::AsynchBindStatusCallback::QueryInterface(REFIID riid,void ** ppv)

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:       riid  -   identifier of the requested interface
                     ppvObject  -   indirect pointer to the object
    Returns:    S_OK if the interface is supported, E_NOINTERFACE otherwise.
    Purpose:   standard IUnknown method

********************************************************************************************/
HRESULT _stdcall AsynchDownload::AsynchBindStatusCallback::QueryInterface(REFIID riid,void ** ppv)
{
    *ppv = NULL;

    if (riid==IID_IUnknown || riid==IID_IBindStatusCallback)
    {
        *ppv = this;
        AddRef();
        return S_OK;
    }
    else if (riid == IID_IAuthenticate)
    {
        *ppv = (IAuthenticate *)this;
        AddRef();
        return S_OK;
    }

    return E_NOINTERFACE;
}  

/********************************************************************************************
>   HRESULT _stdcall AsynchDownload::AsynchBindStatusCallback::OnStartBinding(DWORD dwReserved, IBinding* pbinding)

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:       dwReserved    -   not used, must be 0
                     pbinding   -   pointer to the IBinding interface for the current bind operation
    Returns: S_OK 
    Purpose:   standard IBindStatusCallback method (must be  implemented). Allows us to get a pointer to the binding. 
    See also:  MS Internet SDK documentation (URL Monikers)
********************************************************************************************/
HRESULT _stdcall AsynchDownload::AsynchBindStatusCallback::OnStartBinding(DWORD dwReserved, IBinding* pbinding)
{
    m_pDownload->m_ulFileSize = 0;
    m_pDownload->m_ulDownloaded = 0;
    // We save the pointer to the binding
    m_pBinding = pbinding;
    if (m_pBinding != NULL)
        m_pBinding->AddRef();
    // Create & display the progress dialog if the download requires one
    if (m_pDownload->m_bHasProgressDlg)
    {
        HWND hProgressDlg;
        BOOL bNeedsPositioning = (m_pDownload->m_Priority != PRIORITY_NORMAL) ||
                (m_pDownload->m_Priority == PRIORITY_NORMAL && !m_hNormalPriorityProgressDlg);
        if (!AttachProgressDlg())
        {
            ERROR3("Could not create progress dialog");
            goto END; 
        }
        if (m_pDownload->m_Priority == PRIORITY_NORMAL)
            hProgressDlg = m_hNormalPriorityProgressDlg;
        else
            hProgressDlg = m_hProgressDlg;
        if (hProgressDlg)
        {
            HWND hProgressBar = GetDlgItem(hProgressDlg, _R(IDC_PROGRESSBAR)); // hadle of progress bar
            HWND hPercentage = GetDlgItem(hProgressDlg, _R(IDC_PERCENTAGE)); // handle of static text used to display percent downloaded
            ERROR3IF(!(hProgressBar && hPercentage), "Cannot find control");
            // Set initial position on the progress bar to 0
            ::SendMessage(hProgressBar, PBM_SETPOS, (WPARAM) 0, 0);
            // Set initial percentage
            String_256 strPercentage = _T("0%");
            // Set the dialog caption
            String_256 strURL = m_pDownload->m_strTargetURL;
            strtok(strURL, _T(":/"));
            String_256 strCaption;
            strCaption.MakeMsg(_R(IDS_CONTACTING_HOST), strtok(NULL, _T(":/")));
            ::SetWindowText(hProgressDlg, (TCHAR*) strCaption);
            ::SetWindowText(hPercentage, (TCHAR*) strPercentage);
            // Position the window if necessary 
            if (bNeedsPositioning)
            {
                CRect rcDialog;
                ::GetWindowRect(hProgressDlg, &rcDialog);
                // Finally position & show the dialog box
                ::SetWindowPos(hProgressDlg, HWND_TOPMOST, ::GetSystemMetrics(SM_CXSCREEN) - rcDialog.Width(), 0,
                        0, 0, SWP_NOSIZE | SWP_SHOWWINDOW);
            }
            else
                ::SetWindowPos(hProgressDlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW);

            ::UpdateWindow(hProgressBar);
            ::UpdateWindow(hPercentage);
            ::UpdateWindow(hProgressDlg);
        }
    }
END:    
    return S_OK;
}

/********************************************************************************************
>   HRESULT _stdcall  AsynchDownload::AsynchBindStatusCallback::OnProgress(UINT32 ulProgress, UINT32 ulProgressMax, UINT32 ulStateCode,
                            LPCWSTR pwzStateText)

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:       ulProgress    -   progress indicator for bind operation
                     ulProgressMax  -   expected maximum value of ulProgress parameter
                     ulStateCode    -   BINDSTATUS value indicating bind progress
                     szStateText    -   displayable information indicating bind progress
    Returns:    NOERROR or E_ABORT if Abort() has been called 
    Purpose:   standard IBindStatusCallback (must be implemented). Allows monitoring the progress of the bind.
                    changes 
    See also:  MS Internet SDK documentation (URL Monikers)
********************************************************************************************/
HRESULT _stdcall  AsynchDownload::AsynchBindStatusCallback::OnProgress(UINT32 ulProgress, UINT32 ulProgressMax, UINT32 ulStateCode,
                            LPCWSTR pwzStateText)
{
    if (m_pDownload->m_bAbort)
    {
        return E_ABORT;
    }
    TCHAR   sz[256];
    if(pwzStateText != NULL)
        WideCharToMultiByte(CP_ACP, 0, pwzStateText, -1, sz, sizeof(sz)/sizeof(TCHAR), 0, 0);
    // Update download progress
    // (Note that ulProgressMax is the file size returned by the server and if may be 0 if the server doesn't know it)
    // (Hopefully our server is better than that)
    m_pDownload->m_ulFileSize = (ulProgress > ulProgressMax) ? ulProgress : ulProgressMax;
    m_pDownload->m_ulDownloaded = ulProgress;
    INT32 nPercentage = (ulProgress && ulProgressMax) ? (100 * ulProgress/ulProgressMax) : 0;

    if (nPercentage!=m_pDownload->m_nPercentageDownloaded)
    {
        // we should inform our client that things are happening...
        InternetManager::SetState(m_pDownload->m_Handle, AsynchDownload::STATE_PENDING);
    }

    m_pDownload->m_nPercentageDownloaded = nPercentage;
    if (m_pDownload->m_bHasProgressDlg)
    {
        HWND hProgressDlg;
        if (m_pDownload->m_Priority == PRIORITY_NORMAL)
            hProgressDlg = m_hNormalPriorityProgressDlg;
        else
            hProgressDlg = m_hProgressDlg;
        // Make sure the progress dialog handle is still valid before attempting to update it 
        if (hProgressDlg && ::IsWindow(hProgressDlg))
        {   
            HWND hPercentage = GetDlgItem(hProgressDlg, _R(IDC_PERCENTAGE)); // handle of static text used to display percent downloaded
            HWND hProgressBar = GetDlgItem(hProgressDlg, _R(IDC_PROGRESSBAR)); // handle of progress bar
            if (!(hPercentage && hProgressBar))
            {
                ERROR3("Cannot find control");
            }
            else
            {
                String_256 strCaption, strPercentage;
                switch (ulStateCode)
                {
                    case BINDSTATUS_FINDINGRESOURCE: // these 3 states are now displayed as "Contacting host..."
                    case BINDSTATUS_CONNECTING:
                    case BINDSTATUS_SENDINGREQUEST:
                        break;

                    case BINDSTATUS_DOWNLOADINGDATA:
                        {
                            strCaption = String_256(_R(IDS_DOWNLOAD));
                            if (m_pDownload->m_strDescription.IsEmpty()) // no description available, just use the filename
                            {
                                strCaption+= _T("'");
                                strCaption += strrchr(m_pDownload->m_strTargetURL, _T('/')) + 1;
                                strCaption+= _T("'");
                            }
                            else
                            {
                                strCaption += m_pDownload->m_strDescription;
                            }
                            if (!ulProgressMax)
                            {
                                strPercentage = "N/A"; // in case the server didn't return any size information
                                m_pDownload->m_nPercentageDownloaded = 0;
                            }
                            else // set the progress bar to the percentage we have downloaded
                            {
                                wsprintf(strPercentage, "%d%%", nPercentage);
                                ::SendMessage(hProgressBar, PBM_SETPOS, (WPARAM) nPercentage, 0);
                                // Force an immediate repaint to avoid any redraw latency
                                ::UpdateWindow(hProgressBar);
                            }
                        }
                        break;
                    case BINDSTATUS_ENDDOWNLOADDATA:
                        strPercentage = _T("100%");
                        ::SendMessage(hProgressBar, PBM_SETPOS, (WPARAM) 100, 0);
                        // Force an immediate repaint to avoid any redraw latency
                        ::UpdateWindow(hProgressBar);
                        strCaption = String_256(_R(IDS_ENDDOWNLOAD));
                        break;
                }
                // We'll update the controls only if the new strings are different to the current ones so that we don't 
                // get any flicker 
                TCHAR tchBuff[96];
                ::GetWindowText(hPercentage, tchBuff, sizeof(tchBuff)/sizeof(TCHAR));
                if (strPercentage != String_256(tchBuff))
                {
                    ::SetWindowText(hPercentage, (TCHAR*) strPercentage);
                    ::UpdateWindow(hPercentage);
                }
                ::GetWindowText(hProgressDlg, tchBuff, sizeof(tchBuff)/sizeof(TCHAR));
                if (strCaption.Length() && strCaption != String_256(tchBuff)) // we need to update the message
                {
                    ::SetWindowText(hProgressDlg, (TCHAR*) strCaption);
                    ::UpdateWindow(hProgressDlg);
                }
            }
        }
    }   
    // Save filename of local image if available
    if (ulStateCode == BINDSTATUS_CACHEFILENAMEAVAILABLE)
        m_pDownload->m_strCacheFileName = sz;

    return (NOERROR);
}


/********************************************************************************************
>   HRESULT _stdcall AsynchDownload::AsynchBindStatusCallback::OnStopBinding(HRESULT hrState, LPCWSTR szError)

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:       hrState   -       bind operation status code
                     szError    -   currently not used
    Returns:    S_OK 
    Purpose:   standard IBindStatusCallback (must be implemented). Allows us to retrieve the result of the bind in hrState.
    See also:  MS Internet SDK documentation (URL Monikers)
********************************************************************************************/

HRESULT _stdcall AsynchDownload::AsynchBindStatusCallback::OnStopBinding(HRESULT hrState, LPCWSTR szError)
{
#ifdef _DEBUG
    if (hrState) // download diagnostic in debug builds
    {
        TCHAR szErrorMsg[256];
        if (hrState == 0x800C0006) // file not found
            wsprintf(szErrorMsg, "%s %s\n", (TCHAR*) (String_256) m_pDownload->m_strTargetURL, _T("not found on the server"));
        else
            wsprintf(szErrorMsg, "%s %s\n", _T("Got network error (possibly host not found) downloading"), (TCHAR*) (String_256) m_pDownload->m_strTargetURL);
         if (hrState != 0x80004004) // user cancel
             TRACE(szErrorMsg);

         // Write error to log
         String_256 strAppDataPath;
         GetAppDataPath(&strAppDataPath);
         PathName logPath(strAppDataPath);
         String_256 strLogName("errlog.txt");
         logPath.SetFileNameAndType(strLogName);
         static BOOL bShouldOverwrite = TRUE; // overwrite any error log generated in a previous session
         INT32 iFlags = bShouldOverwrite ? ios::out | ios::trunc    :   ios::out | ios::app;
         bShouldOverwrite = FALSE;
         ofstream logFile((TCHAR*) (String_256) logPath.GetPath(), iFlags);
         if (!logFile.bad())
             logFile << szErrorMsg;
         logFile.close();
    }
#endif

    // Clean up
    if (m_pBinding)
    {
        m_pBinding->Release();
        m_pBinding = NULL;
    }
    if (m_pDownload->m_bHasProgressDlg)
        DetachProgressDlg(); // release/destroy the progress dialog, if any

    if (!hrState && !m_pDownload->m_bAbort) // file downloaded successfully
    {
        // The file has been downloaded to the system internet cache, so we need to copy it over to the required location
        PathNameEx path(m_pDownload->m_strLocalFilePath);
        BOOL bIsCacheFile = DownloadCache::IsCachePath(m_pDownload->m_strLocalFilePath); 
        if (!path.CreateLocation()) // create the directory path if it doesn't exist - otherwise ofstream() may fail
        {
            InformError(_R(IDS_DIRCREATEFAIL), _R(IDS_OK));
            m_pDownload->m_bSuccess = FALSE;
            goto COMPLETE;
        }
        ifstream stmCache((TCHAR*) m_pDownload->m_strCacheFileName, ios::in | ios::nocreate | ios::binary);
        // We overwrite the existing file if any
        DownloadCache::RemoveFile(m_pDownload->m_strLocalFilePath);
        if (bIsCacheFile)
            DownloadCache::m_CacheMonitor.IgnoreEvents(1);
        ofstream stmFile((TCHAR*) m_pDownload->m_strLocalFilePath, ios::out | ios::binary | ios::trunc);
        if (stmCache.bad() || stmFile.bad())
        {
            String_256 strTemp;
            PathName path(m_pDownload->m_strLocalFilePath);
            strTemp.MakeMsg(_R(IDS_FILEIOERROR), (TCHAR*) String_256(path.GetFileName()));
            Error::SetError(0, strTemp, 0);
            InformError();
            stmFile.close();
            stmCache.close();
            goto COMPLETE;
        }
        stmFile << stmCache.rdbuf();
        if (stmFile.bad() || stmCache.bad())
        {
            String_256 strTemp;
            PathName path(m_pDownload->m_strLocalFilePath);
            strTemp.MakeMsg(_R(IDS_FILEIOERROR), (TCHAR*) String_256(path.GetFileName()));
            Error::SetError(0,strTemp, 0);
            InformError();
        }
        else
            m_pDownload->m_bSuccess = TRUE;
        stmFile.close();
        stmCache.close();
    }
    else if (hrState == 0x800C0007) // we got a network error (unfortunately these error codes are not documented by Microsoft)
    {
        return m_pDownload->Retry();
    }
         
COMPLETE:
    InternetManager::OnDownloadComplete(m_pDownload);
    return S_OK;
}  

/********************************************************************************************
>   HRESULT _stdcall AsynchDownload::AsynchBindStatusCallback::GetBindInfo(DWORD* pgrfBINDF, BINDINFO* pbindInfo)

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:       pgrfBINDF -   pointer to BINDF value
                     pbindinfo  -   pointer to BINDINFO structure
    Returns:    S_OK 
    Purpose:   standard IBindStatusCallback method (must be implemented)
    See also:  MS Internet SDK documentation (URL Monikers)
********************************************************************************************/
HRESULT _stdcall AsynchDownload::AsynchBindStatusCallback::GetBindInfo(DWORD* pgrfBINDF, BINDINFO* pbindInfo)
{
    *pgrfBINDF = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_GETNEWESTVERSION; // bind asynchronously
    pbindInfo->cbSize = sizeof(BINDINFO);
    pbindInfo->szExtraInfo = NULL;
    memset(&pbindInfo->stgmedData, 0, sizeof(STGMEDIUM));
    pbindInfo->grfBindInfoF = 0;
    pbindInfo->dwBindVerb = BINDVERB_GET;
    pbindInfo->szCustomVerb = NULL;
    return S_OK;
} 

/********************************************************************************************
> HRESULT _stdcall AsynchDownload::AsynchBindStatusCallback::OnDataAvailable(DWORD grfBSCF, DWORD dwSize, FORMATETC *pfmtetc,
                            STGMEDIUM* pstgmed)

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:       gfBSCF    -   BSCF enumeration values
                     dwSize -   length of data in bytes available from current bind operation
                     pfmtetc    -   pointer to FORMATETC structure
                     pstgmed    -   Pointer to STGMEDIUM structure
    Returns:    S_OK 
    Purpose:   standard IBindStatusCallback method (must be implemented, so we just return S_OK)
    See also:  MS Internet SDK documentation (URL Monikers)
********************************************************************************************/
HRESULT _stdcall AsynchDownload::AsynchBindStatusCallback::OnDataAvailable(DWORD grfBSCF, DWORD dwSize, FORMATETC *pfmtetc,
                            STGMEDIUM* pstgmed)
{
    // We're not reading any data before the download is complete, so just return S_OK 
    return S_OK;
}  

/********************************************************************************************
>   STDMETHODIMP AsynchDownload::AsynchBindStatusCallback::Authenticate(HWND *phwnd,
                                                    LPWSTR *pszUserName, LPWSTR *pszPassword)
    Author:     Jonathan_Payne (Xara Group Ltd) <camelotdev@xara.com>
    Created:    14/02/2001
    Purpose:    This method is called when athentication is required to access a resource.
                We simply tell the calling function to go away and the authentication it's
                self.
    See also:   MSDN docs for the function
********************************************************************************************/
STDMETHODIMP AsynchDownload::AsynchBindStatusCallback::Authenticate(HWND *phwnd, LPWSTR *pszUserName, LPWSTR *pszPassword)
{
    *phwnd = AfxGetMainWnd()->m_hWnd;
    *pszUserName = 0;
    *pszPassword = 0;

    return S_OK;
}

/********************************************************************************************
> BOOL CALLBACK AsynchDownload::AsynchBindStatusCallback::DialogProc(HWND hwndDlg, UINT32 message, WPARAM wParam, LPARAM lParam)

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:      hwndDlg - identifies the dialog box. 
                    uMsg - specifies the message. 
                    wParam - specifies additional message-specific information. 
                    lParam - specifies additional message-specific information

    Returns:    non-zero if it processes the message, 0 if not
    Purpose:   progress dialog procedure

********************************************************************************************/

BOOL CALLBACK AsynchDownload::AsynchBindStatusCallback::DialogProc(HWND hDlg, UINT32 message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
     {
        case WM_TIMER:
        {
            if (wParam == ICON_ANIMATION)
            {
                UINT32* pIconID = NULL;
                if (hDlg == m_hNormalPriorityProgressDlg)
                    pIconID = &m_nNormalPriorityIconID;
                else
                {
                    AsynchBindStatusCallback* pCallback = NULL;
                    if (!m_CallbackTable.Lookup(hDlg, pCallback))
                    {
                        ERROR3("Callback not found in the lookup table");
                    }
                    else if (pCallback)
                        pIconID = &pCallback->m_nIconID;
                }
                if (*pIconID == _R(IDI_DOWNLOADING6))
                    *pIconID = _R(IDI_DOWNLOADING);
                else
                    (*pIconID)++;

                HICON hiconPrev = m_hiconProgress;
                m_hiconProgress = (HICON)::LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(*pIconID), IMAGE_ICON, 16, 16, 0);
                ::SendMessage(hDlg, WM_SETICON, (WPARAM) FALSE, (LPARAM) m_hiconProgress );
                ::DestroyIcon(hiconPrev);
                return TRUE;
            }
        }
        break;
        case WM_COMMAND:
        {
            switch (LOWORD(wParam))
            {
                case IDCANCEL:
                {
CANCEL:                 
                    if (m_hiconProgress)
                    {
                        ::DestroyIcon(m_hiconProgress);
                        m_hiconProgress = 0;
                    }

                    // Got CANCEL from the user, find the callback this dialog belongs to
                    if (hDlg == m_hNormalPriorityProgressDlg) // thumbnail/catalog file download progress
                    {
                        AsynchDownload* pDownload = InternetManager::GetCurrentNormalPriorityDownload();
                        if (pDownload)
                            pDownload->AbortDownload();
                        return TRUE;
                    }
                    AsynchBindStatusCallback* pCallback = NULL;
                    if (!m_CallbackTable.Lookup(hDlg, pCallback))
                    {
                        ERROR3("Callback not found in the lookup table");
                    }
                    else
                    {
                        if (pCallback && pCallback->m_pDownload)
                        {
                            // Although the callback object doesn't contain any runtime information and
                            // thus we cannot directly check if it's still valid or not, a non-null pointer in the callback
                            // table should guarantee that, as callback objects call DetachProgressDlg() when
                            // a download completes or is terminated by the user.
                            // Never use the delete operator on a download in progress (instead of calling the Release() member
                            // function) as it could result in pCallback being no longer valid at this point and cause an access violation
                            HRESULT result = pCallback->m_pDownload->AbortDownload();
                            ERROR3IF(result == E_FAIL, "Could not abort download");
                        }
                    }
                    return TRUE;
                }
                break;
            }
        }
        break;
        case WM_CLOSE:
            goto CANCEL; // we assume they actually want to cancel the download
    }
    return FALSE;
}


/********************************************************************************************
> BOOL AsynchDownload::AsynchBindStatusCallback::AttachProgressDlg()

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:      -
    Returns:    TRUE if the dialog box was created successful, FALSE otherwise
    Purpose:   creates a modeless progress dialog box and attach it to this callback,
                    i.e. make an entry in the callback table mapping the callback pointer 
                    to the handle of its dialog

********************************************************************************************/
BOOL AsynchDownload::AsynchBindStatusCallback::AttachProgressDlg()
{
    static BOOL bShouldRegisterClass = TRUE;
    if (bShouldRegisterClass) // register the progress dlg class if needed
    {
        WNDCLASSEX wndClass;
        static char szClassName[] =  "DownloadProgressDlg";
        if (!::GetClassInfoEx(NULL, MAKEINTRESOURCE(32770), &wndClass))
        {
            ERROR3("Failed to get class info");
        }
        wndClass.lpszClassName = szClassName;
        wndClass.hInstance = AfxGetResourceHandle();
        wndClass.hIcon = NULL;
        wndClass.hIconSm = (HICON) ::LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(_R(IDI_DOWNLOADING)), IMAGE_ICON, 16, 16, 0);
        wndClass.cbSize = sizeof(wndClass);
        ERROR3IF(!wndClass.hIconSm, "Failed to load icon");
        if (!::RegisterClassEx(&wndClass))
        {
            ERROR3("Failed to register progress dlg class");
        }
        else
            bShouldRegisterClass = FALSE;
    }
    if (m_pDownload->m_Priority == PRIORITY_HIGH) // high priority download - gets its own progress dialog
    {
        m_hProgressDlg = ::CreateDialogParam(AfxGetResourceHandle(), MAKEINTRESOURCE(_R(IDD_PROGRESS)), 
            HWND_DESKTOP,   (DLGPROC) &DialogProc, NULL);
        if (!m_hProgressDlg)
        {
            ERROR3("Could not create progress dialog");
            return FALSE;
        }
        else
        {
            // Enter the handle in the callback table
            m_CallbackTable[m_hProgressDlg] = this;
            ::SetTimer(m_hProgressDlg, ICON_ANIMATION, ICON_UPDATE_INTERVAL, NULL);
        }
    }
    else if (!m_hNormalPriorityProgressDlg) // low priority download - create dialog only if there is none to be reused
    {
        m_hNormalPriorityProgressDlg = ::CreateDialogParam(AfxGetResourceHandle(), MAKEINTRESOURCE(_R(IDD_PROGRESS)), 
            HWND_DESKTOP,   (DLGPROC) &DialogProc, NULL);
        if (!m_hNormalPriorityProgressDlg)
        {
            ERROR3("Could not create progress dialog");
            return FALSE;
        }
        else
            ::SetTimer(m_hNormalPriorityProgressDlg, ICON_ANIMATION, ICON_UPDATE_INTERVAL, NULL);
    }
    return TRUE;
}


/********************************************************************************************
> void AsynchDownload::AsynchBindStatusCallback::DetachProgressDlg()

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:      -
    Returns:    -
    Purpose:   called by OnStopBinding() to remove this callback's entry in the 
                    callback table - as it will be no longer valid - and destroy the 
                    progress dialog if one exists

********************************************************************************************/
void AsynchDownload::AsynchBindStatusCallback::DetachProgressDlg()
{
    if (m_hProgressDlg && m_pDownload->m_Priority == PRIORITY_HIGH)
    {
        BOOL bDestroyed = FALSE;
        // Kill the icon animation timer
        bDestroyed = ::KillTimer(m_hProgressDlg, ICON_ANIMATION);
        ERROR3IF(!bDestroyed, "Warning: timer not destroyed");
        // Make sure the progress dialog is destroyed 
        if (::IsWindow(m_hProgressDlg))
            bDestroyed = ::DestroyWindow(m_hProgressDlg);
        ERROR3IF(!bDestroyed, "Warning: progress dialog not destroyed");
        // Just in case we couldn't destroy the window for some reason we'll set the dialog handle
        // entry in the callback table to NULL indicating it references a callback pointer no longer valid
        m_CallbackTable[m_hProgressDlg] = NULL;
        m_hProgressDlg = NULL;
    }
    else if (m_hNormalPriorityProgressDlg && m_pDownload->m_Priority == PRIORITY_NORMAL)
    {
        if (m_pDownload->m_nNormalPriorityInstanceCount == 1)
        {
            // Kill the icon animation timer
            BOOL bDestroyed = ::KillTimer(m_hNormalPriorityProgressDlg, ICON_ANIMATION);
            ERROR3IF(!bDestroyed, "Warning: timer not destroyed");
            ::DestroyWindow(m_hNormalPriorityProgressDlg);
            m_hNormalPriorityProgressDlg = NULL;
        }
    }
}



// DownloadQueue


/********************************************************************************************
> DownloadQueue::~DownloadQueue()

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:       none
    Returns:    none 
    Purpose:   destructor
********************************************************************************************/

DownloadQueue::~DownloadQueue()
{
    if (!IsEmpty())
        Flush();
}



/********************************************************************************************
> DownloadQueue::Queue(AsynchDownload* pDownload)

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:       pDownload     -   pointer to download to be queued
    Returns:    TRUE is successful, FALSE otherwise
    Purpose:   Adds a new download  pointer to the queue
********************************************************************************************/


BOOL DownloadQueue::Queue(AsynchDownload* pDownload)
{
    if (!pDownload)
    {
        ERROR3("Unexpected NULL pointer");
        return FALSE;
    }
    if (m_enType != LIFO && m_enType != FIFO)
    {
        ERROR3("Invalid queue type");
        return FALSE;
    }
    try
    {
        if (m_enType == FIFO)
            m_List.AddTail(pDownload);
        else
            m_List.AddHead(pDownload);
    }
    catch (CMemoryException* pxMem)
    {
        pxMem->Delete();
        ERROR2(FALSE, "Could not queue download - memory problems");
    }
    return TRUE;
}


/********************************************************************************************
> DownloadQueue::Remove(AsynchDownload* pDownload)

    Author:     Adrian_Stoicar (Xara Group Ltd) <camelotdev@xara.com>
    Created:    18/11/96
    Inputs:       pDownload     -   pointer to download to be removed
    Returns:    TRUE is successful, FALSE otherwise
    Purpose:   remove a download  from the queue. The object is also deleted
********************************************************************************************/


BOOL DownloadQueue::Remove(AsynchDownload* pDownload)
{
    if (!pDownload)
    {
        ERROR3("Unexpected NULL pointer");
        return FALSE;
    }
    POSITION pos = m_Lis