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

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