mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3717 lines
105 KiB
3717 lines
105 KiB
// Copyright (C) 1996-1997 Microsoft Corporation. All rights reserved.
|
|
|
|
#include "header.h"
|
|
#include "secwin.h"
|
|
|
|
#include "strtable.h"
|
|
#include "hha_strtable.h"
|
|
#include "htmlhelp.h"
|
|
#include <commctrl.h>
|
|
|
|
#include "sitemap.h" // ReplaceEscapes
|
|
|
|
#include <shlobj.h> // CSIDL_X defs
|
|
|
|
// global window type array.
|
|
#include "gwintype.h"
|
|
#include "cstr.h"
|
|
|
|
#ifndef _DEBUG
|
|
#undef THIS_FILE
|
|
static const char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#ifndef _DEBUG
|
|
#pragma optimize("a", on)
|
|
#endif
|
|
|
|
#define PT_TO_PIXELS(hdc, pt) MulDiv(-(pt), GetDeviceCaps(hdc, LOGPIXELSY), 72)
|
|
|
|
static POINT GetTextSize(HDC hdc, PCSTR qchBuf, int iCount);
|
|
static POINT GetTextSizeW(HDC hdc, WCHAR *qchBuf, int iCount);
|
|
|
|
BOOL IsDigitW(WCHAR ch) { return (ch >= L'0' && ch <= 'L9'); }
|
|
|
|
int IEColorToWin32Color( PCWSTR pwsz )
|
|
{
|
|
// input: "#rrggbb"
|
|
// output: int in hex form of 0xbbggrr
|
|
char sz[9];
|
|
strcpy( sz, "0x" );
|
|
|
|
// get blue
|
|
WideCharToMultiByte( CP_ACP, 0, pwsz+5, 2, &(sz[2]), 2, NULL, NULL );
|
|
|
|
// get green
|
|
WideCharToMultiByte( CP_ACP, 0, pwsz+3, 2, &(sz[4]), 2, NULL, NULL );
|
|
|
|
// get red
|
|
WideCharToMultiByte( CP_ACP, 0, pwsz+1, 2, &(sz[6]), 2, NULL, NULL );
|
|
|
|
// null terminate the string
|
|
sz[8] = 0;
|
|
|
|
// convert it
|
|
return Atoi( sz );
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// MakeWideFromAnsi
|
|
//=--------------------------------------------------------------------------=
|
|
// given a string, make a BSTR out of it.
|
|
//
|
|
// Parameters:
|
|
// LPSTR - [in]
|
|
// BYTE - [in]
|
|
//
|
|
// Output:
|
|
// LPWSTR - needs to be cast to final desired result
|
|
//
|
|
// Notes:
|
|
//
|
|
|
|
LPWSTR MakeWideStrFromAnsi(LPSTR psz, BYTE bType)
|
|
{
|
|
LPWSTR pwsz;
|
|
int i;
|
|
|
|
ASSERT(psz)
|
|
|
|
// compute the length of the required BSTR
|
|
|
|
i = MultiByteToWideChar(CP_ACP, 0, psz, -1, NULL, 0);
|
|
if (i <= 0)
|
|
return NULL;
|
|
|
|
// allocate the widestr
|
|
|
|
switch (bType) {
|
|
case STR_BSTR:
|
|
// -1 since it'll add it's own space for a NULL terminator
|
|
|
|
pwsz = (LPWSTR) SysAllocStringLen(NULL, i - 1);
|
|
break;
|
|
|
|
case STR_OLESTR:
|
|
pwsz = (LPWSTR) CoTaskMemAlloc(i * sizeof(WCHAR));
|
|
break;
|
|
|
|
default:
|
|
FAIL("Bogus String Type.");
|
|
}
|
|
|
|
if (!pwsz)
|
|
return NULL;
|
|
MultiByteToWideChar(CP_ACP, 0, psz, -1, pwsz, i);
|
|
pwsz[i - 1] = 0;
|
|
return pwsz;
|
|
}
|
|
|
|
|
|
LPWSTR MakeWideStr(LPSTR psz, UINT codepage)
|
|
{
|
|
LPWSTR pwsz;
|
|
int i;
|
|
|
|
ASSERT(psz)
|
|
|
|
// compute the length of the required BSTR
|
|
|
|
i = MultiByteToWideChar(codepage, 0, psz, -1, NULL, 0);
|
|
if (i <= 0)
|
|
return NULL;
|
|
|
|
++i;
|
|
|
|
pwsz = (WCHAR *) malloc(i * sizeof(WCHAR));
|
|
|
|
if (!pwsz)
|
|
return NULL;
|
|
|
|
MultiByteToWideChar(codepage, 0, psz, -1, pwsz, i);
|
|
|
|
return pwsz;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// MakeWideStrFromResId
|
|
//=--------------------------------------------------------------------------=
|
|
// given a resource ID, load it, and allocate a wide string for it.
|
|
//
|
|
// Parameters:
|
|
// WORD - [in] resource id.
|
|
// BYTE - [in] type of string desired.
|
|
//
|
|
// Output:
|
|
// LPWSTR - needs to be cast to desired string type.
|
|
//
|
|
// Notes:
|
|
//
|
|
|
|
LPWSTR MakeWideStrFromResourceId (WORD wId, BYTE bType)
|
|
{
|
|
int i;
|
|
|
|
char szTmp[512];
|
|
|
|
// load the string from the resources.
|
|
//
|
|
i = LoadString(_Module.GetResourceInstance(), wId, szTmp, 512);
|
|
if (!i)
|
|
return NULL;
|
|
|
|
return MakeWideStrFromAnsi(szTmp, bType);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// MakeWideStrFromWide
|
|
//=--------------------------------------------------------------------------=
|
|
// given a wide string, make a new wide string with it of the given type.
|
|
//
|
|
// Parameters:
|
|
// LPWSTR - [in] current wide str.
|
|
// BYTE - [in] desired type of string.
|
|
//
|
|
// Output:
|
|
// LPWSTR
|
|
//
|
|
// Notes:
|
|
//
|
|
LPWSTR MakeWideStrFromWide
|
|
(
|
|
LPWSTR pwsz,
|
|
BYTE bType
|
|
)
|
|
{
|
|
LPWSTR pwszTmp;
|
|
int i;
|
|
|
|
if (!pwsz) return NULL;
|
|
|
|
// just copy the string, depending on what type they want.
|
|
//
|
|
switch (bType) {
|
|
case STR_OLESTR:
|
|
i = lstrlenW(pwsz);
|
|
pwszTmp = (LPWSTR)CoTaskMemAlloc((i * sizeof(WCHAR)) + sizeof(WCHAR));
|
|
if (!pwszTmp) return NULL;
|
|
memcpy(pwszTmp, pwsz, (sizeof(WCHAR) * i) + sizeof(WCHAR));
|
|
break;
|
|
|
|
case STR_BSTR:
|
|
pwszTmp = (LPWSTR)SysAllocString(pwsz);
|
|
break;
|
|
}
|
|
|
|
return pwszTmp;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// StringFromGuidA
|
|
//=--------------------------------------------------------------------------=
|
|
// returns an ANSI string from a CLSID or GUID
|
|
//
|
|
// Parameters:
|
|
// REFIID - [in] clsid to make string out of.
|
|
// LPSTR - [in] buffer in which to place resultant GUID.
|
|
//
|
|
// Output:
|
|
// int - number of chars written out.
|
|
//
|
|
// Notes:
|
|
//
|
|
int StringFromGuidA
|
|
(
|
|
REFIID riid,
|
|
LPSTR pszBuf
|
|
)
|
|
{
|
|
return wsprintf((char *)pszBuf, "{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", riid.Data1,
|
|
riid.Data2, riid.Data3, riid.Data4[0], riid.Data4[1], riid.Data4[2],
|
|
riid.Data4[3], riid.Data4[4], riid.Data4[5], riid.Data4[6], riid.Data4[7]);
|
|
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// RegisterUnknownObject
|
|
//=--------------------------------------------------------------------------=
|
|
// registers a simple CoCreatable object. nothing terribly serious.
|
|
// we add the following information to the registry:
|
|
//
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID> = <ObjectName> Object
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\InprocServer32 = <path to local server>
|
|
//
|
|
// Parameters:
|
|
// LPCSTR - [in] Object Name
|
|
// REFCLSID - [in] CLSID of the object
|
|
//
|
|
// Output:
|
|
// BOOL - FALSE means couldn't register it all
|
|
|
|
BOOL RegisterUnknownObject(LPCSTR pszObjectName, REFCLSID riidObject)
|
|
{
|
|
HKEY hk = NULL, hkSub = NULL;
|
|
char szGuidStr[GUID_STR_LEN];
|
|
DWORD dwPathLen, dwDummy;
|
|
char szScratch[MAX_PATH];
|
|
long l;
|
|
|
|
// clean out any garbage
|
|
|
|
UnregisterUnknownObject(riidObject);
|
|
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID> = <ObjectName> Object
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\InprocServer32 = <path to local server>
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\InprocServer32 @ThreadingModel = Apartment
|
|
//
|
|
if (!StringFromGuidA(riidObject, szGuidStr)) goto CleanUp;
|
|
wsprintf(szScratch, "CLSID\\%s", szGuidStr);
|
|
l = RegCreateKeyEx(HKEY_CLASSES_ROOT, szScratch, 0, "", REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE, NULL, &hk, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
wsprintf(szScratch, "%s Object", pszObjectName);
|
|
l = RegSetValueEx(hk, NULL, 0, REG_SZ, (BYTE *)szScratch, (ULONG)strlen(szScratch) + 1);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
l = RegCreateKeyEx(hk, "InprocServer32", 0, "", REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE, NULL, &hkSub, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
dwPathLen = GetModuleFileName(_Module.GetModuleInstance(), szScratch, sizeof(szScratch));
|
|
if (!dwPathLen)
|
|
goto CleanUp;
|
|
|
|
l = RegSetValueEx(hkSub, NULL, 0, REG_SZ, (BYTE *)szScratch, dwPathLen + 1);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
l = RegSetValueEx(hkSub, "ThreadingModel", 0, REG_SZ, (BYTE *)"Apartment", sizeof("Apartment"));
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
RegCloseKey(hkSub);
|
|
RegCloseKey(hk);
|
|
|
|
return TRUE;
|
|
|
|
CleanUp:
|
|
if (hk)
|
|
RegCloseKey(hk);
|
|
if (hkSub)
|
|
RegCloseKey(hkSub);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// RegisterAutomationObject
|
|
//=--------------------------------------------------------------------------=
|
|
// given a little bit of information about an automation object, go and put it
|
|
// in the registry.
|
|
// we add the following information in addition to that set up in
|
|
// RegisterUnknownObject:
|
|
//
|
|
//
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName> = <ObjectName> Object
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName>\CLSID = <CLSID>
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName>\CurVer = <ObjectName>.Object.<VersionNumber>
|
|
//
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName>.<VersionNumber> = <ObjectName> Object
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName>.<VersionNumber>\CLSID = <CLSID>
|
|
//
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\TypeLib = <LibidOfTypeLibrary>
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\ProgID = <LibraryName>.<ObjectName>.<VersionNumber>
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\VersionIndependentProgID = <LibraryName>.<ObjectName>
|
|
//
|
|
// Parameters:
|
|
// LPCSTR - [in] Library Name
|
|
// LPCSTR - [in] Object Name
|
|
// long - [in] Version Number
|
|
// REFCLSID - [in] LIBID of type library
|
|
// REFCLSID - [in] CLSID of the object
|
|
//
|
|
// Output:
|
|
// BOOL - FALSE means not all of it was registered
|
|
|
|
BOOL RegisterAutomationObject
|
|
(
|
|
LPCSTR pszLibName,
|
|
LPCSTR pszObjectName,
|
|
long lVersion,
|
|
REFCLSID riidLibrary,
|
|
REFCLSID riidObject
|
|
)
|
|
{
|
|
HKEY hk = NULL, hkSub = NULL;
|
|
char szGuidStr[GUID_STR_LEN];
|
|
char szScratch[MAX_PATH];
|
|
long l;
|
|
DWORD dwDummy;
|
|
|
|
// first register the simple Unknown stuff.
|
|
//
|
|
if (!RegisterUnknownObject(pszObjectName, riidObject)) return FALSE;
|
|
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName> = <ObjectName> Object
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName>\CLSID = <CLSID>
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName>\CurVer = <ObjectName>.Object.<VersionNumber>
|
|
//
|
|
strcpy(szScratch, pszLibName);
|
|
strcat(szScratch, ".");
|
|
strcat(szScratch, pszObjectName);
|
|
|
|
l = RegCreateKeyEx(HKEY_CLASSES_ROOT, szScratch, 0L, "",
|
|
REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE,
|
|
NULL, &hk, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
wsprintf(szScratch, "%s Object", pszObjectName);
|
|
l = RegSetValueEx(hk, NULL, 0L, REG_SZ, (BYTE *)szScratch, (ULONG)strlen(szScratch)+1);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
l = RegCreateKeyEx(hk, "CLSID", 0L, "", REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE, NULL, &hkSub, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
if (!StringFromGuidA(riidObject, szGuidStr))
|
|
goto CleanUp;
|
|
|
|
l = RegSetValueEx(hkSub, NULL, 0L, REG_SZ, (BYTE *)szGuidStr, (ULONG)strlen(szGuidStr) + 1);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
RegCloseKey(hkSub);
|
|
l = RegCreateKeyEx(hk, "CurVer", 0, "", REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE, NULL, &hkSub, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
wsprintf(szScratch, "%s.%s.%ld", pszLibName, pszObjectName, lVersion);
|
|
l = RegSetValueEx(hkSub, NULL, 0, REG_SZ, (BYTE *)szScratch, (ULONG)strlen(szScratch) + 1);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
RegCloseKey(hkSub);
|
|
RegCloseKey(hk);
|
|
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName>.<VersionNumber> = <ObjectName> Object
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName>.<VersionNumber>\CLSID = <CLSID>
|
|
//
|
|
l = RegCreateKeyEx(HKEY_CLASSES_ROOT, szScratch, 0, "", REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE, NULL, &hk, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
wsprintf(szScratch, "%s Object", pszObjectName);
|
|
l = RegSetValueEx(hk, NULL, 0, REG_SZ, (BYTE *)szScratch, (ULONG)strlen(szScratch) + 1);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
l = RegCreateKeyEx(hk, "CLSID", 0, "", REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE, NULL, &hkSub, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
l = RegSetValueEx(hkSub, NULL, 0, REG_SZ, (BYTE *)szGuidStr, (ULONG)strlen(szGuidStr) + 1);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
RegCloseKey(hkSub);
|
|
RegCloseKey(hk);
|
|
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\ProgID = <LibraryName>.<ObjectName>.<VersionNumber>
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\VersionIndependentProgID = <LibraryName>.<ObjectName>
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\TypeLib = <LibidOfTypeLibrary>
|
|
//
|
|
if (!StringFromGuidA(riidObject, szGuidStr)) goto CleanUp;
|
|
wsprintf(szScratch, "CLSID\\%s", szGuidStr);
|
|
|
|
l = RegCreateKeyEx(HKEY_CLASSES_ROOT, szScratch, 0, "", REG_OPTION_NON_VOLATILE,
|
|
KEY_READ|KEY_WRITE, NULL, &hk, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
l = RegCreateKeyEx(hk, "VersionIndependentProgID", 0, "", REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE, NULL, &hkSub, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
wsprintf(szScratch, "%s.%s", pszLibName, pszObjectName);
|
|
l = RegSetValueEx(hkSub, NULL, 0, REG_SZ, (BYTE *)szScratch, (ULONG)strlen(szScratch) + 1);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
RegCloseKey(hkSub);
|
|
|
|
l = RegCreateKeyEx(hk, "ProgID", 0, "", REG_OPTION_NON_VOLATILE,
|
|
KEY_READ | KEY_WRITE, NULL, &hkSub, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
wsprintf(szScratch, "%s.%s.%ld", pszLibName, pszObjectName, lVersion);
|
|
l = RegSetValueEx(hkSub, NULL, 0, REG_SZ, (BYTE *)szScratch, (ULONG)strlen(szScratch) + 1);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
RegCloseKey(hkSub);
|
|
l = RegCreateKeyEx(hk, "TypeLib", 0, "", REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE,
|
|
NULL, &hkSub, &dwDummy);
|
|
|
|
if (!StringFromGuidA(riidLibrary, szGuidStr)) goto CleanUp;
|
|
|
|
l = RegSetValueEx(hkSub, NULL, 0, REG_SZ, (BYTE *)szGuidStr, (ULONG)strlen(szGuidStr) + 1);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
RegCloseKey(hkSub);
|
|
RegCloseKey(hk);
|
|
return TRUE;
|
|
|
|
CleanUp:
|
|
if (hk) RegCloseKey(hkSub);
|
|
if (hk) RegCloseKey(hk);
|
|
return FALSE;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// RegisterControlObject.
|
|
//=--------------------------------------------------------------------------=
|
|
// in addition to writing out automation object information, this function
|
|
// writes out some values specific to a control.
|
|
//
|
|
// What we add here:
|
|
//
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\Control
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\MiscStatus\1 = <MISCSTATUSBITS>
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\ToolboxBitmap32 = <PATH TO BMP>
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID>\Version = <VERSION>
|
|
//
|
|
// Parameters:
|
|
// LPCSTR - [in] Library Name
|
|
// LPCSTR - [in] Object Name
|
|
// long - [in] Version Number
|
|
// REFCLSID - [in] LIBID of type library
|
|
// REFCLSID - [in] CLSID of the object
|
|
// DWORD - [in] misc status flags for ctl
|
|
// WORD - [in] toolbox id for control
|
|
//
|
|
// Output:
|
|
// BOOL
|
|
//
|
|
// Notes:
|
|
// - not the most terribly efficient routine.
|
|
//
|
|
BOOL RegisterControlObject
|
|
(
|
|
LPCSTR pszLibName,
|
|
LPCSTR pszObjectName,
|
|
long lVersion,
|
|
REFCLSID riidLibrary,
|
|
REFCLSID riidObject,
|
|
DWORD dwMiscStatus,
|
|
WORD wToolboxBitmapId
|
|
)
|
|
{
|
|
HKEY hk, hkSub = NULL, hkSub2 = NULL;
|
|
char szTmp[MAX_PATH];
|
|
char szGuidStr[GUID_STR_LEN];
|
|
DWORD dwDummy;
|
|
LONG l;
|
|
|
|
// first register all the automation information for this sucker.
|
|
//
|
|
if (!RegisterAutomationObject(pszLibName, pszObjectName, lVersion, riidLibrary, riidObject)) return FALSE;
|
|
|
|
// then go and register the control specific stuff.
|
|
//
|
|
StringFromGuidA(riidObject, szGuidStr);
|
|
wsprintf(szTmp, "CLSID\\%s", szGuidStr);
|
|
l = RegOpenKeyEx(HKEY_CLASSES_ROOT, szTmp, 0, KEY_ALL_ACCESS, &hk);
|
|
if (l != ERROR_SUCCESS) return FALSE;
|
|
|
|
// create the control flag.
|
|
//
|
|
l = RegCreateKeyEx(hk, "Control", 0, "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkSub, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
// now set up the MiscStatus Bits...
|
|
//
|
|
RegCloseKey(hkSub);
|
|
hkSub = NULL;
|
|
l = RegCreateKeyEx(hk, "MiscStatus", 0, "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkSub, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
szTmp[0] = '0';
|
|
szTmp[1] = '\0';
|
|
l = RegSetValueEx(hkSub, NULL, 0, REG_SZ, (BYTE *)szTmp, 2);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
l = RegCreateKeyEx(hkSub, "1", 0, "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkSub2, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
wsprintf(szTmp, "%d", dwMiscStatus);
|
|
l = RegSetValueEx(hkSub2, NULL, 0, REG_SZ, (BYTE *)szTmp, (ULONG)strlen(szTmp) + 1);
|
|
RegCloseKey(hkSub2);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
RegCloseKey(hkSub);
|
|
|
|
// now set up the toolbox bitmap
|
|
//
|
|
GetModuleFileName(_Module.GetModuleInstance(), szTmp, MAX_PATH);
|
|
wsprintf(szGuidStr, ", %d", wToolboxBitmapId);
|
|
strcat(szTmp, szGuidStr);
|
|
|
|
l = RegCreateKeyEx(hk, "ToolboxBitmap32", 0, "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkSub, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
l = RegSetValueEx(hkSub, NULL, 0, REG_SZ, (BYTE *)szTmp, (ULONG)strlen(szTmp) + 1);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
// now set up the version information
|
|
//
|
|
RegCloseKey(hkSub);
|
|
l = RegCreateKeyEx(hk, "Version", 0, "", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkSub, &dwDummy);
|
|
CLEANUP_ON_ERROR(l);
|
|
|
|
wsprintf(szTmp, "%ld.0", lVersion);
|
|
l = RegSetValueEx(hkSub, NULL, 0, REG_SZ, (BYTE *)szTmp, (ULONG)strlen(szTmp) + 1);
|
|
|
|
CleanUp:
|
|
if (hk)
|
|
RegCloseKey(hk);
|
|
if (hkSub)
|
|
RegCloseKey(hkSub);
|
|
|
|
return (l == ERROR_SUCCESS) ? TRUE : FALSE;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// UnregisterUnknownObject
|
|
//=--------------------------------------------------------------------------=
|
|
// cleans up all the stuff that RegisterUnknownObject puts in the
|
|
// registry.
|
|
//
|
|
// Parameters:
|
|
// REFCLSID - [in] CLSID of the object
|
|
//
|
|
// Output:
|
|
// BOOL - FALSE means not all of it was registered
|
|
//
|
|
// Notes:
|
|
// - WARNING: this routine will blow away all other keys under the CLSID
|
|
// for this object. mildly anti-social, but likely not a problem.
|
|
//
|
|
BOOL UnregisterUnknownObject
|
|
(
|
|
REFCLSID riidObject
|
|
)
|
|
{
|
|
char szScratch[MAX_PATH];
|
|
HKEY hk;
|
|
BOOL f;
|
|
long l;
|
|
|
|
// delete everybody of the form
|
|
// HKEY_CLASSES_ROOT\CLSID\<CLSID> [\] *
|
|
//
|
|
if (!StringFromGuidA(riidObject, szScratch))
|
|
return FALSE;
|
|
|
|
l = RegOpenKeyEx(HKEY_CLASSES_ROOT, "CLSID", 0, KEY_ALL_ACCESS, &hk);
|
|
if (l != ERROR_SUCCESS) return FALSE;
|
|
|
|
f = DeleteKeyAndSubKeys(hk, szScratch);
|
|
RegCloseKey(hk);
|
|
|
|
return f;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// UnregisterAutomationObject
|
|
//=--------------------------------------------------------------------------=
|
|
// unregisters an automation object, including all of it's unknown object
|
|
// information.
|
|
//
|
|
// Parameters:
|
|
// LPCSTR - [in] Library Name
|
|
// LPCSTR - [in] Object Name
|
|
// long - [in] Version Number
|
|
// REFCLSID - [in] CLSID of the object
|
|
//
|
|
// Output:
|
|
// BOOL - FALSE means couldn't get it all unregistered.
|
|
//
|
|
// Notes:
|
|
//
|
|
BOOL UnregisterAutomationObject
|
|
(
|
|
LPCSTR pszLibName,
|
|
LPCSTR pszObjectName,
|
|
long lVersion,
|
|
REFCLSID riidObject
|
|
)
|
|
{
|
|
char szScratch[MAX_PATH];
|
|
BOOL f;
|
|
|
|
// first thing -- unregister Unknown information
|
|
//
|
|
f = UnregisterUnknownObject(riidObject);
|
|
if (!f) return FALSE;
|
|
|
|
// delete everybody of the form:
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName> [\] *
|
|
//
|
|
wsprintf(szScratch, "%s.%s", pszLibName, pszObjectName);
|
|
f = DeleteKeyAndSubKeys(HKEY_CLASSES_ROOT, szScratch);
|
|
if (!f) return FALSE;
|
|
|
|
// delete everybody of the form
|
|
// HKEY_CLASSES_ROOT\<LibraryName>.<ObjectName>.<VersionNumber> [\] *
|
|
//
|
|
wsprintf(szScratch, "%s.%s.%ld", pszLibName, pszObjectName, lVersion);
|
|
f = DeleteKeyAndSubKeys(HKEY_CLASSES_ROOT, szScratch);
|
|
if (!f) return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// UnregisterTypeLibrary
|
|
//=--------------------------------------------------------------------------=
|
|
// blows away the type library keys for a given libid.
|
|
//
|
|
// Parameters:
|
|
// REFCLSID - [in] libid to blow away.
|
|
//
|
|
// Output:
|
|
// BOOL - TRUE OK, FALSE bad.
|
|
//
|
|
// Notes:
|
|
// - WARNING: this function just blows away the entire type library section,
|
|
// including all localized versions of the type library. mildly anti-
|
|
// social, but not killer.
|
|
//
|
|
BOOL UnregisterTypeLibrary
|
|
(
|
|
REFCLSID riidLibrary
|
|
)
|
|
{
|
|
HKEY hk;
|
|
char szScratch[GUID_STR_LEN];
|
|
long l;
|
|
BOOL f;
|
|
|
|
// convert the libid into a string.
|
|
//
|
|
if (!StringFromGuidA(riidLibrary, szScratch))
|
|
return FALSE;
|
|
|
|
l = RegOpenKeyEx(HKEY_CLASSES_ROOT, "TypeLib", 0, KEY_ALL_ACCESS, &hk);
|
|
if (l != ERROR_SUCCESS) return FALSE;
|
|
|
|
f = DeleteKeyAndSubKeys(hk, szScratch);
|
|
RegCloseKey(hk);
|
|
return f;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// DeleteKeyAndSubKeys
|
|
//=--------------------------------------------------------------------------=
|
|
// delete's a key and all of it's subkeys.
|
|
//
|
|
// Parameters:
|
|
// HKEY - [in] delete the descendant specified
|
|
// LPSTR - [in] i'm the descendant specified
|
|
//
|
|
// Output:
|
|
// BOOL - TRUE OK, FALSE baaaad.
|
|
//
|
|
// Notes:
|
|
// - I don't feel too bad about implementing this recursively, since the
|
|
// depth isn't likely to get all the great.
|
|
// - Despite the win32 docs claiming it does, RegDeleteKey doesn't seem to
|
|
// work with sub-keys under windows 95.
|
|
//
|
|
BOOL DeleteKeyAndSubKeys
|
|
(
|
|
HKEY hkIn,
|
|
LPSTR pszSubKey
|
|
)
|
|
{
|
|
HKEY hk;
|
|
char szTmp[MAX_PATH];
|
|
DWORD dwTmpSize;
|
|
long l;
|
|
BOOL f;
|
|
int x;
|
|
|
|
l = RegOpenKeyEx(hkIn, pszSubKey, 0, KEY_ALL_ACCESS, &hk);
|
|
if (l != ERROR_SUCCESS) return FALSE;
|
|
|
|
// loop through all subkeys, blowing them away.
|
|
//
|
|
f = TRUE;
|
|
x = 0;
|
|
while (f) {
|
|
dwTmpSize = MAX_PATH;
|
|
l = RegEnumKeyEx(hk, x, szTmp, &dwTmpSize, 0, NULL, NULL, NULL);
|
|
if (l != ERROR_SUCCESS) break;
|
|
f = DeleteKeyAndSubKeys(hk, szTmp);
|
|
x++;
|
|
}
|
|
|
|
// there are no subkeys left, [or we'll just generate an error and return FALSE].
|
|
// let's go blow this dude away.
|
|
//
|
|
RegCloseKey(hk);
|
|
l = RegDeleteKey(hkIn, pszSubKey);
|
|
|
|
return (l == ERROR_SUCCESS) ? TRUE : FALSE;
|
|
}
|
|
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// Conversion Routines
|
|
//=--------------------------------------------------------------------------=
|
|
// the following stuff is stuff used for the various conversion routines.
|
|
//
|
|
#define HIMETRIC_PER_INCH 2540
|
|
#define MAP_PIX_TO_LOGHIM(x,ppli) ( (HIMETRIC_PER_INCH*(x) + ((ppli)>>1)) / (ppli) )
|
|
#define MAP_LOGHIM_TO_PIX(x,ppli) ( ((ppli)*(x) + HIMETRIC_PER_INCH/2) / HIMETRIC_PER_INCH )
|
|
|
|
static int s_iXppli; // Pixels per logical inch along width
|
|
static int s_iYppli; // Pixels per logical inch along height
|
|
static BYTE s_fGotScreenMetrics; // Are above valid?
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// GetScreenMetrics
|
|
//=--------------------------------------------------------------------------=
|
|
// private function we call to set up various metrics the conversion routines
|
|
// will use.
|
|
//
|
|
// Notes:
|
|
|
|
// BUGBUG: 26-Sep-1997 [ralphw] This will fail miserably if the user changes
|
|
// screen resolutions. Doah!
|
|
|
|
static void GetScreenMetrics (void)
|
|
{
|
|
if (s_fGotScreenMetrics)
|
|
return;
|
|
|
|
// we want the metrics for the screen
|
|
|
|
HDC hdc = CreateIC("DISPLAY", NULL, NULL, NULL);
|
|
|
|
ASSERT(hdc);
|
|
s_iXppli = GetDeviceCaps(hdc, LOGPIXELSX);
|
|
s_iYppli = GetDeviceCaps(hdc, LOGPIXELSY);
|
|
|
|
DeleteDC( hdc );
|
|
s_fGotScreenMetrics = TRUE;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// HiMetricToPixel
|
|
//=--------------------------------------------------------------------------=
|
|
// converts from himetric to Pixels.
|
|
//
|
|
// Parameters:
|
|
// const SIZEL * - [in] dudes in himetric
|
|
// SIZEL * - [out] size in pixels.
|
|
//
|
|
// Notes:
|
|
//
|
|
void HiMetricToPixel(const SIZEL * lpSizeInHiMetric, SIZE* lpSizeInPix)
|
|
{
|
|
GetScreenMetrics();
|
|
|
|
// We got logical HIMETRIC along the display, convert them to pixel units
|
|
|
|
lpSizeInPix->cx = MAP_LOGHIM_TO_PIX(lpSizeInHiMetric->cx, s_iXppli);
|
|
lpSizeInPix->cy = MAP_LOGHIM_TO_PIX(lpSizeInHiMetric->cy, s_iYppli);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// PixelToHiMetric
|
|
//=--------------------------------------------------------------------------=
|
|
// converts from pixels to himetric.
|
|
//
|
|
// Parameters:
|
|
// const SIZEL * - [in] size in pixels
|
|
// SIZEL * - [out] size in himetric
|
|
|
|
void PixelToHiMetric(const SIZEL * lpSizeInPix, LPSIZEL lpSizeInHiMetric)
|
|
{
|
|
GetScreenMetrics();
|
|
|
|
// We got pixel units, convert them to logical HIMETRIC along the display
|
|
|
|
lpSizeInHiMetric->cx = MAP_PIX_TO_LOGHIM(lpSizeInPix->cx, s_iXppli);
|
|
lpSizeInHiMetric->cy = MAP_PIX_TO_LOGHIM(lpSizeInPix->cy, s_iYppli);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// _MakePath
|
|
//=--------------------------------------------------------------------------=
|
|
// little helper routine for RegisterLocalizedTypeLibs and GetResourceHandle.
|
|
// not terrilby efficient or smart, but it's registration code, so we don't
|
|
// really care.
|
|
//
|
|
// Notes:
|
|
//
|
|
void _MakePath
|
|
(
|
|
LPSTR pszFull,
|
|
const char * pszName,
|
|
LPSTR pszOut
|
|
)
|
|
{
|
|
LPSTR psz;
|
|
LPSTR pszLast;
|
|
|
|
strcpy(pszOut, pszFull);
|
|
psz = pszLast = pszOut;
|
|
while (*psz) {
|
|
if (*psz == '\\')
|
|
pszLast = AnsiNext(psz);
|
|
psz = AnsiNext(psz);
|
|
}
|
|
|
|
// got the last \ character, so just go and replace the name.
|
|
//
|
|
strcpy(pszLast, pszName);
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: GetStringResource
|
|
|
|
PURPOSE: Copy a string resource to a buffer, returning a pointer
|
|
to that buffer
|
|
|
|
PARAMETERS:
|
|
idString -- resource id
|
|
|
|
RETURNS: Pointer to the string containing the buffer
|
|
|
|
COMMENTS:
|
|
Note that the same buffer is used each time. You will need to
|
|
duplicate the returned pointer if you need to call this function
|
|
again before the previous value is no longer needed.
|
|
|
|
***************************************************************************/
|
|
|
|
PCSTR GetStringResource(int idString)
|
|
{
|
|
static TCHAR pszStringBuf[MAX_STRING_RESOURCE_LEN + 1];
|
|
|
|
|
|
pszStringBuf[0] = 0;
|
|
|
|
// special case W2K
|
|
//
|
|
// The purpose of this code is to get the resource string in Unicode
|
|
// and then convert to ANSI using the UI codepage when running under W2K.
|
|
//
|
|
// The narrow GetStringResource() API fails under MUI configurations
|
|
// due to it using the default system locale rather than the UI locale
|
|
// for the conversion to ANSI.
|
|
//
|
|
if(g_bWinNT5)
|
|
{
|
|
const WCHAR *pswString = GetStringResourceW(idString);
|
|
static char pszAnsiStringBuf[MAX_STRING_RESOURCE_LEN + 1];
|
|
|
|
if(pswString)
|
|
{
|
|
DWORD cp = CodePageFromLCID(MAKELCID(_Module.m_Language.GetUiLanguage(),SORT_DEFAULT));
|
|
pszAnsiStringBuf[0] = 0;
|
|
WideCharToMultiByte (cp, 0, pswString, -1, pszAnsiStringBuf, sizeof(pszAnsiStringBuf), NULL, NULL);
|
|
return pszAnsiStringBuf;
|
|
}
|
|
else
|
|
return pszStringBuf;
|
|
}
|
|
|
|
if (LoadString(_Module.GetResourceInstance(), idString, pszStringBuf, MAX_STRING_RESOURCE_LEN) == 0) {
|
|
#ifdef _DEBUG
|
|
wsprintf(pszStringBuf, "invalid string id #%u", idString);
|
|
MsgBox(pszStringBuf);
|
|
#endif
|
|
pszStringBuf[0] = '\0';
|
|
}
|
|
return (PCSTR) pszStringBuf;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: GetStringResource
|
|
|
|
PURPOSE: Copy a string resource to a buffer, returning a pointer
|
|
to that buffer
|
|
|
|
PARAMETERS:
|
|
idString -- resource id
|
|
hInstance -- resource instance
|
|
|
|
RETURNS: Pointer to the string containing the buffer
|
|
|
|
COMMENTS:
|
|
Note that the same buffer is used each time. You will need to
|
|
duplicate the returned pointer if you need to call this function
|
|
again before the previous value is no longer needed.
|
|
|
|
***************************************************************************/
|
|
|
|
PCSTR GetStringResource(int idString, HINSTANCE hInstance)
|
|
{
|
|
static TCHAR pszStringBuf[MAX_STRING_RESOURCE_LEN + 1];
|
|
|
|
pszStringBuf[0] = 0;
|
|
|
|
// special case W2K
|
|
//
|
|
// The purpose of this code is to get the resource string in Unicode
|
|
// and then convert to ANSI using the UI codepage when running under W2K.
|
|
//
|
|
// The narrow GetStringResource() API fails under MUI configurations
|
|
// due to it using the default system locale rather than the UI locale
|
|
// for the conversion to ANSI.
|
|
//
|
|
if(g_bWinNT5)
|
|
{
|
|
const WCHAR *pswString = GetStringResourceW(idString, hInstance);
|
|
static char pszAnsiStringBuf[MAX_STRING_RESOURCE_LEN + 1];
|
|
|
|
if(pswString)
|
|
{
|
|
DWORD cp = CodePageFromLCID(MAKELCID(_Module.m_Language.GetUiLanguage(),SORT_DEFAULT));
|
|
pszAnsiStringBuf[0] = 0;
|
|
WideCharToMultiByte (cp, 0, pswString, -1, pszAnsiStringBuf, sizeof(pszAnsiStringBuf), NULL, NULL);
|
|
return pszAnsiStringBuf;
|
|
}
|
|
else
|
|
return pszStringBuf;
|
|
}
|
|
|
|
if (LoadString(hInstance, idString, pszStringBuf, MAX_STRING_RESOURCE_LEN) == 0) {
|
|
#ifdef _DEBUG
|
|
wsprintf(pszStringBuf, "invalid string id #%u", idString);
|
|
MsgBox(pszStringBuf);
|
|
#endif
|
|
pszStringBuf[0] = '\0';
|
|
}
|
|
return (PCSTR) pszStringBuf;
|
|
}
|
|
|
|
PCWSTR GetStringResourceW(int idString)
|
|
{
|
|
static WCHAR pszStringBuf[MAX_STRING_RESOURCE_LEN + 1];
|
|
|
|
if (0 == ::LoadStringW(_Module.GetResourceInstance(), idString, pszStringBuf, MAX_STRING_RESOURCE_LEN))
|
|
{
|
|
if (ERROR_CALL_NOT_IMPLEMENTED == ::GetLastError())
|
|
{
|
|
PCSTR pszA = GetStringResource(idString);
|
|
MultiByteToWideChar(CP_ACP, 0, pszA, -1, pszStringBuf, MAX_STRING_RESOURCE_LEN);
|
|
}
|
|
else
|
|
{
|
|
ASSERT(0); // bad string id, probably
|
|
pszStringBuf[0] = '\0';
|
|
}
|
|
}
|
|
return (PCWSTR) pszStringBuf;
|
|
}
|
|
|
|
// GetStringResourceW
|
|
//
|
|
PCWSTR GetStringResourceW(int idString, HINSTANCE hInstance)
|
|
{
|
|
static WCHAR pszStringBuf[MAX_STRING_RESOURCE_LEN + 1];
|
|
|
|
if (0 == ::LoadStringW(hInstance, idString, pszStringBuf, MAX_STRING_RESOURCE_LEN))
|
|
{
|
|
if (ERROR_CALL_NOT_IMPLEMENTED == ::GetLastError())
|
|
{
|
|
PCSTR pszA = GetStringResource(idString, hInstance);
|
|
MultiByteToWideChar(CP_ACP, 0, pszA, -1, pszStringBuf, MAX_STRING_RESOURCE_LEN);
|
|
}
|
|
else
|
|
{
|
|
ASSERT(0); // bad string id, probably
|
|
pszStringBuf[0] = '\0';
|
|
}
|
|
}
|
|
return (PCWSTR) pszStringBuf;
|
|
}
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: Atoi
|
|
|
|
PURPOSE: Convert string to an integer
|
|
|
|
PARAMETERS:
|
|
psz
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
Taken from C runtime code -- this code makes no function calls, and
|
|
assumes there is no such thing as a DBCS number. It will read either
|
|
decimal or hex (preceeded with an 0x)
|
|
|
|
MODIFICATION DATES:
|
|
04-Dec-1997 [ralphw]
|
|
15-Aug-1997 [ralphw] Support hex digits
|
|
|
|
***************************************************************************/
|
|
|
|
int FASTCALL Atoi(PCSTR psz)
|
|
{
|
|
// skip whitespace
|
|
|
|
while (*psz == ' ' || *psz == '\t')
|
|
++psz;
|
|
|
|
if (!*psz)
|
|
return 0;
|
|
|
|
int c = (int) (unsigned char) *psz++;
|
|
int sign = c; // save sign indication
|
|
if (c == '-' || c == '+')
|
|
c = (int) (unsigned char) *psz++; // skip sign
|
|
|
|
int total = 0;
|
|
|
|
if (c == '0' && psz[0] == 'x') {
|
|
psz++; // skip over the 'x'
|
|
c = (int) (unsigned char) *psz++; // skip sign
|
|
for (;;) {
|
|
if (c >= '0' && c <= '9') {
|
|
total = 16 * total + (c - '0');
|
|
c = (int)(unsigned char)*psz++;
|
|
}
|
|
else if (c >= 'a' && c <= 'f') {
|
|
total = 16 * total + ((c - 'a') + 10);
|
|
c = (int)(unsigned char)*psz++;
|
|
}
|
|
else if (c >= 'A' && c <= 'F') {
|
|
total = 16 * total + ((c - 'A') + 10);
|
|
c = (int)(unsigned char)*psz++;
|
|
}
|
|
else {
|
|
if (sign == '-')
|
|
return -total;
|
|
else
|
|
return total;
|
|
}
|
|
}
|
|
}
|
|
while (c >= '0' && c <= '9') {
|
|
total = 10 * total + (c - '0');
|
|
c = (int)(unsigned char)*psz++;
|
|
}
|
|
|
|
if (sign == '-')
|
|
return -total;
|
|
else
|
|
return total;
|
|
}
|
|
|
|
void OOM(void)
|
|
{
|
|
#ifdef _DEBUG
|
|
ASSERT_COMMENT(FALSE, "Out of memory.");
|
|
#else
|
|
char szMsg[256];
|
|
LoadString(_Module.GetResourceInstance(), IDS_OOM, szMsg, sizeof(szMsg));
|
|
|
|
// Task modal to allow other applications to run. Note that this will
|
|
// disable the caller's windows.
|
|
|
|
MessageBox(GetActiveWindow(), szMsg, "", MB_OK | MB_TASKMODAL | MB_ICONHAND);
|
|
ExitProcess((UINT) -1);
|
|
#endif
|
|
}
|
|
|
|
int MsgBox(int idString, UINT nType)
|
|
{
|
|
if(g_bWinNT5)
|
|
{
|
|
WCHAR *pszString;
|
|
WCHAR wcString[(MAX_STRING_RESOURCE_LEN + 1) + MAX_PATH + 64];
|
|
WCHAR wcTitle[(MAX_STRING_RESOURCE_LEN + 1) + MAX_PATH + 64];
|
|
wcTitle[0] = 0;
|
|
|
|
pszString = (WCHAR *) GetStringResourceW(idString);
|
|
|
|
if(!pszString)
|
|
{
|
|
#ifdef _DEBUG
|
|
char szMsg[(MAX_STRING_RESOURCE_LEN + 1) + MAX_PATH + 64];
|
|
wsprintf(szMsg, "invalid string id #%u", idString);
|
|
DBWIN(szMsg);
|
|
#endif
|
|
return 0;
|
|
}
|
|
else
|
|
wcscpy(wcString,pszString);
|
|
|
|
char *pszTitle = _Resource.MsgBoxTitle();
|
|
if(pszTitle)
|
|
{
|
|
|
|
DWORD cp = CodePageFromLCID(MAKELCID(_Module.m_Language.GetUiLanguage(),SORT_DEFAULT));
|
|
MultiByteToWideChar(cp, 0, pszTitle, -1, wcTitle, sizeof(wcTitle));
|
|
}
|
|
else
|
|
return 0;
|
|
|
|
return MessageBoxW(GetActiveWindow(), wcString, wcTitle, nType | g_fuBiDiMessageBox);
|
|
}
|
|
else
|
|
{
|
|
|
|
|
|
CStr pszTemp = (char *) GetStringResource(idString);
|
|
|
|
if(!pszTemp.psz)
|
|
{
|
|
#ifdef _DEBUG
|
|
char szMsg[(MAX_STRING_RESOURCE_LEN + 1) + MAX_PATH + 64];
|
|
wsprintf(szMsg, "invalid string id #%u", idString);
|
|
DBWIN(szMsg);
|
|
#endif
|
|
return 0;
|
|
}
|
|
return MessageBox(GetActiveWindow(), pszTemp, _Resource.MsgBoxTitle(), nType | g_fuBiDiMessageBox);
|
|
}
|
|
}
|
|
|
|
int MsgBox(PCSTR pszMsg, UINT nType)
|
|
{
|
|
return MessageBox(GetActiveWindow(), pszMsg, _Resource.MsgBoxTitle(), nType | g_fuBiDiMessageBox);
|
|
}
|
|
|
|
int MsgBox(int idFormatString, PCSTR pszSubString, UINT nType)
|
|
{
|
|
CStr csz(idFormatString, pszSubString);
|
|
return MessageBox(GetActiveWindow(), csz.psz, _Resource.MsgBoxTitle(), nType);
|
|
}
|
|
|
|
void AddTrailingBackslash(PSTR psz)
|
|
{
|
|
int sPos;
|
|
|
|
if (psz != NULL && *psz != '\0') {
|
|
|
|
if (g_fDBCSSystem) {
|
|
PSTR pszEnd = psz + strlen(psz);
|
|
if (*(CharPrev(psz, pszEnd)) != '\\' &&
|
|
*(CharPrev(psz, pszEnd)) != '/' &&
|
|
*(CharPrev(psz, pszEnd)) != ':') {
|
|
*pszEnd++ = '\\';
|
|
*pszEnd++ = '\0';
|
|
}
|
|
}
|
|
else {
|
|
sPos = (int)strlen(psz) - 1;
|
|
|
|
if (psz[sPos] != '\\' && psz[sPos] != '/' && psz[sPos] != ':') {
|
|
psz[sPos + 1] = '\\';
|
|
psz[sPos + 2] = '\0';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
/***************************************************************************
|
|
|
|
FUNCTION: StrChr
|
|
|
|
PURPOSE: DBCS-capable version of strchr
|
|
|
|
PARAMETERS:
|
|
pszString
|
|
ch
|
|
|
|
RETURNS: pointer to the character
|
|
|
|
COMMENTS: This can NOT find a DBCS character. It can only be used to
|
|
find a SBCS character imbedded in a DBCS character string.
|
|
|
|
MODIFICATION DATES:
|
|
29-Jul-1994 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
extern "C" PSTR StrChr(PCSTR pszString, char ch)
|
|
{
|
|
if (!g_fDBCSSystem)
|
|
return strchr(pszString, ch);
|
|
while (*pszString) {
|
|
while (IsDBCSLeadByte(*pszString))
|
|
pszString += 2;
|
|
if (*pszString == ch)
|
|
return (PSTR) pszString;
|
|
else if (!*pszString)
|
|
return NULL;
|
|
pszString++;
|
|
}
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
extern "C" PSTR StrRChr(PCSTR pszString, char ch)
|
|
{
|
|
PSTR psz = StrChr(pszString, ch);
|
|
PSTR pszLast;
|
|
|
|
if (!psz)
|
|
return NULL;
|
|
do {
|
|
pszLast = psz;
|
|
psz = StrChr(pszLast + 1, ch);
|
|
} while (psz);
|
|
|
|
return pszLast;
|
|
}
|
|
|
|
extern "C" PSTR FirstNonSpace(PCSTR psz)
|
|
{
|
|
// note, for various bits of code to work throughout the HH project,
|
|
// this function cannot return NULL if the first non-space does not exist,
|
|
// instead the caller may count on this function returning non-NULL and
|
|
// thus we need to pass back a pointer to the terminating NULL character
|
|
// instead of simply a NULL value.
|
|
|
|
if( !psz /*|| !*psz*/ )
|
|
return NULL;
|
|
|
|
if (g_fDBCSSystem) {
|
|
while (!IsDBCSLeadByte(*psz) && (*psz == ' ' || *psz == '\t'))
|
|
psz++;
|
|
return (PSTR) psz;
|
|
}
|
|
|
|
while(*psz == ' ' || *psz == '\t')
|
|
psz++;
|
|
return (PSTR) psz;
|
|
}
|
|
|
|
WCHAR *FirstNonSpaceW(WCHAR *psz)
|
|
{
|
|
// note, for various bits of code to work throughout the HH project,
|
|
// this function cannot return NULL if the first non-space does not exist,
|
|
// instead the caller may count on this function returning non-NULL and
|
|
// thus we need to pass back a pointer to the terminating NULL character
|
|
// instead of simply a NULL value.
|
|
|
|
if( !psz /*|| !*psz*/ )
|
|
return NULL;
|
|
|
|
while(*psz == L' ' || *psz == L'\t')
|
|
psz++;
|
|
return psz;
|
|
}
|
|
|
|
PSTR SzTrimSz(PSTR pszOrg)
|
|
{
|
|
if (!pszOrg)
|
|
return NULL;
|
|
|
|
// Skip over leading whitespace
|
|
|
|
if (g_fDBCSSystem) {
|
|
PSTR psz = pszOrg;
|
|
while (!IsDBCSLeadByte(*psz) && IsSpace(*psz))
|
|
psz++;
|
|
if (psz != pszOrg)
|
|
strcpy(pszOrg, psz);
|
|
}
|
|
|
|
else if (IsSpace(*pszOrg))
|
|
strcpy(pszOrg, FirstNonSpace(pszOrg));
|
|
|
|
RemoveTrailingSpaces(pszOrg);
|
|
|
|
return pszOrg;
|
|
}
|
|
|
|
void RemoveTrailingSpaces(PSTR pszString)
|
|
{
|
|
if (!g_fDBCSSystem) {
|
|
PSTR psz = pszString + strlen(pszString) - 1;
|
|
|
|
while (IsSpace(*psz)) {
|
|
if (--psz <= pszString) {
|
|
*pszString = '\0';
|
|
return;
|
|
}
|
|
}
|
|
psz[1] = '\0';
|
|
}
|
|
else {
|
|
|
|
/*
|
|
* Removing trailing spaces in DBCS requires stepping through
|
|
* from the beginning of the string since we can't know if a
|
|
* trailing space is really a space or the second byte of a lead
|
|
* byte.
|
|
*/
|
|
PSTR psz = pszString + strlen(pszString) - 1;
|
|
while (IsSpace(*psz) && psz > pszString + 2 &&
|
|
!IsDBCSLeadByte(psz[-1])) {
|
|
if (--psz <= pszString) {
|
|
*pszString = '\0';
|
|
return;
|
|
}
|
|
}
|
|
psz[1] = '\0';
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: GetLeftOfEquals
|
|
|
|
PURPOSE: Allocate a string and copy everything to the left of the
|
|
equal character to that string. If there is no equal character,
|
|
return NULL.
|
|
|
|
PARAMETERS:
|
|
pszString -- note that we do actually modify this string, but we
|
|
restore it before returning, hence we use PCSTR
|
|
so the compiler thinks it is unmodified.
|
|
|
|
RETURNS: Allocated memory or NULL
|
|
|
|
COMMENTS:
|
|
DBCS enabled. A backslash character may be used to escape (ignore)
|
|
the equals character.
|
|
|
|
MODIFICATION DATES:
|
|
07-Jul-1997 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
PSTR GetLeftOfEquals(PCSTR pszString)
|
|
{
|
|
PSTR pszEqual = (PSTR) FindEqCharacter(pszString);
|
|
if (!pszEqual)
|
|
return NULL;
|
|
*pszEqual = '\0';
|
|
|
|
PSTR pszLeft = (PSTR) lcStrDup(pszString);
|
|
RemoveTrailingSpaces(pszLeft);
|
|
*pszEqual = '=';
|
|
return pszLeft;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: FindEqCharacter
|
|
|
|
PURPOSE: Return a pointer to the '=' character in a line
|
|
|
|
PARAMETERS:
|
|
pszLine
|
|
|
|
RETURNS: Pointer to '=' or NULL if there is no '='
|
|
|
|
COMMENTS:
|
|
We DO modify pszLine in spite of it's being marked as PCSTR, but
|
|
we always put it back the way we found it before returning. So, you
|
|
can't use this function on a string stored in a code segment.
|
|
|
|
MODIFICATION DATES:
|
|
10-Jul-1997 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
PCSTR FindEqCharacter(PCSTR pszLine)
|
|
{
|
|
PSTR pszEqual = (PSTR) pszLine;
|
|
for (;;) {
|
|
pszEqual = StrChr(pszEqual, '=');
|
|
if (!pszEqual)
|
|
return NULL;
|
|
*pszEqual = '\0';
|
|
|
|
/*
|
|
* We need to find out if the previous character was a backslash.
|
|
* You can't back up in a DBCS string, so we just start from the
|
|
* first and search for the last backslash. Don't be fooled into
|
|
* thinking CharPrev() will do the trick -- it will, but by doing
|
|
* the same thing we do here more efficiently (start from the
|
|
* beginning of the string).
|
|
*/
|
|
|
|
PSTR pszBackSlash = StrRChr(pszLine, '\\');
|
|
if (pszBackSlash && pszBackSlash == (pszEqual - 1)) {
|
|
*pszEqual = '='; // put the character back
|
|
pszEqual++;
|
|
continue; // keep looking;
|
|
}
|
|
|
|
*pszEqual = '='; // put the character back
|
|
return pszEqual;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: Itoa
|
|
|
|
PURPOSE: Convert a positive interger to a base 10 string
|
|
|
|
PARAMETERS:
|
|
val
|
|
pszDst
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
Taken from C runtime code, modified for speed and size
|
|
|
|
MODIFICATION DATES:
|
|
04-Dec-1997 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
void FASTCALL Itoa(int val, PSTR pszDst)
|
|
{
|
|
if (val < 0) {
|
|
*pszDst++ = '-';
|
|
val = abs(val);
|
|
}
|
|
PSTR firstdig = pszDst; // save pointer to first digit
|
|
|
|
do {
|
|
*pszDst++ = ((char) (val % 10)) + '0';
|
|
val /= 10; // get next digit
|
|
} while (val > 0);
|
|
|
|
/*
|
|
* We now have the digit of the number in the buffer, but in reverse
|
|
* order. Thus we reverse them now.
|
|
*/
|
|
|
|
*pszDst-- = '\0'; // terminate string; p points to last digit
|
|
|
|
do {
|
|
char temp = *pszDst;
|
|
*pszDst = *firstdig;
|
|
*firstdig = temp; // swap *p and *firstdig
|
|
--pszDst;
|
|
++firstdig; // advance to next two digits
|
|
} while (firstdig < pszDst); // repeat until halfway
|
|
}
|
|
|
|
#if 0
|
|
/***************************************************************************
|
|
|
|
FUNCTION: stristr
|
|
|
|
PURPOSE: Case-insensitive search for a sub string in a main string
|
|
|
|
PARAMETERS:
|
|
pszMain
|
|
pszSub
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
Not tested
|
|
|
|
MODIFICATION DATES:
|
|
28-Mar-1994 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
// REVIEW: should replace this with a version that doesn't use CompareString,
|
|
// since this function is typically used to parse sitemap files -- the object
|
|
// names of a sitemap file will always be in english.
|
|
|
|
extern "C"
|
|
PSTR stristr(PCSTR pszMain, PCSTR pszSub)
|
|
{
|
|
if (!pszMain || !pszSub)
|
|
return NULL;
|
|
PSTR pszCur = (PSTR) pszMain;
|
|
char ch = ToLower(*pszSub);
|
|
int cb = strlen(pszSub);
|
|
|
|
if (g_fDBCSSystem) {
|
|
for (;;) {
|
|
while (ToLower(*pszCur) != ch && *pszCur)
|
|
pszCur = CharNext(pszCur);
|
|
if (!*pszCur)
|
|
return NULL;
|
|
if (CompareString(g_lcidSystem, NORM_IGNORECASE,
|
|
pszCur, cb, pszSub, cb) == 2)
|
|
return pszCur;
|
|
pszCur = CharNext(pszCur);
|
|
}
|
|
}
|
|
else {
|
|
for (;;) {
|
|
while (ToLower(*pszCur) != ch && *pszCur)
|
|
pszCur++;
|
|
if (!*pszCur)
|
|
return NULL;
|
|
if (CompareString(g_lcidSystem, NORM_IGNORECASE,
|
|
pszCur, cb, pszSub, cb) == 2)
|
|
return pszCur;
|
|
pszCur++;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// NOTE: this only works with Unicode strings
|
|
|
|
BOOL IsSamePrefix(PCWSTR pwszMainIn, PCWSTR pwszSubIn, int cchPrefix)
|
|
{
|
|
if( !pwszMainIn || !pwszSubIn )
|
|
return FALSE;
|
|
|
|
const WCHAR* pwszMain = pwszMainIn;
|
|
const WCHAR* pwszSub = pwszSubIn;
|
|
|
|
if( cchPrefix == -1 )
|
|
cchPrefix = lstrlenW(pwszSub);
|
|
|
|
// convert both to lowercase and then compare the first few characters
|
|
// in pwszSub to pwszMain
|
|
while( cchPrefix-- ) {
|
|
|
|
// if we hit the end of the strings, quit and return
|
|
// TRUE if both NULL or FALSE otherwise
|
|
if( !(*pwszSub) || !(*pwszMain) ) {
|
|
if( (*pwszSub) == (*pwszMain) )
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
WCHAR wchSub = *(pwszSub++);
|
|
WCHAR wchMain = *(pwszMain++);
|
|
|
|
CharLowerW( &wchSub );
|
|
CharLowerW( &wchMain );
|
|
|
|
// if not the same then quit and return FALSE
|
|
if( wchSub != wchMain )
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// NOTE: this only works with ANSI strings
|
|
|
|
BOOL IsSamePrefix(PCSTR pszMain, PCSTR pszSub, int cbPrefix)
|
|
{
|
|
if (!pszMain || !pszSub)
|
|
return FALSE;
|
|
|
|
if (cbPrefix == -1)
|
|
cbPrefix = (int)strlen(pszSub);
|
|
|
|
int f, l;
|
|
while (cbPrefix--) {
|
|
if (((f = (BYTE) (*(pszMain++))) >= 'A') && (f <= 'Z'))
|
|
f -= 'A' - 'a';
|
|
|
|
if (((l = (BYTE) (*(pszSub++))) >= 'A') && (l <= 'Z'))
|
|
l -= 'A' - 'a';
|
|
|
|
if (f != l)
|
|
return FALSE;
|
|
else if (!f)
|
|
return (f == l);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
#ifndef _DEBUG
|
|
#pragma optimize("t", on)
|
|
#endif
|
|
|
|
int FASTCALL CompareIntPointers(const void *pval1, const void *pval2)
|
|
{
|
|
#ifdef _DEBUG
|
|
int val1 = *(int*) pval1;
|
|
int val2 = *(int*) pval2;
|
|
#endif
|
|
return *(int*) pval1 - *(int*) pval2;
|
|
}
|
|
|
|
/*
|
|
* this parameter defines the cutoff between using quick sort and insertion
|
|
* sort for arrays; arrays with lengths shorter or equal to the below value
|
|
* use insertion sort
|
|
*/
|
|
|
|
#define CUTOFF 8 // testing shows that this is good value
|
|
|
|
void INLINE Swap(void* pb1, void* pb2, UINT width)
|
|
{
|
|
BYTE tmp[256];
|
|
ASSERT(width < sizeof(tmp));
|
|
CopyMemory(tmp, pb1, width);
|
|
CopyMemory(pb1, pb2, width);
|
|
CopyMemory(pb2, tmp, width);
|
|
}
|
|
|
|
static void InsertionSort(char *lo, char *hi, unsigned width,
|
|
int (FASTCALL *compare)(const void *, const void *))
|
|
{
|
|
char *p, *max;
|
|
|
|
/*
|
|
* Note: in assertions below, i and j are alway inside original bound
|
|
* of array to sort.
|
|
*/
|
|
|
|
while (hi > lo) {
|
|
/* A[i] <= A[j] for i <= j, j > hi */
|
|
max = lo;
|
|
for (p = lo + width; p <= hi; p += width) {
|
|
/* A[i] <= A[max] for lo <= i < p */
|
|
if (compare(p, max) > 0) {
|
|
max = p;
|
|
}
|
|
/* A[i] <= A[max] for lo <= i <= p */
|
|
}
|
|
|
|
/* A[i] <= A[max] for lo <= i <= hi */
|
|
|
|
Swap(max, hi, width);
|
|
|
|
/* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */
|
|
|
|
hi -= width;
|
|
|
|
// A[i] <= A[j] for i <= j, j > hi, loop top condition established
|
|
}
|
|
/* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,
|
|
so array is sorted */
|
|
}
|
|
|
|
void QSort(void *pbase, UINT num, UINT width,
|
|
int (FASTCALL *compare)(const void *, const void *))
|
|
{
|
|
char *lo, *hi; // ends of sub-array currently sorting
|
|
char *mid; // points to middle of subarray
|
|
char *loguy, *higuy; // traveling pointers for partition step
|
|
unsigned size; // size of the sub-array
|
|
char *lostk[30], *histk[30];
|
|
int stkptr; // stack for saving sub-array to be processed
|
|
|
|
/* Note: the number of stack entries required is no more than
|
|
1 + log2(size), so 30 is sufficient for any array */
|
|
|
|
if (num < 2 || width == 0)
|
|
return; // nothing to do
|
|
|
|
stkptr = 0; // initialize stack
|
|
|
|
lo = (char*) pbase;
|
|
hi = (char *) pbase + width * (num-1); // initialize limits
|
|
|
|
/* this entry point is for pseudo-recursion calling: setting
|
|
lo and hi and jumping to here is like recursion, but stkptr is
|
|
prserved, locals aren't, so we preserve stuff on the stack */
|
|
recurse:
|
|
|
|
size = (unsigned)((hi - lo) / width + 1); // number of el's to sort
|
|
|
|
// below a certain size, it is faster to use a O(n^2) sorting method
|
|
|
|
if (size <= CUTOFF) {
|
|
InsertionSort(lo, hi, width, compare);
|
|
}
|
|
else {
|
|
/*
|
|
* First we pick a partititioning element. The efficiency of the
|
|
* algorithm demands that we find one that is approximately the
|
|
* median of the values, but also that we select one fast. Using the
|
|
* first one produces bad performace if the array is already sorted,
|
|
* so we use the middle one, which would require a very wierdly
|
|
* arranged array for worst case performance. Testing shows that a
|
|
* median-of-three algorithm does not, in general, increase
|
|
* performance.
|
|
*/
|
|
|
|
mid = lo + (size / 2) * width; // find middle element
|
|
Swap(mid, lo, width); // swap it to beginning of array
|
|
|
|
/*
|
|
* We now wish to partition the array into three pieces, one
|
|
* consisiting of elements <= partition element, one of elements
|
|
* equal to the parition element, and one of element >= to it. This
|
|
* is done below; comments indicate conditions established at every
|
|
* step.
|
|
*/
|
|
|
|
loguy = lo;
|
|
higuy = hi + width;
|
|
|
|
/*
|
|
* Note that higuy decreases and loguy increases on every
|
|
* iteration, so loop must terminate.
|
|
*/
|
|
|
|
for (;;) {
|
|
/* lo <= loguy < hi, lo < higuy <= hi + 1,
|
|
A[i] <= A[lo] for lo <= i <= loguy,
|
|
A[i] >= A[lo] for higuy <= i <= hi */
|
|
|
|
do {
|
|
loguy += width;
|
|
} while (loguy <= hi && compare(loguy, lo) <= 0);
|
|
|
|
/* lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy,
|
|
either loguy > hi or A[loguy] > A[lo] */
|
|
|
|
do {
|
|
higuy -= width;
|
|
} while (higuy > lo && compare(higuy, lo) >= 0);
|
|
|
|
/* lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi,
|
|
either higuy <= lo or A[higuy] < A[lo] */
|
|
|
|
if (higuy < loguy)
|
|
break;
|
|
|
|
/* if loguy > hi or higuy <= lo, then we would have exited, so
|
|
A[loguy] > A[lo], A[higuy] < A[lo],
|
|
loguy < hi, highy > lo */
|
|
|
|
Swap(loguy, higuy, width);
|
|
|
|
/* A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top
|
|
of loop is re-established */
|
|
}
|
|
|
|
/* A[i] >= A[lo] for higuy < i <= hi,
|
|
A[i] <= A[lo] for lo <= i < loguy,
|
|
higuy < loguy, lo <= higuy <= hi
|
|
implying:
|
|
A[i] >= A[lo] for loguy <= i <= hi,
|
|
A[i] <= A[lo] for lo <= i <= higuy,
|
|
A[i] = A[lo] for higuy < i < loguy */
|
|
|
|
Swap(lo, higuy, width); // put partition element in place
|
|
|
|
/* OK, now we have the following:
|
|
A[i] >= A[higuy] for loguy <= i <= hi,
|
|
A[i] <= A[higuy] for lo <= i < higuy
|
|
A[i] = A[lo] for higuy <= i < loguy */
|
|
|
|
/* We've finished the partition, now we want to sort the subarrays
|
|
[lo, higuy-1] and [loguy, hi].
|
|
We do the smaller one first to minimize stack usage.
|
|
We only sort arrays of length 2 or more.*/
|
|
|
|
if ( higuy - 1 - lo >= hi - loguy ) {
|
|
if (lo + width < higuy) {
|
|
lostk[stkptr] = lo;
|
|
histk[stkptr] = higuy - width;
|
|
++stkptr;
|
|
} // save big recursion for later
|
|
|
|
if (loguy < hi) {
|
|
lo = loguy;
|
|
goto recurse; // do small recursion
|
|
}
|
|
}
|
|
else {
|
|
if (loguy < hi) {
|
|
lostk[stkptr] = loguy;
|
|
histk[stkptr] = hi;
|
|
++stkptr; // save big recursion for later
|
|
}
|
|
|
|
if (lo + width < higuy) {
|
|
hi = higuy - width;
|
|
goto recurse; // do small recursion
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* We have sorted the array, except for any pending sorts on the
|
|
* stack. Check if there are any, and do them.
|
|
*/
|
|
|
|
--stkptr;
|
|
if (stkptr >= 0) {
|
|
lo = lostk[stkptr];
|
|
hi = histk[stkptr];
|
|
goto recurse; // pop subarray from stack
|
|
}
|
|
else
|
|
return; // all subarrays done
|
|
}
|
|
|
|
// C Runtime stuff
|
|
|
|
int __cdecl _purecall()
|
|
{
|
|
#ifdef _DEBUG
|
|
DebugBreak();
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: MoveClientWindow
|
|
|
|
PURPOSE: Moves a child window using screen coordinates
|
|
|
|
PARAMETERS:
|
|
hwndParent
|
|
hwndChild
|
|
prc - rectangle containing coordinates
|
|
fRedraw
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
This function is similar to MoveWindow, only it expects the
|
|
coordinates to be in screen coordinates rather then client
|
|
coordinates. This makes it possible to use functions like
|
|
GetWindowRect() and use the values directly.
|
|
|
|
MODIFICATION DATES:
|
|
25-Feb-1992 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
BOOL MoveClientWindow(HWND hwndParent, HWND hwndChild, const RECT *prc, BOOL fRedraw)
|
|
{
|
|
POINT pt;
|
|
pt.x = pt.y = 0;
|
|
|
|
ScreenToClient(hwndParent, &pt);
|
|
|
|
return SetWindowPos(hwndChild, NULL, prc->left + pt.x, prc->top + pt.y,
|
|
RECT_WIDTH(prc), RECT_HEIGHT(prc),
|
|
(fRedraw ? (SWP_NOZORDER | SWP_NOACTIVATE) :
|
|
(SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW)));
|
|
}
|
|
|
|
HWND FindTopLevelWindow(HWND hwnd)
|
|
{
|
|
HWND hwndParent = hwnd;
|
|
while (IsValidWindow(hwndParent)) {
|
|
char szClass[256];
|
|
GetClassName(hwndParent, szClass, sizeof(szClass));
|
|
if (IsSamePrefix(szClass, "IEFrame", -2) ||
|
|
IsSamePrefix(szClass, txtHtmlHelpWindowClass, -2))
|
|
return hwndParent;
|
|
hwndParent = GetParent(hwndParent);
|
|
}
|
|
return hwnd; // no parent found
|
|
}
|
|
|
|
void ConvertBackSlashToForwardSlash(PSTR pszUrl)
|
|
{
|
|
PSTR psz;
|
|
|
|
if ( !(psz = pszUrl) )
|
|
return;
|
|
//
|
|
// <mc>
|
|
// I added the code to terminate the loop when we encounter a '#' char because that designates
|
|
// an anchor name or reference. We cannot modify this part of the URL without breaking the link.
|
|
// We have to respect the way the anchor is marked up in the HTM. I made this fix for bug#2058
|
|
// 12-15-97.
|
|
// </mc>
|
|
//
|
|
while (*psz && *psz != '#' )
|
|
{
|
|
if ( *psz == '\\' )
|
|
*psz = '/';
|
|
psz = AnsiNext(psz);
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GetParentSize
|
|
//
|
|
/*
|
|
This function is used by the navigation panes to get the size of the
|
|
area with which they have to work.
|
|
*/
|
|
HWND GetParentSize(RECT* prcParent, HWND hwndParent, int padding, int navpos)
|
|
{
|
|
GetClientRect(hwndParent, prcParent);
|
|
if (padding)
|
|
{
|
|
InflateRect(prcParent, -padding, -padding);
|
|
}
|
|
char szClass[256];
|
|
GetClassName(hwndParent, szClass, sizeof(szClass)); // NOTE: The tab control is note the parent of the panes. The Navigation window is.
|
|
if (IsSamePrefix(szClass, WC_TABCONTROL, -2))
|
|
{
|
|
// Get the dimensions of a tab.
|
|
RECT rectTab ;
|
|
TabCtrl_GetItemRect(hwndParent, 0, &rectTab) ;
|
|
int RowCount = TabCtrl_GetRowCount( hwndParent );
|
|
switch (navpos) {
|
|
case HHWIN_NAVTAB_TOP:
|
|
prcParent->top += RECT_HEIGHT(rectTab)*RowCount;
|
|
break;
|
|
|
|
case HHWIN_NAVTAB_LEFT:
|
|
prcParent->left += RECT_WIDTH(rectTab);
|
|
InflateRect(prcParent, 0, 2); // need less space top/bottom
|
|
break;
|
|
|
|
case HHWIN_NAVTAB_BOTTOM:
|
|
prcParent->bottom -= RECT_HEIGHT(rectTab)*RowCount;
|
|
break;
|
|
}
|
|
// The following is used by the index and search tabs.
|
|
// I think that there has to be a better way.
|
|
hwndParent = GetParent(hwndParent);
|
|
}
|
|
else if (padding)
|
|
{
|
|
//InflateRect(prcParent, padding, padding);
|
|
|
|
// If there is no tab control, we need to add some space to clear the top edge.
|
|
prcParent->top += GetSystemMetrics(SM_CYSIZEFRAME)*2 ; //TODO: Centralize.
|
|
}
|
|
return hwndParent ;
|
|
}
|
|
|
|
// pszFont == "facename, pointsize, charset, color and attributes"
|
|
//
|
|
// color or attributes: 0x??? == specifies a standard win32 COLORREF DWORD == 0xbbggrr
|
|
// #??? == specifies an IE color in the form #rrggbb.
|
|
//
|
|
HFONT CreateUserFont(PCSTR pszFont, COLORREF* pclrFont, HDC hDC, INT charset)
|
|
{
|
|
LOGFONT logfont;
|
|
ZERO_STRUCTURE(logfont);
|
|
logfont.lfWeight = FW_NORMAL;
|
|
logfont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
|
|
logfont.lfCharSet = 0xff; // lfCharSet is unsigned (don't use -1).
|
|
|
|
if( pclrFont )
|
|
*pclrFont = CLR_INVALID;
|
|
|
|
// facename[, point size[, charset[, color[, BOLD | ITALIC | UNDERLINE]]]]
|
|
|
|
CStr cszFont(pszFont); // make a copy so that we can change it
|
|
PSTR pszComma = StrChr(cszFont, ',');
|
|
int ptSize = 12;
|
|
|
|
if (pszComma){
|
|
*pszComma = '\0'; // So the facename is isolated
|
|
pszComma = FirstNonSpace(pszComma + 1); // get the point size
|
|
if (IsDigit(*pszComma))
|
|
ptSize = Atoi(pszComma);
|
|
|
|
pszComma = StrChr(pszComma, ',');
|
|
if (pszComma) {
|
|
pszComma = FirstNonSpace(pszComma + 1); // get the charset
|
|
if (IsDigit(*pszComma))
|
|
logfont.lfCharSet = (BYTE)Atoi(pszComma);
|
|
|
|
pszComma = StrChr(pszComma, ',');
|
|
if (pszComma) { // get color or attribs
|
|
|
|
// Get the font attributes first
|
|
pszComma = FirstNonSpace(pszComma + 1);
|
|
|
|
if (stristr(pszComma, "BOLD"))
|
|
logfont.lfWeight = FW_BOLD;
|
|
if (stristr(pszComma, "ITALIC"))
|
|
logfont.lfItalic = TRUE;
|
|
if (stristr(pszComma, "UNDERLINE"))
|
|
logfont.lfUnderline = TRUE;
|
|
|
|
// may be a color value instead, if so, save the color
|
|
// an repeat this check go fetch the attributes
|
|
if( stristr( pszComma, "#" ) ) { // IE color
|
|
//*(pszComma+7) = 0;
|
|
// IE Color
|
|
CWStr pwszColor = pszComma;
|
|
if( pclrFont )
|
|
*pclrFont = IEColorToWin32Color( pwszColor.pw );
|
|
}
|
|
else if( stristr( pszComma, "0x" ) || stristr( pszComma, "0X" ) ) {
|
|
//*(pszComma+8) = 0;
|
|
// Win32 Color
|
|
if( pclrFont )
|
|
*pclrFont = Atoi( pszComma );
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
lstrcpyn(logfont.lfFaceName, cszFont, LF_FACESIZE);
|
|
|
|
// REVIEW: we could special-case some common font names to get the
|
|
// correct font family for logfont.lfPitchAndFamily
|
|
logfont.lfOutPrecision = OUT_DEFAULT_PRECIS;
|
|
logfont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
|
|
logfont.lfQuality = DEFAULT_QUALITY;
|
|
|
|
// Deal with charset...
|
|
//
|
|
if ( charset != -1 )
|
|
logfont.lfCharSet = (BYTE)charset;
|
|
else
|
|
{
|
|
if ( logfont.lfCharSet == 0xff)
|
|
{
|
|
if (isSameString(cszFont, "Symbol") || isSameString(cszFont, "WingDings"))
|
|
logfont.lfCharSet = SYMBOL_CHARSET;
|
|
else
|
|
{
|
|
HWND hwndDesktop = GetDesktopWindow();
|
|
HDC hdc = GetDC(hwndDesktop);
|
|
if (hdc) {
|
|
TEXTMETRIC tm;
|
|
GetTextMetrics(hdc, &tm);
|
|
logfont.lfCharSet = tm.tmCharSet;
|
|
ReleaseDC(hwndDesktop, hdc);
|
|
}
|
|
else
|
|
logfont.lfCharSet = ANSI_CHARSET; // REVIEW: should use the current system charset
|
|
}
|
|
}
|
|
}
|
|
|
|
// fix for Whistler bug #8123
|
|
//
|
|
if(PRIMARYLANGID(LANGIDFROMLCID(GetSystemDefaultLCID())) == LANG_THAI && g_bWinNT5 && ptSize < 11)
|
|
ptSize = 11;
|
|
|
|
|
|
LONG dyHeight;
|
|
if (! hDC )
|
|
{
|
|
hDC = CreateIC("DISPLAY", NULL, NULL, NULL);
|
|
dyHeight = MulDiv(GetDeviceCaps(hDC, LOGPIXELSY), ptSize * 2, 144);
|
|
DeleteDC(hDC);
|
|
}
|
|
else
|
|
dyHeight = MulDiv(GetDeviceCaps(hDC, LOGPIXELSY), ptSize * 2, 144);
|
|
|
|
logfont.lfHeight = -dyHeight;
|
|
return CreateFontIndirect(&logfont);
|
|
}
|
|
|
|
// pszFont == "facename, pointsize, charset, color and attributes"
|
|
//
|
|
// color or attributes: 0x??? == specifies a standard win32 COLORREF DWORD == 0xbbggrr
|
|
// #??? == specifies an IE color in the form #rrggbb.
|
|
//
|
|
HFONT CreateUserFontW(WCHAR *pwzFont, COLORREF* pclrFont, HDC hDC, INT charset)
|
|
{
|
|
LOGFONTW logfont;
|
|
ZERO_STRUCTURE(logfont);
|
|
logfont.lfWeight = FW_NORMAL;
|
|
logfont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
|
|
logfont.lfCharSet = -1;
|
|
|
|
if( pclrFont )
|
|
*pclrFont = CLR_INVALID;
|
|
|
|
// facename[, point size[, charset[, color[, BOLD | ITALIC | UNDERLINE]]]]
|
|
|
|
|
|
WCHAR *cwzFont = _wcsdup(pwzFont); // make a copy so that we can change it
|
|
WCHAR *pwzComma = wcschr(cwzFont, L',');
|
|
int ptSize = 12;
|
|
|
|
if (pwzComma){
|
|
*pwzComma = '\0'; // So the facename is isolated
|
|
pwzComma = FirstNonSpaceW(pwzComma + 1); // get the point size
|
|
if (IsDigitW(*pwzComma))
|
|
ptSize = _wtoi(pwzComma);
|
|
|
|
pwzComma = wcschr(pwzComma, L',');
|
|
if (pwzComma)
|
|
{
|
|
pwzComma = FirstNonSpaceW(pwzComma + 1); // get the charset
|
|
if (IsDigitW(*pwzComma))
|
|
logfont.lfCharSet = (BYTE)_wtoi(pwzComma);
|
|
|
|
pwzComma = wcschr(pwzComma, L',');
|
|
if (pwzComma)
|
|
{ // get color or attribs
|
|
|
|
// Get the font attributes first
|
|
pwzComma = FirstNonSpaceW(pwzComma + 1);
|
|
|
|
if (wcsstr(pwzComma, L"BOLD"))
|
|
logfont.lfWeight = FW_BOLD;
|
|
if (wcsstr(pwzComma, L"ITALIC"))
|
|
logfont.lfItalic = TRUE;
|
|
if (wcsstr(pwzComma, L"UNDERLINE"))
|
|
logfont.lfUnderline = TRUE;
|
|
|
|
// may be a color value instead, if so, save the color
|
|
// an repeat this check go fetch the attributes
|
|
if( wcsstr( pwzComma, L"#" ) ) { // IE color
|
|
//*(pszComma+7) = 0;
|
|
// IE Color
|
|
*pclrFont = IEColorToWin32Color( pwzComma);
|
|
}
|
|
else if( wcsstr( pwzComma, L"0x" ) || wcsstr( pwzComma, L"0X" ) )
|
|
{
|
|
//*(pszComma+8) = 0;
|
|
// Win32 Color
|
|
if( pclrFont )
|
|
*pclrFont = _wtoi( pwzComma );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
wcsncpy(logfont.lfFaceName, cwzFont, LF_FACESIZE);
|
|
|
|
// REVIEW: we could special-case some common font names to get the
|
|
// correct font family for logfont.lfPitchAndFamily
|
|
logfont.lfOutPrecision = OUT_DEFAULT_PRECIS;
|
|
logfont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
|
|
logfont.lfQuality = DEFAULT_QUALITY;
|
|
|
|
// Deal with charset...
|
|
//
|
|
if ( charset != -1 )
|
|
logfont.lfCharSet = (BYTE)charset;
|
|
else
|
|
{
|
|
if ( logfont.lfCharSet == -1 )
|
|
{
|
|
if (!wcsicmp(cwzFont, L"Symbol") || !wcsicmp(cwzFont, L"WingDings"))
|
|
logfont.lfCharSet = SYMBOL_CHARSET;
|
|
else
|
|
{
|
|
HWND hwndDesktop = GetDesktopWindow();
|
|
HDC hdc = GetDC(hwndDesktop);
|
|
if (hdc) {
|
|
TEXTMETRIC tm;
|
|
GetTextMetrics(hdc, &tm);
|
|
logfont.lfCharSet = tm.tmCharSet;
|
|
ReleaseDC(hwndDesktop, hdc);
|
|
}
|
|
else
|
|
logfont.lfCharSet = ANSI_CHARSET; // REVIEW: should use the current system charset
|
|
}
|
|
}
|
|
}
|
|
|
|
LONG dyHeight;
|
|
if (! hDC )
|
|
{
|
|
hDC = CreateIC("DISPLAY", NULL, NULL, NULL);
|
|
dyHeight = MulDiv(GetDeviceCaps(hDC, LOGPIXELSY), ptSize * 2, 144);
|
|
DeleteDC(hDC);
|
|
}
|
|
else
|
|
dyHeight = MulDiv(GetDeviceCaps(hDC, LOGPIXELSY), ptSize * 2, 144);
|
|
|
|
logfont.lfHeight = -dyHeight;
|
|
|
|
free(cwzFont);
|
|
|
|
return CreateFontIndirectW(&logfont);
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: CreateFolder
|
|
|
|
PURPOSE: Create a directory, even if it means creating several
|
|
subdirectories
|
|
|
|
PARAMETERS:
|
|
pszPath
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
|
|
MODIFICATION DATES:
|
|
31-Oct-1996 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
BOOL CreateFolder(PCSTR pszPath)
|
|
{
|
|
CStr cszPath(pszPath); // copy it so that we can change it
|
|
|
|
if (CreateDirectory(cszPath, NULL))
|
|
return TRUE;
|
|
|
|
PSTR psz = StrRChr(cszPath, CH_BACKSLASH);
|
|
if (!psz) {
|
|
psz = StrRChr(cszPath, '/');
|
|
if (!psz)
|
|
return FALSE;
|
|
}
|
|
*psz = '\0';
|
|
BOOL fResult = CreateFolder(cszPath);
|
|
*psz = CH_BACKSLASH;
|
|
return CreateDirectory(cszPath, NULL);
|
|
}
|
|
|
|
BOOL GetHighContrastFlag(void)
|
|
{
|
|
HIGHCONTRAST highcontrast;
|
|
|
|
highcontrast.cbSize = sizeof(highcontrast);
|
|
|
|
if (SystemParametersInfo(SPI_GETHIGHCONTRAST,
|
|
sizeof(highcontrast),
|
|
&highcontrast, FALSE)) {
|
|
return (highcontrast.dwFlags & HCF_HIGHCONTRASTON);
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
#if 0
|
|
BOOL IsValidString(LPCWSTR lpsz, int nLength)
|
|
{
|
|
if (lpsz == NULL)
|
|
return FALSE;
|
|
return ::IsBadStringPtrW(lpsz, nLength) == 0;
|
|
}
|
|
|
|
BOOL IsValidString(LPCSTR lpsz, int nLength)
|
|
{
|
|
if (lpsz == NULL)
|
|
return FALSE;
|
|
return ::IsBadStringPtrA(lpsz, nLength) == 0;
|
|
}
|
|
|
|
BOOL IsValidAddress(const void* lp, UINT nBytes, BOOL bReadWrite)
|
|
{
|
|
// simple version using Win-32 APIs for pointer validation.
|
|
return (lp != NULL && !IsBadReadPtr(lp, nBytes) &&
|
|
(!bReadWrite || !IsBadWritePtr((LPVOID)lp, nBytes)));
|
|
}
|
|
|
|
#endif
|
|
|
|
void ConvertSpacesToEscapes(PCSTR pszSrc, CStr* pcszDst)
|
|
{
|
|
int cbAlloc = pcszDst->SizeAlloc();
|
|
if (!cbAlloc)
|
|
pcszDst->ReSize(cbAlloc = (int)(strlen(pszSrc) + 128));
|
|
int dstPos = 0;
|
|
if (!pszSrc) {
|
|
*pcszDst = "";
|
|
return;
|
|
}
|
|
int cbSrc = (int)strlen(pszSrc);
|
|
while (*pszSrc) {
|
|
if (*pszSrc == ' ') {
|
|
if ((size_t) cbAlloc - dstPos <= 4)
|
|
pcszDst->ReSize(cbAlloc += 128);
|
|
strcpy(pcszDst->psz + dstPos, "%20");
|
|
dstPos += (int)strlen("%20");
|
|
pszSrc++;
|
|
}
|
|
else
|
|
pcszDst->psz[dstPos++] = *pszSrc++;
|
|
if (cbAlloc <= dstPos)
|
|
pcszDst->ReSize(cbAlloc += 128);
|
|
}
|
|
pcszDst->psz[dstPos] = '\0';
|
|
}
|
|
|
|
static const char txtItsExtension[] = ".its";
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: IsCompiledURL
|
|
|
|
PURPOSE: Determines if a specified URL represents one of our compiled
|
|
files.
|
|
|
|
PARAMETERS:
|
|
pszURL - URL to check
|
|
|
|
RETURNS:
|
|
|
|
TRUE if so, otherwise FALSE.
|
|
|
|
COMMENTS:
|
|
|
|
Unlike IsCompiledHtmlFile, this function does not have any side
|
|
effects--the way God intended all IsX functions to be!
|
|
|
|
MODIFICATION DATES:
|
|
02-Jan-1998 [paulti]
|
|
|
|
***************************************************************************/
|
|
|
|
BOOL IsCompiledURL( PCSTR pszURL )
|
|
{
|
|
// Check to see if the pszURL is prefixed with the moniker information.
|
|
if( IsSamePrefix(pszURL, txtMkStore, (int)strlen(txtMkStore) - 1) ||
|
|
IsSamePrefix(pszURL, txtMsItsMoniker, (int)strlen(txtMsItsMoniker) - 1) ||
|
|
IsSamePrefix(pszURL, txtItsMoniker, (int)strlen(txtItsMoniker) - 1)) {
|
|
return TRUE;
|
|
}
|
|
|
|
// TODO: do we want to verify this further? We could do an existence
|
|
// check or make sure the URL is formulated correctly. However,
|
|
// doing such will just introduce more overhead.
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: GetURLType
|
|
|
|
PURPOSE: Determines what type of URL we have.
|
|
|
|
PARAMETERS:
|
|
pszURL - URL to check
|
|
|
|
RETURNS:
|
|
|
|
HH_URL_PREFIX_LESS if of the form: my.chm::/my.htm
|
|
HH_URL_UNQUALIFIED if of the form: mk@MSITStore:my.chm::/my.htm
|
|
HH_URL_QUALIFIED if of the form: mk@MSITStore:c:\my.chm::/my.htm
|
|
HH_URL_JAVASCRIPT if of the form: javascript:...
|
|
HH_URL_UNKNOWN if of an unknown form (just pass these along)
|
|
|
|
COMMENTS:
|
|
|
|
The unknown URL type is basically a non-HTML Help URL that
|
|
should remain unprocessed!
|
|
|
|
MODIFICATION DATES:
|
|
11-Jun-1998 [paulti] created
|
|
29-Oct-1998 [paulti] added ms-its:http://some.server.com/... check
|
|
18-Nov-1998 [paulti] added //255.255.255.255 check
|
|
|
|
***************************************************************************/
|
|
|
|
UINT GetURLType( PCSTR pszURL )
|
|
{
|
|
// bail out if we are passed a NULL value
|
|
if( !pszURL || !*pszURL )
|
|
return HH_URL_UNKNOWN;
|
|
|
|
// check if it is a javascript
|
|
if( !StrNCmpI(pszURL, "javascript:", 11) )
|
|
return HH_URL_JAVASCRIPT;
|
|
|
|
UINT uiReturn = HH_URL_UNKNOWN;
|
|
|
|
// check if the URL contains a ".chm" string
|
|
PSTR pszExt = NULL;
|
|
if( (uiReturn == HH_URL_UNKNOWN) && (pszExt = stristr(pszURL, txtDefExtension)) ) {
|
|
|
|
PSTR pszChm = (PSTR) pszURL;
|
|
uiReturn = HH_URL_UNQUALIFIED;
|
|
|
|
// Check to see if the pszURL is prefixed with the moniker information.
|
|
// if it is then we will call is this a unqualified URL (and will prove
|
|
// if it is really qualified later).
|
|
if( IsSamePrefix(pszURL, txtMkStore, (int)strlen(txtMkStore) - 1) )
|
|
pszChm += strlen(txtMkStore);
|
|
else if ( IsSamePrefix(pszURL, txtMsItsMoniker, (int)strlen(txtMsItsMoniker) - 1) )
|
|
pszChm += strlen(txtMsItsMoniker);
|
|
else if ( IsSamePrefix(pszURL, txtItsMoniker, (int)strlen(txtItsMoniker) - 1))
|
|
pszChm += strlen(txtItsMoniker);
|
|
else
|
|
uiReturn = HH_URL_PREFIX_LESS;
|
|
|
|
// if prefix less lets make sure it really is just prefixed with
|
|
// a simple chm filename instead of some other bizarre URL that does
|
|
// contain .chm somewhere in the middle
|
|
if( uiReturn == HH_URL_PREFIX_LESS ) {
|
|
PSTR psz = (PSTR) pszURL;
|
|
while( psz != pszExt ) {
|
|
if( *psz == ':' || *psz == '\\' || *psz == '/' ) {
|
|
uiReturn = HH_URL_UNKNOWN;
|
|
break;
|
|
}
|
|
psz++;
|
|
}
|
|
}
|
|
|
|
// if unqualified, check if it is really qualified or not
|
|
// if it begins with "X:" or "\\" then it is qualified
|
|
// if it is not qualified but contains a '/' or a '\' and the .chm
|
|
// extention then it is unknown (probably of the for:"
|
|
// ms-its:http://some.server.com/some/file.chm::some.stream.htm
|
|
if( uiReturn == HH_URL_UNQUALIFIED ) {
|
|
PSTR psz = (PSTR) ((DWORD_PTR)pszChm+1);
|
|
if( *psz == ':' || *psz == '\\' || *psz == '/' ) {
|
|
|
|
// make sure it is not of the type:
|
|
// ms-its:\\172.30.161.112\shared\boof\oops.chm::/source/Adam_nt.html
|
|
// if it is, call it unknown
|
|
BOOL bTCPIPServer = FALSE;
|
|
for( psz++; psz && *psz != '\\' && *psz != '/'; psz++ ) {
|
|
if( isdigit( *psz ) )
|
|
bTCPIPServer = TRUE;
|
|
else if( *psz == '.' )
|
|
bTCPIPServer = TRUE;
|
|
else {
|
|
bTCPIPServer = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( bTCPIPServer ) {
|
|
uiReturn = HH_URL_UNKNOWN;
|
|
}
|
|
else {
|
|
uiReturn = HH_URL_QUALIFIED;
|
|
}
|
|
}
|
|
else {
|
|
// seek to the first slash/backslash--if .chm is after this then
|
|
// we have an unknown type possibly of the form:
|
|
// ms-its:http://some.server.com/some/file.chm::some.stream.htm
|
|
PSTR pszSlash = strstr( psz, "/" );
|
|
if( !pszSlash )
|
|
pszSlash = strstr( psz, "\\" );
|
|
if( pszSlash && (pszSlash <= pszExt) ) {
|
|
uiReturn = HH_URL_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return uiReturn;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: IsCompiledHtmlFile
|
|
|
|
PURPOSE: Determines if a compiled HTML file is specified. If
|
|
pcszFile is specified, and pszFile does not begin with a
|
|
moniker, then we find the compiled HTML file before
|
|
returning.
|
|
|
|
PARAMETERS:
|
|
pszFile
|
|
pcszFile --- If this parameter is null, we don't attempt to find.
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
|
|
MODIFICATION DATES:
|
|
03-Jun-1997 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
BOOL IsCompiledHtmlFile(PCSTR pszFile, CStr* pcszFile)
|
|
{
|
|
//--- Check to see if the pszFile is prefixed with the moniker information.
|
|
if ( IsCompiledURL(pszFile) ) {
|
|
if (pcszFile)
|
|
*pcszFile = pszFile;
|
|
return TRUE;
|
|
}
|
|
|
|
//--- Look for the chm::topic separator.
|
|
PCSTR pszSep = stristr(pszFile, txtDoubleColonSep);
|
|
if (!pszSep)
|
|
{
|
|
// The separator has not been found.
|
|
if (stristr(pszFile, txtDefExtension) || stristr(pszFile, txtItsExtension))
|
|
pszSep = pszFile;
|
|
else
|
|
return FALSE; // not a compiled file if no separator
|
|
}
|
|
|
|
// If pcszFile is NULL, don't go look for the file.
|
|
if (!pcszFile)
|
|
return TRUE; // don't find it, just say it's compiled
|
|
|
|
//NOTE: We always return true. Whether we find the file or not.
|
|
|
|
// Remove the topic from the filename, before we find the file.
|
|
CStr cszFindFile(pszFile);
|
|
if (pszSep > pszFile)
|
|
cszFindFile.psz[pszSep - pszFile] = '\0'; // remove separator
|
|
|
|
//--- Find the file.
|
|
if (FindThisFile(NULL, cszFindFile, &cszFindFile, FALSE)) {
|
|
// Add on the moniker information. FindThisFile doesn't do this.
|
|
char szSep[MAX_PATH];
|
|
strcpy(szSep, pszSep); // in case pszFile == *pcszFile
|
|
*pcszFile = (g_bMsItsMonikerSupport ? txtMsItsMoniker : txtMkStore);
|
|
*pcszFile += cszFindFile.psz;
|
|
if (pszSep > pszFile)
|
|
*pcszFile += szSep;
|
|
return TRUE;
|
|
}
|
|
else
|
|
*pcszFile = pszFile;
|
|
|
|
// If we get here, it's a compiled file, but we don't know where it is
|
|
|
|
return TRUE; // we can't find the file, so let IE try to find it
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: IsCollectionFile
|
|
|
|
PURPOSE: Determines if a input file is a collection
|
|
|
|
PARAMETERS:
|
|
pszName -- original name
|
|
|
|
RETURNS:
|
|
TRUE if file is a collection
|
|
|
|
MODIFICATION DATES:
|
|
29-Jul-1997 [dondr]
|
|
|
|
***************************************************************************/
|
|
BOOL IsCollectionFile(PCSTR pszName)
|
|
{
|
|
if (stristr(pszName, txtCollectionExtension))
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: GetCompiledName
|
|
|
|
PURPOSE: Parse out just the compiled file name (and path)
|
|
E.g. "its:c:\foo.chm::/bar.htm" becomes "c:\foo.chm"
|
|
Note, we must convert any and all escape sequences like %20 as well [paulti]
|
|
|
|
PARAMETERS:
|
|
pszName -- original name
|
|
pcsz -- CStr to store result
|
|
|
|
RETURNS:
|
|
Pointer to any filename after a '::' separator in the
|
|
original string (pszName);
|
|
|
|
MODIFICATION DATES:
|
|
10-Jun-1997 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
PCSTR GetCompiledName(PCSTR pszName, CStr* pcsz)
|
|
{
|
|
ASSERT(pcsz != NULL) ;
|
|
if( !pszName )
|
|
return NULL;
|
|
|
|
if (IsSamePrefix(pszName, txtMkStore))
|
|
pszName += strlen(txtMkStore);
|
|
else if (IsSamePrefix(pszName, txtMsItsMoniker))
|
|
pszName += strlen(txtMsItsMoniker);
|
|
else if (IsSamePrefix(pszName, txtItsMoniker))
|
|
pszName += strlen(txtItsMoniker);
|
|
|
|
*pcsz = pszName;
|
|
PSTR pszSep = strstr(*pcsz, txtDoubleColonSep);
|
|
if (pszSep) {
|
|
*pszSep = '\0';
|
|
ReplaceEscapes(pcsz->psz, pcsz->psz, ESCAPE_URL); // remove escapes
|
|
return (strstr(pszName, txtDoubleColonSep) + 2);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: NormalizeFileName
|
|
|
|
PURPOSE: Take a filename to a CHM or COL and create a definitive
|
|
name for the file. For a CHM file, this is the moniker.
|
|
For a COL, its the moniker to the master CHM.
|
|
|
|
PARAMETERS:
|
|
cszFileName -- Modifies the name passed in.
|
|
|
|
RETURNS:
|
|
true - success
|
|
false - failure.
|
|
|
|
MODIFICATION DATES:
|
|
27-Apr-98 [dalero]
|
|
|
|
***************************************************************************/
|
|
bool
|
|
NormalizeFileName(CStr& cszFileName)
|
|
{
|
|
// We shouldn't be getting any http files. This isn't incorrect. I'm just testing my assumptions.
|
|
ASSERT(!IsHttp(cszFileName)) ;
|
|
|
|
if (IsCollectionFile(cszFileName)) // Is this a collection?
|
|
{
|
|
//...Much of this was borrowed from OnDisplayTopic...
|
|
// Get the master chm file name.
|
|
|
|
GetCompiledName(cszFileName, &cszFileName); // pszFilePortion is everything is cszFile after the '::', in other words the topic path.
|
|
if (!FindThisFile(NULL, cszFileName, &cszFileName, FALSE))
|
|
{
|
|
//TODO: Move error message into FindThisFile.
|
|
//g_LastError.Set(HH_E_FILENOTFOUND) ;
|
|
return false;
|
|
}
|
|
|
|
CHmData* phmData;
|
|
|
|
CExCollection* pCollection = GetCurrentCollection(NULL, (PCSTR)cszFileName);
|
|
if ( pCollection )
|
|
phmData = pCollection->m_phmData;
|
|
|
|
if (phmData == NULL)
|
|
{
|
|
//g_LastError.Set(HH_E_INVALIDHELPFILE) ; // TODO: FindCurFileData should set this.
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// Get the name of the master chm.
|
|
cszFileName = phmData->GetCompiledFile();
|
|
}
|
|
}
|
|
|
|
// Find the file and get all the moniker information.
|
|
if (IsCompiledHtmlFile(cszFileName, &cszFileName))
|
|
{
|
|
// Remove any filename tacked onto the end.
|
|
PSTR pszSep = strstr(cszFileName.psz, txtDoubleColonSep);
|
|
if (pszSep)
|
|
{
|
|
*pszSep = '\0';
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false ;
|
|
}
|
|
|
|
}
|
|
/***************************************************************************
|
|
|
|
FUNCTION: GetButtonDimensions
|
|
|
|
PURPOSE: Get the width/height of the button
|
|
|
|
PARAMETERS:
|
|
hwnd
|
|
psz
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
|
|
MODIFICATION DATES:
|
|
04-Feb-1993 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
#define CXBUTTONEXTRA 16 // spacing between text and button
|
|
#define CYBUTTONEXTRA 7
|
|
|
|
DWORD GetButtonDimensions(HWND hwnd, HFONT hFont, PCSTR psz)
|
|
{
|
|
HDC hdc = GetDC(hwnd);
|
|
DWORD dwRet;
|
|
POINT pt;
|
|
|
|
if (hdc == NULL)
|
|
return 0L;
|
|
// Select in the new font. The dialog may not have done this.
|
|
HFONT hOldFont = NULL ;
|
|
if (hFont)
|
|
{
|
|
hOldFont = (HFONT)SelectObject(hdc, hFont) ;
|
|
}
|
|
|
|
// Get the size of the text.
|
|
pt = GetTextSize(hdc, psz, (int)strlen(psz));
|
|
dwRet = MAKELONG(pt.x, pt.y) +
|
|
MAKELONG(CXBUTTONEXTRA, CYBUTTONEXTRA);
|
|
|
|
// Cleanup.
|
|
if (hOldFont)
|
|
{
|
|
SelectObject(hdc, hOldFont) ;
|
|
}
|
|
|
|
ReleaseDC(hwnd, hdc);
|
|
return dwRet;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GetStaticDimensions - used by simple search tab. max_len should include
|
|
// any space needed between the static text and buttons on the left or right.
|
|
//
|
|
DWORD GetStaticDimensions(HWND hwnd, HFONT hFont, PCSTR psz, int max_len )
|
|
{
|
|
DWORD dwRet;
|
|
POINT pt;
|
|
int rows;
|
|
HDC hdc = GetDC(hwnd);
|
|
|
|
if ( hdc == NULL )
|
|
return 0L;
|
|
|
|
// Select in the new font. The dialog may not have done this.
|
|
HFONT hOldFont = NULL ;
|
|
if (hFont)
|
|
{
|
|
hOldFont = (HFONT)SelectObject(hdc, hFont) ;
|
|
}
|
|
|
|
// Get the text extent.
|
|
pt = GetTextSize(hdc, psz, (int)strlen(psz) );
|
|
|
|
rows = pt.x/(max_len ? max_len : 1);
|
|
if ( pt.x%(max_len ? max_len : 1) > 0 )
|
|
rows++;
|
|
pt.y *= rows;
|
|
dwRet = MAKELONG(pt.x, pt.y);
|
|
|
|
// Cleanup.
|
|
if (hOldFont)
|
|
{
|
|
SelectObject(hdc, hOldFont) ;
|
|
}
|
|
|
|
ReleaseDC(hwnd, hdc);
|
|
return dwRet;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GetStaticDimensions - used by simple search tab. max_len should include
|
|
// any space needed between the static text and buttons on the left or right.
|
|
//
|
|
DWORD GetStaticDimensionsW(HWND hwnd, HFONT hFont, WCHAR *psz, int max_len )
|
|
{
|
|
DWORD dwRet;
|
|
POINT pt;
|
|
int rows;
|
|
HDC hdc = GetDC(hwnd);
|
|
|
|
if ( hdc == NULL )
|
|
return 0L;
|
|
|
|
// Select in the new font. The dialog may not have done this.
|
|
HFONT hOldFont = NULL ;
|
|
if (hFont)
|
|
{
|
|
hOldFont = (HFONT)SelectObject(hdc, hFont) ;
|
|
}
|
|
|
|
// Get the text extent.
|
|
pt = GetTextSizeW(hdc, psz, wcslen(psz) );
|
|
|
|
rows = pt.x/(max_len ? max_len : 1);
|
|
if ( pt.x%(max_len ? max_len : 1) > 0 )
|
|
rows++;
|
|
pt.y *= rows;
|
|
dwRet = MAKELONG(pt.x, pt.y);
|
|
|
|
// Cleanup.
|
|
if (hOldFont)
|
|
{
|
|
SelectObject(hdc, hOldFont) ;
|
|
}
|
|
|
|
ReleaseDC(hwnd, hdc);
|
|
return dwRet;
|
|
}
|
|
|
|
|
|
static POINT GetTextSize(HDC hdc, PCSTR qchBuf, int iCount)
|
|
{
|
|
POINT ptRet;
|
|
SIZE size;
|
|
|
|
GetTextExtentPoint32(hdc, qchBuf, iCount, &size);
|
|
ptRet.x = size.cx;
|
|
ptRet.y = size.cy;
|
|
|
|
return ptRet;
|
|
}
|
|
|
|
static POINT GetTextSizeW(HDC hdc, WCHAR *qchBuf, int iCount)
|
|
{
|
|
POINT ptRet;
|
|
SIZE size;
|
|
|
|
GetTextExtentPoint32W(hdc, qchBuf, iCount, &size);
|
|
ptRet.x = size.cx;
|
|
ptRet.y = size.cy;
|
|
|
|
return ptRet;
|
|
}
|
|
|
|
|
|
DWORD CreatePath(char *szPath)
|
|
{
|
|
char szTmp[MAX_PATH],*p,*q,szTmp2[MAX_PATH];
|
|
DWORD dwErr;
|
|
|
|
strcpy(szTmp2,szPath);
|
|
memset(szTmp,0,sizeof(szTmp));
|
|
q = szTmp2;
|
|
p = szTmp;
|
|
|
|
while (*q)
|
|
{
|
|
if (*q == '/' || *q == '\\')
|
|
{
|
|
if (szTmp[1] == ':' && strlen(szTmp) <= 3)
|
|
{
|
|
if(IsDBCSLeadByte(*q))
|
|
{
|
|
*p++ = *q++;
|
|
if(*q)
|
|
*p++ = *q++;
|
|
}
|
|
else
|
|
*p++ = *q++;
|
|
continue;
|
|
}
|
|
if (!::CreateDirectory(szTmp,0))
|
|
{
|
|
if ( (dwErr = GetLastError()) != ERROR_ALREADY_EXISTS)
|
|
return(dwErr);
|
|
}
|
|
}
|
|
if(IsDBCSLeadByte(*q))
|
|
{
|
|
*p++ = *q++;
|
|
if(*q)
|
|
*p++ = *q++;
|
|
}
|
|
else
|
|
*p++ = *q++;
|
|
}
|
|
if (!::CreateDirectory(szTmp,0))
|
|
{
|
|
if ((dwErr = GetLastError()) != ERROR_ALREADY_EXISTS)
|
|
return(dwErr);
|
|
}
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
BOOL IsFile( LPCSTR lpszPathname )
|
|
{
|
|
DWORD dwAttribs = GetFileAttributes( lpszPathname );
|
|
if( dwAttribs != (DWORD) -1 )
|
|
if( (dwAttribs & FILE_ATTRIBUTE_DIRECTORY) == 0 )
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsDirectory( LPCSTR lpszPathname )
|
|
{
|
|
DWORD dwAttribs = GetFileAttributes( lpszPathname );
|
|
if( dwAttribs != (DWORD) -1 )
|
|
if( dwAttribs & FILE_ATTRIBUTE_DIRECTORY )
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
/***
|
|
*SplitPath() - split a path name into its individual components
|
|
*
|
|
*Purpose:
|
|
* to split a path name into its individual components
|
|
*
|
|
*Entry:
|
|
* path - pointer to path name to be parsed
|
|
* drive - pointer to buffer for drive component, if any
|
|
* dir - pointer to buffer for subdirectory component, if any
|
|
* fname - pointer to buffer for file base name component, if any
|
|
* ext - pointer to buffer for file name extension component, if any
|
|
*
|
|
*Exit:
|
|
* drive - pointer to drive string. Includes ':' if a drive was given.
|
|
* dir - pointer to subdirectory string. Includes leading and trailing
|
|
* '/' or '\', if any.
|
|
* fname - pointer to file base name
|
|
* ext - pointer to file extension, if any. Includes leading '.'.
|
|
*
|
|
*Exceptions:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
void __cdecl SplitPath (
|
|
const char *path,
|
|
char *drive,
|
|
char *dir,
|
|
char *fname,
|
|
char *ext
|
|
)
|
|
{
|
|
char *p;
|
|
char *last_slash = NULL, *dot = NULL;
|
|
unsigned len;
|
|
|
|
/* we assume that the path argument has the following form, where any
|
|
* or all of the components may be missing.
|
|
*
|
|
* <drive><dir><fname><ext>
|
|
*
|
|
* and each of the components has the following expected form(s)
|
|
*
|
|
* drive:
|
|
* 0 to _MAX_DRIVE-1 characters, the last of which, if any, is a
|
|
* ':'
|
|
* dir:
|
|
* 0 to _MAX_DIR-1 characters in the form of an absolute path
|
|
* (leading '/' or '\') or relative path, the last of which, if
|
|
* any, must be a '/' or '\'. E.g -
|
|
* absolute path:
|
|
* \top\next\last\ ; or
|
|
* /top/next/last/
|
|
* relative path:
|
|
* top\next\last\ ; or
|
|
* top/next/last/
|
|
* Mixed use of '/' and '\' within a path is also tolerated
|
|
* fname:
|
|
* 0 to _MAX_FNAME-1 characters not including the '.' character
|
|
* ext:
|
|
* 0 to _MAX_EXT-1 characters where, if any, the first must be a
|
|
* '.'
|
|
*
|
|
*/
|
|
|
|
/* extract drive letter and :, if any */
|
|
|
|
if ((strlen(path) >= (_MAX_DRIVE - 2)) && (*(path + _MAX_DRIVE - 2) == ':')) {
|
|
if (drive) {
|
|
lstrcpyn(drive, path, _MAX_DRIVE);
|
|
*(drive + _MAX_DRIVE-1) = '\0';
|
|
}
|
|
path += _MAX_DRIVE - 1;
|
|
}
|
|
else if (drive) {
|
|
*drive = '\0';
|
|
}
|
|
|
|
/* extract path string, if any. Path now points to the first character
|
|
* of the path, if any, or the filename or extension, if no path was
|
|
* specified. Scan ahead for the last occurence, if any, of a '/' or
|
|
* '\' path separator character. If none is found, there is no path.
|
|
* We will also note the last '.' character found, if any, to aid in
|
|
* handling the extension.
|
|
*/
|
|
|
|
for (last_slash = NULL, p = (char *)path; *p; p++) {
|
|
#ifdef _MBCS
|
|
if (IsDBCSLeadByte (*p))
|
|
p++;
|
|
else {
|
|
#endif /* _MBCS */
|
|
if (*p == '/' || *p == '\\')
|
|
/* point to one beyond for later copy */
|
|
last_slash = p + 1;
|
|
else if (*p == '.')
|
|
dot = p;
|
|
#ifdef _MBCS
|
|
}
|
|
#endif /* _MBCS */
|
|
}
|
|
|
|
if (last_slash) {
|
|
|
|
/* found a path - copy up through last_slash or max. characters
|
|
* allowed, whichever is smaller
|
|
*/
|
|
|
|
if (dir) {
|
|
len = (unsigned)__min(((char *)last_slash - (char *)path) / sizeof(char),
|
|
(_MAX_DIR - 1));
|
|
lstrcpyn(dir, path, len+1);
|
|
*(dir + len) = '\0';
|
|
}
|
|
path = last_slash;
|
|
}
|
|
else if (dir) {
|
|
|
|
/* no path found */
|
|
|
|
*dir = '\0';
|
|
}
|
|
|
|
/* extract file name and extension, if any. Path now points to the
|
|
* first character of the file name, if any, or the extension if no
|
|
* file name was given. Dot points to the '.' beginning the extension,
|
|
* if any.
|
|
*/
|
|
|
|
if (dot && (dot >= path)) {
|
|
/* found the marker for an extension - copy the file name up to
|
|
* the '.'.
|
|
*/
|
|
if (fname) {
|
|
len = (unsigned)__min(((char *)dot - (char *)path) / sizeof(char),
|
|
(_MAX_FNAME - 1));
|
|
lstrcpyn(fname, path, len+1);
|
|
*(fname + len) = '\0';
|
|
}
|
|
/* now we can get the extension - remember that p still points
|
|
* to the terminating nul character of path.
|
|
*/
|
|
if (ext) {
|
|
len = (unsigned)__min(((char *)p - (char *)dot) / sizeof(char),
|
|
(_MAX_EXT - 1));
|
|
lstrcpyn(ext, dot, len+1);
|
|
*(ext + len) = '\0';
|
|
}
|
|
}
|
|
else {
|
|
/* found no extension, give empty extension and copy rest of
|
|
* string into fname.
|
|
*/
|
|
if (fname) {
|
|
len = (unsigned)__min(((char *)p - (char *)path) / sizeof(char),
|
|
(_MAX_FNAME - 1));
|
|
lstrcpyn(fname, path, len+1);
|
|
*(fname + len) = '\0';
|
|
}
|
|
if (ext) {
|
|
*ext = '\0';
|
|
}
|
|
}
|
|
}
|
|
|
|
void MemMove(void * dst, const void * src, int count)
|
|
{
|
|
#if defined (_M_MRX000) || defined (_M_ALPHA) || defined (_M_PPC)
|
|
{
|
|
|
|
RtlMoveMemory( dst, src, count );
|
|
}
|
|
#else /* defined (_M_MRX000) || defined (_M_ALPHA) || defined (_M_PPC) */
|
|
if (dst <= src || (char *)dst >= ((char *)src + count)) {
|
|
memcpy(dst, src, count);
|
|
}
|
|
else {
|
|
/*
|
|
* Overlapping Buffers
|
|
* copy from higher addresses to lower addresses
|
|
*/
|
|
dst = (char *)dst + count - 1;
|
|
src = (char *)src + count - 1;
|
|
|
|
while (count--) {
|
|
*(char *)dst = *(char *)src;
|
|
dst = (char *)dst - 1;
|
|
src = (char *)src - 1;
|
|
}
|
|
}
|
|
#endif /* defined (_M_MRX000) || defined (_M_ALPHA) || defined (_M_PPC) */
|
|
}
|
|
|
|
LPSTR CatPath(LPSTR lpTop, LPCSTR lpTail)
|
|
{
|
|
//
|
|
// make sure we have a slash at the end of the first element
|
|
//
|
|
LPSTR p;
|
|
|
|
if (lpTop && lpTop[0])
|
|
{
|
|
p = lpTop + strlen(lpTop);
|
|
p = CharPrev(lpTop,p);
|
|
if (*p != '\\' && *p != '/')
|
|
{
|
|
strcat(lpTop,"\\");
|
|
}
|
|
|
|
//
|
|
// strip any leading slash from the second element
|
|
//
|
|
|
|
while (*lpTail == '\\') lpTail = CharNext(lpTail);
|
|
|
|
//
|
|
}
|
|
// add them together
|
|
//
|
|
|
|
strcat(lpTop, lpTail);
|
|
|
|
return lpTop;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// NoRun - Checks registry to determine if the no run option is set for this system
|
|
//
|
|
BOOL NoRun()
|
|
{
|
|
HKEY hKeyResult;
|
|
DWORD dwNoRun;
|
|
DWORD count = sizeof(DWORD);
|
|
DWORD type;
|
|
LONG lReturn;
|
|
|
|
lReturn = RegOpenKeyEx( HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer", 0, KEY_READ, &hKeyResult);
|
|
|
|
if( lReturn == ERROR_SUCCESS )
|
|
{
|
|
lReturn = RegQueryValueEx(hKeyResult, "NoRun", 0, &type, (BYTE *)&dwNoRun, &count);
|
|
RegCloseKey(hKeyResult);
|
|
}
|
|
|
|
if (lReturn == ERROR_SUCCESS)
|
|
{
|
|
if (dwNoRun == 1)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
count = sizeof(DWORD);
|
|
lReturn = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer", 0, KEY_READ, &hKeyResult);
|
|
|
|
if( lReturn == ERROR_SUCCESS )
|
|
{
|
|
lReturn = RegQueryValueEx(hKeyResult, "NoRun", 0, &type, (BYTE *)&dwNoRun, &count);
|
|
RegCloseKey(hKeyResult);
|
|
}
|
|
|
|
if (lReturn == ERROR_SUCCESS)
|
|
{
|
|
if (dwNoRun == 1)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// NormalizeUrlInPlace
|
|
//
|
|
void
|
|
NormalizeUrlInPlace(LPSTR szURL)
|
|
{
|
|
//
|
|
// Normalize the URL by stripping off protocol, storage type, storage name goo from the URL then make sure
|
|
// we only have forward slashes. BUGBUG: May want to consider moving this to util.cpp if it turns up useful.
|
|
//
|
|
PSTR pszSep = strstr(szURL, txtDoubleColonSep);
|
|
if (pszSep)
|
|
{
|
|
strcpy(szURL, pszSep + 3);
|
|
}
|
|
ConvertBackSlashToForwardSlash(szURL);
|
|
}
|
|
|
|
void QRect(HDC hdc, INT x, INT y, INT cx, INT cy, INT color)
|
|
{
|
|
DWORD dwColor;
|
|
RECT rc;
|
|
|
|
dwColor = SetBkColor(hdc,GetSysColor(color));
|
|
rc.left = x;
|
|
rc.top = y;
|
|
rc.right = x + cx;
|
|
rc.bottom = y + cy;
|
|
ExtTextOut(hdc,0,0,ETO_OPAQUE,&rc,NULL,0,NULL);
|
|
SetBkColor(hdc,dwColor);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Determine if the wintype is a global wintype.
|
|
//
|
|
bool
|
|
IsGlobalWinType(const char* szType)
|
|
{
|
|
// Skip possible leading window separator character.
|
|
const char* psz = szType ;
|
|
if (psz[0] == '>')
|
|
{
|
|
psz++ ;
|
|
}
|
|
|
|
if (_strnicmp(psz, GLOBAL_WINDOWTYPE_PREFIX, (int)strlen(GLOBAL_WINDOWTYPE_PREFIX)) == 0)
|
|
{
|
|
return true ;
|
|
}
|
|
else if (_strnicmp(psz, GLOBAL_WINDOWTYPE_PREFIX_OFFICE, (int)strlen(GLOBAL_WINDOWTYPE_PREFIX_OFFICE)) == 0)
|
|
{
|
|
return true ;
|
|
}
|
|
else if (_Module.m_GlobalWinTypes.Find(psz))
|
|
{
|
|
return true ;
|
|
}
|
|
else
|
|
{
|
|
return false ;
|
|
}
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Determine if the wintype is a global wintype.
|
|
//
|
|
bool
|
|
IsGlobalWinTypeW(LPCWSTR szType)
|
|
{
|
|
LPCWSTR psz = szType ;
|
|
if (psz[0] == '>')
|
|
{
|
|
psz++ ;
|
|
}
|
|
|
|
if (_wcsnicmp(psz, GLOBAL_WINDOWTYPE_PREFIX_W, wcslen(GLOBAL_WINDOWTYPE_PREFIX_W)) == 0)
|
|
{
|
|
return true ;
|
|
}
|
|
else if (_wcsnicmp(psz, GLOBAL_WINDOWTYPE_PREFIX_OFFICE_W, wcslen(GLOBAL_WINDOWTYPE_PREFIX_OFFICE_W)) == 0)
|
|
{
|
|
return true ;
|
|
}
|
|
else if (_Module.m_GlobalWinTypes.Find(psz))
|
|
{
|
|
return true ;
|
|
}
|
|
else
|
|
{
|
|
return false ;
|
|
}
|
|
|
|
}
|
|
|
|
static const char txtSetupKey[] = "Software\\Microsoft\\Windows\\CurrentVersion\\Setup";
|
|
static const char txtSharedDir[] = "SharedDir";
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Get the windows directory for the system or the user
|
|
//
|
|
// Note, Windows NT Terminal Server has changed the system API
|
|
// of GetWindowsDirectory to return a per-user system directory.
|
|
// Inorder to determine this condtion we need to check kernel32
|
|
// for the GetSystemWindowsDirectory API and if it exists use
|
|
// this one instead.
|
|
//
|
|
UINT HHGetWindowsDirectory( LPSTR lpBuffer, UINT uSize, UINT uiType )
|
|
{
|
|
UINT uiReturn = 0;
|
|
static PFN_GETWINDOWSDIRECTORY pfnGetUsersWindowsDirectory = NULL;
|
|
static PFN_GETWINDOWSDIRECTORY pfnGetSystemWindowsDirectory = NULL;
|
|
|
|
// determine which system API to call for each case
|
|
if( !pfnGetSystemWindowsDirectory || !pfnGetSystemWindowsDirectory ) {
|
|
|
|
HINSTANCE hInst = LoadLibrary( "Kernel32" );
|
|
if( !hInst )
|
|
return uiReturn;
|
|
|
|
pfnGetSystemWindowsDirectory = (PFN_GETWINDOWSDIRECTORY) GetProcAddress( hInst, "GetSystemWindowsDirectoryA" );
|
|
|
|
pfnGetUsersWindowsDirectory = (PFN_GETWINDOWSDIRECTORY) GetProcAddress( hInst, "GetWindowsDirectoryA" );
|
|
ASSERT( pfnGetUsersWindowsDirectory ); // if NULL then we have a bug!
|
|
|
|
if( !pfnGetSystemWindowsDirectory ) {
|
|
pfnGetSystemWindowsDirectory = pfnGetUsersWindowsDirectory;
|
|
}
|
|
|
|
FreeLibrary( hInst );
|
|
}
|
|
|
|
// for Windows 9x, we need to consult with the registry shareddir first
|
|
// [paulti] - I have no idea why we need to do this -- this code came
|
|
// from Ralph!
|
|
HKEY hkey;
|
|
DWORD type;
|
|
|
|
DWORD cbPath = uSize;
|
|
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, txtSetupKey, 0, KEY_READ, &hkey) ==
|
|
ERROR_SUCCESS) {
|
|
RegQueryValueEx(hkey, txtSharedDir, 0, &type, (PBYTE) lpBuffer, &cbPath);
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
// if this failed, then call the system functions
|
|
if( cbPath == uSize ) { // means couldn't read registry key
|
|
if( uiType == HH_SYSTEM_WINDOWS_DIRECTORY )
|
|
uiReturn = pfnGetSystemWindowsDirectory( lpBuffer, uSize );
|
|
else if( uiType == HH_USERS_WINDOWS_DIRECTORY )
|
|
uiReturn = pfnGetUsersWindowsDirectory( lpBuffer, uSize );
|
|
else
|
|
uiReturn = 0;
|
|
}
|
|
else
|
|
uiReturn = cbPath;
|
|
|
|
|
|
return uiReturn;
|
|
}
|
|
|
|
static const char txtGlobal[] = "global.col";
|
|
static const char txtColReg[] = "hhcolreg.dat";
|
|
static const char txtHelp[] = "help";
|
|
static const char txtHHDat[] = "hh.dat";
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Get the help directory
|
|
//
|
|
// Note, this is always relative to the system's windows
|
|
// directory and not the user's windows directory.
|
|
// See HHGetWindowsDirectory for details on this.
|
|
//
|
|
UINT HHGetHelpDirectory( LPTSTR lpBuffer, UINT uSize )
|
|
{
|
|
UINT uiReturn = 0;
|
|
|
|
uiReturn = HHGetWindowsDirectory( lpBuffer, uSize );
|
|
CatPath( lpBuffer, txtHelp );
|
|
|
|
return uiReturn;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Get the full pathname to the global collections file
|
|
//
|
|
// Note, this is in always in the system's help directory.
|
|
//
|
|
UINT HHGetGlobalCollectionPathname( LPTSTR lpBuffer, UINT uSize, BOOL *pbNewPath )
|
|
{
|
|
UINT uiReturn = 0;
|
|
|
|
*pbNewPath = TRUE;
|
|
uiReturn = HHGetHelpDataPath( lpBuffer );
|
|
|
|
if (uiReturn != S_OK)
|
|
{
|
|
*pbNewPath = FALSE;
|
|
uiReturn = HHGetHelpDirectory( lpBuffer, uSize );
|
|
if( !IsDirectory(lpBuffer) )
|
|
CreatePath( lpBuffer );
|
|
}
|
|
CatPath( lpBuffer, txtColReg );
|
|
|
|
return uiReturn;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Get the full pathname to the old global collections file
|
|
//
|
|
// Note, this is in always in the user's windows\help directory
|
|
// since the old code did not handle the Terminal Server path correctly.
|
|
//
|
|
UINT HHGetOldGlobalCollectionPathname( LPTSTR lpBuffer, UINT uSize )
|
|
{
|
|
UINT uiReturn = 0;
|
|
|
|
uiReturn = HHGetHelpDirectory( lpBuffer, uSize );
|
|
|
|
if( !IsDirectory(lpBuffer) )
|
|
CreatePath( lpBuffer );
|
|
|
|
CatPath( lpBuffer, txtColReg );
|
|
|
|
return uiReturn;
|
|
}
|
|
|
|
typedef HRESULT (WINAPI *PFN_SHGETSPECIALFOLDERPATH)( HWND hWnd, LPSTR pszPath, int nFolder, BOOL fCreate );
|
|
static const char txtProfiles[] = "Profiles";
|
|
static const char txtUser[] = "Default User";
|
|
static const char txtAllUsers[] = "All Users";
|
|
static const char txtApplicationData[] = "Application Data";
|
|
static const char txtMicrosoft[] = "Microsoft";
|
|
static const char txtHTMLHelp[] = "HTML Help";
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Get the full path to where the user's data file is stored
|
|
//
|
|
// Note, if the subdirectories of the path does not exist
|
|
// we will create them
|
|
//
|
|
// Note, the Shell32 function SHGetSpecialFolderPathA only exist
|
|
// on platforms with IE4 or later. For those platforms that
|
|
// do not have this API we will have to simulate the returned
|
|
// "%windir%\Profiles\%username%\Application Data" path
|
|
HRESULT HHGetUserDataPath( LPSTR pszPath )
|
|
{
|
|
HRESULT hResult = S_OK;
|
|
static PFN_SHGETSPECIALFOLDERPATH pfnSHGetSpecialFolderPath = NULL;
|
|
|
|
// get the pointer to this function in shell32
|
|
if( !pfnSHGetSpecialFolderPath ) {
|
|
HINSTANCE hInst = LoadLibrary( "Shell32" );
|
|
if( !hInst )
|
|
return S_FALSE;
|
|
pfnSHGetSpecialFolderPath = (PFN_SHGETSPECIALFOLDERPATH) GetProcAddress( hInst, "SHGetSpecialFolderPathA" );
|
|
FreeLibrary( hInst ); // since we already have a copy of Shell32 loaded, free it
|
|
}
|
|
|
|
// if this function does not exist then we need to similate the return path of
|
|
// "%windir%\Profiles\%username%\Application Data"
|
|
if( !pfnSHGetSpecialFolderPath ) {
|
|
HardCodeUserPath:
|
|
// get the system's Windows directory
|
|
HHGetWindowsDirectory( pszPath, _MAX_PATH, HH_SYSTEM_WINDOWS_DIRECTORY );
|
|
|
|
// append "Profiles"
|
|
CatPath( pszPath, txtProfiles );
|
|
if( !IsDirectory(pszPath) )
|
|
if( !CreateDirectory( pszPath, NULL ) )
|
|
return S_FALSE;
|
|
|
|
// append "User"
|
|
char szUsername[_MAX_PATH];
|
|
DWORD dwSize = sizeof(szUsername);
|
|
if( !GetUserName( szUsername, &dwSize ) )
|
|
strcpy( szUsername, txtUser );
|
|
CatPath( pszPath, szUsername );
|
|
if( !IsDirectory(pszPath) )
|
|
if( !CreateDirectory( pszPath, NULL ) )
|
|
return S_FALSE;
|
|
|
|
// append "Application Data"
|
|
CatPath( pszPath, txtApplicationData );
|
|
if( !IsDirectory(pszPath) )
|
|
if( !CreateDirectory( pszPath, NULL ) )
|
|
return S_FALSE;
|
|
|
|
}
|
|
else {
|
|
// now call it
|
|
hResult = pfnSHGetSpecialFolderPath( NULL, pszPath, CSIDL_APPDATA, 0 );
|
|
if (pszPath[0] == NULL)
|
|
goto HardCodeUserPath;
|
|
}
|
|
|
|
// append "Microsoft"
|
|
CatPath( pszPath, txtMicrosoft );
|
|
if( !IsDirectory(pszPath) )
|
|
if( !CreateDirectory( pszPath, NULL ) )
|
|
return S_FALSE;
|
|
|
|
// append "HTML Help"
|
|
CatPath( pszPath, txtHTMLHelp );
|
|
if( !IsDirectory(pszPath) )
|
|
if( !CreateDirectory( pszPath, NULL ) )
|
|
return S_FALSE;
|
|
|
|
return hResult;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Get the full pathname to the user's data file
|
|
//
|
|
// Note, older version of HTML Help always put the hh.dat file
|
|
// in the user's windows directory. Thus, if we find one there
|
|
// and not in the new user's directory we will copy over this file
|
|
// to the new location.
|
|
//
|
|
HRESULT HHGetUserDataPathname( LPSTR lpBuffer, UINT uSize )
|
|
{
|
|
HRESULT hResult = S_OK;
|
|
|
|
// check the new user data path first
|
|
if( (SUCCEEDED( hResult = HHGetUserDataPath( lpBuffer ))) ) {
|
|
|
|
// append the name of the hh.dat file to the path
|
|
CatPath( lpBuffer, txtHHDat );
|
|
|
|
// if file exists there then we are done
|
|
if( !IsFile(lpBuffer) ) {
|
|
|
|
// if the file does not exist in the new user's path then
|
|
// check the users's windows directory can copy it if found
|
|
char szHHDatPathname[_MAX_PATH];
|
|
HHGetWindowsDirectory( szHHDatPathname, sizeof(szHHDatPathname),
|
|
HH_USERS_WINDOWS_DIRECTORY );
|
|
CatPath( szHHDatPathname, txtHHDat );
|
|
if( IsFile( szHHDatPathname ) ) {
|
|
CopyFile( szHHDatPathname, lpBuffer, TRUE );
|
|
//DeleteFile( szHHDatPathname ); // should we nuke the old one?
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return hResult;
|
|
}
|
|
typedef HRESULT (WINAPI *PFN_SHGETFOLDERPATH)( HWND hWnd, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath );
|
|
#ifndef CSIDL_FLAG_CREATE
|
|
#define CSIDL_COMMON_APPDATA 0x0023
|
|
#define CSIDL_FLAG_CREATE 0x8000
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Get the full path to where the common help data files lives
|
|
// hhcolreg.dat
|
|
//
|
|
// Note, if the subdirectories of the path does not exist
|
|
// we will create them
|
|
//
|
|
HRESULT HHGetHelpDataPath( LPSTR pszPath )
|
|
{
|
|
HRESULT hResult = S_OK;
|
|
static PFN_SHGETFOLDERPATH pfnSHGetFolderPath = NULL;
|
|
|
|
// get the pointer to this function in shell32
|
|
if( !pfnSHGetFolderPath ) {
|
|
HINSTANCE hInst = LoadLibrary( "Shell32" );
|
|
if( !hInst )
|
|
return S_FALSE;
|
|
pfnSHGetFolderPath = (PFN_SHGETFOLDERPATH) GetProcAddress( hInst, "SHGetFolderPathA" );
|
|
FreeLibrary( hInst ); // since we already have a copy of Shell32 loaded, free it
|
|
}
|
|
|
|
// if this function does not exist then we need to similate the return path of
|
|
// "%windir%\Profiles\All Users\Application Data"
|
|
if( pfnSHGetFolderPath ) {
|
|
// now call it
|
|
hResult = pfnSHGetFolderPath( NULL, CSIDL_FLAG_CREATE | CSIDL_COMMON_APPDATA, NULL, 0, pszPath);
|
|
if (pszPath[0] == NULL)
|
|
return S_FALSE;
|
|
}
|
|
else
|
|
return S_FALSE;
|
|
|
|
// append "Microsoft"
|
|
CatPath( pszPath, txtMicrosoft );
|
|
if( !IsDirectory(pszPath) )
|
|
if( !CreateDirectory( pszPath, NULL ) )
|
|
return S_FALSE;
|
|
|
|
// append "HTML Help"
|
|
CatPath( pszPath, txtHTMLHelp );
|
|
if( !IsDirectory(pszPath) )
|
|
if( !CreateDirectory( pszPath, NULL ) )
|
|
return S_FALSE;
|
|
|
|
return hResult;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Get the full path to where the common help data files lives
|
|
// hhcolreg.dat
|
|
//
|
|
// Note, if the subdirectories of the path does not exist
|
|
// we will create them
|
|
//
|
|
HRESULT HHGetCurUserDataPath( LPSTR pszPath )
|
|
{
|
|
HRESULT hResult = S_OK;
|
|
static PFN_SHGETFOLDERPATH pfnSHGetFolderPath = NULL;
|
|
|
|
// get the pointer to this function in shell32
|
|
if( !pfnSHGetFolderPath ) {
|
|
HINSTANCE hInst = LoadLibrary( "Shell32" );
|
|
if( !hInst )
|
|
return S_FALSE;
|
|
pfnSHGetFolderPath = (PFN_SHGETFOLDERPATH) GetProcAddress( hInst, "SHGetFolderPathA" );
|
|
FreeLibrary( hInst ); // since we already have a copy of Shell32 loaded, free it
|
|
}
|
|
|
|
// if this function does not exist then we need to similate the return path of
|
|
// "%windir%\Profiles\"username"\Application Data"
|
|
if( pfnSHGetFolderPath ) {
|
|
// now call it
|
|
hResult = pfnSHGetFolderPath( NULL, CSIDL_FLAG_CREATE | CSIDL_APPDATA , NULL, 0, pszPath);
|
|
if (pszPath[0] == NULL)
|
|
return S_FALSE;
|
|
}
|
|
else
|
|
return S_FALSE;
|
|
|
|
// append "Microsoft"
|
|
CatPath( pszPath, txtMicrosoft );
|
|
if( !IsDirectory(pszPath) )
|
|
if( !CreateDirectory( pszPath, NULL ) )
|
|
return S_FALSE;
|
|
|
|
// append "HTML Help"
|
|
CatPath( pszPath, txtHTMLHelp );
|
|
if( !IsDirectory(pszPath) )
|
|
if( !CreateDirectory( pszPath, NULL ) )
|
|
return S_FALSE;
|
|
|
|
return hResult;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// NT Keyboard hidden UI support functions.
|
|
//
|
|
LRESULT SendMessageAnsiOrWide(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (IsWindowUnicode(hwnd))
|
|
{
|
|
return SendMessageW(hwnd, msg, wParam, lParam);
|
|
}
|
|
else
|
|
{
|
|
return SendMessageA(hwnd, msg, wParam, lParam) ;
|
|
}
|
|
}
|
|
|
|
void UiStateInitialize(HWND hwnd)
|
|
{
|
|
if (g_bWinNT5 && IsWindow(hwnd))
|
|
{
|
|
SendMessageAnsiOrWide(hwnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_INITIALIZE, 0), 0) ;
|
|
}
|
|
}
|
|
|
|
void UiStateChangeOnTab(HWND hwnd)
|
|
{
|
|
if (g_bWinNT5 && IsWindow(hwnd))
|
|
{
|
|
SendMessageAnsiOrWide(hwnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEFOCUS), 0) ;
|
|
}
|
|
}
|
|
|
|
void UiStateChangeOnAlt(HWND hwnd)
|
|
{
|
|
if (g_bWinNT5 && IsWindow(hwnd))
|
|
{
|
|
// The only thing we can do is just turn on the underlines.
|
|
SendMessageAnsiOrWide(hwnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEACCEL | UISF_HIDEFOCUS), 0) ;
|
|
}
|
|
}
|
|
|