Microsoft/WindowsXP-SP1
Microsoft/WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
WindowsXP-SP1/enduser/stuff/hhctrl/sitemap.cpp
Microsoft f7ca35dddd First commit
2020-09-30 16:53:49 +02:00

2718 lines
95 KiB
C++
Raw Permalink Blame History

// Copyright (C) 1996-1997 Microsoft Corporation. All rights reserved.
#include "header.h"
#include "sitemap.h"
#include <shlobj.h>
#include <wininet.h>
#ifndef HHCTRL
#include "hha_strtable.h"
#else
#include "hha_strtable.h"
#include "hhctrl.h"
#include "strtable.h"
#endif
#include "web.h"
#ifdef _DEBUG
#undef THIS_FILE
static const char THIS_FILE[] = __FILE__;
#endif
#ifndef _DEBUG
#pragma optimize("at", on)
#endif
#include "sitechar.cpp"
#ifndef HHCTRL
static const char txtSaveTypeHidden[] = "SaveHidden";
static const char txtSaveTypeExclusive[] = "SaveExclusive";
static const char txtSaveType[] = "SaveType";
static const char txtSaveTypeDesc[] = "SaveTypeDesc";
#endif
class CParseSitemap : public SITEMAP_ENTRY
{
public:
CParseSitemap(CSiteMap* pSiteMap) {
m_pSiteMap = pSiteMap;
Clear();
m_fGlobal = FALSE;
m_cMaxTitles = 50;
m_ppszTitles = (PCSTR*) lcCalloc(m_cMaxTitles * sizeof(PCSTR));
m_pSiteUrl = new CSiteEntryUrl(pSiteMap->InfoTypeSize());
}
~CParseSitemap() { lcFree(m_ppszTitles); delete m_pSiteUrl; }
BOOL IsGlobal(void) { return m_fGlobal; }
void SetGlobal(BOOL fSetting) { m_fGlobal = fSetting; }
void AddTitle(PCSTR psz);
PCSTR* m_ppszTitles;
int m_cMaxTitles;
CStr m_cszValue;
BOOL m_fGlobal;
CSiteMap* m_pSiteMap;
CSiteEntryUrl* m_pSiteUrl;
void SaveUrlEntry() { m_pSiteUrl->SaveUrlEntry(m_pSiteMap, this); }
operator CStr*() { return &m_cszValue; }
operator PSTR() { return m_cszValue.psz; }
operator PCSTR() const { return m_cszValue.psz; }
};
#ifndef _DEBUG
// REVIEW: check this from time to time to see if it is necessary...
#pragma optimize("a", on)
#endif
// Function prototypes
PSTR FindDblQuote(CAInput* painput, CStr* pcsz, PSTR psz);
PSTR GetValue(CAInput* pinput, CStr* pcsz, PSTR psz, CStr* pcszValue);
PSTR FindCharacter(CAInput* pinput, CStr* pcsz, PSTR psz, char ch);
PSTR GetType(CAInput* pinput, CStr* pcsz, PSTR psz, CStr* pcszValue);
#ifdef HHCTRL
#ifdef HHA
BOOL CSiteMap::ReadFromFile(PCSTR pszFileName, BOOL fIndex, CHtmlHelpControl* phhctrl )
#else
BOOL CSiteMap::ReadFromFile(PCSTR pszFileName, BOOL fIndex, CHtmlHelpControl* phhctrl, UINT CodePage )
#endif
#else
BOOL CSiteMap::ReadFromFile(PCSTR pszFileName, BOOL fIndex, PCSTR pszBaseFile)
#endif
{
#ifdef HHCTRL
#ifndef HHA
m_CodePage = CodePage;
#endif
#endif
CAInput ainput;
int curInput = 0;
if (!ainput.Add(pszFileName)) {
#ifdef HHCTRL
if (phhctrl)
phhctrl->AuthorMsg(IDS_CANT_OPEN, pszFileName);
SITEMAP_ENTRY* pSiteMapEntry = AddEntry();
ASSERT_COMMENT(!pSiteMapEntry->iFrameName &&
!pSiteMapEntry->iWindowName,
"Add() function not returning zero'd memory");
pSiteMapEntry->level = 1;
CStr cszLine(IDS_CANT_FIND_FILE, pszFileName);
pSiteMapEntry->pszText = StrDup(cszLine);
pSiteMapEntry->SetTopic(TRUE);
#else
MsgBox(IDS_CANT_OPEN, pszFileName);
#endif
return FALSE;
}
SetSiteMapFile(pszFileName);
m_fIndex = fIndex;
// We don't want the first file to have a basename
#if (defined(HHCTRL) || defined(HHA))
m_pszBase = ainput.GetBaseName();
*m_pszBase = '\0';
#endif
// used for indexes
CParseSitemap cparse(this);
CTable *ptblSubSets=NULL; // To hold any subset declarations.
int curLevel = 0;
CStr cszLine;
BOOL fSiteMap = FALSE;
BOOL fMergePending = FALSE; // TRUE if we need to include another file
CStr cszMergeFile; // file to merge into current
#ifdef _DEBUG
int cLoops = 0; // so we know when to set a breakpoint
#endif
for (;;) {
#ifdef _DEBUG
cLoops++;
// lcHeapCheck();
#endif
if (fMergePending) {
#if (defined(HHCTRL) || defined(HHA))
char szUrl[INTERNET_MAX_URL_LENGTH];
#endif
#ifdef HHA
// When compiling, find the full path to the file
strcpy(szUrl, cszMergeFile);
ConvertToFull(pszBaseFile, szUrl);
ainput.Add(szUrl);
{
#else
if (!ainput.Add(cszMergeFile)) {
#endif
#ifdef HHCTRL
if (ConvertToCacheFile(cszMergeFile, szUrl))
ainput.Add(szUrl);
else if (phhctrl && phhctrl->m_pWebBrowserApp) {
CStr cszUrl;
phhctrl->m_pWebBrowserApp->GetLocationURL(&cszUrl);
PSTR psz = (PSTR) FindFilePortion(cszUrl);
if (psz) {
*psz = '\0';
cszUrl += cszMergeFile;
if (ConvertToCacheFile(cszUrl, szUrl))
ainput.Add(szUrl);
}
}
#endif
}
fMergePending = FALSE;
#if (defined(HHCTRL) || defined(HHA))
m_pszBase = ainput.GetBaseName();
/*
* If we are in the same location as our parent, ignore the
* base name
*/
if (!IsEmptyString(m_pszBase)) {
CStr cszBase(m_pszBase);
CStr cszSitemap(GetSiteMapFile());
PSTR psz = (PSTR) FindFilePortion(cszSitemap);
ASSERT(psz);
if (psz)
*psz = '\0';
ConvertBackSlashToForwardSlash(cszBase);
ConvertBackSlashToForwardSlash(cszSitemap);
if (lstrcmpi(cszBase, cszSitemap) == 0)
m_pszBase = NULL;
}
#endif
}
if (curInput < 0)
break;
if (!ainput.getline(&cszLine)) {
if (!ainput.Remove()) {
if (m_fIndex)
return TRUE;
break; // we're all done.
}
/*
* Set parse to global so that if this was part of a merged
* file we won't rewrite the last item when an </OBJECT> is
* encountered.
*/
// 16-Dec-1997 [ralphw] Don't call SetGlobal -- it deletes the
// next folder
// cparse.SetGlobal(TRUE);
cparse.Clear();
#if (defined(HHCTRL) || defined(HHA))
m_pszBase = ainput.GetBaseName();
#endif
continue;
}
PSTR psz = FirstNonSpace(cszLine);
Loop:
if ( !psz || !*psz)
continue; // ignore blank lines
if (*psz == '<') {
int cb;
if ((cb = CompareSz(psz, txtParam))) {
psz = FindDblQuote(&ainput, &cszLine, psz + cb);
if (!psz)
goto FlushAndExit;
PSTR pszParamType = psz;
psz = GetValue(&ainput, &cszLine, psz, cparse);
if (!psz)
goto FlushAndExit;
if (ParseSiteMapParam(&cparse, pszParamType, ptblSubSets)) {
goto Loop;
}
else if (isSameString(pszParamType, txtParamHHI)) {
m_pszHHIFile = StrDup(cparse.m_cszValue.psz);
goto Loop;
}
else if (isSameString(pszParamType, txtParamMerge)) {
#if (!defined(HHCTRL) && !defined(HHA))
cszMergeFile = GetStringResource(IDS_INCLUDED_FILE);
cszMergeFile += cparse.m_cszValue.psz;
cparse.pszText = StrDup(cszMergeFile);
cparse.fInclude = TRUE;
cparse.iImage = IMAGE_CLOSED_FOLDER;
AddEntry(&cparse);
cparse.SetGlobal(TRUE); // so end object doesn't rewrite
#elif defined(HHA)
if (stristr(cparse.m_cszValue.psz, ".CHM")) {
cparse.pszText = StrDup(cparse.m_cszValue.psz);
cparse.fInclude = TRUE;
cparse.iImage = IMAGE_CLOSED_FOLDER;
AddEntry(&cparse);
}
else {
cszMergeFile = cparse.m_cszValue.psz;
fMergePending = TRUE;
}
#else
cszMergeFile = cparse.m_cszValue.psz;
fMergePending = TRUE;
#endif
goto Loop;
}
else if (!m_fIndex && isSameString(pszParamType, txtFavorites)) {
#if (defined(HHCTRL) || defined(HHA))
CreateFavorites();
goto Loop;
#endif
// REVIEW: how do we deal with this in HHW?
}
}
else if ((cb = CompareSz(psz, txtBeginList))) {
curLevel++;
psz = FirstNonSpace(psz + cb);
goto Loop;
}
else if ((cb = CompareSz(psz, txtEndList))) {
curLevel--;
psz = FirstNonSpace(psz + cb);
goto Loop;
}
else if ((cb = CompareSz(psz, txtBeginListItem))) {
psz = FindCharacter(&ainput, &cszLine, psz + cb, '>');
if (!psz)
goto FlushAndExit;
if ((cb = CompareSz(psz, txtBeginObject))) {
psz = GetType(&ainput, &cszLine, psz + cb, cparse);
if (!psz) {
if (!ainput.getline(&cszLine))
goto FlushAndExit;
psz = GetType(&ainput, &cszLine, cszLine, cparse);
if (!psz)
goto FlushAndExit;
}
//////////////////// New Node /////////////////////////////////////////////
if (isSameString(cparse, txtSiteMapObject)) {
// Create a new entry
cparse.Clear();
cparse.level = (BYTE)curLevel;
goto Loop;
}
else if (isSameString(cparse, txtSitemapProperties)) {
cparse.SetGlobal(TRUE);
}
}
}
else if ((cb = CompareSz(psz, txtEndObject))) {
//////////////////// End Node /////////////////////////////////////////////
if (!cparse.IsGlobal()) {
if (m_fIndex) {
if (!cparse.m_pSiteUrl->m_fUrlSpecified) {
// BUGBUG: nag the author -- entry without a URL
psz += cb;
goto Loop;
}
cparse.SaveUrlEntry();
if (cparse.pszText && cparse.cUrls) {
AddEntry(&cparse);
}
else {
#if (defined(HHCTRL) || defined(HHA))
cparse.pszText = StrDup(GetStringResource(IDSHHA_INVALID_KEYWORD));
AddEntry(&cparse);
#endif
// we ignore the entry entirely in hhctrl.ocx
}
cparse.Clear();
cparse.level = (BYTE)curLevel;
}
else {
if (cparse.m_pSiteUrl->m_fUrlSpecified)
cparse.SaveUrlEntry();
AddEntry(&cparse);
}
}
else {
cparse.SetGlobal(FALSE);
//#ifdef HHCTRL // having this conditional for HHCTRL causes IT declarations to not be present in HHW until the info type tab is visited
// bug 4762
if (IsNonEmpty(m_pszHHIFile)) {
cszMergeFile = cparse.m_cszValue.psz;
fMergePending = TRUE;
m_pszHHIFile = NULL; // so we don't merge twice
}
//#endif
}
psz += cb;
goto Loop;
}
else if (isSameString(psz, txtSitemap) ||
isSameString(psz, txtSitemap1) ||
isSameString(psz, txtSitemap2)) {
fSiteMap = TRUE;
psz = FindCharacter(&ainput, &cszLine, psz, '>');
if (!psz)
goto FlushAndExit;
else if (!*psz)
continue;
}
// Global properties?
else if ((cb = CompareSz(psz, txtBeginObject))) {
psz = GetType(&ainput, &cszLine, psz + cb, cparse);
if (!psz) {
if (!ainput.getline(&cszLine))
goto FlushAndExit;
psz = GetType(&ainput, &cszLine, psz + cb, cparse);
if (!psz)
goto FlushAndExit;
}
if (isSameString(cparse, txtSitemapProperties)) {
cparse.SetGlobal(TRUE);
goto Loop;
}
else {
// ******** Check for Merge (include another file) *******
/*
* This is an object that appears outside of a list
* item. If it's a merge tag, then extract the merge
* information. Otherwise, ignore it.
*/
psz = strstr(psz, txtEndTag);
if (psz)
psz = FirstNonSpace(psz + 1);
for (;;) {
if (!psz) {
if (!ainput.getline(&cszLine))
goto FlushAndExit;
psz = FirstNonSpace(cszLine.psz);
}
if ( !psz || !*psz) {
psz = NULL; // so we'll read the next line
continue; // ignore blank lines
}
if (*psz == '<') {
if ((cb = CompareSz(psz, txtEndObject))) {
psz += cb;
goto Loop;
}
else if ((cb = CompareSz(psz, txtParam))) {
psz = FindDblQuote(&ainput, &cszLine,
psz + cb);
if (!psz)
goto FlushAndExit;
PSTR pszParamType = psz;
psz = GetValue(&ainput, &cszLine,
psz, cparse);
if (!psz)
goto FlushAndExit;
if (isSameString(pszParamType, txtParamMerge)) {
#if (!defined(HHCTRL) && !defined(HHA))
cszMergeFile = GetStringResource(IDS_INCLUDED_FILE);
cszMergeFile += cparse.m_cszValue.psz;
cparse.pszText = StrDup(cszMergeFile);
cparse.fInclude = TRUE;
cparse.iImage = IMAGE_CLOSED_FOLDER;
cparse.level = curLevel;
AddEntry(&cparse);
#elif defined(HHA)
if (stristr(cparse.m_cszValue.psz, ".CHM")) {
cparse.pszText = StrDup(cparse.m_cszValue.psz);
cparse.fInclude = TRUE;
cparse.iImage = IMAGE_CLOSED_FOLDER;
cparse.level = curLevel;
AddEntry(&cparse);
}
else {
cszMergeFile = cparse.m_cszValue.psz;
fMergePending = TRUE;
}
#else
cszMergeFile = cparse.m_cszValue.psz;
fMergePending = TRUE;
#endif
}
}
}
}
}
}
else if (isSameString(psz, txtBeginHref)) {
// Skip over all of HREF
for (;;) {
psz = strstr(psz, txtEndTag);
if (psz) {
if (strncmp(psz, txtEndHref, (int)strlen(txtEndHref)) == 0)
break;
psz = stristr(psz, txtEndHref);
}
if (!psz) {
if (!ainput.getline(&cszLine))
goto FlushAndExit;
psz = cszLine.psz;
}
else
break;
}
psz = FindCharacter(&ainput, &cszLine, psz, '>');
goto Loop;
}
else {
// Ignore whatever it is
psz = FindCharacter(&ainput, &cszLine, psz, '>');
goto Loop;
}
}
if (fSiteMap) {
// In sitemaps, we only care about what appears inside angle
// brackets.
for(;;) {
psz = StrChr(psz, '<');
if (!psz) {
if (!ainput.getline(&cszLine)) {
psz = ""; // so Loop processing works
break;
}
psz = cszLine.psz;
}
else
break;
}
goto Loop;
}
}
# ifdef NOTYET
// populate subsets
if ( ptblSubSets )
{
if ( !m_pSubSets )
m_pSubSets = new CSubSets(m_itTables.m_itSize, ptblSubSets, this, TRUE);
delete ptblSubSets;
}
#endif
if (!fIndex) {
// Now determine what is a book -- anything without a child is a topic
curLevel = 0;
int pos;
for (pos = 1; pos < endpos - 1; pos++) {
SITEMAP_ENTRY* pSiteMapEntry = GetSiteMapEntry(pos);
if (pSiteMapEntry->level > curLevel + 1)
pSiteMapEntry->level = curLevel + 1;
curLevel = pSiteMapEntry->level;
if (pSiteMapEntry->cUrls == 0)
continue; // if there is no URL, then it's a book
#ifdef _DEBUG
SITEMAP_ENTRY* pSiteMapEntryNext = GetSiteMapEntry(pos + 1);
#endif
if (pSiteMapEntry->level >= GetSiteMapEntry(pos + 1)->level)
pSiteMapEntry->SetTopic(TRUE);
}
// You can never end with a book
if (endpos > 1)
GetSiteMapEntry(endpos - 1)->SetTopic(TRUE);
}
return TRUE;
FlushAndExit:
return FALSE;
}
BOOL CSiteMap::ParseSiteMapParam(CParseSitemap* pcparse, PCSTR pszParamType, CTable *ptblSubSets)
{
int iLastType = 0;
// Deal with any escape sequences starting with '&'
ReplaceEscapes(*pcparse, (PSTR) *pcparse, ESCAPE_ENTITY);
if (pcparse->IsGlobal()) {
int cb;
// WARNING! Check for txtParamTypeDesc BEFORE the check for txtParamType
// (because it's a substring search).
#ifdef NOTYET
// parse Subset Declarations
if ( isSameString( pszParamType, txtParamSSInclusive ) ||
isSameString( pszParamType, txtParamSSExclusive))
{
if( !ptblSubSets )
ptblSubsets = new CTable(16 * 1024);
ptblSubSets->AddString(*pcparse);
}else
#endif
// parse Information Types Declarations
if (isSameString(pszParamType, txtParamTypeExclusive)
#ifndef HHCTRL
|| isSameString(pszParamType, txtSaveTypeExclusive)
#endif
) {
if (m_itTables.m_ptblInfoTypes && m_itTables.m_ptblInfoTypes->IsStringInTable(*pcparse)) {
iLastType = GetITIndex( *pcparse );
AddToCategory( iLastType );
return TRUE;
}else
{
iLastType = AddTypeName(*pcparse);
AddExclusiveIT( iLastType );
AddToCategory( iLastType );
return TRUE;
}
}
else if (isSameString(pszParamType, txtParamTypeHidden)
#ifndef HHCTRL
|| isSameString(pszParamType, txtSaveTypeHidden)
#endif
) {
if (m_itTables.m_ptblInfoTypes && m_itTables.m_ptblInfoTypes->IsStringInTable(*pcparse)) {
iLastType = GetITIndex( *pcparse );
AddToCategory( iLastType );
return TRUE;
}else
{
iLastType = AddTypeName(*pcparse);
AddHiddenIT( iLastType );
AddToCategory( iLastType );
return TRUE;
}
}
else if ((cb = CompareSz(pszParamType, txtParamTypeDesc))
#ifndef HHCTRL
|| isSameString(pszParamType, txtSaveTypeDesc)
#endif
) {
if (!m_itTables.m_ptblInfoTypeDescriptions)
return TRUE; // BUGBUG: nag author about description before type
// add a blank description to infotype description, description not provided for last infotype
while (m_itTables.m_ptblInfoTypes->CountStrings() > m_itTables.m_ptblInfoTypeDescriptions->CountStrings()+1)
m_itTables.m_ptblInfoTypeDescriptions->AddString("");
if ( m_itTables.m_ptblInfoTypes->CountStrings() != m_itTables.m_ptblInfoTypeDescriptions->CountStrings() )
m_itTables.m_ptblInfoTypeDescriptions->AddString(*pcparse);
return TRUE;
} // this matches anything that begins with "type"
else if (isSameString(pszParamType, txtParamType)
#ifndef HHCTRL
|| isSameString(pszParamType, txtSaveType)
#endif
) {
if (m_itTables.m_ptblInfoTypes && m_itTables.m_ptblInfoTypes->IsStringInTable(*pcparse)) {
iLastType = GetITIndex( *pcparse );
AddToCategory( iLastType );
return TRUE;
}
else
{
iLastType = AddTypeName(*pcparse);
AddToCategory( iLastType );
return TRUE;
}
}
// WARNING! Check for txtParamCategoryDesc BEFORE the check for txtParamCategory
// (because it's a substring search).
else if ((cb = CompareSz(pszParamType, txtParamCategoryDesc))) {
if (!m_itTables.m_ptblCatDescription)
return TRUE; // BUGBUG: nag author about description before type
// add a blank description to category description, description not provided for last Category
while (m_itTables.m_ptblCategories->CountStrings() > m_itTables.m_ptblCatDescription->CountStrings()+1)
m_itTables.m_ptblCatDescription->AddString("");
m_itTables.m_ptblCatDescription->AddString(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtParamCategory)) {
if (m_itTables.m_ptblCategories && m_itTables.m_ptblCategories->IsStringInTable(*pcparse)) {
// BUGBUG: we should nag the help author
return TRUE;
}
if (!m_itTables.m_ptblCategories)
{
m_itTables.m_ptblCategories = new CTable(16 * 1024);
m_itTables.m_ptblCatDescription = new CTable(16 * 1024);
}
m_itTables.m_ptblCategories->AddString(*pcparse);
return TRUE;
}
else
if (isSameString(pszParamType, txtParamFrame)) {
if (!IsFrameDefined()) // can't override in a sitemap file
SetFrameName(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtParamWindow)) {
if (!IsWindowDefined())
SetWindowName(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtImageType)) {
if (isSameString(*pcparse, txtFolderType))
m_fFolderImages = TRUE;
}
else if (isSameString(pszParamType, txtImageList)) {
m_pszImageList = StrDup(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtQueryType)) {
m_fPromotForInfoTypes = TRUE;
return TRUE;
}
else if (isSameString(pszParamType, txtBackGround)) {
m_clrBackground = Atoi(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtBackGroundImage)) {
m_pszBackBitmap = StrDup(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtForeGround)) {
m_clrForeground = Atoi(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtFont)) {
m_pszFont = StrDup(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtNumberImages)) {
m_cImages = Atoi(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtColorMask)) {
m_clrMask = Atoi(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtImageWidth)) {
m_cImageWidth = Atoi(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtWindowStyles) &&
m_tvStyles == (DWORD) -1) {
m_tvStyles = Atoi(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtExWindowStyles)) {
m_exStyles = Atoi(*pcparse);
return TRUE;
}
#if (!defined(HHCTRL) && !defined(HHA))
else if (isSameString(pszParamType, txtAutoGenerated)) {
m_fAutoGenerated = YesNo(*pcparse);
return TRUE;
}
#endif
return FALSE;
}
if (m_fIndex) {
if (isSameString(pszParamType, txtParamSectionTitle) ||
isSameString(pszParamType, txtParamName)) {
if (!pcparse->pszText)
pcparse->pszText = StrDup(*pcparse);
else {
if (pcparse->m_pSiteUrl->m_pUrl->pszTitle) {
if (pcparse->m_pSiteUrl->m_fUrlSpecified)
pcparse->SaveUrlEntry();
else
FreeMemory(pcparse->pszText, -1);
}
pcparse->AddTitle(*pcparse);
}
return TRUE;
}
else if (isSameString(pszParamType, txtParamKeyword)) {
// BUGBUG: check for duplicates first!
pcparse->pszText = StrDup(*pcparse);
return TRUE;
}
}
else { // not an Index
if (isSameString(pszParamType, txtParamName)) {
if (pcparse->m_pSiteUrl->m_fUrlSpecified)
pcparse->SaveUrlEntry();
// BUGBUG: deal with duplicate names being specified
pcparse->pszText = StrDup(*pcparse);
return TRUE;
}
}
if (isSameString(pszParamType, txtParamLocal)) {
if (pcparse->m_pSiteUrl->m_fUrlSpecified) {
// save previous URL entry
pcparse->SaveUrlEntry();
}
URL url = AddUrl(*pcparse);
if (pcparse->m_pSiteUrl->m_pUrl->urlSecondary == url)
return TRUE; // ignore duplicate URLs for primary and secondary
pcparse->m_pSiteUrl->m_pUrl->urlPrimary = url;
pcparse->m_pSiteUrl->m_fUrlSpecified = TRUE;
return TRUE;
}
else if (isSameString(pszParamType, txtParamUrl) || isSameString(pszParamType, txtParamSecondary)) {
if (pcparse->m_pSiteUrl->m_fUrlSpecified && pcparse->m_pSiteUrl->m_pUrl->urlSecondary) {
// save previous URL entry
pcparse->SaveUrlEntry();
}
URL url = AddUrl(*pcparse);
if (pcparse->m_pSiteUrl->m_pUrl->urlPrimary == url)
return TRUE; // ignore duplicate URLs for primary and secondary
pcparse->m_pSiteUrl->m_pUrl->urlSecondary = url;
pcparse->m_pSiteUrl->m_fUrlSpecified = TRUE;
return TRUE;
}
else if (isSameString(pszParamType, txtParamType) ||
isSameString(pszParamType, txtParamTypeExclusive) ||
isSameString(pszParamType, txtParamTypeHidden)) {
if (pcparse->m_pSiteUrl->m_fUrlSpecified)
// save previous URL entry
pcparse->SaveUrlEntry();
if (m_itTables.m_ptblInfoTypes)
{
INFOTYPE iType = GetInfoType(*pcparse);
if (iType == (INFOTYPE) -1)
iType = 0;
else
AddIT(iType, pcparse->m_pSiteUrl->m_pUrl->ainfoTypes );
}
return TRUE;
}
else if (isSameString(pszParamType, txtParamNew)) {
pcparse->fNew = TRUE;
return TRUE;
}
else if (isSameString(pszParamType, txtParamImageNumber)) {
pcparse->iImage = (BYTE) Atoi(*pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtParamDisplay)) {
if (isSameString(*pcparse, txtNo))
pcparse->fNoDisplay = TRUE;
return TRUE;
}
else if (isSameString(pszParamType, txtParamFrame)) {
SetEntryFrame(pcparse, *pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtParamWindow)) {
SetEntryWindow(pcparse, *pcparse);
return TRUE;
}
else if (isSameString(pszParamType, txtSeeAlso)) {
pcparse->m_pSiteUrl->m_pUrl->urlPrimary = AddUrl(*pcparse);
pcparse->fSeeAlso = TRUE;
pcparse->m_pSiteUrl->m_fUrlSpecified = TRUE;
return TRUE;
}
else if (isSameString(pszParamType, txtSendEvent)) {
pcparse->m_pSiteUrl->m_pUrl->urlPrimary = AddUrl(*pcparse);
pcparse->SaveUrlEntry();
pcparse->fSendEvent = TRUE;
return TRUE;
}
else if (isSameString(pszParamType, txtSendMessage)) {
pcparse->m_pSiteUrl->m_pUrl->urlPrimary = AddUrl(*pcparse);
pcparse->SaveUrlEntry();
pcparse->fSendMessage = TRUE;
return TRUE;
}
#if (!defined(HHCTRL) && !defined(HHA))
else if (isSameString(pszParamType, txtParamComment)) {
pcparse->pszComment = StrDup(*pcparse);
return TRUE;
}
#endif
return FALSE;
}
URL CSiteMap::AddUrl(PCSTR pszUrl)
{
if (IsEmptyString(pszUrl))
return NULL;
#if (defined(HHCTRL) || defined(HHA))
if (!IsEmptyString(m_pszBase) && !StrChr(pszUrl, ':')) {
char szPath[INTERNET_MAX_URL_LENGTH];
strcpy(szPath, m_pszBase);
strcat(szPath, pszUrl);
return (URL) StrDup(szPath);
}
#endif
PCSTR psz = FirstNonSpace(pszUrl);
return (URL) StrDup(psz?psz:"");
}
void CSiteMap::AddToCategory( int iLastType )
{
// Add the info type to the last category defined; if there is a Category
if ( m_itTables.m_ptblCategories )
{
int posCat = m_itTables.m_ptblCategories->CountStrings();
if (posCat <= 0 )
return;
AddITtoCategory( posCat-1, iLastType);
}
}
int CompareSz(PCSTR psz, PCSTR pszSub)
{
int cb;
if (IsSamePrefix(psz, pszSub, cb = (int)strlen(pszSub)))
return cb;
else
return 0;
}
void CParseSitemap::AddTitle(PCSTR psz)
{
if (m_pSiteUrl->m_pUrl->pszTitle)
m_pSiteMap->FreeMemory(m_pSiteUrl->m_pUrl->pszTitle, -1);
m_pSiteUrl->m_pUrl->pszTitle = m_pSiteMap->StrDup(psz);
}
void CSiteEntryUrl::SaveUrlEntry(CSiteMap* pSiteMap, SITEMAP_ENTRY* pSiteMapEntry)
{
SITE_ENTRY_URL* pNewUrls = (SITE_ENTRY_URL*) pSiteMap->TableMalloc(
sizeof(SITE_ENTRY_URL) * (pSiteMapEntry->cUrls + 1));
if (pSiteMapEntry->cUrls) {
ASSERT(pSiteMapEntry->pUrls);
memcpy(pNewUrls, pSiteMapEntry->pUrls,
sizeof(SITE_ENTRY_URL) * pSiteMapEntry->cUrls);
pSiteMap->FreeMemory((PCSTR) pSiteMapEntry->pUrls,
sizeof(SITE_ENTRY_URL) * pSiteMapEntry->cUrls);
}
memcpy((PBYTE) pNewUrls + sizeof(SITE_ENTRY_URL) * pSiteMapEntry->cUrls,
m_pUrl, sizeof(SITE_ENTRY_URL));
pSiteMapEntry->cUrls++;
pSiteMapEntry->pUrls = pNewUrls;
if (!pSiteMap->AreAnyInfoTypesDefined(pSiteMapEntry))
pSiteMapEntry->fShowToEveryOne = TRUE;
ZeroMemory(m_pUrl, sizeof(SITE_ENTRY_URL));
m_pUrl->ainfoTypes = (INFOTYPE*)lcCalloc( pSiteMap->InfoTypeSize() );
m_fUrlSpecified = FALSE;
}
/***************************************************************************
FUNCTION: HashFromSz
PURPOSE: Convert a string into a hash representation
PARAMETERS:
pszKey
RETURNS: Hash number
COMMENTS:
Shamelessly stolen from the WinHelp code, since after 6 years
of use by up to 1 million help authors, there were no reports
of collisions.
MODIFICATION DATES:
10-Aug-1996 [ralphw] Stolen from WinHelp, removed special-case
hash characters
***************************************************************************/
// This constant defines the alphabet size for our hash function.
static const HASH MAX_CHARS = 43;
HASH WINAPI HashFromSz(PCSTR pszKey)
{
HASH hash = 0;
int cch = (int)strlen(pszKey);
for (int ich = 0; ich < cch; ++ich) {
// treat '/' and '\' as the same
if (pszKey[ich] == '/')
hash = (hash * MAX_CHARS) + ('\\' - '0');
else if (pszKey[ich] <= 'Z')
hash = (hash * MAX_CHARS) + (pszKey[ich] - '0');
else
hash = (hash * MAX_CHARS) + (pszKey[ich] - '0' - ('a' - 'A'));
}
/*
* Since the value 0 is reserved as a nil value, if any context
* string actually hashes to this value, we just move it.
*/
return (hash == 0 ? 0 + 1 : hash);
}
int CSiteMap::AddName(PCSTR psz)
{
if (IsEmptyString(psz))
return 0;
psz = FirstNonSpace(psz);
HASH hash = HashFromSz(psz);
if (!m_ptblStrings)
m_ptblStrings = new CTable(16 * 1024);
int pos = m_ptblStrings->IsHashInTable(hash);
if (pos > 0)
return pos;
else {
m_ptblStrings->AddString(hash, psz);
return m_ptblStrings->CountStrings();
}
}
PSTR FindCharacter(CAInput* pinput, CStr* pcsz, PSTR psz, char ch)
{
for(;;) {
psz = StrChr(psz, ch);
if (!psz) {
if (!pinput)
return NULL;
if (!pinput->getline(pcsz))
return NULL;
psz = pcsz->psz;
}
else
break;
}
return FirstNonSpace(psz + 1);
}
PSTR FindDblQuote(CAInput* pinput, CStr* pcsz, PSTR psz)
{
for(;;) {
psz = StrChr(psz, '\042');
if (!psz) {
if (!pinput->getline(pcsz))
return NULL;
psz = pcsz->psz;
}
else
break;
}
return FirstNonSpace(psz + 1);
}
/***************************************************************************
FUNCTION: GetValue
PURPOSE: Copy the value of a param type into pszValue, and return
a pointer to the first character after the closing angle
bracket
PARAMETERS:
pinput pointer to current CInput file
pcsz CStr to read new line into
psz position in current line
pcszValue CStr to receive value
pszPrefix prefix to look for
RETURNS:
COMMENTS:
MODIFICATION DATES:
24-Aug-1996 [ralphw]
***************************************************************************/
PSTR GetValue(CAInput* pinput, CStr* pcsz, PSTR psz, CStr* pcszValue)
{
// Skip past ending quote of parameter type
psz = FindDblQuote(pinput, pcsz, psz);
if (!psz)
return NULL;
if (!isSameString(psz, txtValue)) {
psz = stristr(psz, txtValue);
if (!psz) {
if (!pinput->getline(pcsz))
return NULL;
psz = stristr(pcsz->psz, txtValue);
if (!psz)
return NULL;
}
}
// Now find opening quote of the value
psz = FindDblQuote(pinput, pcsz, psz);
if (!psz)
return NULL;
if (!pcszValue->psz)
pcszValue->psz = (PSTR) lcMalloc(256);
PSTR pszDst = pcszValue->psz;
PSTR pszEnd = pszDst + lcSize(pcszValue->psz);
while (*psz != '\042') {
if (!*psz) {
if (!pinput->getline(pcsz))
return NULL;
psz = pcsz->psz;
continue;
}
*pszDst++ = *psz++;
if (pszDst >= pszEnd) {
/*
* Our destination buffer is too small, so increase it by
* 128 bytes.
*/
int offset = (int)(pszDst - pcszValue->psz);
pcszValue->ReSize((int)(pszEnd - pcszValue->psz) + 128);
pszDst = pcszValue->psz + offset;
pszEnd = pcszValue->psz + pcszValue->SizeAlloc();
lcHeapCheck();
}
}
*pszDst = '\0';
return FindCharacter(pinput, pcsz, psz, '>');
}
PSTR GetType(CAInput* pinput, CStr* pcsz, PSTR psz, CStr* pcszValue)
{
psz = FirstNonSpace(psz);
ASSERT(strlen(txtType) == sizeof(txtType) - 1); // make sure the compiler doesn't mess this up
if (IsSamePrefix(psz, txtType, sizeof(txtType) - 1)) {
psz = stristr(psz, txtType);
if (!psz) {
if (!pinput->getline(pcsz))
return NULL;
psz = stristr(pcsz->psz, txtType);
if (!psz)
return NULL;
}
}
// Now find opening quote of the value
psz = FindDblQuote(pinput, pcsz, psz);
if (!psz)
return NULL;
if (!pcszValue->psz)
pcszValue->psz = (PSTR) lcMalloc(256);
PSTR pszDst = *pcszValue;
PSTR pszEnd = pszDst + lcSize(pszDst);
while (*psz != '\042') {
if (!*psz) {
if (!pinput->getline(pcsz))
return NULL;
psz = pcsz->psz;
continue;
}
*pszDst++ = *psz++;
if (pszDst >= pszEnd) {
/*
* Our input buffer is too small, so increase it by
* 128 bytes.
*/
int offset = (int)(pszDst - pcsz->psz);
pcsz->ReSize((int)(pszEnd - pcsz->psz) + 128);
pszDst = pcsz->psz + offset;
pszEnd = pcsz->psz + pcsz->SizeAlloc();
lcHeapCheck();
}
}
*pszDst = '\0';
return FindCharacter(pinput, pcsz, psz, '>');
}
// This is called from the code that parses the sitemap in the information type section.
// Information types found outside of the declaration section are NOT added to the
// information types declared. So we don't have to worry about increasing the size of
// SITE_ENTRY_URLs after they have been defined. At least in this routine. We will have to
// deal with increasing the size of SITE_ENTRY_URLs when adding information types.
int CSiteMap::AddTypeName(PCSTR pszTypeName)
{
ASSERT(!IsEmptyString(pszTypeName));
if (!m_itTables.m_ptblInfoTypes) {
m_itTables.m_ptblInfoTypes = new CTable(16 * 1024);
ASSERT(!m_itTables.m_ptblInfoTypeDescriptions);
m_itTables.m_ptblInfoTypeDescriptions = new CTable(64 * 1024);
}
ASSERT(m_itTables.m_ptblInfoTypes);
/*
* If we have an Information type, but the table counts don't match,
* then we didn't get a description for the last type, so we add a blank
* description to keep the tables in sync.
*/
while (m_itTables.m_ptblInfoTypes->CountStrings() > m_itTables.m_ptblInfoTypeDescriptions->CountStrings())
m_itTables.m_ptblInfoTypeDescriptions->AddString("");
/*
A category and type is specified as:
category::type name
*/
CStr cszCategory;
CStr cszType;
int category = 0;
PCSTR pszCat = strstr(pszTypeName, "::");
if (pszCat) { // separate category name from type name
cszType = pszCat + 2; // make a local copy
cszCategory = pszTypeName;
cszCategory.psz[pszCat - pszTypeName] = '\0';
if (!m_itTables.m_ptblCategories) {
m_itTables.m_ptblCategories = new CTable(16 * 1024);
}
category = m_itTables.m_ptblCategories->IsStringInTable(cszCategory);
if (!category)
category = m_itTables.m_ptblCategories->AddString(cszCategory);
pszTypeName = cszType.psz;
}
int pos = m_itTables.m_ptblInfoTypes->IsStringInTable(pszTypeName);
if (pos <= 0) {
if ( (m_itTables.m_cTypes > 0) && ((m_itTables.m_cTypes+1) % 32 == 0) )
ReSizeIT(); // increase by one DWORD
pos = m_itTables.m_ptblInfoTypes->AddString(pszTypeName);
m_itTables.m_cTypes++;
int offset = 0;
int type = pos;
while (type > 32) {
offset++;
type -= 32;
}
INFOTYPE* pInfoType = m_pInfoTypes + offset;
*pInfoType |= (1 << type);
}
category--; // zero offset
if ( category >=0 )
AddITtoCategory(category, pos );
#if 0
/*
* If we have more then 32 information types, then we need to be certain
* the size of the SITE_ENTRY_URL* structure allocated for Sitemap Entries
* is large enough.
*/
// BUGBUG: we need to deal with the situation where an information type
// gets specified AFTER a sitemap entry has been specified.
if (pos > m_pSiteUrl->m_cMaxTypes) {
m_cUrlEntry = sizeof(SITE_ENTRY_URL) + pos / sizeof(UINT);
m_pSiteUrl->m_pUrl = (SITE_ENTRY_URL*) lcReAlloc(m_pSiteUrl->m_pUrl, m_cUrlEntry);
m_pSiteUrl->m_cMaxTypes += 32;
m_cInfoTypeOffsets++;
}
if ( pos % 32 == 0 )
{
// Increase the Categories
for(int i=0; i<m_itTables.m_max_categories; i++)
m_itTables.m_aCategories[i].pInfoType = (INFOTYPE*)lcReAlloc(m_itTables.m_aCategories[i].pInfoType,
InfoTypeSize());
// Increase the Exclusive and Hidden IT fields.
m_itTables.m_pExclusive = (INFOTYPE*) lcReAlloc(m_itTables.m_pExclusive,
InfoTypeSize() );
m_itTables.m_pHidden = (INFOTYPE*) lcReAlloc(m_itTables.m_pHidden,
InfoTypeSize() );
}
#endif
return pos;
}
BOOL CSiteMap::AreAnyInfoTypesDefined(SITEMAP_ENTRY* pSiteMapEntry)
{
INFOTYPE *pIT;
SITE_ENTRY_URL* pUrl = pSiteMapEntry->pUrls;
for (int iUrl = 0; iUrl < pSiteMapEntry->cUrls; iUrl++)
{
pIT = pUrl->ainfoTypes;
for (int i=0; i < InfoTypeSize()/4; i++)
{
if (*pIT)
return TRUE; // an info type was found
else
pIT++;
}
pUrl = NextUrlEntry(pUrl);
}
return FALSE;
}
/***************************************************************************
FUNCTION: CSiteMap::AreTheseInfoTypesDefined
PURPOSE: Find out if the specified INFOTYPES are defined
PARAMETERS:
pSiteMapEntry
types -- bit flag mask
offset -- offset into ainfoTypes
RETURNS:
A pointer to the first SITE_ENTRY_URL structure containing at
least one of the requested information types.
COMMENTS:
32 Information Types may be checked on each call. This will check
every URL defined for the current Sitemap entry, and return
TRUE if there is any match.
If you needed to find out if information type number 33 was
defined, you would call this with types set to 1, and offset to 1
(offset determines which set of 32 information types to look at).
MODIFICATION DATES:
25-Jan-1997 [ralphw]
***************************************************************************/
SITE_ENTRY_URL* CSiteMap::AreTheseInfoTypesDefined(SITEMAP_ENTRY* pSiteMapEntry,
INFOTYPE types, int offset) const
{
ASSERT((UINT) offset <= m_itTables.m_cTypes / sizeof(INFOTYPE));
SITE_ENTRY_URL* pUrl = pSiteMapEntry->pUrls;
if (!pUrl)
return NULL;
for (int iUrl = 0; iUrl < pSiteMapEntry->cUrls; iUrl++)
{
if ( *(pUrl->ainfoTypes+offset) & types )
return pUrl;
pUrl = NextUrlEntry(pUrl);
}
return NULL;
}
// This includes all memory for URL names and sitemap entries
const int MAX_POINTERS = (1024 * 1024); // 1 meg, 262,144 strings
const int MAX_STRINGS = (25 * 1024 * 1024) - 4096L; // 25 megs
CSiteMap::CSiteMap(int cMaxEntries) : CTable((cMaxEntries ? (cMaxEntries * 256) : MAX_STRINGS))
{
// Can't clear memory, because of our base class
m_fTypeCopy = FALSE;
m_fSaveIT = TRUE;
m_pszSitemapFile = NULL;
m_pTypicalInfoTypes = NULL;
m_fIndex = FALSE;
m_pszBase = NULL;
m_pszImageList = NULL;
m_cImages = 0;
m_pszFont = NULL;
m_fFolderImages = FALSE;
m_fPromotForInfoTypes = FALSE;
m_pszBackBitmap = NULL;
m_fAutoGenerated = FALSE;
m_ptblStrings = NULL;
m_pszFrameName = NULL;
m_pszWindowName = NULL;
m_pszHHIFile = NULL;
ZeroMemory(&m_itTables, sizeof(INFOTYPE_TABLES));
m_itTables.m_max_categories = MAX_CATEGORIES;
m_itTables.m_aCategories = (CATEGORY_TYPE*) lcMalloc(MAX_CATEGORIES*sizeof(CATEGORY_TYPE) );
m_itTables.m_cTypes = 0;
m_itTables.m_cITSize = 1; // Initially allocate one DWORD to hold info type bits
for(int i=0; i< MAX_CATEGORIES; i++)
{
m_itTables.m_aCategories[i].pInfoType = (INFOTYPE*)lcCalloc( sizeof(INFOTYPE) );
memset(m_itTables.m_aCategories[i].pInfoType, '\0', InfoTypeSize() );
m_itTables.m_aCategories[i].c_Types = 0;
}
m_itTables.m_pExclusive = (INFOTYPE*)lcCalloc( sizeof(INFOTYPE ) );
m_itTables.m_pHidden = (INFOTYPE*)lcCalloc( sizeof(INFOTYPE) );
m_clrBackground = (COLORREF) -1;
m_clrForeground = (COLORREF) -1;
m_exStyles = (DWORD) -1;
m_tvStyles = (DWORD) -1;
m_clrMask = 0xFFFFFF;
m_cImageWidth = 20;
m_pInfoTypes = (INFOTYPE*) lcCalloc(sizeof(INFOTYPE) );
m_pTypicalInfoTypes = (INFOTYPE*) lcCalloc( sizeof(INFOTYPE) );
// By default, select all information types
memset(m_pInfoTypes, 0xFF, sizeof(INFOTYPE) );
#ifdef HHCTRL
#ifndef HHA
m_CodePage = (UINT)-1;
#endif
#endif
}
CSiteMap::~CSiteMap()
{
for (int pos = 1; pos < endpos - 1; pos++)
{
SITEMAP_ENTRY* pSiteMapEntry = GetSiteMapEntry(pos);
if ( pSiteMapEntry && pSiteMapEntry->pUrls && pSiteMapEntry->pUrls->ainfoTypes )
lcFree(pSiteMapEntry->pUrls->ainfoTypes);
}
if (m_ptblStrings)
delete m_ptblStrings;
if (!m_fTypeCopy) {
if (m_itTables.m_ptblInfoTypes)
delete m_itTables.m_ptblInfoTypes;
if (m_itTables.m_ptblInfoTypeDescriptions)
delete m_itTables.m_ptblInfoTypeDescriptions;
if (m_itTables.m_ptblCategories)
delete m_itTables.m_ptblCategories;
if (m_itTables.m_ptblCatDescription)
delete m_itTables.m_ptblCatDescription;
}
for (int i=0; i< m_itTables.m_max_categories; i++)
lcFree( m_itTables.m_aCategories[i].pInfoType);
lcFree (m_itTables.m_aCategories);
lcFree (m_itTables.m_pHidden);
lcFree (m_itTables.m_pExclusive);
lcFree (m_pInfoTypes);
lcFree (m_pTypicalInfoTypes);
}
void CSiteMap::ReSizeURLIT(int Size)
{
int oldSize = InfoTypeSize();
if ( Size == 0 )
m_itTables.m_cITSize++;
else
m_itTables.m_cITSize= Size;
//Increase each sitemap entry URL infotype
int cEntries = Count();
INFOTYPE *pIT;
for (int i=1; i<=cEntries; i++)
{
SITEMAP_ENTRY *pSE = GetSiteMapEntry(i);
SITE_ENTRY_URL *pSEURL = pSE->pUrls;
for(int j=0; j<pSE->cUrls; j++)
{
pSEURL = pSEURL+j;
pIT = (INFOTYPE*) lcCalloc( InfoTypeSize() );
memcpy(pIT, pSEURL->ainfoTypes, oldSize);
lcFree( pSEURL->ainfoTypes );
pSEURL->ainfoTypes = pIT;
}
}
SizeIT( oldSize );
}
void CSiteMap::ReSizeIT(int Size)
{
int oldSize = InfoTypeSize();
if ( Size == 0 )
m_itTables.m_cITSize++; // increase by one
else
m_itTables.m_cITSize = Size;
SizeIT(oldSize);
}
void CSiteMap::SizeIT(int oldSize)
{
// Increase each category
INFOTYPE * pIT;
for(int i=0; i<m_itTables.m_max_categories; i++)
{
pIT = (INFOTYPE *) lcCalloc( InfoTypeSize() );
memcpy(pIT, m_itTables.m_aCategories[i].pInfoType, oldSize);
lcFree(m_itTables.m_aCategories[i].pInfoType);
m_itTables.m_aCategories[i].pInfoType = pIT;
}
pIT = (INFOTYPE *) lcCalloc( InfoTypeSize() );
memcpy(pIT, m_itTables.m_pExclusive, oldSize);
lcFree(m_itTables.m_pExclusive);
m_itTables.m_pExclusive = pIT;
pIT = (INFOTYPE *) lcCalloc( InfoTypeSize() );
memcpy(pIT, m_itTables.m_pHidden, oldSize);
lcFree(m_itTables.m_pHidden);
m_itTables.m_pHidden = pIT;
pIT = (INFOTYPE *) lcCalloc( InfoTypeSize() );
memcpy(pIT, m_pInfoTypes, oldSize);
lcFree(m_pInfoTypes);
m_pInfoTypes = pIT;
pIT = (INFOTYPE *) lcCalloc( InfoTypeSize() );
memcpy(pIT, m_pTypicalInfoTypes, oldSize);
lcFree(m_pTypicalInfoTypes);
m_pTypicalInfoTypes = pIT;
}
void CSiteMap::CopyCat(INFOTYPE_TABLES *Dst_itTables, const INFOTYPE_TABLES * Src_itTables)
{
// copy the categories table
Dst_itTables->m_max_categories = Src_itTables->m_max_categories;
if ( Dst_itTables->m_max_categories > MAX_CATEGORIES )
Dst_itTables->m_aCategories = (CATEGORY_TYPE *)lcReAlloc(Dst_itTables->m_aCategories,
Dst_itTables->m_max_categories * sizeof(CATEGORY_TYPE) );
for(int i=0; i<Dst_itTables->m_max_categories; i++)
{
if ( Dst_itTables->m_aCategories[i].pInfoType )
lcFree(Dst_itTables->m_aCategories[i].pInfoType);
Dst_itTables->m_aCategories[i].pInfoType = (INFOTYPE*) lcCalloc( InfoTypeSize());
if ( Src_itTables->m_aCategories[i].c_Types > 0 )
{
memcpy(Dst_itTables->m_aCategories[i].pInfoType,
Src_itTables->m_aCategories[i].pInfoType,
InfoTypeSize() );
Dst_itTables->m_aCategories[i].c_Types = Src_itTables->m_aCategories[i].c_Types;
}
else
{
Dst_itTables->m_aCategories[i].c_Types = 0;
}
}
}
// Check all the categories to see if this type is a member of any of them, return TRUE on first occurrence
BOOL CSiteMap::IsInACategory( int type ) const
{
for (int i=0; i<HowManyCategories(); i++ )
{
int offset;
INFOTYPE *pIT;
offset = type / 32;
ASSERT ( m_itTables.m_aCategories[i].pInfoType );
pIT = m_itTables.m_aCategories[i].pInfoType + offset;
if ( *pIT & (1<<(type-(offset*32))) )
return TRUE;
}
return FALSE;
}
int CSiteMap::GetInfoType(PCSTR pszTypeName)
{
int type;
CStr cszCat = pszTypeName;
ASSERT(!IsEmptyString(pszTypeName));
/*
A category and type is specified as:
category::type name
*/
PSTR pszCat = strstr(cszCat.psz, "::");
if ( !pszCat )
{
pszCat = StrChr(cszCat.psz, ':');
if (pszCat != NULL)
{
*pszCat = '\0';
pszCat++; // step over the :
}
}
else
{
*pszCat = '\0';
pszCat+=2; // step over the ::
}
if ( pszCat == NULL )
return GetITIndex(pszTypeName); // there is not category.
else
{
int cat = GetCatPosition( cszCat.psz );
if (cat <= 0)
return -1;
type = GetFirstCategoryType( cat-1 );
while( type != -1 )
{
if ( strcmp( pszCat, GetInfoTypeName(type) ) == 0 )
return type;
type = GetNextITinCategory();
}
}
return -1;
}
// Reads the user's current favorites to create nodes
void CSiteMap::CreateFavorites(int level)
{
HRESULT hr;
LPITEMIDLIST pidl;
char szFavoritesPath[MAX_PATH];
hr = SHGetSpecialFolderLocation(NULL, CSIDL_FAVORITES, &pidl);
if (SUCCEEDED(hr)) {
BOOL fResult = SHGetPathFromIDList(pidl, szFavoritesPath);
// SHFree(pidl); // BUGBUG: this function doesn't exist!!!
if (!fResult)
return; // BUGBUG: nag the author
}
else
return; // BUGBUG: nag the author
AddTrailingBackslash(szFavoritesPath);
CStr cszSearch(szFavoritesPath);
cszSearch += "*.*";
CTable tblFolders;
CTable tblFiles;
WIN32_FIND_DATA wfd;
HANDLE hFind = FindFirstFile(cszSearch, &wfd);
if (hFind != INVALID_HANDLE_VALUE) {
do {
if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
if (wfd.cFileName[0] != '.') // ignore . and ..
tblFolders.AddString(wfd.cFileName);
}
else
tblFiles.AddString(wfd.cFileName);
} while (FindNextFile(hFind, &wfd));
FindClose(hFind);
}
// Did we get at least one entry?
if (tblFolders.CountStrings() || tblFiles.CountStrings()) {
SITEMAP_ENTRY SiteMapEntry;
ZERO_STRUCTURE(SiteMapEntry);
// Add the top level book called Favorites
SiteMapEntry.level = level++;
SiteMapEntry.pszText = StrDup(GetStringResource(IDS_BROWSER_FAVORITES));
AddEntry(&SiteMapEntry);
tblFolders.SortTablei(); // BUGBUG: set lcide first
for (int pos = 1; pos <= tblFolders.CountStrings(); pos++)
AddFavoriteNodes(szFavoritesPath, tblFolders.GetPointer(pos), level);
tblFiles.SortTablei(); // BUGBUG: set lcid first
for (pos = 1; pos <= tblFiles.CountStrings(); pos++) {
char szUrl[MAX_PATH * 4];
char szPath[MAX_PATH];
strcpy(szPath, szFavoritesPath);
AddTrailingBackslash(szPath);
strcat(szPath, tblFiles.GetPointer(pos));
if (GetPrivateProfileString("InternetShortcut", "URL", "",
szUrl, sizeof(szUrl), szPath) > 0 && szUrl[0]) {
CStr cszName(tblFiles.GetPointer(pos));
PSTR pszExtension = StrRChr(cszName, '.');
if (pszExtension) {
*pszExtension = '\0';
SiteMapEntry.level = (BYTE)level;
SiteMapEntry.pszText = StrDup(cszName);
CSiteEntryUrl curl( InfoTypeSize() );
curl.m_pUrl->urlPrimary = AddUrl(szUrl);
SiteMapEntry.pUrls = curl.m_pUrl;
SiteMapEntry.SetTopic(TRUE);
AddEntry(&SiteMapEntry);
}
}
}
}
}
void CSiteMap::AddFavoriteNodes(PCSTR pszRoot, PCSTR pszNewFolder, int level)
{
CTable tblFolders;
CTable tblFiles;
char szPath[MAX_PATH];
strcpy(szPath, pszRoot);
AddTrailingBackslash(szPath);
strcat(szPath, pszNewFolder);
CStr cszRoot(szPath); // save in case we need to recurse
AddTrailingBackslash(szPath);
strcat(szPath, "*.*");
WIN32_FIND_DATA wfd;
HANDLE hFind = FindFirstFile(szPath, &wfd);
if (hFind != INVALID_HANDLE_VALUE) {
do {
if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
if (wfd.cFileName[0] != '.') // ignore . and ..
tblFolders.AddString(wfd.cFileName);
}
else
tblFiles.AddString(wfd.cFileName);
} while (FindNextFile(hFind, &wfd));
FindClose(hFind);
}
// Did we get at least one entry?
if (tblFolders.CountStrings() || tblFiles.CountStrings()) {
SITEMAP_ENTRY SiteMapEntry;
ZERO_STRUCTURE(SiteMapEntry);
SiteMapEntry.level = level++;
SiteMapEntry.pszText = StrDup(pszNewFolder);
AddEntry(&SiteMapEntry);
tblFolders.SortTablei(); // BUGBUG: set lcid first
// Handle all nested folders
for (int pos = 1; pos <= tblFolders.CountStrings(); pos++)
AddFavoriteNodes(cszRoot, tblFolders.GetPointer(pos), level);
tblFiles.SortTablei(); // BUGBUG: set lcide first
for (pos = 1; pos <= tblFiles.CountStrings(); pos++) {
char szUrl[MAX_PATH * 4];
strcpy(szPath, cszRoot);
AddTrailingBackslash(szPath);
strcat(szPath, tblFiles.GetPointer(pos));
if (GetPrivateProfileString("InternetShortcut", "URL", "",
szUrl, sizeof(szUrl), szPath) > 0 && szUrl[0]) {
CStr cszName(tblFiles.GetPointer(pos));
PSTR pszExtension = StrRChr(cszName, '.');
if (pszExtension) {
*pszExtension = '\0';
SiteMapEntry.level = (BYTE)level;
SiteMapEntry.pszText = StrDup(cszName);
CSiteEntryUrl curl( InfoTypeSize() );
curl.m_pUrl->urlPrimary = AddUrl(szUrl);
SiteMapEntry.pUrls = curl.m_pUrl;
SiteMapEntry.SetTopic(TRUE);
AddEntry(&SiteMapEntry);
}
}
}
}
}
int CSiteMap::GetImageNumber(SITEMAP_ENTRY* pSiteMapEntry) const
{
int image = pSiteMapEntry->GetImageIndex();
if (image == 0) {
if (pSiteMapEntry->IsTopic()) {
image = pSiteMapEntry->fNew ?
IMAGE_HELP_TOPIC_NEW : IMAGE_HELP_TOPIC;
if (m_fFolderImages)
image+= 2; // switch to standard topic images
}
else {
image = pSiteMapEntry->fNew ? IMAGE_OPEN_BOOK_NEW : IMAGE_OPEN_BOOK;
if (m_fFolderImages)
image += 4; // switch to standard books
}
}
if (m_cImages && image > m_cImages) {
// BUGBUG: if this really happens, nag the author
image = IMAGE_CLOSED_BOOK;
}
return image;
}
BOOL CSiteMap::IsEntryInCurTypeList(SITEMAP_ENTRY* pSiteMapEntry) const
{
int cTypes = m_itTables.m_ptblInfoTypes->CountStrings();
if (cTypes < 32) {
return AreTheseInfoTypesDefined(pSiteMapEntry, m_pInfoTypes[0], 0) != NULL;
}
else {
for (int i = 0; cTypes > 32; i++) {
if (AreTheseInfoTypesDefined(pSiteMapEntry, m_pInfoTypes[i], i))
return TRUE;
cTypes -= 32;
}
return AreTheseInfoTypesDefined(pSiteMapEntry, m_pInfoTypes[i], i) != NULL;
}
}
typedef struct tagEntityMap
{
PCSTR pszName;
int ch;
} ENTITYMAP, * PENTITYMAP;
// ENTITY TABLE SWIPED FROM IE
const ENTITYMAP rgEntities[] =
{
"AElig", '\306', // capital AE diphthong (ligature)
"Aacute", '\301', // capital A, acute accent
"Acirc", '\302', // capital A, circumflex accent
"Agrave", '\300', // capital A, grave accent
"Aring", '\305', // capital A, ring
"Atilde", '\303', // capital A, tilde
"Auml", '\304', // capital A, dieresis or umlaut mark
"Ccedil", '\307', // capital C, cedilla
"Dstrok", '\320', // capital Eth, Icelandic
"ETH", '\320', // capital Eth, Icelandic
"Eacute", '\311', // capital E, acute accent
"Ecirc", '\312', // capital E, circumflex accent
"Egrave", '\310', // capital E, grave accent
"Euml", '\313', // capital E, dieresis or umlaut mark
"Iacute", '\315', // capital I, acute accent
"Icirc", '\316', // capital I, circumflex accent
"Igrave", '\314', // capital I, grave accent
"Iuml", '\317', // capital I, dieresis or umlaut mark
"Ntilde", '\321', // capital N, tilde
"Oacute", '\323', // capital O, acute accent
"Ocirc", '\324', // capital O, circumflex accent
"Ograve", '\322', // capital O, grave accent
"Oslash", '\330', // capital O, slash
"Otilde", '\325', // capital O, tilde
"Ouml", '\326', // capital O, dieresis or umlaut mark
"THORN", '\336', // capital THORN, Icelandic
"Uacute", '\332', // capital U, acute accent
"Ucirc", '\333', // capital U, circumflex accent
"Ugrave", '\331', // capital U, grave accent
"Uuml", '\334', // capital U, dieresis or umlaut mark
"Yacute", '\335', // capital Y, acute accent
"aacute", '\341', // small a, acute accent
"acirc", '\342', // small a, circumflex accent
"acute", '\264', // acute accent
"aelig", '\346', // small ae diphthong (ligature)
"agrave", '\340', // small a, grave accent
"amp", '\046', // ampersand
"aring", '\345', // small a, ring
"atilde", '\343', // small a, tilde
"auml", '\344', // small a, dieresis or umlaut mark
"brkbar", '\246', // broken vertical bar
"brvbar", '\246', // broken vertical bar
"ccedil", '\347', // small c, cedilla
"cedil", '\270', // cedilla
"cent", '\242', // small c, cent
"copy", '\251', // copyright symbol (proposed 2.0)
"curren", '\244', // currency symbol
"deg", '\260', // degree sign
"die", '\250', // umlaut (dieresis)
"divide", '\367', // divide sign
"eacute", '\351', // small e, acute accent
"ecirc", '\352', // small e, circumflex accent
"egrave", '\350', // small e, grave accent
"eth", '\360', // small eth, Icelandic
"euml", '\353', // small e, dieresis or umlaut mark
"frac12", '\275', // fraction 1/2
"frac14", '\274', // fraction 1/4
"frac34", '\276', // fraction 3/4*/
"gt", '\076', // greater than
"hibar", '\257', // macron accent
"iacute", '\355', // small i, acute accent
"icirc", '\356', // small i, circumflex accent
"iexcl", '\241', // inverted exclamation
"igrave", '\354', // small i, grave accent
"iquest", '\277', // inverted question mark
"iuml", '\357', // small i, dieresis or umlaut mark
"laquo", '\253', // left angle quote
"lt", '\074', // less than
"macr", '\257', // macron accent
"micro", '\265', // micro sign
"middot", '\267', // middle dot
"nbsp", '\240', // non-breaking space (proposed 2.0)
"not", '\254', // not sign
"ntilde", '\361', // small n, tilde
"oacute", '\363', // small o, acute accent
"ocirc", '\364', // small o, circumflex accent
"ograve", '\362', // small o, grave accent
"ordf", '\252', // feminine ordinal
"ordm", '\272', // masculine ordinal
"oslash", '\370', // small o, slash
"otilde", '\365', // small o, tilde
"ouml", '\366', // small o, dieresis or umlaut mark
"para", '\266', // paragraph sign
"plusmn", '\261', // plus minus
"pound", '\243', // pound sterling
"quot", '"', // double quote
"raquo", '\273', // right angle quote
"reg", '\256', // registered trademark (proposed 2.0)
"sect", '\247', // section sign
"shy", '\255', // soft hyphen (proposed 2.0)
"sup1", '\271', // superscript 1
"sup2", '\262', // superscript 2
"sup3", '\263', // superscript 3
"szlig", '\337', // small sharp s, German (sz ligature)
"thorn", '\376', // small thorn, Icelandic
"times", '\327', // times sign
"trade", '\231', // trademark sign
"uacute", '\372', // small u, acute accent
"ucirc", '\373', // small u, circumflex accent
"ugrave", '\371', // small u, grave accent
"uml", '\250', // umlaut (dieresis)
"uuml", '\374', // small u, dieresis or umlaut mark
"yacute", '\375', // small y, acute accent
"yen", '\245', // yen
"yuml", '\377', // small y, dieresis or umlaut mark
0, 0
};
BOOL ReplaceEscapes(PCSTR pszSrc, PSTR pszDst, int flags)
{
if (IsEmptyString(pszSrc))
return FALSE;
ASSERT(pszDst);
if ((flags & ESCAPE_URL)) {
if (StrChr(pszSrc, '%'))
goto CheckForEscape;
}
if ((flags & ESCAPE_C)) {
if (StrChr(pszSrc, '\\'))
goto CheckForEscape;
}
if ((flags & ESCAPE_ENTITY)) {
if (StrChr(pszSrc, '&'))
goto CheckForEscape;
}
// If we get here, there are no escape sequences, so copy the string and
// return.
if (pszDst != pszSrc)
strcpy(pszDst, pszSrc);
return FALSE; // nothing changed
CheckForEscape:
#ifdef _DEBUG
PSTR pszOrgDst = pszDst;
int cbSource = (int)strlen(pszSrc);
#endif
while (*pszSrc) {
if (IsDBCSLeadByte(*pszSrc))
{
if (pszSrc[1])
{
*pszDst++ = *pszSrc++;
*pszDst++ = *pszSrc++;
}
else
{
// leadbyte followed by 0; invalid!
*pszDst++ = '?';
break;
}
}
else if ((flags & ESCAPE_URL) && *pszSrc == '%')
{
// URL style hex digits
get_hex:
int val;
pszSrc++;
if (IsDigit(*pszSrc))
val = *pszSrc++ - '0';
else if (*pszSrc >= 'a' && *pszSrc <= 'f')
val = *pszSrc++ - 'a' + 10;
else if (*pszSrc >= 'A' && *pszSrc <= 'F')
val = *pszSrc++ - 'A' + 10;
if (IsDigit(*pszSrc))
val = val * 16 + *pszSrc++ - '0';
else if (*pszSrc >= 'a' && *pszSrc <= 'f')
val = val * 16 + *pszSrc++ - 'a' + 10;
else if (*pszSrc >= 'A' && *pszSrc <= 'F')
val = val * 16 + *pszSrc++ - 'A' + 10;
if (val)
{
*pszDst++ = (CHAR)val;
}
}
else if ((flags & ESCAPE_C) && *pszSrc == '\\')
{
// C style escape
switch (*++pszSrc)
{
case 'n':
*pszDst++ = '\n';
pszSrc++;
break;
case 'r':
*pszDst++ = '\r';
pszSrc++;
break;
case 't':
*pszDst++ = '\t';
pszSrc++;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
// octal digits
{
int val;
if (*pszSrc >= '0' && *pszSrc <= '7')
val = *pszSrc++ - '0';
if (*pszSrc >= '0' && *pszSrc <= '7')
val = val * 8 + *pszSrc++ - '0';
if (*pszSrc >= '0' && *pszSrc <= '7')
val = val * 8 + *pszSrc++ - '0';
if (val)
*pszDst++ = (CHAR)val;
}
break;
case 'x':
case 'X':
// hex digits
goto get_hex;
break;
case 0:
break;
default:
*pszDst++ = *pszSrc++;
break;
}
}
else if ( (flags & ESCAPE_ENTITY) && *pszSrc == '&' && *(pszSrc+1) != ' ' )
{
pszSrc++;
if (*pszSrc == '#')
{
// SGML/HTML character entity (decimal)
pszSrc++;
for (int val = 0; *pszSrc && *pszSrc != ';' && *pszSrc != ' '; pszSrc++)
{
if (*pszSrc >= '0' && *pszSrc <= '9')
val = val * 10 + *pszSrc - '0';
else
{
while (*pszSrc && *pszSrc != ';' && *pszSrc != ' ')
pszSrc++;
break;
}
}
if( *pszSrc == ';' )
pszSrc++;
if (val) {
*pszDst++ = (CHAR)val;
}
}
else if (*pszSrc)
{
char szEntityName[256];
int count = 0;
// extra code was added below to handle the case where an & appears without
// an entity name (which is an error in the HTML). This avoids overunning
// the szEntityName buffer.
//
for (PSTR p = szEntityName; *pszSrc && *pszSrc != ';' && *pszSrc != ' ' && count < sizeof(szEntityName);)
{
*p++ = *pszSrc++;
count++;
}
*p = 0;
if (*pszSrc == ';')
pszSrc++;
for (int i = 0; rgEntities[i].pszName; i++)
{
if (!strcmp(szEntityName, rgEntities[i].pszName)) {
if (rgEntities[i].ch) {
*pszDst++ = (CHAR)rgEntities[i].ch;
}
break;
}
}
if (!rgEntities[i].pszName) {
// illegal entity name, put in a block character
*pszDst++ = '?';
}
}
}
else {
// just your usual character...
*pszDst++ = *pszSrc++;
}
}
*pszDst = 0;
ASSERT(pszDst - pszOrgDst <= cbSource);
return TRUE;
}
#ifndef HHCTRL
void STDCALL ConvertToEscapes(PCSTR pszSrc, CStr* pcszDst)
{
int cbAlloc = pcszDst->SizeAlloc();
if (!cbAlloc)
pcszDst->ReSize(cbAlloc = (strlen(pszSrc) + 128));
int dstPos = 0;
if (!pszSrc) {
*pcszDst = "";
return;
}
int cbSrc = strlen(pszSrc);
while (*pszSrc) {
if( IsDBCSLeadByte(*pszSrc) )
{
pcszDst->psz[dstPos++] = *pszSrc++;
if( pszSrc )
pcszDst->psz[dstPos++] = *pszSrc++;
}
else {
for (int i = 0; rgEntities[i].pszName; i++) {
if (*pszSrc == rgEntities[i].ch) {
if ((size_t) cbAlloc - dstPos <= strlen(rgEntities[i].pszName) + 2)
pcszDst->ReSize(cbAlloc += 128);
pcszDst->psz[dstPos++] = '&';
strcpy(pcszDst->psz + dstPos, rgEntities[i].pszName);
strcat(pcszDst->psz, ";");
dstPos += strlen(rgEntities[i].pszName) + 1;
pszSrc++;
break;
}
}
if (!rgEntities[i].pszName)
pcszDst->psz[dstPos++] = *pszSrc++;
}
if (cbAlloc <= dstPos)
pcszDst->ReSize(cbAlloc += 128);
}
pcszDst->psz[dstPos] = '\0';
}
#endif
#ifdef HHCTRL
BOOL CAInput::Add(PCSTR pszFile)
{
m_ainput[++m_curInput].pin = new CInput(pszFile);
m_ainput[m_curInput].pszBaseName = lcStrDup(pszFile);
if (!m_ainput[m_curInput].pin->isInitialized()) {
Remove();
return FALSE;
}
// Strip basename down to the path
PSTR pszFilePortion = (PSTR) FindFilePortion(m_ainput[m_curInput].pszBaseName);
if (pszFilePortion)
*pszFilePortion = '\0';
ConvertBackSlashToForwardSlash(m_ainput[m_curInput].pszBaseName);
return TRUE;
}
#endif
////////////////////////////////// non-HHCTRL code //////////////////////////////////
#ifndef HHCTRL
const int MAX_PARAM = 4096;
#pragma warning(disable:4125) // decimal digit terminates octal escape sequence
static const char txtSiteMapVersion[] = "<!-- Sitemap 1.0 -->";
static const char txtStringParam[] = "<param name=\042%s\042 value=\042%s\042>";
static const char txtSSConvString[] = "<param name=\042%s\042 value=\042%s:%s:%s\042>";
static const char txtYes[] = "Yes";
static const char txtDecimalParam[] = "<param name=\042%s\042 value=\042%u\042>";
static const char txtHexParam[] = "<param name=\042%s\042 value=\0420x%x\042>";
__inline void PadOutput(COutput* pout, int level) {
for (int i = 0; i < level; i++)
pout->outchar('\t');
}
BOOL CSiteMap::SaveSiteMap(PCSTR pszPathName, BOOL fIndex)
{
COutput output(pszPathName);
if (!output.isFileOpen()) {
// DO NOT USE MsgBox() as the parent window handle is invalid if we are closing
CStr csz(IDS_CANT_WRITE, pszPathName);
MessageBox(APP_WINDOW, csz, txtAppTitle, MB_OK | MB_ICONHAND);
return FALSE;
}
CStr cszTmp;
CMem memParam(MAX_PARAM);
PSTR pszParam = memParam.psz; // for notational convenience
output.outstring(GetStringResource(IDSHHA_HTML_NEW_FILE1));
output.outstring_eol(txtSiteMapVersion);
output.outstring_eol("</HEAD><BODY>");
// Write out any global properties
if ( IsFrameDefined() ||
IsWindowDefined() ||
m_itTables.m_ptblInfoTypes ||
m_itTables.m_ptblCategories ||
m_fFolderImages ||
m_pszImageList ||
m_fAutoGenerated ||
IsNonEmpty(m_pszFont) ||
IsNonEmpty(m_pszHHIFile) ||
m_clrBackground != (COLORREF) -1 ||
m_clrForeground != (COLORREF) -1 ||
m_exStyles != (DWORD) -1 ||
m_tvStyles != (DWORD) -1) {
output.outstring_eol("<OBJECT type=\042text/site properties\042>");
if (m_fAutoGenerated) {
wsprintf(pszParam, txtStringParam, txtAutoGenerated,
txtYes);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
if (IsFrameDefined()) {
ConvertToEscapes(GetFrameName(), &cszTmp);
wsprintf(pszParam, txtStringParam, txtParamFrame, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
if (IsWindowDefined()) {
ConvertToEscapes(GetWindowName(), &cszTmp);
wsprintf(pszParam, txtStringParam, txtParamWindow, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
/*
* REVIEW: we should eliminate Information Types which haven't
* actually been used.
*/
// output the entire list of info types to disk, without regard to their inclusion
// in a category. We may have ITs that are not members of a category.
if ( m_fSaveIT && m_itTables.m_cTypes )
{
for(int pos=1; pos<=m_itTables.m_cTypes; pos++)
{
ConvertToEscapes(m_itTables.m_ptblInfoTypes->GetPointer(pos), &cszTmp);
if ( HowManyCategories() > 0 )
{
if ( IsExclusive(pos) ) // An Exclusive IT
wsprintf( pszParam, txtStringParam, txtSaveTypeExclusive, cszTmp);
else if ( IsHidden(pos) ) // A Hidden IT
wsprintf( pszParam, txtStringParam, txtSaveTypeHidden, cszTmp);
else // A regular IT
wsprintf(pszParam, txtStringParam, txtSaveType, cszTmp);
}
else
{
if ( IsExclusive(pos) ) // An Exclusive IT
wsprintf( pszParam, txtStringParam, txtParamTypeExclusive, cszTmp);
else if ( IsHidden(pos) ) // A Hidden IT
wsprintf( pszParam, txtStringParam, txtParamTypeHidden, cszTmp);
else // A regular IT
wsprintf(pszParam, txtStringParam, txtParamType, cszTmp);
}
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
ConvertToEscapes(m_itTables.m_ptblInfoTypeDescriptions->GetPointer(pos), &cszTmp);
if (!IsEmptyString(cszTmp))
{
if (StrChr(cszTmp, '&'))
{
cszTmp = cszTmp;
cszTmp.AddAmpersandEscape();
cszTmp = cszTmp.psz;
}
if ( HowManyCategories() > 0)
wsprintf(pszParam, txtStringParam, txtSaveTypeDesc, cszTmp);
else
wsprintf(pszParam, txtStringParam, txtParamTypeDesc, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
else
{
CStr cszTemp(" ");
cszTmp = cszTemp.psz;
if ( HowManyCategories() > 0)
wsprintf(pszParam, txtStringParam, txtSaveTypeDesc, cszTmp);
else
wsprintf(pszParam, txtStringParam, txtParamTypeDesc, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
}
}
//Output Categories and the info types, that are members of each category, to disk.
if (m_fSaveIT && m_itTables.m_ptblCategories && m_itTables.m_ptblCategories->CountStrings() )
{
for(int posCat=1; posCat<=m_itTables.m_ptblCategories->CountStrings(); posCat++)
{
if ( IsCatDeleted( posCat ) )
continue;
ConvertToEscapes(GetCategoryString(posCat), &cszTmp);
if (cszTmp.IsNonEmpty())
{
wsprintf(pszParam, txtStringParam, txtParamCategory, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
ConvertToEscapes(m_itTables.m_ptblCatDescription->GetPointer(posCat), &cszTmp);
if (!IsEmptyString(cszTmp))
{
if (StrChr(cszTmp, '&'))
{
cszTmp = cszTmp;
cszTmp.AddAmpersandEscape();
cszTmp = cszTmp.psz;
}
wsprintf(pszParam, txtStringParam, txtParamCategoryDesc, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
else
{
CStr cszTemp(" ");
cszTmp = cszTemp.psz;
wsprintf(pszParam, txtStringParam, txtParamCategoryDesc, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
}
int posType = GetFirstCategoryType(posCat-1);
// for(int j = 1; j <= m_itTables.m_aCategories[posCat-1].c_Types; j++)
while( posType != -1 )
{
ConvertToEscapes(GetInfoTypeName(posType), &cszTmp);
if ( IsExclusive( posType ) )
wsprintf( pszParam, txtStringParam, txtParamTypeExclusive, cszTmp);
else
if ( IsHidden(posType) ) // A Hidden IT
wsprintf( pszParam, txtStringParam, txtParamTypeHidden, cszTmp);
else // A regular IT
wsprintf(pszParam, txtStringParam, txtParamType, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
ConvertToEscapes(m_itTables.m_ptblInfoTypeDescriptions->GetPointer(posType), &cszTmp);
if (cszTmp.IsNonEmpty())
{
if (StrChr(cszTmp, '&'))
{
cszTmp = cszTmp;
cszTmp.AddAmpersandEscape();
cszTmp = cszTmp.psz;
}
wsprintf(pszParam, txtStringParam, txtParamTypeDesc, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
else
{
CStr cszTemp(" ");
cszTmp = cszTemp.psz;
wsprintf(pszParam, txtStringParam, txtParamTypeDesc, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
posType = GetNextITinCategory();
} // for each IT in a category
} // for each category
} // if there are categories.
#ifdef NOTYET
// OutPut the SubSet Declarations.
CStr cszTemp;
for(int i=0; i<m_pSubSets->HowManySubSets(); i++)
{
CSubSet * cur_subset = m_pSubSets->GetSubSet(i);
if ( cur_subset == NULL )
continue;
// output the Inclusive IT's in the subset
int type = cur_subset->GetFirstIncITinSubSet();
while ( type != -1 )
{
wsprintf(pszParam, txtSSConvString, txtParamSSInclusive, txtSSInclusive
cur_subset->m_cszSubSetName.psz,
cur_subset->m_pIT->m_itTables.m_ptblInfoTypes->GetPointer(type) );
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
type = cur_subset->GetNextIncITinSubSet();
}
// output the Exclusive IT's of the subset
type = cur_subset->GetFirstExcITinSubSet();
while( type != -1 )
{
wsprintf(pszParam, txtSSConvString, txtParamSSExclusive, txtSSExclusive
cur_subset->m_cszSubSetName.psz,
cur_subset->m_pIT->m_itTables.m_ptblInfoTypes->GetPointer(type) );
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
type = cur_subset->GetNextExcITinSubSet();
}
} // End OutPut SubSets
#endif
if (m_pszImageList && m_cImageWidth) {
ConvertToEscapes(m_pszImageList, &cszTmp);
wsprintf(pszParam, txtStringParam, txtImageList, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
wsprintf(pszParam, txtDecimalParam, txtImageWidth, m_cImageWidth);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
if (m_clrMask != 0xFFFFFF) {
wsprintf(pszParam, txtHexParam, txtColorMask, m_clrMask);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
}
if (m_clrBackground != (DWORD) -1) {
wsprintf(pszParam, txtHexParam, txtBackGround, m_clrBackground);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
if (m_clrForeground != (DWORD) -1) {
wsprintf(pszParam, txtHexParam, txtForeGround, m_clrForeground);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
if (m_exStyles != (DWORD) -1) {
wsprintf(pszParam, txtHexParam, txtExWindowStyles, m_exStyles);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
if (m_tvStyles != (DWORD) -1) {
wsprintf(pszParam, txtHexParam, txtWindowStyles, m_tvStyles);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
if (m_fFolderImages) {
wsprintf(pszParam, txtStringParam, txtImageType, txtFolderType);
ASSERT(strlen(pszParam) < MAX_PARAM);
output.outchar('\t');
output.outstring_eol(pszParam);
}
if (IsNonEmpty(m_pszFont)) {
ConvertToEscapes(m_pszFont, &cszTmp);
wsprintf(pszParam, txtStringParam, txtFont, cszTmp);
output.outstring_eol(pszParam);
}
if (IsNonEmpty(m_pszHHIFile)) {
wsprintf(pszParam, txtStringParam, txtParamHHI, m_pszHHIFile);
output.outstring_eol(pszParam);
}
output.outstring_eol(txtEndObject);
}
// Write out the actual entries
output.outstring_eol(txtBeginList);
int curLevel = 1;
for (int pos = 1; pos <= CountStrings(); pos++) {
SITEMAP_ENTRY* pSiteMapEntry = GetSiteMapEntry(pos);
ASSERT(pSiteMapEntry->pszText);
if (!pSiteMapEntry->pszText) // should never happen, but I'm paranoid...
continue;
// If level is greater, begin list item
while (pSiteMapEntry->level > curLevel) {
PadOutput(&output, curLevel);
output.outstring_eol(txtBeginList);
curLevel++;
}
// While level is lower, end lists
while (pSiteMapEntry->level < curLevel) {
curLevel--;
PadOutput(&output, curLevel);
output.outstring_eol(txtEndList);
}
PadOutput(&output, curLevel);
if (!pSiteMapEntry->fInclude)
output.outstring("<LI> ");
output.outstring_eol("<OBJECT type=\042text/sitemap\042>");
if (pSiteMapEntry->fInclude) {
PadOutput(&output, curLevel + 1);
output.outstring("<param name=\042Merge\042 value=\042");
ConvertToEscapes(pSiteMapEntry->pszText + strlen(GetStringResource(IDS_INCLUDED_FILE)), &cszTmp);
output.outstring(cszTmp);
output.outstring_eol("\042>\r\n");
PadOutput(&output, curLevel + 1);
output.outstring_eol(txtEndObject);
continue;
}
ConvertToEscapes(pSiteMapEntry->pszText, &cszTmp);
wsprintf(pszParam, txtStringParam, txtParamName, cszTmp);
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(&output, curLevel + 1);
output.outstring_eol(pszParam);
OutputDefaultSiteMapEntry(&output, pSiteMapEntry, curLevel, fIndex);
PadOutput(&output, curLevel + 1);
output.outstring_eol(txtEndObject);
#if 0
/*
* We need to add an HREF to keep down-level sitemap readers happy
* (makes the .hhc file readable in a browser). We pick the first
* URL specified and use that.
*/
for (int i = 0; i < pSiteMapEntry->cTypes; i++) {
if ( pSiteMapEntry->aSiteInfoTypes[i].urlNumber > 0 &&
pSiteMapEntry->aSiteInfoTypes[i].infoNumber > 0) {
wsprintf(pszParam, "<A HREF=\042%s\042>%s</A>",
m_ptoc->GetUrlString((pSiteMapEntry->aSiteInfoTypes[i].urlNumber),
pSiteMapEntry->pszText);
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(&output, curLevel + 1);
output.outstring_eol(pszParam);
break;
}
}
#endif
}
while (curLevel > 1) {
curLevel--;
PadOutput(&output, curLevel);
output.outstring_eol(txtEndList);
}
output.outstring_eol(txtEndList);
output.outstring_eol("</BODY></HTML>");
return TRUE;
}
void CSiteMap::OutputDefaultSiteMapEntry(COutput* pout, SITEMAP_ENTRY* pSiteMapEntry,
int curLevel, BOOL fIndex)
{
CMem memParam(8 * 1024);
PSTR pszParam = memParam.psz; // for notational convenience
SITE_ENTRY_URL* pUrl = pSiteMapEntry->pUrls;
int cTypes = HowManyInfoTypes();
for (int i = 0; i < pSiteMapEntry->cUrls; i++) {
if (!IsEmptyString(pUrl->pszTitle)) {
wsprintf(pszParam, txtStringParam, txtParamName, pUrl->pszTitle);
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(pout, curLevel + 1);
pout->outstring_eol(pszParam);
}
if (cTypes) {
int bitflag = 1 << 1;
int offset = 0;
CSiteMapEntry sitemapentry;
sitemapentry.cUrls = 1;
sitemapentry.pUrls = pUrl;
for (int infotype = 1; infotype <= cTypes; infotype++) {
if (AreTheseInfoTypesDefined(&sitemapentry, bitflag, offset)) {
CStr csz;
for (int l = 0; l < HowManyCategories(); l++) {
if( m_itTables.m_aCategories[l].c_Types <= 0)
break;
if( IsITinCategory( l, infotype) )
{
csz = GetCategoryString(l+1);
csz += "::";
break;
}
}
csz += GetInfoTypeName(infotype);
wsprintf(pszParam, txtStringParam, txtParamType, csz.psz);
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(pout, curLevel + 1);
pout->outstring_eol(pszParam);
}
bitflag = bitflag << 1;
if (!bitflag) { // wrap around, so switch offsets
offset++;
bitflag = 1;
}
}
}
if (pUrl->urlPrimary) {
if (pSiteMapEntry->fSeeAlso) {
wsprintf(pszParam, txtStringParam, txtSeeAlso, GetUrlString(pUrl->urlPrimary));
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(pout, curLevel + 1);
pout->outstring_eol(pszParam);
break; // only one URL if See Also entry
}
wsprintf(pszParam, txtStringParam, txtParamLocal,
GetUrlString(pUrl->urlPrimary));
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(pout, curLevel + 1);
pout->outstring_eol(pszParam);
}
if (pUrl->urlSecondary) {
wsprintf(pszParam, txtStringParam, txtParamUrl,
GetUrlString(pUrl->urlSecondary));
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(pout, curLevel + 1);
pout->outstring_eol(pszParam);
}
pUrl = NextUrlEntry(pUrl);
}
if (pSiteMapEntry->iFrameName) {
wsprintf(pszParam, txtStringParam, txtParamFrame,
GetName(pSiteMapEntry->iFrameName));
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(pout, curLevel + 1);
pout->outstring_eol(pszParam);
}
if (pSiteMapEntry->iWindowName) {
wsprintf(pszParam, txtStringParam, txtParamWindow,
GetName(pSiteMapEntry->iWindowName));
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(pout, curLevel + 1);
pout->outstring_eol(pszParam);
}
if (pSiteMapEntry->pszComment) {
wsprintf(pszParam, txtStringParam, txtParamComment, pSiteMapEntry->pszComment);
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(pout, curLevel + 1);
pout->outstring_eol(pszParam);
}
if (pSiteMapEntry->fNew) {
wsprintf(pszParam, txtDecimalParam, txtParamNew, 1);
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(pout, curLevel + 1);
pout->outstring_eol(pszParam);
}
if (pSiteMapEntry->iImage) {
wsprintf(pszParam, txtDecimalParam, txtParamImageNumber,
pSiteMapEntry->iImage);
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(pout, curLevel + 1);
pout->outstring_eol(pszParam);
}
if (pSiteMapEntry->fNoDisplay) {
wsprintf(pszParam, txtStringParam, txtParamDisplay, txtNo);
ASSERT(strlen(pszParam) < MAX_PARAM);
PadOutput(pout, curLevel + 1);
pout->outstring_eol(pszParam);
}
}
#endif // HHCTRL
Reference in New Issue View Git Blame Copy Permalink