user32: Implement GetWindowModuleFileName.
[wine] / programs / winhlp32 / 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., 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();
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     WINE_TRACE("()\n");
559     MACRO_JumpContents((Globals.wVersion > 4) ? "winhelp32.hlp" : "winhelp.hlp", NULL);
560 }
561
562 void CALLBACK MACRO_HelpOnTop(void)
563 {
564     WINE_FIXME("()\n");
565 }
566
567 void CALLBACK MACRO_History(void)
568 {
569     WINE_TRACE("()\n");
570
571     if (Globals.active_win && !Globals.active_win->hHistoryWnd)
572     {
573         HWND hWnd = CreateWindow(HISTORY_WIN_CLASS_NAME, "History", WS_OVERLAPPEDWINDOW,
574                                  0, 0, 0, 0, 0, 0, Globals.hInstance, Globals.active_win);
575         ShowWindow(hWnd, SW_NORMAL);
576     }
577 }
578
579 void CALLBACK MACRO_IfThen(BOOL b, LPCSTR t)
580 {
581     if (b) MACRO_ExecuteMacro(t);
582 }
583
584 void CALLBACK MACRO_IfThenElse(BOOL b, LPCSTR t, LPCSTR f)
585 {
586     if (b) MACRO_ExecuteMacro(t); else MACRO_ExecuteMacro(f);
587 }
588
589 BOOL CALLBACK MACRO_InitMPrint(void)
590 {
591     WINE_FIXME("()\n");
592     return FALSE;
593 }
594
595 void CALLBACK MACRO_InsertItem(LPCSTR str1, LPCSTR str2, LPCSTR str3, LPCSTR str4, LONG u)
596 {
597     WINE_FIXME("(\"%s\", \"%s\", \"%s\", \"%s\", %u)\n", str1, str2, str3, str4, u);
598 }
599
600 void CALLBACK MACRO_InsertMenu(LPCSTR str1, LPCSTR str2, LONG u)
601 {
602     WINE_FIXME("(\"%s\", \"%s\", %u)\n", str1, str2, u);
603 }
604
605 BOOL CALLBACK MACRO_IsBook(void)
606 {
607     WINE_TRACE("()\n");
608     return Globals.isBook;
609 }
610
611 BOOL CALLBACK MACRO_IsMark(LPCSTR str)
612 {
613     WINE_FIXME("(\"%s\")\n", str);
614     return FALSE;
615 }
616
617 BOOL CALLBACK MACRO_IsNotMark(LPCSTR str)
618 {
619     WINE_FIXME("(\"%s\")\n", str);
620     return TRUE;
621 }
622
623 void CALLBACK MACRO_JumpContents(LPCSTR lpszPath, LPCSTR lpszWindow)
624 {
625     HLPFILE*    hlpfile;
626
627     WINE_TRACE("(\"%s\", \"%s\")\n", lpszPath, lpszWindow);
628     if ((hlpfile = WINHELP_LookupHelpFile(lpszPath)))
629         WINHELP_OpenHelpWindow(HLPFILE_PageByHash, hlpfile, 0,
630                                WINHELP_GetWindowInfo(hlpfile, lpszWindow),
631                                SW_NORMAL);
632 }
633
634 void CALLBACK MACRO_JumpContext(LPCSTR lpszPath, LPCSTR lpszWindow, LONG context)
635 {
636     HLPFILE*    hlpfile;
637
638     WINE_TRACE("(\"%s\", \"%s\", %d)\n", lpszPath, lpszWindow, context);
639     hlpfile = WINHELP_LookupHelpFile(lpszPath);
640     /* Some madness: what user calls 'context', hlpfile calls 'map' */
641     WINHELP_OpenHelpWindow(HLPFILE_PageByMap, hlpfile, context,
642                            WINHELP_GetWindowInfo(hlpfile, lpszWindow),
643                            SW_NORMAL);
644 }
645
646 void CALLBACK MACRO_JumpHash(LPCSTR lpszPath, LPCSTR lpszWindow, LONG lHash)
647 {
648     HLPFILE*    hlpfile;
649
650     WINE_TRACE("(\"%s\", \"%s\", %u)\n", lpszPath, lpszWindow, lHash);
651     hlpfile = WINHELP_LookupHelpFile(lpszPath);
652     WINHELP_OpenHelpWindow(HLPFILE_PageByHash, hlpfile, lHash,
653                            WINHELP_GetWindowInfo(hlpfile, lpszWindow),
654                            SW_NORMAL);
655 }
656
657 void CALLBACK MACRO_JumpHelpOn(void)
658 {
659     WINE_FIXME("()\n");
660 }
661
662 void CALLBACK MACRO_JumpID(LPCSTR lpszPathWindow, LPCSTR topic_id)
663 {
664     LPSTR       ptr;
665
666     WINE_TRACE("(\"%s\", \"%s\")\n", lpszPathWindow, topic_id);
667     if ((ptr = strchr(lpszPathWindow, '>')) != NULL)
668     {
669         LPSTR   tmp;
670         size_t  sz = ptr - lpszPathWindow;
671
672         tmp = HeapAlloc(GetProcessHeap(), 0, sz + 1);
673         if (tmp)
674         {
675             memcpy(tmp, lpszPathWindow, sz);
676             tmp[sz] = '\0';
677             MACRO_JumpHash(tmp, ptr + 1, HLPFILE_Hash(topic_id));
678             HeapFree(GetProcessHeap(), 0, tmp);
679         }
680     }
681     else
682         MACRO_JumpHash(lpszPathWindow, NULL, HLPFILE_Hash(topic_id));
683 }
684
685 /* FIXME: this macros is wrong
686  * it should only contain 2 strings, path & window are coded as path>window
687  */
688 void CALLBACK MACRO_JumpKeyword(LPCSTR lpszPath, LPCSTR lpszWindow, LPCSTR keyword)
689 {
690     WINE_FIXME("(\"%s\", \"%s\", \"%s\")\n", lpszPath, lpszWindow, keyword);
691 }
692
693 void CALLBACK MACRO_KLink(LPCSTR str1, LONG u, LPCSTR str2, LPCSTR str3)
694 {
695     WINE_FIXME("(\"%s\", %u, \"%s\", \"%s\")\n", str1, u, str2, str3);
696 }
697
698 void CALLBACK MACRO_Menu(void)
699 {
700     WINE_FIXME("()\n");
701 }
702
703 void CALLBACK MACRO_MPrintHash(LONG u)
704 {
705     WINE_FIXME("(%u)\n", u);
706 }
707
708 void CALLBACK MACRO_MPrintID(LPCSTR str)
709 {
710     WINE_FIXME("(\"%s\")\n", str);
711 }
712
713 void CALLBACK MACRO_Next(void)
714 {
715     WINHELP_WNDPAGE     wp;
716
717     WINE_TRACE("()\n");
718     wp.page = Globals.active_win->page;
719     wp.page = HLPFILE_PageByOffset(wp.page->file, wp.page->browse_fwd, &wp.relative);
720     if (wp.page)
721     {
722         wp.page->file->wRefCount++;
723         wp.wininfo = Globals.active_win->info;
724         WINHELP_CreateHelpWindow(&wp, SW_NORMAL, TRUE);
725     }
726 }
727
728 void CALLBACK MACRO_NoShow(void)
729 {
730     WINE_FIXME("()\n");
731 }
732
733 void CALLBACK MACRO_PopupContext(LPCSTR str, LONG u)
734 {
735     WINE_FIXME("(\"%s\", %u)\n", str, u);
736 }
737
738 void CALLBACK MACRO_PopupHash(LPCSTR str, LONG u)
739 {
740     WINE_FIXME("(\"%s\", %u)\n", str, u);
741 }
742
743 void CALLBACK MACRO_PopupId(LPCSTR str1, LPCSTR str2)
744 {
745     WINE_FIXME("(\"%s\", \"%s\")\n", str1, str2);
746 }
747
748 void CALLBACK MACRO_PositionWindow(LONG i1, LONG i2, LONG u1, LONG u2, LONG u3, LPCSTR str)
749 {
750     WINE_FIXME("(%i, %i, %u, %u, %u, \"%s\")\n", i1, i2, u1, u2, u3, str);
751 }
752
753 void CALLBACK MACRO_Prev(void)
754 {
755     WINHELP_WNDPAGE     wp;
756
757     WINE_TRACE("()\n");
758     wp.page = Globals.active_win->page;
759     wp.page = HLPFILE_PageByOffset(wp.page->file, wp.page->browse_bwd, &wp.relative);
760     if (wp.page)
761     {
762         wp.page->file->wRefCount++;
763         wp.wininfo = Globals.active_win->info;
764         WINHELP_CreateHelpWindow(&wp, SW_NORMAL, TRUE);
765     }
766 }
767
768 void CALLBACK MACRO_Print(void)
769 {
770     PRINTDLG printer;
771
772     WINE_TRACE("()\n");
773
774     printer.lStructSize         = sizeof(printer);
775     printer.hwndOwner           = Globals.active_win->hMainWnd;
776     printer.hInstance           = Globals.hInstance;
777     printer.hDevMode            = 0;
778     printer.hDevNames           = 0;
779     printer.hDC                 = 0;
780     printer.Flags               = 0;
781     printer.nFromPage           = 0;
782     printer.nToPage             = 0;
783     printer.nMinPage            = 0;
784     printer.nMaxPage            = 0;
785     printer.nCopies             = 0;
786     printer.lCustData           = 0;
787     printer.lpfnPrintHook       = 0;
788     printer.lpfnSetupHook       = 0;
789     printer.lpPrintTemplateName = 0;
790     printer.lpSetupTemplateName = 0;
791     printer.hPrintTemplate      = 0;
792     printer.hSetupTemplate      = 0;
793
794     if (PrintDlgA(&printer)) {
795         WINE_FIXME("Print()\n");
796     }
797 }
798
799 void CALLBACK MACRO_PrinterSetup(void)
800 {
801     WINE_FIXME("()\n");
802 }
803
804 void CALLBACK MACRO_RegisterRoutine(LPCSTR dll_name, LPCSTR proc, LPCSTR args)
805 {
806     FARPROC             fn = NULL;
807     int                 size;
808     WINHELP_DLL*        dll;
809
810     WINE_TRACE("(\"%s\", \"%s\", \"%s\")\n", dll_name, proc, args);
811
812     /* FIXME: are the registered DLLs global or linked to the current file ???
813      * We assume globals (as we did for macros, but is this really the case ???)
814      */
815     for (dll = Globals.dlls; dll; dll = dll->next)
816     {
817         if (!strcmp(dll->name, dll_name)) break;
818     }
819     if (!dll)
820     {
821         HANDLE hLib = LoadLibrary(dll_name);
822
823         /* FIXME: the library will not be unloaded until exit of program 
824          * We don't send the DW_TERM message
825          */
826         WINE_TRACE("Loading %s\n", dll_name);
827         /* FIXME: should look in the directory where current hlpfile
828          * is loaded from
829          */
830         if (hLib == NULL)
831         {
832             /* FIXME: internationalisation for error messages */
833             WINE_FIXME("Cannot find dll %s\n", dll_name);
834         }
835         else if ((dll = HeapAlloc(GetProcessHeap(), 0, sizeof(*dll))))
836         {
837             dll->hLib = hLib;
838             dll->name = strdup(dll_name); /* FIXME */
839             dll->next = Globals.dlls;
840             Globals.dlls = dll;
841             dll->handler = (WINHELP_LDLLHandler)GetProcAddress(dll->hLib, "LDLLHandler");
842             dll->class = dll->handler ? (dll->handler)(DW_WHATMSG, 0, 0) : DC_NOMSG;
843             WINE_TRACE("Got class %x for DLL %s\n", dll->class, dll_name);
844             if (dll->class & DC_INITTERM) dll->handler(DW_INIT, 0, 0);
845             if (dll->class & DC_CALLBACKS) dll->handler(DW_CALLBACKS, (DWORD)Callbacks, 0);
846         }
847         else WINE_WARN("OOM\n");
848     }
849     if (dll && !(fn = GetProcAddress(dll->hLib, proc)))
850     {
851         /* FIXME: internationalisation for error messages */
852         WINE_FIXME("Cannot find proc %s in dll %s\n", dll_name, proc);
853     }
854
855     size = ++MACRO_NumLoaded * sizeof(struct MacroDesc);
856     if (!MACRO_Loaded) MACRO_Loaded = HeapAlloc(GetProcessHeap(), 0, size);
857     else MACRO_Loaded = HeapReAlloc(GetProcessHeap(), 0, MACRO_Loaded, size);
858     MACRO_Loaded[MACRO_NumLoaded - 1].name      = strdup(proc); /* FIXME */
859     MACRO_Loaded[MACRO_NumLoaded - 1].alias     = NULL;
860     MACRO_Loaded[MACRO_NumLoaded - 1].isBool    = 0;
861     MACRO_Loaded[MACRO_NumLoaded - 1].arguments = strdup(args); /* FIXME */
862     MACRO_Loaded[MACRO_NumLoaded - 1].fn        = fn;
863     WINE_TRACE("Added %s(%s) at %p\n", proc, args, fn);
864 }
865
866 void CALLBACK MACRO_RemoveAccelerator(LONG u1, LONG u2)
867 {
868     WINE_FIXME("(%u, %u)\n", u1, u2);
869 }
870
871 void CALLBACK MACRO_ResetMenu(void)
872 {
873     WINE_FIXME("()\n");
874 }
875
876 void CALLBACK MACRO_SaveMark(LPCSTR str)
877 {
878     WINE_FIXME("(\"%s\")\n", str);
879 }
880
881 void CALLBACK MACRO_Search(void)
882 {
883     WINE_FIXME("()\n");
884 }
885
886 void CALLBACK MACRO_SetContents(LPCSTR str, LONG u)
887 {
888     WINE_FIXME("(\"%s\", %u)\n", str, u);
889 }
890
891 void CALLBACK MACRO_SetHelpOnFile(LPCSTR str)
892 {
893     WINE_FIXME("(\"%s\")\n", str);
894 }
895
896 void CALLBACK MACRO_SetPopupColor(LONG u1, LONG u2, LONG u3)
897 {
898     WINE_FIXME("(%u, %u, %u)\n", u1, u2, u3);
899 }
900
901 void CALLBACK MACRO_ShellExecute(LPCSTR str1, LPCSTR str2, LONG u1, LONG u2, LPCSTR str3, LPCSTR str4)
902 {
903     WINE_FIXME("(\"%s\", \"%s\", %u, %u, \"%s\", \"%s\")\n", str1, str2, u1, u2, str3, str4);
904 }
905
906 void CALLBACK MACRO_ShortCut(LPCSTR str1, LPCSTR str2, LONG w, LONG l, LPCSTR str)
907 {
908     WINE_FIXME("(\"%s\", \"%s\", %x, %x, \"%s\")\n", str1, str2, w, l, str);
909 }
910
911 void CALLBACK MACRO_TCard(LONG u)
912 {
913     WINE_FIXME("(%u)\n", u);
914 }
915
916 void CALLBACK MACRO_Test(LONG u)
917 {
918     WINE_FIXME("(%u)\n", u);
919 }
920
921 BOOL CALLBACK MACRO_TestALink(LPCSTR str)
922 {
923     WINE_FIXME("(\"%s\")\n", str);
924     return FALSE;
925 }
926
927 BOOL CALLBACK MACRO_TestKLink(LPCSTR str)
928 {
929     WINE_FIXME("(\"%s\")\n", str);
930     return FALSE;
931 }
932
933 void CALLBACK MACRO_UncheckItem(LPCSTR str)
934 {
935     WINE_FIXME("(\"%s\")\n", str);
936 }
937
938 void CALLBACK MACRO_UpdateWindow(LPCSTR str1, LPCSTR str2)
939 {
940     WINE_FIXME("(\"%s\", \"%s\")\n", str1, str2);
941 }