// Copyright (C) 1996-1997 Microsoft Corporation. All rights reserved.
#if _MSC_VER > 1000
#pragma once
#endif
#ifndef __SITEMAP_H__
#define __SITEMAP_H__
class CHtmlHelpControl; // forward reference
#include "cinput.h"
#include "strtable.h"
typedef PCSTR URL;
typedef UINT INFOTYPE;
const INFOTYPE ITYPE_ALWAYS_SHOW = 0; // when this info type is defined, the entry is always shown to the user (unless a Hidden info type overrides)
const int MAX_RELATED_ENTRIES = 256; // maximum number of sitemap entries for Related Topics
const int MAX_KEYSEARCH_ENTRIES = 256; // maximum number of sitemap entries for Keyword Search
enum {
IMAGE_CLOSED_BOOK = 1,
IMAGE_OPEN_BOOK,
IMAGE_CLOSED_BOOK_NEW,
IMAGE_OPEN_BOOK_NEW,
IMAGE_CLOSED_FOLDER,
IMAGE_OPEN_FOLDER,
IMAGE_CLOSED_FOLDER_NEW,
IMAGE_OPEN_FOLDER_NEW,
IMAGE_HELP_TOPIC,
IMAGE_HELP_TOPIC_NEW,
IMAGE_TOPIC,
IMAGE_TOPIC_NEW,
IMAGE_TOPIC_REMOTE,
IMAGE_TOPIC_NEW_REMOTE,
};
#define IMAGE_INFOTYPE 37
#define ESCAPE_ENTITY 0x01
#define ESCAPE_URL 0x02
#define ESCAPE_C 0x04
#define ESCAPE_ALL 0x07
/*
Each URL can be associated with any number of information types.
Information types are stored as bit flags. By default, each
SITE_ENTRY_URL entry contains enough storage for 32 information types.
If more are needed, then additional memory must be allocated. Note that
we must allocate 4 bytes for each additional information type in order to
avoid alignment problems.
The CSiteMap class must keep track of the total number of bytes to
allocate for each SITE_ENTRY_URL structure. This can NOT change once
a SITEMAP_ENTRY has been allocated (unless all SITEMAP_ENTRY structures
get updated). Within the SITEMAP_ENTRY structure, cUrls tells us how
many SITE_ENTRY_URL structures to allocate.
*/
typedef struct {
PCSTR pszTitle;
URL urlPrimary;
URL urlSecondary;
//INFOTYPE ainfoTypes[1]; // which information types
INFOTYPE *ainfoTypes;
} SITE_ENTRY_URL;
const int MAX_CATEGORIES = 10;
typedef struct {
int c_Types; // the number of ITs in a category
INFOTYPE *pInfoType; // a pointer to a set of infotype bits. The bits represent info types
// bit zero is reserved.
} CATEGORY_TYPE;
typedef struct {
CTable* m_ptblInfoTypes;
CTable* m_ptblInfoTypeDescriptions;
CTable* m_ptblCategories;
CTable* m_ptblCatDescription;
int m_cTypes; // total number of types
int m_cITSize; // The number of DWORDs allocated for categories, m_pExclusive, and m_pHidden
INFOTYPE* m_pExclusive; // index to first exclusive information type
INFOTYPE* m_pHidden; // index to first hidden information type
int m_max_categories; // The number of categories currently allocated.
CATEGORY_TYPE *m_aCategories;
} INFOTYPE_TABLES;
// Overhead is 20 bytes per entry + 12 for each URL (assuming up to 32 InfoTypes)
// forward reference
class CSiteMap;
typedef struct _tagSiteMapEntry {
#ifndef HHA
CSiteMap* pSiteMap;
#endif
PCSTR pszText; // title/keyword for this entry
#ifndef HHCTRL
PCSTR pszComment;
PCSTR pszSort; // used when sorting index
#endif
short iWindowName;
short iFrameName;
short iFontName;
short cUrls; // number or URLS
BYTE iImage;
BYTE level;
BYTE fInclude; // Used by HHW to track included sitemap file
BYTE fTopic:1;
BYTE fNew:1;
BYTE fNoDisplay:1;
BYTE fSeeAlso:1;
BYTE fShowToEveryOne:1; // TRUE if no Information Type was specified
BYTE fSendEvent:1; // TRUE if URL is an event string
BYTE fSendMessage:1; // TRUE if URL is a message string
BYTE fShortCut:1; // TRUE if URL is a shortcut string
// WARNING! pUrls must be the last member of this structure
SITE_ENTRY_URL* pUrls;
int GetLevel(void) const { return level; }
void SetLevel(int val) { level = (BYTE)val; }
PCSTR GetKeyword() const { return pszText; }
#ifdef HHCTRL
#ifndef HHA
HRESULT GetKeyword( WCHAR* pwszKeyword, int cch );
#endif
#endif
PCSTR GetTitle( SITE_ENTRY_URL* pUrl ) { return pUrl->pszTitle ? pUrl->pszTitle : GetStringResource(IDS_UNTITLED); }
#ifdef HHCTRL
#ifndef HHA
HRESULT GetTitle( SITE_ENTRY_URL* pUrl, WCHAR* pwszTitle, int cch );
#endif
#endif
BOOL IsTopic(void) const { return fTopic; }
void SetTopic(BOOL fSetting) { fTopic = fSetting; }
BOOL IsNew(void) const { return fNew; }
void SetNew(BOOL fSetting) { fNew = fSetting; }
BOOL GetSeeAlso(void) const { return fSeeAlso; }
void SetSeeAlso(BOOL fSetting) { fSeeAlso = fSetting; }
int GetImageIndex(void) const { return iImage; }
void SetImageIndex(int IndexImage) { iImage = (BYTE) IndexImage; }
int GetWindowIndex(void) const { return (int) iWindowName; }
void SetWindowIndex(int index) { iWindowName = (short)index; }
int GetFrameIndex(void) const { return (int) iFrameName; }
void SetFrameIndex(int index) { iFrameName = (short)index; }
int GetFontIndex(void) const { return (int) iFontName; }
void SetFontIndex(int index) { iFontName = (short)index; }
void Clear(void) { ClearMemory(this, sizeof(_tagSiteMapEntry)); }
} SITEMAP_ENTRY;
class CSiteMapEntry : public SITEMAP_ENTRY
{
public:
CSiteMapEntry() { ClearMemory(this, sizeof(CSiteMapEntry)); }
#ifndef HHCTRL
void CopyFrom(const SITEMAP_ENTRY* pSiteMapEntry, CSiteMap* pSiteMapSrc, CSiteMap* pSiteMapDst);
void CopyTo(SITEMAP_ENTRY* pSiteMapEntry, CSiteMap* pSiteMapSrc, CSiteMap* pSiteMapDst);
#endif
};
class CSiteEntryUrl
{
public:
CSiteEntryUrl(int ITSize) {
m_pUrl = (SITE_ENTRY_URL*) lcCalloc(sizeof(SITE_ENTRY_URL) );
m_pUrl->ainfoTypes = (INFOTYPE*)lcCalloc( ITSize==0?sizeof(INFOTYPE):ITSize );
m_fUrlSpecified = FALSE;
}
~CSiteEntryUrl() { lcFree(m_pUrl->ainfoTypes); lcFree(m_pUrl); }
void SaveUrlEntry(CSiteMap* pSiteMap, SITEMAP_ENTRY* pSiteMapEntry);
SITE_ENTRY_URL* m_pUrl;
int m_cMaxTypes;
BOOL m_fUrlSpecified;
};
class CParseSitemap; // forward reference
// Forward declarations declared in genit.cpp
//
int GetITBitfromIT(INFOTYPE const *IT, int* offset, int* bit, int cTypes);
void AddIT(int const type, INFOTYPE *pIT );
void DeleteIT(int const type, INFOTYPE *pIT );
int GetITfromCat(int* offset, INFOTYPE* bit, INFOTYPE* pInfoType, int cTypes);
int GetITBitfromIT(INFOTYPE const *IT, int* offset, INFOTYPE* bit, int cTypes);
void CopyITBits(INFOTYPE** ITDst, INFOTYPE* ITSrc, int size);
// WARNING!!! All member classes should be included as pointers or initialization
// will trash the class.
// forward reference
SITEMAP_ENTRY;
class CSiteMap : public CTable
{
private:
void SizeIT(int oldSize);
public:
CSiteMap(int cMaxEntries = 0);
virtual ~CSiteMap();
#ifdef HHA
SITEMAP_ENTRY* AddEntry( SITEMAP_ENTRY* pSiteMapEntry = NULL )
{
int iData = AddData(sizeof(SITEMAP_ENTRY), pSiteMapEntry);
if (iData)
{
return GetSiteMapEntry(iData);
}
else
return NULL;
}
#else
SITEMAP_ENTRY* AddEntry( SITEMAP_ENTRY* pSiteMapEntry = NULL )
{
int iData = AddData(sizeof(SITEMAP_ENTRY), pSiteMapEntry);
if (iData)
{
SITEMAP_ENTRY* pReturn = GetSiteMapEntry(iData);
pReturn->pSiteMap = this;
return pReturn;
}
else
return NULL;
}
#endif
void AddFavoriteNodes(PCSTR pszRoot, PCSTR pszNewFolder, int level);
void AddInfoTypeToUrl(SITEMAP_ENTRY* pSiteMapEntry, INFOTYPE iType);
int AddTypeName(PCSTR pszName);
int Count(void) const { return endpos - 1; };
void CreateFavorites(int level = 1);
int GetImageNumber(SITEMAP_ENTRY* pSiteMapEntry) const;
SITEMAP_ENTRY* GetSiteMapEntry(int pos) const { return (SITEMAP_ENTRY*) GetPointer(pos); }
#ifdef HHCTRL
#ifdef HHA
BOOL ReadFromFile(PCSTR pszFileName, BOOL fIndex, CHtmlHelpControl* phhctrl );
#else
BOOL ReadFromFile(PCSTR pszFileName, BOOL fIndex, CHtmlHelpControl* phhctrl, UINT CodePage );
#endif
#else
BOOL ReadFromFile(PCSTR pszFileName, BOOL fIndex, PCSTR pszBaseFile = NULL);
#endif
BOOL AreAnyInfoTypesDefined(SITEMAP_ENTRY* pSiteMapEntry);
SITE_ENTRY_URL* AreTheseInfoTypesDefined(SITEMAP_ENTRY* pSiteMapEntry, INFOTYPE types, int offset) const;
SITE_ENTRY_URL* NextUrlEntry(SITE_ENTRY_URL* pUrl) const { return (SITE_ENTRY_URL*) ((PBYTE) pUrl + sizeof(SITE_ENTRY_URL) ); }
SITE_ENTRY_URL* GetUrlEntry(SITEMAP_ENTRY* pSiteMapEntry, int pos /* zero-based */) { return (SITE_ENTRY_URL*) ((PBYTE) pSiteMapEntry->pUrls + (GetUrlEntrySize() * pos)); }
SITE_ENTRY_URL* GetUrlEntry(SITE_ENTRY_URL* pUrl, int pos /* zero-based */) { return (SITE_ENTRY_URL*) ((PBYTE) pUrl + (GetUrlEntrySize() * pos)); }
PCSTR GetUrlTitle(SITEMAP_ENTRY* pSiteMapEntry, int pos /* zero-based */) { return pSiteMapEntry->GetTitle((SITE_ENTRY_URL*) (SITE_ENTRY_URL*) ((PBYTE) pSiteMapEntry->pUrls + (GetUrlEntrySize() * pos))); }
int GetUrlEntrySize(void) const { return sizeof(SITE_ENTRY_URL); }
BOOL ParseSiteMapParam(CParseSitemap* pcparse, PCSTR pszParamType, CTable *ptblSubSets);
void ReSizeIT(int Size=0);
void ReSizeURLIT(int Size=0);
BOOL IsEntryInCurTypeList(SITEMAP_ENTRY* pSiteMapEntry) const;
int GetInfoType(PCSTR pszTypeName);
PCSTR GetInfoTypeName(int pos) const { return m_itTables.m_ptblInfoTypes->GetPointer(pos); }
int GetITIndex(PCSTR pszString) const { return m_itTables.m_ptblInfoTypes->IsStringInTable( pszString ); }
PCSTR GetInfoTypeDescription(int pos) const { return m_itTables.m_ptblInfoTypeDescriptions->GetPointer(pos); }
int GetInfoTypeSize(void) const { return InfoTypeSize(); }
int HowManyInfoTypes(void) const { return m_itTables.m_ptblInfoTypes ? m_itTables.m_ptblInfoTypes->CountStrings() : 0; }
BOOL IsInACategory( int type ) const;
int InfoTypeSize(void) const { return m_itTables.m_cITSize * sizeof(INFOTYPE); }
BOOL IsDeleted( const int pos ) const { return ( *(GetInfoTypeName(pos))==' ' )?TRUE:FALSE; }
int GetFirstExclusive(int=-1, INFOTYPE=1) const;
int GetNextExclusive(void) const;
int GetLastExclusive(void) const;
void AddExclusiveIT(int const type) { AddIT( type, m_itTables.m_pExclusive ); }
void DeleteExclusiveIT(int const type ) { DeleteIT( type, m_itTables.m_pExclusive); }
BOOL IsExclusive(int const type) const { return m_itTables.m_pExclusive?*(m_itTables.m_pExclusive+(type/32)) & (1<<(type%32)):0; }
int GetFirstHidden(int=-1, INFOTYPE=1) const;
int GetNextHidden(void) const;
int GetLastHidden(void) const;
void AddHiddenIT(int const type ) { AddIT(type, m_itTables.m_pHidden); }
void DeleteHiddenIT(int const type) { DeleteIT( type, m_itTables.m_pHidden ); }
BOOL IsHidden(int const type) const { return m_itTables.m_pHidden?*(m_itTables.m_pHidden+(type/32)) & (1<<(type%32)):0; }
int GetFirstCategoryType(int pos) const ;
int GetNextITinCategory( void ) const ;
int GetLastCategoryType(int pos) const ;
void AddITtoCategory(int pos, int type);
void AddToCategory( int iLastType );
void DeleteITfromCat(int pos, int type);
BOOL IsITinCategory( int pos, int type) const { return m_itTables.m_aCategories[pos].pInfoType?*(m_itTables.m_aCategories[pos].pInfoType+(type/32)) & (1<<(type%32)):0; }
BOOL IsCatDeleted( const int pos ) const { return ( *(GetCategoryString(pos))==' ' )?TRUE:FALSE; }
void CopyCat(INFOTYPE_TABLES*, const INFOTYPE_TABLES*);
PCSTR GetCategoryString(int pos) const { return m_itTables.m_ptblCategories->GetPointer(pos); }
int GetCatPosition(PCSTR psz) const { return m_itTables.m_ptblCategories->IsStringInTable(psz); }
int HowManyCategories(void) const { return m_itTables.m_ptblCategories ? m_itTables.m_ptblCategories->CountStrings() : 0; }
PCSTR GetCategoryDescription(int pos) const { return m_itTables.m_ptblCatDescription?m_itTables.m_ptblCatDescription->GetPointer(pos):0; }
int GetLevel(int pos) const { return GetSiteMapEntry(pos)->GetLevel(); }
void SetLevel(int val, int pos) { GetSiteMapEntry(pos)->SetLevel(val); }
PCSTR GetPathName(void) { return m_pszSitemapFile; }
PCSTR GetSiteMapFile(void) { return m_pszSitemapFile; }
void SetSiteMapFile(PCSTR pszFile)
{
if (!m_pszSitemapFile && pszFile)
m_pszSitemapFile = StrDup(pszFile);
}
PCSTR GetFrameName(void) { return m_pszFrameName ? m_pszFrameName : ""; }
void SetFrameName(PCSTR psz) { m_pszFrameName = IsEmptyString(psz) ? NULL : StrDup(psz); }
BOOL IsFrameDefined(void) { return m_pszFrameName != NULL; }
void SetEntryFrame(SITEMAP_ENTRY* pSiteMapEntry, PCSTR psz) { pSiteMapEntry->SetFrameIndex(AddName(psz)); }
PCSTR GetEntryFrame(SITEMAP_ENTRY* pSiteMapEntry) { return GetName(pSiteMapEntry->GetFrameIndex()); }
PCSTR GetWindowName(void) { return m_pszWindowName ? m_pszWindowName : ""; }
void SetWindowName(PCSTR psz) { m_pszWindowName = IsEmptyString(psz) ? NULL : StrDup(psz); }
BOOL IsWindowDefined(void) { return m_pszWindowName != NULL; }
void SetEntryWindow(SITEMAP_ENTRY* pSiteMapEntry, PCSTR psz) { pSiteMapEntry->SetWindowIndex(AddName(psz)); }
PCSTR GetEntryWindow(SITEMAP_ENTRY* pSiteMapEntry) { return GetName(pSiteMapEntry->GetWindowIndex()); }
URL AddUrl(PCSTR pszUrl);
PCSTR GetUrlString(URL url) const { return (PCSTR) url; }
int AddName(PCSTR psz);
PCSTR GetName(int pos)
{
#ifdef _DEBUG
if (m_ptblStrings)
ASSERT(pos <= m_ptblStrings->CountStrings());
#endif
return (m_ptblStrings && pos > 0) ? m_ptblStrings->GetHashStringPointer(pos) : "";
}
BOOL IsIndex(void) { return m_fIndex; }
#ifndef HHA
UINT GetCodePage() { if( m_CodePage != (UINT)-1 ) return m_CodePage; else return CP_ACP; }
#endif
//////// member variables //////////
/*
!!! WARNING: if you add or remove members, you must change the version
!!! number in hhamsgs.h or face a GPF when the author does a View Entry.
*/
BOOL m_fTypeCopy; // TRUE if following tables are pointers that must not be freed
INFOTYPE_TABLES m_itTables;
// CSubSets *m_pSubSets;
PCSTR m_pszSitemapFile;
INFOTYPE* m_pInfoTypes; // user-specified Information Types
INFOTYPE* m_pTypicalInfoTypes; // "typical" information types
BOOL m_fIndex; // TRUE if using this as an index
PSTR m_pszBase; // used when reading sitemap file
PCSTR m_pszImageList;
int m_cImageWidth; // width of each icon in image
int m_cImages;
COLORREF m_clrMask;
COLORREF m_clrBackground;
COLORREF m_clrForeground;
PCSTR m_pszFont; // name, pointsize, ext. usefull to CTocClass.
BOOL m_fFolderImages; // use folders instead of books as the image
BOOL m_fPromotForInfoTypes;
DWORD m_tvStyles; // regular window styles
DWORD m_exStyles; // extended window styles
PCSTR m_pszBackBitmap; // used for TOC and Index
int m_cITSize; // The number of DWORDS currently allocated for IT bits for the URL
// int m_cUrlEntry; // sizeof(SITE_ENTRY_URL) + sizeof(URL) for each additional 32 Information Types
// int m_cInfoTypeOffsets; // number of additional offsets to check
BOOL m_fAutoGenerated; // means the file is not writeable
#ifndef HHCTRL
SITEMAP_ENTRY* Add(const SITEMAP_ENTRY* pSiteMapEntry = NULL);
SITEMAP_ENTRY* Insert(int pos, const SITEMAP_ENTRY* pSiteMapEntry = NULL);
void Remove(int pos, BOOL fCompact = TRUE);
void FillUrlComboBox(SITEMAP_ENTRY* pSiteMapEntry, HWND hwndCombo);
void MoveEntry(int posSrc, int posDst);
BOOL SaveSiteMap(PCSTR pszPathName, BOOL fIndex);
void OutputDefaultSiteMapEntry(COutput* pout, SITEMAP_ENTRY* pSiteMapEntry, int curLevel, BOOL fIndex);
void CopyProperties(CSiteMap* pSiteMap, BOOL fIncludeTables = FALSE);
#endif
CTable* m_ptblStrings;
PCSTR m_pszFrameName; // default frame to use
PCSTR m_pszWindowName; // default window to use
PCSTR m_pszHHIFile;
BOOL m_fSaveIT; // Save the declared IT in an instance of CSitemap, if there is an hhi hhc IT declarations are not saved.
#ifndef HHA
private:
UINT m_CodePage;
#endif
};
// note the inlined SITEMAP_ENTRY functions below must be declared after
// the declaration of CSiteMap otherwise the compiler will choke on them
// since they access CSiteMap members/methods
#ifdef HHCTRL
#ifndef HHA
inline HRESULT SITEMAP_ENTRY::GetKeyword( WCHAR* pwszKeyword, int cch )
{
ASSERT( pSiteMap );
//ASSERT( pSiteMap->GetCodePage() );
UINT CodePage = pSiteMap->GetCodePage();
if( MultiByteToWideChar( CodePage, 0, pszText, -1, pwszKeyword, cch ) == 0 )
return E_FAIL;
return S_OK;
}
#endif
#endif
#ifdef HHCTRL
#ifndef HHA
inline HRESULT SITEMAP_ENTRY::GetTitle( SITE_ENTRY_URL* pUrl, WCHAR* pwszTitle, int cch )
{
ASSERT( pSiteMap );
//ASSERT( pSiteMap->GetCodePage() );
if( !pUrl->pszTitle ) {
wcsncpy( pwszTitle, GetStringResourceW(IDS_UNTITLED), cch);
pwszTitle[cch] = 0;
return S_OK;
}
UINT CodePage = pSiteMap->GetCodePage();
if( MultiByteToWideChar( CodePage, 0, pszText, -1, pwszTitle, cch) == 0 )
return E_FAIL;
return S_OK;
}
#endif
#endif
extern const char txtBeginList[]; // "<UL>"
extern const char txtEndList[] ; // "</UL>"
extern const char txtBeginListItem[]; // "<LI"
extern const char txtSitemap[]; // "<!Sitemap";
extern const char txtSitemap1[]; // "<!--Sitemap";
extern const char txtSitemap2[]; // "<!Sitemap";
extern const char txtParam[]; // "<param name";
extern const char txtValue[]; // "value";
extern const char txtBeginHref[]; // "<A HREF";
extern const char txtEndHref[]; // "</A>";
extern const char txtBeginObject[]; // "<OBJECT"
extern const char txtEndObject[]; // "</OBJECT>"
extern const char txtSiteMapObject[]; // "text/sitemap";
extern const char txtSitemapProperties[]; // "text/site properties";
extern const char txtBackGround[]; // "Background";
extern const char txtForeGround[]; // "Foreground";
extern const char txtFont[]; // "Font";
extern const char txtImageList[]; // "ImageList";
extern const char txtImageWidth[]; // "Image Width";
extern const char txtColorMask[]; // "Color Mask";
extern const char txtNumberImages[]; // "NumberImages";
extern const char txtExWindowStyles[]; // "ExWindow Styles";
extern const char txtWindowStyles[]; // "Window Styles";
extern const char txtType[]; // "type";
extern const char txtNo[]; // "No";
extern const char txtFolderType[]; // "Folder";
extern const char txtEndTag[]; // "</";
extern const char txtInfoTypeDeclaration[]; // "InformationTypeDecl";
// Param labels
extern const char txtParamType[]; // "Type";
extern const char txtParamTypeExclusive[];// "TypeExclusive";
extern const char txtParamTypeHidden[]; // "TypeHidden";
extern const char txtParamTypeDesc[]; // "TypeDesc";
extern const char txtParamCategory[]; // "Category";
extern const char txtParamCategoryDesc[]; // "CategoryDesc";
extern const char txtParamName[]; // "Name";
extern const char txtParamUrl[]; // "URL";
extern const char txtParamIcon[]; // "Icon";
extern const char txtParamLocal[]; // "Local";
extern const char txtParamFrame[]; // "Frame";
extern const char txtParamWindow[]; // "Window";
extern const char txtParamNew[]; // "New";
extern const char txtParamComment[]; // "Comment";
extern const char txtParamImageNumber[]; // "ImageNumber";
extern const char txtParamDisplay[]; // "Display";
extern const char txtParamKeyword[]; // "Keyword";
extern const char txtParamInstruction[]; // "Instruction";
extern const char txtParamSectionTitle[]; // "Section Title";
extern const char txtSeeAlso[]; // "See Also";
extern const char txtImageType[]; // "ImageType";
extern const char txtFavorites[]; // "Favorites";
extern const char txtAutoGenerated[]; // "Auto Generated";
extern const char txtSSInclusive[]; // "Inclusive";
extern const char txtSSExclusive[]; // "Exclusive";
//////////////////////////////////// Functions ///////////////////////////////
int CompareSz(PCSTR psz, PCSTR pszSub);
HASH HashFromSz(PCSTR pszKey);
BOOL ReplaceEscapes(PCSTR pszSrc, PSTR pszDst, int); // pszSrc can be same as pszDst
#endif // __SITEMAP_H__