1120 lines
38 KiB
C++
1120 lines
38 KiB
C++
|
|
// This module is for reading binary files out of a compiled HTML file
|
|
|
|
#include "header.h"
|
|
#include "system.h"
|
|
#include "htmlhelp.h"
|
|
#include "strtable.h"
|
|
#include "fts.h"
|
|
#include "TCHAR.h"
|
|
#include "parserhh.h"
|
|
#include "collect.h"
|
|
#include "hhtypes.h"
|
|
#include "toc.h"
|
|
|
|
#include "secwin.h" // Only included for SetWinType....
|
|
|
|
enum {
|
|
TYPE_STRINGS,
|
|
TYPE_URLS,
|
|
};
|
|
|
|
#include "sysnames.h"
|
|
|
|
CHmData** g_phmData;
|
|
BOOL AddTitleToGlobalList(PCSTR pszITSSFile);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Darwin Stuff
|
|
//
|
|
|
|
// REVIEW: These must be tied to the calling process. If we ever support
|
|
// multiple processes in a single OCX, this will break big time.
|
|
|
|
PSTR g_pszDarwinGuid;
|
|
PSTR g_pszDarwinBackupGuid;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// CTitleInformation - read in the title informaton file (#SYSTEM) settings for each title
|
|
//
|
|
|
|
#ifndef SEEK_SET
|
|
#define SEEK_CUR 1
|
|
#define SEEK_END 2
|
|
#define SEEK_SET 0
|
|
#endif
|
|
|
|
unsigned short CharsetFromLangID(unsigned short uLangID)
|
|
{
|
|
unsigned short uCharset;
|
|
|
|
switch (uLangID)
|
|
{
|
|
case LANG_RUSSIAN: uCharset = RUSSIAN_CHARSET; break;
|
|
case LANG_ENGLISH: uCharset = ANSI_CHARSET; break;
|
|
case LANG_JAPANESE: uCharset = SHIFTJIS_CHARSET; break;
|
|
case LANG_KOREAN: uCharset = HANGEUL_CHARSET; break;
|
|
case LANG_ARABIC: uCharset = ARABIC_CHARSET; break;
|
|
case LANG_GREEK: uCharset = GREEK_CHARSET; break;
|
|
case LANG_THAI: uCharset = THAI_CHARSET; break;
|
|
case LANG_HEBREW: uCharset = HEBREW_CHARSET; break;
|
|
case LANG_TURKISH: uCharset = TURKISH_CHARSET; break;
|
|
case LANG_VIETNAMESE: uCharset = VIETNAMESE_CHARSET; break;
|
|
|
|
case LANG_CHINESE:
|
|
if ( (SUBLANGID(uLangID) == SUBLANG_CHINESE_TRADITIONAL) || (SUBLANGID(uLangID) == SUBLANG_CHINESE_HONGKONG) )
|
|
uCharset = CHINESEBIG5_CHARSET;
|
|
else
|
|
uCharset = GB2312_CHARSET;
|
|
break;
|
|
|
|
default:
|
|
uCharset = DEFAULT_CHARSET;
|
|
}
|
|
return uCharset;
|
|
}
|
|
|
|
CTitleInformation::CTitleInformation( CFileSystem* pFileSystem )
|
|
{
|
|
ClearMemory( this, sizeof( CTitleInformation ) );
|
|
m_pFileSystem = pFileSystem;
|
|
m_iCharset = -1;
|
|
}
|
|
|
|
CTitleInformation::~CTitleInformation()
|
|
{
|
|
if (m_pszCompilerVersion)
|
|
lcFree (m_pszCompilerVersion); // leak fix
|
|
|
|
CHECK_AND_FREE( m_pszDefToc );
|
|
CHECK_AND_FREE( m_pszDefIndex );
|
|
CHECK_AND_FREE( m_pszDefHtml );
|
|
CHECK_AND_FREE( m_pszDefCaption );
|
|
CHECK_AND_FREE( m_pszDefWindow );
|
|
CHECK_AND_FREE( m_pszShortName );
|
|
|
|
if( m_pdInfoTypes )
|
|
lcFree(m_pdInfoTypes );
|
|
if (m_paExtTabs) {
|
|
for (DWORD i = 0; i < m_cExtTabs; i++) {
|
|
lcFree(m_paExtTabs[i].pszTabName);
|
|
lcFree(m_paExtTabs[i].pszProgId);
|
|
}
|
|
lcFree(m_paExtTabs);
|
|
}
|
|
if ( m_hFontAccessableContent && (m_hFontAccessableContent != m_hFont) )
|
|
DeleteObject(m_hFontAccessableContent);
|
|
|
|
if (m_hFont)
|
|
DeleteObject(m_hFont);
|
|
}
|
|
|
|
HRESULT CTitleInformation::Initialize()
|
|
{
|
|
if( !m_pFileSystem )
|
|
return S_FALSE;
|
|
|
|
// open the title information file (#SYSTEM)
|
|
CSubFileSystem* pSubFileSystem = new CSubFileSystem(m_pFileSystem);
|
|
HRESULT hr = pSubFileSystem->OpenSub(txtSystemFile);
|
|
if( FAILED(hr))
|
|
return S_FALSE;
|
|
|
|
// check the version of the title information file (#SYSTEM)
|
|
|
|
DWORD dwVersion;
|
|
DWORD cbRead;
|
|
hr = pSubFileSystem->ReadSub(&dwVersion, sizeof(dwVersion), &cbRead);
|
|
if( FAILED(hr) || cbRead != sizeof(dwVersion) ) {
|
|
delete pSubFileSystem;
|
|
return STG_E_READFAULT;
|
|
}
|
|
if( dwVersion > VERSION_SYSTEM ) {
|
|
// BUGBUG: This will fail if we allow more then one process to attach
|
|
// to us -- meaning we won't put up a warning for each process
|
|
|
|
static BOOL fWarned = FALSE;
|
|
if (!fWarned) {
|
|
MsgBox(IDS_NEWER_VERSION);
|
|
fWarned = TRUE;
|
|
}
|
|
return STG_E_OLDDLL;
|
|
}
|
|
|
|
// read in each and every item (skip those tags we don't care about)
|
|
|
|
SYSTEM_TAG tag;
|
|
for(;;) {
|
|
|
|
// get the tag type
|
|
|
|
hr = pSubFileSystem->ReadSub(&tag, sizeof(SYSTEM_TAG), &cbRead);
|
|
if( FAILED(hr) || cbRead != sizeof(SYSTEM_TAG))
|
|
break;
|
|
|
|
// handle each tag according to it's type
|
|
|
|
switch( tag.tag ) {
|
|
|
|
// where all of our simple settings are stored
|
|
|
|
case TAG_SYSTEM_FLAGS: {
|
|
ZERO_STRUCTURE( m_Settings );
|
|
DWORD cbSettings = sizeof(m_Settings);
|
|
DWORD cbTag = tag.cbTag;
|
|
DWORD cbReadIn = 0;
|
|
if( cbTag > cbSettings )
|
|
cbReadIn = cbSettings;
|
|
else
|
|
cbReadIn = cbTag;
|
|
hr = pSubFileSystem->ReadSub( &m_Settings, cbReadIn, &cbRead );
|
|
if( cbTag > cbSettings )
|
|
hr = pSubFileSystem->SeekSub( cbTag-cbSettings, SEEK_CUR );
|
|
break;
|
|
}
|
|
|
|
// where the short name of the title is stored
|
|
|
|
case TAG_SHORT_NAME:
|
|
m_pszShortName = (PCSTR) lcMalloc(tag.cbTag);
|
|
hr = pSubFileSystem->ReadSub((void*) m_pszShortName, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
case TAG_DEFAULT_TOC:
|
|
m_pszDefToc = (PCSTR) lcMalloc(tag.cbTag);
|
|
hr = pSubFileSystem->ReadSub((void*) m_pszDefToc, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
case TAG_DEFAULT_INDEX:
|
|
m_pszDefIndex = (PCSTR) lcMalloc(tag.cbTag);
|
|
hr = pSubFileSystem->ReadSub((void*) m_pszDefIndex, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
case TAG_DEFAULT_HTML:
|
|
m_pszDefHtml = (PCSTR) lcMalloc(tag.cbTag);
|
|
hr = pSubFileSystem->ReadSub((void*) m_pszDefHtml, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
case TAG_DEFAULT_CAPTION:
|
|
m_pszDefCaption = (PCSTR) lcMalloc(tag.cbTag);
|
|
hr = pSubFileSystem->ReadSub((void*) m_pszDefCaption, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
case TAG_DEFAULT_WINDOW:
|
|
m_pszDefWindow = (PCSTR) lcMalloc(tag.cbTag);
|
|
hr = pSubFileSystem->ReadSub((void*) m_pszDefWindow, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
case TAG_HASH_BINARY_TOC:
|
|
hr = pSubFileSystem->ReadSub((void*) &m_hashBinaryTocName, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
case TAG_HASH_BINARY_INDEX:
|
|
hr = pSubFileSystem->ReadSub((void*) &m_hashBinaryIndexName, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
case TAG_INFO_TYPES:
|
|
ASSERT(!m_pdInfoTypes);
|
|
m_pdInfoTypes = (INFOTYPE_DATA*) lcMalloc(tag.cbTag);
|
|
hr = pSubFileSystem->ReadSub((void*) m_pdInfoTypes, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
case TAG_COMPILER_VERSION:
|
|
m_pszCompilerVersion = (PCSTR) lcMalloc(tag.cbTag);
|
|
hr = pSubFileSystem->ReadSub((void*) m_pszCompilerVersion, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
case TAG_INFOTYPE_COUNT:
|
|
hr = pSubFileSystem->ReadSub((void*)&m_iCntInfoTypes, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
case TAG_IDXHEADER:
|
|
hr = pSubFileSystem->ReadSub((void*)&m_idxhdr, tag.cbTag, &cbRead);
|
|
m_bGotHeader = TRUE;
|
|
break;
|
|
|
|
case TAG_EXT_TABS:
|
|
{
|
|
ASSERT_COMMENT(!m_ptblExtTabs, "TAG_EXT_TABS appears in the system file twice.");
|
|
hr = pSubFileSystem->ReadSub((void*) &m_cExtTabs, sizeof(DWORD), &cbRead);
|
|
CMem mem(tag.cbTag);
|
|
hr = pSubFileSystem->ReadSub((void*) mem.pb,
|
|
tag.cbTag - sizeof(DWORD), &cbRead);
|
|
PCSTR psz = (PCSTR) mem.pb;
|
|
m_paExtTabs = (EXTENSIBLE_TAB*) lcMalloc(m_cExtTabs * sizeof(EXTENSIBLE_TAB));
|
|
for (DWORD iTab = 0; iTab < m_cExtTabs; iTab++) {
|
|
m_paExtTabs[iTab].pszTabName = lcStrDup(psz);
|
|
psz += strlen(psz) + 1;
|
|
m_paExtTabs[iTab].pszProgId = lcStrDup(psz);
|
|
psz += strlen(psz) + 1;
|
|
|
|
//--- Add the accelerator to the global accelerator list.
|
|
char* p = strchr(m_paExtTabs[iTab].pszTabName , '&') ;
|
|
if (p != NULL)
|
|
{
|
|
_Resource.TabCtrlKeys(HH_TAB_CUSTOM_FIRST + iTab, tolower(*(p+1))) ;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TAG_DEFAULT_FONT:
|
|
m_pszDefaultFont = (PCSTR) lcMalloc(tag.cbTag);
|
|
hr = pSubFileSystem->ReadSub((void*) m_pszDefaultFont, tag.cbTag, &cbRead);
|
|
ASSERT_COMMENT(!m_hFont, "Compiler should never allow two font tags");
|
|
m_hFont = (HFONT)1; // just to say we've been here before...
|
|
break;
|
|
|
|
case TAG_NEVER_PROMPT_ON_MERGE:
|
|
hr = pSubFileSystem->ReadSub( (void*) &m_bNeverPromptOnMerge, tag.cbTag, &cbRead);
|
|
break;
|
|
|
|
|
|
// skip those we don't care about or don't know about
|
|
|
|
default:
|
|
hr = pSubFileSystem->SeekSub( tag.cbTag, SEEK_CUR );
|
|
break;
|
|
|
|
}
|
|
|
|
if( FAILED(hr) ) {
|
|
delete pSubFileSystem;
|
|
return STG_E_READFAULT;
|
|
}
|
|
}
|
|
delete pSubFileSystem;
|
|
//
|
|
// Init title charset.
|
|
//
|
|
unsigned short uLangID = PRIMARYLANGID(LANGIDFROMLCID(m_Settings.lcid));
|
|
m_iCharset = CharsetFromLangID(uLangID);
|
|
//
|
|
// Init the title font...
|
|
//
|
|
_Module.SetCodePage(CodePageFromLCID(m_Settings.lcid));
|
|
#ifndef CHIINDEX
|
|
InitContentFont(m_pszDefaultFont);
|
|
#endif
|
|
m_bInit = TRUE;
|
|
return S_OK;
|
|
}
|
|
|
|
void CTitleInformation::InitContentFont(PCSTR pszFontSpec)
|
|
{
|
|
TCHAR szLocal[MAX_PATH];
|
|
PSTR pszComma;
|
|
LOGFONT lf;
|
|
NONCLIENTMETRICS ncm;
|
|
|
|
//
|
|
// We're only going to trust the charset specification if it came from the title!
|
|
//
|
|
if ( !pszFontSpec || !(*pszFontSpec) )
|
|
{
|
|
// if Win9X on Japaneese system. AsPer Achimru Bug# 7012
|
|
//
|
|
if ( (GetVersion() >= 0x80000000) && ( (_Module.m_Language.GetUiLanguage() & 0x00FF) == LANG_JAPANESE) )
|
|
pszFontSpec = "MS P Gothic,9,128";
|
|
else
|
|
{
|
|
#ifndef HHUTIL
|
|
pszFontSpec = (PSTR)GetStringResource(IDS_DEFAULT_CONTENT_FONT);
|
|
#endif
|
|
// HH bugs 7859 and 7707:
|
|
//
|
|
// It turns out that on Win9x, using DEFAULT_CHARSET means I don't care about the char set. Soooo, the
|
|
// last thing we want to do is use a blank facename with default charset on Win9x. On NT, default_charset
|
|
// has a reasonable meaning, i.e. use an appropiate charset based on system locale. So, to fix the above
|
|
// bugs, I'm only going to execute this logic on NT. <mc>
|
|
//
|
|
if( g_fSysWinNT )
|
|
{
|
|
// lang != english AND the resID charset does NOT match the .CHM charset then use a blank facename
|
|
// but retain the pointsize specified in the resource string.
|
|
//
|
|
char* pszFS = StrChr(pszFontSpec, ',');
|
|
int iCharSet = Atoi(pszFontSpec + 1);
|
|
if ( pszFontSpec && ((m_iCharset != ANSI_CHARSET) || (m_iCharset != DEFAULT_CHARSET)) && (iCharSet != m_iCharset) )
|
|
pszFontSpec = pszFS;
|
|
}
|
|
}
|
|
|
|
if ( !pszFontSpec )
|
|
{
|
|
// nothing specified in the .res file. Go with hardcoded defaults?
|
|
//
|
|
lstrcpy(szLocal, "MS Shell Dlg,8");
|
|
}
|
|
else
|
|
lstrcpy(szLocal, pszFontSpec);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We have a specification from the .HHP file, insure it matches the LCID specified in the .HHP
|
|
// The specification string is formatted as followes:
|
|
// Facename, point size, charset, (BOLD | ITALIC | UNDERLINE) | 0x???? colorspec | #rrggbb colorspec
|
|
//
|
|
// We'll override the charset selected from the title LCID if we have a valid one specified in the title font.
|
|
//
|
|
lstrcpy(szLocal, pszFontSpec);
|
|
if ( (pszComma = StrChr(szLocal, ',')) )
|
|
{
|
|
pszComma++;
|
|
if ( (pszComma = StrChr(pszComma, ',')) )
|
|
{
|
|
pszComma++;
|
|
m_iCharset = atoi(pszComma);
|
|
}
|
|
}
|
|
}
|
|
// We (Doug and Mikecole) have decided to override the ANSI charset (english) with the current user charset
|
|
// in the event we find we're viweing an english chm on a non englist system on Win9X...
|
|
//
|
|
if ( (m_iCharset == ANSI_CHARSET) )
|
|
{
|
|
LANGID lid = _Module.m_Language.GetUiLanguage();
|
|
m_iCharset = CharsetFromLangID(lid);
|
|
}
|
|
|
|
if(g_fSysWinNT)
|
|
{
|
|
char wchLocale[10];
|
|
|
|
// Check to see if the system understands the LCID of the title. If not, we have no way of
|
|
// accurately processing the text in szLocal (it's in an encoding the OS doesn't understand).
|
|
// The only safe thing we can do is to default to MS Shell Dlg and hope for the best.
|
|
//
|
|
if (!GetLocaleInfoA(m_Settings.lcid, LOCALE_IDEFAULTANSICODEPAGE, wchLocale, sizeof(wchLocale)))
|
|
lstrcpy(szLocal, "MS Shell Dlg,8");
|
|
|
|
WCHAR *pwcLocal = MakeWideStr(szLocal,CodePageFromLCID(m_Settings.lcid));
|
|
if(pwcLocal)
|
|
{
|
|
m_hFont = CreateUserFontW(pwcLocal, NULL, NULL, m_iCharset);
|
|
free(pwcLocal);
|
|
}
|
|
}
|
|
else
|
|
m_hFont = CreateUserFont(szLocal, NULL, NULL, m_iCharset);
|
|
|
|
ASSERT(m_hFont);
|
|
BOOL bRet1 = GetObject(m_hFont, sizeof(lf), &lf) ;
|
|
ncm.cbSize = sizeof(NONCLIENTMETRICS);
|
|
BOOL bRet2 = SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), (void*)&ncm, 0);
|
|
if ( bRet1 && bRet2 && (ncm.lfMenuFont.lfHeight < lf.lfHeight) )
|
|
{
|
|
lf.lfHeight = ncm.lfMenuFont.lfHeight;
|
|
m_hFontAccessableContent = CreateFontIndirect(&lf);
|
|
}
|
|
else
|
|
m_hFontAccessableContent = m_hFont;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// CTitleInformation2 - get title informaton without going through the file system
|
|
//
|
|
|
|
CTitleInformation2::CTitleInformation2( LPCTSTR pszPathName )
|
|
{
|
|
ClearMemory( this, sizeof(CTitleInformation2) );
|
|
m_pszPathName = pszPathName;
|
|
}
|
|
|
|
CTitleInformation2::~CTitleInformation2()
|
|
{
|
|
if( m_pszShortName )
|
|
delete [] (PSTR) m_pszShortName;
|
|
}
|
|
|
|
HRESULT CTitleInformation2::Initialize()
|
|
{
|
|
HANDLE hFile = CreateFile( m_pszPathName, GENERIC_READ, FILE_SHARE_READ,
|
|
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL );
|
|
|
|
if( hFile == INVALID_HANDLE_VALUE )
|
|
return S_FALSE;
|
|
|
|
DWORD dwFileStamp = 0;
|
|
LCID FileLocale = 0;
|
|
DWORD dwRead = 0;
|
|
|
|
SetFilePointer( hFile, 4*sizeof(UINT), NULL, FILE_BEGIN );
|
|
ReadFile( hFile, (void*) &dwFileStamp, sizeof( dwFileStamp ), &dwRead, NULL );
|
|
ReadFile( hFile, (void*) &FileLocale, sizeof( FileLocale ), &dwRead, NULL );
|
|
CloseHandle( hFile );
|
|
|
|
m_FileTime.dwLowDateTime = dwFileStamp;
|
|
m_FileTime.dwHighDateTime = dwFileStamp;
|
|
m_lcid = FileLocale;
|
|
|
|
TCHAR szShortName[MAX_PATH];
|
|
LPTSTR pszShortName = szShortName;
|
|
|
|
GetFullPathName( m_pszPathName, MAX_PATH, szShortName, &pszShortName );
|
|
LPTSTR pszShortNameEnd = StrRChr( pszShortName, '.' );
|
|
*pszShortNameEnd = 0;
|
|
|
|
m_pszShortName = new char[ strlen(pszShortName)+1 ];
|
|
strcpy( (PSTR) m_pszShortName, pszShortName );
|
|
|
|
m_bInit = TRUE;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// CHmData
|
|
//
|
|
#ifdef _WIN64
|
|
typedef struct tagHH_DISK_WINTYPE {
|
|
int cbStruct; // IN: size of this structure including all Information Types
|
|
BOOL fUniCodeStrings; // IN/OUT: TRUE if all strings are in UNICODE
|
|
DWORD /*LPCTSTR*/ pszType;// IN/OUT: Name of a type of window
|
|
DWORD fsValidMembers; // IN: Bit flag of valid members (HHWIN_PARAM_)
|
|
DWORD fsWinProperties; // IN/OUT: Properties/attributes of the window (HHWIN_)
|
|
|
|
DWORD /*LPCTSTR*/ pszCaption;// IN/OUT: Window title
|
|
DWORD dwStyles; // IN/OUT: Window styles
|
|
DWORD dwExStyles; // IN/OUT: Extended Window styles
|
|
RECT rcWindowPos; // IN: Starting position, OUT: current position
|
|
int nShowState; // IN: show state (e.g., SW_SHOW)
|
|
|
|
LONG /*HWND*/ hwndHelp; // OUT: window handle
|
|
LONG /*HWND*/ hwndCaller; // OUT: who called this window
|
|
|
|
DWORD /*HH_INFOTYPE* */ paInfoTypes; // IN: Pointer to an array of Information Types
|
|
|
|
// The following members are only valid if HHWIN_PROP_TRI_PANE is set
|
|
|
|
LONG /*HWND*/ hwndToolBar; // OUT: toolbar window in tri-pane window
|
|
LONG /*HWND*/ hwndNavigation; // OUT: navigation window in tri-pane window
|
|
LONG /*HWND*/ hwndHTML; // OUT: window displaying HTML in tri-pane window
|
|
int iNavWidth; // IN/OUT: width of navigation window
|
|
RECT rcHTML; // OUT: HTML window coordinates
|
|
|
|
DWORD /*LPCTSTR*/ pszToc; // IN: Location of the table of contents file
|
|
DWORD /*LPCTSTR*/ pszIndex; // IN: Location of the index file
|
|
DWORD /*LPCTSTR*/ pszFile; // IN: Default location of the html file
|
|
DWORD /*LPCTSTR*/ pszHome; // IN/OUT: html file to display when Home button is clicked
|
|
DWORD fsToolBarFlags; // IN: flags controling the appearance of the toolbar
|
|
BOOL fNotExpanded; // IN: TRUE/FALSE to contract or expand, OUT: current state
|
|
int curNavType; // IN/OUT: UI to display in the navigational pane
|
|
int tabpos; // IN/OUT: HHWIN_NAVTAB_TOP, HHWIN_NAVTAB_LEFT, or HHWIN_NAVTAB_BOTTOM
|
|
int idNotify; // IN: ID to use for WM_NOTIFY messages
|
|
BYTE tabOrder[HH_MAX_TABS + 1]; // IN/OUT: tab order: Contents, Index, Search, History, Favorites, Reserved 1-5, Custom tabs
|
|
int cHistory; // IN/OUT: number of history items to keep (default is 30)
|
|
DWORD /*LPCTSTR*/ pszJump1; // Text for HHWIN_BUTTON_JUMP1
|
|
DWORD /*LPCTSTR*/ pszJump2; // Text for HHWIN_BUTTON_JUMP2
|
|
DWORD /*LPCTSTR*/ pszUrlJump1; // URL for HHWIN_BUTTON_JUMP1
|
|
DWORD /*LPCTSTR*/ pszUrlJump2; // URL for HHWIN_BUTTON_JUMP2
|
|
RECT rcMinSize; // Minimum size for window (ignored in version 1)
|
|
int cbInfoTypes; // size of paInfoTypes;
|
|
DWORD /*LPCTSTR*/ pszCustomTabs; // multiple zero-terminated strings
|
|
} HH_DISK_WINTYPE, *PHH_DISK_WINTYPE;
|
|
|
|
static
|
|
void ConvertToWin64HHWinType( HH_WINTYPE& rWinType , const HH_DISK_WINTYPE& rDiskWinType )
|
|
{
|
|
rWinType.cbStruct = sizeof(HH_WINTYPE); // ???
|
|
rWinType.fUniCodeStrings = rDiskWinType.fUniCodeStrings;
|
|
// LPCTSTR pszType; // IN/OUT: Name of a type of window
|
|
rWinType.fsValidMembers = rDiskWinType.fsValidMembers;
|
|
rWinType.fsWinProperties = rDiskWinType.fsWinProperties;
|
|
|
|
// LPCTSTR pszCaption; // IN/OUT: Window title
|
|
rWinType.dwStyles = rDiskWinType.dwStyles;
|
|
rWinType.dwExStyles = rDiskWinType.dwExStyles;
|
|
CopyRect( &rWinType.rcWindowPos, &rDiskWinType.rcWindowPos );
|
|
rWinType.nShowState = rDiskWinType.nShowState;
|
|
|
|
// HWND hwndHelp; // OUT: window handle
|
|
// HWND hwndCaller; // OUT: who called this window
|
|
|
|
// HH_INFOTYPE* paInfoTypes; // IN: Pointer to an array of Information Types
|
|
|
|
// HWND hwndToolBar; // OUT: toolbar window in tri-pane window
|
|
// HWND hwndNavigation; // OUT: navigation window in tri-pane window
|
|
// HWND hwndHTML; // OUT: window displaying HTML in tri-pane window
|
|
rWinType.iNavWidth = rDiskWinType.iNavWidth;
|
|
CopyRect( &rWinType.rcHTML, &rDiskWinType.rcHTML );
|
|
|
|
// LPCTSTR pszToc; // IN: Location of the table of contents file
|
|
// LPCTSTR pszIndex; // IN: Location of the index file
|
|
// LPCTSTR pszFile; // IN: Default location of the html file
|
|
// LPCTSTR pszHome; // IN/OUT: html file to display when Home button is clicked
|
|
rWinType.fsToolBarFlags = rDiskWinType.fsToolBarFlags;
|
|
rWinType.fNotExpanded = rDiskWinType.fNotExpanded;
|
|
rWinType.curNavType = rDiskWinType.curNavType;
|
|
rWinType.tabpos = rDiskWinType.tabpos;
|
|
rWinType.idNotify = rDiskWinType.idNotify;
|
|
memcpy( rWinType.tabOrder, rDiskWinType.tabOrder, sizeof(rWinType.tabOrder) );
|
|
rWinType.cHistory = rDiskWinType.cHistory;
|
|
// LPCTSTR pszJump1; // Text for HHWIN_BUTTON_JUMP1
|
|
// LPCTSTR pszJump2; // Text for HHWIN_BUTTON_JUMP2
|
|
// LPCTSTR pszUrlJump1; // URL for HHWIN_BUTTON_JUMP1
|
|
// LPCTSTR pszUrlJump2; // URL for HHWIN_BUTTON_JUMP2
|
|
CopyRect( &rWinType.rcMinSize, &rDiskWinType.rcMinSize );
|
|
rWinType.cbInfoTypes = rDiskWinType.cbInfoTypes;
|
|
// LPCTSTR pszCustomTabs; // multiple zero-terminated strings
|
|
}
|
|
#endif
|
|
|
|
|
|
CHmData::CHmData()
|
|
{
|
|
ClearMemory(this, sizeof(CHmData));
|
|
}
|
|
|
|
CHmData::~CHmData()
|
|
{
|
|
if( m_pszDefToc )
|
|
lcFree( m_pszDefToc );
|
|
|
|
if( m_pszDefIndex )
|
|
lcFree( m_pszDefIndex );
|
|
|
|
if (m_pTitleCollection)
|
|
delete m_pTitleCollection;
|
|
|
|
if (m_pdSubSets)
|
|
lcFree(m_pdSubSets);
|
|
|
|
if (m_pszITSSFile)
|
|
lcFree(m_pszITSSFile);
|
|
|
|
}
|
|
|
|
int CHmData::Release(void)
|
|
{
|
|
if ( cRef )
|
|
cRef--;
|
|
if (! cRef )
|
|
{
|
|
delete this;
|
|
return 0;
|
|
}
|
|
else
|
|
return cRef;
|
|
}
|
|
|
|
HFONT CHmData::GetContentFont()
|
|
{
|
|
return (m_pTitleCollection->GetMasterTitle()->GetInfo()->GetContentFont());
|
|
}
|
|
|
|
// BUGBUG: This is broken! We cannot pass in any random offset and use GetFirstTitle() to fetch a string. <mc>
|
|
|
|
PCSTR CHmData::GetString(DWORD offset)
|
|
{
|
|
ASSERT(m_pTitleCollection);
|
|
ASSERT(m_pTitleCollection->GetFirstTitle());
|
|
ASSERT(m_pTitleCollection->GetFirstTitle()->GetString(offset));
|
|
return m_pTitleCollection->GetFirstTitle()->GetString(offset);
|
|
}
|
|
|
|
CExTitle* CHmData::GetExTitle(void)
|
|
{
|
|
ASSERT(m_pTitleCollection);
|
|
ASSERT(m_pTitleCollection->GetFirstTitle());
|
|
return m_pTitleCollection->GetFirstTitle();
|
|
}
|
|
|
|
BOOL CHmData::ReadSubSets( CExTitle *pTitle )
|
|
{
|
|
ULONG cbRead;
|
|
HRESULT hr;
|
|
SYSTEM_TAG tag;
|
|
|
|
CFSClient fsclient(pTitle->GetFileSystem(), txtSubSetFile);
|
|
if (!fsclient.isStreamOpen())
|
|
return TRUE;
|
|
hr = fsclient.Read(&tag, sizeof(SYSTEM_TAG), &cbRead);
|
|
if (FAILED(hr) || cbRead != sizeof(SYSTEM_TAG))
|
|
{
|
|
fsclient.CloseStream();
|
|
return STG_E_READFAULT;
|
|
}
|
|
m_pdSubSets = (SUBSET_DATA *)lcMalloc(tag.cbTag);
|
|
hr = fsclient.Read(m_pdSubSets, tag.cbTag, &cbRead);
|
|
if (FAILED(hr) || cbRead != tag.cbTag)
|
|
{
|
|
fsclient.CloseStream();
|
|
return STG_E_READFAULT;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
BOOL CHmData::ReadSystemFiles(PCSTR pszITSSFile)
|
|
{
|
|
TCHAR szScratch[MAX_PATH];
|
|
m_pTitleCollection = new CExCollection(this, pszITSSFile, !IsCollectionFile(pszITSSFile));
|
|
if (m_pTitleCollection->InitCollection() == FALSE)
|
|
return FALSE;
|
|
|
|
CTitleInformation *pInfo = m_pTitleCollection->GetMasterTitle()->GetInfo();
|
|
LANGID MasterLangId;
|
|
|
|
if (pInfo)
|
|
MasterLangId = LANGIDFROMLCID(pInfo->GetLanguage());
|
|
else
|
|
return FALSE;
|
|
//
|
|
// Determine if we are running a bidi title or collection
|
|
//
|
|
// This is the place where we turn on/off bi-di settings for the help system
|
|
//
|
|
if(PRIMARYLANGID(MasterLangId) == LANG_HEBREW || PRIMARYLANGID(MasterLangId) == LANG_ARABIC)
|
|
{
|
|
g_fuBiDiMessageBox = MB_RIGHT | MB_RTLREADING;
|
|
|
|
// Turn on the Bi-Di "Mirroring" style when running on Bi-Di system and Win98 or NT5
|
|
//
|
|
if(g_bWinNT5 || g_bWin98)
|
|
{
|
|
// MessageBox(NULL,"Bidi Enabled NT5/Win98","Notice",MB_OK);
|
|
g_RTL_Mirror_Style = WS_EX_LAYOUT_RTL | WS_EX_LTRREADING | WS_EX_RIGHT;
|
|
g_RTL_Style = WS_EX_RTLREADING | WS_EX_RIGHT;
|
|
}
|
|
else
|
|
{
|
|
// MessageBox(NULL,"Bidi Under NT4/Win95","Notice",MB_OK);
|
|
g_RTL_Mirror_Style = 0;
|
|
g_RTL_Style = WS_EX_RTLREADING | WS_EX_RIGHT;
|
|
}
|
|
|
|
g_fBiDi = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// MessageBox(NULL,"Bidi Not Enabled","Notice",MB_OK);
|
|
g_fuBiDiMessageBox = 0;
|
|
g_RTL_Style = 0;
|
|
g_fBiDi = FALSE;
|
|
}
|
|
|
|
CExTitle* pTitle = m_pTitleCollection->GetMasterTitle();
|
|
CStr cszCompiledFile(pTitle->GetIndexFileName());
|
|
if (ReadSystemFile(pTitle) == FALSE)
|
|
return FALSE;
|
|
m_pInfo = pTitle->GetInfo();
|
|
|
|
// init fts and keyword
|
|
m_pTitleCollection->InitFTSKeyword();
|
|
|
|
// init structural subsetting if appropiate.
|
|
//
|
|
m_pTitleCollection->InitStructuralSubsets();
|
|
|
|
// Read the SubSets
|
|
ReadSubSets ( pTitle ); //from the #SUBSETS subfile
|
|
|
|
// Init the Infotypes and predefined subsets objects from the master title...
|
|
if ( pTitle && pTitle->GetInfo() )
|
|
{
|
|
int iCntITBytes = ((pTitle->GetInfo()->GetInfoTypeCount() / 8) + 1);
|
|
|
|
if ( ( m_pTitleCollection->m_pSubSets = new CSubSets(iCntITBytes, this, FALSE)) )
|
|
m_pTitleCollection->m_pSubSets->CopyTo(this);
|
|
//
|
|
// Add "Entire Collection" to the list since all subset users (FTS, TOC and Index) use it.
|
|
//
|
|
CSubSet* pS = m_pTitleCollection->m_pSubSets->AddSubSet();
|
|
pS->m_bIsEntireCollection = TRUE;
|
|
pS->m_cszSubSetName = (PCSTR)GetStringResource(IDS_ADVSEARCH_SEARCHIN_ENTIRE);
|
|
memset(pS->m_pInclusive, 0xFF, pS->m_pIT->InfoTypeSize());
|
|
// Mask out all the hidden ITs from entire contents.
|
|
INFOTYPE HiddenIT;
|
|
for ( int i=0; i< pS->m_pIT->m_itTables.m_cITSize; i++)
|
|
{ HiddenIT = (*pS->m_pInclusive)+i & ~(*pS->m_pIT->m_itTables.m_pHidden)+i;
|
|
memcpy( &(*pS->m_pInclusive)+i, &HiddenIT, sizeof(INFOTYPE) ); // flip the Hidden bits in the filter mask
|
|
}
|
|
pS->m_bPredefined = TRUE;
|
|
//
|
|
// Restore persisted subset selections for FTS, Index anf TOC.
|
|
//
|
|
CState* pstate = m_pTitleCollection->GetState();
|
|
DWORD cb;
|
|
if ( SUCCEEDED(pstate->Open(g_szFTSKey,STGM_READ)) && SUCCEEDED(pstate->Read(szScratch,MAX_PATH,&cb)) && cb > 0 )
|
|
m_pTitleCollection->m_pSubSets->SetFTSMask(szScratch);
|
|
else
|
|
m_pTitleCollection->m_pSubSets->SetFTSMask(pS->m_cszSubSetName); // Entire Collection.
|
|
pstate->Close();
|
|
|
|
if ( SUCCEEDED(pstate->Open(g_szIndexKey,STGM_READ)) && SUCCEEDED(pstate->Read(szScratch,MAX_PATH,&cb)) && cb > 0 )
|
|
m_pTitleCollection->m_pSubSets->SetIndexMask(szScratch);
|
|
else
|
|
m_pTitleCollection->m_pSubSets->SetIndexMask(pS->m_cszSubSetName); // Entire Collection.
|
|
pstate->Close();
|
|
|
|
if ( SUCCEEDED(pstate->Open(g_szTOCKey,STGM_READ)) && SUCCEEDED(pstate->Read(szScratch,MAX_PATH,&cb)) && cb > 0 )
|
|
m_pTitleCollection->m_pSubSets->SetTocMask(szScratch, NULL);
|
|
else
|
|
m_pTitleCollection->m_pSubSets->SetTocMask(pS->m_cszSubSetName, NULL); // Entire Collection.
|
|
pstate->Close();
|
|
}
|
|
|
|
// Read all the window definitions
|
|
CFSClient fsclient(pTitle->GetFileSystem(), txtWindowsFile);
|
|
if (!fsclient.isStreamOpen())
|
|
return TRUE;
|
|
DWORD cWindows;
|
|
DWORD cbStruct;
|
|
ULONG cbRead;
|
|
CStr csz;
|
|
HRESULT hr = fsclient.Read(&cWindows, sizeof(DWORD), &cbRead);
|
|
if (FAILED(hr) || cbRead != sizeof(DWORD))
|
|
goto ForgetIt;
|
|
hr = fsclient.Read(&cbStruct, sizeof(DWORD), &cbRead);
|
|
if (FAILED(hr) || cbRead != sizeof(DWORD))
|
|
goto ForgetIt;
|
|
|
|
HH_WINTYPE hhWinType;
|
|
#ifdef _WIN64
|
|
HH_DISK_WINTYPE hhDiskWinType;
|
|
#else
|
|
#define hhDiskWinType hhWinType
|
|
#endif
|
|
|
|
DWORD i;
|
|
for (i = 0; i < cWindows; i++)
|
|
{
|
|
ZERO_STRUCTURE(hhWinType);
|
|
#ifdef _WIN64
|
|
ZERO_STRUCTURE(hhDiskWinType);
|
|
#endif
|
|
hr = fsclient.Read(&hhDiskWinType, cbStruct, &cbRead);
|
|
#ifdef _WIN64
|
|
ConvertToWin64HHWinType( hhWinType, hhDiskWinType );
|
|
#endif
|
|
if (FAILED(hr) || cbRead != cbStruct)
|
|
goto ForgetIt;
|
|
|
|
if (SUCCEEDED(m_pTitleCollection->GetFirstTitle()->GetString(
|
|
(DWORD) hhDiskWinType.pszType, &csz)))
|
|
csz.TransferPointer(&hhWinType.pszType);
|
|
if (SUCCEEDED(m_pTitleCollection->GetFirstTitle()->GetString(
|
|
(DWORD) hhDiskWinType.pszCaption, &csz)))
|
|
csz.TransferPointer(&hhWinType.pszCaption);
|
|
if (SUCCEEDED(m_pTitleCollection->GetFirstTitle()->GetString(
|
|
(DWORD) hhDiskWinType.pszJump1, &csz)))
|
|
csz.TransferPointer(&hhWinType.pszJump1);
|
|
if (SUCCEEDED(m_pTitleCollection->GetFirstTitle()->GetString(
|
|
(DWORD) hhDiskWinType.pszJump2, &csz)))
|
|
csz.TransferPointer(&hhWinType.pszJump2);
|
|
|
|
// BUGBUG: needs to match compiler which should be using URL store
|
|
|
|
if (SUCCEEDED(m_pTitleCollection->GetFirstTitle()->GetString((DWORD) hhDiskWinType.pszToc, &csz)))
|
|
{
|
|
if (csz.IsNonEmpty()) // BUGBUG: GetString should fail on Empty strings.
|
|
{
|
|
if (!m_pszDefToc)
|
|
m_pszDefToc = lcStrDup(csz.psz);
|
|
if (!stristr(csz, txtDoubleColonSep) &&
|
|
!stristr(csz, txtFileHeader) && !stristr(csz, txtHttpHeader)) {
|
|
cszCompiledFile = GetCompiledFile();
|
|
cszCompiledFile += txtSepBack;
|
|
cszCompiledFile += csz.psz;
|
|
cszCompiledFile.TransferPointer(&hhWinType.pszToc);
|
|
}
|
|
else
|
|
csz.TransferPointer(&hhWinType.pszToc);
|
|
}
|
|
}
|
|
if (SUCCEEDED(m_pTitleCollection->GetFirstTitle()->GetString((DWORD) hhDiskWinType.pszIndex, &csz)))
|
|
{
|
|
if (csz.IsNonEmpty()) // BUGBUG: GetString should fail on Empty strings.
|
|
{
|
|
if (!m_pszDefIndex)
|
|
m_pszDefIndex = lcStrDup(csz.psz);
|
|
if (!stristr(csz, txtDoubleColonSep) &&
|
|
!stristr(csz, txtFileHeader) && !stristr(csz, txtHttpHeader))
|
|
{
|
|
cszCompiledFile = GetCompiledFile();
|
|
cszCompiledFile += txtSepBack;
|
|
cszCompiledFile += csz.psz;
|
|
cszCompiledFile.TransferPointer(&hhWinType.pszIndex);
|
|
}
|
|
else
|
|
csz.TransferPointer(&hhWinType.pszIndex);
|
|
}
|
|
}
|
|
if (SUCCEEDED(m_pTitleCollection->GetFirstTitle()->GetString(
|
|
(DWORD) hhDiskWinType.pszFile, &csz))) {
|
|
#if 0
|
|
if (!stristr(csz, txtDoubleColonSep) &&
|
|
!stristr(csz, txtFileHeader) && !stristr(csz, txtHttpHeader)) {
|
|
cszCompiledFile = GetCompiledFile();
|
|
cszCompiledFile += txtSepBack;
|
|
cszCompiledFile += csz.psz;
|
|
cszCompiledFile.TransferPointer(&hhWinType.pszFile);
|
|
}
|
|
else
|
|
#endif
|
|
csz.TransferPointer(&hhWinType.pszFile);
|
|
}
|
|
if (SUCCEEDED(m_pTitleCollection->GetFirstTitle()->GetString(
|
|
(DWORD) hhDiskWinType.pszHome, &csz))) {
|
|
if (!stristr(csz, txtDoubleColonSep) &&
|
|
!stristr(csz, txtFileHeader) && !stristr(csz, txtHttpHeader)) {
|
|
cszCompiledFile = GetCompiledFile();
|
|
cszCompiledFile += txtSepBack;
|
|
cszCompiledFile += csz.psz;
|
|
cszCompiledFile.TransferPointer(&hhWinType.pszHome);
|
|
}
|
|
else
|
|
csz.TransferPointer(&hhWinType.pszHome);
|
|
}
|
|
if (SUCCEEDED(m_pTitleCollection->GetFirstTitle()->GetString(
|
|
(DWORD) hhDiskWinType.pszUrlJump1, &csz))) {
|
|
if (!stristr(csz, txtDoubleColonSep) &&
|
|
!stristr(csz, txtFileHeader) && !stristr(csz, txtHttpHeader)) {
|
|
cszCompiledFile = GetCompiledFile();
|
|
cszCompiledFile += txtSepBack;
|
|
cszCompiledFile += csz.psz;
|
|
cszCompiledFile.TransferPointer(&hhWinType.pszUrlJump1);
|
|
}
|
|
else
|
|
csz.TransferPointer(&hhWinType.pszUrlJump1);
|
|
}
|
|
if (SUCCEEDED(m_pTitleCollection->GetFirstTitle()->GetString(
|
|
(DWORD) hhDiskWinType.pszUrlJump2, &csz))) {
|
|
if (!stristr(csz, txtDoubleColonSep) &&
|
|
!stristr(csz, txtFileHeader) && !stristr(csz, txtHttpHeader)) {
|
|
cszCompiledFile = GetCompiledFile();
|
|
cszCompiledFile += txtSepBack;
|
|
cszCompiledFile += csz.psz;
|
|
cszCompiledFile.TransferPointer(&hhWinType.pszUrlJump2);
|
|
}
|
|
else
|
|
csz.TransferPointer(&hhWinType.pszUrlJump2);
|
|
}
|
|
|
|
// Set the window type, but don't call FindCurFileData...
|
|
SetWinType(pszITSSFile, &hhWinType, this);
|
|
|
|
CHECK_AND_FREE(hhWinType.pszType) ;
|
|
CHECK_AND_FREE(hhWinType.pszCaption) ;
|
|
CHECK_AND_FREE(hhWinType.pszToc) ;
|
|
CHECK_AND_FREE(hhWinType.pszIndex) ;
|
|
CHECK_AND_FREE(hhWinType.pszFile) ;
|
|
CHECK_AND_FREE(hhWinType.pszHome) ;
|
|
CHECK_AND_FREE(hhWinType.pszJump1) ;
|
|
CHECK_AND_FREE(hhWinType.pszJump2) ;
|
|
CHECK_AND_FREE(hhWinType.pszUrlJump1) ;
|
|
CHECK_AND_FREE(hhWinType.pszUrlJump2) ;
|
|
|
|
}
|
|
#ifndef _WIN64
|
|
#undef hhDiskWinType
|
|
#endif
|
|
|
|
ForgetIt:
|
|
fsclient.CloseStream();
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CHmData::ReadSystemFile(CExTitle* pTitle)
|
|
{
|
|
ASSERT(pTitle);
|
|
|
|
CTitleInformation *pInfo = pTitle->GetInfo();
|
|
|
|
if (!pInfo)
|
|
return FALSE;
|
|
m_sysflags = pInfo->GetSystemFlags();
|
|
|
|
m_pszDefToc = lcStrDup( pInfo->GetDefaultToc() );
|
|
m_pszDefIndex = lcStrDup( pInfo->GetDefaultIndex() );
|
|
m_pszDefHtml = pInfo->GetDefaultHtml();
|
|
m_pszDefCaption = pInfo->GetDefaultCaption();
|
|
m_pszDefWindow = pInfo->GetDefaultWindow();
|
|
m_pszShortName = pInfo->GetShortName();
|
|
|
|
m_hashBinaryTocName = pInfo->GetBinaryTocNameHash();
|
|
m_hashBinaryIndexName = pInfo->GetBinaryIndexNameHash();
|
|
m_pdInfoTypes = pInfo->GetInfoTypeData();
|
|
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CHmData::PopulateUNICODETables( void )
|
|
{
|
|
if ( !m_ptblIT )
|
|
{
|
|
ASSERT(!m_ptblIT_Desc);
|
|
ASSERT(!m_ptblCat);
|
|
ASSERT(!m_ptblCat_Desc);
|
|
if ( !m_pInfoType )
|
|
{
|
|
m_pInfoType = new CInfoType();
|
|
m_pInfoType->CopyTo( this );
|
|
}
|
|
// populate the unicode CTables for Info Type and Catagory strings.
|
|
m_ptblIT = new CTable(16 * 1024 * 2);
|
|
m_ptblIT_Desc = new CTable(64 * 1024 * 2);
|
|
m_ptblCat = new CTable(16 * 1024 * 2);
|
|
m_ptblCat_Desc = new CTable(64 * 1024 * 2);
|
|
for ( int i=1; i <= m_pInfoType->HowManyInfoTypes(); i++ )
|
|
{
|
|
CWStr cwsz( (PCSTR)m_pInfoType->GetInfoTypeName(i) );
|
|
m_ptblIT->AddString( cwsz.pw );
|
|
cwsz = (PCSTR)m_pInfoType->GetInfoTypeDescription(i);
|
|
m_ptblIT_Desc->AddString( cwsz.pw );
|
|
}
|
|
for ( i=1; i <= m_pInfoType->HowManyCategories(); i++ )
|
|
{
|
|
CWStr cwsz( (PCSTR)m_pInfoType->GetCategoryString(i) );
|
|
m_ptblCat->AddString( cwsz.pw );
|
|
cwsz = (PCSTR)m_pInfoType->GetCategoryDescription(i);
|
|
m_ptblCat_Desc->AddString( cwsz.pw );
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
// CHmData Helper functions
|
|
//
|
|
|
|
void DeleteAllHmData()
|
|
{
|
|
for (int i = 0; i < g_cHmSlots; i++)
|
|
{
|
|
if (g_phmData[i])
|
|
{
|
|
CHmData* p = g_phmData[i];
|
|
g_phmData[i] = NULL;
|
|
delete p;
|
|
}
|
|
}
|
|
}
|
|
|
|
CHmData* FindCurFileData(PCSTR pszITSSFile)
|
|
{
|
|
CStr csz;
|
|
if (!FindThisFile(NULL, pszITSSFile, &csz, FALSE))
|
|
return NULL;
|
|
if (!g_phmData)
|
|
goto NeverSeen;
|
|
|
|
if (IsCollectionFile(csz))
|
|
{
|
|
// Check current system data first
|
|
|
|
if (g_phmData[g_curHmData] &&
|
|
g_phmData[g_curHmData]->m_pTitleCollection &&
|
|
lstrcmpi(csz, g_phmData[g_curHmData]->m_pTitleCollection->m_csFile) == 0) {
|
|
return g_phmData[g_curHmData];
|
|
}
|
|
|
|
// Not current, so check our cache
|
|
|
|
for (int i = 0; i < g_cHmSlots; i++) {
|
|
if (g_phmData[i] &&
|
|
g_phmData[i]->m_pTitleCollection &&
|
|
lstrcmpi(csz,g_phmData[i]->m_pTitleCollection->m_csFile) == 0) {
|
|
return g_phmData[i];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (g_phmData[g_curHmData] &&
|
|
lstrcmpi(csz, g_phmData[g_curHmData]->GetCompiledFile()) == 0) {
|
|
return g_phmData[g_curHmData];
|
|
}
|
|
|
|
// Not current, so check our cache
|
|
|
|
for (int i = 0; i < g_cHmSlots; i++) {
|
|
if (g_phmData[i] &&
|
|
lstrcmpi(csz, g_phmData[i]->GetCompiledFile()) == 0) {
|
|
return g_phmData[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
NeverSeen:
|
|
|
|
// If we get here, then either we haven't seen the file before, or it
|
|
// isn't cached.
|
|
|
|
if (!AddTitleToGlobalList(csz))
|
|
return NULL;
|
|
else
|
|
{
|
|
return g_phmData[g_curHmData];
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: AddTitleToGlobalList
|
|
|
|
PURPOSE: Read the various system files into memory
|
|
|
|
PARAMETERS:
|
|
pszITSSFile
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
|
|
MODIFICATION DATES:
|
|
30-Apr-1997 [ralphw]
|
|
03-Mar-1998 [dalero] no more process ids
|
|
|
|
***************************************************************************/
|
|
|
|
BOOL AddTitleToGlobalList(PCSTR pszITSSFile)
|
|
{
|
|
// HH BUG 2428
|
|
// Make sure that we can read the file in before we put it in the array.
|
|
|
|
if (IsFile(pszITSSFile) == FALSE)
|
|
return FALSE;
|
|
|
|
CHmData* pHmData = new CHmData;
|
|
|
|
BOOL bResult = pHmData->ReadSystemFiles(pszITSSFile);
|
|
if (!bResult)
|
|
{
|
|
// The ReadSystemFiles call failed. Cleanup and get out.
|
|
delete pHmData ;
|
|
}
|
|
else
|
|
{
|
|
// We have valid data. Get us a place to store it.
|
|
if (!g_phmData) {
|
|
g_cHmSlots = 5;
|
|
g_phmData = (CHmData**) lcCalloc(g_cHmSlots * sizeof(CHmData*));
|
|
for (int i = 0; i < g_cHmSlots; i++) // just in case
|
|
g_phmData[i] = NULL;
|
|
}
|
|
|
|
// Find an open slot to store the file data
|
|
|
|
for (int pos = 0; pos < g_cHmSlots; pos++) {
|
|
if (!g_phmData[pos])
|
|
break;
|
|
}
|
|
if (pos == g_cHmSlots) {
|
|
g_cHmSlots += 5;
|
|
g_phmData = (CHmData**) lcReAlloc(g_phmData, g_cHmSlots * sizeof(CHmData*));
|
|
for (int i = pos; i < g_cHmSlots; i++)
|
|
g_phmData[i] = NULL;
|
|
}
|
|
|
|
// Store the new data.
|
|
g_phmData[pos] = pHmData;
|
|
|
|
// Change the current global data pointer.
|
|
g_curHmData = pos ;
|
|
}
|
|
return bResult ;
|
|
}
|