Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

426 lines
14 KiB

// Copyright (C) Microsoft Corporation 1996-1997, All Rights reserved.
//*********************************************************************************************************************************************
//
// File: toc.h
// Author: Donald Drake
// Purpose: Defines classes to support populating the table of contents
#if _MSC_VER > 1000
#pragma once
#endif
#ifndef _TOC_H
#define _TOC_H
#include "cinfotyp.h"
#include "system.h"
#include "collect.h"
#include "hhtypes.h"
#include "fs.h"
#include "subfile.h"
#include "state.h"
#include "csubset.h"
//#include "subset.h" // Structural subsets
#include "hhfinder.h"
#define MAX_OPEN_TITLES 25
//#define DUMPTOC 1
#ifdef DUMPTOC
#include <stdio.h>
#endif
// Persist keys. Declared in toc.cpp
//
extern const char g_szFTSKey[];
extern const char g_szIndexKey[];
extern const char g_szTOCKey[];
class CExTitle;
class CExFolderNode;
class CExTitleNode;
class CExMergedTitleNode;
class CExNode;
class CTreeNode;
class CFullTextSearch;
class CTitleFTS;
class CSearchHighlight;
class CPagedSubfile;
class CTitleDatabase;
class CSSList;
extern CExCollection* g_pCurrentCollection;
//[ZERO IDXHDR] The IDX Header subfile may be zero length, because some early version of HHCTRL
// didn't write it out. We need to make sure that we have an IDX header before we try to use it.
// If we don't we will crash.
#define IDXHEADER_UNINITIALIZED (0xFFFFFFFF)
//class CExTitle: public CSubfileGroupList
class CExTitle SI_COUNT(CExTitle)
{
friend class CPagedSubfile;
public:
void _CExTitle();
CExTitle(CTitle* p, DWORD ColNo, CExCollection* pCollection);
CExTitle(const CHAR* pszFileName, CExCollection* pCollection);
~CExTitle();
inline BOOL Init() { int bReturn = TRUE; if( !isOpen() ) bReturn = OpenTitle(); return bReturn; }
inline CTitleInformation* GetInfo() { if( Init() ) return m_pInfo; else return NULL; }
inline CTitleInformation2* GetInfo2() { return m_pInfo2; }
inline BOOL isOpen(void) { return m_bOpen; }
inline CFileSystem* GetTitleIdxFileSystem(void) { if(!m_bOpen) OpenTitle(); return m_pCFileSystem; }
inline void SetNodeOffsetInParentTitle(DWORD dw) { m_dwNodeOffsetInParentTitle = dw;}
inline DWORD GetNodeOffsetInParentTitle() { return m_dwNodeOffsetInParentTitle; }
inline CExTitle* GetNext() { return m_pNext; }
inline void SetNext(CExTitle* p) { m_pNext = p; }
IDXHEADER* GetIdxHeaderStruct() { ASSERT(IsIdxHeaderValid()); return m_pIdxHeader;}
DWORD GetTopicCount() { ASSERT(IsIdxHeaderValid()); return m_pIdxHeader->cTopics;}
BOOL IsIdxHeaderValid() { if(m_pIdxHeader) return (BOOL)m_pIdxHeader->cTopics; else return FALSE; }
CTitle* GetCTitle() { return m_pTitle; }
CFileSystem* GetFileSystem(void) { return m_pCFileSystem; }
LOCATIONHISTORY* GetUsedLocation() { return m_pUsedLocation; }
BOOL isChiFile(void) { return m_fIsChiFile; }
const unsigned int* GetITBits(DWORD dwOffsBits);
BOOL OpenTitle();
void CloseTitle();
BOOL exOpenFile(const CHAR* pszContent, const CHAR* pszIndex = NULL);
BOOL InfoTypeFilter(CSubSet* pSubSet, DWORD dwTopic);
const unsigned int* GetTopicITBits(DWORD dwTN);
HRESULT GetRootNode(TOC_FOLDERNODE* pNode);
DWORD GetRootSlot(void);
HRESULT GetNode(DWORD iNode, TOC_FOLDERNODE* pNode);
const CHAR* GetFileName();
const CHAR* GetPathName();
const CHAR* GetQueryName();
const CHAR* GetIndexFileName();
const CHAR* GetCurrentAttachmentName();
const CHAR* SetCurrentAttachmentName( const CHAR* pszAttachmentPathName );
HRESULT GetTopicName( DWORD dwTopic, CHAR* pszTitle, int cb );
HRESULT GetTopicName( DWORD dwTopic, WCHAR* pwszTitle, int cch );
HRESULT GetTopicLocation(DWORD dwTopic, CHAR* pszLocation, int cb);
HRESULT GetTopicLocation(DWORD dwTopic, WCHAR* pwszLocation, int cch);
HRESULT GetUrlTocSlot(const CHAR* pszURL, DWORD* pdwSlot, DWORD* pdwTopicNumber);
HRESULT GetTopicURL(DWORD dwTopic, CHAR* pszURL, int cb, BOOL bFull = TRUE );
const CHAR* GetString( DWORD dwOffset );
HRESULT GetString( DWORD dwOffset, CStr* pcsz );
HRESULT GetString( DWORD dwOffset, CHAR* psz, int cb );
HRESULT GetString( DWORD dwOffset, CWStr* pcsz );
HRESULT GetString( DWORD dwOffset, WCHAR* pwsz, int cb );
HRESULT GetURLTreeNode(const CHAR* pszURL, CTreeNode** ppTreeNode, BOOL b = TRUE);
HRESULT GetVolumeOrder( UINT* puiVolumeOrder, UINT uiFileType = HHRMS_TYPE_TITLE );
HRESULT ConvertURL( const CHAR* pszURLIn, CHAR* pszURLOut );
HRESULT Slot2TreeNode(DWORD dwSlot, CTreeNode** ppTreeNode);
HRESULT URL2Topic(const CHAR* pszURL, TOC_TOPIC* pTopic, DWORD* pdwTN = NULL);
BOOL FindUsedLocation();
BOOL EnsureChmChiMatch( CHAR* pszChm = NULL );
HRESULT ResolveContextId(DWORD id, CHAR** ppszURL);
inline CStr& GetContentFileName() { return m_ContentFileName; }
// data members should always be private!
CTitleFTS* m_pTitleFTS;
CTitle* m_pTitle;
CExCollection* m_pCollection;
HASH m_dwHash;
int m_ITCnt;
//
// Support for VB style "super chms"
//
CExTitle* m_pKid;
CExTitle* m_pNextKid;
CExTitle* m_pParent;
private:
HRESULT GetTopicData(DWORD dwTopic, TOC_TOPIC* pTopicData);
CStr m_ContentFileName;
CStr m_IndexFileName;
TOCIDX_HDR* m_pHeader; // Header of #TOCIDX system subfile.
IDXHEADER* m_pIdxHeader; // Global header information for entire .CHM/.CHI file.
LOCATIONHISTORY* m_pUsedLocation;
BOOL m_bOpen;
CExTitle* m_pNext;
DWORD m_dwColNo;
DWORD m_dwNodeOffsetInParentTitle;
BOOL m_fIsChiFile;
BOOL m_bIsValidTitle;
BOOL m_bChiChmChecked;
MAPPED_ID* m_pMapIds;
int m_cMapIds;
//
// Tome FS object (.chm/.chi) and Cached subfile objects.
//
CFileSystem* m_pCFileSystem;
CPagedSubfile* m_pTocNodes;
CPagedSubfile* m_pTopics;
CPagedSubfile* m_pStrTbl;
CPagedSubfile* m_pUrlTbl;
CPagedSubfile* m_pUrlStrings;
CPagedSubfile* m_pITBits;
CTitleInformation* m_pInfo;
CTitleInformation2* m_pInfo2;
UINT m_uiVolumeOrder;
char m_szAttachmentPathName[MAX_PATH];
};
class CExCollection SI_COUNT(CExCollection)
{
public:
CExCollection(CHmData* phmData, const CHAR* pszFile, BOOL bSingleTitle = TRUE);
virtual ~CExCollection();
BOOL InitCollection();
#ifdef CHIINDEX
BOOL InitCollection( const TCHAR * FullPath, const TCHAR * szMasterChmFn );
#endif
BOOL InitFTSKeyword();
CHmData* m_phmData;
DWORD GetRefedTitleCount();
BOOL IsBinaryTOC(const CHAR* pszToc);
void GetOpenSlot(CExTitle* p);
CTreeNode* GetRootNode();
CTreeNode* GetPrev(CTreeNode* pTreeNode, DWORD* pdwSlot = NULL);
CTreeNode* GetNext(CTreeNode* pTreeNode, DWORD* pdwSlot = NULL);
CTreeNode* GetNextTopicNode(CTreeNode* pTreeNode, DWORD* pdwSlot = NULL);
HRESULT Sync(CPointerList* pHier, const CHAR* pszURL = NULL);
HRESULT GetCurrentTocNode(CTreeNode** ppTreeNode) { if (m_pCurrTitle) return m_pCurrTitle->Slot2TreeNode(m_dwCurrSlot, ppTreeNode); else return E_FAIL ;}
CExTitle* GetFirstTitle() { return m_pHeadTitles; }
CExTitle* GetMasterTitle() { return m_pMasterTitle; }
CExTitle* GetCurSyncExTitle() { return m_pCurrTitle; }
CExTitle* FindTitle(const CHAR* pszId, LANGID LangId);
// Try multiple LangIds before failing
CExTitle* FindTitleNonExact(const CHAR* pszId, LANGID LangId);
CLocation* FindLocation(CHAR* pszId);
void CheckForTitleChild(CFolder* p, BOOL *pbFound);
CTreeNode* CheckForTitleNode(CFolder* );
void GetMergedTitles(CExTitle* );
BOOL IsSingleTitle() { return m_bSingleTitle; }
CFolder* FindTitleFolder(CExTitle* pTitle);
const CHAR* GetPathName() const {
return m_phmData->GetCompiledFile(); }
HRESULT URL2ExTitle(const CHAR* pszURL, CExTitle** ppTitle);
const CHAR* GetUserCHSLocalStoragePathnameByLanguage();
const CHAR* GetUserCHSLocalStoragePathname();
const CHAR* GetLocalStoragePathname( const CHAR* pszExt );
BOOL UpdateLocation( const CHAR* pszLocId, const CHAR* pszNewPath, const CHAR* pszNewVolume = NULL, const CHAR* pszNewTitle = NULL);
void GetChildURLS(CTreeNode* pNode, CTable *pTable);
void UpdateTopicSlot(DWORD dwSlot, DWORD dwTN, CExTitle* pTitle);
void SetTopicSlot(DWORD dwSlot, DWORD dwTN, CExTitle* pTitle) { m_dwCurrSlot = (dwSlot ? dwSlot : m_dwCurrSlot), m_dwCurrTN = dwTN, m_pCurrTitle = pTitle ? pTitle : m_pCurrTitle; }
CExTitle* TitleFromChmName(const CHAR* pszChmName);
void InitStructuralSubsets(void);
//
// State API's
//
CState* GetState(void) { return m_pstate; }
HRESULT OpenState(const CHAR* pszName, DWORD dwAccess = (STGM_READWRITE | STGM_SHARE_DENY_WRITE)) { return m_pstate->Open(pszName, dwAccess); }
void CloseState(void) { m_pstate->Close(); }
HRESULT ReadState(void* pData, DWORD cb, DWORD* pcbRead) { return m_pstate->Read(pData, cb, pcbRead); }
DWORD WriteState(const void* pData, DWORD cb) { return m_pstate->Write(pData, cb); }
// data members should always be private!
CFullTextSearch* m_pFullTextSearch;
CSearchHighlight* m_pSearchHighlight;
CTitleDatabase* m_pDatabase;
CSubSets *m_pSubSets; // SubSets of information types, instantiated in system.cpp::ReadSystemFiles()
CSSList* m_pSSList; // List of structural subsets.
CSlotLookupTable* m_pCSlt; // Pointer to the slot lookup table.
CCollection m_Collection;
CStr m_csFile;
private:
const CHAR* SetWordWheelPathname( const CHAR* pszWordWheelPathname );
CTreeNode* GetLastChild(CTreeNode* pTreeNode, DWORD* pdwSlot = NULL);
BOOL ValidateTitle(CExTitle* pExTitle, BOOL bDupCheckOnly = FALSE);
CExTitle* m_pHeadTitles;
CExTitle* m_pMasterTitle;
BOOL m_bSingleTitle;
CHAR* m_szWordWheelPathname;
CExTitle* m_MaxOpenTitles[MAX_OPEN_TITLES];
DWORD m_dwLastSlot;
//
// Topic centricity work below. !!!! Don't ever even consider relying on m_pCurrTitle for any thing !!!!
// this is only here to make make topic centricity work more robustly.
//
DWORD m_dwCurrSlot;
DWORD m_dwCurrTN;
CExTitle* m_pCurrTitle;
//
// Support for persistance via hh.dat
//
CState* m_pstate;
#ifdef DUMPTOC
void DumpNode(CTreeNode**);
FILE* m_fh;
BOOL m_bRoot;
DWORD m_dwLevel;
#endif
};
class CSubSet;
#define EXFOLDERNODE 1
#define EXTITLENODE 2
#define EXNODE 3
#define EXMERGEDNODE 4
class CTreeNode SI_COUNT(CTreeNode)
{
public:
CTreeNode();
virtual ~CTreeNode();
BYTE GetObjType() { return m_ObjType; }
void SetObjType(BYTE x) { m_ObjType = x; }
virtual DWORD GetType() = 0;
virtual HRESULT GetTopicName( CHAR* pszTitle, int cb ) = 0;
virtual HRESULT GetTopicName( WCHAR* pwszTitle, int cch ) = 0;
virtual CTreeNode* GetFirstChild(DWORD* pdwSlot = NULL) = 0;
virtual CTreeNode* GetNextSibling(TOC_FOLDERNODE* pAltNode = NULL, DWORD* pdwSlot = NULL) = 0;
virtual CTreeNode* GetParent(DWORD* pdwSlot = NULL, BOOL bDirectParent = FALSE) = 0;
virtual BOOL HasChildren() = 0;
inline virtual BOOL IsNew() { return FALSE; }
virtual BOOL GetURL(CHAR* pszURL, unsigned cb, BOOL bFull = TRUE);
DWORD GetLastError();
CTreeNode* GetExNode(TOC_FOLDERNODE* pNode, CExTitle* pTitle);
BOOL Compare(CTreeNode* pOtherNode);
// data members should always be private!
BYTE m_Expanded;
private:
void SetError(DWORD dw);
BYTE m_ObjType;
DWORD m_Error;
};
//The GetType function can return one of the follow defines:
#define VIRTUALROOT 0 // a node that contains the top level nodes of the tree, not part of the tree
#define XMLFOLDER 1 // a folder defined in the collection file
#define TITLE 2 // a title which is leaf node of the xml tree
#define FOLDER 3 // a folder defined in a title
#define CONTAINER 4 // a folder that is also a topic
#define TOPIC 5 // a topic
#define BOGUS_FOLDER 6 // a folder that is not a topic and has no kids. Bogus!
class CExFolderNode : MI_COUNT(CExFolderNode)
public CTreeNode
{
public:
CExFolderNode( CFolder*, CExCollection* );
virtual ~CExFolderNode();
inline virtual DWORD GetType() { return XMLFOLDER; }
virtual HRESULT GetTopicName( CHAR* pszTitle, int cb );
virtual HRESULT GetTopicName( WCHAR* pwszTitle, int cch );
inline virtual BOOL HasChildren() { return TRUE; }
virtual CTreeNode* GetFirstChild(DWORD* pdwSlot);
virtual CTreeNode* GetNextSibling(TOC_FOLDERNODE* pAltNode = NULL, DWORD* pdwSlot = NULL);
virtual CTreeNode* GetParent(DWORD* pdwSlot = NULL, BOOL bDirectParent = FALSE);
inline CFolder* GetFolder() { return m_pFolder; }
private:
CFolder* m_pFolder;
CExCollection* m_pCollection;
};
class CExTitleNode : // MI_COUNT(CExTitleNode)
public CTreeNode
{
public:
CExTitleNode( CExTitle* , CFolder* );
// virtual ~CExTitleNode();
inline virtual DWORD GetType() { return TITLE; }
inline virtual HRESULT GetTopicName( CHAR* pszTitle, int cb ) { return NULL; }
inline virtual HRESULT GetTopicName( WCHAR* pwszTitle, int cch ) { return NULL; }
virtual CTreeNode* GetFirstChild(DWORD* pdwSlot = NULL);
virtual CTreeNode* GetNextSibling(TOC_FOLDERNODE* pAltNode = NULL, DWORD* pdwSlot = NULL);
virtual CTreeNode* GetParent(DWORD* pdwSlot = NULL, BOOL bDirectParent = FALSE);
inline virtual BOOL HasChildren() { return TRUE; }
CExTitle* GetTitle() { return m_pTitle; }
CFolder* GetFolder() { return m_pFolder; }
private:
CFolder* m_pFolder;
CExTitle* m_pTitle;
};
class CExNode : MI_COUNT(CExNode)
public CTreeNode
{
public:
CExNode(TOC_FOLDERNODE* p, CExTitle* pTitle);
// virtual ~CExNode();
virtual BOOL GetURL(CHAR* pszURL, unsigned cb, BOOL bFull = TRUE);
virtual DWORD GetType();
virtual HRESULT GetTopicName( CHAR* pszTitle, int cb );
virtual HRESULT GetTopicName( WCHAR* pwszTitle, int cch );
virtual CTreeNode* GetFirstChild(DWORD* pdwSlot = NULL);
virtual CTreeNode* GetNextSibling(TOC_FOLDERNODE* pAltNode = NULL, DWORD* pdwSlot = NULL);
virtual CTreeNode* GetParent(DWORD* pdwSlot = NULL, BOOL bDirectParent = FALSE);
inline virtual BOOL HasChildren() { return m_Node.dwFlags & TOC_HAS_CHILDREN; }
inline virtual BOOL IsNew() { return m_Node.dwFlags & TOC_NEW_NODE; }
inline CExTitle* GetTitle() { return m_pTitle; }
// data members should always be private!
TOC_FOLDERNODE m_Node;
private:
CExTitle* m_pTitle;
};
class CExMergedTitleNode : MI_COUNT(CExMergedTitleNode)
public CExNode
{
public:
CExMergedTitleNode( TOC_FOLDERNODE* pFolderNode, CExTitle* pTitle );
virtual ~CExMergedTitleNode();
inline virtual DWORD GetType() { return TITLE; }
virtual CTreeNode* GetFirstChild( DWORD* pdwSlot = NULL );
};
// Helper functions
#endif // _TOC_H