wine/programs/winhelp/macro.c
2006-01-18 14:23:11 +01:00

964 lines
28 KiB
C

/*
* Help Viewer
*
* Copyright 1996 Ulrich Schmid
* Copyright 2002 Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include "windows.h"
#include "commdlg.h"
#include "winhelp.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(winhelp);
/**************************************************/
/* Macro table */
/**************************************************/
struct MacroDesc {
const char* name;
const char* alias;
BOOL isBool;
const char* arguments;
FARPROC fn;
};
/* types:
* U: 32 bit unsigned int
* I: 32 bit signed int
* S: string
* v: unknown (32 bit entity)
*/
static struct MacroDesc MACRO_Builtins[] = {
{"About", NULL, 0, "", (FARPROC)MACRO_About},
{"AddAccelerator", "AA", 0, "UUS", (FARPROC)MACRO_AddAccelerator},
{"ALink", "AL", 0, "SUS", (FARPROC)MACRO_ALink},
{"Annotate", NULL, 0, "", (FARPROC)MACRO_Annotate},
{"AppendItem", NULL, 0, "SSSS", (FARPROC)MACRO_AppendItem},
{"Back", NULL, 0, "", (FARPROC)MACRO_Back},
{"BackFlush", "BF", 0, "", (FARPROC)MACRO_BackFlush},
{"BookmarkDefine", NULL, 0, "", (FARPROC)MACRO_BookmarkDefine},
{"BookmarkMore", NULL, 0, "", (FARPROC)MACRO_BookmarkMore},
{"BrowseButtons", NULL, 0, "", (FARPROC)MACRO_BrowseButtons},
{"ChangeButtonBinding", "CBB",0, "SS", (FARPROC)MACRO_ChangeButtonBinding},
{"ChangeEnable", "CE", 0, "SS", (FARPROC)MACRO_ChangeEnable},
{"ChangeItemBinding", "CIB",0, "SS", (FARPROC)MACRO_ChangeItemBinding},
{"CheckItem", "CI", 0, "S", (FARPROC)MACRO_CheckItem},
{"CloseSecondarys", "CS", 0, "", (FARPROC)MACRO_CloseSecondarys},
{"CloseWindow", "CW", 0, "S", (FARPROC)MACRO_CloseWindow},
{"Compare", NULL, 0, "S", (FARPROC)MACRO_Compare},
{"Contents", NULL, 0, "", (FARPROC)MACRO_Contents},
{"ControlPanel", NULL, 0, "SSU", (FARPROC)MACRO_ControlPanel},
{"CopyDialog", NULL, 0, "", (FARPROC)MACRO_CopyDialog},
{"CopyTopic", "CT", 0, "", (FARPROC)MACRO_CopyTopic},
{"CreateButton", "CB", 0, "SSS", (FARPROC)MACRO_CreateButton},
{"DeleteItem", NULL, 0, "S", (FARPROC)MACRO_DeleteItem},
{"DeleteMark", NULL, 0, "S", (FARPROC)MACRO_DeleteMark},
{"DestroyButton", NULL, 0, "S", (FARPROC)MACRO_DestroyButton},
{"DisableButton", "DB", 0, "S", (FARPROC)MACRO_DisableButton},
{"DisableItem", "DI", 0, "S", (FARPROC)MACRO_DisableItem},
{"EnableButton", "EB", 0, "S", (FARPROC)MACRO_EnableButton},
{"EnableItem", "EI", 0, "S", (FARPROC)MACRO_EnableItem},
{"EndMPrint", NULL, 0, "", (FARPROC)MACRO_EndMPrint},
{"ExecFile", "EF", 0, "SSUS", (FARPROC)MACRO_ExecFile},
{"ExecProgram", "EP", 0, "SU", (FARPROC)MACRO_ExecProgram},
{"Exit", NULL, 0, "", (FARPROC)MACRO_Exit},
{"ExtAbleItem", NULL, 0, "SU", (FARPROC)MACRO_ExtAbleItem},
{"ExtInsertItem", NULL, 0, "SSSSUU", (FARPROC)MACRO_ExtInsertItem},
{"ExtInsertMenu", NULL, 0, "SSSUU", (FARPROC)MACRO_ExtInsertMenu},
{"FileExist", "FE", 1, "S", (FARPROC)MACRO_FileExist},
{"FileOpen", "FO", 0, "", (FARPROC)MACRO_FileOpen},
{"Find", NULL, 0, "", (FARPROC)MACRO_Find},
{"Finder", "FD", 0, "", (FARPROC)MACRO_Finder},
{"FloatingMenu", NULL, 0, "", (FARPROC)MACRO_FloatingMenu},
{"Flush", "FH", 0, "", (FARPROC)MACRO_Flush},
{"FocusWindow", NULL, 0, "S", (FARPROC)MACRO_FocusWindow},
{"Generate", NULL, 0, "SUU", (FARPROC)MACRO_Generate},
{"GotoMark", NULL, 0, "S", (FARPROC)MACRO_GotoMark},
{"HelpOn", NULL, 0, "", (FARPROC)MACRO_HelpOn},
{"HelpOnTop", NULL, 0, "", (FARPROC)MACRO_HelpOnTop},
{"History", NULL, 0, "", (FARPROC)MACRO_History},
{"InitMPrint", NULL, 1, "", (FARPROC)MACRO_InitMPrint},
{"InsertItem", NULL, 0, "SSSSU", (FARPROC)MACRO_InsertItem},
{"InsertMenu", NULL, 0, "SSU", (FARPROC)MACRO_InsertMenu},
{"IfThen", "IF", 0, "BS", (FARPROC)MACRO_IfThen},
{"IfThenElse", "IE", 0, "BSS", (FARPROC)MACRO_IfThenElse},
{"IsBook", NULL, 1, "", (FARPROC)MACRO_IsBook},
{"IsMark", NULL, 1, "S", (FARPROC)MACRO_IsMark},
{"IsNotMark", "NM", 1, "S", (FARPROC)MACRO_IsNotMark},
{"JumpContents", NULL, 0, "SS", (FARPROC)MACRO_JumpContents},
{"JumpContext", "JC", 0, "SSU", (FARPROC)MACRO_JumpContext},
{"JumpHash", "JH", 0, "SSU", (FARPROC)MACRO_JumpHash},
{"JumpHelpOn", NULL, 0, "", (FARPROC)MACRO_JumpHelpOn},
{"JumpID", "JI", 0, "SSS", (FARPROC)MACRO_JumpID},
{"JumpKeyword", "JK", 0, "SSS", (FARPROC)MACRO_JumpKeyword},
{"KLink", "KL", 0, "SUSS", (FARPROC)MACRO_KLink},
{"Menu", "MU", 0, "", (FARPROC)MACRO_Menu},
{"MPrintHash", NULL, 0, "U", (FARPROC)MACRO_MPrintHash},
{"MPrintID", NULL, 0, "S", (FARPROC)MACRO_MPrintID},
{"Next", NULL, 0, "", (FARPROC)MACRO_Next},
{"NoShow", NULL, 0, "", (FARPROC)MACRO_NoShow},
{"PopupContext", "PC", 0, "SU", (FARPROC)MACRO_PopupContext},
{"PopupHash", NULL, 0, "SU", (FARPROC)MACRO_PopupHash},
{"PopupId", "PI", 0, "SS", (FARPROC)MACRO_PopupId},
{"PositionWindow", "PW", 0, "IIUUUS", (FARPROC)MACRO_PositionWindow},
{"Prev", NULL, 0, "", (FARPROC)MACRO_Prev},
{"Print", NULL, 0, "", (FARPROC)MACRO_Print},
{"PrinterSetup", NULL, 0, "", (FARPROC)MACRO_PrinterSetup},
{"RegisterRoutine", "RR", 0, "SSS", (FARPROC)MACRO_RegisterRoutine},
{"RemoveAccelerator", "RA", 0, "UU", (FARPROC)MACRO_RemoveAccelerator},
{"ResetMenu", NULL, 0, "", (FARPROC)MACRO_ResetMenu},
{"SaveMark", NULL, 0, "S", (FARPROC)MACRO_SaveMark},
{"Search", NULL, 0, "", (FARPROC)MACRO_Search},
{"SetContents", NULL, 0, "SU", (FARPROC)MACRO_SetContents},
{"SetHelpOnFile", NULL, 0, "S", (FARPROC)MACRO_SetHelpOnFile},
{"SetPopupColor", "SPC",0, "UUU", (FARPROC)MACRO_SetPopupColor},
{"ShellExecute", "SE", 0, "SSUUSS", (FARPROC)MACRO_ShellExecute},
{"ShortCut", "SH", 0, "SSUUS", (FARPROC)MACRO_ShortCut},
{"TCard", NULL, 0, "U", (FARPROC)MACRO_TCard},
{"Test", NULL, 0, "U", (FARPROC)MACRO_Test},
{"TestALink", NULL, 1, "S", (FARPROC)MACRO_TestALink},
{"TestKLink", NULL, 1, "S", (FARPROC)MACRO_TestKLink},
{"UncheckItem", "UI", 0, "S", (FARPROC)MACRO_UncheckItem},
{"UpdateWindow", "UW", 0, "SS", (FARPROC)MACRO_UpdateWindow},
{NULL, NULL, 0, NULL, NULL}
};
static struct MacroDesc*MACRO_Loaded /* = NULL */;
static unsigned MACRO_NumLoaded /* = 0 */;
static int MACRO_DoLookUp(struct MacroDesc* start, const char* name, struct lexret* lr, unsigned len)
{
struct MacroDesc* md;
for (md = start; md->name && len != 0; md++, len--)
{
if (strcasecmp(md->name, name) == 0 || (md->alias != NULL && strcasecmp(md->alias, name) == 0))
{
lr->proto = md->arguments;
lr->function = md->fn;
return md->isBool ? BOOL_FUNCTION : VOID_FUNCTION;
}
}
return EMPTY;
}
int MACRO_Lookup(const char* name, struct lexret* lr)
{
int ret;
if ((ret = MACRO_DoLookUp(MACRO_Builtins, name, lr, -1)) != EMPTY)
return ret;
if (MACRO_Loaded && (ret = MACRO_DoLookUp(MACRO_Loaded, name, lr, MACRO_NumLoaded)) != EMPTY)
return ret;
lr->string = name;
return IDENTIFIER;
}
/******* helper functions *******/
static WINHELP_BUTTON** MACRO_LookupButton(WINHELP_WINDOW* win, LPCSTR name)
{
WINHELP_BUTTON** b;
for (b = &win->first_button; *b; b = &(*b)->next)
if (!lstrcmpi(name, (*b)->lpszID)) break;
return b;
}
/******* real macro implementation *******/
void CALLBACK MACRO_About(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_AddAccelerator(LONG u1, LONG u2, LPCSTR str)
{
WINE_FIXME("(%lu, %lu, \"%s\")\n", u1, u2, str);
}
void CALLBACK MACRO_ALink(LPCSTR str1, LONG u, LPCSTR str2)
{
WINE_FIXME("(\"%s\", %lu, \"%s\")\n", str1, u, str2);
}
void CALLBACK MACRO_Annotate(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_AppendItem(LPCSTR str1, LPCSTR str2, LPCSTR str3, LPCSTR str4)
{
WINE_FIXME("(\"%s\", \"%s\", \"%s\", \"%s\")\n", str1, str2, str3, str4);
}
void CALLBACK MACRO_Back(void)
{
WINHELP_WINDOW* win = Globals.active_win;
WINE_TRACE("()\n");
if (win && win->backIndex >= 2)
WINHELP_CreateHelpWindow(win->back[--win->backIndex - 1],
win->info, SW_SHOW);
}
void CALLBACK MACRO_BackFlush(void)
{
WINHELP_WINDOW* win = Globals.active_win;
WINE_TRACE("()\n");
if (win)
{
int i;
for (i = 0; i < win->backIndex; i++)
{
HLPFILE_FreeHlpFile(win->back[i]->file);
win->back[i] = NULL;
}
win->backIndex = 0;
}
}
void CALLBACK MACRO_BookmarkDefine(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_BookmarkMore(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_BrowseButtons(void)
{
WINE_TRACE("()\n");
MACRO_CreateButton("BTN_PREV", "&<<", "Prev()");
MACRO_CreateButton("BTN_NEXT", "&>>", "Next()");
}
void CALLBACK MACRO_ChangeButtonBinding(LPCSTR id, LPCSTR macro)
{
WINHELP_WINDOW* win = Globals.active_win;
WINHELP_BUTTON* button;
WINHELP_BUTTON** b;
LONG size;
LPSTR ptr;
WINE_TRACE("(\"%s\", \"%s\")\n", id, macro);
b = MACRO_LookupButton(win, id);
if (!*b) {WINE_FIXME("Couldn't find button '%s'\n", id); return;}
size = sizeof(WINHELP_BUTTON) + lstrlen(id) +
lstrlen((*b)->lpszName) + lstrlen(macro) + 3;
button = HeapAlloc(GetProcessHeap(), 0, size);
if (!button) return;
button->next = (*b)->next;
button->hWnd = (*b)->hWnd;
button->wParam = (*b)->wParam;
ptr = (char*)button + sizeof(WINHELP_BUTTON);
lstrcpy(ptr, id);
button->lpszID = ptr;
ptr += lstrlen(id) + 1;
lstrcpy(ptr, (*b)->lpszName);
button->lpszName = ptr;
ptr += lstrlen((*b)->lpszName) + 1;
lstrcpy(ptr, macro);
button->lpszMacro = ptr;
*b = button;
SendMessage(win->hMainWnd, WM_USER, 0, 0);
}
void CALLBACK MACRO_ChangeEnable(LPCSTR id, LPCSTR macro)
{
WINE_TRACE("(\"%s\", \"%s\")\n", id, macro);
MACRO_ChangeButtonBinding(id, macro);
MACRO_EnableButton(id);
}
void CALLBACK MACRO_ChangeItemBinding(LPCSTR str1, LPCSTR str2)
{
WINE_FIXME("(\"%s\", \"%s\")\n", str1, str2);
}
void CALLBACK MACRO_CheckItem(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_CloseSecondarys(void)
{
WINHELP_WINDOW *win;
WINE_TRACE("()\n");
for (win = Globals.win_list; win; win = win->next)
if (win->lpszName && lstrcmpi(win->lpszName, "main"))
DestroyWindow(win->hMainWnd);
}
void CALLBACK MACRO_CloseWindow(LPCSTR lpszWindow)
{
WINHELP_WINDOW *win;
WINE_TRACE("(\"%s\")\n", lpszWindow);
if (!lpszWindow || !lpszWindow[0]) lpszWindow = "main";
for (win = Globals.win_list; win; win = win->next)
if (win->lpszName && !lstrcmpi(win->lpszName, lpszWindow))
DestroyWindow(win->hMainWnd);
}
void CALLBACK MACRO_Compare(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_Contents(void)
{
WINE_TRACE("()\n");
if (Globals.active_win->page)
MACRO_JumpContents(Globals.active_win->page->file->lpszPath, NULL);
}
void CALLBACK MACRO_ControlPanel(LPCSTR str1, LPCSTR str2, LONG u)
{
WINE_FIXME("(\"%s\", \"%s\", %lu)\n", str1, str2, u);
}
void CALLBACK MACRO_CopyDialog(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_CopyTopic(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_CreateButton(LPCSTR id, LPCSTR name, LPCSTR macro)
{
WINHELP_WINDOW *win = Globals.active_win;
WINHELP_BUTTON *button, **b;
LONG size;
LPSTR ptr;
WINE_TRACE("(\"%s\", \"%s\", %s)\n", id, name, macro);
size = sizeof(WINHELP_BUTTON) + lstrlen(id) + lstrlen(name) + lstrlen(macro) + 3;
button = HeapAlloc(GetProcessHeap(), 0, size);
if (!button) return;
button->next = 0;
button->hWnd = 0;
ptr = (char*)button + sizeof(WINHELP_BUTTON);
lstrcpy(ptr, id);
button->lpszID = ptr;
ptr += lstrlen(id) + 1;
lstrcpy(ptr, name);
button->lpszName = ptr;
ptr += lstrlen(name) + 1;
lstrcpy(ptr, macro);
button->lpszMacro = ptr;
button->wParam = WH_FIRST_BUTTON;
for (b = &win->first_button; *b; b = &(*b)->next)
button->wParam = max(button->wParam, (*b)->wParam + 1);
*b = button;
SendMessage(win->hMainWnd, WM_USER, 0, 0);
}
void CALLBACK MACRO_DeleteItem(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_DeleteMark(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_DestroyButton(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_DisableButton(LPCSTR id)
{
WINHELP_BUTTON** b;
WINE_FIXME("(\"%s\")\n", id);
b = MACRO_LookupButton(Globals.active_win, id);
if (!*b) {WINE_FIXME("Couldn't find button '%s'\n", id); return;}
EnableWindow((*b)->hWnd, FALSE);
}
void CALLBACK MACRO_DisableItem(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_EnableButton(LPCSTR id)
{
WINHELP_BUTTON** b;
WINE_TRACE("(\"%s\")\n", id);
b = MACRO_LookupButton(Globals.active_win, id);
if (!*b) {WINE_FIXME("Couldn't find button '%s'\n", id); return;}
EnableWindow((*b)->hWnd, TRUE);
}
void CALLBACK MACRO_EnableItem(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_EndMPrint(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_ExecFile(LPCSTR str1, LPCSTR str2, LONG u, LPCSTR str3)
{
WINE_FIXME("(\"%s\", \"%s\", %lu, \"%s\")\n", str1, str2, u, str3);
}
void CALLBACK MACRO_ExecProgram(LPCSTR str, LONG u)
{
WINE_FIXME("(\"%s\", %lu)\n", str, u);
}
void CALLBACK MACRO_Exit(void)
{
WINE_TRACE("()\n");
while (Globals.win_list)
DestroyWindow(Globals.win_list->hMainWnd);
}
void CALLBACK MACRO_ExtAbleItem(LPCSTR str, LONG u)
{
WINE_FIXME("(\"%s\", %lu)\n", str, u);
}
void CALLBACK MACRO_ExtInsertItem(LPCSTR str1, LPCSTR str2, LPCSTR str3, LPCSTR str4, LONG u1, LONG u2)
{
WINE_FIXME("(\"%s\", \"%s\", \"%s\", \"%s\", %lu, %lu)\n", str1, str2, str3, str4, u1, u2);
}
void CALLBACK MACRO_ExtInsertMenu(LPCSTR str1, LPCSTR str2, LPCSTR str3, LONG u1, LONG u2)
{
WINE_FIXME("(\"%s\", \"%s\", \"%s\", %lu, %lu)\n", str1, str2, str3, u1, u2);
}
BOOL CALLBACK MACRO_FileExist(LPCSTR str)
{
WINE_TRACE("(\"%s\")\n", str);
return GetFileAttributes(str) != INVALID_FILE_ATTRIBUTES;
}
void CALLBACK MACRO_FileOpen(void)
{
OPENFILENAME openfilename;
CHAR szPath[MAX_PATHNAME_LEN];
CHAR szDir[MAX_PATHNAME_LEN];
CHAR szzFilter[2 * MAX_STRING_LEN + 100];
LPSTR p = szzFilter;
WINE_TRACE("()\n");
LoadString(Globals.hInstance, STID_HELP_FILES_HLP, p, MAX_STRING_LEN);
p += strlen(p) + 1;
lstrcpy(p, "*.hlp");
p += strlen(p) + 1;
LoadString(Globals.hInstance, STID_ALL_FILES, p, MAX_STRING_LEN);
p += strlen(p) + 1;
lstrcpy(p, "*.*");
p += strlen(p) + 1;
*p = '\0';
GetCurrentDirectory(sizeof(szDir), szDir);
szPath[0]='\0';
openfilename.lStructSize = sizeof(OPENFILENAME);
openfilename.hwndOwner = Globals.active_win->hMainWnd;
openfilename.hInstance = Globals.hInstance;
openfilename.lpstrFilter = szzFilter;
openfilename.lpstrCustomFilter = 0;
openfilename.nMaxCustFilter = 0;
openfilename.nFilterIndex = 1;
openfilename.lpstrFile = szPath;
openfilename.nMaxFile = sizeof(szPath);
openfilename.lpstrFileTitle = 0;
openfilename.nMaxFileTitle = 0;
openfilename.lpstrInitialDir = szDir;
openfilename.lpstrTitle = 0;
openfilename.Flags = 0;
openfilename.nFileOffset = 0;
openfilename.nFileExtension = 0;
openfilename.lpstrDefExt = 0;
openfilename.lCustData = 0;
openfilename.lpfnHook = 0;
openfilename.lpTemplateName = 0;
if (GetOpenFileName(&openfilename))
{
HLPFILE* hlpfile = WINHELP_LookupHelpFile(szPath);
WINHELP_CreateHelpWindowByHash(hlpfile, 0,
WINHELP_GetWindowInfo(hlpfile, "main"), SW_SHOWNORMAL);
}
}
void CALLBACK MACRO_Find(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_Finder(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_FloatingMenu(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_Flush(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_FocusWindow(LPCSTR lpszWindow)
{
WINHELP_WINDOW *win;
WINE_TRACE("(\"%s\")\n", lpszWindow);
if (!lpszWindow || !lpszWindow[0]) lpszWindow = "main";
for (win = Globals.win_list; win; win = win->next)
if (win->lpszName && !lstrcmpi(win->lpszName, lpszWindow))
SetFocus(win->hMainWnd);
}
void CALLBACK MACRO_Generate(LPCSTR str, LONG w, LONG l)
{
WINE_FIXME("(\"%s\", %lx, %lx)\n", str, w, l);
}
void CALLBACK MACRO_GotoMark(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_HelpOn(void)
{
WINE_TRACE("()\n");
MACRO_JumpContents((Globals.wVersion > 4) ? "winhelp32.hlp" : "winhelp.hlp", NULL);
}
void CALLBACK MACRO_HelpOnTop(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_History(void)
{
WINE_TRACE("()\n");
if (Globals.active_win && !Globals.active_win->hHistoryWnd)
{
HWND hWnd = CreateWindow(HISTORY_WIN_CLASS_NAME, "History", WS_OVERLAPPEDWINDOW,
0, 0, 0, 0, 0, 0, Globals.hInstance, Globals.active_win);
ShowWindow(hWnd, SW_NORMAL);
}
}
void CALLBACK MACRO_IfThen(BOOL b, LPCSTR t)
{
if (b) MACRO_ExecuteMacro(t);
}
void CALLBACK MACRO_IfThenElse(BOOL b, LPCSTR t, LPCSTR f)
{
if (b) MACRO_ExecuteMacro(t); else MACRO_ExecuteMacro(f);
}
BOOL CALLBACK MACRO_InitMPrint(void)
{
WINE_FIXME("()\n");
return FALSE;
}
void CALLBACK MACRO_InsertItem(LPCSTR str1, LPCSTR str2, LPCSTR str3, LPCSTR str4, LONG u)
{
WINE_FIXME("(\"%s\", \"%s\", \"%s\", \"%s\", %lu)\n", str1, str2, str3, str4, u);
}
void CALLBACK MACRO_InsertMenu(LPCSTR str1, LPCSTR str2, LONG u)
{
WINE_FIXME("(\"%s\", \"%s\", %lu)\n", str1, str2, u);
}
BOOL CALLBACK MACRO_IsBook(void)
{
WINE_TRACE("()\n");
return Globals.isBook;
}
BOOL CALLBACK MACRO_IsMark(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
return FALSE;
}
BOOL CALLBACK MACRO_IsNotMark(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
return TRUE;
}
void CALLBACK MACRO_JumpContents(LPCSTR lpszPath, LPCSTR lpszWindow)
{
HLPFILE* hlpfile;
WINE_TRACE("(\"%s\", \"%s\")\n", lpszPath, lpszWindow);
hlpfile = WINHELP_LookupHelpFile(lpszPath);
WINHELP_CreateHelpWindowByHash(hlpfile, 0,
WINHELP_GetWindowInfo(hlpfile, lpszWindow),
SW_NORMAL);
}
void CALLBACK MACRO_JumpContext(LPCSTR lpszPath, LPCSTR lpszWindow, LONG context)
{
WINE_FIXME("(\"%s\", \"%s\", %ld)semi-stub\n", lpszPath, lpszWindow, context);
return MACRO_JumpContents(lpszPath, lpszWindow);
}
void CALLBACK MACRO_JumpHash(LPCSTR lpszPath, LPCSTR lpszWindow, LONG lHash)
{
HLPFILE* hlpfile;
WINE_TRACE("(\"%s\", \"%s\", %lu)\n", lpszPath, lpszWindow, lHash);
hlpfile = WINHELP_LookupHelpFile(lpszPath);
WINHELP_CreateHelpWindowByHash(hlpfile, lHash,
WINHELP_GetWindowInfo(hlpfile, lpszWindow),
SW_NORMAL);
}
void CALLBACK MACRO_JumpHelpOn(void)
{
WINE_FIXME("()\n");
}
/* FIXME: those two macros are wrong
* they should only contain 2 strings, path & window are coded as path>window
*/
void CALLBACK MACRO_JumpID(LPCSTR lpszPath, LPCSTR lpszWindow, LPCSTR topic_id)
{
WINE_TRACE("(\"%s\", \"%s\", \"%s\")\n", lpszPath, lpszWindow, topic_id);
MACRO_JumpHash(lpszPath, lpszWindow, HLPFILE_Hash(topic_id));
}
void CALLBACK MACRO_JumpKeyword(LPCSTR lpszPath, LPCSTR lpszWindow, LPCSTR keyword)
{
WINE_FIXME("(\"%s\", \"%s\", \"%s\")\n", lpszPath, lpszWindow, keyword);
}
void CALLBACK MACRO_KLink(LPCSTR str1, LONG u, LPCSTR str2, LPCSTR str3)
{
WINE_FIXME("(\"%s\", %lu, \"%s\", \"%s\")\n", str1, u, str2, str3);
}
void CALLBACK MACRO_Menu(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_MPrintHash(LONG u)
{
WINE_FIXME("(%lu)\n", u);
}
void CALLBACK MACRO_MPrintID(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_Next(void)
{
HLPFILE_PAGE* page;
WINE_TRACE("()\n");
page = Globals.active_win->page;
page = HLPFILE_PageByOffset(page->file, page->browse_fwd);
if (page)
{
page->file->wRefCount++;
WINHELP_CreateHelpWindow(page, Globals.active_win->info, SW_NORMAL);
}
}
void CALLBACK MACRO_NoShow(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_PopupContext(LPCSTR str, LONG u)
{
WINE_FIXME("(\"%s\", %lu)\n", str, u);
}
void CALLBACK MACRO_PopupHash(LPCSTR str, LONG u)
{
WINE_FIXME("(\"%s\", %lu)\n", str, u);
}
void CALLBACK MACRO_PopupId(LPCSTR str1, LPCSTR str2)
{
WINE_FIXME("(\"%s\", \"%s\")\n", str1, str2);
}
void CALLBACK MACRO_PositionWindow(LONG i1, LONG i2, LONG u1, LONG u2, LONG u3, LPCSTR str)
{
WINE_FIXME("(%li, %li, %lu, %lu, %lu, \"%s\")\n", i1, i2, u1, u2, u3, str);
}
void CALLBACK MACRO_Prev(void)
{
HLPFILE_PAGE* page;
WINE_TRACE("()\n");
page = Globals.active_win->page;
page = HLPFILE_PageByOffset(page->file, page->browse_bwd);
if (page)
{
page->file->wRefCount++;
WINHELP_CreateHelpWindow(page, Globals.active_win->info, SW_NORMAL);
}
}
void CALLBACK MACRO_Print(void)
{
PRINTDLG printer;
WINE_TRACE("()\n");
printer.lStructSize = sizeof(printer);
printer.hwndOwner = Globals.active_win->hMainWnd;
printer.hInstance = Globals.hInstance;
printer.hDevMode = 0;
printer.hDevNames = 0;
printer.hDC = 0;
printer.Flags = 0;
printer.nFromPage = 0;
printer.nToPage = 0;
printer.nMinPage = 0;
printer.nMaxPage = 0;
printer.nCopies = 0;
printer.lCustData = 0;
printer.lpfnPrintHook = 0;
printer.lpfnSetupHook = 0;
printer.lpPrintTemplateName = 0;
printer.lpSetupTemplateName = 0;
printer.hPrintTemplate = 0;
printer.hSetupTemplate = 0;
if (PrintDlgA(&printer)) {
WINE_FIXME("Print()\n");
}
}
void CALLBACK MACRO_PrinterSetup(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_RegisterRoutine(LPCSTR dll_name, LPCSTR proc, LPCSTR args)
{
FARPROC fn = NULL;
int size;
WINHELP_DLL* dll;
WINE_TRACE("(\"%s\", \"%s\", \"%s\")\n", dll_name, proc, args);
/* FIXME: are the registered DLLs global or linked to the current file ???
* We assume globals (as we did for macros, but is this really the case ???)
*/
for (dll = Globals.dlls; dll; dll = dll->next)
{
if (!strcmp(dll->name, dll_name)) break;
}
if (!dll)
{
HANDLE hLib = LoadLibrary(dll_name);
/* FIXME: the library will not be unloaded until exit of program
* We don't send the DW_TERM message
*/
WINE_TRACE("Loading %s\n", dll_name);
/* FIXME: should look in the directory where current hlpfile
* is loaded from
*/
if (hLib == NULL)
{
/* FIXME: internationalisation for error messages */
WINE_FIXME("Cannot find dll %s\n", dll_name);
}
else if ((dll = HeapAlloc(GetProcessHeap(), 0, sizeof(*dll))))
{
dll->hLib = hLib;
dll->name = strdup(dll_name); /* FIXME */
dll->next = Globals.dlls;
Globals.dlls = dll;
dll->handler = (WINHELP_LDLLHandler)GetProcAddress(dll->hLib, "LDLLHandler");
dll->class = dll->handler ? (dll->handler)(DW_WHATMSG, 0, 0) : DC_NOMSG;
WINE_TRACE("Got class %lx for DLL %s\n", dll->class, dll_name);
if (dll->class & DC_INITTERM) dll->handler(DW_INIT, 0, 0);
if (dll->class & DC_CALLBACKS) dll->handler(DW_CALLBACKS, (DWORD)Callbacks, 0);
}
else WINE_WARN("OOM\n");
}
if (dll && !(fn = GetProcAddress(dll->hLib, proc)))
{
/* FIXME: internationalisation for error messages */
WINE_FIXME("Cannot find proc %s in dll %s\n", dll_name, proc);
}
size = ++MACRO_NumLoaded * sizeof(struct MacroDesc);
if (!MACRO_Loaded) MACRO_Loaded = HeapAlloc(GetProcessHeap(), 0, size);
else MACRO_Loaded = HeapReAlloc(GetProcessHeap(), 0, MACRO_Loaded, size);
MACRO_Loaded[MACRO_NumLoaded - 1].name = strdup(proc); /* FIXME */
MACRO_Loaded[MACRO_NumLoaded - 1].alias = NULL;
MACRO_Loaded[MACRO_NumLoaded - 1].isBool = 0;
MACRO_Loaded[MACRO_NumLoaded - 1].arguments = strdup(args); /* FIXME */
MACRO_Loaded[MACRO_NumLoaded - 1].fn = fn;
WINE_TRACE("Added %s(%s) at %p\n", proc, args, fn);
}
void CALLBACK MACRO_RemoveAccelerator(LONG u1, LONG u2)
{
WINE_FIXME("(%lu, %lu)\n", u1, u2);
}
void CALLBACK MACRO_ResetMenu(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_SaveMark(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_Search(void)
{
WINE_FIXME("()\n");
}
void CALLBACK MACRO_SetContents(LPCSTR str, LONG u)
{
WINE_FIXME("(\"%s\", %lu)\n", str, u);
}
void CALLBACK MACRO_SetHelpOnFile(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_SetPopupColor(LONG u1, LONG u2, LONG u3)
{
WINE_FIXME("(%lu, %lu, %lu)\n", u1, u2, u3);
}
void CALLBACK MACRO_ShellExecute(LPCSTR str1, LPCSTR str2, LONG u1, LONG u2, LPCSTR str3, LPCSTR str4)
{
WINE_FIXME("(\"%s\", \"%s\", %lu, %lu, \"%s\", \"%s\")\n", str1, str2, u1, u2, str3, str4);
}
void CALLBACK MACRO_ShortCut(LPCSTR str1, LPCSTR str2, LONG w, LONG l, LPCSTR str)
{
WINE_FIXME("(\"%s\", \"%s\", %lx, %lx, \"%s\")\n", str1, str2, w, l, str);
}
void CALLBACK MACRO_TCard(LONG u)
{
WINE_FIXME("(%lu)\n", u);
}
void CALLBACK MACRO_Test(LONG u)
{
WINE_FIXME("(%lu)\n", u);
}
BOOL CALLBACK MACRO_TestALink(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
return FALSE;
}
BOOL CALLBACK MACRO_TestKLink(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
return FALSE;
}
void CALLBACK MACRO_UncheckItem(LPCSTR str)
{
WINE_FIXME("(\"%s\")\n", str);
}
void CALLBACK MACRO_UpdateWindow(LPCSTR str1, LPCSTR str2)
{
WINE_FIXME("(\"%s\", \"%s\")\n", str1, str2);
}