git.oblomov.eu Git - wine/blob - programs/winhelp/macro.c

   1 /*
   2  * Help Viewer
   3  *
   4  * Copyright 1996 Ulrich Schmid
   5  * Copyright 2002 Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <stdio.h>
  23
  24 #include "windows.h"
  25 #include "commdlg.h"
  26 #include "winhelp.h"
  27
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(winhelp);
  31
  32 /**************************************************/
  33 /*               Macro table                      */
  34 /**************************************************/
  35 struct MacroDesc {
  36     const char* name;
  37     const char* alias;
  38     BOOL        isBool;
  39     const char* arguments;
  40     FARPROC     fn;
  41 };
  42
  43 /* types:
  44  *      U:      32 bit unsigned int
  45  *      I:      32 bit signed int
  46  *      S:      string
  47  *      v:      unknown (32 bit entity)
  48  */
  49
  50 static struct MacroDesc MACRO_Builtins[] = {
  51     {"About",               NULL, 0, "",       (FARPROC)MACRO_About},
  52     {"AddAccelerator",      "AA", 0, "UUS",    (FARPROC)MACRO_AddAccelerator},
  53     {"ALink",               "AL", 0, "SUS",    (FARPROC)MACRO_ALink},
  54     {"Annotate",            NULL, 0, "",       (FARPROC)MACRO_Annotate},
  55     {"AppendItem",          NULL, 0, "SSSS",   (FARPROC)MACRO_AppendItem},
  56     {"Back",                NULL, 0, "",       (FARPROC)MACRO_Back},
  57     {"BackFlush",           "BF", 0, "",       (FARPROC)MACRO_BackFlush},
  58     {"BookmarkDefine",      NULL, 0, "",       (FARPROC)MACRO_BookmarkDefine},
  59     {"BookmarkMore",        NULL, 0, "",       (FARPROC)MACRO_BookmarkMore},
  60     {"BrowseButtons",       NULL, 0, "",       (FARPROC)MACRO_BrowseButtons},
  61     {"ChangeButtonBinding", "CBB",0, "SS",     (FARPROC)MACRO_ChangeButtonBinding},
  62     {"ChangeEnable",        "CE", 0, "SS",     (FARPROC)MACRO_ChangeEnable},
  63     {"ChangeItemBinding",   "CIB",0, "SS",     (FARPROC)MACRO_ChangeItemBinding},
  64     {"CheckItem",           "CI", 0, "S",      (FARPROC)MACRO_CheckItem},
  65     {"CloseSecondarys",     "CS", 0, "",       (FARPROC)MACRO_CloseSecondarys},
  66     {"CloseWindow",         "CW", 0, "S",      (FARPROC)MACRO_CloseWindow},
  67     {"Compare",             NULL, 0, "S",      (FARPROC)MACRO_Compare},
  68     {"Contents",            NULL, 0, "",       (FARPROC)MACRO_Contents},
  69     {"ControlPanel",        NULL, 0, "SSU",    (FARPROC)MACRO_ControlPanel},
  70     {"CopyDialog",          NULL, 0, "",       (FARPROC)MACRO_CopyDialog},
  71     {"CopyTopic",           "CT", 0, "",       (FARPROC)MACRO_CopyTopic},
  72     {"CreateButton",        "CB", 0, "SSS",    (FARPROC)MACRO_CreateButton},
  73     {"DeleteItem",          NULL, 0, "S",      (FARPROC)MACRO_DeleteItem},
  74     {"DeleteMark",          NULL, 0, "S",      (FARPROC)MACRO_DeleteMark},
  75     {"DestroyButton",       NULL, 0, "S",      (FARPROC)MACRO_DestroyButton},
  76     {"DisableButton",       "DB", 0, "S",      (FARPROC)MACRO_DisableButton},
  77     {"DisableItem",         "DI", 0, "S",      (FARPROC)MACRO_DisableItem},
  78     {"EnableButton",        "EB", 0, "S",      (FARPROC)MACRO_EnableButton},
  79     {"EnableItem",          "EI", 0, "S",      (FARPROC)MACRO_EnableItem},
  80     {"EndMPrint",           NULL, 0, "",       (FARPROC)MACRO_EndMPrint},
  81     {"ExecFile",            "EF", 0, "SSUS",   (FARPROC)MACRO_ExecFile},
  82     {"ExecProgram",         "EP", 0, "SU",     (FARPROC)MACRO_ExecProgram},
  83     {"Exit",                NULL, 0, "",       (FARPROC)MACRO_Exit},
  84     {"ExtAbleItem",         NULL, 0, "SU",     (FARPROC)MACRO_ExtAbleItem},
  85     {"ExtInsertItem",       NULL, 0, "SSSSUU", (FARPROC)MACRO_ExtInsertItem},
  86     {"ExtInsertMenu",       NULL, 0, "SSSUU",  (FARPROC)MACRO_ExtInsertMenu},
  87     {"FileExist",           "FE", 1, "S",      (FARPROC)MACRO_FileExist},
  88     {"FileOpen",            "FO", 0, "",       (FARPROC)MACRO_FileOpen},
  89     {"Find",                NULL, 0, "",       (FARPROC)MACRO_Find},
  90     {"Finder",              "FD", 0, "",       (FARPROC)MACRO_Finder},
  91     {"FloatingMenu",        NULL, 0, "",       (FARPROC)MACRO_FloatingMenu},
  92     {"Flush",               "FH", 0, "",       (FARPROC)MACRO_Flush},
  93     {"FocusWindow",         NULL, 0, "S",      (FARPROC)MACRO_FocusWindow},
  94     {"Generate",            NULL, 0, "SUU",    (FARPROC)MACRO_Generate},
  95     {"GotoMark",            NULL, 0, "S",      (FARPROC)MACRO_GotoMark},
  96     {"HelpOn",              NULL, 0, "",       (FARPROC)MACRO_HelpOn},
  97     {"HelpOnTop",           NULL, 0, "",       (FARPROC)MACRO_HelpOnTop},
  98     {"History",             NULL, 0, "",       (FARPROC)MACRO_History},
  99     {"InitMPrint",          NULL, 1, "",       (FARPROC)MACRO_InitMPrint},
 100     {"InsertItem",          NULL, 0, "SSSSU",  (FARPROC)MACRO_InsertItem},
 101     {"InsertMenu",          NULL, 0, "SSU",    (FARPROC)MACRO_InsertMenu},
 102     {"IfThen",              "IF", 0, "BS",     (FARPROC)MACRO_IfThen},
 103     {"IfThenElse",          "IE", 0, "BSS",    (FARPROC)MACRO_IfThenElse},
 104     {"IsBook",              NULL, 1, "",       (FARPROC)MACRO_IsBook},
 105     {"IsMark",              NULL, 1, "S",      (FARPROC)MACRO_IsMark},
 106     {"IsNotMark",           "NM", 1, "S",      (FARPROC)MACRO_IsNotMark},
 107     {"JumpContents",        NULL, 0, "SS",     (FARPROC)MACRO_JumpContents},
 108     {"JumpContext",         "JC", 0, "SSU",    (FARPROC)MACRO_JumpContext},
 109     {"JumpHash",            "JH", 0, "SSU",    (FARPROC)MACRO_JumpHash},
 110     {"JumpHelpOn",          NULL, 0, "",       (FARPROC)MACRO_JumpHelpOn},
 111     {"JumpID",              "JI", 0, "SSS",    (FARPROC)MACRO_JumpID},
 112     {"JumpKeyword",         "JK", 0, "SSS",    (FARPROC)MACRO_JumpKeyword},
 113     {"KLink",               "KL", 0, "SUSS",   (FARPROC)MACRO_KLink},
 114     {"Menu",                "MU", 0, "",       (FARPROC)MACRO_Menu},
 115     {"MPrintHash",          NULL, 0, "U",      (FARPROC)MACRO_MPrintHash},
 116     {"MPrintID",            NULL, 0, "S",      (FARPROC)MACRO_MPrintID},
 117     {"Next",                NULL, 0, "",       (FARPROC)MACRO_Next},
 118     {"NoShow",              NULL, 0, "",       (FARPROC)MACRO_NoShow},
 119     {"PopupContext",        "PC", 0, "SU",     (FARPROC)MACRO_PopupContext},
 120     {"PopupHash",           NULL, 0, "SU",     (FARPROC)MACRO_PopupHash},
 121     {"PopupId",             "PI", 0, "SS",     (FARPROC)MACRO_PopupId},
 122     {"PositionWindow",      "PW", 0, "IIUUUS", (FARPROC)MACRO_PositionWindow},
 123     {"Prev",                NULL, 0, "",       (FARPROC)MACRO_Prev},
 124     {"Print",               NULL, 0, "",       (FARPROC)MACRO_Print},
 125     {"PrinterSetup",        NULL, 0, "",       (FARPROC)MACRO_PrinterSetup},
 126     {"RegisterRoutine",     "RR", 0, "SSS",    (FARPROC)MACRO_RegisterRoutine},
 127     {"RemoveAccelerator",   "RA", 0, "UU",     (FARPROC)MACRO_RemoveAccelerator},
 128     {"ResetMenu",           NULL, 0, "",       (FARPROC)MACRO_ResetMenu},
 129     {"SaveMark",            NULL, 0, "S",      (FARPROC)MACRO_SaveMark},
 130     {"Search",              NULL, 0, "",       (FARPROC)MACRO_Search},
 131     {"SetContents",         NULL, 0, "SU",     (FARPROC)MACRO_SetContents},
 132     {"SetHelpOnFile",       NULL, 0, "S",      (FARPROC)MACRO_SetHelpOnFile},
 133     {"SetPopupColor",       "SPC",0, "UUU",    (FARPROC)MACRO_SetPopupColor},
 134     {"ShellExecute",        "SE", 0, "SSUUSS", (FARPROC)MACRO_ShellExecute},
 135     {"ShortCut",            "SH", 0, "SSUUS",  (FARPROC)MACRO_ShortCut},
 136     {"TCard",               NULL, 0, "U",      (FARPROC)MACRO_TCard},
 137     {"Test",                NULL, 0, "U",      (FARPROC)MACRO_Test},
 138     {"TestALink",           NULL, 1, "S",      (FARPROC)MACRO_TestALink},
 139     {"TestKLink",           NULL, 1, "S",      (FARPROC)MACRO_TestKLink},
 140     {"UncheckItem",         "UI", 0, "S",      (FARPROC)MACRO_UncheckItem},
 141     {"UpdateWindow",        "UW", 0, "SS",     (FARPROC)MACRO_UpdateWindow},
 142     {NULL,                  NULL, 0, NULL,     NULL}
 143 };
 144
 145 static struct MacroDesc*MACRO_Loaded /* = NULL */;
 146 static unsigned         MACRO_NumLoaded /* = 0 */;
 147
 148 static int MACRO_DoLookUp(struct MacroDesc* start, const char* name, struct lexret* lr, unsigned len)
 149 {
 150     struct MacroDesc*   md;
 151
 152     for (md = start; md->name && len != 0; md++, len--)
 153     {
 154         if (strcasecmp(md->name, name) == 0 || (md->alias != NULL && strcasecmp(md->alias, name) == 0))
 155         {
 156             lr->proto = md->arguments;
 157             lr->function = md->fn;
 158             return md->isBool ? BOOL_FUNCTION : VOID_FUNCTION;
 159         }
 160     }
 161     return EMPTY;
 162 }
 163
 164 int MACRO_Lookup(const char* name, struct lexret* lr)
 165 {
 166     int ret;
 167
 168     if ((ret = MACRO_DoLookUp(MACRO_Builtins, name, lr, -1)) != EMPTY)
 169         return ret;
 170     if (MACRO_Loaded && (ret = MACRO_DoLookUp(MACRO_Loaded, name, lr, MACRO_NumLoaded)) != EMPTY)
 171         return ret;
 172
 173     lr->string = name;
 174     return IDENTIFIER;
 175 }
 176
 177 /*******      helper functions     *******/
 178
 179 static WINHELP_BUTTON**        MACRO_LookupButton(WINHELP_WINDOW* win, LPCSTR name)
 180 {
 181     WINHELP_BUTTON**    b;
 182
 183     for (b = &win->first_button; *b; b = &(*b)->next)
 184         if (!lstrcmpi(name, (*b)->lpszID)) break;
 185     return b;
 186 }
 187
 188 /******* real macro implementation *******/
 189
 190 void CALLBACK MACRO_About(void)
 191 {
 192     WINE_FIXME("()\n");
 193 }
 194
 195 void CALLBACK MACRO_AddAccelerator(LONG u1, LONG u2, LPCSTR str)
 196 {
 197     WINE_FIXME("(%lu, %lu, \"%s\")\n", u1, u2, str);
 198 }
 199
 200 void CALLBACK MACRO_ALink(LPCSTR str1, LONG u, LPCSTR str2)
 201 {
 202     WINE_FIXME("(\"%s\", %lu, \"%s\")\n", str1, u, str2);
 203 }
 204
 205 void CALLBACK MACRO_Annotate(void)
 206 {
 207     WINE_FIXME("()\n");
 208 }
 209
 210 void CALLBACK MACRO_AppendItem(LPCSTR str1, LPCSTR str2, LPCSTR str3, LPCSTR str4)
 211 {
 212     WINE_FIXME("(\"%s\", \"%s\", \"%s\", \"%s\")\n", str1, str2, str3, str4);
 213 }
 214
 215 void CALLBACK MACRO_Back(void)
 216 {
 217     WINHELP_WINDOW* win = Globals.active_win;
 218
 219     WINE_TRACE("()\n");
 220
 221     if (win && win->backIndex >= 2)
 222         WINHELP_CreateHelpWindow(win->back[--win->backIndex - 1],
 223                                  win->info, SW_SHOW);
 224 }
 225
 226 void CALLBACK MACRO_BackFlush(void)
 227 {
 228     WINHELP_WINDOW* win = Globals.active_win;
 229
 230     WINE_TRACE("()\n");
 231
 232     if (win)
 233     {
 234         int     i;
 235
 236         for (i = 0; i < win->backIndex; i++)
 237         {
 238             HLPFILE_FreeHlpFile(win->back[i]->file);
 239             win->back[i] = NULL;
 240         }
 241         win->backIndex = 0;
 242     }
 243 }
 244
 245 void CALLBACK MACRO_BookmarkDefine(void)
 246 {
 247     WINE_FIXME("()\n");
 248 }
 249
 250 void CALLBACK MACRO_BookmarkMore(void)
 251 {
 252     WINE_FIXME("()\n");
 253 }
 254
 255 void CALLBACK MACRO_BrowseButtons(void)
 256 {
 257     WINE_TRACE("()\n");
 258
 259     MACRO_CreateButton("BTN_PREV", "&<<", "Prev()");
 260     MACRO_CreateButton("BTN_NEXT", "&>>", "Next()");
 261 }
 262
 263 void CALLBACK MACRO_ChangeButtonBinding(LPCSTR id, LPCSTR macro)
 264 {
 265     WINHELP_WINDOW*     win = Globals.active_win;
 266     WINHELP_BUTTON*     button;
 267     WINHELP_BUTTON**    b;
 268     LONG                size;
 269     LPSTR               ptr;
 270
 271     WINE_TRACE("(\"%s\", \"%s\")\n", id, macro);
 272
 273     b = MACRO_LookupButton(win, id);
 274     if (!*b) {WINE_FIXME("Couldn't find button '%s'\n", id); return;}
 275
 276     size = sizeof(WINHELP_BUTTON) + lstrlen(id) +
 277         lstrlen((*b)->lpszName) + lstrlen(macro) + 3;
 278
 279     button = HeapAlloc(GetProcessHeap(), 0, size);
 280     if (!button) return;
 281
 282     button->next  = (*b)->next;
 283     button->hWnd  = (*b)->hWnd;
 284     button->wParam = (*b)->wParam;
 285
 286     ptr = (char*)button + sizeof(WINHELP_BUTTON);
 287
 288     lstrcpy(ptr, id);
 289     button->lpszID = ptr;
 290     ptr += lstrlen(id) + 1;
 291
 292     lstrcpy(ptr, (*b)->lpszName);
 293     button->lpszName = ptr;
 294     ptr += lstrlen((*b)->lpszName) + 1;
 295
 296     lstrcpy(ptr, macro);
 297     button->lpszMacro = ptr;
 298
 299     *b = button;
 300
 301     SendMessage(win->hMainWnd, WM_USER, 0, 0);
 302 }
 303
 304 void CALLBACK MACRO_ChangeEnable(LPCSTR id, LPCSTR macro)
 305 {
 306     WINE_TRACE("(\"%s\", \"%s\")\n", id, macro);
 307
 308     MACRO_ChangeButtonBinding(id, macro);
 309     MACRO_EnableButton(id);
 310 }
 311
 312 void CALLBACK MACRO_ChangeItemBinding(LPCSTR str1, LPCSTR str2)
 313 {
 314     WINE_FIXME("(\"%s\", \"%s\")\n", str1, str2);
 315 }
 316
 317 void CALLBACK MACRO_CheckItem(LPCSTR str)
 318 {
 319     WINE_FIXME("(\"%s\")\n", str);
 320 }
 321
 322 void CALLBACK MACRO_CloseSecondarys(void)
 323 {
 324     WINHELP_WINDOW *win;
 325
 326     WINE_TRACE("()\n");
 327     for (win = Globals.win_list; win; win = win->next)
 328         if (win->lpszName && lstrcmpi(win->lpszName, "main"))
 329             DestroyWindow(win->hMainWnd);
 330 }
 331
 332 void CALLBACK MACRO_CloseWindow(LPCSTR lpszWindow)
 333 {
 334     WINHELP_WINDOW *win;
 335
 336     WINE_TRACE("(\"%s\")\n", lpszWindow);
 337
 338     if (!lpszWindow || !lpszWindow[0]) lpszWindow = "main";
 339
 340     for (win = Globals.win_list; win; win = win->next)
 341         if (win->lpszName && !lstrcmpi(win->lpszName, lpszWindow))
 342             DestroyWindow(win->hMainWnd);
 343 }
 344
 345 void CALLBACK MACRO_Compare(LPCSTR str)
 346 {
 347     WINE_FIXME("(\"%s\")\n", str);
 348 }
 349
 350 void CALLBACK MACRO_Contents(void)
 351 {
 352     WINE_TRACE("()\n");
 353
 354     if (Globals.active_win->page)
 355         MACRO_JumpContents(Globals.active_win->page->file->lpszPath, NULL);
 356 }
 357
 358 void CALLBACK MACRO_ControlPanel(LPCSTR str1, LPCSTR str2, LONG u)
 359 {
 360     WINE_FIXME("(\"%s\", \"%s\", %lu)\n", str1, str2, u);
 361 }
 362
 363 void CALLBACK MACRO_CopyDialog(void)
 364 {
 365     WINE_FIXME("()\n");
 366 }
 367
 368 void CALLBACK MACRO_CopyTopic(void)
 369 {
 370     WINE_FIXME("()\n");
 371 }
 372
 373 void CALLBACK MACRO_CreateButton(LPCSTR id, LPCSTR name, LPCSTR macro)
 374 {
 375     WINHELP_WINDOW *win = Globals.active_win;
 376     WINHELP_BUTTON *button, **b;
 377     LONG            size;
 378     LPSTR           ptr;
 379
 380     WINE_TRACE("(\"%s\", \"%s\", %s)\n", id, name, macro);
 381
 382     size = sizeof(WINHELP_BUTTON) + lstrlen(id) + lstrlen(name) + lstrlen(macro) + 3;
 383
 384     button = HeapAlloc(GetProcessHeap(), 0, size);
 385     if (!button) return;
 386
 387     button->next  = 0;
 388     button->hWnd  = 0;
 389
 390     ptr = (char*)button + sizeof(WINHELP_BUTTON);
 391
 392     lstrcpy(ptr, id);
 393     button->lpszID = ptr;
 394     ptr += lstrlen(id) + 1;
 395
 396     lstrcpy(ptr, name);
 397     button->lpszName = ptr;
 398     ptr += lstrlen(name) + 1;
 399
 400     lstrcpy(ptr, macro);
 401     button->lpszMacro = ptr;
 402
 403     button->wParam = WH_FIRST_BUTTON;
 404     for (b = &win->first_button; *b; b = &(*b)->next)
 405         button->wParam = max(button->wParam, (*b)->wParam + 1);
 406     *b = button;
 407
 408     SendMessage(win->hMainWnd, WM_USER, 0, 0);
 409 }
 410
 411 void CALLBACK MACRO_DeleteItem(LPCSTR str)
 412 {
 413     WINE_FIXME("(\"%s\")\n", str);
 414 }
 415
 416 void CALLBACK MACRO_DeleteMark(LPCSTR str)
 417 {
 418     WINE_FIXME("(\"%s\")\n", str);
 419 }
 420
 421 void CALLBACK MACRO_DestroyButton(LPCSTR str)
 422 {
 423     WINE_FIXME("(\"%s\")\n", str);
 424 }
 425
 426 void CALLBACK MACRO_DisableButton(LPCSTR id)
 427 {
 428     WINHELP_BUTTON**    b;
 429
 430     WINE_FIXME("(\"%s\")\n", id);
 431
 432     b = MACRO_LookupButton(Globals.active_win, id);
 433     if (!*b) {WINE_FIXME("Couldn't find button '%s'\n", id); return;}
 434
 435     EnableWindow((*b)->hWnd, FALSE);
 436 }
 437
 438 void CALLBACK MACRO_DisableItem(LPCSTR str)
 439 {
 440     WINE_FIXME("(\"%s\")\n", str);
 441 }
 442
 443 void CALLBACK MACRO_EnableButton(LPCSTR id)
 444 {
 445     WINHELP_BUTTON**    b;
 446
 447     WINE_TRACE("(\"%s\")\n", id);
 448
 449     b = MACRO_LookupButton(Globals.active_win, id);
 450     if (!*b) {WINE_FIXME("Couldn't find button '%s'\n", id); return;}
 451
 452     EnableWindow((*b)->hWnd, TRUE);
 453 }
 454
 455 void CALLBACK MACRO_EnableItem(LPCSTR str)
 456 {
 457     WINE_FIXME("(\"%s\")\n", str);
 458 }
 459
 460 void CALLBACK MACRO_EndMPrint(void)
 461 {
 462     WINE_FIXME("()\n");
 463 }
 464
 465 void CALLBACK MACRO_ExecFile(LPCSTR str1, LPCSTR str2, LONG u, LPCSTR str3)
 466 {
 467     WINE_FIXME("(\"%s\", \"%s\", %lu, \"%s\")\n", str1, str2, u, str3);
 468 }
 469
 470 void CALLBACK MACRO_ExecProgram(LPCSTR str, LONG u)
 471 {
 472     WINE_FIXME("(\"%s\", %lu)\n", str, u);
 473 }
 474
 475 void CALLBACK MACRO_Exit(void)
 476 {
 477     WINE_TRACE("()\n");
 478
 479     while (Globals.win_list)
 480         DestroyWindow(Globals.win_list->hMainWnd);
 481 }
 482
 483 void CALLBACK MACRO_ExtAbleItem(LPCSTR str, LONG u)
 484 {
 485     WINE_FIXME("(\"%s\", %lu)\n", str, u);
 486 }
 487
 488 void CALLBACK MACRO_ExtInsertItem(LPCSTR str1, LPCSTR str2, LPCSTR str3, LPCSTR str4, LONG u1, LONG u2)
 489 {
 490     WINE_FIXME("(\"%s\", \"%s\", \"%s\", \"%s\", %lu, %lu)\n", str1, str2, str3, str4, u1, u2);
 491 }
 492
 493 void CALLBACK MACRO_ExtInsertMenu(LPCSTR str1, LPCSTR str2, LPCSTR str3, LONG u1, LONG u2)
 494 {
 495     WINE_FIXME("(\"%s\", \"%s\", \"%s\", %lu, %lu)\n", str1, str2, str3, u1, u2);
 496 }
 497
 498 BOOL CALLBACK MACRO_FileExist(LPCSTR str)
 499 {
 500     WINE_TRACE("(\"%s\")\n", str);
 501     return GetFileAttributes(str) != INVALID_FILE_ATTRIBUTES;
 502 }
 503
 504 void CALLBACK MACRO_FileOpen(void)
 505 {
 506     OPENFILENAME openfilename;
 507     CHAR szPath[MAX_PATHNAME_LEN];
 508     CHAR szDir[MAX_PATHNAME_LEN];
 509     CHAR szzFilter[2 * MAX_STRING_LEN + 100];
 510     LPSTR p = szzFilter;
 511
 512     WINE_TRACE("()\n");
 513
 514     LoadString(Globals.hInstance, STID_HELP_FILES_HLP, p, MAX_STRING_LEN);
 515     p += strlen(p) + 1;
 516     lstrcpy(p, "*.hlp");
 517     p += strlen(p) + 1;
 518     LoadString(Globals.hInstance, STID_ALL_FILES, p, MAX_STRING_LEN);
 519     p += strlen(p) + 1;
 520     lstrcpy(p, "*.*");
 521     p += strlen(p) + 1;
 522     *p = '\0';
 523
 524     GetCurrentDirectory(sizeof(szDir), szDir);
 525
 526     szPath[0]='\0';
 527
 528     openfilename.lStructSize       = sizeof(OPENFILENAME);
 529     openfilename.hwndOwner         = Globals.active_win->hMainWnd;
 530     openfilename.hInstance         = Globals.hInstance;
 531     openfilename.lpstrFilter       = szzFilter;
 532     openfilename.lpstrCustomFilter = 0;
 533     openfilename.nMaxCustFilter    = 0;
 534     openfilename.nFilterIndex      = 1;
 535     openfilename.lpstrFile         = szPath;
 536     openfilename.nMaxFile          = sizeof(szPath);
 537     openfilename.lpstrFileTitle    = 0;
 538     openfilename.nMaxFileTitle     = 0;
 539     openfilename.lpstrInitialDir   = szDir;
 540     openfilename.lpstrTitle        = 0;
 541     openfilename.Flags             = 0;
 542     openfilename.nFileOffset       = 0;
 543     openfilename.nFileExtension    = 0;
 544     openfilename.lpstrDefExt       = 0;
 545     openfilename.lCustData         = 0;
 546     openfilename.lpfnHook          = 0;
 547     openfilename.lpTemplateName    = 0;
 548
 549     if (GetOpenFileName(&openfilename))
 550     {
 551         HLPFILE*        hlpfile = WINHELP_LookupHelpFile(szPath);
 552
 553         WINHELP_CreateHelpWindowByHash(hlpfile, 0,
 554                                        WINHELP_GetWindowInfo(hlpfile, "main"), SW_SHOWNORMAL);
 555     }
 556 }
 557
 558 void CALLBACK MACRO_Find(void)
 559 {
 560     WINE_FIXME("()\n");
 561 }
 562
 563 void CALLBACK MACRO_Finder(void)
 564 {
 565     WINE_FIXME("()\n");
 566 }
 567
 568 void CALLBACK MACRO_FloatingMenu(void)
 569 {
 570     WINE_FIXME("()\n");
 571 }
 572
 573 void CALLBACK MACRO_Flush(void)
 574 {
 575     WINE_FIXME("()\n");
 576 }
 577
 578 void CALLBACK MACRO_FocusWindow(LPCSTR lpszWindow)
 579 {
 580     WINHELP_WINDOW *win;
 581
 582     WINE_TRACE("(\"%s\")\n", lpszWindow);
 583
 584     if (!lpszWindow || !lpszWindow[0]) lpszWindow = "main";
 585
 586     for (win = Globals.win_list; win; win = win->next)
 587         if (win->lpszName && !lstrcmpi(win->lpszName, lpszWindow))
 588             SetFocus(win->hMainWnd);
 589 }
 590
 591 void CALLBACK MACRO_Generate(LPCSTR str, LONG w, LONG l)
 592 {
 593     WINE_FIXME("(\"%s\", %lx, %lx)\n", str, w, l);
 594 }
 595
 596 void CALLBACK MACRO_GotoMark(LPCSTR str)
 597 {
 598     WINE_FIXME("(\"%s\")\n", str);
 599 }
 600
 601 void CALLBACK MACRO_HelpOn(void)
 602 {
 603     WINE_TRACE("()\n");
 604     MACRO_JumpContents((Globals.wVersion > 4) ? "winhelp32.hlp" : "winhelp.hlp", NULL);
 605 }
 606
 607 void CALLBACK MACRO_HelpOnTop(void)
 608 {
 609     WINE_FIXME("()\n");
 610 }
 611
 612 void CALLBACK MACRO_History(void)
 613 {
 614     WINE_TRACE("()\n");
 615
 616     if (Globals.active_win && !Globals.active_win->hHistoryWnd)
 617     {
 618         HWND hWnd = CreateWindow(HISTORY_WIN_CLASS_NAME, "History", WS_OVERLAPPEDWINDOW,
 619                                  0, 0, 0, 0, 0, 0, Globals.hInstance, Globals.active_win);
 620         ShowWindow(hWnd, SW_NORMAL);
 621     }
 622 }
 623
 624 void CALLBACK MACRO_IfThen(BOOL b, LPCSTR t)
 625 {
 626     if (b) MACRO_ExecuteMacro(t);
 627 }
 628
 629 void CALLBACK MACRO_IfThenElse(BOOL b, LPCSTR t, LPCSTR f)
 630 {
 631     if (b) MACRO_ExecuteMacro(t); else MACRO_ExecuteMacro(f);
 632 }
 633
 634 BOOL CALLBACK MACRO_InitMPrint(void)
 635 {
 636     WINE_FIXME("()\n");
 637     return FALSE;
 638 }
 639
 640 void CALLBACK MACRO_InsertItem(LPCSTR str1, LPCSTR str2, LPCSTR str3, LPCSTR str4, LONG u)
 641 {
 642     WINE_FIXME("(\"%s\", \"%s\", \"%s\", \"%s\", %lu)\n", str1, str2, str3, str4, u);
 643 }
 644
 645 void CALLBACK MACRO_InsertMenu(LPCSTR str1, LPCSTR str2, LONG u)
 646 {
 647     WINE_FIXME("(\"%s\", \"%s\", %lu)\n", str1, str2, u);
 648 }
 649
 650 BOOL CALLBACK MACRO_IsBook(void)
 651 {
 652     WINE_TRACE("()\n");
 653     return Globals.isBook;
 654 }
 655
 656 BOOL CALLBACK MACRO_IsMark(LPCSTR str)
 657 {
 658     WINE_FIXME("(\"%s\")\n", str);
 659     return FALSE;
 660 }
 661
 662 BOOL CALLBACK MACRO_IsNotMark(LPCSTR str)
 663 {
 664     WINE_FIXME("(\"%s\")\n", str);
 665     return TRUE;
 666 }
 667
 668 void CALLBACK MACRO_JumpContents(LPCSTR lpszPath, LPCSTR lpszWindow)
 669 {
 670     HLPFILE*    hlpfile;
 671
 672     WINE_TRACE("(\"%s\", \"%s\")\n", lpszPath, lpszWindow);
 673     hlpfile = WINHELP_LookupHelpFile(lpszPath);
 674     WINHELP_CreateHelpWindowByHash(hlpfile, 0,
 675                                    WINHELP_GetWindowInfo(hlpfile, lpszWindow),
 676                                    SW_NORMAL);
 677 }
 678
 679 void CALLBACK MACRO_JumpContext(LPCSTR lpszPath, LPCSTR lpszWindow, LONG context)
 680 {
 681     WINE_FIXME("(\"%s\", \"%s\", %ld)semi-stub\n", lpszPath, lpszWindow, context);
 682     return MACRO_JumpContents(lpszPath, lpszWindow);
 683 }
 684
 685 void CALLBACK MACRO_JumpHash(LPCSTR lpszPath, LPCSTR lpszWindow, LONG lHash)
 686 {
 687     HLPFILE*    hlpfile;
 688
 689     WINE_TRACE("(\"%s\", \"%s\", %lu)\n", lpszPath, lpszWindow, lHash);
 690     hlpfile = WINHELP_LookupHelpFile(lpszPath);
 691     WINHELP_CreateHelpWindowByHash(hlpfile, lHash,
 692                                    WINHELP_GetWindowInfo(hlpfile, lpszWindow),
 693                                    SW_NORMAL);
 694 }
 695
 696 void CALLBACK MACRO_JumpHelpOn(void)
 697 {
 698     WINE_FIXME("()\n");
 699 }
 700
 701 /* FIXME: those two macros are wrong
 702  * they should only contain 2 strings, path & window are coded as path>window
 703  */
 704 void CALLBACK MACRO_JumpID(LPCSTR lpszPath, LPCSTR lpszWindow, LPCSTR topic_id)
 705 {
 706     WINE_TRACE("(\"%s\", \"%s\", \"%s\")\n", lpszPath, lpszWindow, topic_id);
 707     MACRO_JumpHash(lpszPath, lpszWindow, HLPFILE_Hash(topic_id));
 708 }
 709
 710 void CALLBACK MACRO_JumpKeyword(LPCSTR lpszPath, LPCSTR lpszWindow, LPCSTR keyword)
 711 {
 712     WINE_FIXME("(\"%s\", \"%s\", \"%s\")\n", lpszPath, lpszWindow, keyword);
 713 }
 714
 715 void CALLBACK MACRO_KLink(LPCSTR str1, LONG u, LPCSTR str2, LPCSTR str3)
 716 {
 717     WINE_FIXME("(\"%s\", %lu, \"%s\", \"%s\")\n", str1, u, str2, str3);
 718 }
 719
 720 void CALLBACK MACRO_Menu(void)
 721 {
 722     WINE_FIXME("()\n");
 723 }
 724
 725 void CALLBACK MACRO_MPrintHash(LONG u)
 726 {
 727     WINE_FIXME("(%lu)\n", u);
 728 }
 729
 730 void CALLBACK MACRO_MPrintID(LPCSTR str)
 731 {
 732     WINE_FIXME("(\"%s\")\n", str);
 733 }
 734
 735 void CALLBACK MACRO_Next(void)
 736 {
 737     HLPFILE_PAGE*   page;
 738
 739     WINE_TRACE("()\n");
 740     page = Globals.active_win->page;
 741     page = HLPFILE_PageByOffset(page->file, page->browse_fwd);
 742     if (page)
 743     {
 744         page->file->wRefCount++;
 745         WINHELP_CreateHelpWindow(page, Globals.active_win->info, SW_NORMAL);
 746     }
 747 }
 748
 749 void CALLBACK MACRO_NoShow(void)
 750 {
 751     WINE_FIXME("()\n");
 752 }
 753
 754 void CALLBACK MACRO_PopupContext(LPCSTR str, LONG u)
 755 {
 756     WINE_FIXME("(\"%s\", %lu)\n", str, u);
 757 }
 758
 759 void CALLBACK MACRO_PopupHash(LPCSTR str, LONG u)
 760 {
 761     WINE_FIXME("(\"%s\", %lu)\n", str, u);
 762 }
 763
 764 void CALLBACK MACRO_PopupId(LPCSTR str1, LPCSTR str2)
 765 {
 766     WINE_FIXME("(\"%s\", \"%s\")\n", str1, str2);
 767 }
 768
 769 void CALLBACK MACRO_PositionWindow(LONG i1, LONG i2, LONG u1, LONG u2, LONG u3, LPCSTR str)
 770 {
 771     WINE_FIXME("(%li, %li, %lu, %lu, %lu, \"%s\")\n", i1, i2, u1, u2, u3, str);
 772 }
 773
 774 void CALLBACK MACRO_Prev(void)
 775 {
 776     HLPFILE_PAGE*   page;
 777
 778     WINE_TRACE("()\n");
 779     page = Globals.active_win->page;
 780     page = HLPFILE_PageByOffset(page->file, page->browse_bwd);
 781     if (page)
 782     {
 783         page->file->wRefCount++;
 784         WINHELP_CreateHelpWindow(page, Globals.active_win->info, SW_NORMAL);
 785     }
 786 }
 787
 788 void CALLBACK MACRO_Print(void)
 789 {
 790     PRINTDLG printer;
 791
 792     WINE_TRACE("()\n");
 793
 794     printer.lStructSize         = sizeof(printer);
 795     printer.hwndOwner           = Globals.active_win->hMainWnd;
 796     printer.hInstance           = Globals.hInstance;
 797     printer.hDevMode            = 0;
 798     printer.hDevNames           = 0;
 799     printer.hDC                 = 0;
 800     printer.Flags               = 0;
 801     printer.nFromPage           = 0;
 802     printer.nToPage             = 0;
 803     printer.nMinPage            = 0;
 804     printer.nMaxPage            = 0;
 805     printer.nCopies             = 0;
 806     printer.lCustData           = 0;
 807     printer.lpfnPrintHook       = 0;
 808     printer.lpfnSetupHook       = 0;
 809     printer.lpPrintTemplateName = 0;
 810     printer.lpSetupTemplateName = 0;
 811     printer.hPrintTemplate      = 0;
 812     printer.hSetupTemplate      = 0;
 813
 814     if (PrintDlgA(&printer)) {
 815         WINE_FIXME("Print()\n");
 816     }
 817 }
 818
 819 void CALLBACK MACRO_PrinterSetup(void)
 820 {
 821     WINE_FIXME("()\n");
 822 }
 823
 824 void CALLBACK MACRO_RegisterRoutine(LPCSTR dll_name, LPCSTR proc, LPCSTR args)
 825 {
 826     FARPROC             fn = NULL;
 827     int                 size;
 828     WINHELP_DLL*        dll;
 829
 830     WINE_TRACE("(\"%s\", \"%s\", \"%s\")\n", dll_name, proc, args);
 831
 832     /* FIXME: are the registered DLLs global or linked to the current file ???
 833      * We assume globals (as we did for macros, but is this really the case ???)
 834      */
 835     for (dll = Globals.dlls; dll; dll = dll->next)
 836     {
 837         if (!strcmp(dll->name, dll_name)) break;
 838     }
 839     if (!dll)
 840     {
 841         HANDLE hLib = LoadLibrary(dll_name);
 842
 843         /* FIXME: the library will not be unloaded until exit of program
 844          * We don't send the DW_TERM message
 845          */
 846         WINE_TRACE("Loading %s\n", dll_name);
 847         /* FIXME: should look in the directory where current hlpfile
 848          * is loaded from
 849          */
 850         if (hLib == NULL)
 851         {
 852             /* FIXME: internationalisation for error messages */
 853             WINE_FIXME("Cannot find dll %s\n", dll_name);
 854         }
 855         else if ((dll = HeapAlloc(GetProcessHeap(), 0, sizeof(*dll))))
 856         {
 857             dll->hLib = hLib;
 858             dll->name = strdup(dll_name); /* FIXME */
 859             dll->next = Globals.dlls;
 860             Globals.dlls = dll;
 861             dll->handler = (WINHELP_LDLLHandler)GetProcAddress(dll->hLib, "LDLLHandler");
 862             dll->class = dll->handler ? (dll->handler)(DW_WHATMSG, 0, 0) : DC_NOMSG;
 863             WINE_TRACE("Got class %lx for DLL %s\n", dll->class, dll_name);
 864             if (dll->class & DC_INITTERM) dll->handler(DW_INIT, 0, 0);
 865             if (dll->class & DC_CALLBACKS) dll->handler(DW_CALLBACKS, (DWORD)Callbacks, 0);
 866         }
 867         else WINE_WARN("OOM\n");
 868     }
 869     if (dll && !(fn = GetProcAddress(dll->hLib, proc)))
 870     {
 871         /* FIXME: internationalisation for error messages */
 872         WINE_FIXME("Cannot find proc %s in dll %s\n", dll_name, proc);
 873     }
 874
 875     size = ++MACRO_NumLoaded * sizeof(struct MacroDesc);
 876     if (!MACRO_Loaded) MACRO_Loaded = HeapAlloc(GetProcessHeap(), 0, size);
 877     else MACRO_Loaded = HeapReAlloc(GetProcessHeap(), 0, MACRO_Loaded, size);
 878     MACRO_Loaded[MACRO_NumLoaded - 1].name      = strdup(proc); /* FIXME */
 879     MACRO_Loaded[MACRO_NumLoaded - 1].alias     = NULL;
 880     MACRO_Loaded[MACRO_NumLoaded - 1].isBool    = 0;
 881     MACRO_Loaded[MACRO_NumLoaded - 1].arguments = strdup(args); /* FIXME */
 882     MACRO_Loaded[MACRO_NumLoaded - 1].fn        = fn;
 883     WINE_TRACE("Added %s(%s) at %p\n", proc, args, fn);
 884 }
 885
 886 void CALLBACK MACRO_RemoveAccelerator(LONG u1, LONG u2)
 887 {
 888     WINE_FIXME("(%lu, %lu)\n", u1, u2);
 889 }
 890
 891 void CALLBACK MACRO_ResetMenu(void)
 892 {
 893     WINE_FIXME("()\n");
 894 }
 895
 896 void CALLBACK MACRO_SaveMark(LPCSTR str)
 897 {
 898     WINE_FIXME("(\"%s\")\n", str);
 899 }
 900
 901 void CALLBACK MACRO_Search(void)
 902 {
 903     WINE_FIXME("()\n");
 904 }
 905
 906 void CALLBACK MACRO_SetContents(LPCSTR str, LONG u)
 907 {
 908     WINE_FIXME("(\"%s\", %lu)\n", str, u);
 909 }
 910
 911 void CALLBACK MACRO_SetHelpOnFile(LPCSTR str)
 912 {
 913     WINE_FIXME("(\"%s\")\n", str);
 914 }
 915
 916 void CALLBACK MACRO_SetPopupColor(LONG u1, LONG u2, LONG u3)
 917 {
 918     WINE_FIXME("(%lu, %lu, %lu)\n", u1, u2, u3);
 919 }
 920
 921 void CALLBACK MACRO_ShellExecute(LPCSTR str1, LPCSTR str2, LONG u1, LONG u2, LPCSTR str3, LPCSTR str4)
 922 {
 923     WINE_FIXME("(\"%s\", \"%s\", %lu, %lu, \"%s\", \"%s\")\n", str1, str2, u1, u2, str3, str4);
 924 }
 925
 926 void CALLBACK MACRO_ShortCut(LPCSTR str1, LPCSTR str2, LONG w, LONG l, LPCSTR str)
 927 {
 928     WINE_FIXME("(\"%s\", \"%s\", %lx, %lx, \"%s\")\n", str1, str2, w, l, str);
 929 }
 930
 931 void CALLBACK MACRO_TCard(LONG u)
 932 {
 933     WINE_FIXME("(%lu)\n", u);
 934 }
 935
 936 void CALLBACK MACRO_Test(LONG u)
 937 {
 938     WINE_FIXME("(%lu)\n", u);
 939 }
 940
 941 BOOL CALLBACK MACRO_TestALink(LPCSTR str)
 942 {
 943     WINE_FIXME("(\"%s\")\n", str);
 944     return FALSE;
 945 }
 946
 947 BOOL CALLBACK MACRO_TestKLink(LPCSTR str)
 948 {
 949     WINE_FIXME("(\"%s\")\n", str);
 950     return FALSE;
 951 }
 952
 953 void CALLBACK MACRO_UncheckItem(LPCSTR str)
 954 {
 955     WINE_FIXME("(\"%s\")\n", str);
 956 }
 957
 958 void CALLBACK MACRO_UpdateWindow(LPCSTR str1, LPCSTR str2)
 959 {
 960     WINE_FIXME("(\"%s\", \"%s\")\n", str1, str2);
 961 }