?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Change types of WPARAM, LPARAM and LRESULT according to MS SDK definitions.
[wine/multimedia.git] / programs / winhelp / hlpfile.c
blob7917989b09cfacb231734c9dc0955816846ce3d3
1 /*
2 * Help Viewer
3 *
4 * Copyright 1996 Ulrich Schmid
5 * 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 #include <string.h>
24 #include "winbase.h"
25 #include "wingdi.h"
26 #include "winuser.h"
27 #include "winhelp.h"
28
29 #include "wine/debug.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(winhelp);
32
33 static inline unsigned short GET_USHORT(const BYTE* buffer, unsigned i)
34 {
35 return (BYTE)buffer[i] + 0x100 * (BYTE)buffer[i + 1];
36 }
37
38 static inline short GET_SHORT(const BYTE* buffer, unsigned i)
39 {
40 return (BYTE)buffer[i] + 0x100 * (signed char)buffer[i+1];
41 }
42
43 static inline unsigned GET_UINT(const BYTE* buffer, unsigned i)
44 {
45 return GET_USHORT(buffer, i) + 0x10000 * GET_USHORT(buffer, i + 2);
46 }
47
48 static HLPFILE *first_hlpfile = 0;
49 static BYTE *file_buffer;
50
51 static struct
52 {
53 UINT num;
54 unsigned* offsets;
55 char* buffer;
56 } phrases;
57
58 static struct
59 {
60 BYTE** map;
61 BYTE* end;
62 UINT wMapLen;
63 } topic;
64
65 static struct
66 {
67 UINT wFont;
68 UINT wIndent;
69 UINT wHSpace;
70 UINT wVSpace;
71 HLPFILE_LINK* link;
72 } attributes;
73
74 static BOOL HLPFILE_DoReadHlpFile(HLPFILE*, LPCSTR);
75 static BOOL HLPFILE_ReadFileToBuffer(HFILE);
76 static BOOL HLPFILE_FindSubFile(LPCSTR name, BYTE**, BYTE**);
77 static BOOL HLPFILE_SystemCommands(HLPFILE*);
78 static INT HLPFILE_UncompressedLZ77_Size(BYTE *ptr, BYTE *end);
79 static BYTE* HLPFILE_UncompressLZ77(BYTE *ptr, BYTE *end, BYTE *newptr);
80 static BOOL HLPFILE_UncompressLZ77_Phrases(HLPFILE*);
81 static BOOL HLPFILE_Uncompress_Phrases40(HLPFILE*);
82 static BOOL HLPFILE_Uncompress_Topic(HLPFILE*);
83 static BOOL HLPFILE_GetContext(HLPFILE*);
84 static BOOL HLPFILE_AddPage(HLPFILE*, BYTE*, BYTE*, unsigned);
85 static BOOL HLPFILE_AddParagraph(HLPFILE*, BYTE *, BYTE*, unsigned*);
86 static void HLPFILE_Uncompress2(const BYTE*, const BYTE*, BYTE*, const BYTE*);
87 static BOOL HLPFILE_Uncompress3(char*, const char*, const BYTE*, const BYTE*);
88 static void HLPFILE_UncompressRLE(const BYTE* src, unsigned sz, BYTE** dst);
89 static BOOL HLPFILE_ReadFont(HLPFILE* hlpfile);
90
91 /***********************************************************************
92 *
93 * HLPFILE_PageByNumber
94 */
95 HLPFILE_PAGE *HLPFILE_PageByNumber(LPCSTR lpszPath, UINT wNum)
96 {
97 HLPFILE_PAGE *page;
98 HLPFILE *hlpfile = HLPFILE_ReadHlpFile(lpszPath);
99
100 if (!hlpfile) return 0;
101
102 WINE_TRACE("[%s/%u]\n", lpszPath, wNum);
103
104 for (page = hlpfile->first_page; page && wNum; page = page->next) wNum--;
105
106 /* HLPFILE_FreeHlpFile(lpszPath); */
107
108 return page;
109 }
110
111 /* FIXME:
112 * this finds the page containing the offset. The offset can either
113 * refer to the top of the page (offset == page->offset), or
114 * to some paragraph inside the page...
115 * As of today, we only return the page... we should also return
116 * a paragraph, and then, while opening a new page, compute the
117 * y-offset of the paragraph to be shown and scroll the window
118 * accordinly
119 */
120 /******************************************************************
121 * HLPFILE_PageByOffset
122 *
123 *
124 */
125 HLPFILE_PAGE *HLPFILE_PageByOffset(HLPFILE* hlpfile, LONG offset)
126 {
127 HLPFILE_PAGE* page;
128 HLPFILE_PAGE* found;
129
130 if (!hlpfile) return 0;
131
132 WINE_TRACE("<%s>[%lx]\n", hlpfile->lpszPath, offset);
133
134 if (offset == 0xFFFFFFFF) return NULL;
135 page = NULL;
136
137 for (found = NULL, page = hlpfile->first_page; page; page = page->next)
138 {
139 if (page->offset <= offset && (!found || found->offset < page->offset))
140 found = page;
141 }
142 if (!found)
143 WINE_ERR("Page of offset %lu not found in file %s\n",
144 offset, hlpfile->lpszPath);
145 return found;
146 }
147
148 /***********************************************************************
149 *
150 * HLPFILE_HlpFilePageByHash
151 */
152 HLPFILE_PAGE *HLPFILE_PageByHash(HLPFILE* hlpfile, LONG lHash)
153 {
154 int i;
155
156 if (!hlpfile) return 0;
157
158 WINE_TRACE("<%s>[%lx]\n", hlpfile->lpszPath, lHash);
159
160 for (i = 0; i < hlpfile->wContextLen; i++)
161 {
162 if (hlpfile->Context[i].lHash == lHash)
163 return HLPFILE_PageByOffset(hlpfile, hlpfile->Context[i].offset);
164 }
165
166 WINE_ERR("Page of hash %lx not found in file %s\n", lHash, hlpfile->lpszPath);
167 return NULL;
168 }
169
170 /***********************************************************************
171 *
172 * HLPFILE_Contents
173 */
174 HLPFILE_PAGE* HLPFILE_Contents(HLPFILE *hlpfile)
175 {
176 HLPFILE_PAGE* page = NULL;
177
178 if (!hlpfile) return NULL;
179
180 page = HLPFILE_PageByOffset(hlpfile, hlpfile->contents_start);
181 if (!page) page = hlpfile->first_page;
182 return page;
183 }
184
185 /***********************************************************************
186 *
187 * HLPFILE_Hash
188 */
189 LONG HLPFILE_Hash(LPCSTR lpszContext)
190 {
191 LONG lHash = 0;
192 CHAR c;
193
194 while ((c = *lpszContext++))
195 {
196 CHAR x = 0;
197 if (c >= 'A' && c <= 'Z') x = c - 'A' + 17;
198 if (c >= 'a' && c <= 'z') x = c - 'a' + 17;
199 if (c >= '1' && c <= '9') x = c - '0';
200 if (c == '0') x = 10;
201 if (c == '.') x = 12;
202 if (c == '_') x = 13;
203 if (x) lHash = lHash * 43 + x;
204 }
205 return lHash;
206 }
207
208 /***********************************************************************
209 *
210 * HLPFILE_ReadHlpFile
211 */
212 HLPFILE *HLPFILE_ReadHlpFile(LPCSTR lpszPath)
213 {
214 HLPFILE* hlpfile;
215
216 for (hlpfile = first_hlpfile; hlpfile; hlpfile = hlpfile->next)
217 {
218 if (!strcmp(lpszPath, hlpfile->lpszPath))
219 {
220 hlpfile->wRefCount++;
221 return hlpfile;
222 }
223 }
224
225 hlpfile = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE) + lstrlen(lpszPath) + 1);
226 if (!hlpfile) return 0;
227
228 hlpfile->lpszPath = (char*)hlpfile + sizeof(HLPFILE);
229 hlpfile->lpszTitle = NULL;
230 hlpfile->lpszCopyright = NULL;
231 hlpfile->first_page = NULL;
232 hlpfile->first_macro = NULL;
233 hlpfile->wContextLen = 0;
234 hlpfile->Context = NULL;
235 hlpfile->contents_start = 0xFFFFFFFF;
236 hlpfile->prev = NULL;
237 hlpfile->next = first_hlpfile;
238 hlpfile->wRefCount = 1;
239
240 hlpfile->numBmps = 0;
241 hlpfile->bmps = NULL;
242
243 hlpfile->numFonts = 0;
244 hlpfile->fonts = NULL;
245
246 hlpfile->numWindows = 0;
247 hlpfile->windows = NULL;
248
249 strcpy(hlpfile->lpszPath, lpszPath);
250
251 first_hlpfile = hlpfile;
252 if (hlpfile->next) hlpfile->next->prev = hlpfile;
253
254 phrases.offsets = NULL;
255 phrases.buffer = NULL;
256 topic.map = NULL;
257 topic.end = NULL;
258 file_buffer = NULL;
259
260 if (!HLPFILE_DoReadHlpFile(hlpfile, lpszPath))
261 {
262 HLPFILE_FreeHlpFile(hlpfile);
263 hlpfile = 0;
264 }
265
266 if (phrases.offsets) HeapFree(GetProcessHeap(), 0, phrases.offsets);
267 if (phrases.buffer) HeapFree(GetProcessHeap(), 0, phrases.buffer);
268 if (topic.map) HeapFree(GetProcessHeap(), 0, topic.map);
269 if (file_buffer) HeapFree(GetProcessHeap(), 0, file_buffer);
270
271 return hlpfile;
272 }
273
274 /***********************************************************************
275 *
276 * HLPFILE_DoReadHlpFile
277 */
278 static BOOL HLPFILE_DoReadHlpFile(HLPFILE *hlpfile, LPCSTR lpszPath)
279 {
280 BOOL ret;
281 HFILE hFile;
282 OFSTRUCT ofs;
283 BYTE* buf;
284 DWORD ref = 0x0C;
285 unsigned index, old_index, offset, len, offs;
286
287 hFile = OpenFile(lpszPath, &ofs, OF_READ | OF_SEARCH);
288 if (hFile == HFILE_ERROR) return FALSE;
289
290 ret = HLPFILE_ReadFileToBuffer(hFile);
291 _lclose(hFile);
292 if (!ret) return FALSE;
293
294 if (!HLPFILE_SystemCommands(hlpfile)) return FALSE;
295
296 /* load phrases support */
297 if (!HLPFILE_UncompressLZ77_Phrases(hlpfile))
298 HLPFILE_Uncompress_Phrases40(hlpfile);
299
300 if (!HLPFILE_Uncompress_Topic(hlpfile)) return FALSE;
301 if (!HLPFILE_ReadFont(hlpfile)) return FALSE;
302
303 buf = topic.map[0];
304 old_index = -1;
305 offs = 0;
306 do
307 {
308 BYTE* end;
309
310 /* FIXME this depends on the blocksize, can be 2k in some cases */
311 index = (ref - 0x0C) >> 14;
312 offset = (ref - 0x0C) & 0x3fff;
313
314 WINE_TRACE("ref=%08lx => [%u/%u]\n", ref, index, offset);
315
316 if (index >= topic.wMapLen) {WINE_WARN("maplen\n"); break;}
317 buf = topic.map[index] + offset;
318 if (buf + 0x15 >= topic.end) {WINE_WARN("extra\n"); break;}
319 end = min(buf + GET_UINT(buf, 0), topic.end);
320 if (index != old_index) {offs = 0; old_index = index;}
321
322 switch (buf[0x14])
323 {
324 case 0x02:
325 if (!HLPFILE_AddPage(hlpfile, buf, end, index * 0x8000L + offs)) return FALSE;
326 break;
327
328 case 0x20:
329 if (!HLPFILE_AddParagraph(hlpfile, buf, end, &len)) return FALSE;
330 offs += len;
331 break;
332
333 case 0x23:
334 if (!HLPFILE_AddParagraph(hlpfile, buf, end, &len)) return FALSE;
335 offs += len;
336 break;
337
338 default:
339 WINE_ERR("buf[0x14] = %x\n", buf[0x14]);
340 }
341
342 ref = GET_UINT(buf, 0xc);
343 } while (ref != 0xffffffff);
344
345 return HLPFILE_GetContext(hlpfile);
346 }
347
348 /***********************************************************************
349 *
350 * HLPFILE_AddPage
351 */
352 static BOOL HLPFILE_AddPage(HLPFILE *hlpfile, BYTE *buf, BYTE *end, unsigned offset)
353 {
354 HLPFILE_PAGE* page;
355 BYTE* title;
356 UINT titlesize;
357 char* ptr;
358 HLPFILE_MACRO*macro;
359
360 if (buf + 0x31 > end) {WINE_WARN("page1\n"); return FALSE;};
361 title = buf + GET_UINT(buf, 0x10);
362 if (title > end) {WINE_WARN("page2\n"); return FALSE;};
363
364 titlesize = GET_UINT(buf, 4);
365 page = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_PAGE) + titlesize + 1);
366 if (!page) return FALSE;
367 page->lpszTitle = (char*)page + sizeof(HLPFILE_PAGE);
368
369 if (hlpfile->hasPhrases)
370 {
371 HLPFILE_Uncompress2(title, end, page->lpszTitle, page->lpszTitle + titlesize);
372 }
373 else
374 {
375 if (GET_UINT(buf, 0x4) > GET_UINT(buf, 0) - GET_UINT(buf, 0x10))
376 {
377 /* need to decompress */
378 HLPFILE_Uncompress3(page->lpszTitle, page->lpszTitle + titlesize,
379 title, end);
380 }
381 else
382 {
383 memcpy(page->lpszTitle, title, titlesize);
384 }
385 }
386
387 page->lpszTitle[titlesize] = '\0';
388
389 if (hlpfile->first_page)
390 {
391 HLPFILE_PAGE *p;
392
393 for (p = hlpfile->first_page; p->next; p = p->next);
394 page->prev = p;
395 p->next = page;
396 }
397 else
398 {
399 hlpfile->first_page = page;
400 page->prev = NULL;
401 }
402
403 page->file = hlpfile;
404 page->next = NULL;
405 page->first_paragraph = NULL;
406 page->first_macro = NULL;
407 page->wNumber = GET_UINT(buf, 0x21);
408 page->offset = offset;
409
410 page->browse_bwd = GET_UINT(buf, 0x19);
411 page->browse_fwd = GET_UINT(buf, 0x1D);
412
413 WINE_TRACE("Added page[%d]: title='%s' %08lx << %08x >> %08lx\n",
414 page->wNumber, page->lpszTitle,
415 page->browse_bwd, page->offset, page->browse_fwd);
416
417 memset(&attributes, 0, sizeof(attributes));
418
419 /* now load macros */
420 ptr = page->lpszTitle + strlen(page->lpszTitle) + 1;
421 while (ptr < page->lpszTitle + titlesize)
422 {
423 unsigned len = strlen(ptr);
424 WINE_TRACE("macro: %s\n", ptr);
425 macro = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_MACRO) + len + 1);
426 macro->lpszMacro = (char*)(macro + 1);
427 memcpy((char*)macro->lpszMacro, ptr, len + 1);
428 /* FIXME: shall we really link macro in reverse order ??
429 * may produce strange results when played at page opening
430 */
431 macro->next = page->first_macro;
432 page->first_macro = macro;
433 ptr += len + 1;
434 }
435
436 return TRUE;
437 }
438
439 static long fetch_long(BYTE** ptr)
440 {
441 long ret;
442
443 if (*(*ptr) & 1)
444 {
445 ret = (*(unsigned long*)(*ptr) - 0x80000000L) / 2;
446 (*ptr) += 4;
447 }
448 else
449 {
450 ret = (*(unsigned short*)(*ptr) - 0x8000) / 2;
451 (*ptr) += 2;
452 }
453
454 return ret;
455 }
456
457 static unsigned long fetch_ulong(BYTE** ptr)
458 {
459 unsigned long ret;
460
461 if (*(*ptr) & 1)
462 {
463 ret = *(unsigned long*)(*ptr) / 2;
464 (*ptr) += 4;
465 }
466 else
467 {
468 ret = *(unsigned short*)(*ptr) / 2;
469 (*ptr) += 2;
470 }
471 return ret;
472 }
473
474 static short fetch_short(BYTE** ptr)
475 {
476 short ret;
477
478 if (*(*ptr) & 1)
479 {
480 ret = (*(unsigned short*)(*ptr) - 0x8000) / 2;
481 (*ptr) += 2;
482 }
483 else
484 {
485 ret = (*(unsigned char*)(*ptr) - 0x80) / 2;
486 (*ptr)++;
487 }
488 return ret;
489 }
490
491 static unsigned short fetch_ushort(BYTE** ptr)
492 {
493 unsigned short ret;
494
495 if (*(*ptr) & 1)
496 {
497 ret = *(unsigned short*)(*ptr) / 2;
498 (*ptr) += 2;
499 }
500 else
501 {
502 ret = *(unsigned char*)(*ptr) / 2;
503 (*ptr)++;
504 }
505 return ret;
506 }
507
508 /******************************************************************
509 * HLPFILE_DecompressGfx
510 *
511 * Decompress the data part of a bitmap or a metafile
512 */
513 static BYTE* HLPFILE_DecompressGfx(BYTE* src, unsigned csz, unsigned sz, BYTE packing)
514 {
515 BYTE* dst;
516 BYTE* tmp;
517 BYTE* tmp2;
518 unsigned sz77;
519
520 WINE_TRACE("Unpacking (%d) from %u bytes to %u bytes\n", packing, csz, sz);
521
522 switch (packing)
523 {
524 case 0: /* uncompressed */
525 if (sz != csz)
526 WINE_WARN("Bogus gfx sizes: %u / %u\n", sz, csz);
527 dst = src;
528 break;
529 case 1: /* RunLen */
530 tmp = dst = HeapAlloc(GetProcessHeap(), 0, sz);
531 if (!dst) return NULL;
532 HLPFILE_UncompressRLE(src, csz, &tmp);
533 if (tmp - dst != sz)
534 WINE_FIXME("Bogus gfx sizes: %u/%u\n", tmp - dst, sz);
535 break;
536 case 2: /* LZ77 */
537 sz77 = HLPFILE_UncompressedLZ77_Size(src, src + csz);
538 dst = HeapAlloc(GetProcessHeap(), 0, sz77);
539 if (!dst) return NULL;
540 HLPFILE_UncompressLZ77(src, src + csz, dst);
541 if (sz77 != sz)
542 WINE_WARN("Bogus gfx sizes: %u / %u\n", sz77, sz);
543 break;
544 case 3: /* LZ77 then RLE */
545 sz77 = HLPFILE_UncompressedLZ77_Size(src, src + csz);
546 tmp = HeapAlloc(GetProcessHeap(), 0, sz/*sz77*/);
547 if (!tmp) return FALSE;
548 HLPFILE_UncompressLZ77(src, src + csz, tmp);
549 dst = tmp2 = HeapAlloc(GetProcessHeap(), 0, sz);
550 if (!dst) return FALSE;
551 HLPFILE_UncompressRLE(tmp, sz77, &tmp2);
552 if (tmp2 - dst != sz)
553 WINE_WARN("Bogus gfx: %u / %u\n", tmp2 - dst, sz);
554 HeapFree(GetProcessHeap(), 0, tmp);
555 break;
556 default:
557 WINE_FIXME("Unsupported packing %u\n", packing);
558 return NULL;
559 }
560 return dst;
561 }
562
563 /******************************************************************
564 * HLPFILE_LoadBitmap
565 *
566 *
567 */
568 static BOOL HLPFILE_LoadBitmap(BYTE* beg, BYTE type, BYTE pack,
569 HLPFILE_PARAGRAPH* paragraph)
570 {
571 BYTE* ptr;
572 BYTE* pict_beg;
573 BITMAPINFO* bi;
574 unsigned long off, csz;
575 HDC hdc;
576
577 bi = HeapAlloc(GetProcessHeap(), 0, sizeof(*bi));
578 if (!bi) return FALSE;
579
580 ptr = beg + 2; /* for type and pack */
581
582 bi->bmiHeader.biSize = sizeof(bi->bmiHeader);
583 bi->bmiHeader.biXPelsPerMeter = fetch_ulong(&ptr);
584 bi->bmiHeader.biYPelsPerMeter = fetch_ulong(&ptr);
585 bi->bmiHeader.biPlanes = fetch_ushort(&ptr);
586 bi->bmiHeader.biBitCount = fetch_ushort(&ptr);
587 bi->bmiHeader.biWidth = fetch_ulong(&ptr);
588 bi->bmiHeader.biHeight = fetch_ulong(&ptr);
589 bi->bmiHeader.biClrUsed = fetch_ulong(&ptr);
590 bi->bmiHeader.biClrImportant = fetch_ulong(&ptr);
591 bi->bmiHeader.biCompression = BI_RGB;
592 if (bi->bmiHeader.biBitCount > 32) WINE_FIXME("Unknown bit count %u\n", bi->bmiHeader.biBitCount);
593 if (bi->bmiHeader.biPlanes != 1) WINE_FIXME("Unsupported planes %u\n", bi->bmiHeader.biPlanes);
594 bi->bmiHeader.biSizeImage = (((bi->bmiHeader.biWidth * bi->bmiHeader.biBitCount + 31) & ~31) / 8) * bi->bmiHeader.biHeight;
595
596 csz = fetch_ulong(&ptr);
597 fetch_ulong(&ptr); /* hotspot size */
598
599 off = GET_UINT(ptr, 0); ptr += 4;
600 /* GET_UINT(ptr, 0); hotspot offset */ ptr += 4;
601
602 /* now read palette info */
603 if (type == 0x06)
604 {
605 unsigned nc = bi->bmiHeader.biClrUsed;
606 unsigned i;
607
608 /* not quite right, especially for bitfields type of compression */
609 if (!nc && bi->bmiHeader.biBitCount <= 8)
610 nc = 1 << bi->bmiHeader.biBitCount;
611
612 bi = HeapReAlloc(GetProcessHeap(), 0, bi, sizeof(*bi) + nc * sizeof(RGBQUAD));
613 if (!bi) return FALSE;
614 for (i = 0; i < nc; i++)
615 {
616 bi->bmiColors[i].rgbBlue = ptr[0];
617 bi->bmiColors[i].rgbGreen = ptr[1];
618 bi->bmiColors[i].rgbRed = ptr[2];
619 bi->bmiColors[i].rgbReserved = 0;
620 ptr += 4;
621 }
622 }
623 pict_beg = HLPFILE_DecompressGfx(beg + off, csz, bi->bmiHeader.biSizeImage, pack);
624
625 paragraph->u.gfx.u.bmp.hBitmap = CreateDIBitmap(hdc = GetDC(0), &bi->bmiHeader,
626 CBM_INIT, pict_beg,
627 bi, DIB_RGB_COLORS);
628 ReleaseDC(0, hdc);
629 if (!paragraph->u.gfx.u.bmp.hBitmap)
630 WINE_ERR("Couldn't create bitmap\n");
631
632 HeapFree(GetProcessHeap(), 0, bi);
633 if (pict_beg != beg + off) HeapFree(GetProcessHeap(), 0, pict_beg);
634
635 return TRUE;
636 }
637
638 /******************************************************************
639 * HLPFILE_LoadMetaFile
640 *
641 *
642 */
643 static BOOL HLPFILE_LoadMetaFile(BYTE* beg, BYTE pack, HLPFILE_PARAGRAPH* paragraph)
644 {
645 BYTE* ptr;
646 unsigned long size, csize;
647 unsigned long off, hsoff;
648 BYTE* bits;
649 METAFILEPICT mfp;
650
651 WINE_TRACE("Loading metafile\n");
652
653 ptr = beg + 2; /* for type and pack */
654
655 mfp.mm = fetch_ushort(&ptr); /* mapping mode */
656
657 mfp.xExt = GET_USHORT(ptr, 0);
658 mfp.yExt = GET_USHORT(ptr, 2);
659 ptr += 4;
660
661 size = fetch_ulong(&ptr); /* decompressed size */
662 csize = fetch_ulong(&ptr); /* compressed size */
663 fetch_ulong(&ptr); /* hotspot size */
664 off = GET_UINT(ptr, 0);
665 hsoff = GET_UINT(ptr, 4);
666 ptr += 8;
667
668 WINE_FIXME("sz=%lu csz=%lu (%ld,%ld) offs=%lu/%u,%lu\n",
669 size, csize, mfp.xExt, mfp.yExt, off, ptr - beg, hsoff);
670
671 bits = HLPFILE_DecompressGfx(beg + off, csize, size, pack);
672 if (!bits) return FALSE;
673
674 paragraph->cookie = para_metafile;
675
676 mfp.hMF = NULL;
677
678 paragraph->u.gfx.u.mf.hMetaFile = SetMetaFileBitsEx(size, bits);
679
680 if (!paragraph->u.gfx.u.mf.hMetaFile)
681 WINE_FIXME("Couldn't load metafile\n");
682
683 if (bits != beg + off) HeapFree(GetProcessHeap(), 0, bits);
684
685 paragraph->u.gfx.u.mf.mfSize.cx = mfp.xExt;
686 paragraph->u.gfx.u.mf.mfSize.cy = mfp.yExt;
687
688 return TRUE;
689 }
690
691 /******************************************************************
692 * HLPFILE_LoadGfxByAddr
693 *
694 *
695 */
696 static BOOL HLPFILE_LoadGfxByAddr(HLPFILE *hlpfile, BYTE* ref,
697 unsigned long size,
698 HLPFILE_PARAGRAPH* paragraph)
699 {
700 unsigned i, numpict;
701
702 numpict = GET_USHORT(ref, 2);
703 WINE_TRACE("Got picture magic=%04x #=%d\n",
704 GET_USHORT(ref, 0), numpict);
705
706 for (i = 0; i < numpict; i++)
707 {
708 BYTE* beg;
709 BYTE* ptr;
710 BYTE type, pack;
711
712 WINE_TRACE("Offset[%d] = %x\n", i, GET_UINT(ref, (1 + i) * 4));
713 beg = ptr = ref + GET_UINT(ref, (1 + i) * 4);
714
715 type = *ptr++;
716 pack = *ptr++;
717
718 switch (type)
719 {
720 case 5: /* device dependent bmp */
721 case 6: /* device independent bmp */
722 HLPFILE_LoadBitmap(beg, type, pack, paragraph);
723 break;
724 case 8:
725 HLPFILE_LoadMetaFile(beg, pack, paragraph);
726 break;
727 default: WINE_FIXME("Unknown type %u\n", type); return FALSE;
728 }
729
730 /* FIXME: hotspots */
731
732 /* FIXME: implement support for multiple picture format */
733 if (numpict != 1) WINE_FIXME("Supporting only one bitmap format per logical bitmap (for now). Using first format\n");
734 break;
735 }
736 return TRUE;
737 }
738
739 /******************************************************************
740 * HLPFILE_LoadGfxByIndex
741 *
742 *
743 */
744 static BOOL HLPFILE_LoadGfxByIndex(HLPFILE *hlpfile, unsigned index,
745 HLPFILE_PARAGRAPH* paragraph)
746 {
747 char tmp[16];
748 BYTE *ref, *end;
749 BOOL ret;
750
751 WINE_TRACE("Loading picture #%d\n", index);
752
753 if (index < hlpfile->numBmps && hlpfile->bmps[index] != NULL)
754 {
755 paragraph->u.gfx.u.bmp.hBitmap = hlpfile->bmps[index];
756 return TRUE;
757 }
758
759 sprintf(tmp, "|bm%u", index);
760
761 if (!HLPFILE_FindSubFile(tmp, &ref, &end)) {WINE_WARN("no sub file\n"); return FALSE;}
762
763 ref += 9;
764
765 ret = HLPFILE_LoadGfxByAddr(hlpfile, ref, end - ref, paragraph);
766
767 /* cache bitmap */
768 if (ret && paragraph->cookie == para_bitmap)
769 {
770 if (index >= hlpfile->numBmps)
771 {
772 hlpfile->numBmps = index + 1;
773 hlpfile->bmps = HeapReAlloc(GetProcessHeap(), 0, hlpfile->bmps,
774 hlpfile->numBmps * sizeof(hlpfile->bmps[0]));
775 }
776 hlpfile->bmps[index] = paragraph->u.gfx.u.bmp.hBitmap;
777 }
778 return ret;
779 }
780
781 /******************************************************************
782 * HLPFILE_AllocLink
783 *
784 *
785 */
786 static HLPFILE_LINK* HLPFILE_AllocLink(int cookie, const char* str, LONG hash,
787 BOOL clrChange, unsigned wnd)
788 {
789 HLPFILE_LINK* link;
790
791 /* FIXME: should build a string table for the attributes.link.lpszPath
792 * they are reallocated for each link
793 */
794 link = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_LINK) + strlen(str) + 1);
795 if (!link) return NULL;
796
797 link->cookie = cookie;
798 link->lpszString = (char*)link + sizeof(HLPFILE_LINK);
799 strcpy((char*)link->lpszString, str);
800 link->lHash = hash;
801 link->bClrChange = clrChange ? 1 : 0;
802 link->window = wnd;
803 link->wRefCount = 1;
804
805 WINE_TRACE("Link[%d] to %s@%08lx:%d\n",
806 link->cookie, link->lpszString,
807 link->lHash, link->window);
808 return link;
809 }
810
811 /***********************************************************************
812 *
813 * HLPFILE_AddParagraph
814 */
815 static BOOL HLPFILE_AddParagraph(HLPFILE *hlpfile, BYTE *buf, BYTE *end, unsigned* len)
816 {
817 HLPFILE_PAGE *page;
818 HLPFILE_PARAGRAPH *paragraph, **paragraphptr;
819 UINT textsize;
820 BYTE *format, *format_end, *text, *text_end;
821 long size;
822 unsigned short bits;
823 unsigned nc, ncol = 1;
824
825 if (!hlpfile->first_page) {WINE_WARN("no page\n"); return FALSE;};
826
827 for (page = hlpfile->first_page; page->next; page = page->next) /* Nothing */;
828 for (paragraphptr = &page->first_paragraph; *paragraphptr;
829 paragraphptr = &(*paragraphptr)->next) /* Nothing */;
830
831 if (buf + 0x19 > end) {WINE_WARN("header too small\n"); return FALSE;};
832
833 size = GET_UINT(buf, 0x4);
834 text = HeapAlloc(GetProcessHeap(), 0, size);
835 if (!text) return FALSE;
836 if (hlpfile->hasPhrases)
837 {
838 HLPFILE_Uncompress2(buf + GET_UINT(buf, 0x10), end, text, text + size);
839 }
840 else
841 {
842 if (GET_UINT(buf, 0x4) > GET_UINT(buf, 0) - GET_UINT(buf, 0x10))
843 {
844 /* block is compressed */
845 HLPFILE_Uncompress3(text, text + size, buf + GET_UINT(buf, 0x10), end);
846 }
847 else
848 {
849 text = buf + GET_UINT(buf, 0x10);
850 }
851 }
852 text_end = text + size;
853
854 format = buf + 0x15;
855 format_end = buf + GET_UINT(buf, 0x10);
856
857 fetch_long(&format);
858 *len = fetch_ushort(&format);
859
860 if (buf[0x14] == 0x23)
861 {
862 char type;
863
864 ncol = *format++;
865
866 WINE_TRACE("#cols %u\n", ncol);
867 type = *format++;
868 if (type == 0 || type == 2)
869 format += 2;
870 format += ncol * 4;
871 }
872
873 for (nc = 0; nc < ncol; nc++)
874 {
875 WINE_TRACE("looking for format at offset %u for column %d\n", format - (buf + 0x15), nc);
876 if (buf[0x14] == 0x23)
877 format += 5;
878 format += 4;
879 bits = GET_USHORT(format, 0); format += 2;
880 if (bits & 0x0001) fetch_long(&format);
881 if (bits & 0x0002) fetch_short(&format);
882 if (bits & 0x0004) fetch_short(&format);
883 if (bits & 0x0008) fetch_short(&format);
884 if (bits & 0x0010) fetch_short(&format);
885 if (bits & 0x0020) fetch_short(&format);
886 if (bits & 0x0040) fetch_short(&format);
887 if (bits & 0x0100) format += 3;
888 if (bits & 0x0200)
889 {
890 int ntab = fetch_short(&format);
891 unsigned short ts;
892
893 while (ntab-- > 0)
894 {
895 ts = fetch_ushort(&format);
896 if (ts & 0x4000) fetch_ushort(&format);
897 }
898 }
899 /* 0x0400, 0x0800 and 0x1000 don't need space */
900 if ((bits & 0xE080) != 0)
901 WINE_FIXME("Unsupported bits %04x, potential trouble ahead\n", bits);
902
903 while (text < text_end && format < format_end)
904 {
905 WINE_TRACE("Got text: '%s' (%p/%p - %p/%p)\n", text, text, text_end, format, format_end);
906 textsize = strlen(text) + 1;
907 if (textsize > 1)
908 {
909 paragraph = HeapAlloc(GetProcessHeap(), 0,
910 sizeof(HLPFILE_PARAGRAPH) + textsize);
911 if (!paragraph) return FALSE;
912 *paragraphptr = paragraph;
913 paragraphptr = &paragraph->next;
914
915 paragraph->next = NULL;
916 paragraph->link = attributes.link;
917 if (paragraph->link) paragraph->link->wRefCount++;
918 paragraph->cookie = para_normal_text;
919 paragraph->u.text.wFont = attributes.wFont;
920 paragraph->u.text.wVSpace = attributes.wVSpace;
921 paragraph->u.text.wHSpace = attributes.wHSpace;
922 paragraph->u.text.wIndent = attributes.wIndent;
923 paragraph->u.text.lpszText = (char*)paragraph + sizeof(HLPFILE_PARAGRAPH);
924 strcpy(paragraph->u.text.lpszText, text);
925
926 attributes.wVSpace = 0;
927 attributes.wHSpace = 0;
928 }
929 /* else: null text, keep on storing attributes */
930 text += textsize;
931
932 if (*format == 0xff)
933 {
934 format++;
935 break;
936 }
937
938 WINE_TRACE("format=%02x\n", *format);
939 switch (*format)
940 {
941 case 0x20:
942 WINE_FIXME("NIY20\n");
943 format += 5;
944 break;
945
946 case 0x21:
947 WINE_FIXME("NIY21\n");
948 format += 3;
949 break;
950
951 case 0x80:
952 attributes.wFont = GET_USHORT(format, 1);
953 WINE_TRACE("Changing font to %d\n", attributes.wFont);
954 format += 3;
955 break;
956
957 case 0x81:
958 attributes.wVSpace++;
959 format += 1;
960 break;
961
962 case 0x82:
963 attributes.wVSpace++;
964 attributes.wIndent = 0;
965 format += 1;
966 break;
967
968 case 0x83:
969 attributes.wIndent++;
970 format += 1;
971 break;
972
973 #if 0
974 case 0x84:
975 format += 3;
976 break;
977 #endif
978
979 case 0x86:
980 case 0x87:
981 case 0x88:
982 {
983 BYTE pos = (*format - 0x86);
984 BYTE type = format[1];
985 long size;
986
987 format += 2;
988 size = fetch_long(&format);
989
990 paragraph = HeapAlloc(GetProcessHeap(), 0,
991 sizeof(HLPFILE_PARAGRAPH) + textsize);
992 if (!paragraph) return FALSE;
993 *paragraphptr = paragraph;
994 paragraphptr = &paragraph->next;
995
996 paragraph->next = NULL;
997 paragraph->link = attributes.link;
998 if (paragraph->link) paragraph->link->wRefCount++;
999 paragraph->cookie = para_bitmap;
1000 paragraph->u.gfx.pos = pos;
1001 switch (type)
1002 {
1003 case 0x22:
1004 fetch_ushort(&format); /* hot spot */
1005 /* fall thru */
1006 case 0x03:
1007 switch (GET_SHORT(format, 0))
1008 {
1009 case 0:
1010 HLPFILE_LoadGfxByIndex(hlpfile, GET_SHORT(format, 2),
1011 paragraph);
1012 break;
1013 case 1:
1014 WINE_FIXME("does it work ??? %x<%lu>#%u\n",
1015 GET_SHORT(format, 0),
1016 size, GET_SHORT(format, 2));
1017 HLPFILE_LoadGfxByAddr(hlpfile, format + 2, size - 4,
1018 paragraph);
1019 break;
1020 default:
1021 WINE_FIXME("??? %u\n", GET_SHORT(format, 0));
1022 break;
1023 }
1024 break;
1025 case 0x05:
1026 WINE_FIXME("Got an embedded element %s\n", format + 6);
1027 break;
1028 default:
1029 WINE_FIXME("Got a type %d picture\n", type);
1030 break;
1031 }
1032 if (attributes.wVSpace) paragraph->u.gfx.pos |= 0x8000;
1033
1034 format += size;
1035 }
1036 break;
1037
1038 case 0x89:
1039 HLPFILE_FreeLink(attributes.link);
1040 attributes.link = NULL;
1041 format += 1;
1042 break;
1043
1044 case 0x8B:
1045 case 0x8C:
1046 WINE_FIXME("NIY non-break space/hyphen\n");
1047 format += 1;
1048 break;
1049
1050 #if 0
1051 case 0xA9:
1052 format += 2;
1053 break;
1054 #endif
1055
1056 case 0xC8:
1057 case 0xCC:
1058 WINE_TRACE("macro => %s\n", format + 3);
1059 HLPFILE_FreeLink(attributes.link);
1060 attributes.link = HLPFILE_AllocLink(hlp_link_macro, format + 3,
1061 0, !(*format & 4), -1);
1062 format += 3 + GET_USHORT(format, 1);
1063 break;
1064
1065 case 0xE0:
1066 case 0xE1:
1067 WINE_WARN("jump topic 1 => %u\n", GET_UINT(format, 1));
1068 format += 5;
1069 break;
1070
1071 case 0xE2:
1072 case 0xE3:
1073 case 0xE6:
1074 case 0xE7:
1075 HLPFILE_FreeLink(attributes.link);
1076 attributes.link = HLPFILE_AllocLink((*format & 1) ? hlp_link_link : hlp_link_popup,
1077 hlpfile->lpszPath,
1078 GET_UINT(format, 1),
1079 !(*format & 4), -1);
1080 format += 5;
1081 break;
1082
1083 case 0xEA:
1084 case 0xEB:
1085 case 0xEE:
1086 case 0xEF:
1087 {
1088 char* ptr = format + 8;
1089 BYTE type = format[3];
1090 int wnd = -1;
1091 char* str;
1092
1093 if (type == 1) wnd = *ptr++;
1094 if (type == 4 || type == 6)
1095 {
1096 str = ptr;
1097 ptr += strlen(ptr) + 1;
1098 }
1099 else
1100 str = hlpfile->lpszPath;
1101 if (type == 6)
1102 {
1103 for (wnd = hlpfile->numWindows - 1; wnd >= 0; wnd--)
1104 {
1105 if (!strcmp(ptr, hlpfile->windows[wnd].name)) break;
1106 }
1107 if (wnd == -1)
1108 WINE_WARN("Couldn't find window info for %s\n", ptr);
1109 }
1110 HLPFILE_FreeLink(attributes.link);
1111 attributes.link = HLPFILE_AllocLink((*format & 4) ? hlp_link_link : hlp_link_popup,
1112 str, GET_UINT(format, 4),
1113 !(*format & 1), wnd);
1114 }
1115 format += 3 + GET_USHORT(format, 1);
1116 break;
1117
1118 default:
1119 WINE_WARN("format %02x\n", *format);
1120 format++;
1121 }
1122 }
1123 }
1124 if (text_end != buf + GET_UINT(buf, 0x10) + size)
1125 HeapFree(GetProcessHeap(), 0, text_end - size);
1126 return TRUE;
1127 }
1128
1129 /******************************************************************
1130 * HLPFILE_ReadFont
1131 *
1132 *
1133 */
1134 static BOOL HLPFILE_ReadFont(HLPFILE* hlpfile)
1135 {
1136 BYTE *ref, *end;
1137 unsigned i, len, idx;
1138 unsigned face_num, dscr_num, face_offset, dscr_offset;
1139 BYTE flag, family;
1140
1141 if (!HLPFILE_FindSubFile("|FONT", &ref, &end))
1142 {
1143 WINE_WARN("no subfile FONT\n");
1144 hlpfile->numFonts = 0;
1145 hlpfile->fonts = NULL;
1146 return FALSE;
1147 }
1148
1149 ref += 9;
1150
1151 face_num = GET_USHORT(ref, 0);
1152 dscr_num = GET_USHORT(ref, 2);
1153 face_offset = GET_USHORT(ref, 4);
1154 dscr_offset = GET_USHORT(ref, 6);
1155
1156 WINE_TRACE("Got NumFacenames=%u@%u NumDesc=%u@%u\n",
1157 face_num, face_offset, dscr_num, dscr_offset);
1158
1159 hlpfile->numFonts = dscr_num;
1160 hlpfile->fonts = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_FONT) * dscr_num);
1161
1162 len = (dscr_offset - face_offset) / face_num;
1163 /* EPP for (i = face_offset; i < dscr_offset; i += len) */
1164 /* EPP WINE_FIXME("[%d]: %*s\n", i / len, len, ref + i); */
1165 for (i = 0; i < dscr_num; i++)
1166 {
1167 flag = ref[dscr_offset + i * 11 + 0];
1168 family = ref[dscr_offset + i * 11 + 2];
1169
1170 hlpfile->fonts[i].LogFont.lfHeight = -ref[dscr_offset + i * 11 + 1] / 2;
1171 hlpfile->fonts[i].LogFont.lfWidth = 0;
1172 hlpfile->fonts[i].LogFont.lfEscapement = 0;
1173 hlpfile->fonts[i].LogFont.lfOrientation = 0;
1174 hlpfile->fonts[i].LogFont.lfWeight = (flag & 1) ? 700 : 400;
1175 hlpfile->fonts[i].LogFont.lfItalic = (flag & 2) ? TRUE : FALSE;
1176 hlpfile->fonts[i].LogFont.lfUnderline = (flag & 4) ? TRUE : FALSE;
1177 hlpfile->fonts[i].LogFont.lfStrikeOut = (flag & 8) ? TRUE : FALSE;
1178 hlpfile->fonts[i].LogFont.lfCharSet = ANSI_CHARSET;
1179 hlpfile->fonts[i].LogFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
1180 hlpfile->fonts[i].LogFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
1181 hlpfile->fonts[i].LogFont.lfQuality = DEFAULT_QUALITY;
1182 hlpfile->fonts[i].LogFont.lfPitchAndFamily = DEFAULT_PITCH;
1183
1184 switch (family)
1185 {
1186 case 0x01: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_MODERN; break;
1187 case 0x02: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_ROMAN; break;
1188 case 0x03: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_SWISS; break;
1189 case 0x04: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_SCRIPT; break;
1190 case 0x05: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_DECORATIVE; break;
1191 default: WINE_FIXME("Unknown family %u\n", family);
1192 }
1193 idx = GET_USHORT(ref, dscr_offset + i * 11 + 3);
1194
1195 if (idx < face_num)
1196 {
1197 strncpy(hlpfile->fonts[i].LogFont.lfFaceName, ref + face_offset + idx * len, min(len, LF_FACESIZE - 1));
1198 hlpfile->fonts[i].LogFont.lfFaceName[min(len, LF_FACESIZE - 1) + 1] = '\0';
1199 }
1200 else
1201 {
1202 WINE_FIXME("Too high face ref (%u/%u)\n", idx, face_num);
1203 strcpy(hlpfile->fonts[i].LogFont.lfFaceName, "Helv");
1204 }
1205 hlpfile->fonts[i].hFont = (HANDLE)0;
1206 hlpfile->fonts[i].color = RGB(ref[dscr_offset + i * 11 + 5],
1207 ref[dscr_offset + i * 11 + 6],
1208 ref[dscr_offset + i * 11 + 7]);
1209 #define X(b,s) ((flag & (1 << b)) ? "-"s: "")
1210 WINE_TRACE("Font[%d]: flags=%02x%s%s%s%s%s%s pSize=%u family=%u face=%s[%u] color=%08x\n",
1211 i, flag,
1212 X(0, "bold"),
1213 X(1, "italic"),
1214 X(2, "underline"),
1215 X(3, "strikeOut"),
1216 X(4, "dblUnderline"),
1217 X(5, "smallCaps"),
1218 ref[dscr_offset + i * 11 + 1],
1219 family,
1220 hlpfile->fonts[i].LogFont.lfFaceName, idx,
1221 GET_UINT(ref, dscr_offset + i * 11 + 5) & 0x00FFFFFF);
1222 }
1223 return TRUE;
1224 }
1225
1226 /***********************************************************************
1227 *
1228 * HLPFILE_ReadFileToBuffer
1229 */
1230 static BOOL HLPFILE_ReadFileToBuffer(HFILE hFile)
1231 {
1232 BYTE header[16], dummy[1];
1233 UINT size;
1234
1235 if (_hread(hFile, header, 16) != 16) {WINE_WARN("header\n"); return FALSE;};
1236
1237 /* sanity checks */
1238 if (GET_UINT(header, 0) != 0x00035F3F)
1239 {WINE_WARN("wrong header\n"); return FALSE;};
1240
1241 size = GET_UINT(header, 12);
1242 file_buffer = HeapAlloc(GetProcessHeap(), 0, size + 1);
1243 if (!file_buffer) return FALSE;
1244
1245 memcpy(file_buffer, header, 16);
1246 if (_hread(hFile, file_buffer + 16, size - 16) != size - 16)
1247 {WINE_WARN("filesize1\n"); return FALSE;};
1248
1249 if (_hread(hFile, dummy, 1) != 0) WINE_WARN("filesize2\n");
1250
1251 file_buffer[size] = '\0'; /* FIXME: was '0', sounds ackward to me */
1252
1253 return TRUE;
1254 }
1255
1256 /***********************************************************************
1257 *
1258 * HLPFILE_FindSubFile
1259 */
1260 static BOOL HLPFILE_FindSubFile(LPCSTR name, BYTE **subbuf, BYTE **subend)
1261 {
1262 BYTE *root = file_buffer + GET_UINT(file_buffer, 4);
1263 BYTE *end = file_buffer + GET_UINT(file_buffer, 12);
1264 BYTE *ptr;
1265 BYTE *bth;
1266
1267 unsigned pgsize;
1268 unsigned pglast;
1269 unsigned nentries;
1270 unsigned i, n;
1271
1272 bth = root + 9;
1273
1274 /* FIXME: this should be using the EnumBTree functions from this file */
1275 pgsize = GET_USHORT(bth, 4);
1276 WINE_TRACE("%s => pgsize=%u #pg=%u rootpg=%u #lvl=%u\n",
1277 name, pgsize, GET_USHORT(bth, 30), GET_USHORT(bth, 26), GET_USHORT(bth, 32));
1278
1279 ptr = bth + 38 + GET_USHORT(bth, 26) * pgsize;
1280
1281 for (n = 1; n < GET_USHORT(bth, 32); n++)
1282 {
1283 nentries = GET_USHORT(ptr, 2);
1284 pglast = GET_USHORT(ptr, 4);
1285 WINE_TRACE("[%u]: #entries=%u next=%u\n", n, nentries, pglast);
1286
1287 ptr += 6;
1288 for (i = 0; i < nentries; i++)
1289 {
1290 WINE_TRACE("<= %s\n", ptr);
1291 if (strcmp(name, ptr) < 0) break;
1292 ptr += strlen(ptr) + 1;
1293 pglast = GET_USHORT(ptr, 0);
1294 ptr += 2;
1295 }
1296 ptr = bth + 38 + pglast * pgsize;
1297 }
1298
1299 nentries = GET_USHORT(ptr, 2);
1300 ptr += 8;
1301 for (i = 0; i < nentries; i++)
1302 {
1303 char* fname = ptr;
1304 ptr += strlen(fname) + 1;
1305 WINE_TRACE("\\- %s\n", fname);
1306 if (strcmp(fname, name) == 0)
1307 {
1308 *subbuf = file_buffer + GET_UINT(ptr, 0);
1309 *subend = *subbuf + GET_UINT(*subbuf, 0);
1310 if (file_buffer > *subbuf || *subbuf > *subend || *subend > end)
1311 {
1312 WINE_WARN("size mismatch\n");
1313 return FALSE;
1314 }
1315 return TRUE;
1316 }
1317 ptr += 4;
1318 }
1319
1320 return FALSE;
1321 }
1322
1323 /***********************************************************************
1324 *
1325 * HLPFILE_SystemCommands
1326 */
1327 static BOOL HLPFILE_SystemCommands(HLPFILE* hlpfile)
1328 {
1329 BYTE *buf, *ptr, *end;
1330 HLPFILE_MACRO *macro, **m;
1331 LPSTR p;
1332 unsigned short magic, minor, major, flags;
1333
1334 hlpfile->lpszTitle = NULL;
1335
1336 if (!HLPFILE_FindSubFile("|SYSTEM", &buf, &end)) return FALSE;
1337
1338 magic = GET_USHORT(buf + 9, 0);
1339 minor = GET_USHORT(buf + 9, 2);
1340 major = GET_USHORT(buf + 9, 4);
1341 /* gen date on 4 bytes */
1342 flags = GET_USHORT(buf + 9, 10);
1343 WINE_TRACE("Got system header: magic=%04x version=%d.%d flags=%04x\n",
1344 magic, major, minor, flags);
1345 if (magic != 0x036C || major != 1)
1346 {WINE_WARN("Wrong system header\n"); return FALSE;}
1347 if (minor <= 16) {WINE_WARN("too old file format (NIY)\n"); return FALSE;}
1348 if (flags & 8) {WINE_WARN("Unsupported yet page size\n"); return FALSE;}
1349
1350 hlpfile->version = minor;
1351 hlpfile->flags = flags;
1352
1353 for (ptr = buf + 0x15; ptr + 4 <= end; ptr += GET_USHORT(ptr, 2) + 4)
1354 {
1355 switch (GET_USHORT(ptr, 0))
1356 {
1357 case 1:
1358 if (hlpfile->lpszTitle) {WINE_WARN("title\n"); break;}
1359 hlpfile->lpszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(ptr + 4) + 1);
1360 if (!hlpfile->lpszTitle) return FALSE;
1361 lstrcpy(hlpfile->lpszTitle, ptr + 4);
1362 WINE_TRACE("Title: %s\n", hlpfile->lpszTitle);
1363 break;
1364
1365 case 2:
1366 if (hlpfile->lpszCopyright) {WINE_WARN("copyright\n"); break;}
1367 hlpfile->lpszCopyright = HeapAlloc(GetProcessHeap(), 0, strlen(ptr + 4) + 1);
1368 if (!hlpfile->lpszCopyright) return FALSE;
1369 lstrcpy(hlpfile->lpszCopyright, ptr + 4);
1370 WINE_TRACE("Copyright: %s\n", hlpfile->lpszCopyright);
1371 break;
1372
1373 case 3:
1374 if (GET_USHORT(ptr, 2) != 4) {WINE_WARN("system3\n");break;}
1375 hlpfile->contents_start = GET_UINT(ptr, 4);
1376 WINE_TRACE("Setting contents start at %08lx\n", hlpfile->contents_start);
1377 break;
1378
1379 case 4:
1380 macro = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_MACRO) + lstrlen(ptr + 4) + 1);
1381 if (!macro) break;
1382 p = (char*)macro + sizeof(HLPFILE_MACRO);
1383 lstrcpy(p, (LPSTR)ptr + 4);
1384 macro->lpszMacro = p;
1385 macro->next = 0;
1386 for (m = &hlpfile->first_macro; *m; m = &(*m)->next);
1387 *m = macro;
1388 break;
1389
1390 case 6:
1391 if (GET_USHORT(ptr, 2) != 90) {WINE_WARN("system6\n");break;}
1392 hlpfile->windows = HeapReAlloc(GetProcessHeap(), 0, hlpfile->windows,
1393 sizeof(HLPFILE_WINDOWINFO) * ++hlpfile->numWindows);
1394 if (hlpfile->windows)
1395 {
1396 unsigned flags = GET_USHORT(ptr, 4);
1397 HLPFILE_WINDOWINFO* wi = &hlpfile->windows[hlpfile->numWindows - 1];
1398
1399 if (flags & 0x0001) strcpy(wi->type, ptr + 6); else wi->type[0] = '\0';
1400 if (flags & 0x0002) strcpy(wi->name, ptr + 16); else wi->name[0] = '\0';
1401 if (flags & 0x0004) strcpy(wi->caption, ptr + 25); else strncpy(wi->caption, hlpfile->lpszTitle, sizeof(wi->caption));
1402 wi->origin.x = (flags & 0x0008) ? GET_USHORT(ptr, 76) : CW_USEDEFAULT;
1403 wi->origin.y = (flags & 0x0010) ? GET_USHORT(ptr, 78) : CW_USEDEFAULT;
1404 wi->size.cx = (flags & 0x0020) ? GET_USHORT(ptr, 80) : CW_USEDEFAULT;
1405 wi->size.cy = (flags & 0x0040) ? GET_USHORT(ptr, 82) : CW_USEDEFAULT;
1406 wi->style = (flags & 0x0080) ? GET_USHORT(ptr, 84) : SW_SHOW;
1407 wi->sr_color = (flags & 0x0100) ? GET_UINT(ptr, 86) : 0xFFFFFF;
1408 wi->nsr_color = (flags & 0x0200) ? GET_UINT(ptr, 90) : 0xFFFFFF;
1409 WINE_FIXME("System-Window: flags=%c%c%c%c%c%c%c%c type=%s name=%s caption=%s (%ld,%ld)x(%ld,%ld)\n",
1410 flags & 0x0001 ? 'T' : 't',
1411 flags & 0x0002 ? 'N' : 'n',
1412 flags & 0x0004 ? 'C' : 'c',
1413 flags & 0x0008 ? 'X' : 'x',
1414 flags & 0x0010 ? 'Y' : 'y',
1415 flags & 0x0020 ? 'W' : 'w',
1416 flags & 0x0040 ? 'H' : 'h',
1417 flags & 0x0080 ? 'S' : 's',
1418 wi->type, wi->name, wi->caption, wi->origin.x, wi->origin.y,
1419 wi->size.cx, wi->size.cy);
1420 }
1421 break;
1422 default:
1423 WINE_WARN("Unsupported SystemRecord[%d]\n", GET_USHORT(ptr, 0));
1424 }
1425 }
1426 return TRUE;
1427 }
1428
1429 /***********************************************************************
1430 *
1431 * HLPFILE_UncompressedLZ77_Size
1432 */
1433 static INT HLPFILE_UncompressedLZ77_Size(BYTE *ptr, BYTE *end)
1434 {
1435 int i, newsize = 0;
1436
1437 while (ptr < end)
1438 {
1439 int mask = *ptr++;
1440 for (i = 0; i < 8 && ptr < end; i++, mask >>= 1)
1441 {
1442 if (mask & 1)
1443 {
1444 int code = GET_USHORT(ptr, 0);
1445 int len = 3 + (code >> 12);
1446 newsize += len;
1447 ptr += 2;
1448 }
1449 else newsize++, ptr++;
1450 }
1451 }
1452
1453 return newsize;
1454 }
1455
1456 /***********************************************************************
1457 *
1458 * HLPFILE_UncompressLZ77
1459 */
1460 static BYTE *HLPFILE_UncompressLZ77(BYTE *ptr, BYTE *end, BYTE *newptr)
1461 {
1462 int i;
1463
1464 while (ptr < end)
1465 {
1466 int mask = *ptr++;
1467 for (i = 0; i < 8 && ptr < end; i++, mask >>= 1)
1468 {
1469 if (mask & 1)
1470 {
1471 int code = GET_USHORT(ptr, 0);
1472 int len = 3 + (code >> 12);
1473 int offset = code & 0xfff;
1474 memcpy(newptr, newptr - offset - 1, len);
1475 newptr += len;
1476 ptr += 2;
1477 }
1478 else *newptr++ = *ptr++;
1479 }
1480 }
1481
1482 return newptr;
1483 }
1484
1485 /***********************************************************************
1486 *
1487 * HLPFILE_UncompressLZ77_Phrases
1488 */
1489 static BOOL HLPFILE_UncompressLZ77_Phrases(HLPFILE* hlpfile)
1490 {
1491 UINT i, num, dec_size;
1492 BYTE *buf, *end;
1493
1494 if (!HLPFILE_FindSubFile("|Phrases", &buf, &end)) return FALSE;
1495
1496 num = phrases.num = GET_USHORT(buf, 9);
1497 if (buf + 2 * num + 0x13 >= end) {WINE_WARN("1a\n"); return FALSE;};
1498
1499 dec_size = HLPFILE_UncompressedLZ77_Size(buf + 0x13 + 2 * num, end);
1500
1501 phrases.offsets = HeapAlloc(GetProcessHeap(), 0, sizeof(unsigned) * (num + 1));
1502 phrases.buffer = HeapAlloc(GetProcessHeap(), 0, dec_size);
1503 if (!phrases.offsets || !phrases.buffer) return FALSE;
1504
1505 for (i = 0; i <= num; i++)
1506 phrases.offsets[i] = GET_USHORT(buf, 0x11 + 2 * i) - 2 * num - 2;
1507
1508 HLPFILE_UncompressLZ77(buf + 0x13 + 2 * num, end, phrases.buffer);
1509
1510 hlpfile->hasPhrases = TRUE;
1511 return TRUE;
1512 }
1513
1514 /***********************************************************************
1515 *
1516 * HLPFILE_Uncompress_Phrases40
1517 */
1518 static BOOL HLPFILE_Uncompress_Phrases40(HLPFILE* hlpfile)
1519 {
1520 UINT num, dec_size, cpr_size;
1521 BYTE *buf_idx, *end_idx;
1522 BYTE *buf_phs, *end_phs;
1523 short i, n;
1524 long* ptr, mask = 0;
1525 unsigned short bc;
1526
1527 if (!HLPFILE_FindSubFile("|PhrIndex", &buf_idx, &end_idx) ||
1528 !HLPFILE_FindSubFile("|PhrImage", &buf_phs, &end_phs)) return FALSE;
1529
1530 ptr = (long*)(buf_idx + 9 + 28);
1531 bc = GET_USHORT(buf_idx, 9 + 24) & 0x0F;
1532 num = phrases.num = GET_USHORT(buf_idx, 9 + 4);
1533
1534 WINE_TRACE("Index: Magic=%08x #entries=%u CpsdSize=%u PhrImgSize=%u\n"
1535 "\tPhrImgCprsdSize=%u 0=%u bc=%x ukn=%x\n",
1536 GET_UINT(buf_idx, 9 + 0),
1537 GET_UINT(buf_idx, 9 + 4),
1538 GET_UINT(buf_idx, 9 + 8),
1539 GET_UINT(buf_idx, 9 + 12),
1540 GET_UINT(buf_idx, 9 + 16),
1541 GET_UINT(buf_idx, 9 + 20),
1542 GET_USHORT(buf_idx, 9 + 24),
1543 GET_USHORT(buf_idx, 9 + 26));
1544
1545 dec_size = GET_UINT(buf_idx, 9 + 12);
1546 cpr_size = GET_UINT(buf_idx, 9 + 16);
1547
1548 if (dec_size != cpr_size &&
1549 dec_size != HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs))
1550 {
1551 WINE_WARN("size mismatch %u %u\n",
1552 dec_size, HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs));
1553 dec_size = max(dec_size, HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs));
1554 }
1555
1556 phrases.offsets = HeapAlloc(GetProcessHeap(), 0, sizeof(unsigned) * (num + 1));
1557 phrases.buffer = HeapAlloc(GetProcessHeap(), 0, dec_size);
1558 if (!phrases.offsets || !phrases.buffer) return FALSE;
1559
1560 #define getbit() (ptr += (mask < 0), mask = mask*2 + (mask<=0), (*ptr & mask) != 0)
1561
1562 phrases.offsets[0] = 0;
1563 for (i = 0; i < num; i++)
1564 {
1565 for (n = 1; getbit(); n += 1 << bc);
1566 if (getbit()) n++;
1567 if (bc > 1 && getbit()) n += 2;
1568 if (bc > 2 && getbit()) n += 4;
1569 if (bc > 3 && getbit()) n += 8;
1570 if (bc > 4 && getbit()) n += 16;
1571 phrases.offsets[i + 1] = phrases.offsets[i] + n;
1572 }
1573 #undef getbit
1574
1575 if (dec_size == cpr_size)
1576 memcpy(phrases.buffer, buf_phs + 9, dec_size);
1577 else
1578 HLPFILE_UncompressLZ77(buf_phs + 9, end_phs, phrases.buffer);
1579
1580 hlpfile->hasPhrases = FALSE;
1581 return TRUE;
1582 }
1583
1584 /***********************************************************************
1585 *
1586 * HLPFILE_Uncompress_Topic
1587 */
1588 static BOOL HLPFILE_Uncompress_Topic(HLPFILE* hlpfile)
1589 {
1590 BYTE *buf, *ptr, *end, *newptr;
1591 int i, newsize = 0;
1592
1593 if (!HLPFILE_FindSubFile("|TOPIC", &buf, &end))
1594 {WINE_WARN("topic0\n"); return FALSE;}
1595
1596 switch (hlpfile->flags & (8|4))
1597 {
1598 case 8:
1599 WINE_FIXME("Unsupported format\n");
1600 return FALSE;
1601 case 4:
1602 buf += 9;
1603 topic.wMapLen = (end - buf - 1) / 0x1000 + 1;
1604
1605 for (i = 0; i < topic.wMapLen; i++)
1606 {
1607 ptr = buf + i * 0x1000;
1608
1609 /* I don't know why, it's necessary for printman.hlp */
1610 if (ptr + 0x44 > end) ptr = end - 0x44;
1611
1612 newsize += HLPFILE_UncompressedLZ77_Size(ptr + 0xc, min(end, ptr + 0x1000));
1613 }
1614
1615 topic.map = HeapAlloc(GetProcessHeap(), 0,
1616 topic.wMapLen * sizeof(topic.map[0]) + newsize);
1617 if (!topic.map) return FALSE;
1618 newptr = (char*)(topic.map + topic.wMapLen);
1619 topic.end = newptr + newsize;
1620
1621 for (i = 0; i < topic.wMapLen; i++)
1622 {
1623 ptr = buf + i * 0x1000;
1624 if (ptr + 0x44 > end) ptr = end - 0x44;
1625
1626 topic.map[i] = newptr;
1627 newptr = HLPFILE_UncompressLZ77(ptr + 0xc, min(end, ptr + 0x1000), newptr);
1628 }
1629 break;
1630 case 0:
1631 /* basically, we need to copy the 0x1000 byte pages (removing the first 0x0C) in
1632 * one single are in memory
1633 */
1634 #define DST_LEN (0x1000 - 0x0C)
1635 buf += 9;
1636 newsize = end - buf;
1637 /* number of destination pages */
1638 topic.wMapLen = (newsize - 1) / DST_LEN + 1;
1639 topic.map = HeapAlloc(GetProcessHeap(), 0,
1640 topic.wMapLen * (sizeof(topic.map[0]) + DST_LEN));
1641 if (!topic.map) return FALSE;
1642 newptr = (char*)(topic.map + topic.wMapLen);
1643 topic.end = newptr + newsize;
1644
1645 for (i = 0; i < topic.wMapLen; i++)
1646 {
1647 topic.map[i] = newptr + i * DST_LEN;
1648 memcpy(topic.map[i], buf + i * 0x1000 + 0x0C, DST_LEN);
1649 }
1650 #undef DST_LEN
1651 break;
1652 }
1653 return TRUE;
1654 }
1655
1656 /***********************************************************************
1657 *
1658 * HLPFILE_Uncompress2
1659 */
1660
1661 static void HLPFILE_Uncompress2(const BYTE *ptr, const BYTE *end, BYTE *newptr, const BYTE *newend)
1662 {
1663 BYTE *phptr, *phend;
1664 UINT code;
1665 UINT index;
1666
1667 while (ptr < end && newptr < newend)
1668 {
1669 if (!*ptr || *ptr >= 0x10)
1670 *newptr++ = *ptr++;
1671 else
1672 {
1673 code = 0x100 * ptr[0] + ptr[1];
1674 index = (code - 0x100) / 2;
1675
1676 phptr = phrases.buffer + phrases.offsets[index];
1677 phend = phrases.buffer + phrases.offsets[index + 1];
1678
1679 if (newptr + (phend - phptr) > newend)
1680 {
1681 WINE_FIXME("buffer overflow %p > %p for %d bytes\n",
1682 newptr, newend, phend - phptr);
1683 return;
1684 }
1685 memcpy(newptr, phptr, phend - phptr);
1686 newptr += phend - phptr;
1687 if (code & 1) *newptr++ = ' ';
1688
1689 ptr += 2;
1690 }
1691 }
1692 if (newptr > newend) WINE_FIXME("buffer overflow %p > %p\n", newptr, newend);
1693 }
1694
1695 /******************************************************************
1696 * HLPFILE_Uncompress3
1697 *
1698 *
1699 */
1700 static BOOL HLPFILE_Uncompress3(char* dst, const char* dst_end,
1701 const BYTE* src, const BYTE* src_end)
1702 {
1703 int idx, len;
1704
1705 for (; src < src_end; src++)
1706 {
1707 if ((*src & 1) == 0)
1708 {
1709 idx = *src / 2;
1710 if (idx > phrases.num)
1711 {
1712 WINE_ERR("index in phrases %d/%d\n", idx, phrases.num);
1713 len = 0;
1714 }
1715 else
1716 {
1717 len = phrases.offsets[idx + 1] - phrases.offsets[idx];
1718 memcpy(dst, &phrases.buffer[phrases.offsets[idx]], len);
1719 }
1720 }
1721 else if ((*src & 0x03) == 0x01)
1722 {
1723 idx = (*src + 1) * 64;
1724 idx += *++src;
1725 if (idx > phrases.num)
1726 {
1727 WINE_ERR("index in phrases %d/%d\n", idx, phrases.num);
1728 len = 0;
1729 }
1730 else
1731 {
1732 len = phrases.offsets[idx + 1] - phrases.offsets[idx];
1733 memcpy(dst, &phrases.buffer[phrases.offsets[idx]], len);
1734 }
1735 }
1736 else if ((*src & 0x07) == 0x03)
1737 {
1738 len = (*src / 8) + 1;
1739 memcpy(dst, src + 1, len);
1740 src += len;
1741 }
1742 else
1743 {
1744 len = (*src / 16) + 1;
1745 memset(dst, ((*src & 0x0F) == 0x07) ? ' ' : 0, len);
1746 }
1747 dst += len;
1748 }
1749
1750 if (dst > dst_end) WINE_ERR("buffer overflow (%p > %p)\n", dst, dst_end);
1751 return TRUE;
1752 }
1753
1754 /******************************************************************
1755 * HLPFILE_UncompressRLE
1756 *
1757 *
1758 */
1759 static void HLPFILE_UncompressRLE(const BYTE* src, unsigned sz, BYTE** dst)
1760 {
1761 unsigned i;
1762 BYTE ch;
1763
1764 for (i = 0; i < sz; i++)
1765 {
1766 ch = src[i];
1767 if (ch & 0x80)
1768 {
1769 ch &= 0x7F;
1770 memcpy(*dst, src + i + 1, ch);
1771 i += ch;
1772 }
1773 else
1774 {
1775 memset(*dst, (char)src[i + 1], ch);
1776 i++;
1777 }
1778 *dst += ch;
1779 }
1780 }
1781
1782 /******************************************************************
1783 * HLPFILE_EnumBTreeLeaves
1784 *
1785 *
1786 */
1787 static void HLPFILE_EnumBTreeLeaves(const BYTE* buf, const BYTE* end, unsigned (*fn)(const BYTE*, void*), void* user)
1788 {
1789 unsigned psize, pnext;
1790 unsigned num, nlvl;
1791 const BYTE* ptr;
1792
1793 num = GET_UINT(buf, 9 + 34);
1794 psize = GET_USHORT(buf, 9 + 4);
1795 nlvl = GET_USHORT(buf, 9 + 32);
1796 pnext = GET_USHORT(buf, 9 + 26);
1797
1798 WINE_TRACE("BTree: #entries=%u pagSize=%u #levels=%u #pages=%u root=%u struct%16s\n",
1799 num, psize, nlvl, GET_USHORT(buf, 9 + 30), pnext, buf + 9 + 6);
1800 if (!num) return;
1801
1802 while (--nlvl > 0)
1803 {
1804 ptr = (buf + 9 + 38) + pnext * psize;
1805 WINE_TRACE("BTree: (index[%u]) unused=%u #entries=%u <%u\n",
1806 pnext, GET_USHORT(ptr, 0), GET_USHORT(ptr, 2), GET_USHORT(ptr, 4));
1807 pnext = GET_USHORT(ptr, 4);
1808 }
1809 while (pnext != 0xFFFF)
1810 {
1811 const BYTE* node_page;
1812 unsigned short limit;
1813
1814 node_page = ptr = (buf + 9 + 38) + pnext * psize;
1815 limit = GET_USHORT(ptr, 2);
1816 WINE_TRACE("BTree: (leaf [%u]) unused=%u #entries=%u <%u >%u\n",
1817 pnext, GET_USHORT(ptr, 0), limit, GET_USHORT(ptr, 4), GET_USHORT(ptr, 6));
1818 ptr += 8;
1819 while (limit--)
1820 ptr += (fn)(ptr, user);
1821 pnext = GET_USHORT(node_page, 6);
1822 }
1823 }
1824
1825 struct myfncb {
1826 HLPFILE* hlpfile;
1827 int i;
1828 };
1829
1830 static unsigned myfn(const BYTE* ptr, void* user)
1831 {
1832 struct myfncb* m = user;
1833
1834 m->hlpfile->Context[m->i].lHash = GET_UINT(ptr, 0);
1835 m->hlpfile->Context[m->i].offset = GET_UINT(ptr, 4);
1836 m->i++;
1837 return 8;
1838 }
1839
1840 /***********************************************************************
1841 *
1842 * HLPFILE_GetContext
1843 */
1844 static BOOL HLPFILE_GetContext(HLPFILE *hlpfile)
1845 {
1846 BYTE *cbuf, *cend;
1847 struct myfncb m;
1848 unsigned clen;
1849
1850 if (!HLPFILE_FindSubFile("|CONTEXT", &cbuf, &cend)) {WINE_WARN("context0\n"); return FALSE;}
1851
1852 clen = GET_UINT(cbuf, 0x2b);
1853 hlpfile->Context = HeapAlloc(GetProcessHeap(), 0, clen * sizeof(HLPFILE_CONTEXT));
1854 if (!hlpfile->Context) return FALSE;
1855 hlpfile->wContextLen = clen;
1856
1857 m.hlpfile = hlpfile;
1858 m.i = 0;
1859 HLPFILE_EnumBTreeLeaves(cbuf, cend, myfn, &m);
1860
1861 return TRUE;
1862 }
1863
1864 /******************************************************************
1865 * HLPFILE_DeleteLink
1866 *
1867 *
1868 */
1869 void HLPFILE_FreeLink(HLPFILE_LINK* link)
1870 {
1871 if (link && !--link->wRefCount)
1872 HeapFree(GetProcessHeap(), 0, link);
1873 }
1874
1875 /***********************************************************************
1876 *
1877 * HLPFILE_DeleteParagraph
1878 */
1879 static void HLPFILE_DeleteParagraph(HLPFILE_PARAGRAPH* paragraph)
1880 {
1881 HLPFILE_PARAGRAPH* next;
1882
1883 while (paragraph)
1884 {
1885 next = paragraph->next;
1886
1887 if (paragraph->cookie == para_metafile)
1888 DeleteMetaFile(paragraph->u.gfx.u.mf.hMetaFile);
1889
1890 HLPFILE_FreeLink(paragraph->link);
1891
1892 HeapFree(GetProcessHeap(), 0, paragraph);
1893 paragraph = next;
1894 }
1895 }
1896
1897 /***********************************************************************
1898 *
1899 * DeleteMacro
1900 */
1901 static void HLPFILE_DeleteMacro(HLPFILE_MACRO* macro)
1902 {
1903 HLPFILE_MACRO* next;
1904
1905 while (macro)
1906 {
1907 next = macro->next;
1908 HeapFree(GetProcessHeap(), 0, macro);
1909 macro = next;
1910 }
1911 }
1912
1913 /***********************************************************************
1914 *
1915 * DeletePage
1916 */
1917 static void HLPFILE_DeletePage(HLPFILE_PAGE* page)
1918 {
1919 HLPFILE_PAGE* next;
1920
1921 while (page)
1922 {
1923 next = page->next;
1924 HLPFILE_DeleteParagraph(page->first_paragraph);
1925 HLPFILE_DeleteMacro(page->first_macro);
1926 HeapFree(GetProcessHeap(), 0, page);
1927 page = next;
1928 }
1929 }
1930
1931 /***********************************************************************
1932 *
1933 * HLPFILE_FreeHlpFile
1934 */
1935 void HLPFILE_FreeHlpFile(HLPFILE* hlpfile)
1936 {
1937 unsigned i;
1938
1939 if (!hlpfile || --hlpfile->wRefCount > 0) return;
1940
1941 if (hlpfile->next) hlpfile->next->prev = hlpfile->prev;
1942 if (hlpfile->prev) hlpfile->prev->next = hlpfile->next;
1943 else first_hlpfile = hlpfile->next;
1944
1945 if (hlpfile->numFonts)
1946 {
1947 for (i = 0; i < hlpfile->numFonts; i++)
1948 {
1949 DeleteObject(hlpfile->fonts[i].hFont);
1950 }
1951 HeapFree(GetProcessHeap(), 0, hlpfile->fonts);
1952 }
1953
1954 if (hlpfile->numBmps)
1955 {
1956 for (i = 0; i < hlpfile->numBmps; i++)
1957 {
1958 DeleteObject(hlpfile->bmps[i]);
1959 }
1960 HeapFree(GetProcessHeap(), 0, hlpfile->bmps);
1961 }
1962
1963 HLPFILE_DeletePage(hlpfile->first_page);
1964 HLPFILE_DeleteMacro(hlpfile->first_macro);
1965
1966 if (hlpfile->numWindows) HeapFree(GetProcessHeap(), 0, hlpfile->windows);
1967 if (hlpfile->Context) HeapFree(GetProcessHeap(), 0, hlpfile->Context);
1968 if (hlpfile->lpszTitle) HeapFree(GetProcessHeap(), 0, hlpfile->lpszTitle);
1969 if (hlpfile->lpszCopyright) HeapFree(GetProcessHeap(), 0, hlpfile->lpszCopyright);
1970 HeapFree(GetProcessHeap(), 0, hlpfile);
1971 }
Maarten's multimedia branch