archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: 744f0b4006
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '744f0b4006'
${ noResults }
windows-xp/Source/XPSP1/NT/enduser/stuff/hhctrl/wwheel.cpp

1783 lines
52 KiB
Raw Blame History

// WWheel.cpp - HTML Help Word Wheel support
//
// Covers both KeywordLinks and AssociativeLinks
//
//
// needed for those pesky pre-compiled headers
#include "header.h"
#include "wwheel.h"
#include "animate.h"
#include "strtable.h"
#include "resource.h"
#include "util.h"
// memory leak checks
AUTO_CLASS_COUNT_CHECK(CTitleMapEntry);
AUTO_CLASS_COUNT_CHECK(CTitleMap);
AUTO_CLASS_COUNT_CHECK(CTitleDatabase);
AUTO_CLASS_COUNT_CHECK(CResultsEntry);
AUTO_CLASS_COUNT_CHECK(CResults);
AUTO_CLASS_COUNT_CHECK(CWordWheelEntry);
AUTO_CLASS_COUNT_CHECK(CWordWheel);
AUTO_CLASS_COUNT_CHECK(CWordWheelCompiler);
// taken from "hhsyssrt.h"
// {4662dab0-d393-11d0-9a56-00c04fb68b66}
// HACKHACK: I simply changed the last value of CLSID_ITSysSort from 0xf7 to 0x66
DEFINE_GUID(CLSID_HHSysSort,
0x4662dab0, 0xd393, 0x11d0, 0x9a, 0x56, 0x00, 0xc0, 0x4f, 0xb6, 0x8b, 0x66);
// old format
#define IHHSK666_KEYTYPE_ANSI_SZ ((DWORD) 66630) // NULL-term. MBCS string + extra data
#define IHHSK666_KEYTYPE_UNICODE_SZ ((DWORD) 66631) // NULL-term. Unicode string + extra data
#if 0
// New format
#define IHHSK100_KEYTYPE_ANSI_SZ ((DWORD) 10030) // NULL-term. MBCS string + extra data
#define IHHSK100_KEYTYPE_UNICODE_SZ ((DWORD) 10031) // NULL-term. Unicode string + extra data
#endif
#define IHHSK100_KEYTYPE_ANSI_SZ ((DWORD) 30) // NULL-term. MBCS string + extra data
#define IHHSK100_KEYTYPE_UNICODE_SZ ((DWORD) 31) // NULL-term. Unicode string + extra data
#ifdef _DEBUG
#undef THIS_FILE
static const char THIS_FILE[] = __FILE__;
#endif
// Global Variables
static const CHAR g_szKeywordLinks[] = "KeywordLinks";
static const CHAR g_szAssociativeLinks[] = "AssociativeLinks";
static const CHAR g_szTitleMap[] = "$HHTitleMap";
static const WCHAR g_wszKeywordLinks[] = L"KeywordLinks";
static const WCHAR g_wszAssociativeLinks[] = L"AssociativeLinks";
static const WCHAR g_wszTitleMap[] = L"$HHTitleMap";
static const WCHAR g_wszError[] = L"(ERROR)";
DWORD g_dwError = ((DWORD)-1);
/////////////////////////////////////////////////////////////////////////////
// helpful functions
static const CHAR g_szBusyFile[] = "HTMLHelpKeywordMergingBusy";
static HANDLE g_hFileBusy = NULL;
#define BUSY_FILE_SIZE 32
BOOL IsBusy()
{
BOOL bBusy = FALSE;
HANDLE hFileBusy = NULL;
SetLastError(0);
hFileBusy = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READONLY, 0, BUSY_FILE_SIZE, g_szBusyFile );
if( hFileBusy ) {
if( GetLastError() == ERROR_ALREADY_EXISTS )
bBusy = TRUE;
CloseHandle( hFileBusy );
}
return bBusy;
}
void SetBusy( BOOL bBusy )
{
if( bBusy ) {
if( !g_hFileBusy )
g_hFileBusy = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READONLY, 0, BUSY_FILE_SIZE, g_szBusyFile );
}
else {
if( g_hFileBusy ) {
CloseHandle( g_hFileBusy );
g_hFileBusy = NULL;
}
}
}
int FASTCALL CompareIds( const void* p1, const void* p2 )
{
int iReturn;
CTitleMapEntry* pEntry1= (CTitleMapEntry*) p1;
CTitleMapEntry* pEntry2= (CTitleMapEntry*) p2;
DWORD dwId1 = pEntry1->GetId();
DWORD dwId2 = pEntry2->GetId();
if( dwId1 < dwId2 )
iReturn = -1;
else if ( dwId1 > dwId2 )
iReturn = 1;
else
iReturn = 0;
return iReturn;
}
// check if a specified subfile exists in the specified title
BOOL IsSubFile( PCSTR pszTitlePathname, PCSTR pszSubFile )
{
BOOL bExists = FALSE;
if( pszTitlePathname && pszTitlePathname[0] && pszSubFile && pszSubFile[0] ) {
HRESULT hr = S_OK;
CFileSystem* pFS = new CFileSystem;
if( pFS && SUCCEEDED(hr = pFS->Init()) && SUCCEEDED(hr = pFS->Open( pszTitlePathname )) ) {
CSubFileSystem* pSFS = new CSubFileSystem( pFS );
if( pSFS && SUCCEEDED(pSFS->OpenSub(pszSubFile)) ) {
bExists = TRUE;
delete pSFS;
}
delete pFS;
}
}
return bExists;
}
/////////////////////////////////////////////////////////////////////////////
// class CTitleMap implementation
BOOL CTitleMap::Initialize()
{
// bail out if we are already initialized
if( m_bInit )
return TRUE;
// allocate a MBCS version of our file system pathname
CHAR* psz = NULL;
if( m_pszDatabase && *m_pszDatabase ) {
DWORD dwLen = (DWORD)strlen(m_pszDatabase) + 1;
psz = new char[dwLen];
strcpy(psz,m_pszDatabase);
}
m_pszDatabase = psz;
// set this bool first since we are going to call GetAt()
// which will make a reentrant call if this is not set--
// this would be bad!
m_bInit = TRUE;
// if we have a database, read in the data
if( m_pszDatabase ) {
HRESULT hr = S_OK;
// open the database and read in the subfile
CFileSystem* pDatabase = new CFileSystem;
if( SUCCEEDED(hr = pDatabase->Init()) && SUCCEEDED(hr = pDatabase->Open( GetDatabase() )) ) {
CSubFileSystem* pTitleMap = new CSubFileSystem( pDatabase );
if( SUCCEEDED(hr = pTitleMap->OpenSub( g_szTitleMap ) ) ) {
// format of TitleMap subfile is as follows:
//
// wCount (number of entries)
// wShortNameLen, sShortName, FILETIME, LCID
// ...line above repeated for each entry...
//
ULONG cbRead = 0;
WORD wCount = 0;
pTitleMap->ReadSub( (void*) &wCount, sizeof(wCount), &cbRead );
SetCount( (DWORD) wCount );
for( int iCount = 0; iCount < (int) wCount; iCount++ ) {
WORD wLen = 0;
char szShortName[256];
FILETIME FileTime;
LCID lcid;
pTitleMap->ReadSub( (void*) &wLen, sizeof(wLen), &cbRead );
pTitleMap->ReadSub( (void*) &szShortName, wLen, &cbRead );
szShortName[wLen] = 0;
ASSERT(cbRead != 0) ; // See HH Bug 2807 --- Saved a NULL shortname.
// This means that the CHM file associted with this
// topic probably doesn't exist. Tell the owner of the collection.
pTitleMap->ReadSub( (void*) &FileTime, sizeof(FileTime), &cbRead );
pTitleMap->ReadSub( (void*) &lcid, sizeof(lcid), &cbRead );
GetAt((DWORD)iCount)->SetId( iCount+1 );
GetAt((DWORD)iCount)->SetShortName( szShortName );
GetAt((DWORD)iCount)->SetFileTime( FileTime );
GetAt((DWORD)iCount)->SetLanguage( lcid );
}
}
delete pTitleMap;
}
delete pDatabase;
}
else
m_bInit = FALSE;
return m_bInit;
}
BOOL CTitleMap::Free()
{
if( m_pEntries ) {
delete [] m_pEntries;
m_pEntries = NULL;
m_dwCount = HHWW_ERROR;
}
if( m_pszDatabase ) {
delete [] (CHAR*) m_pszDatabase;
m_pszDatabase = NULL;
}
m_bInit = FALSE;
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// class CTitleDatabase implementation (Shared Centaur object)
void CTitleDatabase::_CTitleDatabase()
{
m_bInit = FALSE;
m_pDatabase = NULL;
m_pwszDatabase = NULL;
m_pszDatabase = NULL;
m_bCollection = FALSE;
m_pTitleMap = NULL;
m_pKeywordLinks = NULL;
m_pAssociativeLinks = NULL;
m_pCollection = NULL;
m_pTitle = NULL;
#ifdef CHIINDEX
m_bAnimation = TRUE; // display animation
#endif
}
CTitleDatabase::CTitleDatabase( CExCollection* pCollection )
{
_CTitleDatabase();
m_pCollection = pCollection;
}
CTitleDatabase::CTitleDatabase( CExTitle* pTitle )
{
_CTitleDatabase();
m_pTitle = pTitle;
}
CTitleDatabase::CTitleDatabase( const WCHAR* pwszDatabase )
{
_CTitleDatabase();
m_pwszDatabase = pwszDatabase;
}
CTitleDatabase::CTitleDatabase( const CHAR* pszDatabase )
{
_CTitleDatabase();
m_pszDatabase = pszDatabase;
}
CTitleDatabase::~CTitleDatabase()
{
Free();
}
BOOL CTitleDatabase::Initialize(CHAR *pszFileName)
{
BOOL bReturn = FALSE;
HRESULT hr = S_OK;
// bail out if we are already initialized
if( m_bInit )
return TRUE;
// bail out if collection or title not specified
if( !(m_pCollection || m_pTitle || m_pwszDatabase || m_pszDatabase ) )
return FALSE;
// set the hourglass cursor
CHourGlass HourGlass;
// get the database name
if( m_pCollection ) {
m_pTitle = m_pCollection->GetFirstTitle();
m_bCollection = ( m_pCollection && (m_pCollection->GetRefedTitleCount() > 1) );
if( m_bCollection )
m_pszDatabase = m_pCollection->GetLocalStoragePathname(".chw");
else
m_pszDatabase = m_pTitle->GetIndexFileName();
}
else if( m_pTitle ) {
m_pszDatabase = m_pTitle->GetIndexFileName();
}
if (pszFileName)
{
char drive[_MAX_PATH], dir[_MAX_PATH];
splitpath(m_pszDatabase, drive, dir, NULL, NULL);
if (drive[0] && drive[strlen(drive)-1] != '\\' && dir[0] != '\\')
strcat(drive, "\\");
strcat(drive, dir);
if (drive[strlen(drive)-1] != '\\' && pszFileName[0] != '\\')
strcat(drive, "\\");
strcat(drive, pszFileName);
strcpy(m_szFullPath, drive);
m_pszDatabase = m_szFullPath;
}
// allocate UNICODE and MBCS versions of our file system pathname
WCHAR* pwsz = NULL;
CHAR* psz = NULL;
if( m_pszDatabase && *m_pszDatabase ) {
DWORD dwLen = (DWORD)strlen(m_pszDatabase) + 1;
pwsz = new WCHAR[dwLen];
MultiByteToWideChar(CP_ACP, 0, m_pszDatabase, -1, pwsz, dwLen);
psz = new char[dwLen];
strcpy(psz,m_pszDatabase);
}
else if( m_pwszDatabase && *m_pwszDatabase ) {
DWORD dwLen = wcslen(m_pwszDatabase) + 1;
pwsz = new WCHAR[dwLen];
wcscpy(pwsz,m_pwszDatabase);
psz = new char[dwLen];
WideCharToMultiByte(CP_ACP, 0, m_pwszDatabase, -1, psz, dwLen, NULL, NULL);
}
m_pwszDatabase = pwsz;
m_pszDatabase = psz;
// bail out if file system pathname not specified
if( !m_pwszDatabase || !*m_pwszDatabase )
return FALSE;
// do a merge check
if( m_bCollection ) {
if( !MergeWordWheels() ) {
m_bCollection = FALSE;
m_pCollection = NULL;
Free();
return Initialize();
}
}
// get ITDatabase ptr.
if( SUCCEEDED(hr = CoCreateInstance(CLSID_IITDatabaseLocal, NULL, CLSCTX_INPROC_SERVER,
IID_IITDatabase, (void**)&m_pDatabase) ) ) {
// if the file exists then this is good enough to say we initialized it
if( IsFile( m_pszDatabase ) ) {
bReturn = TRUE;
// Open the database
if( SUCCEEDED(hr = m_pDatabase->Open(NULL, m_pwszDatabase, 0) ) ) {
bReturn = TRUE;
}
}
}
// create our word wheels
CTitleInformation* pInfo = NULL;
if( (m_pTitle && (pInfo = m_pTitle->GetInfo())) || !m_pTitle ) {
if( (m_pTitle && pInfo->IsKeywordLinks()) ||
(!m_pTitle && IsSubFile( m_pszDatabase, "$WWKeywordLinks\\Data" ) ) ) {
m_pKeywordLinks = new CWordWheel( this, g_szKeywordLinks );
}
if( (m_pTitle && pInfo->IsAssociativeLinks()) ||
(!m_pTitle && IsSubFile( m_pszDatabase, "$WWAssociativeLinks\\Data" ) ) ) {
m_pAssociativeLinks = new CWordWheel( this, g_szAssociativeLinks );
}
}
if( !bReturn ) {
Free();
m_bInit = FALSE;
}
else
m_bInit = TRUE;
return bReturn;
}
BOOL CTitleDatabase::Free()
{
BOOL bReturn = FALSE;
if( m_pTitleMap ) {
delete m_pTitleMap;
m_pTitleMap = NULL;
}
if( m_pKeywordLinks ) {
delete m_pKeywordLinks;
m_pKeywordLinks = NULL;
}
if( m_pAssociativeLinks ) {
delete m_pAssociativeLinks;
m_pAssociativeLinks = NULL;
}
if( m_pDatabase ) {
m_pDatabase->Close();
m_pDatabase->Release();
m_pDatabase = NULL;
}
if( m_pwszDatabase ) {
delete [] (WCHAR*) m_pwszDatabase;
m_pwszDatabase = NULL;
}
if( m_pszDatabase ) {
delete [] (CHAR*) m_pszDatabase;
m_pszDatabase = NULL;
}
m_bInit = FALSE;
bReturn = TRUE;
return bReturn;
}
BOOL CTitleDatabase::MergeWordWheels()
{
BOOL bReturn = FALSE;
#ifndef CHIINDEX
// get the application window
int iTry = 0;
HWND hWndApp = GetActiveWindow();
HWND hWndDesktop = GetDesktopWindow();
HWND hWnd = GetParent( hWndApp );
if( hWnd ) {
while( hWnd != hWndDesktop ) {
if( iTry++ == 16 ) {
hWndApp = GetActiveWindow();
if( !IsValidWindow( hWndApp ) )
hWndApp = NULL;
break;
}
hWndApp = hWnd;
hWnd = GetParent( hWndApp );
}
}
#endif
// start the animation
#ifndef CHIINDEX
if( !IsBusy() )
StartAnimation( IDS_CREATING_INDEX, hWndApp );
#endif
// if another merge is in progress then wait
// if we are currently busy then pretend to generate the file
#ifndef CHIINDEX
while( IsBusy() ) {
Sleep( 100 );
NextAnimation();
}
#endif
// set the busy state
SetBusy( TRUE );
// check if we need to merge or not
BOOL bMerge = CheckWordWheels();
// do the merge if necessary
if( bMerge ) {
#if 0 // MsgBox causes a reentrant problem--so don't do this!
if( !m_pTitle->GetInfo()->IsNeverPromptOnMerge() ) {
if( MsgBox( IDS_MERGE_PROMPT, MB_OKCANCEL ) != IDOK )
bMerge = FALSE;
}
#endif
if( bMerge ) {
bReturn = BuildWordWheels();
}
}
else
bReturn = TRUE;
#ifndef CHIINDEX
// stop the animation
StopAnimation();
#endif
// reset the busy state
SetBusy( FALSE );
return bReturn;
}
BOOL CTitleDatabase::CheckWordWheels()
{
BOOL bReturn = FALSE;
//
// We perform a merge under the following conditions:
//
// 1. merged file does not exist.
// 2. title count has changed
// 3. any title has changed (updated, removed, added)
BOOL bMerge = FALSE;
DWORD dwCount = 0;
CExTitle* pTitle = NULL;
// We have to always create the title map even if we do not need to merge
// first check if each title can be initialized
// so we know how many real titles we have
// (the collection may contain bogus entries so we need to exclude these)
DWORD dwCount0 = m_pCollection->GetRefedTitleCount();
// create our title map of the existing files
dwCount = dwCount0;
m_pTitleMap = new CTitleMap;
m_pTitleMap->SetCount( dwCount );
pTitle = m_pCollection->GetFirstTitle();
for( int iTitle = 0; iTitle < (int) dwCount; iTitle++ ) {
CTitleMapEntry* pEntry = m_pTitleMap->GetAt( iTitle );
pEntry->SetTitle( pTitle );
if( pTitle )
pTitle = pTitle->GetNext();
}
// 1. merged file does not exist.
bMerge = !IsFile( m_pszDatabase );
if( !bMerge ) {
// if we cannot read the file since read access is denied then wait
// for the file to be readable again
while( TRUE ) {
HANDLE hFile = CreateFile( m_pszDatabase, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
if( hFile != INVALID_HANDLE_VALUE ) {
CloseHandle( hFile );
break;
}
Sleep( 100 );
NextAnimation();
}
// 2. title count has changed
CTitleMap* pTitleMapSaved = new CTitleMap( m_pszDatabase );
DWORD dwCountSaved = pTitleMapSaved->GetCount();
bMerge = !( dwCountSaved == dwCount );
// 3. any title has changed (updated, removed, added)
if( !bMerge ) {
// walk the title list and compare it's title entries
// to the one we just read in from the title map.
// If they differ, then rebuild the merged file
// otherwise, update the mapping Ids for the title map.
for( int iTitleSaved = 0; iTitleSaved < (int) dwCountSaved; iTitleSaved++ ) {
BOOL bMatch = FALSE;
CTitleMapEntry* pEntrySaved = pTitleMapSaved->GetAt( iTitleSaved );
const CHAR* pszShortNameSaved = pEntrySaved->GetShortName();
FILETIME FileTimeSaved = pEntrySaved->GetFileTime();
LCID lcidSaved = pEntrySaved->GetLanguage();
DWORD dwIdSaved = pEntrySaved->GetId();
for( int iTitle = 0; iTitle < (int) dwCount; iTitle++ ) {
CTitleMapEntry* pEntry = m_pTitleMap->GetAt( iTitle );
const CHAR* pszShortName = pEntry->GetShortName();
FILETIME FileTime = pEntry->GetFileTime();
LCID lcid = pEntry->GetLanguage();
// BUG 2807: the CHW file on the system had NULL for the "=pdobj" title.
// This caused an access violation in SetShortName. [dalero]
// A NULL short name will be saved to the CHW file, if we cannot find the CHM.
if( pszShortNameSaved && !lstrcmpi( pszShortNameSaved, pszShortName ) ) {
if( !CompareFileTime( &FileTimeSaved, &FileTime ) ) {
if( lcidSaved == lcid ) {
// Note, some dummy (MSDN) may have more than one copy of the identical
// title but saved under a different filename.
//
// Thus, we need to make sure that each Id gets assigned to a title
// and we do this by making sure the Id is not set already.
// If it is set, the continue looking for the next free spot that
// contains the same title information.
if( !pEntry->GetId() ) { // empty Id
pEntry->SetId( dwIdSaved ); // set the Id
pEntry->SetShortName( pszShortNameSaved ); // set the Short Name
bMatch = TRUE;
break;
}
}
}
}
}
if( (bMerge = !bMatch) == TRUE )
break;
}
}
delete pTitleMapSaved;
}
if( !bMerge ) {
// sort the map entries in Id order
m_pTitleMap->Sort( CompareIds );
}
bReturn = bMerge;
return bReturn;
}
BOOL CTitleDatabase::BuildWordWheels()
{
BOOL bReturn = FALSE;
// delete existing file
if( IsFile( m_pszDatabase ) )
DeleteFile( m_pszDatabase );
DWORD dwCount = m_pTitleMap->GetCount();
CExTitle* pTitle = NULL;
// now merge the keywords (using the title map)
CWordWheelCompiler* pCompiler = new CWordWheelCompiler( m_pszDatabase,
g_wszKeywordLinks, g_wszAssociativeLinks );
if( pCompiler->Initialize() != S_OK )
return FALSE;
IITBuildCollect* pBuildCollect = NULL;
IITPropList* pPropList = pCompiler->m_pPropList;
// #define HH_SLOW_MERGE // if you want merging to be slow
#ifndef HH_SLOW_MERGE
// create the property items upfront, and just update them as they change
pPropList->Set(STDPROP_UID, (DWORD)0, PROP_ADD );
pPropList->Set(STDPROP_SORTKEY, (VOID*) NULL, 0, PROP_ADD );
#endif
CWordWheel* pWordWheel = NULL;
// set our title map Ids (in order), create our databases,
// and create our word wheels
for( int iTitleWalk = 0; iTitleWalk < (int) dwCount; iTitleWalk++ )
{
#ifdef CHIINDEX
if ( m_bAnimation )
{
#endif
NextAnimation();
Sleep(0);
#ifdef CHIINDEX
}
#endif
CTitleMapEntry* pEntry = m_pTitleMap->GetAt( iTitleWalk );
pEntry->SetId( iTitleWalk+1 );
CTitleDatabase* pDatabase = NULL;
CWordWheel* pKeywordLinks = NULL;
CWordWheel* pAssociativeLinks = NULL;
pDatabase = new CTitleDatabase( pEntry->GetTitle()->GetIndexFileName() );
if( !pDatabase->Initialize() ) {
delete pDatabase;
pDatabase = NULL;
// Can't do anything else without a CTitleDatabase.
continue;
}
pEntry->SetDatabase( pDatabase );
pEntry->SetKeywordLinks( pDatabase->GetKeywordLinks() );
pEntry->SetAssociativeLinks( pDatabase->GetAssociativeLinks() );
// loop through each word wheel type
for( int iWordWheel=1; iWordWheel<=2; iWordWheel++ ) {
if( iWordWheel == 1 ) {
pWordWheel = pDatabase->GetKeywordLinks();
pBuildCollect = pCompiler->m_pBuildCollectKeywordLinks;
}
if( iWordWheel == 2 ) {
pWordWheel = pDatabase->GetAssociativeLinks();
pBuildCollect = pCompiler->m_pBuildCollectAssociativeLinks;
}
if( !pWordWheel )
continue;
// add each keyword
DWORD dwCount = pWordWheel->GetCount();
for( int iKeyword = 0; iKeyword < (int) dwCount; iKeyword++ ) {
// update the animation
if( !(iKeyword%200) ) {
#ifdef CHIINDEX
if (m_bAnimation) {
#endif
NextAnimation();
Sleep(0);
#ifdef CHIINDEX
}
#endif
}
DWORD dwKeyword = iKeyword;
BYTE KeywordObject[HHWW_MAX_KEYWORD_OBJECT_SIZE];
if( SUCCEEDED( pWordWheel->GetWordWheel()->Lookup( dwKeyword, KeywordObject, HHWW_MAX_KEYWORD_OBJECT_SIZE ) ) ) {
int iLen = wcslen( (WCHAR*) KeywordObject );
int iOffset = sizeof(WCHAR) * (iLen+1);
HHKEYINFO* pInfo = (HHKEYINFO*)(((DWORD_PTR)(&KeywordObject)+iOffset));
iOffset += sizeof(HHKEYINFO);
if( pInfo->wFlags & HHWW_SEEALSO )
iOffset += sizeof(WCHAR) * (wcslen( (WCHAR*) (((DWORD_PTR)&KeywordObject)+iOffset) ) + 1);
else { // change the UIDs to 12:20 format
DWORD dwCount = pInfo->dwCount;
UNALIGNED DWORD* pdwURLId = (DWORD*)(((DWORD_PTR)&KeywordObject)+iOffset);
for( int iURLId = 0; iURLId < (int) dwCount; iURLId++ ) {
DWORD dwURLId = *(pdwURLId+iURLId);
dwURLId = ((iTitleWalk+1)<<20) + dwURLId; // 12:20 format
*((UNALIGNED DWORD*)(((DWORD_PTR)&KeywordObject)+iOffset)) = dwURLId;
iOffset += sizeof(DWORD);
}
}
// add the new entry to the new word wheel
// Note, we must set SZ_WWDEST_OCC and not SZ_WWDEST_KEY
// otherwise ITCC crashes
#ifdef HH_SLOW_MERGE
pPropList->Set(STDPROP_UID, (DWORD)0, PROP_ADD );
pPropList->Set(STDPROP_SORTKEY, (VOID*) KeywordObject, iOffset, PROP_ADD );
pBuildCollect->SetEntry(SZ_WWDEST_OCC, pPropList);
pPropList->Clear();
#else
// simply update the property items -- no need to add/clear them each time
pPropList->Set(STDPROP_SORTKEY, (VOID*) KeywordObject, iOffset, PROP_UPDATE );
pBuildCollect->SetEntry(SZ_WWDEST_OCC, pPropList);
#endif
}
}
}
if( pDatabase ) {
delete pDatabase;
pEntry->SetDatabase( NULL );
}
}
#ifndef HH_SLOW_MERGE
pPropList->Clear();
#endif
// build it
#ifdef CHIINDEX
if ( m_bAnimation )
{
#endif
NextAnimation();
Sleep(0);
#ifdef CHIINDEX
}
#endif
pCompiler->Build();
// delete the compiler
delete pCompiler;
// open the database file
CFileSystem* pDatabaseMap = new CFileSystem();
if( FAILED( pDatabaseMap->Init() ) || FAILED( pDatabaseMap->Open( m_pszDatabase, STGM_READWRITE | STGM_SHARE_EXCLUSIVE ) ) ) {
// stop the animation
StopAnimation();
SetBusy( FALSE );
return FALSE;
}
// sort the map entries in Id order
m_pTitleMap->Sort( CompareIds );
// write out the new title map
CSubFileSystem* pTitleMap = new CSubFileSystem( pDatabaseMap );
pTitleMap->CreateSub( g_szTitleMap );
// walk the collection and write out the map
WORD wValue = (WORD) dwCount;
pTitleMap->WriteSub( (const void*) &wValue, sizeof(wValue) );
for( int iTitle = 0; iTitle < (int) dwCount; iTitle++ ) {
CTitleMapEntry* pEntry = m_pTitleMap->GetAt( iTitle );
const CHAR* pszShortName = pEntry->GetShortName(); // NOTE: pszShortName may be NULL. If the CHM file does not exists. It can be NULL!!!
FILETIME FileTime = pEntry->GetFileTime();
LCID lcid = pEntry->GetLanguage();
ASSERT(pszShortName != NULL) ; // NOTE: If you get this assert it most likely means that the CHM file associated with this topic doesn't exist.
DWORD dwLen = 0 ;
if (pszShortName)
{
dwLen = (DWORD)strlen(pszShortName);
}
wValue = (WORD) dwLen;
pTitleMap->WriteSub( (const void*) &wValue, sizeof(wValue) );
pTitleMap->WriteSub( pszShortName, (int) dwLen );
pTitleMap->WriteSub( (const void*) &FileTime, sizeof(FileTime) );
pTitleMap->WriteSub( (const void*) &lcid, sizeof(lcid) );
}
delete pTitleMap;
delete pDatabaseMap;
bReturn = TRUE;
return bReturn;
}
/////////////////////////////////////////////////////////////////////////////
// class CWordWheel implementation
void CWordWheel::_CWordWheel()
{
m_bInit = FALSE;
m_pWordWheel = NULL;
m_dwCount = HHWW_ERROR;
m_pszWordWheelIn = NULL;
m_pwszWordWheelIn = NULL;
m_pwszWordWheel = NULL;
m_dwRefCount = 0;
}
CWordWheel::CWordWheel( CTitleDatabase* pDatabase, const WCHAR* pwszWordWheel, DWORD dwTitleId )
{
_CWordWheel();
m_pDatabase = pDatabase;
m_pwszWordWheelIn = pwszWordWheel;
m_dwTitleId = dwTitleId;
}
CWordWheel::CWordWheel( CTitleDatabase* pDatabase, const CHAR* pszWordWheel, DWORD dwTitleId )
{
_CWordWheel();
m_pDatabase = pDatabase;
m_pszWordWheelIn = pszWordWheel;
m_dwTitleId = dwTitleId;
}
CWordWheel::~CWordWheel()
{
Free();
}
DWORD CWordWheel::AddRef()
{
return ++m_dwRefCount;
}
DWORD CWordWheel::Release()
{
if( m_dwRefCount )
--m_dwRefCount;
return m_dwRefCount;
}
BOOL CWordWheel::Initialize()
{
// bail out if we are already initialized
if( m_bInit )
return TRUE;
// allocate a UNICODE version of our word wheel name
if( m_pszWordWheelIn && *m_pszWordWheelIn ) {
DWORD dwLen = (DWORD)strlen(m_pszWordWheelIn) + 1;
m_pwszWordWheel = new WCHAR[dwLen+1];
MultiByteToWideChar(CP_ACP, 0, m_pszWordWheelIn, -1, (WCHAR*) m_pwszWordWheel, dwLen);
}
else if( m_pwszWordWheelIn && *m_pwszWordWheelIn ) {
DWORD dwLen = wcslen(m_pwszWordWheelIn) + 1;
m_pwszWordWheel = new WCHAR[dwLen];
wcscpy( (WCHAR*) m_pwszWordWheel, m_pwszWordWheelIn );
}
// bail out if word wheel name not specified
if( !m_pwszWordWheel || !*m_pwszWordWheel )
return FALSE;
BOOL bReturn = FALSE;
HRESULT hr = S_OK;
// get ITWordWheel ptr.
if( SUCCEEDED(hr = CoCreateInstance(CLSID_IITWordWheelLocal, NULL, CLSCTX_INPROC_SERVER,
IID_IITWordWheel, (void**)&m_pWordWheel) ) ) {
// open the word wheel
if( SUCCEEDED(hr = m_pWordWheel->Open( m_pDatabase->GetDatabase(), m_pwszWordWheel, ITWW_OPEN_NOCONNECT) ) ) {
bReturn = TRUE;
}
}
if( !bReturn ) {
Free();
m_bInit = FALSE;
}
else
m_bInit = TRUE;
return bReturn;
}
BOOL CWordWheel::Free()
{
BOOL bReturn = FALSE;
if( m_pWordWheel ) {
m_pWordWheel->Close();
m_pWordWheel->Release();
m_pWordWheel = NULL;
}
if( m_pwszWordWheel ) {
delete [] (WCHAR*) m_pwszWordWheel;
m_pwszWordWheel = NULL;
}
if( m_pwszWordWheelIn )
m_pwszWordWheelIn = NULL;
if( m_pszWordWheelIn )
m_pszWordWheelIn = NULL;
m_bInit = FALSE;
bReturn = TRUE;
return bReturn;
}
DWORD CWordWheel::GetCount()
{
DWORD dwReturn = HHWW_ERROR;
if( Init() ) {
if( m_dwCount == HHWW_ERROR ) {
LONG nCount;
if( SUCCEEDED(m_pWordWheel->Count(&nCount)) )
dwReturn = m_dwCount = nCount;
}
else
dwReturn = m_dwCount;
}
return dwReturn;
}
/////////////////////////////////////////////////////////////////////////////
// CWordWheel::GetIndex
//
// params:
//
// pwszKeywordIn - keyword to lookup
//
// bFragment - set this to TRUE if only looking for a partial match
// such as when the user types in a string fragment
// in the Index tab
//
// pdwIndexLast - If not NULL, then the function should return the
// first equivalent index and set the contents of this
// argument to the index of the last equivalent keyword.
// And equivalent keyword is where the root word (less
// and special prefixes) is the same regardless of case.
// For example, "_open", "open", "Open", and "OPEN" are
// equivalent keywords. This should be used for F1 lookups
// and A/KLink lookups as well.
//
// Note: if bFragment is TRUE and pdwIndexLast is non-NULL then
// bFragment will be set to FALSE. If neither, then we look for an
// exact match only.
//
DWORD CWordWheel::GetIndex( const WCHAR* pwszKeywordIn, BOOL bFragment, DWORD* pdwIndexLast )
{
DWORD dwIndexFirst = HHWW_ERROR;
// we cannot do both a fragment lookup and an equivalent lookup
if( pdwIndexLast )
bFragment = FALSE;
if( Init() && pwszKeywordIn && *pwszKeywordIn ) {
if( GetCount() == (DWORD) -1 )
return dwIndexFirst;
// since we are using a pluggable sort object the input to Lookup must
// be in the save format as the sort object itself. That is, we need
// to add an HHKEYINFO structure to the end of this string and fill in
// the data properly since the CHHSysSort::GetSize function in our
// pluggable sort module will get this object and expect in in that format
//
// Note, if it did not contain the trailing struct it can and will fault.
BYTE KeywordObject[HHWW_MAX_KEYWORD_OBJECT_SIZE];
WCHAR* pwszKeywordObject = (WCHAR*) KeywordObject;
wcsncpy( pwszKeywordObject, pwszKeywordIn, HHWW_MAX_KEYWORD_LENGTH );
pwszKeywordObject[HHWW_MAX_KEYWORD_LENGTH] = 0;
#ifdef _DEBUG
int iMaxObject = HHWW_MAX_KEYWORD_OBJECT_SIZE;
int iMaxLen = HHWW_MAX_KEYWORD_LENGTH;
int iLen = wcslen(pwszKeywordObject);
#endif
HHKEYINFO Info;
Info.wFlags = 0;
Info.wLevel = 0;
Info.dwLevelOffset = 0;
Info.dwFont = 0;
Info.dwCount = 0;
DWORD dwLength = sizeof(WCHAR) * (wcslen(pwszKeywordObject) + 1);
*((HHKEYINFO*)(((DWORD_PTR)pwszKeywordObject)+dwLength)) = Info;
// There are three kinds of lookup matches:
//
// 1. Exact - found hits must be completely indentical to the
// keyword we are looking up.
// "FOOBAR" == "FOOBAR"
//
// 2. Equivalent - the keyword must only differ by case or prefixes
// and we continue to find all keywords, not just the
// first one, that meets this criteria.
// "_foobar" == "FooBar" == "FOOBAR"
//
// 3. Fragment - find the first hit where only the first non-prefixed
// characters need to match while ignoring case.
// "~fo" == "FOOBAR" (assuming nothing else was a closer match)
// We have three ways that we perform such lookups:
//
// 1. Index tab - Tries Exact first then uses Fragment lookups.
//
// 2. F1 Lookups - Tries Exact first then uses Equivalent lookups.
//
// 3. A/Klinks - Tries Exact first then uses Equivalent lookups.
// Centaur just doesn't do the right thing for non-exact,
// a.k.a. prefix, lookups!
//
// For exact matches, try the first found keyword and verify it.
// If it does not match, then try a fragment lookup.
//
// For fragment matches, we need to first try the exact match
// technique noted above.
// If it does not match, then try a partial (size of lookup word),
// case-insensitive lookup.
// If it does not match, and then try the *next* entry in the same fashion.
BYTE KeywordObjectTry[HHWW_MAX_KEYWORD_OBJECT_SIZE];
WCHAR* pwszKeywordObjectTry = (WCHAR*) KeywordObjectTry;
// Try exact matches first
if( SUCCEEDED(m_pWordWheel->Lookup( &KeywordObject, (BOOL) TRUE, (LONG*) &dwIndexFirst )) ) {
if( SUCCEEDED(m_pWordWheel->Lookup( dwIndexFirst, &KeywordObjectTry, sizeof(KeywordObjectTry) )) ) {
if( !(wcscmp( pwszKeywordObjectTry, pwszKeywordObject ) == 0) ) {
dwIndexFirst = HHWW_ERROR;
}
}
}
// Try equivalent match next
if( pdwIndexLast && (dwIndexFirst == HHWW_ERROR) ) {
// skip over any special chars
const WCHAR* pwszKeyword = NULL;
for( pwszKeyword = pwszKeywordObject; pwszKeyword; pwszKeyword++ ) {
if( !(( (*pwszKeyword) == L'_') || ( (*pwszKeyword) == L'~')) )
break;
}
// Try a prefix lookup
if( SUCCEEDED(m_pWordWheel->Lookup( pwszKeyword, (BOOL) FALSE, (LONG*) &dwIndexFirst )) ) {
if( SUCCEEDED(m_pWordWheel->Lookup( dwIndexFirst, &KeywordObjectTry, sizeof(KeywordObjectTry) )) ) {
// validate the hit, if it fails, try the next index value
DWORD dwTryFirst = dwIndexFirst;
dwIndexFirst = HHWW_ERROR;
for( DWORD dwTry = dwTryFirst; dwTry <= dwTryFirst+1 ; dwTry++ ) {
if( SUCCEEDED(m_pWordWheel->Lookup( dwTry, &KeywordObjectTry, sizeof(KeywordObjectTry) )) ) {
// try it without prefixes in the input string
if( wcsicmp( pwszKeywordObjectTry, pwszKeyword ) == 0 ) {
dwIndexFirst = dwTry;
break;
} // try it with the prefixes back in
else if( ((DWORD_PTR) pwszKeyword) != ((DWORD_PTR) pwszKeywordObject) ) {
if( wcsicmp( pwszKeywordObjectTry, pwszKeywordObject ) == 0 ) {
dwIndexFirst = dwTry;
break;
}
} // ignore prefixes in found hit
else if( (*pwszKeywordObjectTry == L'_') || (*pwszKeywordObjectTry == L'~') ) {
const WCHAR* pwszKeyword = NULL;
for( pwszKeyword = pwszKeywordObjectTry; pwszKeyword; pwszKeyword++ ) {
if( !(( (*pwszKeyword) == L'_') || ( (*pwszKeyword) == L'~')) )
break;
}
if( wcsicmp( pwszKeywordObject, pwszKeyword ) == 0 ) {
dwIndexFirst = dwTry;
break;
}
}
}
}
}
}
}
// Try fragment match last
if( bFragment && (dwIndexFirst == HHWW_ERROR) ) {
// skip over any special chars
const WCHAR* pwszKeyword = NULL;
for( pwszKeyword = pwszKeywordObject; pwszKeyword; pwszKeyword++ ) {
if( !(( (*pwszKeyword) == L'_') || ( (*pwszKeyword) == L'~')) )
break;
}
while( TRUE ) {
if( SUCCEEDED(m_pWordWheel->Lookup( pwszKeyword, (BOOL) FALSE, (LONG*) &dwIndexFirst )) ) {
int iLen = wcslen( pwszKeyword );
if( SUCCEEDED(m_pWordWheel->Lookup( dwIndexFirst, &KeywordObjectTry, sizeof(KeywordObjectTry) )) ) {
// validate the hit, if it fails, try the next index value
DWORD dwTryFirst = dwIndexFirst;
dwIndexFirst = HHWW_ERROR;
for( DWORD dwTry = dwTryFirst; dwTry <= dwTryFirst+1; dwTry++ ) {
if( SUCCEEDED(m_pWordWheel->Lookup( dwTry, &KeywordObjectTry, sizeof(KeywordObjectTry) )) ) {
// try it without prefixes in the input string
int iLen2 = min(iLen, (int) wcslen(pwszKeywordObjectTry));
if( wcsnicmp( pwszKeywordObjectTry, pwszKeyword, iLen2 ) == 0 ) {
dwIndexFirst = dwTry;
break;
} // try it with the prefixes back in
else if( ((DWORD_PTR) pwszKeyword) != ((DWORD_PTR) pwszKeywordObject) ) {
int iLen = wcslen( pwszKeywordObject );
if( wcsnicmp( pwszKeywordObjectTry, pwszKeywordObject, iLen2 ) == 0 ) {
dwIndexFirst = dwTry;
break;
}
} // ignore prefixes in found hit
else if( (*pwszKeywordObjectTry == L'_') || (*pwszKeywordObjectTry == L'~') ) {
const WCHAR* pwszKeyword = NULL;
for( pwszKeyword = pwszKeywordObjectTry; pwszKeyword; pwszKeyword++ ) {
if( !(( (*pwszKeyword) == L'_') || ( (*pwszKeyword) == L'~')) )
break;
}
if( wcsnicmp( pwszKeywordObject, pwszKeyword, iLen2 ) == 0 ) {
dwIndexFirst = dwTry;
break;
}
} // for framgent lookups only, when all else fails,
// simply trust the first try (works half the time)
else if( dwTry == dwTryFirst+1 ) {
dwIndexFirst = dwTryFirst;
break;
}
}
}
}
}
// for fragments, we need to keep trying until we get a hit by
// trimming the trailing chars one at a time until we get a match
if( KeywordObject[0] && (dwIndexFirst == HHWW_ERROR) ) {
DWORD dwLength = wcslen(pwszKeywordObject);
if( dwLength <= 1 )
break;
pwszKeywordObject[dwLength-1] = L'\0';
*((HHKEYINFO*)(((DWORD_PTR)KeywordObject)+(dwLength*sizeof(WCHAR)))) = Info;
continue;
}
break;
}
}
// if equivalent match found then find the real first and last equivalent
if( pdwIndexLast && (dwIndexFirst != HHWW_ERROR) ) {
DWORD dwIndexFirstTry = dwIndexFirst;
DWORD dwIndexLastTry = dwIndexFirst;
// skip over any special chars
const WCHAR* pwszKeyword = NULL;
for( pwszKeyword = pwszKeywordObject; pwszKeyword; pwszKeyword++ ) {
if( !(( (*pwszKeyword) == L'_') || ( (*pwszKeyword) == L'~')) )
break;
}
// find the first one
for( dwIndexFirstTry--; dwIndexFirstTry != (DWORD)-1; dwIndexFirstTry-- ) {
if( SUCCEEDED(m_pWordWheel->Lookup( dwIndexFirstTry, &KeywordObjectTry, sizeof(KeywordObjectTry) )) ) {
const WCHAR* pwszBuffer = NULL;
for( pwszBuffer = pwszKeywordObjectTry; pwszBuffer; pwszBuffer++ ) {
if( !(( (*pwszBuffer) == L'_') || ( (*pwszBuffer) == L'~')) )
break;
}
if( !(_wcsicmp( pwszBuffer, pwszKeyword ) == 0) )
break;
dwIndexFirst = dwIndexFirstTry;
}
}
// find the last one
*pdwIndexLast = dwIndexLastTry;
for( dwIndexLastTry++; dwIndexLastTry <= m_dwCount; dwIndexLastTry++ ) {
if( SUCCEEDED(m_pWordWheel->Lookup( dwIndexLastTry, &KeywordObjectTry, sizeof(KeywordObjectTry) )) ) {
const WCHAR* pwszBuffer = NULL;
for( pwszBuffer = pwszKeywordObjectTry; pwszBuffer; pwszBuffer++ ) {
if( !(( (*pwszBuffer) == L'_') || ( (*pwszBuffer) == L'~')) )
break;
}
if( !(_wcsicmp( pwszBuffer, pwszKeyword ) == 0) )
break;
*pdwIndexLast = dwIndexLastTry;
}
}
}
}
return dwIndexFirst;
}
DWORD CWordWheel::GetIndex( const CHAR* pszKeyword, BOOL bFragment, DWORD* pdwIndexLast )
{
DWORD dwReturn = HHWW_ERROR;
if( pszKeyword && *pszKeyword ) {
WCHAR wszKeyword[HHWW_MAX_KEYWORD_LENGTH+1];
if( MultiByteToWideChar(CP_ACP, 0, pszKeyword, -1, wszKeyword, HHWW_MAX_KEYWORD_LENGTH+1) )
dwReturn = GetIndex( wszKeyword, bFragment, pdwIndexLast );
}
return dwReturn;
}
BOOL CWordWheel::GetString( DWORD dwKeyword, WCHAR* pwszBuffer, DWORD cchBuffer, BOOL bFull, BOOL bCacheAll )
{
BOOL bReturn = FALSE;
if( pwszBuffer && cchBuffer>0 ) {
if( (bReturn = GetIndexData( dwKeyword, bCacheAll ) ) ) {
DWORD dwLength = 0;
if( bFull )
dwLength = wcslen(m_CachedEntry.m_wszFullKeyword)+1;
else
dwLength = wcslen(m_CachedEntry.m_wszKeyword)+1;
if( dwLength <= cchBuffer )
if( bFull )
wcscpy( pwszBuffer, m_CachedEntry.m_wszFullKeyword );
else
wcscpy( pwszBuffer, m_CachedEntry.m_wszKeyword );
else
*pwszBuffer = L'\0';
}
}
return bReturn;
}
BOOL CWordWheel::GetString( DWORD dwKeyword, CHAR* pszBuffer, DWORD cchBuffer, BOOL bFull, BOOL bCacheAll )
{
BOOL bReturn = FALSE;
if( pszBuffer && cchBuffer>0 ) {
WCHAR wszBuffer[HHWW_MAX_KEYWORD_LENGTH+1];
if( bReturn = GetString( dwKeyword, wszBuffer, cchBuffer, bFull, bCacheAll ) ) {
if( WideCharToMultiByte(CP_ACP, 0, wszBuffer, -1, pszBuffer, cchBuffer, NULL, NULL) == 0 )
bReturn = TRUE;
}
}
return bReturn;
}
DWORD CWordWheel::GetLevel( DWORD dwKeyword )
{
DWORD dwReturn = HHWW_ERROR;
if( GetIndexData( dwKeyword ) )
dwReturn = m_CachedEntry.m_dwLevel;
return dwReturn;
}
DWORD CWordWheel::GetLevelOffset( DWORD dwKeyword )
{
DWORD dwReturn = HHWW_ERROR;
if( GetIndexData( dwKeyword ) )
dwReturn = m_CachedEntry.m_dwLevelOffset;
return dwReturn;
}
BOOL CWordWheel::IsPlaceHolder( DWORD dwKeyword )
{
BOOL bReturn = FALSE;
if( GetIndexData( dwKeyword ) ) {
if( m_CachedEntry.m_dwFlags & HHWW_SEEALSO ) {
if( wcscmp( m_CachedEntry.m_wszSeeAlso, m_CachedEntry.m_wszFullKeyword ) == 0 ) {
bReturn = TRUE;
}
}
}
return bReturn;
}
BOOL CWordWheel::GetSeeAlso( DWORD dwKeyword, WCHAR* pwszBuffer, DWORD cchBuffer )
{
BOOL bReturn = FALSE;
if( pwszBuffer && cchBuffer>0 ) {
if( (bReturn = GetIndexData( dwKeyword ) ) ) {
if( m_CachedEntry.m_dwFlags & HHWW_SEEALSO ) {
if( (DWORD) (wcslen(m_CachedEntry.m_wszSeeAlso)+1) <= cchBuffer )
wcscpy( pwszBuffer, m_CachedEntry.m_wszSeeAlso );
else
*pwszBuffer = L'\0';
}
else
bReturn = FALSE;
}
}
return bReturn;
}
BOOL CWordWheel::GetSeeAlso( DWORD dwKeyword, CHAR* pszBuffer, DWORD cchBuffer )
{
BOOL bReturn = FALSE;
if( pszBuffer && cchBuffer>0 ) {
WCHAR wszBuffer[HHWW_MAX_KEYWORD_LENGTH+1];
if( bReturn = GetSeeAlso( dwKeyword, wszBuffer, cchBuffer ) ) {
if( WideCharToMultiByte(CP_ACP, 0, wszBuffer, -1, pszBuffer, cchBuffer, NULL, NULL) == 0 )
bReturn = TRUE;
}
}
return bReturn;
}
DWORD CWordWheel::GetHitCount( DWORD dwKeyword )
{
DWORD dwReturn = HHWW_ERROR;
if( GetIndexHitData( dwKeyword ) )
dwReturn = m_CachedResults.GetCount();
return dwReturn;
}
DWORD CWordWheel::GetHit( DWORD dwKeyword, DWORD dwHit, CExTitle** ppTitle )
{
DWORD dwReturn = HHWW_ERROR;
if( GetIndexHitData( dwKeyword ) ) {
dwReturn = m_CachedResults.GetAt( dwHit )->GetURLId();
if( ppTitle != NULL )
*ppTitle = m_CachedResults.GetAt( dwHit )->GetTitle();
}
return dwReturn;
}
inline BOOL CWordWheel::GetIndexHitData( const VOID* pcvKeywordObject, DWORD cbSize, HHKEYINFO* pInfo, DWORD dwKeyword )
{
if( !((pInfo->wFlags) & HHWW_UID_OVERFLOW) && pInfo->dwCount ) {
m_CachedResults.SetIndex( dwKeyword, pInfo->dwCount );
for( int i = 0; i < (int) pInfo->dwCount; i++ ) {
DWORD dwURLId = *((UNALIGNED DWORD*) (((DWORD_PTR)pcvKeywordObject) + cbSize + (i*sizeof(DWORD))) );
CExTitle* pTitle = m_pDatabase->GetTitle();
// if we are reading a word wheel that is to be merged then
// translate the URL Ids into 12/20 format
if( m_dwTitleId ) {
dwURLId = (m_dwTitleId<<20) + dwURLId;
}
// if we are reading a collection file then
// translate the URL Ids to standard format
// and set the title pointer appropriately
else if( m_pDatabase->IsCollection() ) {
DWORD dwTitleId = dwURLId>>20;
// v1.1a creates bogus entries in the chw file. So
// to workaround this we need to set the title id to 1
// and the url id to 0 when the title id is greater than
// the title count
if( dwTitleId > m_pDatabase->GetTitleMap()->GetCount() ) {
dwTitleId = 1;
dwURLId = 0;
}
else if( dwTitleId ) {
dwURLId = dwURLId & 0x000FFFFF;
pTitle = m_pDatabase->GetTitleMap()->GetAt(dwTitleId-1)->GetTitle();
}
}
m_CachedResults.GetAt( i )->SetURLId( dwURLId );
m_CachedResults.GetAt( i )->SetTitle( pTitle );
}
}
return TRUE;
}
BOOL CWordWheel::GetIndexData( DWORD dwKeyword, BOOL bCacheAll )
{
BOOL bReturn = FALSE;
if( Init() ) {
if( m_CachedEntry.m_dwIndex != dwKeyword ) {
BYTE KeywordObject[HHWW_MAX_KEYWORD_OBJECT_SIZE];
const VOID* pcvKeywordObject = KeywordObject;
if( SUCCEEDED(m_pWordWheel->Lookup( dwKeyword, KeywordObject, sizeof(KeywordObject) ) ) ) {
m_CachedEntry.m_dwIndex = dwKeyword;
wcscpy( m_CachedEntry.m_wszFullKeyword, (WCHAR*) pcvKeywordObject );
DWORD cbSize = sizeof(WCHAR) * (wcslen((WCHAR*)pcvKeywordObject) + 1);
HHKEYINFO* pInfo = (HHKEYINFO*)(((DWORD_PTR)(pcvKeywordObject))+cbSize);
m_CachedEntry.m_dwFlags = (DWORD) pInfo->wFlags;
m_CachedEntry.m_dwLevel = (DWORD) pInfo->wLevel;
m_CachedEntry.m_dwLevelOffset = pInfo->dwLevelOffset;
cbSize += sizeof(HHKEYINFO);
if( pInfo->wLevel )
wcscpy( m_CachedEntry.m_wszKeyword, (WCHAR*) (((DWORD_PTR)pcvKeywordObject)+(pInfo->dwLevelOffset*sizeof(WCHAR))) );
else
wcscpy( m_CachedEntry.m_wszKeyword, (WCHAR*) pcvKeywordObject );
if( (pInfo->wFlags) & HHWW_SEEALSO ) {
wcscpy( m_CachedEntry.m_wszSeeAlso, (WCHAR*)(((DWORD_PTR)pcvKeywordObject)+cbSize) );
}
if( bCacheAll ) {
GetIndexHitData( pcvKeywordObject, cbSize, pInfo, dwKeyword );
}
}
}
if( dwKeyword < GetCount() )
bReturn = TRUE;
}
return bReturn;
}
BOOL CWordWheel::GetIndexHitData( DWORD dwKeyword )
{
BOOL bReturn = FALSE;
if( Init() ) {
if( m_CachedResults.GetIndex() != dwKeyword ) {
BYTE KeywordObject[HHWW_MAX_KEYWORD_OBJECT_SIZE];
const VOID* pcvKeywordObject = KeywordObject;
if( SUCCEEDED(m_pWordWheel->Lookup( dwKeyword, KeywordObject, sizeof(KeywordObject) ) ) ) {
DWORD cbSize = sizeof(WCHAR) * (wcslen((WCHAR*)pcvKeywordObject) + 1);
HHKEYINFO* pInfo = (HHKEYINFO*)(((DWORD_PTR)(pcvKeywordObject))+cbSize);
cbSize += sizeof(HHKEYINFO);
GetIndexHitData( pcvKeywordObject, cbSize, pInfo, dwKeyword );
}
}
if( dwKeyword < GetCount() )
bReturn = TRUE;
}
return bReturn;
}
/////////////////////////////////////////////////////////////////////////////
// class CWordWheelCompiler implementation
void CWordWheelCompiler::_CWordWheelCompiler()
{
m_bInit = FALSE;
m_pszDatabase = NULL;
m_pwszKeywordLinks = NULL;
m_pwszAssociativeLinks = NULL;
m_lcid = 0;
m_pFileSystem = NULL;
m_pDatabase = NULL;
m_pPersistStorageDatabase = NULL;
m_pBuildCollectKeywordLinks = NULL;
m_pBuildCollectAssociativeLinks = NULL;
m_pPropList = NULL;
m_pStorageKeywordLinks = NULL;
m_pStorageAssociativeLinks = NULL;
m_pPersistStorageKeywordLinks = NULL;
m_pPersistStorageAssociativeLinks = NULL;
}
CWordWheelCompiler::CWordWheelCompiler( const CHAR* pszDatabase, const WCHAR* pwszKeywordLinks, const WCHAR* pwszAssociativeLinks, LCID lcid )
{
_CWordWheelCompiler();
m_pszDatabase = pszDatabase;
m_pwszKeywordLinks = pwszKeywordLinks;
m_pwszAssociativeLinks = pwszAssociativeLinks;
m_lcid = lcid;
}
CWordWheelCompiler::~CWordWheelCompiler()
{
Free();
}
HRESULT CWordWheelCompiler::Initialize()
{
HRESULT hr = S_FALSE;
// bail out if we are already initialized
if( m_bInit )
return S_OK;
// bail out if word wheel stream names not specified
if( !m_pwszKeywordLinks || !*m_pwszKeywordLinks ||
!m_pwszAssociativeLinks || !*m_pwszAssociativeLinks )
return S_FALSE;
// if the database is specified then use it otherwise generate
// a temporary filename
char szTempPath[MAX_PATH];
GetTempPath( sizeof(szTempPath), szTempPath );
if( m_pszDatabase && *m_pszDatabase ) {
strcpy( m_szDatabase, m_pszDatabase );
}
else {
GetTempFileName( szTempPath,"TFS",0, m_szDatabase );
}
// create the file system (delete the old one if it exists
if( IsFile( m_szDatabase ) )
DeleteFile( m_szDatabase );
m_pFileSystem = new CFileSystem;
if( !m_pFileSystem || FAILED( m_pFileSystem->Init() ) || FAILED( m_pFileSystem->CreateUncompressed( m_szDatabase ) ) ) {
return S_FALSE;
}
// get ITDatabase ptr.
if( SUCCEEDED(hr = CoCreateInstance(CLSID_IITDatabaseLocal, NULL, CLSCTX_INPROC_SERVER,
IID_IITDatabase, (void**)&m_pDatabase) ) ) {
if( SUCCEEDED(hr = m_pDatabase->QueryInterface( IID_IPersistStorage, (void**)&m_pPersistStorageDatabase ) ) ) {
if( SUCCEEDED(hr = m_pPersistStorageDatabase->InitNew( m_pFileSystem->GetITStorageDocObj() ) ) ) {
m_bInit = TRUE;
}
}
}
// create the sorter object
DWORD dwSorterInstance;
m_pDatabase->CreateObject( CLSID_HHSysSort, &dwSorterInstance );
// Create Build Collection objects
if( SUCCEEDED(hr = CoCreateInstance( CLSID_IITWordWheelUpdate, NULL, CLSCTX_INPROC_SERVER,
IID_IITBuildCollect, (VOID**)&m_pBuildCollectKeywordLinks ) ) ) {
if( SUCCEEDED(hr = CoCreateInstance( CLSID_IITWordWheelUpdate, NULL, CLSCTX_INPROC_SERVER,
IID_IITBuildCollect, (VOID**)&m_pBuildCollectAssociativeLinks ) ) ) {
// Create keyword Property List (used for both AssociativeLinks and KeywordLinks)
if( SUCCEEDED(hr = CoCreateInstance( CLSID_IITPropList, NULL, CLSCTX_INPROC_SERVER, IID_IITPropList, (VOID**)&m_pPropList) ) ) {
m_bInit = TRUE;
}
}
}
// create the substorage files
DWORD dwLen = 0;
CHAR* psz = NULL;
// KeywordLinks
WCHAR wszKeywordLinks[MAX_PATH];
m_pBuildCollectKeywordLinks->GetTypeString( wszKeywordLinks, NULL ); // Get the "$WW" prefix
wcscat( wszKeywordLinks, m_pwszKeywordLinks );
m_pFileSystem->GetITStorageDocObj()->CreateStorage( wszKeywordLinks, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &m_pStorageKeywordLinks);
m_pBuildCollectKeywordLinks->QueryInterface( IID_IPersistStorage, (void**)&m_pPersistStorageKeywordLinks );
m_pPersistStorageKeywordLinks->InitNew( m_pStorageKeywordLinks );
// AssociativeLinks
WCHAR wszAssociativeLinks[MAX_PATH];
m_pBuildCollectAssociativeLinks->GetTypeString( wszAssociativeLinks, NULL ); // Get the "$WW" prefix
wcscat( wszAssociativeLinks, m_pwszAssociativeLinks );
m_pFileSystem->GetITStorageDocObj()->CreateStorage( wszAssociativeLinks, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &m_pStorageAssociativeLinks);
m_pBuildCollectAssociativeLinks->QueryInterface( IID_IPersistStorage, (void**)&m_pPersistStorageAssociativeLinks );
m_pPersistStorageAssociativeLinks->InitNew( m_pStorageAssociativeLinks );
// get local information
char szCodePage[20] = "1252";
if( m_lcid == ((DWORD)-1) )
m_lcid = GetSystemDefaultLCID();
GetLocaleInfo(m_lcid,LOCALE_IDEFAULTANSICODEPAGE,szCodePage,sizeof(szCodePage) );
DWORD dwCodePage = Atoi( szCodePage );
// apply sorter object information to the new word wheels
VARARG vaDword = {0};
vaDword.dwArgc = 2;
vaDword.Argv[0] = (void *)(INT_PTR)IHHSK100_KEYTYPE_UNICODE_SZ;
vaDword.Argv[1] = (void*) 0;
VARARG vaEmpty = {0};
m_pBuildCollectKeywordLinks->InitHelperInstance( dwSorterInstance, m_pDatabase,
dwCodePage, m_lcid, vaDword, vaEmpty );
m_pBuildCollectAssociativeLinks->InitHelperInstance( dwSorterInstance, m_pDatabase,
dwCodePage, m_lcid, vaDword, vaEmpty );
if( FAILED(hr) ) {
Free();
m_bInit = FALSE;
}
else
m_bInit = TRUE;
return hr;
}
HRESULT CWordWheelCompiler::Free()
{
HRESULT hr = S_FALSE;
if( m_pPersistStorageKeywordLinks ) {
m_pPersistStorageKeywordLinks->Release();
m_pPersistStorageKeywordLinks = NULL;
}
if( m_pPersistStorageAssociativeLinks ) {
m_pPersistStorageAssociativeLinks->Release();
m_pPersistStorageAssociativeLinks = NULL;
}
if( m_pStorageKeywordLinks ) {
m_pStorageKeywordLinks->Release();
m_pStorageKeywordLinks = NULL;
}
if( m_pStorageAssociativeLinks ) {
m_pStorageAssociativeLinks->Release();
m_pStorageAssociativeLinks = NULL;
}
if( m_pPropList ) {
m_pPropList->Release();
m_pPropList = NULL;
}
if( m_pBuildCollectAssociativeLinks ) {
m_pBuildCollectAssociativeLinks->Release();
m_pBuildCollectAssociativeLinks = NULL;
}
if( m_pBuildCollectKeywordLinks ) {
m_pBuildCollectKeywordLinks->Release();
m_pBuildCollectKeywordLinks = NULL;
}
if( m_pPersistStorageDatabase ) {
m_pPersistStorageDatabase->Release();
m_pPersistStorageDatabase = NULL;
}
if( m_pDatabase ) {
m_pDatabase->Close();
m_pDatabase->Release();
m_pDatabase = NULL;
}
if( m_pFileSystem ) {
delete m_pFileSystem;
m_pFileSystem = NULL;
}
m_bInit = FALSE;
hr = S_OK;
return hr;
}
HRESULT CWordWheelCompiler::Build()
{
HRESULT hr = S_FALSE;
if( Init() ) {
#ifdef CHIINDEX
if ( m_bAnimation )
#endif
NextAnimation();
// KeywordLinks
m_pPersistStorageKeywordLinks->Save( m_pStorageKeywordLinks, TRUE );
#ifdef CHIINDEX
if ( m_bAnimation )
#endif
NextAnimation();
m_pPersistStorageKeywordLinks->Release();
m_pPersistStorageKeywordLinks = NULL;
#ifdef CHIINDEX
if ( m_bAnimation )
#endif
NextAnimation();
m_pStorageKeywordLinks->Commit(STGC_DEFAULT);
#ifdef CHIINDEX
if ( m_bAnimation )
#endif
NextAnimation();
// AssociativeLinks
m_pPersistStorageAssociativeLinks->Save( m_pStorageAssociativeLinks, TRUE );
#ifdef CHIINDEX
if ( m_bAnimation )
#endif
NextAnimation();
m_pPersistStorageAssociativeLinks->Release();
m_pPersistStorageAssociativeLinks = NULL;
#ifdef CHIINDEX
if ( m_bAnimation )
#endif
NextAnimation();
m_pStorageAssociativeLinks->Commit(STGC_DEFAULT);
#ifdef CHIINDEX
if ( m_bAnimation )
#endif
NextAnimation();
// Database == $OBJINST file
m_pPersistStorageDatabase->Save( m_pFileSystem->GetITStorageDocObj(), TRUE );
#ifdef CHIINDEX
if ( m_bAnimation )
#endif
NextAnimation();
m_pPersistStorageDatabase->Release();
m_pPersistStorageDatabase = NULL;
#ifdef CHIINDEX
if ( m_bAnimation )
#endif
NextAnimation();
m_pFileSystem->GetITStorageDocObj()->Commit(STGC_DEFAULT);
#ifdef CHIINDEX
if ( m_bAnimation )
#endif
NextAnimation();
}
return hr;
}