// Copyright (c) 1996-1997, Microsoft Corp. All rights reserved.

#include "header.h"
#include "contain.h"
#include "cprint.h"
#include "secwin.h"
#include "web.h"
#include "contain.h"
#include <exdisp.h>
#include <exdispid.h>
#include "cdlg.h"
#include "resource.h"
#include "progress.h"
#include "cpaldc.h"
#include "hha_strtable.h"
#include "animate.h"
#include <wininet.h>

// #define INITGUID
#include <mshtmhst.h>
#include <mshtmcid.h>

BOOL CPrint::OnBeginOrEnd(void)
{
    if (m_fInitializing) {
        switch (m_action) {
            case PRINT_CUR_ALL:
                SetCheck(IDRADIO_PRINT_ALL);
                break;

            case PRINT_CUR_HEADING:
                SetCheck(IDRADIO_PRINT_BOOK);
                break;

            default:
                SetCheck(IDRADIO_PRINT_CURRENT);
                break;

        }
    }
    else {
        if (GetCheck(IDRADIO_PRINT_ALL))
            m_action = PRINT_CUR_ALL;
        else if (GetCheck(IDRADIO_PRINT_BOOK))
            m_action = PRINT_CUR_HEADING;
        else
            m_action = PRINT_CUR_TOPIC;
    }

    return TRUE;
}

void CHHWinType::OnPrint(void)
{
    HWND hWnd;

	if (m_pCIExpContainer == NULL)
	{
		return;
	}

    static BOOL fCurrentlyPrinting = FALSE;
    if (fCurrentlyPrinting) {
        MsgBox(IDS_PRINTING);
        return;
    }
    CToc* ptoc = reinterpret_cast<CToc*>(m_aNavPane[HH_TAB_CONTENTS]) ; // HACKHACK: This should be a dynamic_cast. However, we are not compiling with RTTI.
    hWnd = GetFocus();
    int action = PRINT_CUR_TOPIC;
    if (IsExpandedNavPane() && curNavType == HHWIN_NAVTYPE_TOC && ptoc != NULL)
    {
        HTREEITEM hitem = TreeView_GetSelection(ptoc->m_hwndTree);
        if (hitem) {
            CPrint prt(*this);
            prt.SetAction(action);
            if (!prt.DoModal())
            {
                SetFocus(hWnd);
                return;
            }
            action = prt.GetAction();
        }
    }

    if (action == PRINT_CUR_TOPIC) {
        m_pCIExpContainer->m_pIE3CmdTarget->Exec(NULL, OLECMDID_PRINT,
            OLECMDEXECOPT_PROMPTUSER, NULL, NULL);
    }
    else {
        fCurrentlyPrinting = TRUE;
        PrintTopics(action, ptoc, m_pCIExpContainer->m_pWebBrowserApp, GetHwnd());
        fCurrentlyPrinting = FALSE;
    }
    SetFocus(hWnd);
}

void PrintTopics(int action, CToc* ptoc, IWebBrowserAppImpl* pWebApp, HWND hWndHelp /* = NULL */)
{
    ASSERT(pWebApp && pWebApp);

    if (ptoc == NULL || pWebApp == NULL)
        return;

    static BOOL fCurrentlyPrinting = FALSE;
    if (fCurrentlyPrinting) {
        MsgBox(IDS_PRINTING);
        return;
    }
    fCurrentlyPrinting = TRUE;
    CStr cszCurrentUrl;
    pWebApp->GetLocationURL(&cszCurrentUrl);
    CPrintHook ph(cszCurrentUrl, ptoc, hWndHelp);
    ph.BeginPrinting(action);
    fCurrentlyPrinting = FALSE;
}

/////////////////////////////////////////////////////////////////////////////
// CPrintHook member functions
CPrintHook::CPrintHook(PCSTR pszFirstUrl, CToc* pToc, HWND hWndHelp /* = NULL */)
    : m_pcp(NULL), m_dwCookie(0), m_ref(0), m_pToc(pToc), m_action(PRINT_CUR_TOPIC),
    m_hWndHelp(hWndHelp), m_phh(NULL), m_level(0),
    m_fFirstHeading(TRUE), m_fDestroyHelpWindow(FALSE), m_cszFirstUrl(pszFirstUrl),
    m_fIsIE3(FALSE), m_cszPrintFile("")
{
    m_phh = pToc->m_phh;
}


BOOL CPrintHook::CreatePrintWindow(CStr* pcszUrl /* = NULL */)
{
    BOOL bReturn = FALSE;

    HH_WINTYPE hhWinType;
    ZERO_STRUCTURE(hhWinType);
    hhWinType.cbStruct = sizeof(HH_WINTYPE);
    hhWinType.pszType = txtPrintWindow;
    hhWinType.pszCaption = GetStringResource(IDS_PRINT_CAPTION);
    hhWinType.rcWindowPos.left = 0;
    hhWinType.rcWindowPos.top = 0;
    hhWinType.rcWindowPos.right = 200;
    hhWinType.rcWindowPos.bottom = 200;
    hhWinType.dwStyles = WS_MINIMIZE;
    hhWinType.fsValidMembers = HHWIN_PARAM_RECT | HHWIN_PARAM_STYLES;

    xHtmlHelpA(NULL, NULL, HH_SET_WIN_TYPE, (DWORD_PTR) &hhWinType);

    m_hWndHelp = xHtmlHelpA(NULL, txtPrintWindow, HH_DISPLAY_TOPIC, (DWORD_PTR) (pcszUrl ? pcszUrl->psz : m_cszFirstUrl.psz));
    m_fDestroyHelpWindow = TRUE;

    if (m_hWndHelp != NULL)
    {
        StartAnimation(IDS_GATHERING_PRINTS, m_hWndHelp);
        m_phh = FindWindowIndex(m_hWndHelp);

        if (!m_fDestroyHelpWindow)
            m_phh->m_pCIExpContainer->m_pWebBrowserApp->Navigate((pcszUrl ? (PCSTR)*pcszUrl : (PCSTR)m_cszFirstUrl),
                                                                    NULL, NULL, NULL, NULL);

        // Set up the event sink for the WebBrowser control.
        LPCONNECTIONPOINTCONTAINER pcpc;
        HRESULT hr = m_phh->m_pCIExpContainer->m_pWebBrowserApp->m_lpDispatch->QueryInterface(IID_IConnectionPointContainer, (LPVOID*)&pcpc);

        if (SUCCEEDED(hr))
        {
            // Try to find the connection point for DIID_DWebBrowserEvents2.
            // If that fails, try DIID_DWebBrowserEvents.
            hr = pcpc->FindConnectionPoint(DIID_DWebBrowserEvents2, &m_pcp);

            if (FAILED(hr))
            {
                m_fIsIE3 = TRUE;
                hr = pcpc->FindConnectionPoint(DIID_DWebBrowserEvents, &m_pcp);
            }

            pcpc->Release();

            if (SUCCEEDED(hr))
            {
                hr = m_pcp->Advise((LPUNKNOWN)(LPDISPATCH)this, &m_dwCookie);
                bReturn = TRUE;
            }
        }
    }

    return bReturn;
}


void CPrintHook::DestroyPrintWindow()
{
    // Disconnect the event sink.
    if (m_pcp != NULL)
    {
#ifdef _DEBUG
        HRESULT hr = m_pcp->Unadvise(m_dwCookie);
        ASSERT(SUCCEEDED(hr));
#else
        m_pcp->Unadvise(m_dwCookie);
#endif
        m_pcp->Release();
        m_pcp = NULL;
    }

    if (m_hWndHelp != NULL)
    {
        if (m_fDestroyHelpWindow)
        {
            DestroyWindow(m_hWndHelp);
            m_hWndHelp = NULL;
        }
    }

    DeleteFile(m_cszPrintFile);
}


CPrintHook::~CPrintHook()
{
    DestroyPrintWindow();

    ASSERT(m_ref == 0);
}


// Generic OLE method implementations.

STDMETHODIMP CPrintHook::QueryInterface(
    /* [in] */ REFIID riid,
    /* [iid_is][out] */ void **ppvObject)
{
    if (DO_GUIDS_MATCH(riid, IID_IUnknown) ||
        DO_GUIDS_MATCH(riid, IID_IDispatch) ||
        DO_GUIDS_MATCH(riid, DIID_DWebBrowserEvents) ||
        DO_GUIDS_MATCH(riid, DIID_DWebBrowserEvents2))
    {
        *ppvObject = (LPVOID)this;
        AddRef();
        return S_OK;
    }
    else
    {
        *ppvObject = NULL;
    }

    return E_NOINTERFACE;
}

STDMETHODIMP_(ULONG) CPrintHook::AddRef(void)
{
    return ++m_ref;
}

STDMETHODIMP_(ULONG) CPrintHook::Release(void)
{
    return --m_ref;
}

// IDispatch method implementation.

STDMETHODIMP CPrintHook::GetTypeInfoCount(
    /* [out] */ UINT *pctinfo)
{
    return E_NOTIMPL;
}

STDMETHODIMP CPrintHook::GetTypeInfo(
    /* [in] */ UINT iTInfo,
    /* [in] */ LCID lcid,
    /* [out] */ ITypeInfo **ppTInfo)
{
    // arg checking

    if (iTInfo != 0)
        return DISP_E_BADINDEX;

    if (!ppTInfo)
        return E_POINTER;

    *ppTInfo = NULL;

    return E_NOTIMPL;
}

STDMETHODIMP CPrintHook::GetIDsOfNames(
    /* [in] */ REFIID riid,
    /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
    /* [in] */ UINT cNames,
    /* [in] */ LCID lcid,
    /* [size_is][out] */ DISPID __RPC_FAR *rgDispId)
{
    return E_NOTIMPL;
}

STDMETHODIMP CPrintHook::Invoke(
    /* [in] */ DISPID dispIdMember,
    /* [in] */ REFIID riid,
    /* [in] */ LCID lcid,
    /* [in] */ WORD wFlags,
    /* [out][in] */ DISPPARAMS *pdispparams,
    /* [out] */ VARIANT  *pVarResult,
    /* [out] */ EXCEPINFO  *pExcepInfo,
    /* [out] */ UINT  *puArgErr)
{
    if (!DO_GUIDS_MATCH(riid, IID_NULL))
        return DISP_E_UNKNOWNINTERFACE;

    if (!(wFlags & DISPATCH_METHOD))
        return E_INVALIDARG;

    switch (dispIdMember)
    {
       case DISPID_BEFORENAVIGATE:
            DBWIN("DISPID_BEFORENAVIGATE\n");
            break;

       case DISPID_BEFORENAVIGATE2:     // ie4 version.
          char szURL[MAX_URL];
          char szTFN[MAX_URL];
          char szHeaders[MAX_URL];
          WideCharToMultiByte(CP_ACP, 0, pdispparams->rgvarg[5].pvarVal->bstrVal, -1, szURL, sizeof(szURL), NULL, NULL);
          // 27-Sep-1997 [ralphw] IE 4 will send us a script command, followed
          // by a 1 then the current URL. We don't care about the current URL
          // in this case, so we nuke it.
          {
             PSTR pszCurUrl = StrChr(szURL, 1);
             if (pszCurUrl)
                 *pszCurUrl = '\0';
          }
          szTFN[0] = 0;
          if( pdispparams->rgvarg[3].pvarVal->bstrVal )
            WideCharToMultiByte(CP_ACP, 0, pdispparams->rgvarg[3].pvarVal->bstrVal, -1, szTFN, sizeof(szTFN), NULL, NULL);
          szHeaders[0] = 0;
          if( pdispparams->rgvarg[1].pvarVal->bstrVal )
            WideCharToMultiByte(CP_ACP, 0, pdispparams->rgvarg[1].pvarVal->bstrVal, -1, szHeaders, sizeof(szHeaders), NULL, NULL);

//        OnBeforeNavigate(szURL, (long)pdispparams->rgvarg[4].pvarVal->lVal, szTFN,
//                         pdispparams->rgvarg[2].pvarVal, szHeaders, (BOOL*)pdispparams->rgvarg[0].pboolVal );
          break;

#if 0
        case DISPID_STATUSTEXTCHANGE:
            DBWIN("DISPID_STATUSTEXTCHANGE\n");
            break;

        case DISPID_DOWNLOADBEGIN:
            DBWIN("DISPID_DOWNLOADBEGIN\n");
            break;

        case DISPID_NEWWINDOW:
            DBWIN("DISPID_NEWWINDOW\n");
            break;

        case DISPID_WINDOWMOVE:
            DBWIN("DISPID_WINDOWMOVE\n");
            break;

        case DISPID_WINDOWRESIZE:
            DBWIN("DISPID_WINDOWRESIZE\n");
            break;

        case DISPID_WINDOWACTIVATE:
            DBWIN("DISPID_WINDOWACTIVATE\n");
            break;

        case DISPID_PROPERTYCHANGE:
            DBWIN("DISPID_PROPERTYCHANGE\n");
            break;

        case DISPID_TITLECHANGE:
            DBWIN("DISPID_TITLECHANGE\n");
            break;

        case DISPID_FRAMEBEFORENAVIGATE:
            DBWIN("DISPID_FRAMEBEFORENAVIGATE\n");
            break;

        case DISPID_FRAMENAVIGATECOMPLETE:
            DBWIN("DISPID_FRAMENAVIGATECOMPLETE\n");
            break;

        case DISPID_FRAMENEWWINDOW:
            DBWIN("DISPID_FRAMENEWWINDOW\n");
            break;

        case DISPID_NAVIGATECOMPLETE:
            DBWIN("DISPID_NAVIGATECOMPLETE\n");
            break;

        case DISPID_DOWNLOADCOMPLETE:
            DBWIN("DISPID_DOWNLOADCOMPLETE\n");
            break;

        case DISPID_DOCUMENTCOMPLETE:
            DBWIN("DISPID_DOCUMENTCOMPLETE\n");
            break;
#endif
        case DISPID_PROGRESSCHANGE:
            ASSERT(pdispparams->cArgs == 2);
            DBWIN("DISPID_PROGRESSCHANGE\n");
            OnProgressChange(V_I4(&(pdispparams->rgvarg[1])), V_I4(&(pdispparams->rgvarg[0])));
#if 1
#ifdef _DEBUG
            char szDebug[80];
            wsprintf(szDebug, "ProgressChange(%li, %li)\n", V_I4(&(pdispparams->rgvarg[1])), V_I4(&(pdispparams->rgvarg[0])));
            DBWIN(szDebug);
#endif
#endif
    }

    return S_OK;
}

void CPrintHook::OnProgressChange(LONG lProgress, LONG lProgressMax)
{
    if (lProgress == -1)
    {
        StopAnimation();
        // Print the page if it isn't a duplicate.
        if (m_fIsPrinting)
        {
            Print();
            DBWIN("Printing");
        }
    }
    else
        NextAnimation();
}

// This function allows the WebBrowser to handle its queued messages before continuing.

BOOL CPrintHook::PumpMessages()
{
    MSG msg;

    // Handle WebBrowser window messages
    while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
    {
      if (!m_fIsPrinting)
      {
          if (m_phh && m_phh->m_pCIExpContainer && m_phh->m_pCIExpContainer->m_pWebBrowserApp)
          {
              m_phh->m_pCIExpContainer->m_pWebBrowserApp->Stop();
          }
          return FALSE;
      }

      if(!IsDialogMessage(m_hWndHelp, &msg))
      {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
      }
    }

    return TRUE;
}

void CPrintHook::BeginPrinting(int action)
{
    m_pos = 1;
    m_level = 0;
    m_action = action;
    m_fIsPrinting = TRUE;
    m_fFirstHeading = TRUE;
    SITEMAP_ENTRY* psme = NULL;
    TV_ITEM tvi;

    if (m_action == PRINT_CUR_TOPIC || m_action == PRINT_CUR_HEADING)
    {
        tvi.hItem = TreeView_GetSelection(m_pToc->m_hwndTree);
        if (!tvi.hItem)
            goto ExitBegin;      // no current selection

        if (m_pToc->m_fBinaryTOC == FALSE)
        {
            tvi.mask = TVIF_PARAM;
            if (TreeView_GetItem(m_pToc->m_hwndTree, &tvi))
                psme = m_pToc->m_sitemap.GetSiteMapEntry((int)tvi.lParam);
            if (psme == NULL)
                goto ExitBegin;
            m_pos = (int)tvi.lParam;

            // Because the user may have selected a topic under a heading, but
            // wants to print all of the topics under that heading, we have to
            // search upward until we find the heading.
            if (m_action == PRINT_CUR_HEADING)
            {
                if (psme->fTopic || psme->cUrls <= 0)
                {
                    while (psme != NULL && psme->fTopic && m_pos > 0)
                    {
                        psme = m_pToc->m_sitemap.GetSiteMapEntry(--m_pos);
                    }
                }
            }
            // Set the current level for reference later.  If the user just
            // wants to print the current topic, the level isn't significant.
            m_level = ((m_action == PRINT_CUR_TOPIC || psme == NULL) ? 0 : psme->level);
        }
    }

    if (m_pToc->m_fBinaryTOC == FALSE)
    {
        // If the user isn't printing all topics and psme is NULL,
        // see if this is just a single topic and, if so, print it.
        if (m_action != PRINT_CUR_ALL && psme == NULL)
        {
            // Get the original sitemap entry.
            m_pos = (int)tvi.lParam;
            psme = m_pToc->m_sitemap.GetSiteMapEntry(m_pos);

            // If there's a URL, print it.
            if (psme->cUrls > 0)
            {
                m_action = PRINT_CUR_TOPIC;
            }
        }
    }
    if (BuildPrintTable())
    {
        // We sit in this loop while printing because we don't want this
        // function to return until printing is complete.
        while (PumpMessages());
        DestroyPrintWindow();
    }

ExitBegin:
    return;
}

BOOL CPrintHook::BuildPrintTable()
{
    BOOL bReturn = FALSE;

    if (!m_fIsPrinting)
        return bReturn;

    CTable table;
    CStr cszCurUrl;

    if (m_pToc->m_fBinaryTOC)
    {
        switch (m_action)
        {
            case PRINT_CUR_TOPIC:
                m_pToc->m_phhctrl->m_pWebBrowserApp->GetLocationURL(&cszCurUrl);
                table.AddString((PCSTR)cszCurUrl);
                break;

            case PRINT_CUR_HEADING:
                TV_ITEM tvi;

                tvi.hItem = TreeView_GetSelection(m_pToc->m_hwndTree);
                if (!tvi.hItem)
                {
                    m_pToc->m_phhctrl->m_pWebBrowserApp->GetLocationURL(&cszCurUrl);
                    table.AddString((PCSTR)cszCurUrl);
                 }
                else
                {
                    tvi.mask = TVIF_PARAM;
                    TreeView_GetItem(m_pToc->m_hwndTree, &tvi);

                    CTreeNode *p = (CTreeNode *)tvi.lParam;
                    CTreeNode *pParent = NULL;

                    if (p->GetType() == TOPIC)
                    {
                      pParent = p->GetParent();
                    }
               CHourGlass hour;
                    m_phh->m_phmData->m_pTitleCollection->GetChildURLS((pParent ? pParent: p), &table);
                    if (pParent)
                        delete pParent;
                 }
                 break;

            case PRINT_CUR_ALL:
                if (!m_pToc->m_pBinTOCRoot)
                {
                    m_pToc->m_phhctrl->m_pWebBrowserApp->GetLocationURL(&cszCurUrl);
                    table.AddString((PCSTR)cszCurUrl);
                }
                else
                    m_phh->m_phmData->m_pTitleCollection->GetChildURLS(m_pToc->m_pBinTOCRoot, &table);  // oh my god they are printing the entire TOC
                break;
        }
    }
    else
    {
        // Get the next sitemap entry.
        // Print the sitemap entry URL if the its level is greater than
        // the saved level.  If the sitemap entry is a heading at the same
        // level and contains a URL, proceed as well.
        for (SITEMAP_ENTRY* psme = m_pToc->m_sitemap.GetSiteMapEntry(m_pos);
            psme != NULL;
            psme = m_pToc->m_sitemap.GetSiteMapEntry(++m_pos))
        {
            if ((psme->level > m_level) ||
                (!psme->fTopic && psme->level == m_level && m_fFirstHeading))
            {
                // The top level heading could have a URL, so we
                // want to print it.  However, we don't want to print
                // any other headings at that level, so set the
                // m_fFirstHeading flag to FALSE.
                if (m_action == PRINT_CUR_HEADING &&
                    !psme->fTopic &&
                    psme->level == m_level)
                {
                    m_fFirstHeading = FALSE;
                }

                if (psme->cUrls > 0)
                {
                    // Get the URL from the sitemap entry.
                    LPCTSTR pszUrl = (psme->pUrls->urlPrimary ? psme->pUrls->urlPrimary : psme->pUrls->urlSecondary);
                    CStr cszUrl(pszUrl);

                    // Synchronize the TOC if we created the print window.
                    if (m_fDestroyHelpWindow)
                        m_pToc->Synchronize(cszUrl);

                    // Truncate the strings at the # character if there is one.
                    LPTSTR pszFind = StrChr(cszUrl, '#');
                    if (pszFind != NULL)
                       *pszFind = '\0';

                    ConvertBackSlashToForwardSlash(cszUrl);

                    if (table.IsStringInTable(cszUrl) == 0)
                        table.AddString((PCSTR)cszUrl);

                    if (m_action == PRINT_CUR_TOPIC)
                        break;
                }
            }
            else
                break;
        }
    }

    if (m_pToc->m_phhctrl != NULL)
    {
        m_pToc->m_phhctrl->m_pWebBrowserApp->GetLocationURL(&cszCurUrl);
        m_hwndParent = m_pToc->m_phhctrl->m_hwndParent;
    }
    else if (m_pToc->m_fBinaryTOC)
    {
        cszCurUrl = m_phh->GetToc();
        m_hwndParent = m_phh->GetHwnd();
    }
    else
    {
        cszCurUrl = m_pToc->m_sitemap.GetSiteMapFile();
        if (m_phh)
            m_hwndParent = m_phh->GetHwnd();
        else
            m_hwndParent = m_hWndHelp;
    }

    if (ConstructFile((PCSTR)cszCurUrl, &table, &m_cszPrintFile))
    {
        bReturn = CreatePrintWindow(&m_cszPrintFile);
    }

    return bReturn;
}

static const char txtTmpPrefix[] = "~hh";
static const char txtHtmlExtension[] = ".htm";
static const char txtImg[] = "IMG";
static const char txtSrc[] = "SRC";
static const char txtLink[] = "LINK";
static const char txtHREF[] = "HREF";
static const char txtTagBeginBody[] = "BODY";
static const char txtTagEndBody[] = "/BODY";
static const char txtTagItAll[] = "</BODY></HTML>";
static const char txtTmpPrintStinrg[] = "~hh%X.htm";
static const char txtFrame[] = "FRAME";
static const char txtBeginScript[] = "SCRIPT";
static const char txtEndScript[] = "/SCRIPT";

const int FILE_PAD = 16 * 1024;

BOOL CPrintHook::ConstructFile(PCSTR pszCurrentUrl, CTable* pFileTable,
    CStr* pm_cszPrintFile)
{
    char szTempPath[MAX_PATH];
    char szHtmlFile[MAX_PATH];
    char szThisURL[MAX_PATH];
    char szCurrentUrl[MAX_PATH];

    CProgress progress(GetStringResource(IDS_GATHERING_PRINTS),
        m_hwndParent, pFileTable->CountStrings() / 10, 10);

    strcpy(szCurrentUrl, pszCurrentUrl);
    PSTR pszFilePortion = (PSTR) FindFilePortion(szCurrentUrl);
    ASSERT(pszFilePortion);

    GetTempPath(sizeof(szHtmlFile), szHtmlFile);
    AddTrailingBackslash(szHtmlFile);
    wsprintf(szHtmlFile + strlen(szHtmlFile), txtTmpPrintStinrg, GetTickCount() & 0xFFFF);
    HFILE hfDst = _lcreat(szHtmlFile, 0);
    if (hfDst == HFILE_ERROR) {
        MsgBox(IDS_FILE_ERROR, szHtmlFile, MB_OK);
        return FALSE;
    }

    int endpos = pFileTable->CountStrings();
    PSTR pszMem = NULL;
    CStr cszTmpFile;

    for (int i = 1; i <= endpos; i++) {
        BOOL fSeenBody = FALSE;
        if (pszMem) {
            GlobalFree((HGLOBAL) pszMem);
            pszMem = NULL;
        }
        progress.Progress();

        ASSERT_COMMENT(pFileTable->CountStrings(), "Empty file list");

        PSTR pszFile;
        if (!StrChr(pFileTable->GetPointer(i), CH_COLON)) {
            if (*pFileTable->GetPointer(i) == '/' || *pFileTable->GetPointer(i) == '\\')
            {
                TranslateUrl(szCurrentUrl, pFileTable->GetPointer(i));
            }
            else
            {
                strcpy(pszFilePortion, pFileTable->GetPointer(i));
            }
            pszFile = szCurrentUrl;
        }
        else {
            pszFile = pFileTable->GetPointer(i);
            PSTR psz = stristr(pszFile, txtSysRoot);
            if (psz) {
                char szPath[MAX_PATH];
                GetRegWindowsDirectory(szPath);
                strcat(szPath, psz + strlen(txtSysRoot));
                cszTmpFile = szPath;
                pszFile = cszTmpFile.psz;
            }
            else if (IsCompiledHtmlFile(pszFile, &cszTmpFile)) {
                pszFile = cszTmpFile.psz;
            }
        }

      strcpy(szThisURL, pszFile);

        if (!ConvertToCacheFile(pszFile, szTempPath)) {
            // AuthorMsg(IDS_CANT_OPEN, pFileTable->GetPointer(i), m_hwndParent, NULL);
            continue;
        }

        int cbMem;
        UINT cbFile, cbFinalLen;
        PSTR psz, pszStart , pszTag;

        if ( IsCompiledURL(szTempPath ) ) {
            CStr cszCompiledName;
            PCSTR pszStream = GetCompiledName(szTempPath, &cszCompiledName);
			if (pszStream == NULL)
				continue;

            // BUGBUG: should use existing file system handle if available

            CFSClient fs;
            if (!fs.Initialize(cszCompiledName)) {
                MsgBox(IDS_FILE_ERROR, pFileTable->GetPointer(i), MB_OK);
                continue;
            }
            if (FAILED(fs.OpenStream(pszStream))) {
                // AuthorMsg(IDS_CANT_OPEN, pFileTable->GetPointer(i), m_hwndParent, NULL);
                continue;
            }

            cbFile = fs.SeekSub(0, SK_END);
         cbFinalLen = cbFile;
            fs.SeekSub(0, SK_SET);
            cbMem = cbFile + FILE_PAD;
            pszMem = (PSTR) GlobalAlloc(GMEM_FIXED, cbMem);
            ASSERT(pszMem);
            if (!pszMem) {
                GlobalFree((HGLOBAL) pszMem);
                fs.CloseStream();
                continue;
            }
            if (FAILED(fs.Read((PBYTE) pszMem, cbFile))) {
                fs.CloseStream();
                continue;
            }
            fs.CloseStream();
        }
        else {
            HANDLE hf = CreateFile(szTempPath, GENERIC_READ, FILE_SHARE_READ,
                NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
            if (hf == INVALID_HANDLE_VALUE)
                goto BadFile;

            ASSERT(hf);
            cbFile = GetFileSize(hf, NULL);
         cbFinalLen = cbFile;
            cbMem = cbFile + FILE_PAD;
            pszMem = (PSTR) GlobalAlloc(GMEM_FIXED, cbMem);
            ASSERT(pszMem);
            if (!pszMem) {
                GlobalFree((HGLOBAL) pszMem);
                CloseHandle(hf);
                continue;   // next HTML file might be smaller, so try again
            }
            DWORD cbRead;
            if (!ReadFile(hf, pszMem, cbFile, &cbRead, NULL) || cbRead != cbFile) {
                CloseHandle(hf);
                continue;
            }
            CloseHandle(hf);
        }
        pszMem[cbFile] = '\0';

        psz = pszMem;
        pszStart = psz;
        pszTag = psz;
        while ((pszTag = StrChr(pszTag, '<'))) {
            pszTag = FirstNonSpace(pszTag + 1);
            if (IsSamePrefix(pszTag, txtTagEndBody, sizeof(txtTagEndBody) - 1)) {
                while (*pszTag != '<')  // back up to the angle bracket
                    pszTag--;
                cbFile = (int)(pszTag - pszStart);
                break;
            }
         else if (IsSamePrefix(pszTag, txtBeginScript, sizeof(txtBeginScript) - 1)) {
            // skip to end tag
            while ((pszTag = StrChr(pszTag, '<'))) {
               pszTag = FirstNonSpace(pszTag + 1);
               if (IsSamePrefix(pszTag, txtEndScript, sizeof(txtEndScript) - 1))
                  break;
            }
         }
            else if (IsSamePrefix(pszTag, txtTagBeginBody, sizeof(txtTagBeginBody) - 1)) {

                // If this isn't the first HTML file, then we ignore everything
                // up to the body tag

                if (i > 1 && !fSeenBody) {
                    fSeenBody = TRUE;
                    pszStart = StrChr(pszTag, '>');
                    if (!pszStart) {
                        AuthorMsg(IDSHHA_CORRUPTED_HTML, pFileTable->GetPointer(i), m_hwndParent, NULL);
                        goto BadFile;
                    }
                    pszStart++;
                    cbFile -= (int)(pszStart - pszMem);
                }
            }
            else if (IsSamePrefix(pszTag, txtImg, sizeof(txtImg) - 1)) {

                // Change the URL for images to be a full path -- this lets
                // the browser pull it in without us having to copy it
                // anywhere.

                pszTag += sizeof(txtImg) - 1;
                for(;;) {
                    while (*pszTag != ' ' && *pszTag != '>') {
                        if (*pszTag == CH_QUOTE) {
                            pszTag = StrChr(pszTag + 1, CH_QUOTE);
                            if (!pszTag) {
                                AuthorMsg(IDSHHA_CORRUPTED_HTML, pFileTable->GetPointer(i), m_hwndParent, NULL);
                                goto BadFile;
                            }
                        }
                        pszTag++;
                    }
                    if (*pszTag == '>')
                        goto NoSrcTag;
                    pszTag++;
                    if (IsSamePrefix(pszTag, txtSrc, sizeof(txtSrc) - 1))
                        break;
                    pszTag++;
                }
                ASSERT(IsSamePrefix(pszTag, txtSrc, sizeof(txtSrc) - 1));
                pszTag = StrChr(pszTag, '=');
                if (!pszTag) {
                    AuthorMsg(IDSHHA_CORRUPTED_HTML, pFileTable->GetPointer(i), m_hwndParent, NULL);
                    goto BadFile;
                }
                pszTag = FirstNonSpace(pszTag + 1);
                char chSearch;
                if (*pszTag == CH_QUOTE) {
                    chSearch = CH_QUOTE;
                    pszTag = FirstNonSpace(pszTag + 1);
                }
                else
                    chSearch = ' ';
                PSTR pszBeginUrl = pszTag;
                pszTag = StrChr(pszTag + 1, chSearch);
                if (!pszTag) {
                    AuthorMsg(IDSHHA_CORRUPTED_HTML, pFileTable->GetPointer(i), m_hwndParent, NULL);
                    goto BadFile;
                }
                char chSave = *pszTag;
                *pszTag = '\0';
                if (!StrChr(pszBeginUrl, CH_COLON)) {

                    // This makes it relative to the original HTML file,
                    // but not necessarily relative to the current file

                    CStr cszCompiledName;
                    char fname[_MAX_FNAME]="";
                    int diff=0;
                    PSTR pszBeginFile='\0';
                    strcpy(szTempPath, szThisURL);

                    if ( IsCompiledURL(szTempPath ) )
                    {   // a compiled URL with an image in it.
                        PCSTR pszStream = GetCompiledName(szTempPath, &cszCompiledName);
                        SplitPath(pszStream, NULL, NULL, fname, NULL);
                        pszBeginFile = stristr(szTempPath, fname);
                        ASSERT( pszBeginFile );
                        diff = (int)(strlen(szThisURL) - strlen(pszBeginFile));
                    }else
                    {   // non-compiled URL; an html file with and image in it
                        pszBeginFile = strrchr(szTempPath, '/');
                        ASSERT(pszBeginFile);
                        diff = (int)(pszBeginFile - szTempPath) + 1;
                    }

                    cbFile += diff;
                    cbFinalLen += diff;
                    while (cbFinalLen > (UINT) cbMem) {
                        int StartDiff = (int)(pszStart - pszMem);
                        int TagDiff = (int)(pszTag - pszMem);
                        int BeginDiff = (int)(pszBeginUrl - pszMem);
                        PSTR pszNew = (PSTR) GlobalReAlloc((HGLOBAL) pszMem, cbMem += FILE_PAD, GMEM_MOVEABLE);
                        ASSERT(pszNew);
                        if (!pszNew) {
                            GlobalFree((HGLOBAL) pszMem);
                            MsgBox(IDS_OOM);
                            _lclose(hfDst);
                            DeleteFile(szHtmlFile);
                            if (pszMem) {
                                GlobalFree((HGLOBAL) pszMem);
                                pszMem = NULL;
                            }
                            return FALSE;
                        }
                        pszMem = pszNew;
                        pszStart = pszMem + StartDiff;
                        pszTag = pszMem + TagDiff;
                        pszBeginUrl = pszMem + BeginDiff;
                    }
                    MoveMemory(pszTag + diff, pszTag, cbFinalLen - (pszTag - pszMem) - diff);

                    if ( !IsCompiledURL(szTempPath) )
                    {
                        strcpy(pszBeginFile, "/");
                        pszBeginFile ++;  // pointing at the NULL
                    }
                    strcpy(pszBeginFile, pszBeginUrl);
                    strcpy( pszBeginUrl, szTempPath);
                    pszTag += diff;
                    *pszTag = chSave;
                }
                else
                    *pszTag = chSave;
            }
            else if (IsSamePrefix(pszTag, txtLink, sizeof(txtLink) - 1)) {

                // Change the URL for CSS to be a full path -- this lets
                // the browser pull it in without us having to copy it
                // anywhere.

                pszTag += sizeof(txtImg) - 1;
                for(;;) {
                    while (*pszTag != ' ' && *pszTag != '>') {
                        if (*pszTag == CH_QUOTE) {
                            pszTag = StrChr(pszTag + 1, CH_QUOTE);
                            if (!pszTag) {
                                AuthorMsg(IDSHHA_CORRUPTED_HTML, pFileTable->GetPointer(i), m_hwndParent, NULL);
                                goto BadFile;
                            }
                        }
                        pszTag++;
                    }
                    if (*pszTag == '>')
                        goto NoSrcTag;
                    pszTag++;
                    if (IsSamePrefix(pszTag, txtHREF, sizeof(txtHREF) - 1))
                        break;
                    pszTag++;
                }
                ASSERT(IsSamePrefix(pszTag, txtHREF, sizeof(txtHREF) - 1));
                pszTag = StrChr(pszTag, '=');
                if (!pszTag) {
                    AuthorMsg(IDSHHA_CORRUPTED_HTML, pFileTable->GetPointer(i), m_hwndParent, NULL);
                    goto BadFile;
                }
                pszTag = FirstNonSpace(pszTag + 1);
                char chSearch;
                if (*pszTag == CH_QUOTE) {
                    chSearch = CH_QUOTE;
                    pszTag = FirstNonSpace(pszTag + 1);
                }
                else
                    chSearch = ' ';
                PSTR pszBeginUrl = pszTag;
                pszTag = StrChr(pszTag + 1, chSearch);
                if (!pszTag) {
                    AuthorMsg(IDSHHA_CORRUPTED_HTML, pFileTable->GetPointer(i), m_hwndParent, NULL);
                    goto BadFile;
                }
                char chSave = *pszTag;
                *pszTag = '\0';
                char szScratch[MAX_URL];
                if (!StrChr(pszBeginUrl, CH_COLON)) {

                    // BUGBUG: This makes it relative to the original HTML file,
                    // but not necessarily relative to the current file
                    strcpy(pszFilePortion, pszBeginUrl);
                    strcpy(szScratch, szCurrentUrl);
                }
                else
                {
                   // qualify .CHM filespec which will look like: MK@MSITStore:foo.chm::/bar.css
                   //
                   CExCollection* pCollection;
                   CExTitle* pTitle;
                   HRESULT hr;

                   if ( (pCollection = GetCurrentCollection(NULL, pszBeginUrl)) )
                   {
                      if ( SUCCEEDED(hr = pCollection->URL2ExTitle( pszBeginUrl, &pTitle )) && pTitle )
                      {
                         const char* pszPathName;
                         char* psz;
                         lstrcpy(szScratch, pszBeginUrl);
                         if ( (pszPathName = pTitle->GetPathName()) )
                         {
                            if ( (psz = StrChr(szScratch, CH_COLON)) )
                            {
                               ++psz;
                               strcpy(psz, pszPathName);
                               if ( (psz = StrStr(pszBeginUrl, "::")) )
                                  strcat(szScratch, psz);
                            }
                         }
                      }
                   }
                }
                int diff = (int)(strlen(szScratch) - strlen(pszBeginUrl));
                cbFile += diff;
                cbFinalLen += diff;
                while (cbFinalLen >= (UINT) cbMem) {
                    int StartDiff = (int)(pszStart - pszMem);
                    int TagDiff = (int)(pszTag - pszMem);
                    int BeginDiff = (int)(pszBeginUrl - pszMem);
                    PSTR pszNew = (PSTR) GlobalReAlloc((HGLOBAL) pszMem, cbMem += FILE_PAD, GMEM_MOVEABLE);
                    ASSERT(pszNew);
                    if (!pszNew) {
                        GlobalFree((HGLOBAL) pszMem);
                        MsgBox(IDS_OOM);
                        _lclose(hfDst);
                        DeleteFile(szHtmlFile);
                        if (pszMem) {
                            GlobalFree((HGLOBAL) pszMem);
                            pszMem = NULL;
                        }
                        return FALSE;
                    }
                    pszMem = pszNew;
                    pszStart = pszMem + StartDiff;
                    pszTag = pszMem + TagDiff;
                    pszBeginUrl = pszMem + BeginDiff;
                }
                MoveMemory(pszTag + diff, pszTag, cbFinalLen - (pszTag - pszMem) - diff);
                strcpy(pszBeginUrl, szScratch);
                pszTag += diff;
                *pszTag = chSave;
            }
            else if (IsSamePrefix(pszTag, txtFrame, sizeof(txtFrame) - 1)) {
                MsgBox(IDS_CANT_PRINT_FRAMESET);
                _lclose(hfDst);
                DeleteFile(szHtmlFile);
                if (pszMem) {
                    GlobalFree((HGLOBAL) pszMem);
                    pszMem = NULL;
                }
                return FALSE;
            }

NoSrcTag:
            pszTag++;   // skip over the '<'
        }
        if (_lwrite(hfDst, pszStart, cbFile) != cbFile) {
            MsgBox(IDS_INSUFFICIENT_SPACE, szHtmlFile, MB_OK);
            _lclose(hfDst);
            DeleteFile(szHtmlFile);
        }
BadFile:
        continue;
    }
    if (pszMem) {
        GlobalFree((HGLOBAL) pszMem);
        pszMem = NULL;
    }
    _lclose(hfDst);
    *pm_cszPrintFile = szHtmlFile;
    return TRUE;

#if 0
    BOOL bReturn = (GetSystemDirectory(m_szPrintFile, _MAX_PATH) > 0);

    if (bReturn)
    {
        StrCat(m_szPrintFile, "\\hhtest.htm");
        *pm_cszPrintFile = m_szPrintFile;

        HANDLE hFile = CreateFile(m_szPrintFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

        if (hFile != INVALID_HANDLE_VALUE)
        {
            DWORD dwBytesWritten = 0;
            TCHAR szOpenHTML[] = "<HTML>\r\n<BODY>\r\n" \
                                 "<H2>Printing is not currently implemented.</H2>\r\n" \
                                 "<P></P>\r\n" \
                                 "<B>Here is the list of files that you asked to print:</B>\r\n"
                                 "<P></P>\r\n";
            WriteFile(hFile, (LPCVOID)szOpenHTML, strlen(szOpenHTML) * sizeof(TCHAR), &dwBytesWritten, NULL);

            TCHAR szFile[_MAX_PATH], szFileHTML[_MAX_PATH * 2];

            pFileTable->SetPosition();
            while (pFileTable->GetString(szFile))
            {
                wsprintf(szFileHTML, "%s <BR>\r\n", szFile);
                WriteFile(hFile, (LPCVOID)szFileHTML, strlen(szFileHTML) * sizeof(TCHAR), &dwBytesWritten, NULL);
            }

            TCHAR szCloseHTML[] = "<P></P>\r\n" \
                                  "</BODY>\r\n</HTML>\r\n";
            WriteFile(hFile, (LPCVOID)szCloseHTML, strlen(szCloseHTML) * sizeof(TCHAR), &dwBytesWritten, NULL);
            CloseHandle(hFile);
        }
        else
            bReturn = FALSE;
    }

    return bReturn;
#endif
}

BOOL CPrintHook::TranslateUrl(PSTR pszFullUrl, PSTR pszRelUrl)
{
    BOOL bReturn;
    URL_COMPONENTS uc;
    ZERO_STRUCTURE(uc);

    uc.dwStructSize = sizeof(URL_COMPONENTS);
    uc.dwSchemeLength = 1;
    uc.nScheme = INTERNET_SCHEME_DEFAULT ;
    uc.dwHostNameLength = 1;
    uc.dwUserNameLength = 1;
    uc.dwPasswordLength = 1;
    uc.dwUrlPathLength = 1;
    uc.dwExtraInfoLength = 1;

    if ((bReturn = InternetCrackUrl(pszFullUrl, 0, 0, &uc)))
    {
        uc.lpszUrlPath = pszRelUrl;
        uc.dwUrlPathLength = 0;

        // Make a copy of uc.lpszExtraInfo because it will
        // be lost when InternetCreateUrl() modifies pszFullUrl.

        CStr cszExtraInfo(uc.lpszExtraInfo);

        uc.lpszExtraInfo = (PSTR)cszExtraInfo;
        uc.dwExtraInfoLength = 0;

        DWORD dwBufLen = MAX_PATH;

        bReturn = InternetCreateUrl(&uc, 0, pszFullUrl, &dwBufLen);
    }

    return bReturn;
}

// This function just tells the WebBrowser to print the current page.

HRESULT CPrintHook::Print()
{
    // Change the cursor to an hourglass.
    SetClassLongPtr(m_hWndHelp, GCLP_HCURSOR, (LONG_PTR)LoadCursor(NULL, (LPCTSTR) IDC_WAIT));

    HRESULT hr = E_FAIL;
    HRESULT hrCancelled = (m_fIsIE3 ? 0x80040100 : 0x80040104);

    LPOLECOMMANDTARGET lpOleCommandTarget = m_phh->m_pCIExpContainer->m_pIE3CmdTarget;
    ASSERT(lpOleCommandTarget);

    if (lpOleCommandTarget != NULL)
    {
        // Give printing 10 tries and then bail out if it doesn't work.

        for (USHORT i = 0; i < 10 && FAILED(hr); i++)
        {
            if (!PumpMessages())
                break;

#ifdef _DEBUG
            try
            {
#endif
                // Call the Exec() function to print the currently displayed page.

                if (m_fIsIE3)
                {
                    hr = lpOleCommandTarget->Exec(NULL,OLECMDID_PRINT,
                                                OLECMDEXECOPT_PROMPTUSER,
                                                NULL, NULL);
                }
                else
                {
                    hr = lpOleCommandTarget->Exec(&CGID_MSHTML,IDM_PRINT,
                                                MSOCMDEXECOPT_PROMPTUSER,
                                                NULL, NULL);
                }

#ifdef _DEBUG
                TCHAR szDebug[40];
                wsprintf(szDebug, "m_pos == %i, hr == %lx", m_pos, hr);
                DBWIN(szDebug);
#endif
#ifdef _DEBUG
            }
            catch(...)
            {
                ASSERT_COMMENT(TRUE, "An exception occurred when printing. " \
                               "Please send email to randyfe or ralphw.");
                hr = E_FAIL;
            }
#endif
            // On IE 4, wait for printing to finish before continuing.

            if (!m_fIsIE3)
            {
                OLECMD olecmd;
                olecmd.cmdID = IDM_PRINTQUERYJOBSPENDING;

                do
                {
                    DBWIN("Waiting for printing to finish...");
                    olecmd.cmdf = 0;

#ifdef _DEBUG
                    try
                    {
#else
                        if (m_phh && m_phh->m_pCIExpContainer && m_phh->m_pCIExpContainer->m_pIE3CmdTarget)
#endif
                            m_phh->m_pCIExpContainer->m_pIE3CmdTarget->QueryStatus(&CGID_MSHTML, 1, &olecmd, NULL);
#ifdef _DEBUG
                    }
                    catch(...)
                    {
                        ASSERT_COMMENT(TRUE, "An exception occurred when waiting for printing to finish. " \
                                       "Please send email to randyfe or ralphw.");
                        break;
                    }
#endif
                    PumpMessages();
                }
                while (olecmd.cmdf & OLECMDF_ENABLED);
            }

            if (hr == hrCancelled)
                break;
        }
    }

    m_fIsPrinting = FALSE;

    // Change the cursor back to an arrow.
    SetClassLongPtr(m_hWndHelp, GCLP_HCURSOR, (LONG_PTR)LoadCursor(NULL, (LPCTSTR) IDC_ARROW));

#ifdef _DEBUG
    TCHAR szDebug[50];
    wsprintf(szDebug, "Print complete... hr == %lx", hr);
    DBWIN(szDebug);
#endif

    return hr;
}

STATIC INT_PTR CALLBACK ProgressDialogProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);

const int DEFAULT_WIDTH = 200;
const int DEFAULT_HEIGHT = 50;

CProgress::CProgress(PCSTR pszCaption, HWND hwndCallersParent, int cSteps,
    int cHowOften)
{
    cProgress = -1;
    steps = cSteps;
    cFrequency = cHowOften;
    pszTitle = lcStrDup(pszCaption);
    fWindowCreationFailed = FALSE;
    hwndProgress = NULL;
    hwndParent = hwndCallersParent;
    hwndFrame = NULL;

    dwStartTime = GetTickCount();

    counter = 0;
}

CProgress::~CProgress()
{
    if (hwndFrame && IsWindow(hwndFrame))
        DestroyWindow(hwndFrame);
    lcFree(pszTitle);
}

void CProgress::Progress() {
    if (++counter == cFrequency) {
        counter = 0;
        if (hwndProgress)
            SendMessage(hwndProgress, PBM_STEPIT, 0, 0);
        else {
            cProgress++;
            if (GetTickCount() - dwStartTime >= 1500)
                CreateTheWindow();
        }
    }
}

void CProgress::CreateTheWindow(void)
{
    if (fWindowCreationFailed)
        return; // couldn't create the window

    if (!hwndParent) {
        CPalDC dc(SCREEN_IC);
        rc.left = dc.GetDeviceWidth() - (DEFAULT_WIDTH / 2);
        rc.top = dc.GetDeviceHeight() - (DEFAULT_HEIGHT / 2);
    }
    else {
        RECT rcParent;
        GetWindowRect(hwndParent, &rcParent);
        rc.left = (RECT_WIDTH(rcParent) / 2) - (DEFAULT_WIDTH / 2);
        rc.top =  (RECT_HEIGHT(rcParent) / 2) - (DEFAULT_HEIGHT / 2);
    }

    hwndFrame = CreateDialog(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDDLG_PROGRESS),
        hwndParent, ProgressDialogProc);

    if (!hwndFrame) {
        fWindowCreationFailed = TRUE;
        return;
    }

    RECT rcFrame;
    GetWindowRect(hwndFrame, &rcFrame);
    MoveWindow(hwndFrame, rcFrame.left, rc.top, RECT_WIDTH(rcFrame),
        RECT_HEIGHT(rcFrame), FALSE);

    hwndProgress = GetDlgItem(hwndFrame, ID_PROGRESS);
    if (steps > 0) {
        SendMessage(hwndProgress, PBM_SETRANGE, 0, MAKELPARAM(0, steps));
        SendMessage(hwndProgress, PBM_SETSTEP, (WPARAM) 1, 0);
    }

    SetWindowText(hwndFrame, pszTitle);

    while (cProgress-- >= 0)
        SendMessage(hwndProgress, PBM_STEPIT, 0, 0);

    ShowWindow(hwndFrame, SW_SHOW);
}

STATIC INT_PTR CALLBACK ProgressDialogProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    if (msg == WM_INITDIALOG)
        return TRUE;
    else
        return FALSE;
}