Microsoft/WindowsXP-SP1
Microsoft
/
WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
WindowsXP-SP1/enduser/stuff/hhctrl/htmlhelp.cpp

2390 lines
80 KiB
C++
Raw Permalink Blame History

// Copyright (C) Microsoft Corporation 1996-1997, All Rights reserved.
#include "header.h"
#ifdef _DEBUG
#undef THIS_FILE
static const char THIS_FILE[] = __FILE__;
#endif
#include "strtable.h"
#include "hha_strtable.h"
#include "resource.h"
#include "contain.h"
#include "system.h"
#include "secwin.h"
#include "popup.h"
#include "highlite.h"
// Get hhPreTranslateMessage
#include "hhshell.h"
// Internal API definitions.
#include "hhpriv.h"
// HH_GET_LAST_ERROR support
#include "lasterr.h"
/////////////////////////////////////////////////////////////////////
//
// Internal function prototypes.
//
HWND ReactivateDisplayTopic(HWND hwndCaller, LPCSTR pszFile, DWORD_PTR dwData) ;
HWND InternalHelpContext(HWND hwndCaller, LPCSTR pszFile, DWORD_PTR id, HH_COLLECTION_CONTEXT* pContext);
HWND OnHelpContextInCollection(HWND hwndCaller, LPCSTR pszColFile, DWORD_PTR dwData);
bool SetGlobalProperty(HH_GLOBAL_PROPERTY* prop, CHHWinType*) ;
bool GetNameAndWinType(LPCSTR pszFile, CStr& pszName, CStr& pszWindow) ;
HWND OnReloadNavData(HWND hwndCaller, LPCSTR pszFile, HH_NAVDATA* pNavData) ;
bool GetBrowserInterface(HWND hWndBrowserParent, IDispatch** ppWebBrowser);
// Used by hh.cpp
bool InitializeSession(UNALIGNED DWORD_PTR* pCookie) ;
bool UninitializeSession(DWORD_PTR Cookie) ;
/////////////////////////////////////////////////////////////////////
//
// Constants
//
static const char txtWinHelpFileExt[] = ".hlp";
static const char txtForceWindowType[] = "$Lee";
// Pointer to global array of window types.
HWND xHtmlHelpW(HWND hwndCaller, LPCWSTR pszFile, UINT uCommand, DWORD_PTR dwData)
{
CStr cszFile;
if (pszFile)
cszFile = (WCHAR*) pszFile;
switch (uCommand) {
case HH_DISPLAY_TEXT_POPUP:
{
HH_POPUP* ppopup = (HH_POPUP*) dwData;
CStr cszString;
if (!ppopup->idString) {
cszString = (WCHAR*) ppopup->pszText;
ppopup->pszText = cszString.psz;
}
CStr cszFont;
if (ppopup->pszFont) {
cszFont = (WCHAR*) ppopup->pszFont;
ppopup->pszFont = cszFont.psz;
}
return xHtmlHelpA(hwndCaller, cszFile, uCommand, dwData);
}
case HH_DISPLAY_INDEX:
case HH_GET_WIN_HANDLE:
case HH_DISPLAY_TOPIC:
if (dwData && !IsBadReadPtr((LPCSTR) dwData, sizeof(LPCSTR))) {
char szURL[MAX_PATH];
szURL[WideCharToMultiByte(CP_ACP, 0,
(const WCHAR*) dwData, -1,
szURL, MAX_PATH, NULL, NULL)] = '\0';
return xHtmlHelpA(hwndCaller, cszFile, uCommand, (DWORD_PTR) szURL);
}
else
return xHtmlHelpA(hwndCaller, cszFile, uCommand, dwData);
case HH_KEYWORD_LOOKUP:
{
HH_AKLINK* pakLink = (HH_AKLINK*) dwData;
if (IsBadReadPtr(pakLink, sizeof(HH_AKLINK*)))
// BUGBUG: nag the help author
return NULL;
pakLink->fReserved = TRUE;
return xHtmlHelpA(hwndCaller, cszFile, uCommand, dwData);
}
case HH_SET_INFO_TYPE:
{
PHH_SET_INFOTYPE pSetInfoType = *(PHH_SET_INFOTYPE *)dwData;
CStr cszType;
CStr cszCat;
if (*pSetInfoType->pszCatName != NULL) {
cszCat = (WCHAR*) pSetInfoType->pszCatName;
pSetInfoType->pszCatName = cszCat.psz;
}
if (*pSetInfoType->pszInfoTypeName != NULL) {
cszType = (WCHAR*) pSetInfoType->pszInfoTypeName;
pSetInfoType->pszInfoTypeName = cszType.psz;
}
return xHtmlHelpA(hwndCaller, cszFile, uCommand, dwData);
}
case HH_ENUM_INFO_TYPE:
{
PHH_ENUM_IT penumIT;
penumIT = (PHH_ENUM_IT)(*(PHH_ENUM_IT*)dwData);
HWND ret = xHtmlHelpA(hwndCaller, cszFile, uCommand, dwData);
if ( ret != (HWND)-1 )
{
CHmData* phmData = FindCurFileData( cszFile.psz);
if ( phmData == NULL )
return (HWND)-1;
phmData->PopulateUNICODETables();
penumIT->pszITName = phmData->m_ptblIT->GetPointer((int)(DWORD_PTR)ret);
penumIT->pszITDescription = phmData->m_ptblIT_Desc->GetPointer((int)(DWORD_PTR)ret);
}
return ret;
}
case HH_ENUM_CATEGORY:
{
PHH_ENUM_CAT penumCat;
HWND ret = xHtmlHelpA(hwndCaller, cszFile, uCommand, dwData);
if ( ret != (HWND)-1 )
{
penumCat = *(PHH_ENUM_CAT*) dwData;
CHmData* phmData = FindCurFileData( cszFile.psz);
if ( phmData == NULL )
return (HWND)-1;
phmData->PopulateUNICODETables();
penumCat->pszCatName = phmData->m_ptblCat->GetPointer((int)(DWORD_PTR)ret+1);
penumCat->pszCatDescription = phmData->m_ptblCat_Desc->GetPointer((int)(DWORD_PTR)ret+1);
}
return ret;
}
case HH_ENUM_CATEGORY_IT:
{
PHH_ENUM_IT penumIT;
CStr csz;
penumIT = *(PHH_ENUM_IT*)dwData;
csz = (WCHAR*) penumIT->pszCatName;
penumIT->pszCatName = csz.psz;
HWND ret = xHtmlHelpA(hwndCaller, cszFile, uCommand, dwData);
if ( ret != (HWND)-1 )
{
CHmData* phmData = FindCurFileData( cszFile.psz);
if ( phmData == NULL )
return (HWND)-1;
phmData->PopulateUNICODETables();
penumIT->pszITName = phmData->m_ptblIT->GetPointer((int)(DWORD_PTR)ret);
penumIT->pszITDescription = phmData->m_ptblIT_Desc->GetPointer((int)(DWORD_PTR)ret);
}
return ret;
}
case HH_SET_GUID:
{
// Set all CHM files matching this process ID to use this GUID
// BUGBUG: should NOT be using a global for this -- breaks
// the moment you share instances of HHCTRL accross processes
if (g_pszDarwinGuid)
lcFree(g_pszDarwinGuid);
// Convert to ANSI
CStr pszGuid((LPCWSTR) dwData);
// Save pointer.
pszGuid.TransferPointer(&g_pszDarwinGuid ) ;
}
return NULL;
case HH_SET_BACKUP_GUID:
{
// Set all CHM files matching this process ID to use this GUID
// BUGBUG: should NOT be using a global for this -- breaks
// the moment you share instances of HHCTRL accross processes
if (g_pszDarwinBackupGuid)
lcFree(g_pszDarwinBackupGuid);
// Convert to ANSI
CStr pszGuid((LPCWSTR) dwData);
// Save pointer.
pszGuid.TransferPointer(&g_pszDarwinBackupGuid) ;
}
return NULL;
default:
return xHtmlHelpA(hwndCaller, cszFile, uCommand, dwData);
}
return NULL;
}
HWND xHtmlHelpA(HWND hwndCaller, LPCSTR pszFile, UINT uCommand, DWORD_PTR dwData)
{
#if 0
#ifdef _DEBUG
static int count = 0;
if (!count)
DebugBreak();
count++;
#endif
#endif
switch (uCommand) {
case HH_RESERVED1: // this is a WinHelp HELP_CONTEXTMENU call
WinHelp(hwndCaller, pszFile, HELP_CONTEXTMENU, dwData);
return NULL;
case HH_RESERVED2: // this is a WinHelp HELP_FINDER call
WinHelp(hwndCaller, pszFile, HELP_FINDER, 0);
return NULL;
case HH_RESERVED3: // this is a WinHelp HELP_WM_HELP call
WinHelp(hwndCaller, pszFile, HELP_WM_HELP, dwData);
return NULL;
case HH_DISPLAY_TOPIC:
DBWIN("HH_DISPLAY_TOPIC");
return OnDisplayTopic(hwndCaller, pszFile, dwData);
case HH_SET_WIN_TYPE:
DBWIN("HH_SET_WIN_TYPE");
return SetWinType(pszFile, (HH_WINTYPE*) dwData) ;
case HH_GET_WIN_TYPE:
DBWIN("HH_GET_WIN_TYPE");
return GetWinType(hwndCaller, pszFile, (HH_WINTYPE**)dwData) ;
case HH_DISPLAY_SEARCH:
DBWIN("HH_DISPLAY_SEARCH");
return doDisplaySearch(hwndCaller, pszFile, (HH_FTS_QUERY*) dwData) ;
case HH_DISPLAY_INDEX:
DBWIN("HH_DISPLAY_INDEX");
return doDisplayIndex(hwndCaller, pszFile, (LPCTSTR)dwData);
case HH_DISPLAY_TOC:
DBWIN("HH_DISPLAY_TOC");
if (IsThisAWinHelpFile(hwndCaller, pszFile)) {
WinHelp(hwndCaller, pszFile, HELP_CONTEXT, dwData);
return NULL;
}
return doDisplayToc(hwndCaller, pszFile, dwData);
case HH_DISPLAY_TEXT_POPUP:
DBWIN("HH_DISPLAY_TEXT_POPUP");
return doDisplayTextPopup(hwndCaller, pszFile, (HH_POPUP*)dwData) ;
case HH_TP_HELP_WM_HELP:
DBWIN("HH_TP_HELP_WM_HELP");
if (IsThisAWinHelpFile(hwndCaller, pszFile)) {
WinHelp(hwndCaller, pszFile, HELP_WM_HELP, dwData);
return NULL;
}
return doTpHelpWmHelp(hwndCaller, pszFile, dwData);
case HH_TP_HELP_CONTEXTMENU:
DBWIN("HH_TP_HELP_CONTEXTMENU");
if (IsThisAWinHelpFile(hwndCaller, pszFile)) {
WinHelp(hwndCaller, pszFile, HELP_CONTEXTMENU, dwData);
return NULL;
}
return doTpHelpContextMenu(hwndCaller, pszFile, dwData);
case HH_GET_WIN_HANDLE:
{
DBWIN("HH_GET_WIN_HANDLE");
if (!dwData || IsBadReadPtr((LPCSTR) dwData, sizeof(LPCSTR)))
{
return NULL;
}
if (!pszFile || IsEmptyString(pszFile))
{
return NULL ;
}
// Need to include compiled filename with window lookup
// since there can be two or more .CHM files with identical window type
// names, but different definitions
CHHWinType* phh = FindWindowType(FirstNonSpace((PCSTR) dwData), hwndCaller, pszFile);
if (!phh)
{
return NULL;
}
return phh->GetHwnd();
}
case HH_SYNC:
{
DBWIN("HH_SYNC");
// pszFile has two pieces of information which we need. The filename and the window type name.
// Window type provided?
CStr cszChmName ;
CStr cszWindow ;
if (!GetNameAndWinType(pszFile, cszChmName, cszWindow))
{
return NULL;
}
/*
REVIEW: 27 Apr 98 [dalero] - I'm adding the code to make FindOrCreateWindowSlot
take a filename parameter, and I have to say that this function makes no sense to me.
Why does HH_SYNC require a window type? Shouldn't it figure one out if you don't give
it one? Leave as is for now...
*/
CHHWinType* phh = FindWindowType(cszWindow, hwndCaller, cszChmName);
if (phh->m_aNavPane[HH_TAB_CONTENTS])
{
CStr cszUrl((PCSTR) dwData);
CToc* ptoc = reinterpret_cast<CToc*>(phh->m_aNavPane[HH_TAB_CONTENTS]) ; // HACKHACK: Should use dynamic cast.
ptoc->Synchronize(cszUrl);
}
return phh->GetHwnd();
}
case HH_KEYWORD_LOOKUP:
DBWIN("HH_KEYWORD_LOOKUP");
return OnKeywordSearch(hwndCaller, pszFile, (HH_AKLINK*) dwData);
case HH_ALINK_LOOKUP:
DBWIN("HH_ALINK_LOOKUP");
return OnKeywordSearch(hwndCaller, pszFile, (HH_AKLINK*) dwData, FALSE);
case HH_HELP_CONTEXT:
DBWIN("HH_HELP_CONTEXT");
return OnHelpContext(hwndCaller, pszFile, dwData);
case HH_CLOSE_ALL:
{
DBWIN("HH_CLOSE_ALL");
DeleteWindows() ; // This deletes everything. Windows and chm data.
}
return NULL;
case HH_GET_LAST_ERROR:
DBWIN("HH_GET_LAST_ERROR");
if (SUCCEEDED(hhGetLastError((HH_LAST_ERROR*)(dwData))))
return (HWND)TRUE;
else
return NULL;
case HH_ENUM_INFO_TYPE:
{
DBWIN("HH_ENUM_INFO_TYPE");
static HH_ENUM_IT ITData;
static PHH_ENUM_IT pITData=&ITData;
CHmData* phmData = FindCurFileData( pszFile ) ;
if ( phmData == NULL )
return (HWND)-1;
if ( phmData->m_cur_IT == 0 )
phmData->m_cur_IT = 1;
if ( !phmData->m_pInfoType )
{
phmData->m_pInfoType = new CInfoType();
phmData->m_pInfoType->CopyTo( phmData );
}
// get the information type
if ( phmData->m_cur_IT > phmData->m_pInfoType->HowManyInfoTypes() )
{
phmData->m_cur_IT = 0;
return (HWND)-1;
}
ITData.iType = IT_INCLUSIVE;
if ( phmData->m_pInfoType->IsHidden( phmData->m_cur_IT) )
ITData.iType = IT_HIDDEN;
else
if ( phmData->m_pInfoType->IsExclusive( phmData->m_cur_IT ) )
ITData.iType = IT_EXCLUSIVE;
ITData.pszITName = phmData->m_pInfoType->GetInfoTypeName(phmData->m_cur_IT);
ITData.pszITDescription = phmData->m_pInfoType->GetInfoTypeDescription(phmData->m_cur_IT);
ITData.cbStruct = sizeof(HH_ENUM_IT);
memcpy(*(PHH_ENUM_IT*)dwData, (PHH_ENUM_IT)(pITData), sizeof(HH_ENUM_IT) );
phmData->m_cur_IT++;
return reinterpret_cast<HWND>((DWORD_PTR)(phmData->m_cur_IT-1));
}
case HH_SET_INFO_TYPE:
DBWIN("HH_SET_INFO_TYPE");
if (IsThisAWinHelpFile(hwndCaller, pszFile)) {
WinHelp(hwndCaller, pszFile, HELP_CONTEXTPOPUP, dwData);
return NULL;
}
{
HH_SET_INFOTYPE set_type;
CStr cszIT;
CHmData* phmData = FindCurFileData( pszFile );
if ( phmData == NULL )
return (HWND)-1;
memcpy(&set_type, *(PHH_SET_INFOTYPE*)dwData, (int)(**(int**)dwData));
if ( set_type.pszCatName && *set_type.pszCatName!= NULL)
{
cszIT = set_type.pszCatName;
cszIT+=":";
}
if ( set_type.pszInfoTypeName )
if ( cszIT.IsEmpty() )
cszIT = set_type.pszInfoTypeName;
else
cszIT += set_type.pszInfoTypeName;
else
return (HWND)-1;
if ( !phmData->m_pInfoType )
{
phmData->m_pInfoType = new CInfoType();
phmData->m_pInfoType->CopyTo( phmData );
}
int IT = phmData->m_pInfoType->GetInfoType( cszIT.psz );
if ( IT <= 0 )
return (HWND)-1;
if (!phmData->m_pAPIInfoTypes )
phmData->m_pAPIInfoTypes = (INFOTYPE*)lcCalloc(phmData->m_pInfoType->InfoTypeSize());
AddIT(IT, phmData->m_pAPIInfoTypes);
return reinterpret_cast<HWND>((DWORD_PTR)(IT));
}
case HH_ENUM_CATEGORY:
DBWIN("HH_ENUM_CATEGORY");
{
static HH_ENUM_CAT ITData;
static PHH_ENUM_CAT pITData = &ITData;
CHmData* phmData = FindCurFileData( pszFile );
if ( phmData == NULL )
return (HWND)-1;
if ( !phmData->m_pInfoType )
{
phmData->m_pInfoType = new CInfoType();
phmData->m_pInfoType->CopyTo( phmData );
}
if ( phmData->m_cur_Cat+1 > phmData->m_pInfoType->HowManyCategories() )
{
phmData->m_cur_Cat = 0;
return (HWND)-1;
}
ITData.pszCatName = phmData->m_pInfoType->GetCategoryString(phmData->m_cur_Cat+1);
ITData.pszCatDescription = phmData->m_pInfoType->GetCategoryDescription(phmData->m_cur_Cat+1);
ITData.cbStruct = sizeof(HH_ENUM_CAT);
memcpy(*(PHH_ENUM_CAT*)dwData, (PHH_ENUM_CAT)(pITData), sizeof(HH_ENUM_CAT) );
phmData->m_cur_Cat++;
return reinterpret_cast<HWND>((DWORD_PTR)(phmData->m_cur_Cat-1));
}
case HH_ENUM_CATEGORY_IT:
{
DBWIN("HH_ENUM_CATEGORY_IT");
static HH_ENUM_IT ITData;
static PHH_ENUM_IT pITData = &ITData;
CHmData* phmData = FindCurFileData( pszFile );
if ( phmData == NULL )
return (HWND)-1;
if ( phmData->m_cur_IT == -1 )
{
phmData->m_cur_Cat = 0;
phmData->m_cur_IT = 0;
}
if ( !phmData->m_pInfoType )
{
phmData->m_pInfoType = new CInfoType();
phmData->m_pInfoType->CopyTo( phmData );
}
if ( !dwData )
return (HWND)-1;
memcpy(&ITData, *(PHH_ENUM_IT*)dwData, (int)(**(int**)dwData));
phmData->m_cur_Cat = phmData->m_pInfoType->GetCatPosition(ITData.pszCatName);
if( phmData->m_cur_Cat == -1 )
return (HWND)-1;
if ( phmData->m_cur_IT ==0 )
phmData->m_cur_IT = phmData->m_pInfoType->GetFirstCategoryType( phmData->m_cur_Cat-1 );
else
phmData->m_cur_IT = phmData->m_pInfoType->GetNextITinCategory( );
if ( phmData->m_cur_IT == -1 )
return (HWND)-1;
ITData.iType = IT_INCLUSIVE;
if ( phmData->m_pInfoType->IsHidden( phmData->m_cur_IT) )
ITData.iType = IT_HIDDEN;
else
if ( phmData->m_pInfoType->IsExclusive( phmData->m_cur_IT ) )
ITData.iType = IT_EXCLUSIVE;
ITData.pszITName = phmData->m_pInfoType->GetInfoTypeName( phmData->m_cur_IT );
ITData.pszITDescription = phmData->m_pInfoType->GetInfoTypeDescription( phmData->m_cur_IT );
memcpy(*(PHH_ENUM_IT*)dwData, (PHH_ENUM_IT)(pITData), sizeof(HH_ENUM_IT) );
return reinterpret_cast<HWND>((DWORD_PTR)(phmData->m_cur_IT));
}
case HH_SET_INCLUSIVE_FILTER:
DBWIN("HH_SET_INCLUSIVE_FILTER");
{
CHmData* phmData=NULL;
phmData = FindCurFileData( pszFile );
if ( phmData == NULL )
return (HWND)-1;
if ( !phmData->m_pInfoType )
{
phmData->m_pInfoType = new CInfoType();
phmData->m_pInfoType->CopyTo( phmData );
}
if ( !phmData->m_pAPIInfoTypes )
return (HWND)-1;
*phmData->m_pAPIInfoTypes &= ~1L; // turn bit zero off for inclusive filtering; ie to 0.
return NULL;
}
break;
case HH_SET_EXCLUSIVE_FILTER:
DBWIN("HH_SET_EXCLUSIVE_FILTER");
{
CHmData* phmData=NULL;
phmData = FindCurFileData( pszFile );
if ( phmData == NULL )
return (HWND)-1;
if ( !phmData->m_pInfoType )
{
phmData->m_pInfoType = new CInfoType();
phmData->m_pInfoType->CopyTo( phmData );
}
if ( !phmData->m_pAPIInfoTypes )
return (HWND)-1;
*phmData->m_pAPIInfoTypes |= 1L; // turn bit zero on for exclusive filtering; ie to 1.
return NULL;
}
break;
case HH_RESET_IT_FILTER:
DBWIN("HH_RESET_IT_FILTER");
{
CHmData* phmData=NULL;
BOOL fExclusive;
phmData = FindCurFileData( pszFile );
if ( phmData == NULL )
return (HWND)-1;
if ( !phmData->m_pInfoType )
{
phmData->m_pInfoType = new CInfoType();
phmData->m_pInfoType->CopyTo( phmData );
}
if ( !phmData->m_pAPIInfoTypes )
return NULL;
if ( *phmData->m_pAPIInfoTypes & 1L )
fExclusive = TRUE;
memset(phmData->m_pAPIInfoTypes, '\0', phmData->m_pInfoType->InfoTypeSize() );
if ( fExclusive )
*phmData->m_pAPIInfoTypes |= 1L; // turn bit zero on for exclusive filtering; ie to 1.
return NULL;
}
case HH_INITIALIZE:
return (HWND)(DWORD_PTR)InitializeSession(reinterpret_cast<DWORD_PTR*>(dwData)) ;
case HH_UNINITIALIZE:
return (HWND)(DWORD_PTR)UninitializeSession(dwData) ;
//--- These were internal and are now external.
case HH_PRETRANSLATEMESSAGE:
return (HWND)(DWORD_PTR)hhPreTranslateMessage((MSG*)dwData) ;
case HH_SET_GLOBAL_PROPERTY:
{
CHHWinType *phh = FindCurWindow( );
return (HWND)SetGlobalProperty(reinterpret_cast<HH_GLOBAL_PROPERTY*>(dwData), phh) ;
}
//--- Internal HH Commands.
case HH_TITLE_PATHNAME : // Get the location of the title from its tag.
DBWIN("HH_TITLE_PATHNAME");
return reinterpret_cast<HWND>((DWORD_PTR)(GetLocationFromTitleTag(NULL/*pszFile*/, reinterpret_cast<HH_TITLE_FULLPATH*>(dwData)))) ;
case HH_PRETRANSLATEMESSAGE2:
return (HWND)(DWORD_PTR)hhPreTranslateMessage((MSG*)dwData, hwndCaller);
case HH_HELP_CONTEXT_COLLECTION:
DBWIN("HH_HELP_CONTEXT_COLLECTION");
return OnHelpContextInCollection(hwndCaller, pszFile, dwData) ;
case HH_RELOAD_NAV_DATA:
{
return OnReloadNavData(hwndCaller, pszFile, reinterpret_cast<HH_NAVDATA*>(dwData)) ;
}
case HH_GET_BROWSER_INTERFACE:
{
return reinterpret_cast<HWND>(GetBrowserInterface(hwndCaller, reinterpret_cast<IDispatch**>(dwData))) ;
}
default:
DBWIN("Unsupported API call");
return NULL;
}
}
// <mc> As per HH bug 7487 NT5 bug 303099 I am placing a check here to see if we
// appear to have a valid IE intallation. <mc/>
//
BOOL ValidateIE()
{
BOOL bRet = FALSE;
HKEY hkey;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Internet Explorer", 0, KEY_READ, &hkey) == ERROR_SUCCESS)
{
char szVersion[MAX_URL];
DWORD cbPath = sizeof(szVersion);
if ( (RegQueryValueEx(hkey, "Version", NULL, NULL, (LPBYTE) szVersion, &cbPath) == ERROR_SUCCESS) )
bRet = TRUE;
else if ( (RegQueryValueEx(hkey, "IVer", NULL, NULL, (LPBYTE) szVersion, &cbPath) == ERROR_SUCCESS) )
bRet = TRUE;
else if ( (RegQueryValueEx(hkey, "Build", NULL, NULL, (LPBYTE) szVersion, &cbPath) == ERROR_SUCCESS) )
bRet = TRUE;
RegCloseKey(hkey);
}
return bRet;
}
/***************************************************************************
FUNCTION: OnDisplayTopic
PURPOSE: Display topic in current or specified window, creating the
window if necessary.
PARAMETERS:
hwndCaller -- window requesting this topic
pszFile -- file and optionally the window to display
dwData -- optional data
RETURNS:
Window handle on success
NULL on failure
COMMENTS:
A window name is specified by following the filename (if any) with
a '>' character immediately followed by the window name:
foo.hh>proc4
If a window of the specified type isn't currently created, it will
be created and activated. If the window type has been created, but
is not active, it will be activated and the topic displayed in that
window.
MODIFICATION DATES:
27-Feb-1996 [ralphw]
***************************************************************************/
HWND OnDisplayTopic(HWND hwndCaller, LPCSTR pszFile, DWORD_PTR dwData)
{
if (dwData && IsBadReadPtr((LPCSTR) dwData, sizeof(LPCSTR)))
return NULL ;
// <mc> As per HH bug 7487 NT5 bug 303099 I am placing a check here to see if we
// appear to have a valid IE intallation. <mc/>
//
if ( ! ValidateIE() )
return NULL;
//--- If name has string %SystemRoot% add the windows directory.
CStr cszTmp;
PSTR psz = stristr(pszFile, txtSysRoot);
if (psz) {
char szPath[MAX_PATH];
GetRegWindowsDirectory(szPath);
strcat(szPath, psz + strlen(txtSysRoot));
cszTmp = szPath;
pszFile = (PCSTR) cszTmp.psz;
}
//--- Find the window name.
CStr cszFile(pszFile);
CStr cszWindow;
PSTR pszWindow = StrChr(cszFile, WINDOW_SEPARATOR);
if (pszWindow != NULL) {
*pszWindow = '\0';
RemoveTrailingSpaces(cszFile);
cszWindow = FirstNonSpace(pszWindow + 1);
}
// Is the file a collection?
BOOL bCollection = IsCollectionFile(pszFile);
//--- dwData can point to a particular topic to which to jump. Add this topic.
CStr cszExternal;
if (dwData) {
if (cszFile.IsEmpty())
cszFile = (LPCSTR) dwData;
else
{
//--- Hack: If there is a '::' assume we are specifying a chm file...
PCSTR psz = (LPCSTR) dwData;
if (bCollection && strstr(psz, "::"))
{
// Only valid if we are passing in a collection.
cszExternal = psz;
// If there is a window type at the end, remove it. We get the window type from the collection.
PSTR pszWindowType = StrChr(cszExternal, WINDOW_SEPARATOR);
if (pszWindowType != NULL)
{
*pszWindowType = '\0';
}
}
else
{
cszFile += txtSepBack;
cszFile += (*psz == '/' ? psz + 1 : psz);
}
}
}
//--- CHmData used by the CreateWindow call
CHmData* pHmDataCreateWindow = NULL ;
//--- We have a filename from which we can get the file.
CHHWinType* phh = NULL;
if (bCollection || IsCompiledHtmlFile(cszFile, &cszFile))
{
//--- Initialize the CHmData structure.
CStr cszCompressed;
PCSTR pszFilePortion = GetCompiledName(cszFile, &cszCompressed); // pszFilePortion is everything is cszFile after the '::', in other words the topic path.
if (!FindThisFile(hwndCaller, cszCompressed, &cszCompressed, FALSE))
{
//TODO: Move error message into FindThisFile.
g_LastError.Set(HH_E_FILENOTFOUND) ;
return NULL;
}
CHmData* phmData = NULL;
CExCollection* pCollection = GetCurrentCollection(NULL, pszFile);
//
// if ( .COL file AND g_Col != returned col ) OR ( .CHM file and g_col == returned col )
//
if ( !pCollection
|| ((bCollection && (pCollection != g_pCurrentCollection))
|| (!bCollection && (pCollection == g_pCurrentCollection))
|| (!bCollection && (pCollection == g_phmData[0]->m_pTitleCollection)))) //Bug:: May not have been loaded!!!
{
phmData = FindCurFileData(cszCompressed);
}
else
{
phmData = pCollection->m_phmData;
}
if (phmData == NULL)
{
g_LastError.Set(HH_E_INVALIDHELPFILE) ; // TODO: FindCurFileData should set this.
return NULL;
}
ASSERT(phmData) ; // See the previous if statement!
// IsCompiledHtmlFile has numerous side effects. We need those effects.
if (bCollection)
{
// Get the name of the master chm.
cszFile = phmData->GetCompiledFile();
// Parse it to get the various pieces.
IsCompiledHtmlFile(cszFile, &cszFile);
}
// Get the CHmData associated with the specified window type.
if (cszWindow.IsNonEmpty()
&& !IsGlobalWinType(cszWindow.psz)) // Only use the information from window type if its non-global. Currently, means get the default topic from CHM passed in.
{
phh = FindWindowType(cszWindow, hwndCaller, cszFile);
if (phh)
{
if (phh->m_phmData) // Bug 6799 - This is NULL until the window is created...
{
phmData = phh->m_phmData; //Review: Is the FindCurFileData above a waste in this case?
}
}
else if (strcmp(cszWindow, txtDefWindow + 1) != 0 && strcmp(cszWindow, txtForceWindowType) != 0)
{
AuthorMsg(IDSHHA_NO_HH_GET_WIN_TYPE, cszWindow, hwndCaller, NULL);
// Get the CHmData associated with the default window.
// We could do this in the section outside the outer if, but I'm paranoid about breaking things...
// The default window type is used only if it exists. Therefore, if we have to create a window,
// will use the correct name.
if (phmData->GetDefaultWindow() &&
FindWindowType(phmData->GetDefaultWindow(), hwndCaller, cszFile))
{
AuthorMsg(IDSHHA_NO_HH_GET_WIN_TYPE, cszWindow, hwndCaller, NULL);
cszWindow = phmData->GetDefaultWindow();
}
}
}
// Get the CHmData associated with the default window.
if (cszWindow.IsEmpty() && phmData->GetDefaultWindow())
cszWindow = phmData->GetDefaultWindow();
//--- If the user didn't supply a topic, try and find one...
if (pszFilePortion)
{
// If we have a topic, make sure that the slashes are correct.
ConvertBackSlashToForwardSlash(const_cast<LPSTR>(pszFilePortion)) ; // Danger! Danger! Will Robinson! Casting away const on a pointer inside of a CStr...
}
else
{
LPCTSTR pTopic = NULL ;
if (phh && phh->pszFile) // the window type has a topic
{
pTopic = phh->pszFile ;
}
else if (phmData && phmData->GetDefaultHtml()) // the CHmData struct's default html page.
{
pTopic = phmData->GetDefaultHtml() ;
}
if (pTopic)
{
if (*pTopic == '/') // Look for an initial separator.
{
pTopic++ ; // Skip the initial separator.
}
cszFile += txtSepBack;
cszFile += pTopic ;
}
}
// Get the CHmData structure we want to use with the window.
if (cszExternal.IsEmpty())
pHmDataCreateWindow = g_phmData[g_curHmData] ;
else
pHmDataCreateWindow = phmData ; // CHmdata for the collection.
} // if IsCompiledFile.
if (cszWindow.IsEmpty() && (!phh || phh->m_pCIExpContainer == NULL))
cszWindow = txtForceWindowType;
//--- The user supplied a window type or we have a default window type.
if (cszWindow.IsNonEmpty())
{
CStr cszChmFile;
if (cszFile.IsNonEmpty())
GetCompiledName(cszFile, &cszChmFile); //Have to call this again, because pszFile was built back up.
phh = FindWindowType(cszWindow, hwndCaller, cszChmFile); // Review: We may have already gotten the window type.
if (!phh) // Can't find the window type, so create it.
{
if (strcmp(cszWindow, txtDefWindow + 1) != 0 && strcmp(cszWindow, txtForceWindowType) != 0)
AuthorMsg(IDSHHA_NO_HH_GET_WIN_TYPE, cszWindow, hwndCaller, NULL);
CreateDefaultWindowType(cszChmFile.IsEmpty() ?
txtZeroLength : cszChmFile.psz, cszWindow); // This only does a HH_SET_WIN_TYPE
phh = FindWindowType(cszWindow, hwndCaller, pszFile); // Try again to get the window type.
}
// We still don't have a valid window type or we don't have a valid window.
if (!phh || !IsValidWindow(phh->GetHwnd()))
{
// Create the help window. This does a lot of work.
phh = CreateHelpWindow(cszWindow, cszChmFile, hwndCaller, pHmDataCreateWindow);
if (!phh)
{
g_LastError.Set(HH_E_INVALIDHELPFILE) ; // TODO: FindCurFileData should set this.
return NULL ;
}
RECT rc;
GetClientRect(phh->GetHwnd(), &rc);
SendMessage(phh->GetHwnd(), WM_SIZE, SIZE_RESTORED, MAKELONG(RECT_WIDTH(rc),RECT_HEIGHT(rc)));
// HTML Help Bug 6334 - For some reason on win95, we have a problem with coming up in the background.
// Not sure why, however the following code which is basically what happens if we don't have
// a window fixes the issue.
if (!IsIconic(phh->GetHwnd()))
{
phh->SetActiveHelpWindow();
}
}
else
{
// Bring the existing window to the front and restore if needed.
phh->SetActiveHelpWindow();
}
ASSERT(phh) ; // This has to be true by now.
// Still futzing with the filename. Review: Reduce the futzing.
if (cszFile.IsEmpty())
{
if (phh->pszFile)
cszFile = phh->pszFile;
}
}
// If we are displaying the file in the collection space, just use the string passed in
// the dwData parameter.
return ChangeHtmlTopic(cszExternal.IsNonEmpty() ? cszExternal : cszFile, phh->GetHwnd());
}
HWND ChangeHtmlTopic(PCSTR pszFile, HWND hwndChild, BOOL bHighlight)
{
if (IsEmptyString(pszFile))
return NULL;
CHHWinType* phh;
ASSERT_COMMENT(hwndChild, "It is not valid to call ChangeHtmlTopic with NULL for the calling window handle");
phh = FindHHWindowIndex(hwndChild);
CStr cszTmp;
if ( IsCompiledURL( pszFile ) ) {
if (!strstr(pszFile, txtDoubleColonSep)) {
cszTmp = pszFile;
cszTmp += txtDefFile;
pszFile = cszTmp;
}
}
if (phh->m_pCIExpContainer) {
phh->m_fHighlight = bHighlight;
phh->m_pCIExpContainer->m_pWebBrowserApp->Navigate(pszFile, NULL, NULL, NULL, NULL);
#if 0
if (phh->IsProperty(HHWIN_PROP_AUTO_SYNC))
{
if (phh->m_aNavPane[HH_TAB_CONTENTS])
{
cszTmp = pszFile;
CToc* ptoc = reinterpret_cast<CToc*>(phh->m_aNavPane[HH_TAB_CONTENTS]) ; // HACKHACK: Should use dynamic cast.
ptoc->Synchronize(cszTmp);
}
}
#endif
if (IsValidWindow(phh->GetHwnd())) {
DBWIN("Bringing window to the front");
SetWindowPos(phh->GetHwnd(), HWND_TOP, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE);
}
#ifdef DEBUG
else
DBWIN("Invalid window handle");
#endif
return phh->GetHwnd();
}
return NULL;
}
BOOL ConvertToCacheFile(PCSTR pszSrc, PSTR pszDst)
{
if (!pszSrc)
return FALSE;
CStr cszTmp;
PSTR psz = stristr(pszSrc, txtSysRoot);
if (psz) {
char szPath[MAX_PATH];
GetRegWindowsDirectory(szPath);
strcat(szPath, psz + strlen(txtSysRoot));
cszTmp = szPath;
pszSrc = (PCSTR) cszTmp.psz;
}
if ( IsCompiledURL( pszSrc ) )
{
strcpy(pszDst, pszSrc);
if ( (GetURLType(pszDst) == HH_URL_UNQUALIFIED) )
{
// We need to qualify the .CHM filespec.
//
CExCollection *pCollection;
CExTitle *pTitle;
PSTR pszSep;
if( (pCollection = GetCurrentCollection(NULL, pszDst)) )
{
if ( (SUCCEEDED(pCollection->URL2ExTitle(pszDst, &pTitle))) && pTitle )
{
if ( (pszSep = stristr(pszDst, txtDoubleColonSep)) )
{
while ( ((*(--pszSep) != ':')) && (pszSep != pszDst) );
if ( *pszSep == ':' )
*(++pszSep) = '\0';
lstrcat(pszDst, pTitle->GetContentFileName());
pszSep = stristr(pszSrc, txtDoubleColonSep);
lstrcat(pszDst, pszSep);
return TRUE;
}
}
}
}
else
return TRUE;
}
PCSTR pszChmSep = strstr(pszSrc, txtDoubleColonSep);
if (pszChmSep) {
if (pszSrc != cszTmp.psz) {
cszTmp = pszSrc;
int offset = (int)(pszChmSep - pszSrc);
pszSrc = cszTmp;
pszChmSep = pszSrc + offset;
}
*(PSTR) pszChmSep = '\0'; // Remove the separator
HRESULT hr = URLDownloadToCacheFile(NULL, pszSrc, pszDst, MAX_PATH, 0, NULL);
if (!SUCCEEDED(hr)) {
CStr cszNew;
BOOL fResult = FindThisFile(NULL, pszSrc, &cszNew, FALSE);
if (fResult) {
strcpy(pszDst, cszNew.psz);
*(PSTR) pszChmSep = ':'; // Put the separator back
strcat(pszDst, pszChmSep);
return TRUE;
}
}
else { // we downloaded it, or have a pointer to it
*(PSTR) pszChmSep = ':'; // Put the separator back
strcat(pszDst, pszChmSep);
return TRUE;
}
}
HRESULT hr = URLDownloadToCacheFile(NULL, pszSrc, pszDst, MAX_PATH, 0, NULL);
if (!SUCCEEDED(hr)) {
#if 0
if (MessageBox(NULL, pszSrc, "URLDownloadToCacheFile failure", MB_RETRYCANCEL) == IDRETRY)
DebugBreak();
#endif
return FALSE;
}
return TRUE;
}
void doAuthorMsg(UINT idStringFormatResource, PCSTR pszSubString);
int (STDCALL *pHhaChangeParentWindow)(HWND hwndNewParent);
extern "C" void AuthorMsg(UINT idStringFormatResource, PCSTR pszSubString, HWND hwndParent, void* phhctrl)
{
if (g_hmodHHA == NULL) {
if (g_fTriedHHA || !LoadHHA(hwndParent, _Module.GetModuleInstance()))
return; // no HHA.dll, so not a help author
}
if (!pHhaChangeParentWindow) {
(FARPROC&) pHhaChangeParentWindow = GetProcAddress(g_hmodHHA, MAKEINTATOM(311));
if (!pHhaChangeParentWindow)
return;
}
pHhaChangeParentWindow(hwndParent);
if (phhctrl)
((CHtmlHelpControl*)phhctrl)->ModalDialog(TRUE);
doAuthorMsg(idStringFormatResource, pszSubString);
if (phhctrl)
((CHtmlHelpControl*)phhctrl)->ModalDialog(FALSE);
}
void CreateDefaultWindowType(PCSTR pszCompiledFile, PCSTR pszWindow)
{
HH_WINTYPE hhWinType;
ZERO_STRUCTURE(hhWinType);
hhWinType.cbStruct = sizeof(HH_WINTYPE);
hhWinType.fsToolBarFlags = HHWIN_DEF_BUTTONS;
hhWinType.pszType = pszWindow;
CStr cszToc; // use CStr so we automatically free the memory
CStr cszIndex;
bool bFail = true ;
if (!IsEmptyString(pszCompiledFile) &&
g_phmData && g_phmData[g_curHmData])
{
bool bHasFTS = !((g_phmData[g_curHmData]->m_sysflags.fFTI) == 0) == TRUE;
bool bHasToc = IsNonEmptyString(g_phmData[g_curHmData]->GetDefaultToc()) == TRUE;
bool bHasIndex = IsNonEmptyString(g_phmData[g_curHmData]->GetDefaultIndex()) == TRUE;
bool bHasNavData = (bHasFTS || bHasToc || bHasIndex) ;
if (bHasNavData)
{
hhWinType.fsToolBarFlags |= HHWIN_BUTTON_EXPAND;
hhWinType.fsValidMembers |= HHWIN_PARAM_PROPERTIES | HHWIN_PARAM_TB_FLAGS;
hhWinType.fsWinProperties |= HHWIN_PROP_CHANGE_TITLE | HHWIN_PROP_TRI_PANE ;
if (bHasFTS)
{
hhWinType.fsWinProperties |= HHWIN_PROP_TAB_SEARCH;
}
if (bHasToc)
{
cszToc = pszCompiledFile;
cszToc += "::/";
cszToc += g_phmData[g_curHmData]->GetDefaultToc();
hhWinType.pszToc = cszToc.psz;
hhWinType.fsWinProperties |= HHWIN_PROP_AUTO_SYNC ;
}
if (bHasIndex)
{
cszIndex = pszCompiledFile;
cszIndex += "::/";
cszIndex += g_phmData[g_curHmData]->GetDefaultIndex();
hhWinType.pszIndex = cszIndex.psz;
if (!bHasToc) // REVIEW: 30 Jun 98 : Can this be removed? [dalero]
{
hhWinType.curNavType = HHWIN_NAVTYPE_INDEX;
hhWinType.fsValidMembers |= HHWIN_PARAM_TABPOS;
}
}
if (IsNonEmptyString(g_phmData[g_curHmData]->GetDefaultHtml()))
{
CStr csz, cszFull;
csz = g_phmData[g_curHmData]->GetDefaultHtml();
if (!stristr(csz, txtDoubleColonSep) &&
!stristr(csz, txtFileHeader) && !stristr(csz, txtHttpHeader))
{
cszFull = g_phmData[g_curHmData]->GetCompiledFile();
cszFull += txtSepBack;
cszFull += csz.psz;
cszFull.TransferPointer(&hhWinType.pszHome);
}
else
csz.TransferPointer(&hhWinType.pszHome);
}
if (IsNonEmptyString(g_phmData[g_curHmData]->GetDefaultCaption()))
hhWinType.pszCaption = g_phmData[g_curHmData]->GetDefaultCaption();
else
hhWinType.pszCaption = lcStrDup(GetStringResource(IDS_DEF_WINDOW_CAPTION));
// We've made a nice default window type.
bFail = false ;
}
}
if (bFail)
{
hhWinType.pszCaption = lcStrDup(GetStringResource(IDS_DEF_WINDOW_CAPTION));
}
xHtmlHelpA(NULL, pszCompiledFile, HH_SET_WIN_TYPE, (DWORD_PTR) &hhWinType);
}
BOOL IsThisAWinHelpFile(HWND hwndCaller, PCSTR pszFile)
{
if (stristr(pszFile, txtWinHelpFileExt)) {
CStr cszFile;
if (FindThisFile(hwndCaller, pszFile, &cszFile, FALSE)) {
HFILE hf = _lopen(cszFile, OF_READ);
if (hf != HFILE_ERROR) {
BYTE aMagic[2];
_lread(hf, aMagic, sizeof(aMagic));
_lclose(hf);
if (aMagic[0] == '?' && aMagic[1] == '_') { // yep, this is a WinHelp file
return TRUE;
}
}
}
}
return FALSE;
}
///////////////////////////////////////////////////////////////////////////////
//
// This does a Context ID lookup in the CollectionSpace.
//
HWND OnHelpContextInCollection(HWND hwndCaller,
LPCSTR pszColFile,
DWORD_PTR dwData)
{
HH_COLLECTION_CONTEXT* pContext = reinterpret_cast<HH_COLLECTION_CONTEXT*>(dwData);
//TODO: Validate.
if (!pContext)
{
return NULL ;
}
HWND hwndReturn = InternalHelpContext(hwndCaller, pszColFile, pContext->id, pContext);
if (!hwndReturn)
{
// We can be left in weird states after failures.
// So, we are going to be very aggresive about this and dump all the Hmdata if we don't end up
// with a window. We do this by deleting all of the CHHWinType structures.
// This is somewhat overkill, but the safest solution.
DeleteWindows() ;
}
return hwndReturn ;
}
///////////////////////////////////////////////////////////////////////////////
//
// This is the original OnHelpContext
//
HWND OnHelpContext(HWND hwndCaller, LPCSTR pszFile, DWORD_PTR dwData)
{
return InternalHelpContext(hwndCaller, pszFile, dwData, NULL);
}
///////////////////////////////////////////////////////////////////////////////
//
// Do the actual lookup.
//
HWND InternalHelpContext(HWND hwndCaller,
LPCSTR pszFile,
DWORD_PTR dwData,
HH_COLLECTION_CONTEXT* pContext)
{
CExTitle* pExTitle;
PSTR pszJumpFile;
char szMsg[256];
// Is this a WinHelp file?
if (IsThisAWinHelpFile(hwndCaller, pszFile)) {
WinHelp(hwndCaller, pszFile, HELP_CONTEXT, dwData);
return NULL;
}
PSTR psz = stristr(pszFile, txtSysRoot);
CStr cszTmp;
if (psz) {
char szPath[MAX_PATH];
GetRegWindowsDirectory(szPath);
strcat(szPath, psz + strlen(txtSysRoot));
cszTmp = szPath;
pszFile = (PCSTR) cszTmp.psz;
}
CStr cszFile(pszFile); // copy it so we can modify it
CStr cszWindow;
PSTR pszWindow = StrChr(cszFile, WINDOW_SEPARATOR);
if (pszWindow != NULL) {
*pszWindow = '\0';
RemoveTrailingSpaces(cszFile);
cszWindow = FirstNonSpace(pszWindow + 1);
}
//--- We want to be able to do a lookup in the context of a CHM.
BOOL bCollection = IsCollectionFile(cszFile);
if ((bCollection && pContext) // Only allow lookup in the collection space with valid pContext structure.
|| IsCompiledHtmlFile(cszFile, &cszFile))
{
CStr cszCompressed;
PCSTR pszFilePortion = GetCompiledName(cszFile, &cszCompressed);
if (!FindThisFile(hwndCaller, cszCompressed, &cszCompressed))
{
g_LastError.Set(HH_E_FILENOTFOUND) ; // Let FindThisFile do this when it gets a process id.
return NULL;
}
CHmData* phmData = FindCurFileData(cszCompressed);
if (!phmData)
{
g_LastError.Set(HH_E_INVALIDHELPFILE) ; // TODO: FindCurFileData should set this.
return NULL ;
}
// Handle if we have a collection.
if ( bCollection )
{
// We have to have the tag name.
if (IsEmptyString(pContext->szTag))
{
// TODO: use pszFilePortion...((*pszFilePortion == '/') ? pszFilePortion+1 : pszFilePortion
return NULL ;
}
//---Get the path to the CHM.
pExTitle = phmData->m_pTitleCollection->FindTitleNonExact(pContext->szTag,
LANGIDFROMLCID(pContext->lcid)) ;
if (!pExTitle)
{
return NULL ;
}
//
// We're setting cszFile to the FQ .CHM name for use later in this function (only in the collection case).
//
cszFile = pExTitle->GetFileName();
//
// Yes, This has a side affect we're relying on. We want IsCompiledHtmlFile to decorate the URL for us.
//
//IsCompiledHtmlFile(cszFile, &cszFile); // Doesn't work in CD swaping case.
char szTmp[MAX_PATH*4]; //REVIEW:: Inefficient
wsprintf(szTmp, "%s%s", (g_bMsItsMonikerSupport ? txtMsItsMoniker : txtMkStore), //TODO: We are adding moniker information. This should be centralized.
cszFile.psz);
cszFile = szTmp ;
}
else
{
if (! phmData->m_pTitleCollection->IsSingleTitle() )
{
g_LastError.Set(HH_E_INVALIDHELPFILE) ; // TODO: FindCurFileData should set this.
return NULL;
}
pExTitle = phmData->GetExTitle();
}
//
// Now translate the context hash int a URL so we can jump!
//
HRESULT hr = pExTitle->ResolveContextId((DWORD)dwData, &pszJumpFile);
if ( hr != S_OK )
{
g_LastError.Set(hr);
if (IsHelpAuthor(NULL))
{
if ( hr == HH_E_NOCONTEXTIDS )
doAuthorMsg(IDS_HHA_NO_MAP_SECTION, "");
else if ( hr == HH_E_CONTEXTIDDOESNTEXIT )
{
wsprintf(szMsg, pGetDllStringResource(IDS_HHA_MISSING_MAP_ID), dwData, cszFile.psz);
SendStringToParent(szMsg);
}
}
return NULL;
}
#if 0 // TEST TEST TEST
CStr test("vbcmn98.chm::/html\\vbproMaxMinPropertiesActiveXControls.htm") ;
pszJumpFile = test ;
#endif //TEST TEST TEST
BOOL fIsInterFileJump = IsCompiledHtmlFile(pszJumpFile);
char szUrl[MAX_PATH*4];
if (bCollection & fIsInterFileJump)
{
//--- This is an interfile jump in the context of the collection.
// We need a full path to this file so that we can find it.
CStr pszChmName;
PCSTR pszTopic = GetCompiledName(pszJumpFile, &pszChmName);
// Remove the extension.
PSTR pszExt = stristr(pszChmName, txtDefExtension); // case insensitive search.
if (pszExt)
*pszExt = '\0' ;
// Look in the global col file for this chm.
HH_TITLE_FULLPATH tf ;
tf.lcid = pContext->lcid ;
tf.szTag = pszChmName ;
tf.fullpathname = NULL;
if (GetLocationFromTitleTag(NULL/*cszCompressed*/, &tf))
{
// Found it.
CStr full(tf.fullpathname) ; // Convert.
wsprintf(szUrl, "%s%s::%s", (g_bMsItsMonikerSupport ? txtMsItsMoniker : txtMkStore), //TODO: We are adding moniker information. This should be centralized.
full.psz,
pszTopic);
::SysFreeString(tf.fullpathname); // cleanup.
}
else
{
// Didn't find it. hope for the best...maybe its in the windows help directory.
strcpy(szUrl, pszJumpFile);
}
}
else if (fIsInterFileJump)
{
// On an interfile jump we are given the name of the chm and the topic: "help.chm::topic.htm"
// So we don't combine the two together.
// BUGBUG: This will rarely work, since we will not have a fullpath to the chm.
// To work, it must be in the windows help directory.
strcpy(szUrl, pszJumpFile);
}
else
{
// Combine the chm name with the topic name.
wsprintf(szUrl, "%s::/%s", cszFile.psz, pszJumpFile);
}
// Add on the window.
if (cszWindow.IsNonEmpty()) {
strcat(szUrl, ">");
strcat(szUrl, cszWindow);
}
if (IsHelpAuthor(NULL)) {
wsprintf(szMsg, pGetDllStringResource(IDS_HHA_HH_HELP_CONTEXT),
fIsInterFileJump ? "" : cszFile.psz, dwData, pszJumpFile);
SendStringToParent(szMsg);
}
// Send the COL file to HH_DISPLAY_TOPIC. Also send the chm::htm string.
if (bCollection)
{
return OnDisplayTopic(hwndCaller, cszCompressed, (DWORD_PTR)szUrl);
}
else
{
return OnDisplayTopic(hwndCaller, szUrl, NULL);
}
}
else
{
return NULL ;
}
}
/***************************************************************************
FUNCTION: SetWinType
PURPOSE:
PARAMETERS:
hwndCaller -- window requesting this topic
pszFile -- file and window
bFindCurdata -- if true, it will call FindCurFileData.
Only ReadSystemFiles should call this with True. Its main purpose is to prevent
re-entering ReadSystemFiles.
RETURNS:
COMMENTS:
MODIFICATION DATES:
27-Apr-98
***************************************************************************/
HWND
SetWinType(LPCSTR pszFile, HH_WINTYPE* phhWinType, CHmData* phmDataOrg /*= NULL*/)
{
// Check for uninitialized or invalid pointers
if (IsBadReadPtr(phhWinType, sizeof(HH_WINTYPE*)))
// BUGBUG: nag the help author
return FALSE;
if (IsBadReadPtr(phhWinType->pszType, sizeof(PCSTR)) || IsEmptyString(phhWinType->pszType))
// BUGBUG: nag the help author
return FALSE;
if (IsNonEmptyString(pszFile))
{
// If a CHM happens to have a global window type in it, we do not want to re-load the window type information
// from the CHM if it has already been loaded. Bug 1.1c 5175
if (IsGlobalWinType(phhWinType->pszType))
{
// We are attempting to load the win type information from the CHM.
// Check to see if it has already been loaded.
CHHWinType* phh = FindWindowType(phhWinType->pszType, NULL, NULL);
if (phh)
{
// Don't over write the window type.
return FALSE ;
}
}
// Window types are owned by a particular chm. Unless they are global....
if (!phmDataOrg)
{
FindCurFileData(pszFile); // We aren't getting loaded by SetWinType. So we don't have an Org file...
}
}
else
{
// No filename specified. Must be a global window type.
if (!IsGlobalWinType(phhWinType->pszType))
{
// Force it to be a global window type.
_Module.m_GlobalWinTypes.Add(phhWinType->pszType) ;
}
}
// The following code will over write any current definitions of this window type.
CHHWinType* phh = FindOrCreateWindowSlot(phhWinType->pszType, pszFile);
if (!phh)
return FALSE ;
CHHWinType* phhNew = (CHHWinType*) phhWinType;
phh->SetUniCodeStrings(phhWinType);
phh->SetCaption(phhWinType);
phh->SetToc(phhWinType);
phh->SetIndex(phhWinType);
phh->SetFile(phhWinType);
phh->SetValidMembers(phhWinType);
phh->SetProperties(phhWinType);
phh->SetStyles(phhWinType);
phh->SetExStyles(phhWinType);
phh->SetWindowRect(phhWinType);
phh->SetDisplayState(phhWinType);
phh->SetNavExpansion(phhWinType);
phh->SetNavWidth(phhWinType);
phh->SetCaller(phhWinType);
phh->SetHome(phhWinType);
phh->SetToolBar(phhWinType);
phh->SetTabPos(phhWinType);
phh->SetTabOrder(phhWinType);
phh->SetJump1(phhWinType);
phh->SetJump2(phhWinType);
phh->SetCurNavType(phhWinType);
phh->idNotify = phhWinType->idNotify;
if (phmDataOrg)
{
/*
We are being loaded from ReadSystemFiles. We need to store the CHMDATA from which we are created,
so that we get the custom tab information from the [options] sections of the correct CHM. The
m_pChmData paramter isn't good enough since it is arbitarily set during create window and is over written
as a result of the HH_RELOAD_NAV_DATA.
*/
phh->m_phmDataOrg = phmDataOrg ;
}
// If there isn't a table of contents, turn off various parameters.
if (!phh->IsValidNavPane(HH_TAB_CONTENTS))
{
if (phh->IsValidMember(HHWIN_PARAM_TB_FLAGS))
{
phh->fsToolBarFlags &= ~HHWIN_BUTTON_TOC_PREV ;
phh->fsToolBarFlags &= ~HHWIN_BUTTON_TOC_NEXT ;
}
}
// If we are a tri-pane window with nothing to expand,
// then shut off the automatic expansion
if (!phh->AnyValidNavPane())
{
phh->fNotExpanded = TRUE;
// Bug 1084 Disable the Expand button also.
phh->fsToolBarFlags &= ~HHWIN_BUTTON_EXPAND ;
}
#ifdef _DEBUG
DWORD dwOldStyle;
#endif
// Does this window type name already exist.
if (!phh->GetTypeName())
{
phh->SetTypeName(phhWinType);
return phh->GetHwnd();
}
else
{
// Change the existing window type.
// REVIEW: IsValidWindow(phh->GetHwnd() is called TOO often
// Set Caption
if (phhNew->GetCaption() && IsValidWindow(phh->GetHwnd()))
SetWindowText(phh->GetHwnd(), phh->GetCaption());
// Set window styles
bool bStyleChanged = false ;
if (phhNew->IsValidMember(HHWIN_PARAM_STYLES))
{
phh->AddStyle(WS_VISIBLE | WS_CLIPSIBLINGS); //REVIEW: Why isn't this part of DEFAULT_STYLE?
if (IsValidWindow(phh->GetHwnd()))
{
#ifdef _DEBUG
dwOldStyle = GetWindowLong(*phh, GWL_STYLE);
#endif
SetWindowLong(*phh, GWL_STYLE, phh->GetStyles());
bStyleChanged = true;
}
}
// Change extended window styles.
if (phhNew->IsValidMember(HHWIN_PARAM_EXSTYLES))
{
if (!(phhNew->IsProperty(HHWIN_PROP_NODEF_EXSTYLES)))
{
if (IsValidWindow(phh->GetHwnd()))
phh->AddStyle(GetWindowLong(phh->GetHwnd(), GWL_EXSTYLE));
if (phhWinType->fsWinProperties & HHWIN_PROP_ONTOP)
phh->AddStyle(WS_EX_TOPMOST);
}
if (IsValidWindow(phh->GetHwnd())) {
#ifdef _DEBUG
dwOldStyle = GetWindowLong(phh->GetHwnd(), GWL_EXSTYLE);
#endif
SetWindowLong(phh->GetHwnd(), GWL_EXSTYLE, phh->GetExStyles());
bStyleChanged = true;
}
}
if (bStyleChanged)
{
// Must call this for SetWindowLong to take affect. See docs for SetWindowPos and SetWindowLong.
SetWindowPos(phh->GetHwnd(), NULL, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_FRAMECHANGED) ;
}
// Change the rect.
if (phhNew->IsValidMember(HHWIN_PARAM_RECT))
{
phh->GetWindowRect();
if (phhNew->GetLeft() >= 0)
phh->rcWindowPos.left = phhNew->GetLeft();
if (phhNew->GetRight() >= 0)
phh->rcWindowPos.right = phhNew->GetRight();
if (phhNew->GetTop() >= 0)
phh->rcWindowPos.top = phhNew->GetTop();
if (phhNew->GetBottom() >= 0)
phh->rcWindowPos.bottom = phhNew->GetBottom();
if (IsValidWindow(*phh))
MoveWindow(*phh, phh->GetLeft(), phh->GetTop(),
phh->GetWidth(), phh->GetHeight(), TRUE);
}
// Change the show state.
if (phhNew->IsValidMember(HHWIN_PARAM_SHOWSTATE))
{
if (IsValidWindow(phh->GetHwnd()))
ShowWindow(phh->GetHwnd(), phh->GetShowState());
}
return phh->GetHwnd();
}
}
/***************************************************************************
FUNCTION: GetWinType
PURPOSE:
PARAMETERS:
hwndCaller -- window requesting this topic
pszFile -- file and window
RETURNS:
COMMENTS:
MODIFICATION DATES:
27-Apr-98
***************************************************************************/
HWND
GetWinType(HWND hwndCaller, LPCSTR pszFile, HH_WINTYPE** pphh)
{
CStr cszChmName ;
CStr cszWindow ;
// Support global window types
//
if(pszFile)
{
LPCSTR pszWinType = pszFile;
if(pszWinType[0]=='>')
pszWinType++;
if(pszWinType && IsGlobalWinType(pszWinType))
{
CHHWinType* phh = FindWindowType(pszWinType, hwndCaller, cszChmName);
if (!phh)
return (HWND) -1;
*pphh = phh;
return phh->GetHwnd();
}
}
// A filename and window type name are required to get the window type.
if (!GetNameAndWinType(pszFile, cszChmName, cszWindow))
{
return (HWND) -1;
}
// Read in the chm information.
if (!IsCompiledHtmlFile(cszChmName, &cszChmName))
{
return (HWND) -1;
}
CStr cszCompressed ;
GetCompiledName(cszChmName, &cszCompressed);
CHmData* phm = FindCurFileData(cszCompressed);
if (!phm)
{
return (HWND) -1;
}
// Need to include compiled filename with window lookup
// since there can be two or more .CHM files with identical window type
// names, but different definitions
CHHWinType* phh = FindWindowType(cszWindow, hwndCaller, cszChmName);
if (!phh)
{
//BUG 5004: Not sure what the purpose of all of this stuff is. However,
// cszWindow doesn't have the '>' prefix and txtDefWindow does...[dalero]
if (strcmp(cszWindow, (txtDefWindow+1)) != 0)
{
AuthorMsg(IDSHHA_NO_HH_GET_WIN_TYPE, cszWindow, hwndCaller, NULL);
}
return (HWND) -1;
}
*pphh = phh;
return phh->GetHwnd();
}
/***************************************************************************
FUNCTION: doDisplaySearch
PURPOSE: Save as HH_DISPLAY_TOPIC, but forces search tab to front.
PARAMETERS:
hwndCaller -- window requesting this topic
pszFile -- file and optionally the window to display
pFtsQuery -- the query information structure.
RETURNS:
Window handle on success
NULL on failure
COMMENTS:
MODIFICATION DATES:
26-Jun-97
***************************************************************************/
HWND doDisplaySearch(HWND hwndCaller, LPCSTR pszFile, HH_FTS_QUERY* pFtsQuery)
{
//
// Pre-conditions
//
// Null pointers
ASSERT(IsNonEmptyString(pszFile));
ASSERT(pFtsQuery);
if (IsEmptyString(pszFile) || IsBadReadPtr(pFtsQuery, sizeof(HH_FTS_QUERY*)))
{
FAIL("HH_DISPLAY_SEARCH: pszFile or pFtsQuery is invalid.") ;
return NULL;
}
// Incorrect structure size.
if (pFtsQuery->cbStruct != sizeof(HH_FTS_QUERY))
{
// REVIEW: means all previous versions fail the instant we change the
// structure size. We should just fill in the parts of the structure
// we don't know about.
FAIL("HH_DISPLAY_SEARCH: pFtsQuery points to structure with incorrect size.");
return NULL ;
}
//
// Handle parameters.
//
// String pointer can be NULL, if search is not seeded.
// TODO - Query string.
// Change Proximity
if (pFtsQuery->iProximity != HH_FTS_DEFAULT_PROXIMITY)
{
}
// Convert Strings
if (pFtsQuery->fUniCodeStrings)
{
FAIL("HH_DISPLAY_SEARCH: fUniCodeStrings is not yet implemented. Ignoring.") ;
}
// Manipulate options
if (pFtsQuery->fStemmedSearch)
{
FAIL("HH_DISPLAY_SEARCH: fStemmedSearch is not yet implemented. Ignoring.") ;
}
if (pFtsQuery->fTitleOnly)
{
FAIL("HH_DISPLAY_SEARCH: fTitleOnly is not yet implemented. Ignoring.") ;
}
// Can only Execute if there is a search string.
if (pFtsQuery->fExecute)
{
FAIL("HH_DISPLAY_SEARCH: fExecute is not yet implemented. Ignoring.") ;
}
// Merge the window with the filename.
CStr cszFile(pszFile);
if (!IsEmptyString(pFtsQuery->pszWindow))
{
cszFile += ">";
// BUGBUG: Doesn't handle UNICODE
cszFile += pFtsQuery->pszWindow;
}
// Display the topic
HWND hwnd = ReactivateDisplayTopic(hwndCaller, pszFile, 0);
// Did it succeed?
if (!hwnd || !IsValidWindow(hwnd))
{
FAIL("HH_DISPLAY_SEARCH: Could not start help system.") ;
return NULL ;
}
// BUGBUG: 19-Jun-1997 [ralphw] Why are we doing this? It's already on top
// Bring help window to front.
::BringWindowToTop(hwnd);
// Change the current tab.
CHHWinType* phh = FindHHWindowIndex(hwnd);
ASSERT(phh);
phh->doSelectTab(HH_TAB_SEARCH) ;
// TODO: Seed edit box.
// Done
return hwnd;
}
/***************************************************************************
FUNCTION: doDisplayIndex
PURPOSE: Does a DISPLAY_TOPIC but ensures that the Index tab is selected.
PARAMETERS:
hwndCaller -- window requesting this topic
pszFile -- file and optionally the window to display
pszKeyword -- keyword with which to seed edit control
RETURNS:
Window handle on success
NULL on failure
COMMENTS:
MODIFICATION DATES:
26-Jun-97 [dalero] created.
***************************************************************************/
HWND doDisplayIndex(HWND hwndCaller, LPCSTR pszFile, LPCSTR pszKeyword)
{
//
// Pre-conditions
//
// Null pointers
ASSERT(IsNonEmptyString(pszFile));
if (IsEmptyString(pszFile))
{
FAIL("HH_DISPLAY_SEARCH: pszFile or pFtsQuery is invalid.") ;
return NULL;
}
// Display the topic
HWND hwnd = ReactivateDisplayTopic(hwndCaller, pszFile, 0);
// Did it succeed?
if (!hwnd || !IsValidWindow(hwnd))
{
FAIL("HH_DISPLAY_SEARCH: Could not start help system.") ;
return NULL ;
}
// Bring help window to front.
::BringWindowToTop(hwnd);
// Change the current tab.
CHHWinType* phh = FindHHWindowIndex(hwnd);
ASSERT(phh);
phh->doSelectTab(HH_TAB_INDEX) ;
#define _SEED_ON_
#ifdef _SEED_ON_
// Seed Edit Control
//ASSERT(phh->m_pindex != NULL) ;
if ((phh->m_aNavPane[HH_TAB_INDEX] != NULL) && pszKeyword )
{
phh->m_aNavPane[HH_TAB_INDEX]->Seed(pszKeyword) ;
}
#endif
// Done
return hwnd;
}
/***************************************************************************
FUNCTION: doDisplayToc
PURPOSE: Does a DISPLAY_TOPIC but ensures that the TOC tab is selected.
PARAMETERS:
hwndCaller -- window requesting this topic
pszFile -- file and optionally the window to display
RETURNS:
Window handle on success
NULL on failure
COMMENTS:
MODIFICATION DATES:
26-Jun-97 [dalero] created.
***************************************************************************/
HWND doDisplayToc(HWND hwndCaller, LPCSTR pszFile, DWORD_PTR dwData)
{
//
// Pre-conditions
//
// Null pointers
ASSERT(IsNonEmptyString(pszFile));
if (IsEmptyString(pszFile))
{
FAIL("HH_DISPLAY_SEARCH: pszFile or pFtsQuery is invalid.") ;
return NULL;
}
HWND hwnd = ReactivateDisplayTopic(hwndCaller, pszFile, dwData);
// Did it succeed?
if (!hwnd || !IsValidWindow(hwnd))
{
FAIL("HH_DISPLAY_SEARCH: Could not start help system.") ;
return NULL ;
}
// Bring help window to front.
::BringWindowToTop(hwnd);
// Change the current tab.
CHHWinType* phh = FindHHWindowIndex(hwnd);
ASSERT(phh);
phh->doSelectTab(HH_TAB_CONTENTS) ;
// Done
return hwnd;
}
/***************************************************************************
FUNCTION: GetLocationFromTitleTag
PURPOSE: Looks in the global col to find the location for this TitleTag
PARAMETERS:
pszFile --- Filename of the collection to look in. NULL for global.col
HH_TITLE_FULLPATH pTitleFullPath
RETURNS:
NULL on failure
COMMENTS:
MODIFICATION DATES:
31-Oct-97 [dalero] created.
03-Apr-98 [dalero] the szCollection parameter is currently not used.
***************************************************************************/
int
GetLocationFromTitleTag(LPCSTR szCollection, HH_TITLE_FULLPATH* pTitleFullPath)
{
int iReturn = false ;
// Open a dummy collection.
CCollection collection ;
DWORD e = collection.Open(szCollection ? szCollection : "placeholder") ;
if (e == F_OK)
{
// Locates a title based on id
CTitle* pTitle = collection.FindTitleNonExact(pTitleFullPath->szTag, LANGIDFROMLCID(pTitleFullPath->lcid)) ;
if (pTitle)
{
// Always get the last one.
LOCATIONHISTORY* pLocationHistory = pTitle->m_pTail;//LOCATIONHISTORY* pLocationHistory = pTitle->GetLocation(/*DWORD Index*/0);
if (pLocationHistory && pLocationHistory->FileName)
{
CWStr wide(pLocationHistory->FileName) ;
pTitleFullPath->fullpathname = ::SysAllocString(wide) ;
iReturn = true ;
}
}
}
return iReturn ;
}
/***************************************************************************
FUNCTION: ReactivateDisplayTopic
PURPOSE: If default window type exists, returns HWND.
Otherwise, does an OnDisplayTopic.
This allows OnDisplayToc and others to not change the current topic when changing the tab.
PARAMETERS:
RETURNS:
NULL on failure
COMMENTS:
MODIFICATION DATES:
13 Jan 98 [dalero] created.
***************************************************************************/
HWND ReactivateDisplayTopic(HWND hwndCaller, LPCSTR pszFile, DWORD_PTR dwData)
{
// A lot of this is copied from OnDisplayTopic...
CStr cszFile(pszFile);
CStr cszCompressed ;
GetCompiledName(cszFile, &cszCompressed);
if (FindThisFile(hwndCaller, cszCompressed, &cszCompressed, FALSE))
{
// Get the CHmData for this file.
CHmData* phmData = FindCurFileData(cszCompressed); // Get the
if (phmData)
{
// Get the info for the default window type structure.
CHHWinType* phh = FindWindowType(phmData->GetDefaultWindow(), hwndCaller, cszCompressed);
if (phh && phh->GetHwnd() && IsWindow(phh->GetHwnd()))
{
WINDOWPLACEMENT wp;
wp.length = sizeof(WINDOWPLACEMENT);
GetWindowPlacement(phh->GetHwnd(), &wp);
if (wp.showCmd == SW_SHOWMINIMIZED)
{
ShowWindow(phh->GetHwnd(), SW_RESTORE);
}
SetForegroundWindow(phh->GetHwnd());
return phh->GetHwnd() ;
}
}
}
// Display the topic
return OnDisplayTopic(hwndCaller, pszFile, 0);
}
/***************************************************************************
FUNCTION: ReactivateDisplayTopic
PURPOSE: If default window type exists, returns HWND.
Otherwise, does an OnDisplayTopic.
This allows OnDisplayToc and others to not change the current topic when changing the tab.
PARAMETERS:
RETURNS:
NULL on failure
COMMENTS:
MODIFICATION DATES:
13 Jan 98 [dalero] created.
***************************************************************************/
bool
SetGlobalProperty(HH_GLOBAL_PROPERTY* prop, CHHWinType *phh)
{
bool bReturn = false ;
if (!prop)
return bReturn;
switch(prop->id)
{
case HH_GPROPID_SINGLETHREAD:
if (prop->var.vt == VT_BOOL)
{
g_fStandAlone = (prop->var.boolVal == VARIANT_TRUE) ;
bReturn = true ;
}
break ;
case HH_GPROPID_TOOLBAR_MARGIN:
if ( prop->var.vt == VT_UI4 || prop->var.vt == VT_UINT )
{
long L, R;
R = HIWORD( prop->var.ulVal );
L = LOWORD( prop->var.ulVal );
if ( (L == g_tbLeftMargin) && (R == g_tbRightMargin) )
return TRUE;
g_tbRightMargin = HIWORD( prop->var.ulVal );
g_tbLeftMargin = LOWORD( prop->var.ulVal );
if ( phh && phh->hwndToolBar )
{
::SendMessage(phh->hwndHelp, WM_SIZE, SIZE_RESTORED, (LPARAM)0 );
// Due to a repaint bug in IE 3.02 Comctrl with the toolbar, we need to
// reapint the whole toolbar region including the margins on the left and right.
RECT rcvoid;
rcvoid.top = 0;
rcvoid.bottom = RECT_HEIGHT(phh->rcToolBar);
rcvoid.left = 0;
rcvoid.right = RECT_WIDTH(phh->rcWindowPos);
InvalidateRect(phh->hwndHelp, &rcvoid, TRUE);
UpdateWindow(phh->hwndHelp);
bReturn = true ;
}
}
break;
case HH_GPROPID_UI_LANGUAGE:// Set the language for hhctrl's ui.
{
LANGID request = NULL ;
// Convert the val to a LANGID.
if (prop->var.vt == VT_I4)
{
request = static_cast<LANGID>(prop->var.lVal) ;
}
else if (prop->var.vt = VT_I2)
{
request = prop->var.iVal ;
}
else if (prop->var.vt = VT_UI4)
{
request = prop->var.uiVal ;
}
else if (prop->var.vt = VT_UI2)
{
request = static_cast<LANGID>(prop->var.ulVal) ;
}
if (request)
{
// Request this langid.
LANGID result = _Module.m_Language.SetUiLanguage(request) ;
bReturn = (result == request) ;
}
}
break ;
case HH_GPROPID_CURRENT_SUBSET:
{
if ( prop->var.vt == VT_BSTR && prop->var.bstrVal && *(prop->var.bstrVal) )
{
WideCharToMultiByte(CP_ACP, 0, prop->var.bstrVal, -1, _Module.szCurSS, MAX_SS_NAME_LEN, NULL, NULL);
bReturn = true ; // TODO: Increase robustness!
}
}
break;
default:
ASSERT(0) ;
}
return bReturn ;
}
//////////////////////////////////////////////////////////////////////////
//
// GetNameAndWinType ---(from pszfile) Splits out the name and window type.
//
bool
GetNameAndWinType(LPCSTR pszFile, CStr& cszName, CStr& cszWindow)
{
if (IsEmptyString(pszFile))
{
return false ;
}
// Copy the string.
cszName = pszFile;
// Parse out window type.
PSTR pszWindow = StrChr(cszName, WINDOW_SEPARATOR);
if (pszWindow != NULL)
{
// Terminate the string.
*pszWindow = '\0';
RemoveTrailingSpaces(cszName);
cszWindow = FirstNonSpace(pszWindow + 1);
}
else
{
if(pszFile && IsGlobalWinType(pszFile))
cszWindow = pszFile;
}
// Must have a window type.
if (cszWindow.IsNonEmpty())
{
// Must either be a global window type, or have a filename.
if (IsGlobalWinType(cszWindow) || cszName.IsNonEmpty())
{
return true ;
}
}
return false;
}
//////////////////////////////////////////////////////////////////////////
//
// Reload the nav panes with data from a different CHM.
// NOTE: This is a dangerous Hack for Office.
//
HWND OnReloadNavData(HWND hwndCaller, LPCSTR pszFile, HH_NAVDATA* pNavData)
{
// Remember that the members of pNavData are unicode...
if (IsNonEmptyString(pszFile) // pszFile is not used
//|| !IsValidWindow(hwndCaller) --- Allows reparenting. See FindWindowType
|| !pNavData
|| IsEmptyStringW(pNavData->pszName)
|| IsEmptyStringW(pNavData->pszFile)
|| !IsGlobalWinTypeW(pNavData->pszName) // Window Type must be global!
)
{
return NULL ;
}
// Make sure that we have a compiled filename.
CStr cszFile(pNavData->pszFile) ; // Convert to ANSI.
if (!IsCompiledHtmlFile(cszFile, &cszFile))
{
return NULL ;
}
// Parse out all of the unnecessary bits...
GetCompiledName(cszFile, &cszFile);
if (cszFile.IsEmpty())
{
return NULL ;
}
// Get the CHmData structure for this file.
CHmData* phmdata = FindCurFileData(cszFile) ;
if (!phmdata)
{
return NULL;
}
// Find the window type.
CStr cszName(pNavData->pszName) ; // Convert to ANSI.
CHHWinType* phh = FindWindowType(cszName, hwndCaller, NULL) ; // WindowType must be global!
if (!phh)
{
// Couldn't find the window type. It must be defined.
return NULL ;
}
// Go do it!
phh->ReloadNavData(phmdata) ;
return phh->GetHwnd() ;
}
//////////////////////////////////////////////////////////////////////////
//
// CSession - This is a placeholder class. This will eventually do something.
//
// This should be moved to its own C++ file...
//
class CSession
{
public:
CSession();
~CSession();
private:
DWORD* m_dwData ;
};
// Constructor
CSession::CSession()
: m_dwData(0)
{
//--- Initialize OLE. Competes with process detach/attach.
if ( !g_fCoInitialized )
{
if (S_FALSE == OleInitialize(NULL))
{
// shanemc/dalero
// If S_FALSE is returned OLE was already init'd. We don't want to uninit later
// because it can hose apps that have called OleInit (like IE).
OleUninitialize();
}
else
{
g_fCoInitialized = TRUE; // so that we call CoUninitialize() when dll is unloaded
}
}
}
// Destructor
CSession::~CSession()
{
//--- Unitialize OLE.
ASSERT(g_fCoInitialized); // Should never be FALSE here.
if (g_fCoInitialized)
{
OleUninitialize();
g_fCoInitialized = FALSE;
}
}
//////////////////////////////////////////////////////////////////////////
//
// Initializes everything we need initialized.
//
bool
InitializeSession(UNALIGNED DWORD_PTR* pCookie)
{
bool bReturn = false ;
if (pCookie)
{
//--- Create a session object.
CSession* p = new CSession() ;
// The session object is used as a cookie.
*pCookie = (DWORD_PTR)p;
// Initializing a session, implies standalone.
g_fStandAlone = TRUE ;
// A-ok
bReturn = true ;
}
return bReturn;
}
//////////////////////////////////////////////////////////////////////////
//
// Uninitalizes everything we need initialized.
//
bool
UninitializeSession(DWORD_PTR Cookie)
{
bool bReturn = false ;
ASSERT(g_fStandAlone) ; // Must be standalone.
//--- Need a valid cookie to uninitialize.
if (Cookie)
{
// Convert to a session pointer.
CSession* p = reinterpret_cast<CSession*>(Cookie) ;
// Do something useful.
bReturn = true ;
// Delete the session.
delete p ;
}
return bReturn ;
}
//////////////////////////////////////////////////////////////////////////
//
// Private function which returns the interface pointer to the embedded
// WebBrowser control given a particular window handle.
//
bool
GetBrowserInterface(HWND hWndBrowserParent, IDispatch** ppWebBrowser)
{
bool bReturn = false ;
if (IsWindow(hWndBrowserParent) && !IsBadReadPtr(ppWebBrowser, sizeof(IDispatch**)))
{
CHHWinType* phh = FindHHWindowIndex(hWndBrowserParent);
if (phh &&
phh->m_pCIExpContainer &&
phh->m_pCIExpContainer->m_pWebBrowserApp &&
phh->m_pCIExpContainer->m_pWebBrowserApp->m_lpDispatch)
{
*ppWebBrowser = phh->m_pCIExpContainer->m_pWebBrowserApp->m_lpDispatch;
bReturn = true ;
}
}
return bReturn ;
}
Reference in New Issue View Git Blame Copy Permalink