mirror of https://github.com/tongzx/nt5src
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.
2717 lines
92 KiB
2717 lines
92 KiB
// 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
|