2390 lines
78 KiB
C++
2390 lines
78 KiB
C++
// 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 ;
|
|
}
|