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