windows-xp/Source/XPSP1/NT/enduser/stuff/hhctrl/toc.cpp

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//    File: toc.cpp
//    Author: Donald Drake
//    Purpose: Implements classes to support the table of contents

#include "header.h"
#include "stdio.h"
#include "string.h"
#ifdef HHCTRL
#include "parserhh.h"
#else
#include "windows.h"
#include "parser.h"
#endif
#include "collect.h"
#include "hhtypes.h"
#include "wwheel.h"
#include "toc.h"
#include "fts.h"
#include "subfile.h"
#include "fs.h"
#include "sysnames.h"

#include "highlite.h"
#include "hhfinder.h"
#include "csubset.h"
#include "hherror.h"
// NormalizeUrlInPlace
#include "util.h"
#include "subset.h"

// typed -- just use ANSI for now
#undef _tcsicmp
#undef _tcstok
#define _tcsicmp strcmpi
#define _tcstok  StrToken

#ifdef _DEBUG
#undef THIS_FILE
static const char THIS_FILE[] = __FILE__;
#endif

// Persist keys. No need for these to be localized so I place them here.
//
const char g_szFTSKey[] = "ssv1\\FTS";
const char g_szIndexKey[] = "ssv1\\Index";
const char g_szTOCKey[] = "ssv1\\TOC";
const char g_szUDSKey[] = "ssv2\\UDS";  // User Defined Subsets

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// global helper functions
CExCollection* g_pCurrentCollection = NULL;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CExCollection implementation

CExCollection::CExCollection(CHmData* phmData, const CHAR* pszFile,  BOOL bSingleTitle)
{
    m_pstate = new CState(pszFile);
    m_phmData = phmData;
    m_bSingleTitle = bSingleTitle;
    m_pHeadTitles = NULL;
    m_csFile = pszFile;

    m_pFullTextSearch = NULL;
    m_pSearchHighlight = NULL;
    m_pDatabase = NULL;
    m_szWordWheelPathname = NULL;
    m_dwCurrSlot = 0;
    m_pCurrTitle = NULL;
    m_pSubSets = NULL;
    m_pMasterTitle = NULL ; // HH BUG 2428: Always initialize your variables!!!

    m_dwLastSlot = 0;
    m_pSSList = NULL;

    for (int i = 0; i < MAX_OPEN_TITLES; i++)
        m_MaxOpenTitles[i] = NULL;

    if (! bSingleTitle )
    {
       //
       // If this is ever not the case then we have a situation where we are trying to init more than a single
       // collection. This is a very bad thing and must be avoided.
       //
       ASSERT(g_pCurrentCollection == NULL);
       g_pCurrentCollection = NULL;
    }

    m_pCSlt = NULL;
}

CExCollection::~CExCollection()
{

   if ( m_phmData->m_sysflags.fDoSS && m_pSSList )
   {
      m_pSSList->PersistSubsets(this);
      delete m_pSSList;
   }
   if( m_pDatabase )
      delete m_pDatabase;

   if (m_pFullTextSearch)
      delete m_pFullTextSearch;

   if ( m_pSearchHighlight )
      delete m_pSearchHighlight;

   CExTitle *p, *pNext;
   p = m_pHeadTitles;

   while (p)
   {
      pNext = p->GetNext();
      delete p;
      p = pNext;
   }

   if (m_Collection.IsDirty())
   m_Collection.Save();

   m_Collection.Close();

  if( m_szWordWheelPathname ) {
    delete [] (CHAR*) m_szWordWheelPathname;
    m_szWordWheelPathname = NULL;
  }

  // Persist subset selections.
  //
#if 0
  CSubSet* pSS;
#endif
  if ( m_pSubSets )
  {
#if 0
     if ( (pSS = m_pSubSets->GetFTSSubset()) && SUCCEEDED(m_pstate->Open(g_szFTSKey,STGM_WRITE)) )
     {
        m_pstate->Write(pSS->m_cszSubSetName, strlen(pSS->m_cszSubSetName)+1);
        m_pstate->Close();
     }
     if ( (pSS = m_pSubSets->GetIndexSubset()) && SUCCEEDED(m_pstate->Open(g_szIndexKey,STGM_WRITE)) )
     {
        m_pstate->Write(pSS->m_cszSubSetName, strlen(pSS->m_cszSubSetName)+1);
        m_pstate->Close();
     }
     if ( (pSS = m_pSubSets->GetTocSubset()) && SUCCEEDED(m_pstate->Open(g_szTOCKey,STGM_WRITE)) )
     {
        m_pstate->Write(pSS->m_cszSubSetName, strlen(pSS->m_cszSubSetName)+1);
        m_pstate->Close();
     }

#ifdef _DEBUG
    /* Output all the user defined subsets to the state store.
     *******************/
     int nKey;
     char buf[5];
     CStr cszKey;
extern const char txtSSInclusive[];         // "Inclusive";
extern const char txtSSExclusive[];         // "Exclusive";
static const int MAX_PARAM = 4096;
static const char txtSSConvString[] = "%s:%s:%s";   // Exclusive|Inclusive:SetName:TypeName
CMem memParam( MAX_PARAM );
CHAR* pszParam = (CHAR*)memParam;   // for notational convenience
    for(int i=0; i<m_pSubSets->HowManySubSets(); i++ )
    {
        pSS = m_pSubSets->GetSubSet(i);
        if ( pSS->m_bPredefined )
            continue;
        int type = pSS->GetFirstExcITinSubSet();
        nKey=1;
        while (type != -1 && pSS->m_pIT->GetInfoTypeName(type) && (type <= pSS->m_pIT->HowManyInfoTypes()))
        {
                // even though we don't define exclusive filters, for user defined, it will be
                // here when we do.
            wsprintf(pszParam, txtSSConvString, txtSSExclusive,
                    pSS->m_cszSubSetName.psz,
                    pSS->m_pIT->GetInfoTypeName(type) );
            cszKey = g_szUDSKey;
            wsprintf(buf,"%d",nKey++);
            cszKey += buf;
            if ( SUCCEEDED( m_pstate->Open(cszKey, STGM_WRITE)) )
                m_pstate->Write(pszParam, strlen(pszParam)+1);
            m_pstate->Close();
            type = pSS->GetNextExcITinSubSet();
        }
        type = pSS->GetFirstIncITinSubSet();
        nKey=1;
        while (type != -1 && pSS->m_pIT->GetInfoTypeName(type) && (type <= pSS->m_pIT->HowManyInfoTypes()))
        {
            wsprintf(pszParam, txtSSConvString, txtSSInclusive,
                    pSS->m_cszSubSetName.psz,
                    pSS->m_pIT->GetInfoTypeName(type) );
            cszKey = g_szUDSKey;
            wsprintf(buf,"%d",nKey++);
            cszKey += buf;
            if ( SUCCEEDED( m_pstate->Open(cszKey, STGM_WRITE)) )
                m_pstate->Write(pszParam, strlen(pszParam)+1);
            m_pstate->Close();
            type = pSS->GetNextIncITinSubSet();
        }
    }
#endif

#endif
     delete m_pSubSets;
  }

  if (m_pCSlt)
      delete m_pCSlt; // leak fix

  if ( m_pstate )
     delete m_pstate;

  if (! m_bSingleTitle )
    g_pCurrentCollection = NULL;
}

/* The FullPath parameter is the name of a directory.  The directory is suppose to contain files
   to add to the collection.
*/
#ifdef CHIINDEX
#include <io.h>
BOOL CExCollection::InitCollection( const TCHAR * FullPath, const TCHAR * szMasterChmFn )
{
    char szExt[2][5] = {".chm", ".chi"};
    BOOL ret = FALSE;
    CStr filespec;
    long hSrch;
    struct _finddata_t fd_t;
    CStr szAdd;
    HRESULT hr;

    m_pMasterTitle = NULL;

    for(int i=0; i<2; i++)
    {
        filespec = FullPath;
        filespec += "\\*";
        filespec += szExt[i]; 
        if ( (hSrch = _findfirst( filespec, &fd_t ) ) == -1 )
            continue;
        else
            ret = TRUE;

        do 
        {
            CExTitle *pExTitle = NULL;

            szAdd = FullPath;
            szAdd += "\\";
            szAdd += fd_t.name;

            // only check for the existance of a index for chm files
            if (0==i)
            {
                CFileSystem* pFileSystem = new CFileSystem;
                pFileSystem->Init();
                if (!(SUCCEEDED(pFileSystem->Open( szAdd ))))
                {
                    delete pFileSystem;
                    continue;
                }
                CSubFileSystem* pSubFileSystem = new CSubFileSystem(pFileSystem);
                hr = pSubFileSystem->OpenSub("$WWKeywordLinks\\btree");
                if (FAILED(hr))
                {
                    hr = pSubFileSystem->OpenSub("$WWAssociativeLinks\\btree");
                    if (FAILED(hr))
                    {
                        pFileSystem->Close();
                        delete pFileSystem;
                        delete pSubFileSystem;
                        continue;
                    }
                }
                delete pSubFileSystem;
                pFileSystem->Close();
                delete pFileSystem;
            }
			pExTitle = new CExTitle( szAdd , this );
            pExTitle->SetNext(m_pHeadTitles);
            m_pHeadTitles = pExTitle;

            if ( (m_pMasterTitle == NULL) && (strnicmp( szMasterChmFn, fd_t.name, strlen(szMasterChmFn)) == 0) )
            {
                m_pMasterTitle = m_pHeadTitles;
                m_phmData->SetCompiledFile(szAdd);
            }
            m_Collection.IncrementRefTitleCount();
        } while( _findnext( hSrch, &fd_t ) == 0 );
    } 

    if ( (ret == TRUE) && (m_pMasterTitle == NULL) )
    {
        m_pMasterTitle = m_pHeadTitles;
        m_phmData->SetCompiledFile(szAdd);
    }
    return ret;
}
#endif

BOOL CExCollection::InitCollection()
{
    if (m_bSingleTitle)
    {
        m_pHeadTitles = new CExTitle(m_csFile, this);
        m_pMasterTitle = m_pHeadTitles;
        m_Collection.IncrementRefTitleCount();
        GetMergedTitles(m_pHeadTitles);
        CStr cszCompiledFile;
        const CHAR* pszFilePortion = GetCompiledName(m_csFile, &cszCompiledFile);
        m_phmData->SetCompiledFile(cszCompiledFile);
#ifdef DUMPTOC
        m_fh = fopen("c:\\toc_dump.txt", "w");
        m_bRoot = TRUE;
        m_dwLevel = 0;
        CTreeNode *pNode = GetRootNode();

        DumpNode(&pNode);
        fclose(m_fh);
#endif
   }
   else
   {
      m_Collection.ConfirmTitles();
      m_Collection.m_bFailNoFile = TRUE;
      if (m_Collection.Open(m_csFile) != F_OK)
        return FALSE;

      // Create an CExTitle for each referanced title
      LANGID LangId;
      CHAR* pszTitle;
      CTitle *pTitle;
      CFolder *p;
      LISTITEM *pItem;
      CExTitle *pExTitle;

      m_pCSlt = new CSlotLookupTable();            // start a new slot lookup table.
      pItem = m_Collection.m_RefTitles.First();
      while (pItem)
      {
        p = (CFolder *)pItem->pItem;

        pszTitle = p->GetTitle() + 1;
        LangId = p->GetLanguage();

        // check if extitle already exist, title referanced twice in the collection
        if ( (pExTitle = FindTitle(pszTitle, LangId)) )
        {
           m_Collection.DecrementRefTitleCount();
           pItem = m_Collection.m_RefTitles.Next(pItem);
           p->SetExTitlePtr(pExTitle);
           continue;
        }

        // find the title
        pTitle = m_Collection.FindTitle(pszTitle, LangId);

        if (pTitle == NULL)
        {
           m_Collection.DecrementRefTitleCount();
           pItem = m_Collection.m_RefTitles.Next(pItem);
           continue;
        }
        
        //create CExTitle
        pExTitle = new CExTitle(pTitle, m_Collection.GetColNo(), this);
        if (ValidateTitle(pExTitle) == FALSE)
        {
            pItem = m_Collection.m_RefTitles.Next(pItem);
            continue;
        }

        // add the title
        pExTitle->SetNext(m_pHeadTitles);
        m_pHeadTitles = pExTitle;

        // Wire up the CFolder to the CExTitle, also, generate the Title Hash identifier.
        //
        p->SetExTitlePtr(pExTitle);

        char szBuf[20];
        char szID[MAX_PATH + 20];
        Itoa(p->GetLanguage(), szBuf);
        strcpy(szID, p->GetTitle()+1);    // Don't hash the '='
        strcat(szID, szBuf);
        pExTitle->m_dwHash = HashFromSz(szID);
        m_pCSlt->AddValue(p);

        if (pExTitle->GetUsedLocation()->bSupportsMerge)
        {
           GetMergedTitles(pExTitle);
        }
        pItem = m_Collection.m_RefTitles.Next(pItem);
      }
      //
      // check for a master chm
      //
      CHAR* pszName;
      LANGID LangId2;

      if (m_Collection.GetMasterCHM(&pszName, &LangId2))
      {
        m_pMasterTitle = FindTitle(pszName, LangId2);
      }

      if (!m_pMasterTitle)
      {
        // default to first title
        m_pMasterTitle = GetFirstTitle();
      }

      if (!m_pMasterTitle)
        return FALSE;

      g_pCurrentCollection = this;
      m_pCSlt->SortAndAssignSlots();     // Complete construction of the slot lookup table.
      while (TRUE)
      {
          if (m_pMasterTitle->OpenTitle() == FALSE)
          {
             m_pMasterTitle = m_pMasterTitle->GetNext();
             if (m_pMasterTitle == NULL)
                return FALSE;
             continue;
          }
          CStr cszCompiledFile;
          GetCompiledName(m_pMasterTitle->GetPathName(), &cszCompiledFile);
          m_phmData->SetCompiledFile(cszCompiledFile);
          return TRUE;
      }
   }

   return TRUE;
}

void CExCollection::InitStructuralSubsets(void)
{
   if ( m_bSingleTitle )
   {
      m_phmData->m_sysflags.fDoSS = 0;
      return;
   }
   if ( m_phmData->m_sysflags.fDoSS )
   {
      // Initilize the structural subset list and the "new" and "entire contents" subsets.
      //
      CStructuralSubset* pSS;
      CHAR szBuf[50];

      m_pSSList = new CSSList;

	  strncpy(szBuf,GetStringResource(IDS_ADVSEARCH_SEARCHIN_ENTIRE), sizeof(szBuf));
	  szBuf[49] = 0;
      pSS = new CStructuralSubset(szBuf);
      pSS->SetEntire();
      pSS->SetReadOnly();
      m_pSSList->AddSubset(pSS);
      m_pSSList->SetEC(pSS);

	  strncpy(szBuf,GetStringResource(IDS_NEW), sizeof(szBuf));
	  szBuf[49] = 0;
      pSS = new CStructuralSubset(szBuf);
      pSS->SetEmpty();
      pSS->SetReadOnly();
      m_pSSList->AddSubset(pSS);
      m_pSSList->SetNew(pSS);

      m_pSSList->RestoreSubsets(this, szBuf);
      m_pSSList->ReadPreDefinedSubsets(this, szBuf);
      //
      // If a subset has been selected via SetGlobalProperties() via HH_GPROPID_CURRENT_SUBSET then use that as an override...
      //
      if ( _Module.szCurSS[0] )
      {
         pSS = NULL;
         while ( (pSS = m_pSSList->GetNextSubset(pSS)) )
         {
            if (! strcmpi(_Module.szCurSS, pSS->GetID()) )
            {
               m_pSSList->SetFTS(pSS);
               m_pSSList->SetF1(pSS);
               m_pSSList->SetTOC(pSS);
               break;
            }
         }
      }
   }
}

void CExCollection::GetOpenSlot(CExTitle *p)
{
    if (m_MaxOpenTitles[m_dwLastSlot])
        m_MaxOpenTitles[m_dwLastSlot]->CloseTitle();

    m_MaxOpenTitles[m_dwLastSlot] = p;
    m_dwLastSlot++;

    if (m_dwLastSlot == MAX_OPEN_TITLES)
        m_dwLastSlot = 0;
}

BOOL CExCollection::ValidateTitle(CExTitle *pExTitle, BOOL bDupCheckOnly)
{
	// make sure the collection does not already contain a chm with same location MMC
	CExTitle *pEnumTitle;
	pEnumTitle = GetFirstTitle();

	while (pEnumTitle)
	{
    	if (lstrcmp(pEnumTitle->GetContentFileName(), pExTitle->GetContentFileName()) == 0)
		{
	        delete pExTitle;
			m_Collection.DecrementRefTitleCount();
			return FALSE;
		}
		pEnumTitle = pEnumTitle->GetNext();
	}

    if (bDupCheckOnly == TRUE)
        return TRUE;

    // before adding to title list confirm that files exist
    pExTitle->FindUsedLocation();

    if (pExTitle->GetUsedLocation() == NULL)
    {
        delete pExTitle;
        m_Collection.DecrementRefTitleCount();
        return FALSE;
    }

    if (pExTitle->GetUsedLocation()->IndexFileName && pExTitle->GetUsedLocation()->IndexFileName[0])
    {
        if (GetFileAttributes(pExTitle->GetUsedLocation()->IndexFileName) == HFILE_ERROR)
        {
            delete pExTitle;
            m_Collection.DecrementRefTitleCount();
            return FALSE;
        }
    }
    return TRUE;
}

BOOL CExCollection::UpdateLocation( const CHAR* pszLocId, const CHAR* pszNewPath, const CHAR* pszNewVolume, const CHAR* pszNewTitle )
{
    // find the location itself
    CLocation *pLocation = FindLocation( (CHAR*)pszLocId);
    if (pLocation == NULL)
        return FALSE;

    // make sure new path has trailing backslash
    CStr cStrPath = pszNewPath;
    if (pszNewPath[strlen(pszNewPath) - 1] != '\\')
        cStrPath += "\\";

    // get the current (old) location path
    CStr cStrOldPath = pLocation->GetPath();
    if (cStrOldPath.psz[strlen(cStrOldPath.psz) - 1] != '\\')
        cStrOldPath += "\\";

    // if new and old paths are the some just bail out
    if( lstrcmpi( cStrPath.psz, cStrOldPath.psz ) == 0 )
      return FALSE;

    // determine what has changed in this path (was it just the drive letter?)
    // note we must compare from the tail end and thus we have to be careful when
    // dealing with DBCS strings
    CHAR* pszOldPathHead = cStrOldPath.psz;
    CHAR* pszOldPathTail = CharPrev(pszOldPathHead, pszOldPathHead + strlen(pszOldPathHead));
    CHAR* pszPathHead = cStrPath.psz;
    CHAR* pszPathTail = CharPrev(pszPathHead, pszPathHead + strlen(pszPathHead));
    while( (pszOldPathTail >= pszOldPathHead) && (pszPathTail >= pszPathHead) ) {
      BOOL bOldLB = IsDBCSLeadByte(*pszOldPathTail);
      BOOL bLB = IsDBCSLeadByte(*pszPathTail);
      if( bOldLB && bLB ) {
        if( !((*pszOldPathTail == *pszPathTail) && (*(pszOldPathTail+1) == *(pszPathTail+1))) )
          break;
      }
      else if( bOldLB || bLB ) {
        break;
      }
      else if( ToLower(*pszOldPathTail) != ToLower(*pszPathTail) ) {
        break;
      }
      // bail if we compared all chars
      if( (pszOldPathTail == pszOldPathHead) || (pszPathTail == pszPathHead) )
        break;
      // advance to previous char
      pszOldPathTail = CharPrev(pszOldPathHead, pszOldPathTail);
      pszPathTail = CharPrev(pszPathHead, pszPathTail);
    }
    if( IsDBCSLeadByte(*pszOldPathTail) )
      pszOldPathTail++;
    if( IsDBCSLeadByte(*pszPathTail) )
      pszPathTail++;
    char szOldPathPrefix[MAX_PATH];
    int iLen = (int)(((DWORD_PTR)pszOldPathTail)-((DWORD_PTR)pszOldPathHead)+1); // always at least one
    lstrcpyn( szOldPathPrefix, pszOldPathHead, iLen+1 );
    char szPathPrefix[MAX_PATH];
    iLen = (int)(((DWORD_PTR)pszPathTail)-((DWORD_PTR)pszPathHead)+1); // always at least one
    lstrcpyn( szPathPrefix, pszPathHead, iLen+1 );

    // update title if specified
    if (pszNewTitle)
       pLocation->SetTitle(pszNewTitle);

    // get the volume that will be updated
    CStr cStrVolume = pLocation->GetVolume();

    // first, update each pathname in the titles that have the same volume label
    CExTitle *pExTitle = GetFirstTitle();
    LOCATIONHISTORY *pLH;
    CHAR* pszFilePortion;
    CStr cFileName;
    while (pExTitle)
    {
        // if the used location for this title is the new location update it
        pLH = pExTitle->GetUsedLocation();
        CLocation *pLoc = FindLocation( (CHAR*)pLH->LocationId );
        CStr cStrVol = pLoc->GetVolume();

        // get the old location path
        CStr cStrOldPath = pLoc->GetPath();
        if (cStrOldPath.psz[strlen(cStrOldPath.psz) - 1] != '\\')
            cStrOldPath += "\\";

        if (pExTitle->GetContentFileName().psz && pLH)
        {
            if (strcmpi( cStrVol, cStrVolume ) == 0)
            {
                // make sure that it did point to the old location
                pszFilePortion = (CHAR*)FindFilePortion(pExTitle->GetContentFileName());
                cFileName = cStrOldPath.psz;
                cFileName += pszFilePortion;
                pszFilePortion = (CHAR*)FindFilePortion(cFileName);

                if (strcmpi(cFileName, pExTitle->GetContentFileName()) == 0)
                {
                    // find the ending location of the old prefix
                    CHAR* pszOldPathNameEnd = pExTitle->GetContentFileName().psz + strlen(szOldPathPrefix);

                    // create the new pathname using the prefix of the new location and the
                    // ending string of the old pathname
                    CStr cStrPathName = szPathPrefix;
                    cStrPathName += pszOldPathNameEnd;

                    // update the pathname
                    pExTitle->GetContentFileName() = cStrPathName.psz;
                }
            }
        }

        // check each location for this title
        pLH = pExTitle->m_pTitle->m_pHead;
        while (pLH)
        {
            // chm file location information
            CLocation *pLoc = FindLocation( (CHAR*)pLH->LocationId );
            // if the location is NULL, this indications that we are looking at a title
            // that belongs to a different collection and thus we should skip it
            if( pLoc ) {
              CStr cStrVol = pLoc->GetVolume();

              // get the old location path
              CStr cStrOldPath = pLoc->GetPath();
              if (cStrOldPath.psz[strlen(cStrOldPath.psz) - 1] != '\\')
                  cStrOldPath += "\\";

              // chm file
              if (strcmpi( cStrVol, cStrVolume ) == 0)
              {
                  pszFilePortion = (CHAR*)FindFilePortion(pLH->FileName);
                  cFileName = cStrOldPath.psz;
                  cFileName += pszFilePortion;

                  if (strcmpi(cFileName, pLH->FileName) == 0)
                  {
                      // find the ending location of the old prefix
                      CHAR* pszOldPathNameEnd = pLH->FileName + strlen(szOldPathPrefix);

                      // create the new pathname using the prefix of the new location and the
                      // ending string of the old pathname
                      CStr cStrPathName = szPathPrefix;
                      cStrPathName += pszOldPathNameEnd;

                      // update the pathname
                      AllocSetValue(cStrPathName.psz, &pLH->FileName);
                  }
              }

              // chq file
              if( pLH->QueryFileName && *pLH->QueryFileName ) {

                // chq file location information
                // (use the same as the chm file if QueryLocation is not set)
                if( pLH->QueryLocation && *(pLH->QueryLocation) ) {
                  pLoc = FindLocation( (CHAR*) pLH->QueryLocation );
                  cStrVol = pLoc->GetVolume();

                  // get the old location path
                  cStrOldPath = pLoc->GetPath();
                  if (cStrOldPath.psz[strlen(cStrOldPath.psz) - 1] != '\\')
                      cStrOldPath += "\\";
                }

                // chq file
                if( strcmpi( cStrVol, cStrVolume ) == 0 )
                {
                    pszFilePortion = (CHAR*)FindFilePortion(pLH->QueryFileName);
                    cFileName = cStrOldPath.psz;
                    cFileName += pszFilePortion;

                    if (strcmpi(cFileName, pLH->QueryFileName) == 0)
                    {
                        // find the ending location of the old prefix
                        CHAR* pszOldPathNameEnd = pLH->QueryFileName + strlen(szOldPathPrefix);

                        // create the new pathname using the prefix of the new location and the
                        // ending string of the old pathname
                        CStr cStrPathName = szPathPrefix;
                        cStrPathName += pszOldPathNameEnd;

                        // update the pathname
                        AllocSetValue(cStrPathName.psz, &pLH->QueryFileName);
                    }
                }

              }

            }
            pLH = pLH->pNext;
        }
        pExTitle = pExTitle->GetNext();
    }

    // and finally, update any location identifier that has the same volume label
    //
    // note: we must do this list since the individual title updating relies on the fact
    // that we can fetch the "old" location information to validate the file pathing before
    // we update it
    CLocation *pLoc = m_Collection.FirstLocation();
    while( pLoc ) {
      CStr cStrVol = pLoc->GetVolume();
      if( strcmpi( cStrVol, cStrVolume ) == 0 ) {

        // get the old location path
        CStr cStrOldPath = pLoc->GetPath();
        if (cStrOldPath.psz[strlen(cStrOldPath.psz) - 1] != '\\')
          cStrOldPath += "\\";

        // find the ending location of the old prefix
        CHAR* pszOldPathEnd = cStrOldPath.psz + strlen(szOldPathPrefix);

        // create the new path using the prefix of the new location and the
        // ending string of the old path
        CStr cStrPath = szPathPrefix;
        cStrPath += pszOldPathEnd;

        // make sure the path aways ends with a backslash
        if (cStrPath.psz[strlen(cStrPath.psz) - 1] != '\\')
          cStrPath += "\\";

        // update the path
        pLoc->SetPath(cStrPath);

        // update the volume label if specified
        if( pszNewVolume )
          pLoc->SetVolume( pszNewVolume );

      }
      pLoc = pLoc->GetNextLocation();
    }

    // set the collection dirty bit so the hhcolreg.dat will get updated on shutdown
    m_Collection.Dirty();

    return FALSE;
}

void CExCollection::GetChildURLS(CTreeNode *pNode, CTable *pTable)
{
    CTreeNode *pParents[50];
    CTreeNode *pCur, *pNext;
    CHAR* pszFind;

    DWORD dwCurLevel = 0;
    CHAR szURL[MAX_URL];

    for (int i = 0; i < 50; i++)
       pParents[i] = NULL;

    // add the URL for this node
    if (pNode->GetURL(szURL, sizeof(szURL), TRUE))
    {
        // Truncate the strings at the # character if there is one.
        pszFind = StrChr((const CHAR*)szURL, '#');
        if (pszFind != NULL)
            *pszFind = '\0';

        if (pszFind = StrChr((const CHAR*)szURL, '\\'))
        {
             while (*pszFind != '\0')
             {
                 if (*pszFind == '\\')
                     *pszFind = '/';
                 pszFind = CharNext(pszFind);
              }
         }

         if (pTable->IsStringInTable(szURL) == 0)
             pTable->AddString(szURL);
    }

    if (pNode->HasChildren())
    {
        pParents[dwCurLevel] = pNode;
        dwCurLevel++;

        pCur = pNode->GetFirstChild();

        while (pCur)
        {
            if (pCur->GetURL(szURL, sizeof(szURL), TRUE))
            {
                // Truncate the strings at the # character if there is one.
                pszFind = StrChr((const CHAR*)szURL, '#');
                if (pszFind != NULL)
                    *pszFind = '\0';
                if (pszFind = StrChr((const CHAR*)szURL, '\\'))
                {
                    while (*pszFind != '\0')
                    {
                        if (*pszFind == '\\')
                            *pszFind = '/';
                        pszFind = CharNext(pszFind);
                    }
                }
                if (pTable->IsStringInTable(szURL) == 0)
                    pTable->AddString(szURL);
             }

            if (pNext = pCur->GetFirstChild())
            {
                if (pParents[dwCurLevel])
                    delete pParents[dwCurLevel];
                pParents[dwCurLevel] = pCur;
                dwCurLevel++;
                pCur = pNext;
            }
            else if (pNext = pCur->GetNextSibling())
            {
                delete pCur;
                pCur = pNext;
            }
            else
            {
                delete pCur;
                while (TRUE)
                {
                    dwCurLevel--;
                    if (dwCurLevel == 0)
                    {
                        if (pParents[dwCurLevel+1])
                            delete pParents[dwCurLevel+1];
                        pCur = NULL;
                        break;
                    }
                    pCur = pParents[dwCurLevel];

                    if (pNext = pCur->GetNextSibling())
                    {
                        pCur = pNext;
                        break;
                    }
                    delete pCur;
                    pParents[dwCurLevel] = NULL;
                }
            }
        }
    }
    return;
}

BOOL CExCollection::InitFTSKeyword()
{
   // BUGBUG: we shouldn't do this until we know we have full-text search
   // in the file (which will usually NOT be the case).

   // Create full-text search object
   //
   if (m_phmData->m_sysflags.fFTI) {
      m_pFullTextSearch = new CFullTextSearch(this);
      m_pFullTextSearch->Initialize();

      // Create search highlight object
      //
      m_pSearchHighlight = new CSearchHighlight(this);
   }

  // create word wheels (they self initialize themselves upon use)
  //
  // TODO: move full text search shared code to CTitleDatabase
  //
  m_pDatabase = new CTitleDatabase( this );

   return TRUE;
}


#ifdef DUMPTOC

void CExCollection::DumpNode(CTreeNode **p)
{
   char sz[256];

   if (m_bRoot == TRUE)
      m_bRoot = FALSE;
   else
   {
      for (DWORD i = 1; i < m_dwLevel; i++)
    fprintf(m_fh, "  ");

      (*p)->GetTopicName(sz, sizeof(sz));

      fprintf(m_fh, "%s\n", sz);
   }

   CTreeNode *pNode;

   if (pNode = (*p)->GetFirstChild())
   {
      m_dwLevel++;
      DumpNode(&pNode);
      m_dwLevel--;
   }

   pNode = (*p)->GetNextSibling();
   delete (*p);
   *p = NULL;

   do
   {
      if (pNode)
    DumpNode(&pNode);
   } while (pNode && (pNode = pNode->GetNextSibling()));
}

#endif

void CExCollection::GetMergedTitles(CExTitle *pTitle)
{
    CStr cStrFile;
    CStr cStrFullPath;
    CExTitle *pNewTitle = NULL;
    CExTitle *pPreviousNewTitle = NULL;
    CExTitle *pParent = pTitle;
    char szMasterPath[MAX_PATH];
    char szTmp[MAX_PATH];
    BOOL bOk2Add = FALSE;

    LCID TitleLocale = NULL;

    if( !(pTitle->Init()) )
        return;

    //[ZERO IDXHDR]
    if (!pTitle->IsIdxHeaderValid())
    {
        return ;
    }

    if (pTitle->GetInfo())
    {
        TitleLocale = pTitle->GetInfo()->GetLanguage();
    }

    DWORD dwCount = pTitle->GetIdxHeaderStruct()->dwCntMergedTitles;
    for (DWORD i = 0; i < dwCount; i++)
    {
        // read string table for this string
        if (FAILED(pTitle->GetString((((DWORD*)(&(pTitle->GetIdxHeaderStruct()->pad)))[i]), &cStrFile)))
            continue;

        // if this is not a single title (.col file) search collection registry
        if (m_bSingleTitle == FALSE)
        {
            // get base name
           SplitPath((CHAR*)cStrFile, NULL, NULL,  szTmp, NULL);

            // search
            CTitle *pCTitle = m_Collection.FindTitle(szTmp, (LANGID)TitleLocale);

            if (pCTitle == NULL && TitleLocale != ENGLANGID)  // for localized merged chms if we can't find a child with the same lang look for englist look for english titles in hhcolreg
            {
                pCTitle = m_Collection.FindTitle(szTmp, (LANGID)ENGLANGID);
            }

            if (pCTitle)
            {
                // create CExTitle
                pNewTitle = new CExTitle(pCTitle, m_Collection.GetColNo(), this);
                m_Collection.IncrementRefTitleCount();

                if (ValidateTitle(pNewTitle) == TRUE)
                {
                    CExTitle* pTitle = m_pHeadTitles;
                    while(pTitle->GetNext())
                        pTitle = pTitle->GetNext();
                    pTitle->SetNext(pNewTitle);
                    //
                    // Sync/Next/Prev and subsetting spupport for "merged" chms...
                    //
                    pNewTitle->m_pParent = pParent;       // Set parent pointer.
                    if (! pParent->m_pKid )               // Set parent titles kid pointer to first kid.
                       pParent->m_pKid = pNewTitle;
                    if ( pPreviousNewTitle )
                       pPreviousNewTitle->m_pNextKid = pNewTitle;
                    pPreviousNewTitle = pNewTitle;
                    //
                    // Create a hash for these...
                    //
                    char szBuf[20];
                    char szID[MAX_PATH + 20];
                    Itoa(pCTitle->GetLanguage(), szBuf);
                    strcpy(szID, pCTitle->GetId());
                    strcat(szID, szBuf);
                    pNewTitle->m_dwHash = HashFromSz(szID);
                    continue;
                }
            }
			else if (m_Collection.GetFindMergedCHMS())
			{
	            if ( FindThisFile(NULL, cStrFile, &cStrFullPath) )
		        {
					// if found add to title list (add to the end of the list)
					pNewTitle = new CExTitle(cStrFullPath, this);
					m_Collection.IncrementRefTitleCount();
    
                    if (ValidateTitle(pNewTitle, TRUE) == TRUE)
                    {
					    CExTitle* pTitle = m_pHeadTitles;
					    while(pTitle->GetNext())
    	                    pTitle = pTitle->GetNext();
					    pTitle->SetNext(pNewTitle);
                        //
                        // Sync/Next/Prev and subsetting spupport for "merged" chms...
                        //
                        pNewTitle->m_pParent = pParent;       // Set parent pointer.
                        if (! pParent->m_pKid )               // Set parent titles kid pointer to first kid.
                            pParent->m_pKid = pNewTitle;
                        if ( pPreviousNewTitle )
                           pPreviousNewTitle->m_pNextKid = pNewTitle;
                        pPreviousNewTitle = pNewTitle;
                        //
                        // Create a hash for these...
                        //
                        char szBuf[20];
                        char szID[MAX_PATH + 20];
                        Itoa(0, szBuf);
                        strcpy(szID, szTmp);
                        strcat(szID, szBuf);
                        pNewTitle->m_dwHash = HashFromSz(szID);
                        continue;
				    }
                }
			}
        }
        else
        {
            //
            // First check location of this file
            //
            if ((CHAR*)m_csFile )
            {
               SplitPath((CHAR*)m_csFile, szMasterPath, szTmp, NULL, NULL);
               CatPath(szMasterPath, szTmp);
               CatPath(szMasterPath, (CHAR*)cStrFile);
                bOk2Add = ( GetFileAttributes(szMasterPath) != HFILE_ERROR );
            }

            // search for file
            //
            if (! bOk2Add )
               bOk2Add = FindThisFile(NULL, cStrFile, &cStrFullPath);
            else
               cStrFullPath = (const CHAR*)szMasterPath;

            if ( bOk2Add )
            {
                // if found add to title list (add to the end of the list)
                pNewTitle = new CExTitle(cStrFullPath, this);
                pNewTitle->m_pParent = pParent;       // Set parent pointer.
                CExTitle* pTitle = m_pHeadTitles;
                while(pTitle->GetNext())
                    pTitle = pTitle->GetNext();
                pTitle->SetNext(pNewTitle);
                m_Collection.IncrementRefTitleCount();
            }
        }
    }
}

// BUGBUG: <mikecole> dondr review, could this go away in-lu of checking the f_IsOrphan bit ?

CTreeNode * CExCollection::CheckForTitleNode(CFolder *p)
{
   if (p == NULL)
      return NULL;

   CHAR* pszTitle = p->GetTitle();

   if (pszTitle && pszTitle[0] == '=')
   {
      CExTitle *pt = FindTitle(pszTitle+1, p->GetLanguage());

      if (pt == NULL)
         return NULL;

      CExTitleNode *pext = new CExTitleNode(pt, p);
      return pext;
   }
   else
   {
      // Check if this folder has a title below it somewhere
      BOOL bFound = FALSE;
      CFolder *pFolder;
      if (pFolder = p->GetFirstChildFolder())
      {
         CheckForTitleChild(pFolder, &bFound);
      }
      if (bFound == FALSE)
      {
         return NULL;
      }
      CExFolderNode *pf = new CExFolderNode(p, this);
      return pf;
   }
   return NULL;
}

// BUGBUG: <mikecole> dondr review, could this go away in-lu of checking the f_IsOrphan bit ?

void CExCollection::CheckForTitleChild(CFolder *p, BOOL *pbFound)
{
   if (*pbFound == TRUE)
      return;

   CHAR* pszTitle = p->GetTitle();
   CFolder *pF;

   if (pszTitle && pszTitle[0] == '=')
   {
      *pbFound = TRUE;
      return;
   }

   if (pF = p->GetFirstChildFolder())
   {
      CheckForTitleChild(pF, pbFound);
      if (*pbFound == TRUE)
    return;
   }

   pF = p->GetNextFolder();

   while (pF)
   {
      CheckForTitleChild(pF, pbFound);
      if (*pbFound == TRUE)
    return;
      pF = pF->GetNextFolder();
   }
}

DWORD CExCollection::GetRefedTitleCount()
{
   return m_Collection.GetRefTitleCount();
}

BOOL CExCollection::IsBinaryTOC(const CHAR* pszToc)
{
   if (! m_phmData || !pszToc)
      return FALSE;
   return (HashFromSz(FindFilePortion(pszToc)) == m_phmData->m_hashBinaryTocName);
}

CTreeNode * CExCollection::GetRootNode()
{
   CStructuralSubset* pSS = NULL;

   if (m_bSingleTitle)
   {
      if (!m_pHeadTitles)
         m_pHeadTitles = new CExTitle(GetPathName(), this);

      TOC_FOLDERNODE Node;

      if ( !SUCCEEDED(m_pHeadTitles->GetRootNode(&Node)) )
         return NULL;

      CExTitleNode *pext = new CExTitleNode(m_pHeadTitles, NULL);
         return pext;
   }
   else
   {
      CFolder *p = m_Collection.GetRootFolder();
      CTreeNode *pN;

      // implement structural subset filtering for TOC here.
      if( m_pSSList )
         pSS = m_pSSList->GetTOC();

      while (p)
      {
         if ((pN = CheckForTitleNode(p)))
         {
            if ( !pSS || pSS->IsEntire() || p->bIsVisable() )
               return pN;
            else
               delete pN; // leak fix
         }
         p = p->GetNextFolder();
      }
      return NULL;
   }
}

//////////////////////////////////////////////////////////////////////////
//
// Ignore LangId if its Zero.
//
CExTitle * CExCollection::FindTitle(const CHAR* pszId, LANGID LangId)
{
   // look in list of titles
   CExTitle *p = m_pHeadTitles;

   while (p)
   {
      if( p->GetCTitle() )
          if( _tcsicmp(p->GetCTitle()->GetId(), pszId) == 0 ) 
            if( (LangId == 0 || p->GetCTitle()->GetLanguage() == LangId) ) // If LangId == 0, we ignore the lang id.
      {
         return p;
      }
      p = p->GetNext();
   }
   return NULL;
}

// Try multiple LangIds before failing
CExTitle * CExCollection::FindTitleNonExact(const CHAR* pszId, LANGID DesiredLangId)
{
    CExTitle* pTitle = NULL ;

    CLanguageEnum* pEnum = _Module.m_Language.GetEnumerator(DesiredLangId) ;
    ASSERT(pEnum) ;
    LANGID LangId = pEnum->start() ;
    while (LangId != c_LANGID_ENUM_EOF)
    {
        pTitle = FindTitle(pszId, LangId);
        if (pTitle)
        {
            break ; // Found it!
        }

        LangId = pEnum->next() ;
    }

    // Cleanup.
    if (pEnum)
    {
        delete pEnum ;
    }


    return pTitle;
}

//
CExTitle * CExCollection::TitleFromChmName(const CHAR* pszChmName)
{
   CExTitle *p = m_pHeadTitles;
   CHAR szFN[MAX_PATH];
   CHAR szExt[MAX_PATH];

   while (p)
   {
      SplitPath(p->GetContentFileName(), NULL, NULL, szFN, szExt);
      strcat(szFN, szExt);
      if (! _tcsicmp(szFN, pszChmName) )
         return p;
      p = p->GetNext();
   }
   return NULL;
}

CLocation * CExCollection::FindLocation(CHAR* pszId)
{
   return m_Collection.FindLocation(pszId);
}

// GetNext()
//
// Returns the next physical TOC node irregaurdless of its type. If a node is a container, it's
// next is considered to be it's child.
//
// Note that the caller will be responsible for deleting the returned CTreeNode object.
//
CTreeNode * CExCollection::GetNext(CTreeNode* pTreeNode, DWORD* pdwSlot)
{
   CTreeNode *pTreeNext = NULL, *pTreeParent = NULL, *pSaveNode = NULL;
   DWORD dwObjType;

   dwObjType = pTreeNode->GetType();
   if ( ((dwObjType == FOLDER) || (dwObjType == CONTAINER)) && (pTreeNext = pTreeNode->GetFirstChild(pdwSlot)) )
      return pTreeNext;
   else
   {
      if ( (pTreeNext = pTreeNode->GetNextSibling(NULL, pdwSlot)) )
         return pTreeNext;
      else
      {
         pSaveNode = pTreeNode;
         do
         {
            pTreeParent = pTreeNode->GetParent(pdwSlot, TRUE);
            if ( pSaveNode != pTreeNode )
               delete pTreeNode;
            if (! (pTreeNode = pTreeParent) )
               return NULL;

         } while (!(pTreeNext = pTreeNode->GetNextSibling(NULL, pdwSlot)));
      }
      return pTreeNext;
   }
}

// GetNext()
//
// Returns the next TOC node that represents a displayable topic.
//
// Note that the caller will be responsible for deleting the returned CTreeNode object.
//
CTreeNode * CExCollection::GetNextTopicNode(CTreeNode* pTreeNode, DWORD* pdwSlot)
{
   CTreeNode *pTocNext = NULL, *pTocKid = NULL;
   DWORD dwObjType;

try_again:
   if ( (pTocNext = GetNext(pTreeNode, pdwSlot)) )
   {
      dwObjType = pTocNext->GetType();
      if ( (dwObjType != TOPIC) && (dwObjType != CONTAINER) )
      {
         //  We need to drill down!
         //
         do
         {
             if ( (pTocKid = pTocNext->GetFirstChild(pdwSlot)) )
             {
                 dwObjType = pTocKid->GetType();
                 delete pTocNext;
                 pTocNext = pTocKid;
             }
             else
             {
                 // This is the case of the book that contains no kids! For this case, we'll skip this dirty node!
                 //
                 pTreeNode = pTocNext;
                 goto try_again;
             }
         } while ( (dwObjType != TOPIC) && (dwObjType != CONTAINER) );
      }
      return pTocNext;
   }
   return NULL;
}


// GetPrev()
//
// Returns the previous physical TOC node irregardless of its type.
//
// Note that the caller will be responsible for deleting the returned CTreeNode object.
//
CTreeNode * CExCollection::GetPrev(CTreeNode* pTreeNode, DWORD* pdwSlot)
{
   CTreeNode *pTreeNext = NULL, *pTreeParent = NULL , *pSaveNode = NULL, *pTmpNode = NULL;
   DWORD dwObjType;
   DWORD dwTmpSlot;

   pSaveNode = pTreeNode;
   if (! (pTreeParent = pTreeNode->GetParent(pdwSlot, TRUE)) )
   {
      // Could this be a single title with multiple roots ?
      //
      if ( pTreeNode->GetObjType() == EXNODE )
      {
         CExTitle* pTitle;
         pTitle = ((CExNode*)pTreeNode)->GetTitle();
         if ( pTitle->m_pCollection->IsSingleTitle() )
         {
            TOC_FOLDERNODE Node;
            pTitle->GetRootNode(&Node);
            pTreeNext = new CExNode(&Node, pTitle);
            if ( pTreeNext->Compare(pSaveNode) ) {
               delete pTreeNext;  // leak fix
               return NULL;       // No prev to be found!
            }
            if ( pdwSlot )
               *pdwSlot = pTitle->GetRootSlot();
            goto find_it;
         }
      }
      else
      {
         CFolder *p = m_Collection.GetRootFolder();
         if( !p )
           return NULL;
         p = p->GetFirstChildFolder();
         //
         // Is it visable ?
         //
         CStructuralSubset* pSS = NULL;
         if( m_pSSList )
            pSS = m_pSSList->GetTOC();

         if ( pSS && !pSS->IsEntire() && !p->bIsVisable() )
            return NULL;

         pTreeNext = new CExFolderNode(p, this);
         goto find_it;
      }
      return NULL;
   }
   if (! (pTreeNext = pTreeParent->GetFirstChild(&dwTmpSlot)) ) {
      delete pTreeParent;  // leak fix
      return NULL;
   }

   // ---LEAK!: At this point we have a pTreeNext and pTreeParent ---

   if ( pTreeNext->Compare(pSaveNode) )
   {
      dwObjType = pTreeParent->GetType();
      if ( dwObjType == CONTAINER )
         return pTreeParent;
      else
      {
         pTmpNode = GetPrev(pTreeParent, pdwSlot);
         delete pTreeParent;
         if (! pTmpNode )
         {
             delete pTreeNext ; // Fix Leak.
            return NULL;
         }
         if ( pTmpNode->GetType() == CONTAINER )
            return pTmpNode;
         else
         {
            pTreeParent = GetLastChild(pTmpNode, pdwSlot);
            if ( pTreeParent != pTmpNode )
               delete pTmpNode;
            return pTreeParent;
         }
      }
   }
   delete pTreeParent;
   if ( pdwSlot )
      *pdwSlot = dwTmpSlot;
find_it:
   pTmpNode = pTreeNext->GetNextSibling(NULL, &dwTmpSlot);
   while ( pTmpNode && !pTmpNode->Compare(pSaveNode) )
   {
      delete pTreeNext; pTreeNext = NULL;  // leak fix
      pTreeNext = pTmpNode;
      if ( pdwSlot )
         *pdwSlot = dwTmpSlot;
      pTmpNode = pTreeNext->GetNextSibling(NULL, &dwTmpSlot);
   }
   if (pTmpNode && pTmpNode->Compare(pSaveNode) )
   {
      delete pTmpNode;
      if ( pTreeNext->GetType() == BOGUS_FOLDER )
      {
         pTmpNode = GetPrev(pTreeNext, pdwSlot);
         if ( pTmpNode != pTreeNext )
         {
            delete pTreeNext; pTreeNext = NULL;  // leak fix
            pTreeNext = pTmpNode;
         }
      }
      pTmpNode = GetLastChild(pTreeNext, pdwSlot);
      if ( pTmpNode != pTreeNext )
         delete pTreeNext;
      return pTmpNode;
   }
   else if( pTmpNode )
     delete pTmpNode;  // leak fix

   if( pTreeNext && (pTreeNext != pTmpNode) )
     delete pTreeNext;  // leak fix

   return NULL;
}

CTreeNode * CExCollection::GetLastChild(CTreeNode* pTreeNode, DWORD* pdwSlot)
{
   CTreeNode *pTreeTmp = NULL, *pTreeKid = NULL, *pSiblingNode = NULL;
   DWORD dwObjType;

   if (! pTreeNode )
      return NULL;

   dwObjType = pTreeNode->GetType();
   if ( dwObjType != TOPIC )
   {
      // We need to drill down.
      //
      if ( (pTreeKid = pTreeNode->GetFirstChild(pdwSlot)) )
      {
         while ( (pSiblingNode = pTreeKid->GetNextSibling(NULL, pdwSlot)) )
         {
            while ( pSiblingNode->GetType() == BOGUS_FOLDER )
            {
               if ( ! (pTreeTmp = pSiblingNode->GetNextSibling(NULL, pdwSlot)) )
                  break;
               else
               {
                  delete pSiblingNode;
                  pSiblingNode = pTreeTmp;
               }
            }
            delete pTreeKid;
            pTreeKid = pSiblingNode;
         }
         if ( pTreeKid->GetType() != TOPIC )
         {
            pTreeTmp = GetLastChild(pTreeKid, pdwSlot);
            if (pTreeTmp == pTreeKid)
            {
                delete pTreeKid;
                return NULL;
            }
            delete pTreeKid;
            pTreeKid = pTreeTmp;
         }
         return pTreeKid;
      }
   }
   return pTreeNode;
}

HRESULT CExCollection::URL2ExTitle(const CHAR* pszURL, CExTitle **ppTitle)
{
   // get the title from the URL
   CStr cStr;
   const CHAR* pszThisFileName;
   GetCompiledName(pszURL, &cStr);
   if( !cStr.psz )
     return E_FAIL;
   const CHAR* pszFileName = FindFilePortion( cStr.psz );

   CExTitle *pTitle = GetFirstTitle();

   while (pTitle)
   {
      pszThisFileName = pTitle->GetFileName();
      if (pszThisFileName == NULL)
      {
        pTitle = pTitle->GetNext();
        continue;
      }
      if( StrCmpIA(pszThisFileName, pszFileName) == 0 )
      {
        *ppTitle = pTitle;
        return S_OK;
      }
      pTitle = pTitle->GetNext();
   }
   return E_FAIL;
}

//
// The following bit of code attempts to detect if we have arrived at a topic that is referenced in
// more than one place in the TOC. This is done by comparing the TOC location we lookup for the URL with
// the "m_dwCurrSlot" which is updated here and when any navigation call is made. If these TOC locations
// are different yet they reference the same topic, we utilize the "m_dwCurrSlot" TOC location for syncing
// needs.
//
// UpdateTopicSlot()
//
// Called ONLY from BeforeNavigate() before a navigation in allowed to proceed.
//
void CExCollection::UpdateTopicSlot(DWORD dwSlot, DWORD dwTN, CExTitle* pTitle)
{
   if ( m_dwCurrSlot && dwSlot != m_dwCurrSlot )
   {
//      if ( (dwTN != m_dwCurrTN) && dwSlot )
      if ( (dwTN != m_dwCurrTN) )
         m_dwCurrSlot = dwSlot;
      else
         return;
   }
   else
      m_dwCurrSlot = dwSlot;
   m_dwCurrTN = dwTN;
   m_pCurrTitle = pTitle;
}

HRESULT CExCollection::Sync(CPointerList *pHier, const CHAR* pszURL)
{
   CTreeNode* pThis = NULL;
   CExTitle *pTitle = NULL;
   CTreeNode *pParent = NULL;

   if ( m_dwCurrSlot )
   {
      if( IsBadReadPtr(m_pCurrTitle, sizeof(CExTitle)) )
         return E_FAIL;
      if (! SUCCEEDED(m_pCurrTitle->Slot2TreeNode(m_dwCurrSlot, &pThis)) )
         return E_FAIL;
   }
   else if (pszURL) {
      if (! SUCCEEDED(URL2ExTitle(pszURL, &pTitle)) )
         return E_FAIL;

      // MAJOR HACK to fix a show stopper for nt5.  This code assumes nt's superchm authoring of URLS's as follows
      // MS-ITS:dkconcepts.chm::/defrag_overview_01.htm.  This code assumes ansi URL strings
      if (pTitle->m_pParent)
      {
          char szBuf[MAX_URL];
          strcpy(szBuf, pszURL);

          char *pszLastWak, *pszCurChar;

          pszLastWak = NULL;
          pszCurChar = szBuf;

          while (*pszCurChar)
          {
            // if we get to the :: we are at the end of the pathing information
            if (*pszCurChar == ':' && *(pszCurChar+1) == ':')
                break;
            if (*pszCurChar == '\\' || *pszCurChar == '/')
                pszLastWak = pszCurChar;
            pszCurChar++;
          }
          if (pszLastWak)
          {
              char szBuf2[MAX_URL];
              pszLastWak ++;
              strcpy(szBuf2, pszLastWak);
              strcpy(szBuf, txtMsItsMoniker);
              pszCurChar = szBuf2;
              strcat(szBuf, szBuf2);
              if (! SUCCEEDED(pTitle->m_pParent->GetURLTreeNode(szBuf, &pThis, FALSE)) ) 
                  return E_FAIL;
          }
      } 
      else if (! SUCCEEDED(pTitle->GetURLTreeNode(pszURL, &pThis)) )
      {
          return E_FAIL;
      }
   }
   else 
   {
      return E_FAIL;   
   }

   // Make sure we have a valid CTreeNode pointer (Whistler bug #8112 & 8101).
   // The above code below "MAJOR HACK" doesn't appear to work because:
   //    1) we fall out of the parsing loop before pszLastWak is set, and
   //    2) even if pszLastWak was set, GetURLTreeNode() fails on the 
   //       generated URL.  
   //
   // In the case of bug #8112 & 8101, we get to this point and pThis has not 
   // been set to a valid CTreeNode (thus the crash).  The safest thing to do
   // is simply call GetURLTreeNode here and get the CTreeNode pointer.
   // 
   if(!pThis)
   {
      if (!SUCCEEDED(pTitle->GetURLTreeNode(pszURL, &pThis)))
          return E_FAIL;
   }

   pHier->Add(pThis);
   // now get all of the parents
   for (pParent = pThis->GetParent(); pParent; pParent = pParent->GetParent())
      pHier->Add(pParent);

   return S_OK;
}

CFolder *CExCollection::FindTitleFolder(CExTitle *pTitle)
{
   CFolder *p;
   LISTITEM *pItem;
   pItem = m_Collection.m_RefTitles.First();
   while (pItem)
   {
      p = (CFolder *)pItem->pItem;

      if (pTitle->GetCTitle() && _tcsicmp(pTitle->GetCTitle()->GetId(), p->GetTitle() + 1) == 0 &&
    pTitle->GetCTitle()->GetLanguage() == p->GetLanguage())
    return p;
      pItem = m_Collection.m_RefTitles.Next(pItem);
   }
   return NULL;
}


// <mc>
// I've modified this function be be more generic. It returns a local storage path according to
// the same rules as always:
//
// 1.) location of local .COL
// 2.) "windir"\profiles\"user"\application data\microsoft\htmlhelp directory.
//
// The function mow takes an extension name which will be used to qualify the requested storage
// pathname.
//
//   **** WARNING ****
//   We return a pointer from this function. Callers should make a copy of the string immeadiatly
//   after they call this function rather than placing any reliance of the integrity of the pointer returned.
//
// </mc>

const CHAR* CExCollection::GetLocalStoragePathname(const CHAR* pszExt)
{
  // TODO: read this in from the XML file
  //      (for now base it on the collection pathname)
  //
  // TODO: check write permission of destination, if not allowed
  //       the set the path to the system directory or some
  //       other default writable location
  //
  // TODO: check for sufficient disk space.

  static CHAR szPathname[MAX_PATH];
  CHAR szFileName[MAX_PATH];
  CHAR* pszExtension;
  UINT uiDt = DRIVE_UNKNOWN;

  if( !pszExt && *pszExt )
    return NULL;

  // if we want the chw and it is already set then return it and bail out
  if( !strcmp( pszExt, ".chw" ) ) {
    if( m_szWordWheelPathname )
      return m_szWordWheelPathname;
  }

  // If we're operating a collection, use the location of the collection file and the collection
  // file root name as the .chm name.
  //
  if (! m_bSingleTitle )
   strcpy(szPathname, m_Collection.GetCollectionFileName());
  else   // else, in single title mode, use master .chm name and location.
   strcpy(szPathname ,GetPathName());

  CHAR* pszFilePart = NULL;
  GetFullPathName( szPathname, sizeof(szPathname), szPathname, &pszFilePart );

  // get the drive of the path
  CHAR szDriveRoot[4];
  strncpy( szDriveRoot, szPathname, 4 );
  szDriveRoot[3] = '\0';

  // make sure to add a backslash if the second char is a colon
  // sometimes we will get just "d:" instead of "d:\" and thus
  // GetDriveType will fail under this circumstance
  if( szDriveRoot[1] == ':' ) {
   szDriveRoot[2] = '\\';
   szDriveRoot[3] = 0;
  }

  // Get media type
  if( szDriveRoot[1] == ':' && szDriveRoot[2] == '\\' ) {
   uiDt = GetDriveType(szDriveRoot);
  }
  else if( szDriveRoot[0] == '\\' && szDriveRoot[1] == '\\' ) {
   uiDt = DRIVE_REMOTE;
  }

  // If removable media or not write access then write to the %windir%\profiles... directory
  if( !( ((uiDt == DRIVE_FIXED) || (uiDt == DRIVE_REMOTE) || (uiDt == DRIVE_RAMDISK)) ) ) {  
   strcpy(szFileName, FindFilePortion(szPathname));
   HHGetUserDataPath( szPathname );
   CatPath(szPathname, szFileName);
  }

  // for chw files this location must be writeable
  if( !strcmp( pszExt, ".chw" ) )
  {
   
   if( (pszExtension = StrRChr( szPathname, '.' )) )
     *pszExtension = '\0';
   strcat( szPathname, ".foo" );
   HANDLE hFile = CreateFile(szPathname, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS , FILE_ATTRIBUTE_NORMAL, 0);
   if (INVALID_HANDLE_VALUE == hFile)
   {  
    strcpy(szFileName, FindFilePortion(szPathname));
    HHGetUserDataPath( szPathname );
    CatPath(szPathname, szFileName);
   }
   else
   {
     CloseHandle(hFile);
     DeleteFile(szPathname);
   }
  }
  // now update the extension
  if( (pszExtension = StrRChr( szPathname, '.' )) )
    *pszExtension = '\0';
  strcat( szPathname, pszExt );

  // for the chw file, save it
  if( !strcmp( pszExt, ".chw" ) ) 
    SetWordWheelPathname( szPathname );

  return( szPathname );
}

const CHAR* CExCollection::GetUserCHSLocalStoragePathnameByLanguage()
{
  // TODO: check for sufficient disk space.

  static CHAR szPathname[MAX_PATH];
  CHAR* pszExtension;

  // If we're operating a collection, use the location of the collection file and the collection
  // file root name as the .chm name.
  //
  if (! m_bSingleTitle )
   strcpy(szPathname, m_Collection.GetCollectionFileName());
  else   // else, in single title mode, use master .chm name and location.
   strcpy(szPathname ,GetPathName());

  CHAR* pszFilePart = NULL;
  GetFullPathName( szPathname, sizeof(szPathname), szPathname, &pszFilePart );

  // now get the users path name
  char szUserPath[MAX_PATH];

  if (HHGetCurUserDataPath( szUserPath ) == S_OK)
  {
    // append language id
    CHAR szTemp[5];
    CHAR* pszName;
    LANGID LangId;
    m_Collection.GetMasterCHM(&pszName, &LangId);
    wsprintf(szTemp, "%d", LangId);
    CatPath(szUserPath, szTemp);
    if( !IsDirectory(szUserPath) )
      CreateDirectory( szUserPath, NULL );

    CatPath(szUserPath, pszFilePart);

    strcpy(szPathname, szUserPath);
  }
  // now update the extension
  if( (pszExtension = StrRChr( szPathname, '.' )) )
    *pszExtension = '\0';
  strcat( szPathname, ".chs" );

  return( szPathname );
}

const CHAR* CExCollection::GetUserCHSLocalStoragePathname()
{
  // TODO: check for sufficient disk space.

  static CHAR szPathname[MAX_PATH];
  CHAR* pszExtension;

  // If we're operating a collection, use the location of the collection file and the collection
  // file root name as the .chm name.
  //
  if (! m_bSingleTitle )
   strcpy(szPathname, m_Collection.GetCollectionFileName());
  else   // else, in single title mode, use master .chm name and location.
   strcpy(szPathname ,GetPathName());

  CHAR* pszFilePart = NULL;
  GetFullPathName( szPathname, sizeof(szPathname), szPathname, &pszFilePart );

  // now get the users path name
  char szUserPath[MAX_PATH];

  if (HHGetCurUserDataPath( szUserPath ) == S_OK)
  {
    CatPath(szUserPath, pszFilePart);
    strcpy(szPathname, szUserPath);
  }
  // now update the extension
  if( (pszExtension = StrRChr( szPathname, '.' )) )
    *pszExtension = '\0';
  strcat( szPathname, ".chs" );

  return( szPathname );
}


const CHAR* CExCollection::SetWordWheelPathname( const CHAR* pszWordWheelPathname )
{
  // if we already have one, free it
  if( m_szWordWheelPathname ) {
    delete [] (CHAR*) m_szWordWheelPathname;
    m_szWordWheelPathname = NULL;
  }

  // allocate a new once based on the size of the input buffer
  int iLen = (int)strlen( pszWordWheelPathname );
  m_szWordWheelPathname = new char[iLen+10];                      // Add 10 for future extension additions.
  strcpy( (CHAR*) m_szWordWheelPathname, pszWordWheelPathname );

  return m_szWordWheelPathname;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CExTitle implementation

void CExTitle::_CExTitle() // <--- put all shared initialization here
{
    m_pUsedLocation = NULL;
    m_bOpen = FALSE;
    m_dwNodeOffsetInParentTitle = 0;
    m_pTitleFTS = NULL;
    m_pCFileSystem = NULL;
    m_pTocNodes = m_pTopics = m_pStrTbl = m_pUrlTbl = m_pUrlStrings = m_pITBits = NULL;
    m_pNext = NULL;
    m_pHeader = NULL;
    m_pInfo = NULL;
    m_pInfo2 = NULL;
    m_fIsChiFile = FALSE;
    m_uiVolumeOrder = (UINT) -1;
    m_bChiChmChecked = FALSE;
    m_bIsValidTitle = FALSE;
    m_cMapIds = 0;
    m_pMapIds = NULL;

    //[ZERO IDXHDR] Mark the m_IdxHeader as being uninitialized.
    m_pIdxHeader = NULL;
    m_pKid = m_pNextKid = m_pParent = NULL;
    m_szAttachmentPathName[0] = 0;
}

CExTitle::CExTitle(const CHAR* pszFileName, CExCollection *pCollection)
{
    _CExTitle();
    m_ContentFileName = pszFileName;
    m_dwColNo = 0;
    m_pTitle = NULL;
    m_pCollection = pCollection;
    m_pInfo2 = new CTitleInformation2( GetIndexFileName() );
}

CExTitle::CExTitle(CTitle *p, DWORD ColNo, CExCollection *pCollection)
{
    _CExTitle();
    m_dwColNo = ColNo;
    m_pTitle = p;
    m_pCollection = pCollection;

    const CHAR* pFileName = NULL ;
    ASSERT(p) ;

   FindUsedLocation();

   if (GetUsedLocation() == NULL)
      return;

    if (GetUsedLocation()->IndexFileName)
      pFileName = GetUsedLocation()->IndexFileName  ;
    else
        pFileName = GetUsedLocation()->FileName ;

   m_pInfo2 = new CTitleInformation2(pFileName);
}

CExTitle::~CExTitle()
{
    CloseTitle();

    if ( m_pTitleFTS )
        delete m_pTitleFTS;
    m_pTitleFTS = NULL;

    if ( m_pInfo2 )
        delete m_pInfo2;
    m_pInfo2 = NULL;

    if ( m_pInfo )
        delete m_pInfo;
    m_pInfo = NULL;
}

void CExTitle::CloseTitle()
{
    if ( m_pTocNodes )
        delete m_pTocNodes;
    m_pTocNodes = NULL;

    if ( m_pTopics )
        delete m_pTopics;
    m_pTopics = NULL;

    if ( m_pStrTbl )
        delete m_pStrTbl;
    m_pStrTbl = NULL;

    if ( m_pUrlTbl )
        delete m_pUrlTbl;
    m_pUrlTbl = NULL;

    if ( m_pUrlStrings )
        delete m_pUrlStrings;
    m_pUrlStrings = NULL;

    if ( m_pITBits )
        delete m_pITBits;
    m_pITBits = NULL;

    if ( m_pHeader )
        lcFree(m_pHeader);
    m_pHeader = NULL;

    if ( m_pCFileSystem ) {
        m_pCFileSystem->Close();
        delete m_pCFileSystem;
      }
    m_pCFileSystem = NULL;

    m_bOpen = FALSE;
}

static const char txtChiFile[] = ".chi";

BOOL CExTitle::OpenTitle()
{
  if (m_bOpen)
    return TRUE;

  // get our title locations
  const CHAR* pszContentFilename = GetPathName();
  const CHAR* pszIndexFilename = GetIndexFileName();

  // bail out if neither file specified
  if( !pszContentFilename && !pszIndexFilename )
    return FALSE;

  // for the single title case, the command line is simply
  // the chm file so we will have to see if the chi files lives in the
  // same location.  If it does not, then we have a monolithic title
  // condition.
  char szIndexFilename[_MAX_PATH];
  if( m_pCollection && m_pCollection->IsSingleTitle() && pszContentFilename ) {
    strcpy( szIndexFilename, pszContentFilename );
    CHAR* psz;
    if( (psz = StrRChr(szIndexFilename, '.')) )
      strcpy(psz, txtChiFile);
    else
      strcat(szIndexFilename, txtChiFile);
    if (GetFileAttributes(szIndexFilename) != HFILE_ERROR)
        pszIndexFilename = szIndexFilename;
  }

  // monolithic title?
  BOOL bMonolithic = FALSE;
  if( !pszIndexFilename || !pszContentFilename ||
    (strcmpi( pszContentFilename, pszIndexFilename ) == 0) ) {
    bMonolithic = TRUE;
  }

  // bail out if no content file
  if( !pszContentFilename )
    return FALSE;

  // now open the title files
  return exOpenFile( pszContentFilename, (bMonolithic || pszIndexFilename[0] == NULL) ? NULL : pszIndexFilename );
}

BOOL CExTitle::FindUsedLocation()
{
    if (m_pUsedLocation)
        return TRUE;

    char drive[_MAX_DRIVE];
    char dir[_MAX_DIR];
    char fname[_MAX_FNAME];
    char ext[_MAX_EXT];

    // find the correct location to use
    // first look for the newest local and entry for this collection
    m_pUsedLocation = m_pTitle->m_pHead;
    DWORD dwNewestLocal = 0;
    DWORD dwNewest = 0;
    LOCATIONHISTORY *pNewestLocal = NULL;
    LOCATIONHISTORY *pNewest = NULL;
    LOCATIONHISTORY *pThisCol = NULL;
    while (m_pUsedLocation)
    {
       _splitpath( m_pUsedLocation->FileName, drive, dir, fname, ext );
       strcpy(dir, drive);
       if (dir[0] != NULL)
       {
            dir[1] = ':';
            dir[2] = '\\';
            dir[3] = NULL;
        }
        if (GetDriveType(dir) == DRIVE_FIXED)
        {
            if (m_pUsedLocation->Version > dwNewestLocal)
            {
                dwNewestLocal = m_pUsedLocation->Version;
                pNewestLocal = m_pUsedLocation;
            }
        }

        if (m_pUsedLocation->Version >= dwNewest)
        {
            dwNewest = m_pUsedLocation->Version;
            pNewest = m_pUsedLocation;
        }

        if (m_pUsedLocation->CollectionNumber == m_dwColNo)
        {
            if (pThisCol)
            {
                if (pThisCol->Version <= m_pUsedLocation->Version)
                    pThisCol = m_pUsedLocation;
            }
            else
                pThisCol = m_pUsedLocation;
        }
        m_pUsedLocation = m_pUsedLocation->pNext;
    }

    m_pUsedLocation = pThisCol;

    if (m_pUsedLocation == NULL)
        return FALSE;

    m_ContentFileName = m_pUsedLocation->FileName;
    m_IndexFileName = m_pUsedLocation->IndexFileName;
    return TRUE;
}

BOOL CExTitle::exOpenFile(const CHAR* pszContent, const CHAR* pszIndex)
{
   HRESULT hr;

   if (m_bOpen)
      return TRUE;

   ASSERT_COMMENT(!m_pCFileSystem, "exOpenFile already called once");

   m_pCFileSystem = new CFileSystem();

   if ( m_pCFileSystem->Init() != S_OK )
      goto failure;
   if ( pszIndex )
   {
       hr = m_pCFileSystem->Open(pszIndex);
       m_IndexFileName = pszIndex;
       m_fIsChiFile = TRUE;
   }
   else
       hr = m_pCFileSystem->Open(pszContent);

   if (FAILED(hr))
      goto failure;

   // title information pointer

   if (! m_pInfo )
   {
      m_pInfo = new CTitleInformation( m_pCFileSystem );
      if (! m_pInfo->GetIdxHeader(&m_pIdxHeader) )
      {
         //
         //    Open and read the idxheader subifle.
         //
         CPagedSubfile* pHdrSubFile;
         BYTE* pb;
      
         pHdrSubFile = new CPagedSubfile;
         if ( SUCCEEDED(hr = pHdrSubFile->Open(this, txtIdxHdrFile)) )
         {
            if ( (pb = (BYTE*)pHdrSubFile->Offset(0)) )
            {
               CopyMemory((PVOID)m_pIdxHeader, (LPCVOID)pb, sizeof(IDXHEADER));
//               m_pIdxHeader->dwOffsMergedTitles = (DWORD*)&m_pIdxHeader->pad; // 64bit overwrite
            }
         }
         if( pHdrSubFile )
           delete pHdrSubFile;
      }
   }
   m_bOpen = TRUE;

   //
   // Init full-text for title
   //
   if(!m_pTitleFTS && GetInfo()->IsFullTextSearch())
   {
      m_pTitleFTS = new CTitleFTS( pszContent, GetInfo()->GetLanguage(), this );
   }

   m_ITCnt = GetInfo()->GetInfoTypeCount();

   if( m_pCollection )
   {
     if ( m_pCollection->GetMasterTitle() != this )    // ALWAYS cache the CExTitle data for the master title. i.e.
        m_pCollection->GetOpenSlot(this);
   }

   // BUGBUG - return a value based on hr when these subfiles exist
   return(TRUE);    // TRUE on success.

failure:
   delete m_pCFileSystem;
   m_pCFileSystem = NULL;
   return FALSE;
}

BOOL CExTitle::EnsureChmChiMatch( CHAR* pszChm )
{
   if (! m_fIsChiFile )
      return TRUE;

   if ( !pszChm && m_bChiChmChecked )
      return m_bIsValidTitle;

   if( pszChm ) {
     m_bChiChmChecked = FALSE;
     m_bIsValidTitle = FALSE;
   }
   else
     m_bChiChmChecked = TRUE;

   FILETIME ftChi, ftChm;
   CTitleInformation* pChmInfo = NULL;
   HRESULT hr;

   ftChi = GetInfo()->GetFileTime();
   CFileSystem* pCFileSysChm = new CFileSystem();
   if ( pCFileSysChm->Init() == S_OK )
   {
      const CHAR* pszChmTry;
      if( pszChm )
        pszChmTry = pszChm;
      else
        pszChmTry = GetPathName();

      if ( SUCCEEDED((hr = pCFileSysChm->Open(pszChmTry))) )
      {
         pChmInfo = new CTitleInformation(pCFileSysChm);
         ftChm = pChmInfo->GetFileTime();
         if ( (ftChm.dwHighDateTime != ftChi.dwHighDateTime) || (ftChm.dwLowDateTime != ftChi.dwLowDateTime) )
         {
            if( pszChm )
               m_bIsValidTitle = FALSE;               
            else if ( MsgBox(IDS_CHM_CHI_MISMATCH, GetPathName(), MB_OKCANCEL | MB_ICONWARNING | MB_TASKMODAL) == IDOK )
               m_bIsValidTitle = TRUE;
            else
               m_bIsValidTitle = FALSE;               
         }
         else
           m_bIsValidTitle = TRUE;
      }
   }
   delete pCFileSysChm;

   if ( pChmInfo )
      delete pChmInfo;

   return m_bIsValidTitle;
}

const CHAR* CExTitle::GetFileName()
{
  if (m_pTitle && GetUsedLocation() == NULL)
    return NULL;

  if (GetUsedLocation())
    return FindFilePortion(GetUsedLocation()->FileName);
  else
    return FindFilePortion(m_ContentFileName);
}

const CHAR* CExTitle::GetPathName()
{
  if (m_pTitle && GetUsedLocation() == NULL)
    return NULL;

  if (GetUsedLocation())
    return GetUsedLocation()->FileName;
  else
    return m_ContentFileName;
}

const CHAR* CExTitle::GetQueryName()
{
  if (m_pTitle && GetUsedLocation() == NULL)
    return NULL;

  if (GetUsedLocation())
  {
    char *pszQueryName = GetUsedLocation()->QueryFileName;

    if( pszQueryName && *pszQueryName)  // don't want a null string
      return pszQueryName;
    else
      return NULL;
  }
  else
  {
    // DON: Is this right?
    //
    return NULL;
  }
}

const CHAR* CExTitle::GetIndexFileName()
{
  if (m_pTitle && GetUsedLocation() == NULL)
    return NULL;

  if (GetUsedLocation())
  {
    return GetUsedLocation()->IndexFileName;
  }
  else
  {
    if ( (CHAR*)m_IndexFileName )
      return m_IndexFileName;
    else
      return GetPathName();
  }
}


const CHAR* CExTitle::GetCurrentAttachmentName()
{
  return (const CHAR*) &m_szAttachmentPathName;
}


const CHAR* CExTitle::SetCurrentAttachmentName( const CHAR* pszAttachmentPathName )
{
  if( pszAttachmentPathName && pszAttachmentPathName[0] )
    strcpy( m_szAttachmentPathName, pszAttachmentPathName );
  return (const CHAR*) &m_szAttachmentPathName;
}

DWORD CExTitle::GetRootSlot(void)
{
   BYTE* pb;

   if (m_bOpen == FALSE)
   {
      if (OpenTitle() == FALSE)
         return 0;
   }
   if (!m_pTocNodes)
   {
       m_pTocNodes = new CPagedSubfile;
      if (FAILED(m_pTocNodes->Open(this, txtTocIdxFile)))
      {
         delete m_pTocNodes;
         m_pTocNodes = NULL;
         return 0;
      }
   }
   if (! m_pHeader )
   {
      m_pHeader = (TOCIDX_HDR*)lcCalloc(sizeof(TOCIDX_HDR));
      if (! (pb = (BYTE*)m_pTocNodes->Offset(0)) )
         return 0;  // m_pHeader will be freeed in destructor.
      CopyMemory((PVOID)m_pHeader, (LPCVOID)pb, sizeof(TOCIDX_HDR));
   }
   return(m_pHeader->dwOffsRootNode);
}


HRESULT CExTitle::GetRootNode(TOC_FOLDERNODE *pNode)
{
   HRESULT hr = E_FAIL;
   DWORD dwNode;
   unsigned int uiWidth;
   const unsigned int *pdwITBits;
   CSubSet* pSS;

   dwNode = GetRootSlot();
   do
   {
      if ( !SUCCEEDED(GetNode(dwNode, pNode)) )
         return hr;

      if ( pNode->dwFlags & TOC_HAS_UNTYPED )
         break;

      if ( (pSS = m_pCollection->m_pSubSets->GetTocSubset()) && pSS->m_bIsEntireCollection )
         break;

      if ( pNode->dwFlags & TOC_FOLDER )
      {
         if ( m_ITCnt > 31 )
         {
            uiWidth = (((m_ITCnt / 32) + 1) * 4);
            pdwITBits = GetITBits(pNode->dwIT_Idx * uiWidth);
         }
         else
            pdwITBits = (const unsigned int *)&pNode->dwIT_Idx;
      }
      else
         pdwITBits = GetTopicITBits(pNode->dwOffsTopic);

   } while ( !m_pCollection->m_pSubSets->fTOCFilter(pdwITBits) && (dwNode = pNode->dwOffsNext) );

   if ( dwNode )
      hr = S_OK;
   return hr;
}

HRESULT CExTitle::GetNode(DWORD iNode, TOC_FOLDERNODE *pNode)
{
   BYTE* pb;
   TOC_FOLDERNODE* pLocalNode;
   HRESULT hr = E_FAIL;

   if ( !iNode )
      return hr;

   if (m_bOpen == FALSE)
   {
      if (OpenTitle() == FALSE)
    return hr;
   }
   if (!m_pTocNodes)
   {
      m_pTocNodes = new CPagedSubfile;
     if (FAILED(hr = m_pTocNodes->Open(this, txtTocIdxFile)))
     {
        delete m_pTocNodes;
        m_pTocNodes = NULL;
        return hr;
    }
   }
   if ( (pb = (BYTE*)m_pTocNodes->Offset(iNode)) )
   {
      pLocalNode = (TOC_FOLDERNODE*)pb;

      if ( pLocalNode->dwFlags & TOC_FOLDER )
    CopyMemory((PVOID)pNode, (LPCVOID)pb, sizeof(TOC_FOLDERNODE));
      else
      {
    CopyMemory((PVOID)pNode, (LPCVOID)pb, sizeof(TOC_LEAFNODE));
    pNode->dwOffsChild = 0;
      }
      hr = S_OK;
   }
   return hr;
}

// CExTitle::GetString()
//
const CHAR* CExTitle::GetString( DWORD dwOffset )
{
  HRESULT hr;
  const CHAR* pStr;

  if( !m_bOpen )
    if( !OpenTitle() )
      return NULL;

  if( !m_pStrTbl ) {
    m_pStrTbl = new CPagedSubfile;
    if( FAILED(hr = m_pStrTbl->Open(this,txtStringsFile)) ) {
      delete m_pStrTbl;
      m_pStrTbl = NULL;
      return NULL;
    }
  }

  pStr = (const CHAR*) m_pStrTbl->Offset( dwOffset );

  return pStr;
}


// CExTitle::GetString()
//
HRESULT CExTitle::GetString( DWORD dwOffset, CHAR* psz, int cb )
{
  const CHAR* pStr = GetString( dwOffset );

  if( pStr ) {
    strncpy( psz, pStr, cb );
    psz[cb-1] = 0;

    return S_OK;
  }
  else
    return E_FAIL;
}

// CExTitle::GetString()
//
HRESULT CExTitle::GetString( DWORD dwOffset, CStr* pcsz )
{
  const CHAR* pStr = GetString( dwOffset );

  if( pStr ) {
    *pcsz = pStr;
    return S_OK;
  }
  else
    return E_FAIL;
}

// CExTitle::GetString()
//
HRESULT CExTitle::GetString( DWORD dwOffset, WCHAR* pwsz, int cch )
{
  const CHAR* pStr = GetString( dwOffset );

  if( pStr ) {
    MultiByteToWideChar( GetInfo()->GetCodePage(), 0, pStr, -1, pwsz, cch );
    return S_OK;
  }
  else
    return E_FAIL;
}

// CExTitle::GetString()
//
HRESULT CExTitle::GetString( DWORD dwOffset, CWStr* pcwsz )
{
  const CHAR* pStr = GetString( dwOffset );

  if( pStr ) {
    MultiByteToWideChar( GetInfo()->GetCodePage(), 0, pStr, -1, *pcwsz, -1 );
    return S_OK;
  }
  else
    return E_FAIL;
}


//
// CExTitle::InfoTypeFilter()
//
// Function determines if the given topic id (topic number) is part of the currently
// selected InfoType profile.
//
// ENTRY:
//   dwTopic - Topic number.
//
// EXIT:
//   BOOL - TRUE if topic is part of currently selected infotype profile. FALSE if not.
//
BOOL CExTitle::InfoTypeFilter(CSubSet* pSubSet, DWORD dwTopic)
{
   const unsigned int *pdwITBits;

   if (m_bOpen == FALSE)
   {
      if (OpenTitle() == FALSE)
         return FALSE;
   }
   pdwITBits = GetTopicITBits(dwTopic);
   return pSubSet->Filter(pdwITBits);
}

//
// Given a topic number, fetch and return a pointer to the itbits
// in the form of a DWORD*
//
const unsigned int * CExTitle::GetTopicITBits(DWORD dwTN)
{
   TOC_TOPIC TopicData;
   unsigned int uiWidth;
   static unsigned int dwITBits;

   GetTopicData(dwTN, &TopicData);
   if ( m_ITCnt > 15 )
   {
     uiWidth = (((m_ITCnt / 32) + 1) * 4);
     return (GetITBits(TopicData.wIT_Idx * uiWidth));
   }
   else
   {
      dwITBits = 0;
      dwITBits = TopicData.wIT_Idx;
      return &dwITBits;
   }
}

//
// Given an offset into the ITBITS subfile, fetch and return a pointer to the itbits
// in the form of a DWORD*
//
const unsigned int * CExTitle::GetITBits(DWORD dwOffsBits)
{
   if (! m_pITBits )
   {
      m_pITBits = new CPagedSubfile;
      if (FAILED(m_pITBits->Open(this, txtITBits)))
      {
         delete m_pITBits;
         m_pITBits = NULL;
         return NULL;
     }
   }
   //
   // Compute the width in DWORDS and get the bits.
   //
   return (const unsigned int *)m_pITBits->Offset(dwOffsBits);
}

// CExTitle::GetTopicData()
//
HRESULT CExTitle::GetTopicData(DWORD dwTopic, TOC_TOPIC * pTopicData)
{
   HRESULT hr;
   BYTE * pb;

   if (m_bOpen == FALSE)
   {
      if (OpenTitle() == FALSE)
    return E_FAIL;
   }
   if (!m_pTopics)
   {
      m_pTopics = new CPagedSubfile;
      if (FAILED(hr = m_pTopics->Open(this, txtTopicsFile)))
      {
            delete m_pTopics;
            m_pTopics = NULL;
            return hr;
        }
   }
   pb = (BYTE*)m_pTopics->Offset(dwTopic * sizeof(TOC_TOPIC));
   if (pb)
   {
      memcpy(pTopicData, pb, sizeof(TOC_TOPIC));
      return S_OK;
   }
   else
      return E_FAIL;
}

HRESULT CExTitle::GetTopicName(DWORD dwTopic, CHAR* pszTitle, int cb)
{
   TOC_TOPIC topic;
   HRESULT hr;

   if (SUCCEEDED(hr = GetTopicData(dwTopic, &topic)))
      return GetString(topic.dwOffsTitle, pszTitle, cb);
   else
      return hr;
}

HRESULT CExTitle::GetTopicName(DWORD dwTopic, WCHAR* pwszTitle, int cch)
{
   TOC_TOPIC topic;
   HRESULT hr;

   if (SUCCEEDED(hr = GetTopicData(dwTopic, &topic)))
      return GetString(topic.dwOffsTitle, pwszTitle, cch);
   else
      return hr;
}

HRESULT CExTitle::GetTopicLocation(DWORD dwTopic, CHAR* pszLocation, int cb)
{
  CTitleInformation* pInfo = GetInfo();

  if( pInfo ) {
    const CHAR* psz = NULL;
    psz = pInfo->GetDefaultCaption();
    if( !psz || !*psz )
      psz = pInfo->GetShortName();
    if( psz && *psz ) {
      strncpy( pszLocation, psz, cb );
      pszLocation[cb-1] = 0;
      return S_OK;
    }
  }

  return E_FAIL;
}

HRESULT CExTitle::GetTopicLocation(DWORD dwTopic, WCHAR* pwszLocation, int cch)
{
  CTitleInformation* pInfo = GetInfo();

  if( pInfo ) {
    const CHAR* psz = NULL;
    psz = pInfo->GetDefaultCaption();
    if( !psz || !*psz )
      psz = pInfo->GetShortName();
    if( psz && *psz ) {
      MultiByteToWideChar( GetInfo()->GetCodePage(), 0, psz, -1, pwszLocation, cch );
      return S_OK;
    }
  }

  return E_FAIL;
}

//
// GetUrlTocSlot();
//
// Translates a URL from this title into it's corisponding offset into the TOC.
// Function will also return the Topic number if desired in reference pdwTopicNumber.
//
HRESULT CExTitle::GetUrlTocSlot(const CHAR* pszURL, DWORD* pdwSlot, DWORD* pdwTopicNumber)
{
   char szURL[MAX_URL];
   HRESULT hr = E_FAIL;

   strncpy( szURL, pszURL, MAX_URL );
   szURL[MAX_URL-1] = 0;

   // Remove all of the stuff from the url.
   NormalizeUrlInPlace(szURL) ;

   TOC_TOPIC Topic;
   if (SUCCEEDED(URL2Topic(szURL, &Topic, pdwTopicNumber)))
   {
      *pdwSlot = Topic.dwOffsTOC_Node;
      return S_OK;
   }

   CHAR* pszInterTopic = NULL;
   if (pszInterTopic = StrChr(szURL, '#'))
   {
     *pszInterTopic = NULL;
     if (SUCCEEDED(URL2Topic(szURL, &Topic, pdwTopicNumber)))
     {
      *pdwSlot = Topic.dwOffsTOC_Node;
      return S_OK;
     }
   }

   return E_FAIL;
}

//
// GetURLTreeNode()
//
// Translates a URL from this title into it's corisponding node in the TOC.
//
HRESULT CExTitle::GetURLTreeNode(const CHAR* pszURL, CTreeNode** ppTreeNode, BOOL bNormalize /* = TRUE */)
{
   char szURL[MAX_URL];
   HRESULT hr = E_FAIL;

   strncpy( szURL, pszURL, MAX_URL );
   szURL[MAX_URL-1] = 0;

   // Remove all of the stuff from the url.
   if (bNormalize)
	   NormalizeUrlInPlace(szURL) ;

   TOC_TOPIC Topic;
   if (SUCCEEDED(URL2Topic(szURL, &Topic)))
   {
      TOC_FOLDERNODE Node;
      if (SUCCEEDED(GetNode(Topic.dwOffsTOC_Node, &Node)))
      {
         *ppTreeNode = new CExNode(&Node, this);
         hr = S_OK;
      }
   }
   return hr;
}

//
// Slot2TreeNode(DWORD dwSlot)
//
// Returns a tree node given a TOC "slot" number. A slot number is just the
// offset into the #TOCIDX subfile.
//
HRESULT CExTitle::Slot2TreeNode(DWORD dwSlot, CTreeNode** ppTreeNode)
{
   TOC_FOLDERNODE Node;
   if ( !IsBadReadPtr(this, sizeof(CExTitle)) && SUCCEEDED(GetNode(dwSlot, &Node)))
   {
//      *ppTreeNode = new CExNode(&Node, this, dwSlot);
      *ppTreeNode = new CExNode(&Node, this);
      return S_OK;
   }
   return E_FAIL;
}

HRESULT CExTitle::GetTopicURL(DWORD dwTopic, CHAR* pszURL, int cb, BOOL bFull )
{
    TOC_TOPIC topic;
    HRESULT hr;
    CExTitle* pTitle;
    CHAR* psz;

    if (m_bOpen == FALSE)
    {
        if (OpenTitle() == FALSE)
            return E_FAIL;
    }
    if (!m_pUrlTbl)
    {
        m_pUrlTbl = new CPagedSubfile;
        if (FAILED(hr = m_pUrlTbl->Open(this, txtUrlTblFile)))
        {
            delete m_pUrlTbl;
            m_pUrlTbl = NULL;
            return hr;
        }
    }
    if (!m_pUrlStrings)
    {
        m_pUrlStrings = new CPagedSubfile;
        if (FAILED(hr = m_pUrlStrings->Open(this, txtUrlStrFile)))
        {
            delete m_pUrlStrings;
            m_pUrlStrings = NULL;
            return hr;
        }
    }
    if ( (hr = GetTopicData(dwTopic, &topic)) == S_OK )
    {
        PCURL pUrlTbl;
        if ( (pUrlTbl = (PCURL)m_pUrlTbl->Offset(topic.dwOffsURL)) )
        {
            PURLSTR purl = (PURLSTR) m_pUrlStrings->Offset(pUrlTbl->dwOffsURL);
            if (purl)
            {
                // If not an interfile jump, the create the full URL
                //
                if (! StrChr(purl->szURL, ':'))
                {
                    /*
                     * 22-Oct-1997  [ralphw] ASSERT on this rather then
                     * checking in retail, because if the caller is using
                     * MAX_URL or INTERNET_MAX_URL_LENGTH then an overflow
                     * will never happen.
                     */
                    pTitle = this;
                    psz = purl->szURL;
qualify:
                    ASSERT((strlen(psz) + strlen((g_bMsItsMonikerSupport ? txtMsItsMoniker : txtMkStore)) + strlen(pTitle->GetPathName()) + 7) < (size_t) cb);
                    if ((int) (strlen(psz) + strlen((g_bMsItsMonikerSupport ? txtMsItsMoniker : txtMkStore)) + strlen(pTitle->GetPathName()) + 7) > cb )
                       return E_OUTOFMEMORY;
                    strncpy(pszURL, (g_bMsItsMonikerSupport ? txtMsItsMoniker : txtMkStore), cb);
                    pszURL[cb-1] = 0;
                    if( bFull )
                      strcat(pszURL, pTitle->GetPathName());
                    else
                      strcat(pszURL, pTitle->GetFileName());
                    if (*psz != '/')
                        strcat(pszURL, txtSepBack);
                    else
                        strcat(pszURL, txtDoubleColonSep);
                    strcat(pszURL, psz);
                }
                else
                {
                   // Check for a URL of this type: vb98.chm::\foo\bar\cat.htm
                   //
                   if ( psz = StrStr(purl->szURL, txtChmColon) )
                   {
                      psz += 4;
                      *psz = '\0';
                      pTitle = m_pCollection->TitleFromChmName(purl->szURL);
                      *psz = ':';
                      if ( pTitle )
                      {
                         psz += 2;
                         goto qualify;
                      }
                   }
                   // BUGBUG: we do the check here to see if the CHM exists,
                   // and if not, switch to the alternate URL (if there is one).

                   strncpy(pszURL, purl->szURL, cb);
                   pszURL[cb-1] = 0;
                }
                hr = S_OK;
            }
        }
    }
    return hr;
}

//
//
//
// we now have to support a new URL format for compiled files.  The format is:
//
//  mk:@MSITStore:mytitle.chm::/dir/mytopic.htm
//
// where "mk:@MSITStore:" can take any one of the many forms of our URL
// prefix and it may be optional.  The "mytitle.chm" substring may or
// may not be a full pathname to the title.  The remaining part is simply
// the pathname inside of the compiled title.
//
// When the URL is in the format, we need to change it to the fully
// qualified URL format which is:
//
//  mk:@MSITStore:c:\titles\mytitle.chm::/dir/mytopic.htm
//
HRESULT CExTitle::ConvertURL( const CHAR* pszURLIn, CHAR* pszURLOut )
{
  HRESULT hr = S_OK;

  // prefix
  if( IsSamePrefix(pszURLIn, txtMkStore, (int)strlen(txtMkStore) - 1) )
    strcpy( pszURLOut, txtMkStore );
  else if( IsSamePrefix(pszURLIn, txtMsItsMoniker, (int)strlen(txtMsItsMoniker) - 1) )
    strcpy( pszURLOut, txtMsItsMoniker );
  else if( IsSamePrefix(pszURLIn, txtItsMoniker, (int)strlen(txtItsMoniker) - 1) )
    strcpy( pszURLOut, txtItsMoniker );
  else {
    strcpy( pszURLOut, pszURLIn );
    return hr;
  }

  // title full pathname
  CStr szPathName;
  ConvertSpacesToEscapes( m_ContentFileName.psz, &szPathName );
  strcat( pszURLOut, szPathName.psz );

  // subfile pathname
  char* pszTail = strstr( pszURLIn, "::" );
  if( pszTail )
    strcat( pszURLOut, pszTail );
  else
    strcpy( pszURLOut, pszURLIn );

  return hr;
}

// CExTitle::URL2TopicNumber
//
//          Translate a URL into a topic number.
//
HRESULT CExTitle::URL2Topic(const CHAR* pszURL, TOC_TOPIC* pTopic, DWORD* pdwTN)
{
   static int iPageCnt = (PAGE_SIZE / sizeof(CURL));
   DWORD dwOffs;
   HRESULT hr = E_FAIL;
   HASH dwHash;
   PCURL pCurl;
   int mid,low = 0;

   if (m_bOpen == FALSE)
   {
       if (OpenTitle() == FALSE)
           return E_FAIL;
   }
   //[ZERO IDXHDR]
   if (!IsIdxHeaderValid())
   {
      return E_FAIL;
   }
   int high = m_pIdxHeader->cTopics - 1;

   if (!m_pUrlTbl)
   {
        m_pUrlTbl = new CPagedSubfile;
        if (FAILED(hr = m_pUrlTbl->Open(this,txtUrlTblFile)))
        {
            delete m_pUrlTbl;
            m_pUrlTbl = NULL;
            return hr;
         }
   }
   //
   // Hash it and find it!
   dwHash = HashFromSz(pszURL);
   while ( low <= high )
   {
     mid = ((low + high) / 2);
     dwOffs = (((mid / iPageCnt) * PAGE_SIZE) + ((mid % iPageCnt) * sizeof(CURL)));
     if (! (pCurl = (PCURL)m_pUrlTbl->Offset(dwOffs)) )   // Read the data in.
        return hr;
     if ( pCurl->dwHash == dwHash )
     {
        if ( pdwTN )
        {
           *pdwTN = pCurl->dwTopicNumber;
           hr = S_OK ; // This part succeeded. we may fail the GetTopicData below.
        }

        if ( pTopic )                     // Found it!
           hr = GetTopicData(pCurl->dwTopicNumber, pTopic);
        break;
     }
     else if ( pCurl->dwHash > dwHash )
        high = mid - 1;
     else
        low = mid + 1;
   }
   return hr;
}

////////////////////////////////////////////////////////
// GetVolumeOrder
//
// returned value in puiVolumeOrder is:
//  0   = local drive
//  1-N = Removable media order (CD1, CD2, etc.)
//  -1  = error

HRESULT CExTitle::GetVolumeOrder( UINT* puiVolumeOrder, UINT uiFileType )
{
  HRESULT hr = S_OK;

  if( m_uiVolumeOrder == (UINT) -1 ) {

    if( m_pCollection->IsSingleTitle() )
      return E_FAIL;

    // Get the location information
    LOCATIONHISTORY* pLocationHistory = GetUsedLocation();

    // Get the pathname
    const CHAR* pszPathname = NULL;
    if( uiFileType == HHRMS_TYPE_TITLE )
      pszPathname = GetPathName();
    else if( uiFileType == HHRMS_TYPE_COMBINED_QUERY )
      pszPathname = GetQueryName();
    else
      return E_FAIL;

    // Get the location identifier
    const CHAR* pszLocation = NULL;
    CLocation* pLocation = NULL;
    if( pLocationHistory ) {
      pszLocation = pLocationHistory->LocationId;
      pLocation = m_pCollection->m_Collection.FindLocation( pszLocation, puiVolumeOrder );
      m_uiVolumeOrder = *puiVolumeOrder;
    }

    // Get the location path
    const CHAR* pszPath = NULL;
    CHAR szPath[MAX_PATH];
    szPath[0]= 0;
    if( pLocation ) {
      pszPath = pLocation->GetPath();
      strcpy( szPath, pszPath );
    }

    // get the drive of the path
    CHAR szDriveRoot[4];
    strncpy( szDriveRoot, szPath, 4 );
    szDriveRoot[3] = '\0';

    // make sure to add a backslash if the second char is a colon
    // sometimes we will get just "d:" instead of "d:\" and thus
    // GetDriveType will fail under this circumstance
    if( szDriveRoot[1] == ':' ) {
      szDriveRoot[2] = '\\';
      szDriveRoot[3] = 0;
    }

    // Get media type
    UINT uiDriveType = DRIVE_UNKNOWN;
    if( szDriveRoot[1] == ':' && szDriveRoot[2] == '\\' ) {
      uiDriveType = GetDriveType(szDriveRoot);
    }
    else if( szDriveRoot[0] == '\\' && szDriveRoot[1] == '\\' ) {
      uiDriveType = DRIVE_REMOTE;
    }

    // handle the drive types
    switch( uiDriveType ) {

      case DRIVE_REMOTE:
      case DRIVE_FIXED:
      case DRIVE_RAMDISK:
        m_uiVolumeOrder = 0;
        break;

      case DRIVE_REMOVABLE:
      case DRIVE_CDROM:
        //m_uiVolumeOrder = 1; // set to one for now
        break;

      case DRIVE_UNKNOWN:
      case DRIVE_NO_ROOT_DIR:
        return E_FAIL;
        break;

      default:
        return E_FAIL;

    }

  }

  *puiVolumeOrder = m_uiVolumeOrder;

  if( m_uiVolumeOrder == (UINT) -1 )
    hr = E_FAIL;

  return hr;
}


//////////////////////////////////////////////////////////////////////////
//
// Translate a ContextID into a URL.
//
//
HRESULT CExTitle::ResolveContextId(DWORD id, CHAR** ppszURL)
{
   CSubFileSystem* pCSubFS;
   int cbMapIds, cbRead;

   if (!m_bOpen)
   {
      if (OpenTitle() == FALSE)
         return E_FAIL;
   }
   if ( !m_pMapIds )
   {
      pCSubFS = new CSubFileSystem(m_pCFileSystem);
      if(FAILED(pCSubFS->OpenSub(txtMAP)))
      {
          delete pCSubFS;
          return HH_E_NOCONTEXTIDS;
      }
      if ( (pCSubFS->ReadSub(&cbMapIds, sizeof(DWORD), (ULONG*)&cbRead) != S_OK) || (cbRead != sizeof(DWORD)) )
      {
          delete pCSubFS;
          return HH_E_NOCONTEXTIDS;
      }
      if (! (m_pMapIds = (MAPPED_ID*)lcMalloc(cbMapIds)) )
      {
          delete pCSubFS;
          return E_FAIL;
      }
      if ( (pCSubFS->ReadSub(m_pMapIds, cbMapIds, (ULONG*)&cbRead) != S_OK) || (cbRead != cbMapIds) )
      {
         delete pCSubFS;
         lcFree(m_pMapIds);
         m_pMapIds = NULL;
         return HH_E_NOCONTEXTIDS;
      }
      m_cMapIds = cbMapIds / sizeof(MAPPED_ID);
   }
   //
   // Translate the id into a URL...
   //
   for (int i = 0; i < m_cMapIds; i++)
   {
      if ( id == m_pMapIds[i].idTopic )
      {
         *ppszURL = (CHAR*)GetString(m_pMapIds[i].offUrl);
         return S_OK;
      }
   }
   return HH_E_CONTEXTIDDOESNTEXIT;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CTreeNode implementation

CTreeNode::CTreeNode()
{
   m_Expanded = FALSE;
   SetError(0);
}

CTreeNode::~CTreeNode()
{

}

BOOL CTreeNode::Compare(CTreeNode *pOtherNode)
{
   if (m_ObjType != pOtherNode->GetObjType())
      return FALSE;

   switch (m_ObjType)
   {
      case EXFOLDERNODE:
    if (((CExFolderNode *)this)->GetFolder() == ((CExFolderNode *)pOtherNode)->GetFolder())
       return TRUE;
    return FALSE;
      case EXTITLENODE:
    if (((CExTitleNode *)this)->GetFolder() == ((CExTitleNode *)pOtherNode)->GetFolder() &&
       ((CExTitleNode *)this)->GetTitle() == ((CExTitleNode *)pOtherNode)->GetTitle())
       return TRUE;
    return FALSE;
      case EXNODE:
      case EXMERGEDNODE:
    CExTitle *p1, *p2;
    p1 = ((CExNode *)this)->GetTitle();
    p2 =((CExNode *)pOtherNode)->GetTitle();
    if (p1 == p2 &&
       ((CExNode *)this)->m_Node.dwFlags == ((CExNode *)pOtherNode)->m_Node.dwFlags &&
       ((CExNode *)this)->m_Node.dwOffsTopic == ((CExNode *)pOtherNode)->m_Node.dwOffsTopic &&
       ((CExNode *)this)->m_Node.dwOffsParent == ((CExNode *)pOtherNode)->m_Node.dwOffsParent &&
       ((CExNode *)this)->m_Node.dwOffsNext == ((CExNode *)pOtherNode)->m_Node.dwOffsNext &&
       ((CExNode *)this)->m_Node.dwOffsChild == ((CExNode *)pOtherNode)->m_Node.dwOffsChild)
          return TRUE;
    return FALSE;
   }
   return FALSE;
}

CTreeNode *CTreeNode::GetExNode(TOC_FOLDERNODE *pNode, CExTitle *pTitle)
{
   if (pNode->dwFlags & TOC_MERGED_REF)
   {
      // read chm file from string file
      CStr cStr;
      if (SUCCEEDED(pTitle->GetString(pNode->dwOffsChild, &cStr)))
      {
         // search title list
         CExTitle *pCur = pTitle->m_pCollection->GetFirstTitle();
         while (pCur)
         {
            if (strcmp(cStr, FindFilePortion(pCur->GetPathName())) == 0)
            {
               CExMergedTitleNode *pT;
               pT = new CExMergedTitleNode(pNode, pCur);
               if (pT != NULL)
                  return pT;
            }
            pCur = pCur->GetNext();
         }
      }
      return GetNextSibling(pNode);
   }
   else
   {
      CExNode *p = new CExNode(pNode, pTitle);
      if (p == NULL)
         return GetNextSibling(pNode);
      return p;
   }
}

void CTreeNode::SetError(DWORD dw)
{
   m_Error = dw;
}

DWORD CTreeNode::GetLastError()
{
   return m_Error;
}

BOOL CTreeNode::GetURL(CHAR* pszURL, unsigned cb, BOOL bFull)
{
   return FALSE;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CExFolderNode  implementation
CExFolderNode::CExFolderNode(CFolder *p, CExCollection *pCollection)
{
   SetObjType(EXFOLDERNODE);
   m_pCollection = pCollection;
   m_pFolder = p;
}

CExFolderNode::~CExFolderNode()
{

}

CTreeNode *CExFolderNode::GetFirstChild(DWORD* pdwSlot)
{
   CStructuralSubset* pSS = NULL;
   CFolder *p = m_pFolder->GetFirstChildFolder();
   CTreeNode *pN;

   // implement structural subsetting here.
   if( m_pCollection && m_pCollection->m_pSSList )
      pSS = m_pCollection->m_pSSList->GetTOC();

   while (p)
   {
      if ((pN = m_pCollection->CheckForTitleNode(p)))
      {
         if ( !pSS || pSS->IsEntire() || p->bIsVisable() )
            return pN;
         else
            delete pN; // leak fix
      }
      p = p->GetNextFolder();
   }
   return NULL;
}

CTreeNode *CExFolderNode::GetNextSibling(TOC_FOLDERNODE *pAltNode, DWORD* pdwSlot)
{
   CStructuralSubset* pSS = NULL;
   CFolder *p = m_pFolder->GetNextFolder();
   CTreeNode *pN;

   // implement structural subsetting here.
   if( m_pCollection && m_pCollection->m_pSSList )
      pSS = m_pCollection->m_pSSList->GetTOC();

   while (p)
   {
      if ((pN = m_pCollection->CheckForTitleNode(p)))
      {
         if ( !pSS || pSS->IsEntire() || p->bIsVisable() )
            return pN;
         else
            delete pN; // leak fix
      }
      p = p->GetNextFolder();
   }
   return NULL;
}

CTreeNode *CExFolderNode::GetParent(DWORD* pdwSlot, BOOL bDirectParent)
{
   CFolder *p = m_pFolder->GetParent();

   if (p->GetTitle() == NULL)
      return NULL;

   if (p)
   {
      return m_pCollection->CheckForTitleNode(p);
   }
   return NULL;
}

HRESULT CExFolderNode::GetTopicName(CHAR* pszTitle, int cb)
{
   CHAR* psz = m_pFolder->GetTitle();

   if (strlen(psz) + 1 > (size_t) cb)
      return E_FAIL;
   else
      strcpy(pszTitle, psz);

   return S_OK;
}

HRESULT CExFolderNode::GetTopicName( WCHAR* pwszTitle, int cch )
{
   CHAR* psz = m_pFolder->GetTitle();

   if( (2*(strlen(psz) + 1)) > (size_t) cch )
      return E_FAIL;
   else {
      UINT CodePage = m_pCollection->GetMasterTitle()->GetInfo()->GetCodePage();
      MultiByteToWideChar( CodePage, 0, psz, -1, pwszTitle, cch );
   }

   return S_OK;
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CExTitleNode implementation
CExTitleNode::CExTitleNode(CExTitle *pTitle, CFolder *p)
{
   SetObjType(EXTITLENODE);
   m_pTitle = pTitle;
   m_pFolder = p;
}

#if 0
CExTitleNode::~CExTitleNode()
{

}
#endif

CTreeNode * CExTitleNode::GetFirstChild(DWORD* pdwSlot)
{
   TOC_FOLDERNODE Node;

   if ( !SUCCEEDED(m_pTitle->GetRootNode(&Node)) )
      return NULL;

   if ( pdwSlot )
      *pdwSlot = m_pTitle->GetRootSlot();

   return GetExNode(&Node, m_pTitle);
}

CTreeNode * CExTitleNode::GetNextSibling(TOC_FOLDERNODE *pAltNode, DWORD* pdwSlot)
{
   CTreeNode *pN;
   CStructuralSubset* pSS = NULL;

   if (m_pFolder == NULL)
      return NULL;

   CFolder *p = m_pFolder->GetNextFolder();

   // implement structural subsetting here.
   if(  m_pTitle && m_pTitle->m_pCollection && m_pTitle->m_pCollection->m_pSSList )
      pSS = m_pTitle->m_pCollection->m_pSSList->GetTOC();

   while (p)
   {
      if ((pN = m_pTitle->m_pCollection->CheckForTitleNode(p)))
      {
         if ( !pSS || pSS->IsEntire() || p->bIsVisable() )
            return pN;
         else
            delete pN; // leak fix
      }
      p = p->GetNextFolder();
   }
   return NULL;
}

CTreeNode * CExTitleNode::GetParent(DWORD* pdwSlot, BOOL bDirectParent)
{
   CFolder *p = m_pFolder->GetParent();

   if (p->GetTitle() == NULL)
      return NULL;

   if (p)
   {
      return m_pTitle->m_pCollection->CheckForTitleNode(p);
   }
   return NULL;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CExMergedTitleNode implementation

CExMergedTitleNode::CExMergedTitleNode(TOC_FOLDERNODE *p, CExTitle *pTitle) : CExNode(p, pTitle)
{
   SetObjType(EXMERGEDNODE);
}

CExMergedTitleNode::~CExMergedTitleNode()
{

}

CTreeNode * CExMergedTitleNode::GetFirstChild(DWORD* pdwSlot)
{
   TOC_FOLDERNODE Node;

   if (FAILED(GetTitle()->GetRootNode(&Node)))
      return NULL;

   return GetExNode(&Node, GetTitle());
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CExNode implementation
CExNode::CExNode(TOC_FOLDERNODE *p, CExTitle *pTitle)
{
   SetObjType(EXNODE);
   if (p)
      memcpy(&m_Node, p, sizeof(TOC_FOLDERNODE));
   m_pTitle = pTitle;
}

#if 0
CExNode::~CExNode()
{

}
#endif

DWORD CExNode::GetType()
{
   if ( (m_Node.dwFlags & TOC_FOLDER) )
   {
      if ( (m_Node.dwFlags & TOC_TOPIC_NODE) )
    return CONTAINER; // Topic Folder.
      else
      {
    if ( m_Node.dwOffsChild )
       return FOLDER;
    else
       return BOGUS_FOLDER;
      }
   } // Folder Only.
   return TOPIC;  // Topic Only.
}

HRESULT CExNode::GetTopicName(CHAR* pszTitle, int cb)
{
   HRESULT hr = S_OK;

   if (! (m_Node.dwFlags & TOC_TOPIC_NODE) )
      hr |= m_pTitle->GetString(m_Node.dwOffsTopic, pszTitle, cb);
   else
      hr |= m_pTitle->GetTopicName(m_Node.dwOffsTopic, pszTitle, cb);

   return hr;
}

HRESULT CExNode::GetTopicName( WCHAR* pwszTitle, int cch )
{
   HRESULT hr = S_OK;

   if (! (m_Node.dwFlags & TOC_TOPIC_NODE) )
      hr |= m_pTitle->GetString(m_Node.dwOffsTopic, pwszTitle, cch);
   else
      hr |= m_pTitle->GetTopicName(m_Node.dwOffsTopic, pwszTitle, cch);

   return hr;
}

CTreeNode *CExNode::GetFirstChild(DWORD* pdwSlot)
{
   unsigned int uiWidth;
   const unsigned int *pdwITBits;
   DWORD dwOffsChild;
   CSubSet* pSS;

   if (m_Node.dwFlags & TOC_HAS_CHILDREN)
   {
      TOC_FOLDERNODE Node;
      dwOffsChild = m_Node.dwOffsChild;

      do
      {
         if ( !SUCCEEDED(m_pTitle->GetNode(dwOffsChild, &Node)) )
            return NULL;

         if ( Node.dwFlags & TOC_HAS_UNTYPED )
            break;

         if ( (pSS = m_pTitle->m_pCollection->m_pSubSets->GetTocSubset()) && pSS->m_bIsEntireCollection )
            break;

         if ( Node.dwFlags & TOC_FOLDER )
         {
            if ( m_pTitle->m_ITCnt > 31 )
            {
               uiWidth = (((m_pTitle->m_ITCnt / 32) + 1) * 4);
               pdwITBits = m_pTitle->GetITBits(Node.dwIT_Idx * uiWidth);
            }
            else
               pdwITBits = (const unsigned int *)&Node.dwIT_Idx;
         }
         else
            pdwITBits = m_pTitle->GetTopicITBits(Node.dwOffsTopic);
      } while ( !m_pTitle->m_pCollection->m_pSubSets->fTOCFilter(pdwITBits) && (dwOffsChild = Node.dwOffsNext) );

      if ( dwOffsChild )
      {
         if ( pdwSlot )
            *pdwSlot = dwOffsChild;
         return GetExNode(&Node, m_pTitle);
      }
   }
   return NULL;
}

CTreeNode *CExNode::GetNextSibling(TOC_FOLDERNODE *pAltNode, DWORD* pdwSlot)
{
   TOC_FOLDERNODE Node;
   DWORD dwNext = (pAltNode ? pAltNode->dwOffsNext : m_Node.dwOffsNext);
   unsigned int uiWidth;
   const unsigned int *pdwITBits;
   CSubSet* pSS;

   do
   {
      if ( !SUCCEEDED(m_pTitle->GetNode(dwNext, &Node)) )
         return NULL;

      if ( Node.dwFlags & TOC_HAS_UNTYPED )
         break;

      if ( (pSS = m_pTitle->m_pCollection->m_pSubSets->GetTocSubset()) && pSS->m_bIsEntireCollection )
         break;
      if ( Node.dwFlags & TOC_FOLDER )
      {
         if ( m_pTitle->m_ITCnt > 31 )
         {
            uiWidth = (((m_pTitle->m_ITCnt / 32) + 1) * 4);
            pdwITBits = m_pTitle->GetITBits(Node.dwIT_Idx * uiWidth);
         }
         else
            pdwITBits = (const unsigned int *)&Node.dwIT_Idx;
      }
      else
         pdwITBits = m_pTitle->GetTopicITBits(Node.dwOffsTopic);
   } while ( !m_pTitle->m_pCollection->m_pSubSets->fTOCFilter(pdwITBits) && (dwNext = Node.dwOffsNext) );

   if ( dwNext )
   {
      if ( pdwSlot )
         *pdwSlot = dwNext;
      return GetExNode(&Node, m_pTitle);
   }
   return NULL;
}

CTreeNode *CExNode::GetParent(DWORD* pdwSlot, BOOL bDirectParent)
{
   TOC_FOLDERNODE Node;

    if (m_Node.dwOffsParent)
    {
        if ( !SUCCEEDED(m_pTitle->GetNode(m_Node.dwOffsParent, &Node)) )
            return NULL;
        if ( pdwSlot )
           *pdwSlot = m_Node.dwOffsParent;
        return GetExNode(&Node, m_pTitle);
    }
    else
    {
        // check if this is a merged title
        if (m_pTitle->GetNodeOffsetInParentTitle())
        {
            // assume that the first title in the collection is the master title
            CExTitle * pParent;

            pParent = m_pTitle->m_pCollection->GetFirstTitle();

            if (!pParent)
                return NULL;

            if ( !SUCCEEDED(pParent->GetNode(m_pTitle->GetNodeOffsetInParentTitle(), &Node)) )
                return NULL;
            if ( pdwSlot )
               *pdwSlot = m_pTitle->GetNodeOffsetInParentTitle();
            return GetExNode(&Node, pParent);
        }
        else
        {
             // is this a collection
            if (m_pTitle->m_pCollection->IsSingleTitle() == FALSE)
            {

               CFolder *p = m_pTitle->m_pCollection->FindTitleFolder(m_pTitle);

               if (!p)
                  return NULL;

                CTreeNode *pTitle;
                if (pTitle = m_pTitle->m_pCollection->CheckForTitleNode(p))
                {
                    if (bDirectParent == TRUE)
                        return pTitle;
                    CTreeNode *p = pTitle->GetParent(pdwSlot);
                    delete pTitle;
                    return p;
                }
            }
        }
    }
   return NULL;
}

BOOL CExNode::GetURL(CHAR* pszURL, unsigned cb, BOOL bFull)
{
   if ( (m_Node.dwFlags & TOC_TOPIC_NODE) )
      if ( SUCCEEDED(m_pTitle->GetTopicURL(m_Node.dwOffsTopic, pszURL, cb, bFull)) )
    return TRUE;
   return FALSE;
}