?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msi: Don't define COND_SPACE twice.
[wine/multimedia.git] / programs / winhelp / macro.c
blob35b6ea6a347cdac1e623faae83874b1993acd50f
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, "SSS", (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("(%lu, %lu, \"%s\")\n", u1, u2, str);
200 }
201
202 void CALLBACK MACRO_ALink(LPCSTR str1, LONG u, LPCSTR str2)
203 {
204 WINE_FIXME("(\"%s\", %lu, \"%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->backIndex >= 2)
224 WINHELP_CreateHelpWindow(win->back[--win->backIndex - 1],
225 win->info, SW_SHOW);
226 }
227
228 void CALLBACK MACRO_BackFlush(void)
229 {
230 WINHELP_WINDOW* win = Globals.active_win;
231
232 WINE_TRACE("()\n");
233
234 if (win)
235 {
236 int i;
237
238 for (i = 0; i < win->backIndex; i++)
239 {
240 HLPFILE_FreeHlpFile(win->back[i]->file);
241 win->back[i] = NULL;
242 }
243 win->backIndex = 0;
244 }
245 }
246
247 void CALLBACK MACRO_BookmarkDefine(void)
248 {
249 WINE_FIXME("()\n");
250 }
251
252 void CALLBACK MACRO_BookmarkMore(void)
253 {
254 WINE_FIXME("()\n");
255 }
256
257 void CALLBACK MACRO_BrowseButtons(void)
258 {
259 WINE_TRACE("()\n");
260
261 MACRO_CreateButton("BTN_PREV", "&<<", "Prev()");
262 MACRO_CreateButton("BTN_NEXT", "&>>", "Next()");
263 }
264
265 void CALLBACK MACRO_ChangeButtonBinding(LPCSTR id, LPCSTR macro)
266 {
267 WINHELP_WINDOW* win = Globals.active_win;
268 WINHELP_BUTTON* button;
269 WINHELP_BUTTON** b;
270 LONG size;
271 LPSTR ptr;
272
273 WINE_TRACE("(\"%s\", \"%s\")\n", id, macro);
274
275 b = MACRO_LookupButton(win, id);
276 if (!*b) {WINE_FIXME("Couldn't find button '%s'\n", id); return;}
277
278 size = sizeof(WINHELP_BUTTON) + lstrlen(id) +
279 lstrlen((*b)->lpszName) + lstrlen(macro) + 3;
280
281 button = HeapAlloc(GetProcessHeap(), 0, size);
282 if (!button) return;
283
284 button->next = (*b)->next;
285 button->hWnd = (*b)->hWnd;
286 button->wParam = (*b)->wParam;
287
288 ptr = (char*)button + sizeof(WINHELP_BUTTON);
289
290 lstrcpy(ptr, id);
291 button->lpszID = ptr;
292 ptr += lstrlen(id) + 1;
293
294 lstrcpy(ptr, (*b)->lpszName);
295 button->lpszName = ptr;
296 ptr += lstrlen((*b)->lpszName) + 1;
297
298 lstrcpy(ptr, macro);
299 button->lpszMacro = ptr;
300
301 *b = button;
302
303 SendMessage(win->hMainWnd, WM_USER, 0, 0);
304 }
305
306 void CALLBACK MACRO_ChangeEnable(LPCSTR id, LPCSTR macro)
307 {
308 WINE_TRACE("(\"%s\", \"%s\")\n", id, macro);
309
310 MACRO_ChangeButtonBinding(id, macro);
311 MACRO_EnableButton(id);
312 }
313
314 void CALLBACK MACRO_ChangeItemBinding(LPCSTR str1, LPCSTR str2)
315 {
316 WINE_FIXME("(\"%s\", \"%s\")\n", str1, str2);
317 }
318
319 void CALLBACK MACRO_CheckItem(LPCSTR str)
320 {
321 WINE_FIXME("(\"%s\")\n", str);
322 }
323
324 void CALLBACK MACRO_CloseSecondarys(void)
325 {
326 WINHELP_WINDOW *win;
327
328 WINE_TRACE("()\n");
329 for (win = Globals.win_list; win; win = win->next)
330 if (win->lpszName && lstrcmpi(win->lpszName, "main"))
331 DestroyWindow(win->hMainWnd);
332 }
333
334 void CALLBACK MACRO_CloseWindow(LPCSTR lpszWindow)
335 {
336 WINHELP_WINDOW *win;
337
338 WINE_TRACE("(\"%s\")\n", lpszWindow);
339
340 if (!lpszWindow || !lpszWindow[0]) lpszWindow = "main";
341
342 for (win = Globals.win_list; win; win = win->next)
343 if (win->lpszName && !lstrcmpi(win->lpszName, lpszWindow))
344 DestroyWindow(win->hMainWnd);
345 }
346
347 void CALLBACK MACRO_Compare(LPCSTR str)
348 {
349 WINE_FIXME("(\"%s\")\n", str);
350 }
351
352 void CALLBACK MACRO_Contents(void)
353 {
354 WINE_TRACE("()\n");
355
356 if (Globals.active_win->page)
357 MACRO_JumpContents(Globals.active_win->page->file->lpszPath, NULL);
358 }
359
360 void CALLBACK MACRO_ControlPanel(LPCSTR str1, LPCSTR str2, LONG u)
361 {
362 WINE_FIXME("(\"%s\", \"%s\", %lu)\n", str1, str2, u);
363 }
364
365 void CALLBACK MACRO_CopyDialog(void)
366 {
367 WINE_FIXME("()\n");
368 }
369
370 void CALLBACK MACRO_CopyTopic(void)
371 {
372 WINE_FIXME("()\n");
373 }
374
375 void CALLBACK MACRO_CreateButton(LPCSTR id, LPCSTR name, LPCSTR macro)
376 {
377 WINHELP_WINDOW *win = Globals.active_win;
378 WINHELP_BUTTON *button, **b;
379 LONG size;
380 LPSTR ptr;
381
382 WINE_TRACE("(\"%s\", \"%s\", %s)\n", id, name, macro);
383
384 size = sizeof(WINHELP_BUTTON) + lstrlen(id) + lstrlen(name) + lstrlen(macro) + 3;
385
386 button = HeapAlloc(GetProcessHeap(), 0, size);
387 if (!button) return;
388
389 button->next = 0;
390 button->hWnd = 0;
391
392 ptr = (char*)button + sizeof(WINHELP_BUTTON);
393
394 lstrcpy(ptr, id);
395 button->lpszID = ptr;
396 ptr += lstrlen(id) + 1;
397
398 lstrcpy(ptr, name);
399 button->lpszName = ptr;
400 ptr += lstrlen(name) + 1;
401
402 lstrcpy(ptr, macro);
403 button->lpszMacro = ptr;
404
405 button->wParam = WH_FIRST_BUTTON;
406 for (b = &win->first_button; *b; b = &(*b)->next)
407 button->wParam = max(button->wParam, (*b)->wParam + 1);
408 *b = button;
409
410 SendMessage(win->hMainWnd, WM_USER, 0, 0);
411 }
412
413 void CALLBACK MACRO_DeleteItem(LPCSTR str)
414 {
415 WINE_FIXME("(\"%s\")\n", str);
416 }
417
418 void CALLBACK MACRO_DeleteMark(LPCSTR str)
419 {
420 WINE_FIXME("(\"%s\")\n", str);
421 }
422
423 void CALLBACK MACRO_DestroyButton(LPCSTR str)
424 {
425 WINE_FIXME("(\"%s\")\n", str);
426 }
427
428 void CALLBACK MACRO_DisableButton(LPCSTR id)
429 {
430 WINHELP_BUTTON** b;
431
432 WINE_FIXME("(\"%s\")\n", id);
433
434 b = MACRO_LookupButton(Globals.active_win, id);
435 if (!*b) {WINE_FIXME("Couldn't find button '%s'\n", id); return;}
436
437 EnableWindow((*b)->hWnd, FALSE);
438 }
439
440 void CALLBACK MACRO_DisableItem(LPCSTR str)
441 {
442 WINE_FIXME("(\"%s\")\n", str);
443 }
444
445 void CALLBACK MACRO_EnableButton(LPCSTR id)
446 {
447 WINHELP_BUTTON** b;
448
449 WINE_TRACE("(\"%s\")\n", id);
450
451 b = MACRO_LookupButton(Globals.active_win, id);
452 if (!*b) {WINE_FIXME("Couldn't find button '%s'\n", id); return;}
453
454 EnableWindow((*b)->hWnd, TRUE);
455 }
456
457 void CALLBACK MACRO_EnableItem(LPCSTR str)
458 {
459 WINE_FIXME("(\"%s\")\n", str);
460 }
461
462 void CALLBACK MACRO_EndMPrint(void)
463 {
464 WINE_FIXME("()\n");
465 }
466
467 void CALLBACK MACRO_ExecFile(LPCSTR str1, LPCSTR str2, LONG u, LPCSTR str3)
468 {
469 WINE_FIXME("(\"%s\", \"%s\", %lu, \"%s\")\n", str1, str2, u, str3);
470 }
471
472 void CALLBACK MACRO_ExecProgram(LPCSTR str, LONG u)
473 {
474 WINE_FIXME("(\"%s\", %lu)\n", str, u);
475 }
476
477 void CALLBACK MACRO_Exit(void)
478 {
479 WINE_TRACE("()\n");
480
481 while (Globals.win_list)
482 DestroyWindow(Globals.win_list->hMainWnd);
483 }
484
485 void CALLBACK MACRO_ExtAbleItem(LPCSTR str, LONG u)
486 {
487 WINE_FIXME("(\"%s\", %lu)\n", str, u);
488 }
489
490 void CALLBACK MACRO_ExtInsertItem(LPCSTR str1, LPCSTR str2, LPCSTR str3, LPCSTR str4, LONG u1, LONG u2)
491 {
492 WINE_FIXME("(\"%s\", \"%s\", \"%s\", \"%s\", %lu, %lu)\n", str1, str2, str3, str4, u1, u2);
493 }
494
495 void CALLBACK MACRO_ExtInsertMenu(LPCSTR str1, LPCSTR str2, LPCSTR str3, LONG u1, LONG u2)
496 {
497 WINE_FIXME("(\"%s\", \"%s\", \"%s\", %lu, %lu)\n", str1, str2, str3, u1, u2);
498 }
499
500 BOOL CALLBACK MACRO_FileExist(LPCSTR str)
501 {
502 WINE_TRACE("(\"%s\")\n", str);
503 return GetFileAttributes(str) != INVALID_FILE_ATTRIBUTES;
504 }
505
506 void CALLBACK MACRO_FileOpen(void)
507 {
508 OPENFILENAME openfilename;
509 CHAR szPath[MAX_PATHNAME_LEN];
510 CHAR szDir[MAX_PATHNAME_LEN];
511 CHAR szzFilter[2 * MAX_STRING_LEN + 100];
512 LPSTR p = szzFilter;
513
514 WINE_TRACE("()\n");
515
516 LoadString(Globals.hInstance, STID_HELP_FILES_HLP, p, MAX_STRING_LEN);
517 p += strlen(p) + 1;
518 lstrcpy(p, "*.hlp");
519 p += strlen(p) + 1;
520 LoadString(Globals.hInstance, STID_ALL_FILES, p, MAX_STRING_LEN);
521 p += strlen(p) + 1;
522 lstrcpy(p, "*.*");
523 p += strlen(p) + 1;
524 *p = '\0';
525
526 GetCurrentDirectory(sizeof(szDir), szDir);
527
528 szPath[0]='\0';
529
530 openfilename.lStructSize = sizeof(OPENFILENAME);
531 openfilename.hwndOwner = Globals.active_win->hMainWnd;
532 openfilename.hInstance = Globals.hInstance;
533 openfilename.lpstrFilter = szzFilter;
534 openfilename.lpstrCustomFilter = 0;
535 openfilename.nMaxCustFilter = 0;
536 openfilename.nFilterIndex = 1;
537 openfilename.lpstrFile = szPath;
538 openfilename.nMaxFile = sizeof(szPath);
539 openfilename.lpstrFileTitle = 0;
540 openfilename.nMaxFileTitle = 0;
541 openfilename.lpstrInitialDir = szDir;
542 openfilename.lpstrTitle = 0;
543 openfilename.Flags = 0;
544 openfilename.nFileOffset = 0;
545 openfilename.nFileExtension = 0;
546 openfilename.lpstrDefExt = 0;
547 openfilename.lCustData = 0;
548 openfilename.lpfnHook = 0;
549 openfilename.lpTemplateName = 0;
550
551 if (GetOpenFileName(&openfilename))
552 {
553 HLPFILE* hlpfile = WINHELP_LookupHelpFile(szPath);
554
555 WINHELP_CreateHelpWindowByHash(hlpfile, 0,
556 WINHELP_GetWindowInfo(hlpfile, "main"), SW_SHOWNORMAL);
557 }
558 }
559
560 void CALLBACK MACRO_Find(void)
561 {
562 WINE_FIXME("()\n");
563 }
564
565 void CALLBACK MACRO_Finder(void)
566 {
567 WINE_FIXME("()\n");
568 }
569
570 void CALLBACK MACRO_FloatingMenu(void)
571 {
572 WINE_FIXME("()\n");
573 }
574
575 void CALLBACK MACRO_Flush(void)
576 {
577 WINE_FIXME("()\n");
578 }
579
580 void CALLBACK MACRO_FocusWindow(LPCSTR lpszWindow)
581 {
582 WINHELP_WINDOW *win;
583
584 WINE_TRACE("(\"%s\")\n", lpszWindow);
585
586 if (!lpszWindow || !lpszWindow[0]) lpszWindow = "main";
587
588 for (win = Globals.win_list; win; win = win->next)
589 if (win->lpszName && !lstrcmpi(win->lpszName, lpszWindow))
590 SetFocus(win->hMainWnd);
591 }
592
593 void CALLBACK MACRO_Generate(LPCSTR str, LONG w, LONG l)
594 {
595 WINE_FIXME("(\"%s\", %lx, %lx)\n", str, w, l);
596 }
597
598 void CALLBACK MACRO_GotoMark(LPCSTR str)
599 {
600 WINE_FIXME("(\"%s\")\n", str);
601 }
602
603 void CALLBACK MACRO_HelpOn(void)
604 {
605 WINE_TRACE("()\n");
606 MACRO_JumpContents((Globals.wVersion > 4) ? "winhelp32.hlp" : "winhelp.hlp", NULL);
607 }
608
609 void CALLBACK MACRO_HelpOnTop(void)
610 {
611 WINE_FIXME("()\n");
612 }
613
614 void CALLBACK MACRO_History(void)
615 {
616 WINE_TRACE("()\n");
617
618 if (Globals.active_win && !Globals.active_win->hHistoryWnd)
619 {
620 HWND hWnd = CreateWindow(HISTORY_WIN_CLASS_NAME, "History", WS_OVERLAPPEDWINDOW,
621 0, 0, 0, 0, 0, 0, Globals.hInstance, Globals.active_win);
622 ShowWindow(hWnd, SW_NORMAL);
623 }
624 }
625
626 void CALLBACK MACRO_IfThen(BOOL b, LPCSTR t)
627 {
628 if (b) MACRO_ExecuteMacro(t);
629 }
630
631 void CALLBACK MACRO_IfThenElse(BOOL b, LPCSTR t, LPCSTR f)
632 {
633 if (b) MACRO_ExecuteMacro(t); else MACRO_ExecuteMacro(f);
634 }
635
636 BOOL CALLBACK MACRO_InitMPrint(void)
637 {
638 WINE_FIXME("()\n");
639 return FALSE;
640 }
641
642 void CALLBACK MACRO_InsertItem(LPCSTR str1, LPCSTR str2, LPCSTR str3, LPCSTR str4, LONG u)
643 {
644 WINE_FIXME("(\"%s\", \"%s\", \"%s\", \"%s\", %lu)\n", str1, str2, str3, str4, u);
645 }
646
647 void CALLBACK MACRO_InsertMenu(LPCSTR str1, LPCSTR str2, LONG u)
648 {
649 WINE_FIXME("(\"%s\", \"%s\", %lu)\n", str1, str2, u);
650 }
651
652 BOOL CALLBACK MACRO_IsBook(void)
653 {
654 WINE_TRACE("()\n");
655 return Globals.isBook;
656 }
657
658 BOOL CALLBACK MACRO_IsMark(LPCSTR str)
659 {
660 WINE_FIXME("(\"%s\")\n", str);
661 return FALSE;
662 }
663
664 BOOL CALLBACK MACRO_IsNotMark(LPCSTR str)
665 {
666 WINE_FIXME("(\"%s\")\n", str);
667 return TRUE;
668 }
669
670 void CALLBACK MACRO_JumpContents(LPCSTR lpszPath, LPCSTR lpszWindow)
671 {
672 HLPFILE* hlpfile;
673
674 WINE_TRACE("(\"%s\", \"%s\")\n", lpszPath, lpszWindow);
675 hlpfile = WINHELP_LookupHelpFile(lpszPath);
676 WINHELP_CreateHelpWindowByHash(hlpfile, 0,
677 WINHELP_GetWindowInfo(hlpfile, lpszWindow),
678 SW_NORMAL);
679 }
680
681 void CALLBACK MACRO_JumpContext(LPCSTR lpszPath, LPCSTR lpszWindow, LONG context)
682 {
683 WINE_FIXME("(\"%s\", \"%s\", %ld)semi-stub\n", lpszPath, lpszWindow, context);
684 return MACRO_JumpContents(lpszPath, lpszWindow);
685 }
686
687 void CALLBACK MACRO_JumpHash(LPCSTR lpszPath, LPCSTR lpszWindow, LONG lHash)
688 {
689 HLPFILE* hlpfile;
690
691 WINE_TRACE("(\"%s\", \"%s\", %lu)\n", lpszPath, lpszWindow, lHash);
692 hlpfile = WINHELP_LookupHelpFile(lpszPath);
693 WINHELP_CreateHelpWindowByHash(hlpfile, lHash,
694 WINHELP_GetWindowInfo(hlpfile, lpszWindow),
695 SW_NORMAL);
696 }
697
698 void CALLBACK MACRO_JumpHelpOn(void)
699 {
700 WINE_FIXME("()\n");
701 }
702
703 /* FIXME: those two macros are wrong
704 * they should only contain 2 strings, path & window are coded as path>window
705 */
706 void CALLBACK MACRO_JumpID(LPCSTR lpszPath, LPCSTR lpszWindow, LPCSTR topic_id)
707 {
708 WINE_TRACE("(\"%s\", \"%s\", \"%s\")\n", lpszPath, lpszWindow, topic_id);
709 MACRO_JumpHash(lpszPath, lpszWindow, HLPFILE_Hash(topic_id));
710 }
711
712 void CALLBACK MACRO_JumpKeyword(LPCSTR lpszPath, LPCSTR lpszWindow, LPCSTR keyword)
713 {
714 WINE_FIXME("(\"%s\", \"%s\", \"%s\")\n", lpszPath, lpszWindow, keyword);
715 }
716
717 void CALLBACK MACRO_KLink(LPCSTR str1, LONG u, LPCSTR str2, LPCSTR str3)
718 {
719 WINE_FIXME("(\"%s\", %lu, \"%s\", \"%s\")\n", str1, u, str2, str3);
720 }
721
722 void CALLBACK MACRO_Menu(void)
723 {
724 WINE_FIXME("()\n");
725 }
726
727 void CALLBACK MACRO_MPrintHash(LONG u)
728 {
729 WINE_FIXME("(%lu)\n", u);
730 }
731
732 void CALLBACK MACRO_MPrintID(LPCSTR str)
733 {
734 WINE_FIXME("(\"%s\")\n", str);
735 }
736
737 void CALLBACK MACRO_Next(void)
738 {
739 HLPFILE_PAGE* page;
740
741 WINE_TRACE("()\n");
742 page = Globals.active_win->page;
743 page = HLPFILE_PageByOffset(page->file, page->browse_fwd);
744 if (page)
745 {
746 page->file->wRefCount++;
747 WINHELP_CreateHelpWindow(page, Globals.active_win->info, SW_NORMAL);
748 }
749 }
750
751 void CALLBACK MACRO_NoShow(void)
752 {
753 WINE_FIXME("()\n");
754 }
755
756 void CALLBACK MACRO_PopupContext(LPCSTR str, LONG u)
757 {
758 WINE_FIXME("(\"%s\", %lu)\n", str, u);
759 }
760
761 void CALLBACK MACRO_PopupHash(LPCSTR str, LONG u)
762 {
763 WINE_FIXME("(\"%s\", %lu)\n", str, u);
764 }
765
766 void CALLBACK MACRO_PopupId(LPCSTR str1, LPCSTR str2)
767 {
768 WINE_FIXME("(\"%s\", \"%s\")\n", str1, str2);
769 }
770
771 void CALLBACK MACRO_PositionWindow(LONG i1, LONG i2, LONG u1, LONG u2, LONG u3, LPCSTR str)
772 {
773 WINE_FIXME("(%li, %li, %lu, %lu, %lu, \"%s\")\n", i1, i2, u1, u2, u3, str);
774 }
775
776 void CALLBACK MACRO_Prev(void)
777 {
778 HLPFILE_PAGE* page;
779
780 WINE_TRACE("()\n");
781 page = Globals.active_win->page;
782 page = HLPFILE_PageByOffset(page->file, page->browse_bwd);
783 if (page)
784 {
785 page->file->wRefCount++;
786 WINHELP_CreateHelpWindow(page, Globals.active_win->info, SW_NORMAL);
787 }
788 }
789
790 void CALLBACK MACRO_Print(void)
791 {
792 PRINTDLG printer;
793
794 WINE_TRACE("()\n");
795
796 printer.lStructSize = sizeof(printer);
797 printer.hwndOwner = Globals.active_win->hMainWnd;
798 printer.hInstance = Globals.hInstance;
799 printer.hDevMode = 0;
800 printer.hDevNames = 0;
801 printer.hDC = 0;
802 printer.Flags = 0;
803 printer.nFromPage = 0;
804 printer.nToPage = 0;
805 printer.nMinPage = 0;
806 printer.nMaxPage = 0;
807 printer.nCopies = 0;
808 printer.lCustData = 0;
809 printer.lpfnPrintHook = 0;
810 printer.lpfnSetupHook = 0;
811 printer.lpPrintTemplateName = 0;
812 printer.lpSetupTemplateName = 0;
813 printer.hPrintTemplate = 0;
814 printer.hSetupTemplate = 0;
815
816 if (PrintDlgA(&printer)) {
817 WINE_FIXME("Print()\n");
818 }
819 }
820
821 void CALLBACK MACRO_PrinterSetup(void)
822 {
823 WINE_FIXME("()\n");
824 }
825
826 void CALLBACK MACRO_RegisterRoutine(LPCSTR dll_name, LPCSTR proc, LPCSTR args)
827 {
828 FARPROC fn = NULL;
829 int size;
830 WINHELP_DLL* dll;
831
832 WINE_TRACE("(\"%s\", \"%s\", \"%s\")\n", dll_name, proc, args);
833
834 /* FIXME: are the registered DLLs global or linked to the current file ???
835 * We assume globals (as we did for macros, but is this really the case ???)
836 */
837 for (dll = Globals.dlls; dll; dll = dll->next)
838 {
839 if (!strcmp(dll->name, dll_name)) break;
840 }
841 if (!dll)
842 {
843 HANDLE hLib = LoadLibrary(dll_name);
844
845 /* FIXME: the library will not be unloaded until exit of program
846 * We don't send the DW_TERM message
847 */
848 WINE_TRACE("Loading %s\n", dll_name);
849 /* FIXME: should look in the directory where current hlpfile
850 * is loaded from
851 */
852 if (hLib == NULL)
853 {
854 /* FIXME: internationalisation for error messages */
855 WINE_FIXME("Cannot find dll %s\n", dll_name);
856 }
857 else if ((dll = HeapAlloc(GetProcessHeap(), 0, sizeof(*dll))))
858 {
859 dll->hLib = hLib;
860 dll->name = strdup(dll_name); /* FIXME */
861 dll->next = Globals.dlls;
862 Globals.dlls = dll;
863 dll->handler = (WINHELP_LDLLHandler)GetProcAddress(dll->hLib, "LDLLHandler");
864 dll->class = dll->handler ? (dll->handler)(DW_WHATMSG, 0, 0) : DC_NOMSG;
865 WINE_TRACE("Got class %lx for DLL %s\n", dll->class, dll_name);
866 if (dll->class & DC_INITTERM) dll->handler(DW_INIT, 0, 0);
867 if (dll->class & DC_CALLBACKS) dll->handler(DW_CALLBACKS, (DWORD)Callbacks, 0);
868 }
869 else WINE_WARN("OOM\n");
870 }
871 if (dll && !(fn = GetProcAddress(dll->hLib, proc)))
872 {
873 /* FIXME: internationalisation for error messages */
874 WINE_FIXME("Cannot find proc %s in dll %s\n", dll_name, proc);
875 }
876
877 size = ++MACRO_NumLoaded * sizeof(struct MacroDesc);
878 if (!MACRO_Loaded) MACRO_Loaded = HeapAlloc(GetProcessHeap(), 0, size);
879 else MACRO_Loaded = HeapReAlloc(GetProcessHeap(), 0, MACRO_Loaded, size);
880 MACRO_Loaded[MACRO_NumLoaded - 1].name = strdup(proc); /* FIXME */
881 MACRO_Loaded[MACRO_NumLoaded - 1].alias = NULL;
882 MACRO_Loaded[MACRO_NumLoaded - 1].isBool = 0;
883 MACRO_Loaded[MACRO_NumLoaded - 1].arguments = strdup(args); /* FIXME */
884 MACRO_Loaded[MACRO_NumLoaded - 1].fn = fn;
885 WINE_TRACE("Added %s(%s) at %p\n", proc, args, fn);
886 }
887
888 void CALLBACK MACRO_RemoveAccelerator(LONG u1, LONG u2)
889 {
890 WINE_FIXME("(%lu, %lu)\n", u1, u2);
891 }
892
893 void CALLBACK MACRO_ResetMenu(void)
894 {
895 WINE_FIXME("()\n");
896 }
897
898 void CALLBACK MACRO_SaveMark(LPCSTR str)
899 {
900 WINE_FIXME("(\"%s\")\n", str);
901 }
902
903 void CALLBACK MACRO_Search(void)
904 {
905 WINE_FIXME("()\n");
906 }
907
908 void CALLBACK MACRO_SetContents(LPCSTR str, LONG u)
909 {
910 WINE_FIXME("(\"%s\", %lu)\n", str, u);
911 }
912
913 void CALLBACK MACRO_SetHelpOnFile(LPCSTR str)
914 {
915 WINE_FIXME("(\"%s\")\n", str);
916 }
917
918 void CALLBACK MACRO_SetPopupColor(LONG u1, LONG u2, LONG u3)
919 {
920 WINE_FIXME("(%lu, %lu, %lu)\n", u1, u2, u3);
921 }
922
923 void CALLBACK MACRO_ShellExecute(LPCSTR str1, LPCSTR str2, LONG u1, LONG u2, LPCSTR str3, LPCSTR str4)
924 {
925 WINE_FIXME("(\"%s\", \"%s\", %lu, %lu, \"%s\", \"%s\")\n", str1, str2, u1, u2, str3, str4);
926 }
927
928 void CALLBACK MACRO_ShortCut(LPCSTR str1, LPCSTR str2, LONG w, LONG l, LPCSTR str)
929 {
930 WINE_FIXME("(\"%s\", \"%s\", %lx, %lx, \"%s\")\n", str1, str2, w, l, str);
931 }
932
933 void CALLBACK MACRO_TCard(LONG u)
934 {
935 WINE_FIXME("(%lu)\n", u);
936 }
937
938 void CALLBACK MACRO_Test(LONG u)
939 {
940 WINE_FIXME("(%lu)\n", u);
941 }
942
943 BOOL CALLBACK MACRO_TestALink(LPCSTR str)
944 {
945 WINE_FIXME("(\"%s\")\n", str);
946 return FALSE;
947 }
948
949 BOOL CALLBACK MACRO_TestKLink(LPCSTR str)
950 {
951 WINE_FIXME("(\"%s\")\n", str);
952 return FALSE;
953 }
954
955 void CALLBACK MACRO_UncheckItem(LPCSTR str)
956 {
957 WINE_FIXME("(\"%s\")\n", str);
958 }
959
960 void CALLBACK MACRO_UpdateWindow(LPCSTR str1, LPCSTR str2)
961 {
962 WINE_FIXME("(\"%s\", \"%s\")\n", str1, str2);
963 }
Maarten's multimedia branch