?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
crypt32: Separate checking the tag of encoded bits from decoding the bits.
[wine/multimedia.git] / programs / winhlp32 / macro.c
blob7179dcaacface4017c06c3ae85eef80f44ec2409
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 }
Maarten's multimedia branch