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