mirror of https://github.com/lianthony/NT4.0
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.
741 lines
16 KiB
741 lines
16 KiB
/****************************************************************************
|
|
*
|
|
* HCCOM.CPP
|
|
*
|
|
* Copyright (C) Microsoft Corporation 1993-1994
|
|
* All Rights reserved.
|
|
*
|
|
* Code common to HCW.EXE and HCRTF.EXE
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#ifndef HCCOM_H
|
|
#include "..\common\hccom.h"
|
|
#endif
|
|
|
|
#ifndef _MAX_FNAME
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
#ifndef _COMMON_H
|
|
#include "..\common\common.h"
|
|
#endif
|
|
|
|
#include "..\common\resource.h"
|
|
#include "..\common\cstr.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
////////////////// GLOBALS ///////////////////////////
|
|
|
|
HWND hwndParent = NULL; // HCW.EXE's window handle when this module is hcrtf
|
|
HGLOBAL hmemSz = NULL; // HCRTF's shared memory handle
|
|
HINSTANCE hinstApp = NULL;
|
|
|
|
char txtHCWClass[] = "hcw_class";
|
|
char txtTmpName[] = "~hc";
|
|
const char txtZeroLength[] = "";
|
|
const char txtSharedMem[] = "hcshare";
|
|
|
|
// Must be in same order as OPT enumeration in hccom.h
|
|
|
|
const PSTR ppszOptions[] = {
|
|
"BMROOT",
|
|
"BUILD",
|
|
"COMPRESS",
|
|
"ERRORLOG",
|
|
"FORCEFONT",
|
|
"ICON",
|
|
"CONTENTS",
|
|
"LANGUAGE",
|
|
"MAPFONTSIZE",
|
|
"MULTIKEY",
|
|
"REPORT",
|
|
"ROOT",
|
|
"TITLE",
|
|
"OLDKEYPHRASE",
|
|
"WARNING",
|
|
"COPYRIGHT",
|
|
"OPTCDROM",
|
|
"CITATION",
|
|
|
|
// New for version 4.0
|
|
|
|
"VERSION",
|
|
"NOTES",
|
|
"CNT",
|
|
"HLP",
|
|
"HCW",
|
|
"LCID",
|
|
"DBCS",
|
|
"TMPDIR",
|
|
"REPLACE",
|
|
"CHARSET",
|
|
"FTS",
|
|
"DEFFONT",
|
|
"PREFIX",
|
|
"REVISIONS",
|
|
|
|
// New for 4.01 (except OPT_INDEX)
|
|
|
|
"IGNORE",
|
|
|
|
"INDEX_SEPARATORS",
|
|
};
|
|
|
|
const MACRO_PAIR macropair[] = {
|
|
{ "AA(", "AddAccelerator(", },
|
|
{ "AI(", "AppendItem(", },
|
|
{ "AL(", "ALink(", },
|
|
{ "AN(", "Annotate(", },
|
|
{ "CB(", "CreateButton(", },
|
|
{ "CBB(", "ChangeButtonBinding(", },
|
|
{ "CE(", "ChangeEnable(", },
|
|
{ "CI(", "CheckItem(", },
|
|
{ "CIB(", "ChangeItemBinding(", },
|
|
{ "CS(", "CloseSecondarys(", },
|
|
{ "CT(", "CopyTopic(", },
|
|
{ "CW(", "CloseWindow(", },
|
|
{ "DB(", "DisableButton(", },
|
|
{ "DEB(", "DestroyButton(", },
|
|
{ "DI(", "DisableItem(", },
|
|
{ "EB(", "EnableButton(", },
|
|
{ "EF(", "ExecFile(", },
|
|
{ "EI(", "EnableItem(", },
|
|
{ "EP(", "ExecProgram(", },
|
|
{ "FD(", "Finder(", },
|
|
{ "FE(", "FileExist(", },
|
|
{ "FH(", "FlushMessageQueue(", },
|
|
{ "FO(", "FileOpen(", },
|
|
{ "IB(", "IsBook(", },
|
|
{ "IE(", "IfThenElse(", },
|
|
{ "IF(", "IfElse(", },
|
|
{ "JC(", "JumpContext(", },
|
|
{ "JI(", "JumpId(", },
|
|
{ "JK(", "JumpKeyword(", },
|
|
{ "JW(", "JumpWindow(", },
|
|
{ "KL(", "KLink(", },
|
|
{ "MU(", "Menu(", },
|
|
{ "NS(", "NoShow(", },
|
|
{ "PC(", "PopupContext(", },
|
|
{ "PI(", "PopupId(", },
|
|
{ "RA(", "RemoveAccelerator(", },
|
|
{ "RR(", "RegisterRoutine(", },
|
|
{ "SE(", "ShellExecute(", },
|
|
{ "SF(", "ShowFolder(", },
|
|
{ "SH(", "ShortCut(", },
|
|
{ "SPC(", "SetPopupColor(", },
|
|
{ "SW(", "ShowInWindow(", },
|
|
{ "TC(", "TCard(", },
|
|
{ "UI(", "UncheckItem(", },
|
|
|
|
{ NULL, NULL, },
|
|
};
|
|
|
|
const int MAX_OPT = ELEMENTS(ppszOptions);
|
|
|
|
////////////////// ROUTINES //////////////////////////
|
|
|
|
#include <dos.h>
|
|
|
|
void STDCALL AssertErrorReport(PCSTR pszExpression, UINT line,
|
|
PCSTR pszFile)
|
|
{
|
|
char szBuf[512], szErrorFile[30];
|
|
char szExpression[256];
|
|
HFILE hf;
|
|
OFSTRUCT of;
|
|
static BOOL fAsserted = FALSE;
|
|
|
|
if (fAsserted)
|
|
return; // we already asserted
|
|
else
|
|
fAsserted = TRUE;
|
|
|
|
/*
|
|
* Often the expression will have been obtained via GetStringResource,
|
|
* so we make a copy of it here to save the information.
|
|
*/
|
|
|
|
lstrcpyn(szExpression, pszExpression, sizeof(szExpression));
|
|
|
|
// REVIEW: ultimately, we should use the Mail API to do this.
|
|
|
|
char szName[_MAX_FNAME];
|
|
|
|
#ifdef INTERNAL
|
|
if (!GetVolumeInformation("c:\\", szName, sizeof(szName),
|
|
NULL, NULL, NULL, NULL, 0)) {
|
|
strcpy(szName, "hc");
|
|
}
|
|
else {
|
|
szName[8] = '\0';
|
|
CharLower(szName);
|
|
strcat(szName, ".err");
|
|
strcpy(szErrorFile, "\\\\pike\\bugs\\");
|
|
strcat(szErrorFile, szName);
|
|
}
|
|
|
|
of.cBytes = sizeof(OFSTRUCT);
|
|
hf = OpenFile(szErrorFile, &of, OF_CREATE | OF_WRITE);
|
|
if (hf == HFILE_ERROR) {
|
|
|
|
// couldn't find \\pike, so copy it to their C drive.
|
|
|
|
strcpy(szErrorFile, "c:\\");
|
|
strcat(szErrorFile, szName);
|
|
strcat(szErrorFile, ".err");
|
|
hf = OpenFile(szErrorFile, &of, OF_CREATE | OF_WRITE);
|
|
}
|
|
|
|
#else
|
|
|
|
if (!GetVolumeInformation("c:\\", szName, sizeof(szName),
|
|
NULL, NULL, NULL, NULL, 0)) {
|
|
strcpy(szErrorFile, "hc");
|
|
}
|
|
else {
|
|
strcpy(szErrorFile, "c:\\");
|
|
_strlwr(szName);
|
|
strcat(szErrorFile, szName);
|
|
szErrorFile[10] = '\0';
|
|
strcat(szErrorFile, ".err");
|
|
}
|
|
|
|
of.cBytes = sizeof(OFSTRUCT);
|
|
hf = OpenFile(szErrorFile, &of, OF_CREATE | OF_WRITE);
|
|
|
|
#endif
|
|
|
|
if (hf >= 0) {
|
|
strcpy(szBuf, GetStringResource(IDS_VERSION));
|
|
wsprintf(szBuf + strlen(szBuf),
|
|
GetStringResource(IDS_ASSERTION_FAILURE),
|
|
pszFile, line, szExpression);
|
|
_lwrite(hf, szBuf, strlen(szBuf));
|
|
|
|
wsprintf(szBuf, GetStringResource(IDS_ASSRT_COPY_MSG),
|
|
szErrorFile);
|
|
szMsgBox(szBuf);
|
|
_lclose(hf);
|
|
}
|
|
else {
|
|
MsgBox(IDS_INTERNAL_ERROR);
|
|
}
|
|
|
|
if (hwndParent) { // Usually non-null for the help compiler
|
|
throw 0;
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
int answer = MessageBox(NULL, szExpression, "Retry to call DebugBreak()",
|
|
MB_ABORTRETRYIGNORE);
|
|
|
|
if (answer == IDRETRY) {
|
|
DebugBreak();
|
|
return;
|
|
}
|
|
else if (answer == IDIGNORE)
|
|
return;
|
|
#endif
|
|
FatalAppExit(0, GetStringResource(IDS_ASSERTION_ERROR));
|
|
return;
|
|
}
|
|
|
|
static char szStringBuf[256];
|
|
|
|
PCSTR STDCALL GetStringResource(UINT idString)
|
|
{
|
|
if (LoadString(hinstApp, idString, szStringBuf,
|
|
sizeof(szStringBuf)) == 0) {
|
|
#ifdef _DEBUG
|
|
DebugBreak();
|
|
wsprintf(szStringBuf, "Cannot find string resource id %d.",
|
|
idString);
|
|
MessageBox(NULL, szStringBuf, "", MB_OK);
|
|
#endif
|
|
szStringBuf[0] = '\0';
|
|
}
|
|
return (const PSTR) szStringBuf;
|
|
}
|
|
|
|
void STDCALL GetStringResource(UINT idString, PSTR pszDst)
|
|
{
|
|
if (LoadString(hinstApp, idString, pszDst, 256) == 0) {
|
|
#ifdef _DEBUG
|
|
DebugBreak();
|
|
wsprintf(pszDst, "Cannot find string resource id %d.", idString);
|
|
MessageBox(NULL, pszDst, "", MB_OK);
|
|
#endif
|
|
*pszDst = '\0';
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: ChangeExtension
|
|
|
|
PURPOSE: This version of change extension assumes the extension
|
|
is contained in a resource id
|
|
|
|
PARAMETERS:
|
|
pszDest
|
|
idResource
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
|
|
MODIFICATION DATES:
|
|
16-Oct-1993 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
void STDCALL ChangeExtension(PSTR pszDest, UINT idResource)
|
|
{
|
|
PSTR psz;
|
|
static BOOL fDBCSSystem = IsDbcsSystem();
|
|
|
|
PSTR pszExt = (PSTR) GetStringResource(idResource);
|
|
|
|
// If NULL specified, simply remove any existing extension
|
|
|
|
if (pszExt == NULL || !*pszExt) {
|
|
if ((psz = StrRChr(pszDest, '.', fDBCSSystem)) != NULL)
|
|
*psz = '\0';
|
|
return;
|
|
}
|
|
|
|
if ((psz = StrRChr(pszDest, '.', fDBCSSystem)) == NULL)
|
|
psz = pszDest + strlen(pszDest); // filename didn't have an extension
|
|
if (*pszExt != '.')
|
|
*psz++ = '.';
|
|
strcpy(psz, pszExt);
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: DeleteTmpFiles
|
|
|
|
PURPOSE: Delete all temporary files created by hcrtf
|
|
|
|
PARAMETERS:
|
|
void
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
This will also delete old temporary files from a crashed
|
|
hcrtf. By calling it from both HCW and HCRTF we can be assured that
|
|
we have cleaned up after ourselves.
|
|
|
|
MODIFICATION DATES:
|
|
26-Aug-1993 [ralphw]
|
|
01-Jun-1994 [ralphw] Temporary files are now in TMP
|
|
|
|
***************************************************************************/
|
|
|
|
#include <dos.h>
|
|
|
|
void STDCALL DeleteTmpFiles(void)
|
|
{
|
|
char szTmpName[_MAX_PATH];
|
|
|
|
strcpy(szTmpName, GetTmpDirectory());
|
|
CStr cszPath(szTmpName);
|
|
strcat(szTmpName, txtTmpName);
|
|
strcat(szTmpName, "*.tmp");
|
|
|
|
WIN32_FIND_DATA fileinfo;
|
|
HANDLE hfind = FindFirstFile(szTmpName, &fileinfo);
|
|
|
|
if (hfind != INVALID_HANDLE_VALUE) {
|
|
do {
|
|
strcpy(szTmpName, cszPath);
|
|
strcat(szTmpName, fileinfo.cFileName);
|
|
remove(szTmpName);
|
|
} while (FindNextFile(hfind, &fileinfo));
|
|
FindClose(hfind);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Yes/No/Neither - recognizes various binary options
|
|
*
|
|
* We don't put this into the resource, because the text is supported for
|
|
* backwards compatibility only. HCW-maintained projects use 0 and 1 for
|
|
* FALSE and TRUE respectively.
|
|
*/
|
|
|
|
static const PSTR ppszYesNo[] = {
|
|
"no", "yes",
|
|
"false", "true",
|
|
"off", "on",
|
|
"0", "1",
|
|
};
|
|
|
|
static const int MAX_YESNO = ELEMENTS(ppszYesNo);
|
|
|
|
int STDCALL YesNo(PCSTR psz)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_YESNO; i++) {
|
|
if (!_stricmp(psz, ppszYesNo[i]))
|
|
return i % 2 ? IDYES : IDNO;
|
|
}
|
|
return IDCANCEL;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: GetArg
|
|
|
|
PURPOSE:
|
|
|
|
PARAMETERS:
|
|
pszDest
|
|
pszSrc
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
|
|
MODIFICATION DATES:
|
|
16-Aug-1993 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
PSTR STDCALL GetArg(PSTR pszDest, PCSTR pszSrc)
|
|
{
|
|
static BOOL fDBCSSystem = IsDbcsSystem();
|
|
|
|
if (!pszSrc) {
|
|
*pszDest = '\0';
|
|
return NULL;
|
|
}
|
|
if (*pszSrc == CH_QUOTE) {
|
|
pszSrc++;
|
|
while (*pszSrc && *pszSrc != CH_QUOTE)
|
|
*pszDest++ = *pszSrc++;
|
|
}
|
|
else if (*pszSrc == CH_START_QUOTE) {
|
|
pszSrc++;
|
|
while (*pszSrc && *pszSrc != CH_END_QUOTE)
|
|
*pszDest++ = *pszSrc++;
|
|
}
|
|
else {
|
|
while (*pszSrc && !isspace(*pszSrc))
|
|
*pszDest++ = *pszSrc++;
|
|
}
|
|
*pszDest = '\0';
|
|
return FirstNonSpace(pszSrc, fDBCSSystem);
|
|
}
|
|
|
|
void STDCALL AddTrailingBackslash(PSTR npszStr)
|
|
{
|
|
int sPos;
|
|
|
|
if (npszStr != NULL && *npszStr != '\0') {
|
|
|
|
sPos = strlen(npszStr) - 1;
|
|
|
|
if (npszStr[sPos] != '\\') {
|
|
npszStr[sPos + 1] = '\\';
|
|
npszStr[sPos + 2] = '\0';
|
|
}
|
|
}
|
|
}
|
|
|
|
#include <direct.h>
|
|
|
|
void STDCALL ChangeDirectory(PCSTR pszFile)
|
|
{
|
|
char szPath[_MAX_PATH];
|
|
strcpy(szPath, pszFile);
|
|
PSTR psz = StrRChr(szPath, CH_BACKSLASH, IsDbcsSystem());
|
|
if (!psz)
|
|
return;
|
|
else
|
|
*psz = '\0';
|
|
|
|
if (_chdir(szPath) != 0)
|
|
return;
|
|
|
|
if (szPath[1] == ':')
|
|
_chdrive(tolower(szPath[0]) - ('a' - 1));
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: FGetNum
|
|
|
|
PURPOSE: Get a signed or unsigned 32-bit number
|
|
|
|
PARAMETERS:
|
|
pszIn Points to the number
|
|
ppszOut On return, Points to the first non-space after the number
|
|
pv Where to put the value
|
|
fSigned TRUE if you want a signed number
|
|
|
|
RETURNS: TRUE if the first character is a number
|
|
|
|
COMMENTS:
|
|
|
|
MODIFICATION DATES:
|
|
26-Jun-1994 [ralphw]
|
|
ppszOut can be NULL
|
|
*pv is set to zero on failure
|
|
|
|
***************************************************************************/
|
|
|
|
BOOL STDCALL FGetNum(PCSTR pszIn, PSTR *ppszOut, void* pv, BOOL fSigned)
|
|
{
|
|
PSTR pszTmp;
|
|
PSTR* ppszEnd = ppszOut ? ppszOut : &pszTmp;
|
|
static BOOL fDBCSSystem = IsDbcsSystem();
|
|
|
|
if (!(isdigit(*pszIn) || (*pszIn == '-' && fSigned))) {
|
|
*(int *)pv = 0;
|
|
return FALSE;
|
|
}
|
|
|
|
if (fSigned) {
|
|
int l = strtol(pszIn, ppszEnd, 0);
|
|
*(int *)pv = l;
|
|
}
|
|
else {
|
|
DWORD ul = strtoul(pszIn, ppszEnd, 0);
|
|
*(DWORD *) pv = (UINT) ul;
|
|
}
|
|
|
|
if (ppszOut) {
|
|
// In case caller specifed a long value
|
|
|
|
if ((**ppszEnd == 'l' || **ppszEnd == 'L'))
|
|
++*ppszEnd;
|
|
|
|
*ppszEnd = FirstNonSpace(*ppszOut, fDBCSSystem);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: ReplaceStrings
|
|
|
|
PURPOSE: Replace one string with another in a string
|
|
|
|
PARAMETERS:
|
|
pszCur -- pointer to the buffer
|
|
pszOrg -- original string to be replaced
|
|
pszNew -- string to replace with
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
This will move the buffer to make room for the new string
|
|
|
|
MODIFICATION DATES:
|
|
08-Mar-1995 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
void STDCALL ReplaceStrings(PSTR pszCur, PCSTR pszOrg, PCSTR pszNew)
|
|
{
|
|
ASSERT(nstrisubcmp(pszCur, pszOrg));
|
|
int cbNew = strlen(pszNew);
|
|
int cbOrg = strlen(pszOrg);
|
|
|
|
if (cbNew < cbOrg) {
|
|
strcpy(pszCur, pszNew);
|
|
strcpy(pszCur + cbNew, pszCur + cbOrg);
|
|
}
|
|
else {
|
|
MoveMemory(pszCur + strlen(pszNew) - strlen(pszOrg), pszCur,
|
|
strlen(pszCur) + 1);
|
|
while (*pszNew)
|
|
*pszCur++ = *pszNew++;
|
|
}
|
|
}
|
|
|
|
const char txtAddAcclerator[] = "AddAccelerator(";
|
|
|
|
const MACRO_PAIR vkpair[] = {
|
|
{ "0x08", "VK_BACK", },
|
|
{ "0x09", "VK_TAB", },
|
|
{ "0x0D", "VK_RETURN", },
|
|
{ "0x1B", "VK_ESCAPE", },
|
|
{ "0x20", "VK_SPACE", },
|
|
{ "0x21", "VK_PRIOR", },
|
|
{ "0x22", "VK_NEXT", },
|
|
{ "0x23", "VK_END", },
|
|
{ "0x24", "VK_HOME", },
|
|
{ "0x25", "VK_LEFT", },
|
|
{ "0x26", "VK_UP", },
|
|
{ "0x27", "VK_RIGHT", },
|
|
{ "0x28", "VK_DOWN", },
|
|
{ "0x2D", "VK_INSERT", },
|
|
{ "0x2E", "VK_DELETE", },
|
|
{ "0x2F", "VK_HELP", },
|
|
|
|
{ "0x30", "\'0\'", },
|
|
{ "0x31", "\'1\'", },
|
|
{ "0x32", "\'2\'", },
|
|
{ "0x33", "\'3\'", },
|
|
{ "0x34", "\'4\'", },
|
|
{ "0x35", "\'5\'", },
|
|
{ "0x36", "\'6\'", },
|
|
{ "0x37", "\'7\'", },
|
|
{ "0x38", "\'8\'", },
|
|
{ "0x39", "\'9\'", },
|
|
|
|
{ "0x41", "\'A\'", },
|
|
{ "0x42", "\'B\'", },
|
|
{ "0x43", "\'C\'", },
|
|
{ "0x44", "\'D\'", },
|
|
{ "0x45", "\'E\'", },
|
|
{ "0x46", "\'F\'", },
|
|
{ "0x47", "\'G\'", },
|
|
{ "0x48", "\'H\'", },
|
|
{ "0x49", "\'I\'", },
|
|
{ "0x4A", "\'J\'", },
|
|
{ "0x4B", "\'K\'", },
|
|
{ "0x4C", "\'L\'", },
|
|
{ "0x4D", "\'M\'", },
|
|
{ "0x4E", "\'N\'", },
|
|
{ "0x4F", "\'O\'", },
|
|
{ "0x50", "\'P\'", },
|
|
{ "0x51", "\'Q\'", },
|
|
{ "0x52", "\'R\'", },
|
|
{ "0x53", "\'S\'", },
|
|
{ "0x54", "\'T\'", },
|
|
{ "0x55", "\'U\'", },
|
|
{ "0x56", "\'V\'", },
|
|
{ "0x57", "\'W\'", },
|
|
{ "0x58", "\'X\'", },
|
|
{ "0x59", "\'Y\'", },
|
|
{ "0x5A", "\'Z\'", },
|
|
|
|
{ "0x60", "VK_NUMPAD0", },
|
|
{ "0x61", "VK_NUMPAD1", },
|
|
{ "0x62", "VK_NUMPAD2", },
|
|
{ "0x63", "VK_NUMPAD3", },
|
|
{ "0x64", "VK_NUMPAD4", },
|
|
{ "0x65", "VK_NUMPAD5", },
|
|
{ "0x66", "VK_NUMPAD6", },
|
|
{ "0x67", "VK_NUMPAD7", },
|
|
{ "0x68", "VK_NUMPAD8", },
|
|
{ "0x69", "VK_NUMPAD9", },
|
|
{ "0x6A", "VK_MULTIPLY", },
|
|
{ "0x6B", "VK_ADD", },
|
|
{ "0x6C", "VK_SEPARATOR", },
|
|
{ "0x6D", "VK_SUBTRACT", },
|
|
{ "0x6E", "VK_DECIMAL", },
|
|
{ "0x6F", "VK_DIVIDE", },
|
|
|
|
{ "0x70", "VK_F1", },
|
|
{ "0x71", "VK_F2", },
|
|
{ "0x72", "VK_F3", },
|
|
{ "0x73", "VK_F4", },
|
|
{ "0x74", "VK_F5", },
|
|
{ "0x75", "VK_F6", },
|
|
{ "0x76", "VK_F7", },
|
|
{ "0x77", "VK_F8", },
|
|
{ "0x78", "VK_F9", },
|
|
{ "0x79", "VK_F10", },
|
|
{ "0x7A", "VK_F11", },
|
|
{ "0x7B", "VK_F12", },
|
|
{ "0x7C", "VK_F13", },
|
|
{ "0x7D", "VK_F14", },
|
|
{ "0x7E", "VK_F15", },
|
|
{ "0x7F", "VK_F16", },
|
|
{ "0x80", "VK_F17", },
|
|
{ "0x81", "VK_F18", },
|
|
{ "0x82", "VK_F19", },
|
|
{ "0x83", "VK_F20", },
|
|
{ "0x84", "VK_F21", },
|
|
{ "0x85", "VK_F22", },
|
|
{ "0x86", "VK_F23", },
|
|
{ "0x87", "VK_F24", },
|
|
|
|
{ NULL, NULL, },
|
|
};
|
|
|
|
const MACRO_PAIR vkshift[] = {
|
|
{ "7", "ALT+CTRL+SHIFT", },
|
|
{ "6", "ALT+CTRL", },
|
|
{ "5", "ALT+SHIFT", },
|
|
{ "4", "ALT", },
|
|
{ "3", "CTRL+SHIFT", },
|
|
{ "2", "CTRL", },
|
|
{ "1", "SHIFT", },
|
|
{ "0", "NONE", },
|
|
|
|
{ NULL, NULL, },
|
|
};
|
|
|
|
void STDCALL TweakAddAccelerator(PSTR psz)
|
|
{
|
|
if (nstrisubcmp(psz, txtAddAcclerator)) {
|
|
psz = FirstNonSpace(psz + strlen(txtAddAcclerator));
|
|
int i;
|
|
for (i = 0; vkpair[i].pszShort; i++) {
|
|
if (nstrisubcmp(psz, vkpair[i].pszShort)) {
|
|
ReplaceStrings(psz, vkpair[i].pszShort, vkpair[i].pszExpanded);
|
|
break;
|
|
}
|
|
}
|
|
|
|
psz = strchr(psz, ',');
|
|
if (psz)
|
|
psz = FirstNonSpace(psz + 1);
|
|
|
|
for (i = 0; vkshift[i].pszShort; i++) {
|
|
if (nstrisubcmp(psz, vkshift[i].pszShort)) {
|
|
ReplaceStrings(psz, vkshift[i].pszShort, vkshift[i].pszExpanded);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
- Name: FValidContextSz
|
|
-
|
|
* Purpose:
|
|
* This function determines whether the given string may be
|
|
* used as a context string.
|
|
*
|
|
* Arguments:
|
|
* SZ: String to validate.
|
|
*
|
|
* Returns:
|
|
* TRUE if the string is a valid context string, FALSE otherwise.
|
|
*
|
|
***************************************************************************/
|
|
|
|
BOOL STDCALL IsValidContextSz(PCSTR pszContext)
|
|
{
|
|
/*
|
|
* To avoid confusion with macro strings, context strings may not begin
|
|
* with an exclamation point.
|
|
*/
|
|
|
|
if (*pszContext == CH_MACRO || *pszContext == '\0')
|
|
return FALSE;
|
|
|
|
// Version 4.x help files have almost no limitations on context strings
|
|
|
|
if (strpbrk(pszContext, "#=>@%;"))
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|