?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
comctl32: toolbar: Calculate a correct size for empty buttons with the BTNS_AUTOSIZE...
[wine/multimedia.git] / programs / winhlp32 / hlpfile.c
blob99043ac7b5b4468cdd9016daa95e66bbdfdeb4c6
1 /*
2 * Help Viewer
3 *
4 * Copyright 1996 Ulrich Schmid
5 * 2002, 2008 Eric Pouech
6 * 2007 Kirill K. Smirnov
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <string.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wingdi.h"
30 #include "winuser.h"
31 #include "winhelp.h"
32
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(winhelp);
36
37 static inline unsigned short GET_USHORT(const BYTE* buffer, unsigned i)
38 {
39 return (BYTE)buffer[i] + 0x100 * (BYTE)buffer[i + 1];
40 }
41
42 static inline short GET_SHORT(const BYTE* buffer, unsigned i)
43 {
44 return (BYTE)buffer[i] + 0x100 * (signed char)buffer[i+1];
45 }
46
47 static inline unsigned GET_UINT(const BYTE* buffer, unsigned i)
48 {
49 return GET_USHORT(buffer, i) + 0x10000 * GET_USHORT(buffer, i + 2);
50 }
51
52 static HLPFILE *first_hlpfile = 0;
53
54 static BOOL HLPFILE_DoReadHlpFile(HLPFILE*, LPCSTR);
55 static BOOL HLPFILE_ReadFileToBuffer(HLPFILE*, HFILE);
56 static BOOL HLPFILE_FindSubFile(HLPFILE*, LPCSTR, BYTE**, BYTE**);
57 static BOOL HLPFILE_SystemCommands(HLPFILE*);
58 static INT HLPFILE_UncompressedLZ77_Size(const BYTE *ptr, const BYTE *end);
59 static BYTE* HLPFILE_UncompressLZ77(const BYTE *ptr, const BYTE *end, BYTE *newptr);
60 static BOOL HLPFILE_UncompressLZ77_Phrases(HLPFILE*);
61 static BOOL HLPFILE_Uncompress_Phrases40(HLPFILE*);
62 static BOOL HLPFILE_Uncompress_Topic(HLPFILE*);
63 static BOOL HLPFILE_GetContext(HLPFILE*);
64 static BOOL HLPFILE_GetKeywords(HLPFILE*);
65 static BOOL HLPFILE_GetMap(HLPFILE*);
66 static BOOL HLPFILE_GetTOMap(HLPFILE*);
67 static BOOL HLPFILE_AddPage(HLPFILE*, const BYTE*, const BYTE*, unsigned, unsigned);
68 static BOOL HLPFILE_SkipParagraph(HLPFILE*, const BYTE*, const BYTE*, unsigned*);
69 static void HLPFILE_Uncompress2(HLPFILE*, const BYTE*, const BYTE*, BYTE*, const BYTE*);
70 static BOOL HLPFILE_Uncompress3(HLPFILE*, char*, const char*, const BYTE*, const BYTE*);
71 static void HLPFILE_UncompressRLE(const BYTE* src, const BYTE* end, BYTE* dst, unsigned dstsz);
72 static BOOL HLPFILE_ReadFont(HLPFILE* hlpfile);
73
74 /******************************************************************
75 * HLPFILE_PageByOffset
76 *
77 *
78 */
79 HLPFILE_PAGE *HLPFILE_PageByOffset(HLPFILE* hlpfile, LONG offset, ULONG* relative)
80 {
81 HLPFILE_PAGE* page;
82 HLPFILE_PAGE* found;
83
84 if (!hlpfile) return 0;
85
86 WINE_TRACE("<%s>[%x]\n", hlpfile->lpszPath, offset);
87
88 if (offset == 0xFFFFFFFF) return NULL;
89 page = NULL;
90
91 for (found = NULL, page = hlpfile->first_page; page; page = page->next)
92 {
93 if (page->offset <= offset && (!found || found->offset < page->offset))
94 {
95 *relative = offset - page->offset;
96 found = page;
97 }
98 }
99 if (!found)
100 WINE_ERR("Page of offset %u not found in file %s\n",
101 offset, hlpfile->lpszPath);
102 return found;
103 }
104
105 /**************************************************************************
106 * comp_PageByHash
107 *
108 * HLPFILE_BPTreeCompare function for '|CONTEXT' B+ tree file
109 *
110 */
111 static int comp_PageByHash(void *p, const void *key,
112 int leaf, void** next)
113 {
114 LONG lKey = (LONG_PTR)key;
115 LONG lTest = (INT)GET_UINT(p, 0);
116
117 *next = (char *)p+(leaf?8:6);
118 WINE_TRACE("Comparing '%d' with '%d'\n", lKey, lTest);
119 if (lTest < lKey) return -1;
120 if (lTest > lKey) return 1;
121 return 0;
122 }
123
124 /***********************************************************************
125 *
126 * HLPFILE_PageByHash
127 */
128 HLPFILE_PAGE *HLPFILE_PageByHash(HLPFILE* hlpfile, LONG lHash, ULONG* relative)
129 {
130 BYTE *ptr;
131
132 if (!hlpfile) return NULL;
133 if (!lHash) return HLPFILE_Contents(hlpfile, relative);
134
135 WINE_TRACE("<%s>[%x]\n", hlpfile->lpszPath, lHash);
136
137 /* For win 3.0 files hash values are really page numbers */
138 if (hlpfile->version <= 16)
139 {
140 if (lHash >= hlpfile->wTOMapLen) return NULL;
141 return HLPFILE_PageByOffset(hlpfile, hlpfile->TOMap[lHash], relative);
142 }
143
144 ptr = HLPFILE_BPTreeSearch(hlpfile->Context, LongToPtr(lHash), comp_PageByHash);
145 if (!ptr)
146 {
147 WINE_ERR("Page of hash %x not found in file %s\n", lHash, hlpfile->lpszPath);
148 return NULL;
149 }
150
151 return HLPFILE_PageByOffset(hlpfile, GET_UINT(ptr, 4), relative);
152 }
153
154 /***********************************************************************
155 *
156 * HLPFILE_PageByMap
157 */
158 HLPFILE_PAGE *HLPFILE_PageByMap(HLPFILE* hlpfile, LONG lMap, ULONG* relative)
159 {
160 unsigned int i;
161
162 if (!hlpfile) return 0;
163
164 WINE_TRACE("<%s>[%x]\n", hlpfile->lpszPath, lMap);
165
166 for (i = 0; i < hlpfile->wMapLen; i++)
167 {
168 if (hlpfile->Map[i].lMap == lMap)
169 return HLPFILE_PageByOffset(hlpfile, hlpfile->Map[i].offset, relative);
170 }
171
172 WINE_ERR("Page of Map %x not found in file %s\n", lMap, hlpfile->lpszPath);
173 return NULL;
174 }
175
176 /***********************************************************************
177 *
178 * HLPFILE_Contents
179 */
180 HLPFILE_PAGE* HLPFILE_Contents(HLPFILE *hlpfile, ULONG* relative)
181 {
182 HLPFILE_PAGE* page = NULL;
183
184 if (!hlpfile) return NULL;
185
186 page = HLPFILE_PageByOffset(hlpfile, hlpfile->contents_start, relative);
187 if (!page)
188 {
189 page = hlpfile->first_page;
190 *relative = 0;
191 }
192 return page;
193 }
194
195 /***********************************************************************
196 *
197 * HLPFILE_Hash
198 */
199 LONG HLPFILE_Hash(LPCSTR lpszContext)
200 {
201 LONG lHash = 0;
202 CHAR c;
203
204 while ((c = *lpszContext++))
205 {
206 CHAR x = 0;
207 if (c >= 'A' && c <= 'Z') x = c - 'A' + 17;
208 if (c >= 'a' && c <= 'z') x = c - 'a' + 17;
209 if (c >= '1' && c <= '9') x = c - '0';
210 if (c == '0') x = 10;
211 if (c == '.') x = 12;
212 if (c == '_') x = 13;
213 if (x) lHash = lHash * 43 + x;
214 }
215 return lHash;
216 }
217
218 /***********************************************************************
219 *
220 * HLPFILE_ReadHlpFile
221 */
222 HLPFILE *HLPFILE_ReadHlpFile(LPCSTR lpszPath)
223 {
224 HLPFILE* hlpfile;
225
226 for (hlpfile = first_hlpfile; hlpfile; hlpfile = hlpfile->next)
227 {
228 if (!strcmp(lpszPath, hlpfile->lpszPath))
229 {
230 hlpfile->wRefCount++;
231 return hlpfile;
232 }
233 }
234
235 hlpfile = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
236 sizeof(HLPFILE) + lstrlen(lpszPath) + 1);
237 if (!hlpfile) return 0;
238
239 hlpfile->lpszPath = (char*)hlpfile + sizeof(HLPFILE);
240 hlpfile->contents_start = 0xFFFFFFFF;
241 hlpfile->next = first_hlpfile;
242 hlpfile->wRefCount = 1;
243
244 strcpy(hlpfile->lpszPath, lpszPath);
245
246 first_hlpfile = hlpfile;
247 if (hlpfile->next) hlpfile->next->prev = hlpfile;
248
249 if (!HLPFILE_DoReadHlpFile(hlpfile, lpszPath))
250 {
251 HLPFILE_FreeHlpFile(hlpfile);
252 hlpfile = 0;
253 }
254
255 return hlpfile;
256 }
257
258 /***********************************************************************
259 *
260 * HLPFILE_DoReadHlpFile
261 */
262 static BOOL HLPFILE_DoReadHlpFile(HLPFILE *hlpfile, LPCSTR lpszPath)
263 {
264 BOOL ret;
265 HFILE hFile;
266 OFSTRUCT ofs;
267 BYTE* buf;
268 DWORD ref = 0x0C;
269 unsigned index, old_index, offset, len, offs, topicoffset;
270
271 hFile = OpenFile(lpszPath, &ofs, OF_READ);
272 if (hFile == HFILE_ERROR) return FALSE;
273
274 ret = HLPFILE_ReadFileToBuffer(hlpfile, hFile);
275 _lclose(hFile);
276 if (!ret) return FALSE;
277
278 if (!HLPFILE_SystemCommands(hlpfile)) return FALSE;
279
280 if (hlpfile->version <= 16 && !HLPFILE_GetTOMap(hlpfile)) return FALSE;
281
282 /* load phrases support */
283 if (!HLPFILE_UncompressLZ77_Phrases(hlpfile))
284 HLPFILE_Uncompress_Phrases40(hlpfile);
285
286 if (!HLPFILE_Uncompress_Topic(hlpfile)) return FALSE;
287 if (!HLPFILE_ReadFont(hlpfile)) return FALSE;
288
289 buf = hlpfile->topic_map[0];
290 old_index = -1;
291 offs = 0;
292 do
293 {
294 BYTE* end;
295
296 if (hlpfile->version <= 16)
297 {
298 index = (ref - 0x0C) / hlpfile->dsize;
299 offset = (ref - 0x0C) % hlpfile->dsize;
300 }
301 else
302 {
303 index = (ref - 0x0C) >> 14;
304 offset = (ref - 0x0C) & 0x3FFF;
305 }
306
307 if (hlpfile->version <= 16 && index != old_index && old_index != -1)
308 {
309 /* we jumped to the next block, adjust pointers */
310 ref -= 12;
311 offset -= 12;
312 }
313
314 WINE_TRACE("ref=%08x => [%u/%u]\n", ref, index, offset);
315
316 if (index >= hlpfile->topic_maplen) {WINE_WARN("maplen\n"); break;}
317 buf = hlpfile->topic_map[index] + offset;
318 if (buf + 0x15 >= hlpfile->topic_end) {WINE_WARN("extra\n"); break;}
319 end = min(buf + GET_UINT(buf, 0), hlpfile->topic_end);
320 if (index != old_index) {offs = 0; old_index = index;}
321
322 switch (buf[0x14])
323 {
324 case 0x02:
325 if (hlpfile->version <= 16)
326 topicoffset = ref + index * 12;
327 else
328 topicoffset = index * 0x8000 + offs;
329 if (!HLPFILE_AddPage(hlpfile, buf, end, ref, topicoffset)) return FALSE;
330 break;
331
332 case 0x01:
333 case 0x20:
334 case 0x23:
335 if (!HLPFILE_SkipParagraph(hlpfile, buf, end, &len)) return FALSE;
336 offs += len;
337 break;
338
339 default:
340 WINE_ERR("buf[0x14] = %x\n", buf[0x14]);
341 }
342
343 if (hlpfile->version <= 16)
344 {
345 ref += GET_UINT(buf, 0xc);
346 if (GET_UINT(buf, 0xc) == 0)
347 break;
348 }
349 else
350 ref = GET_UINT(buf, 0xc);
351 } while (ref != 0xffffffff);
352
353 HLPFILE_GetKeywords(hlpfile);
354 HLPFILE_GetMap(hlpfile);
355 if (hlpfile->version <= 16) return TRUE;
356 return HLPFILE_GetContext(hlpfile);
357 }
358
359 /***********************************************************************
360 *
361 * HLPFILE_AddPage
362 */
363 static BOOL HLPFILE_AddPage(HLPFILE *hlpfile, const BYTE *buf, const BYTE *end, unsigned ref, unsigned offset)
364 {
365 HLPFILE_PAGE* page;
366 const BYTE* title;
367 UINT titlesize, blocksize, datalen;
368 char* ptr;
369 HLPFILE_MACRO*macro;
370
371 blocksize = GET_UINT(buf, 0);
372 datalen = GET_UINT(buf, 0x10);
373 title = buf + datalen;
374 if (title > end) {WINE_WARN("page2\n"); return FALSE;};
375
376 titlesize = GET_UINT(buf, 4);
377 page = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_PAGE) + titlesize + 1);
378 if (!page) return FALSE;
379 page->lpszTitle = (char*)page + sizeof(HLPFILE_PAGE);
380
381 if (titlesize > blocksize - datalen)
382 {
383 /* need to decompress */
384 if (hlpfile->hasPhrases)
385 HLPFILE_Uncompress2(hlpfile, title, end, (BYTE*)page->lpszTitle, (BYTE*)page->lpszTitle + titlesize);
386 else if (hlpfile->hasPhrases40)
387 HLPFILE_Uncompress3(hlpfile, page->lpszTitle, page->lpszTitle + titlesize, title, end);
388 else
389 {
390 WINE_FIXME("Text size is too long, splitting\n");
391 titlesize = blocksize - datalen;
392 memcpy(page->lpszTitle, title, titlesize);
393 }
394 }
395 else
396 memcpy(page->lpszTitle, title, titlesize);
397
398 page->lpszTitle[titlesize] = '\0';
399
400 if (hlpfile->first_page)
401 {
402 hlpfile->last_page->next = page;
403 page->prev = hlpfile->last_page;
404 hlpfile->last_page = page;
405 }
406 else
407 {
408 hlpfile->first_page = page;
409 hlpfile->last_page = page;
410 page->prev = NULL;
411 }
412
413 page->file = hlpfile;
414 page->next = NULL;
415 page->first_macro = NULL;
416 page->first_link = NULL;
417 page->wNumber = GET_UINT(buf, 0x21);
418 page->offset = offset;
419 page->reference = ref;
420
421 page->browse_bwd = GET_UINT(buf, 0x19);
422 page->browse_fwd = GET_UINT(buf, 0x1D);
423
424 if (hlpfile->version <= 16)
425 {
426 if (page->browse_bwd == 0xFFFF || page->browse_bwd == 0xFFFFFFFF)
427 page->browse_bwd = 0xFFFFFFFF;
428 else
429 page->browse_bwd = hlpfile->TOMap[page->browse_bwd];
430
431 if (page->browse_fwd == 0xFFFF || page->browse_fwd == 0xFFFFFFFF)
432 page->browse_fwd = 0xFFFFFFFF;
433 else
434 page->browse_fwd = hlpfile->TOMap[page->browse_fwd];
435 }
436
437 WINE_TRACE("Added page[%d]: title='%s' %08x << %08x >> %08x\n",
438 page->wNumber, page->lpszTitle,
439 page->browse_bwd, page->offset, page->browse_fwd);
440
441 /* now load macros */
442 ptr = page->lpszTitle + strlen(page->lpszTitle) + 1;
443 while (ptr < page->lpszTitle + titlesize)
444 {
445 unsigned len = strlen(ptr);
446 char* macro_str;
447
448 WINE_TRACE("macro: %s\n", ptr);
449 macro = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_MACRO) + len + 1);
450 macro->lpszMacro = macro_str = (char*)(macro + 1);
451 memcpy(macro_str, ptr, len + 1);
452 /* FIXME: shall we really link macro in reverse order ??
453 * may produce strange results when played at page opening
454 */
455 macro->next = page->first_macro;
456 page->first_macro = macro;
457 ptr += len + 1;
458 }
459
460 return TRUE;
461 }
462
463 static long fetch_long(const BYTE** ptr)
464 {
465 long ret;
466
467 if (*(*ptr) & 1)
468 {
469 ret = (*(const unsigned long*)(*ptr) - 0x80000000L) / 2;
470 (*ptr) += 4;
471 }
472 else
473 {
474 ret = (*(const unsigned short*)(*ptr) - 0x8000) / 2;
475 (*ptr) += 2;
476 }
477
478 return ret;
479 }
480
481 static unsigned long fetch_ulong(const BYTE** ptr)
482 {
483 unsigned long ret;
484
485 if (*(*ptr) & 1)
486 {
487 ret = *(const unsigned long*)(*ptr) / 2;
488 (*ptr) += 4;
489 }
490 else
491 {
492 ret = *(const unsigned short*)(*ptr) / 2;
493 (*ptr) += 2;
494 }
495 return ret;
496 }
497
498 static short fetch_short(const BYTE** ptr)
499 {
500 short ret;
501
502 if (*(*ptr) & 1)
503 {
504 ret = (*(const unsigned short*)(*ptr) - 0x8000) / 2;
505 (*ptr) += 2;
506 }
507 else
508 {
509 ret = (*(const unsigned char*)(*ptr) - 0x80) / 2;
510 (*ptr)++;
511 }
512 return ret;
513 }
514
515 static unsigned short fetch_ushort(const BYTE** ptr)
516 {
517 unsigned short ret;
518
519 if (*(*ptr) & 1)
520 {
521 ret = *(const unsigned short*)(*ptr) / 2;
522 (*ptr) += 2;
523 }
524 else
525 {
526 ret = *(const unsigned char*)(*ptr) / 2;
527 (*ptr)++;
528 }
529 return ret;
530 }
531
532 /***********************************************************************
533 *
534 * HLPFILE_SkipParagraph
535 */
536 static BOOL HLPFILE_SkipParagraph(HLPFILE *hlpfile, const BYTE *buf, const BYTE *end, unsigned* len)
537 {
538 const BYTE *tmp;
539
540 if (!hlpfile->first_page) {WINE_WARN("no page\n"); return FALSE;};
541 if (buf + 0x19 > end) {WINE_WARN("header too small\n"); return FALSE;};
542
543 tmp = buf + 0x15;
544 if (buf[0x14] == 0x20 || buf[0x14] == 0x23)
545 {
546 fetch_long(&tmp);
547 *len = fetch_ushort(&tmp);
548 }
549 else *len = end-buf-15;
550
551 return TRUE;
552 }
553
554 /******************************************************************
555 * HLPFILE_DecompressGfx
556 *
557 * Decompress the data part of a bitmap or a metafile
558 */
559 static const BYTE* HLPFILE_DecompressGfx(const BYTE* src, unsigned csz, unsigned sz, BYTE packing,
560 BYTE** alloc)
561 {
562 const BYTE* dst;
563 BYTE* tmp;
564 unsigned sz77;
565
566 WINE_TRACE("Unpacking (%d) from %u bytes to %u bytes\n", packing, csz, sz);
567
568 switch (packing)
569 {
570 case 0: /* uncompressed */
571 if (sz != csz)
572 WINE_WARN("Bogus gfx sizes (uncompressed): %u / %u\n", sz, csz);
573 dst = src;
574 *alloc = NULL;
575 break;
576 case 1: /* RunLen */
577 dst = *alloc = HeapAlloc(GetProcessHeap(), 0, sz);
578 if (!dst) return NULL;
579 HLPFILE_UncompressRLE(src, src + csz, *alloc, sz);
580 break;
581 case 2: /* LZ77 */
582 sz77 = HLPFILE_UncompressedLZ77_Size(src, src + csz);
583 dst = *alloc = HeapAlloc(GetProcessHeap(), 0, sz77);
584 if (!dst) return NULL;
585 HLPFILE_UncompressLZ77(src, src + csz, *alloc);
586 if (sz77 != sz)
587 WINE_WARN("Bogus gfx sizes (LZ77): %u / %u\n", sz77, sz);
588 break;
589 case 3: /* LZ77 then RLE */
590 sz77 = HLPFILE_UncompressedLZ77_Size(src, src + csz);
591 tmp = HeapAlloc(GetProcessHeap(), 0, sz77);
592 if (!tmp) return FALSE;
593 HLPFILE_UncompressLZ77(src, src + csz, tmp);
594 dst = *alloc = HeapAlloc(GetProcessHeap(), 0, sz);
595 if (!dst)
596 {
597 HeapFree(GetProcessHeap(), 0, tmp);
598 return FALSE;
599 }
600 HLPFILE_UncompressRLE(tmp, tmp + sz77, *alloc, sz);
601 HeapFree(GetProcessHeap(), 0, tmp);
602 break;
603 default:
604 WINE_FIXME("Unsupported packing %u\n", packing);
605 return NULL;
606 }
607 return dst;
608 }
609
610 static BOOL HLPFILE_RtfAddRawString(struct RtfData* rd, const char* str, size_t sz)
611 {
612 if (rd->ptr + sz >= rd->data + rd->allocated)
613 {
614 char* new = HeapReAlloc(GetProcessHeap(), 0, rd->data, rd->allocated *= 2);
615 if (!new) return FALSE;
616 rd->ptr = new + (rd->ptr - rd->data);
617 rd->data = new;
618 }
619 memcpy(rd->ptr, str, sz);
620 rd->ptr += sz;
621
622 return TRUE;
623 }
624
625 static BOOL HLPFILE_RtfAddControl(struct RtfData* rd, const char* str)
626 {
627 if (*str == '\\' || *str == '{') rd->in_text = FALSE;
628 else if (*str == '}') rd->in_text = TRUE;
629 return HLPFILE_RtfAddRawString(rd, str, strlen(str));
630 }
631
632 static BOOL HLPFILE_RtfAddText(struct RtfData* rd, const char* str)
633 {
634 const char* p;
635 const char* last;
636 const char* replace;
637 unsigned rlen;
638
639 if (!rd->in_text)
640 {
641 if (!HLPFILE_RtfAddRawString(rd, " ", 1)) return FALSE;
642 rd->in_text = TRUE;
643 }
644 for (last = p = str; *p; p++)
645 {
646 if (*p < 0) /* escape non ASCII chars */
647 {
648 static char xx[8];
649 rlen = sprintf(xx, "\\'%x", *(const BYTE*)p);
650 replace = xx;
651 }
652 else switch (*p)
653 {
654 case '{': rlen = 2; replace = "\\{"; break;
655 case '}': rlen = 2; replace = "\\}"; break;
656 case '\\': rlen = 2; replace = "\\\\"; break;
657 default: continue;
658 }
659 if ((p != last && !HLPFILE_RtfAddRawString(rd, last, p - last)) ||
660 !HLPFILE_RtfAddRawString(rd, replace, rlen)) return FALSE;
661 last = p + 1;
662 }
663 return HLPFILE_RtfAddRawString(rd, last, p - last);
664 }
665
666 /******************************************************************
667 * RtfAddHexBytes
668 *
669 */
670 static BOOL HLPFILE_RtfAddHexBytes(struct RtfData* rd, const void* _ptr, unsigned sz)
671 {
672 char tmp[512];
673 unsigned i, step;
674 const BYTE* ptr = _ptr;
675 static const char* _2hex = "0123456789abcdef";
676
677 if (!rd->in_text)
678 {
679 if (!HLPFILE_RtfAddRawString(rd, " ", 1)) return FALSE;
680 rd->in_text = TRUE;
681 }
682 for (; sz; sz -= step)
683 {
684 step = min(256, sz);
685 for (i = 0; i < step; i++)
686 {
687 tmp[2 * i + 0] = _2hex[*ptr >> 4];
688 tmp[2 * i + 1] = _2hex[*ptr++ & 0xF];
689 }
690 if (!HLPFILE_RtfAddRawString(rd, tmp, 2 * step)) return FALSE;
691 }
692 return TRUE;
693 }
694
695 /******************************************************************
696 * HLPFILE_RtfAddTransparentBitmap
697 *
698 * We'll transform a transparent bitmap into an metafile that
699 * we then transform into RTF
700 */
701 static BOOL HLPFILE_RtfAddTransparentBitmap(struct RtfData* rd, const BITMAPINFO* bi,
702 const void* pict, unsigned nc)
703 {
704 HDC hdc, hdcMask, hdcMem, hdcEMF;
705 HBITMAP hbm, hbmMask, hbmOldMask, hbmOldMem;
706 HENHMETAFILE hEMF;
707 BOOL ret = FALSE;
708 void* data;
709 UINT sz;
710
711 hbm = CreateDIBitmap(hdc = GetDC(0), &bi->bmiHeader,
712 CBM_INIT, pict, bi, DIB_RGB_COLORS);
713
714 hdcMem = CreateCompatibleDC(hdc);
715 hbmOldMem = SelectObject(hdcMem, hbm);
716
717 /* create the mask bitmap from the main bitmap */
718 hdcMask = CreateCompatibleDC(hdc);
719 hbmMask = CreateBitmap(bi->bmiHeader.biWidth, bi->bmiHeader.biHeight, 1, 1, NULL);
720 hbmOldMask = SelectObject(hdcMask, hbmMask);
721 SetBkColor(hdcMem,
722 RGB(bi->bmiColors[nc - 1].rgbRed,
723 bi->bmiColors[nc - 1].rgbGreen,
724 bi->bmiColors[nc - 1].rgbBlue));
725 BitBlt(hdcMask, 0, 0, bi->bmiHeader.biWidth, bi->bmiHeader.biHeight, hdcMem, 0, 0, SRCCOPY);
726
727 /* sets to RGB(0,0,0) the transparent bits in main bitmap */
728 SetBkColor(hdcMem, RGB(0,0,0));
729 SetTextColor(hdcMem, RGB(255,255,255));
730 BitBlt(hdcMem, 0, 0, bi->bmiHeader.biWidth, bi->bmiHeader.biHeight, hdcMask, 0, 0, SRCAND);
731
732 SelectObject(hdcMask, hbmOldMask);
733 DeleteDC(hdcMask);
734
735 SelectObject(hdcMem, hbmOldMem);
736 DeleteDC(hdcMem);
737
738 /* we create the bitmap on the fly */
739 hdcEMF = CreateEnhMetaFile(NULL, NULL, NULL, NULL);
740 hdcMem = CreateCompatibleDC(hdcEMF);
741
742 /* sets to RGB(0,0,0) the transparent bits in final bitmap */
743 hbmOldMem = SelectObject(hdcMem, hbmMask);
744 SetBkColor(hdcEMF, RGB(255, 255, 255));
745 SetTextColor(hdcEMF, RGB(0, 0, 0));
746 BitBlt(hdcEMF, 0, 0, bi->bmiHeader.biWidth, bi->bmiHeader.biHeight, hdcMem, 0, 0, SRCAND);
747
748 /* and copy the remaining bits of main bitmap */
749 SelectObject(hdcMem, hbm);
750 BitBlt(hdcEMF, 0, 0, bi->bmiHeader.biWidth, bi->bmiHeader.biHeight, hdcMem, 0, 0, SRCPAINT);
751 SelectObject(hdcMem, hbmOldMem);
752 DeleteDC(hdcMem);
753
754 /* do the cleanup */
755 ReleaseDC(0, hdc);
756 DeleteObject(hbmMask);
757 DeleteObject(hbm);
758
759 hEMF = CloseEnhMetaFile(hdcEMF);
760
761 /* generate rtf stream */
762 sz = GetEnhMetaFileBits(hEMF, 0, NULL);
763 if (sz && (data = HeapAlloc(GetProcessHeap(), 0, sz)))
764 {
765 if (sz == GetEnhMetaFileBits(hEMF, sz, data))
766 {
767 ret = HLPFILE_RtfAddControl(rd, "{\\pict\\emfblip") &&
768 HLPFILE_RtfAddHexBytes(rd, data, sz) &&
769 HLPFILE_RtfAddControl(rd, "}");
770 }
771 HeapFree(GetProcessHeap(), 0, data);
772 }
773 DeleteEnhMetaFile(hEMF);
774
775 return ret;
776 }
777
778 /******************************************************************
779 * HLPFILE_RtfAddBitmap
780 *
781 */
782 static BOOL HLPFILE_RtfAddBitmap(struct RtfData* rd, const BYTE* beg, BYTE type, BYTE pack)
783 {
784 const BYTE* ptr;
785 const BYTE* pict_beg;
786 BYTE* alloc = NULL;
787 BITMAPINFO* bi;
788 unsigned long off, csz;
789 unsigned nc = 0;
790 BOOL clrImportant = FALSE;
791 BOOL ret = FALSE;
792 char tmp[256];
793
794 bi = HeapAlloc(GetProcessHeap(), 0, sizeof(*bi));
795 if (!bi) return FALSE;
796
797 ptr = beg + 2; /* for type and pack */
798
799 bi->bmiHeader.biSize = sizeof(bi->bmiHeader);
800 bi->bmiHeader.biXPelsPerMeter = fetch_ulong(&ptr);
801 bi->bmiHeader.biYPelsPerMeter = fetch_ulong(&ptr);
802 bi->bmiHeader.biPlanes = fetch_ushort(&ptr);
803 bi->bmiHeader.biBitCount = fetch_ushort(&ptr);
804 bi->bmiHeader.biWidth = fetch_ulong(&ptr);
805 bi->bmiHeader.biHeight = fetch_ulong(&ptr);
806 bi->bmiHeader.biClrUsed = fetch_ulong(&ptr);
807 clrImportant = fetch_ulong(&ptr);
808 bi->bmiHeader.biClrImportant = (clrImportant > 1) ? clrImportant : 0;
809 bi->bmiHeader.biCompression = BI_RGB;
810 if (bi->bmiHeader.biBitCount > 32) WINE_FIXME("Unknown bit count %u\n", bi->bmiHeader.biBitCount);
811 if (bi->bmiHeader.biPlanes != 1) WINE_FIXME("Unsupported planes %u\n", bi->bmiHeader.biPlanes);
812 bi->bmiHeader.biSizeImage = (((bi->bmiHeader.biWidth * bi->bmiHeader.biBitCount + 31) & ~31) / 8) * bi->bmiHeader.biHeight;
813 WINE_TRACE("planes=%d bc=%d size=(%d,%d)\n",
814 bi->bmiHeader.biPlanes, bi->bmiHeader.biBitCount,
815 bi->bmiHeader.biWidth, bi->bmiHeader.biHeight);
816
817 csz = fetch_ulong(&ptr);
818 fetch_ulong(&ptr); /* hotspot size */
819
820 off = GET_UINT(ptr, 0); ptr += 4;
821 /* GET_UINT(ptr, 0); hotspot offset */ ptr += 4;
822
823 /* now read palette info */
824 if (type == 0x06)
825 {
826 unsigned i;
827
828 nc = bi->bmiHeader.biClrUsed;
829 /* not quite right, especially for bitfields type of compression */
830 if (!nc && bi->bmiHeader.biBitCount <= 8)
831 nc = 1 << bi->bmiHeader.biBitCount;
832
833 bi = HeapReAlloc(GetProcessHeap(), 0, bi, sizeof(*bi) + nc * sizeof(RGBQUAD));
834 if (!bi) return FALSE;
835 for (i = 0; i < nc; i++)
836 {
837 bi->bmiColors[i].rgbBlue = ptr[0];
838 bi->bmiColors[i].rgbGreen = ptr[1];
839 bi->bmiColors[i].rgbRed = ptr[2];
840 bi->bmiColors[i].rgbReserved = 0;
841 ptr += 4;
842 }
843 }
844 pict_beg = HLPFILE_DecompressGfx(beg + off, csz, bi->bmiHeader.biSizeImage, pack, &alloc);
845
846 if (clrImportant == 1 && nc > 0)
847 {
848 ret = HLPFILE_RtfAddTransparentBitmap(rd, bi, pict_beg, nc);
849 goto done;
850 }
851 if (!HLPFILE_RtfAddControl(rd, "{\\pict")) goto done;
852 if (type == 0x06)
853 {
854 sprintf(tmp, "\\dibitmap0\\picw%d\\pich%d",
855 bi->bmiHeader.biWidth, bi->bmiHeader.biHeight);
856 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
857 if (!HLPFILE_RtfAddHexBytes(rd, bi, sizeof(*bi) + nc * sizeof(RGBQUAD))) goto done;
858 }
859 else
860 {
861 sprintf(tmp, "\\wbitmap0\\wbmbitspixel%d\\wbmplanes%d\\picw%d\\pich%d",
862 bi->bmiHeader.biBitCount, bi->bmiHeader.biPlanes,
863 bi->bmiHeader.biWidth, bi->bmiHeader.biHeight);
864 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
865 }
866 if (!HLPFILE_RtfAddHexBytes(rd, pict_beg, bi->bmiHeader.biSizeImage)) goto done;
867 if (!HLPFILE_RtfAddControl(rd, "}")) goto done;
868
869 ret = TRUE;
870 done:
871 HeapFree(GetProcessHeap(), 0, bi);
872 HeapFree(GetProcessHeap(), 0, alloc);
873
874 return ret;
875 }
876
877 /******************************************************************
878 * HLPFILE_RtfAddMetaFile
879 *
880 */
881 static BOOL HLPFILE_RtfAddMetaFile(struct RtfData* rd, const BYTE* beg, BYTE pack)
882 {
883 const BYTE* ptr;
884 unsigned long size, csize;
885 unsigned long off, hsoff;
886 const BYTE* bits;
887 BYTE* alloc = NULL;
888 char tmp[256];
889 unsigned mm;
890 BOOL ret;
891
892 WINE_TRACE("Loading metafile\n");
893
894 ptr = beg + 2; /* for type and pack */
895
896 mm = fetch_ushort(&ptr); /* mapping mode */
897 sprintf(tmp, "{\\pict\\wmetafile%d\\picw%d\\pich%d",
898 mm, GET_USHORT(ptr, 0), GET_USHORT(ptr, 2));
899 if (!HLPFILE_RtfAddControl(rd, tmp)) return FALSE;
900 ptr += 4;
901
902 size = fetch_ulong(&ptr); /* decompressed size */
903 csize = fetch_ulong(&ptr); /* compressed size */
904 fetch_ulong(&ptr); /* hotspot size */
905 off = GET_UINT(ptr, 0);
906 hsoff = GET_UINT(ptr, 4);
907 ptr += 8;
908
909 WINE_TRACE("sz=%lu csz=%lu offs=%lu/%u,%lu\n",
910 size, csize, off, ptr - beg, hsoff);
911
912 bits = HLPFILE_DecompressGfx(beg + off, csize, size, pack, &alloc);
913 if (!bits) return FALSE;
914
915 ret = HLPFILE_RtfAddHexBytes(rd, bits, size) &&
916 HLPFILE_RtfAddControl(rd, "}");
917
918 HeapFree(GetProcessHeap(), 0, alloc);
919
920 return ret;
921 }
922
923 /******************************************************************
924 * HLPFILE_RtfAddGfxByAddr
925 *
926 */
927 static BOOL HLPFILE_RtfAddGfxByAddr(struct RtfData* rd, HLPFILE *hlpfile,
928 const BYTE* ref, unsigned long size)
929 {
930 unsigned i, numpict;
931
932 numpict = GET_USHORT(ref, 2);
933 WINE_TRACE("Got picture magic=%04x #=%d\n", GET_USHORT(ref, 0), numpict);
934
935 for (i = 0; i < numpict; i++)
936 {
937 const BYTE* beg;
938 const BYTE* ptr;
939 BYTE type, pack;
940
941 WINE_TRACE("Offset[%d] = %x\n", i, GET_UINT(ref, (1 + i) * 4));
942 beg = ptr = ref + GET_UINT(ref, (1 + i) * 4);
943
944 type = *ptr++;
945 pack = *ptr++;
946
947 switch (type)
948 {
949 case 5: /* device dependent bmp */
950 case 6: /* device independent bmp */
951 HLPFILE_RtfAddBitmap(rd, beg, type, pack);
952 break;
953 case 8:
954 HLPFILE_RtfAddMetaFile(rd, beg, pack);
955 break;
956 default: WINE_FIXME("Unknown type %u\n", type); return FALSE;
957 }
958
959 /* FIXME: hotspots */
960
961 /* FIXME: implement support for multiple picture format */
962 if (numpict != 1) WINE_FIXME("Supporting only one bitmap format per logical bitmap (for now). Using first format\n");
963 break;
964 }
965 return TRUE;
966 }
967
968 /******************************************************************
969 * HLPFILE_RtfAddGfxByIndex
970 *
971 *
972 */
973 static BOOL HLPFILE_RtfAddGfxByIndex(struct RtfData* rd, HLPFILE *hlpfile,
974 unsigned index)
975 {
976 char tmp[16];
977 BYTE *ref, *end;
978
979 WINE_TRACE("Loading picture #%d\n", index);
980
981 sprintf(tmp, "|bm%u", index);
982
983 if (!HLPFILE_FindSubFile(hlpfile, tmp, &ref, &end)) {WINE_WARN("no sub file\n"); return FALSE;}
984
985 ref += 9;
986 return HLPFILE_RtfAddGfxByAddr(rd, hlpfile, ref, end - ref);
987 }
988
989 /******************************************************************
990 * HLPFILE_AllocLink
991 *
992 *
993 */
994 static HLPFILE_LINK* HLPFILE_AllocLink(struct RtfData* rd, int cookie,
995 const char* str, unsigned len, LONG hash,
996 unsigned clrChange, unsigned wnd)
997 {
998 HLPFILE_LINK* link;
999 char* link_str;
1000
1001 /* FIXME: should build a string table for the attributes.link.lpszPath
1002 * they are reallocated for each link
1003 */
1004 if (len == -1) len = strlen(str);
1005 link = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_LINK) + len + 1);
1006 if (!link) return NULL;
1007
1008 link->cookie = cookie;
1009 link->string = link_str = (char*)(link + 1);
1010 memcpy(link_str, str, len);
1011 link_str[len] = '\0';
1012 link->hash = hash;
1013 link->bClrChange = clrChange ? 1 : 0;
1014 link->window = wnd;
1015 link->next = rd->first_link;
1016 rd->first_link = link;
1017 link->cpMin = rd->char_pos;
1018 link->cpMax = 0;
1019 rd->force_color = clrChange;
1020 if (rd->current_link) WINE_FIXME("Pending link\n");
1021 rd->current_link = link;
1022
1023 WINE_TRACE("Link[%d] to %s@%08x:%d\n",
1024 link->cookie, link->string, link->hash, link->window);
1025 return link;
1026 }
1027
1028 unsigned HLPFILE_HalfPointsToTwips(unsigned pts)
1029 {
1030 static unsigned logPxY;
1031 if (!logPxY)
1032 {
1033 HDC hdc = GetDC(NULL);
1034 logPxY = GetDeviceCaps(hdc, LOGPIXELSY);
1035 ReleaseDC(NULL, hdc);
1036 }
1037 return MulDiv(pts, 72 * 10, logPxY);
1038 }
1039
1040 /***********************************************************************
1041 *
1042 * HLPFILE_BrowseParagraph
1043 */
1044 static BOOL HLPFILE_BrowseParagraph(HLPFILE_PAGE* page, struct RtfData* rd,
1045 BYTE *buf, BYTE* end, unsigned* parlen)
1046 {
1047 UINT textsize;
1048 const BYTE *format, *format_end;
1049 char *text, *text_base, *text_end;
1050 long size, blocksize, datalen;
1051 unsigned short bits;
1052 unsigned nc, ncol = 1;
1053 short table_width;
1054 BOOL in_table = FALSE;
1055 char tmp[256];
1056 BOOL ret = FALSE;
1057
1058 if (buf + 0x19 > end) {WINE_WARN("header too small\n"); return FALSE;};
1059
1060 *parlen = 0;
1061 blocksize = GET_UINT(buf, 0);
1062 size = GET_UINT(buf, 0x4);
1063 datalen = GET_UINT(buf, 0x10);
1064 text = text_base = HeapAlloc(GetProcessHeap(), 0, size);
1065 if (!text) return FALSE;
1066 if (size > blocksize - datalen)
1067 {
1068 /* need to decompress */
1069 if (page->file->hasPhrases)
1070 HLPFILE_Uncompress2(page->file, buf + datalen, end, (BYTE*)text, (BYTE*)text + size);
1071 else if (page->file->hasPhrases40)
1072 HLPFILE_Uncompress3(page->file, text, text + size, buf + datalen, end);
1073 else
1074 {
1075 WINE_FIXME("Text size is too long, splitting\n");
1076 size = blocksize - datalen;
1077 memcpy(text, buf + datalen, size);
1078 }
1079 }
1080 else
1081 memcpy(text, buf + datalen, size);
1082
1083 text_end = text + size;
1084
1085 format = buf + 0x15;
1086 format_end = buf + GET_UINT(buf, 0x10);
1087
1088 if (buf[0x14] == 0x20 || buf[0x14] == 0x23)
1089 {
1090 fetch_long(&format);
1091 *parlen = fetch_ushort(&format);
1092 }
1093
1094 if (buf[0x14] == 0x23)
1095 {
1096 char type;
1097
1098 in_table = TRUE;
1099 ncol = *format++;
1100
1101 if (!HLPFILE_RtfAddControl(rd, "\\trowd")) goto done;
1102 type = *format++;
1103 if (type == 0 || type == 2)
1104 {
1105 table_width = GET_SHORT(format, 0);
1106 format += 2;
1107 }
1108 else
1109 table_width = 32767;
1110 WINE_TRACE("New table: cols=%d type=%x width=%d\n",
1111 ncol, type, table_width);
1112 if (ncol > 1)
1113 {
1114 int pos;
1115 sprintf(tmp, "\\trgaph%d\\trleft%d",
1116 HLPFILE_HalfPointsToTwips(MulDiv(GET_SHORT(format, 6), table_width, 32767)),
1117 HLPFILE_HalfPointsToTwips(MulDiv(GET_SHORT(format, 0), table_width, 32767)));
1118 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1119 pos = HLPFILE_HalfPointsToTwips(MulDiv(GET_SHORT(format, 6) / 2, table_width, 32767));
1120 for (nc = 0; nc < ncol; nc++)
1121 {
1122 WINE_TRACE("column(%d/%d) gap=%d width=%d\n",
1123 nc, ncol, GET_SHORT(format, nc*4),
1124 GET_SHORT(format, nc*4+2));
1125 pos += GET_SHORT(format, nc * 4) + GET_SHORT(format, nc * 4 + 2);
1126 sprintf(tmp, "\\cellx%d",
1127 HLPFILE_HalfPointsToTwips(MulDiv(pos, table_width, 32767)));
1128 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1129 }
1130 }
1131 else
1132 {
1133 WINE_TRACE("column(0/%d) gap=%d width=%d\n",
1134 ncol, GET_SHORT(format, 0), GET_SHORT(format, 2));
1135 sprintf(tmp, "\\trleft%d\\cellx%d ",
1136 HLPFILE_HalfPointsToTwips(MulDiv(GET_SHORT(format, 0), table_width, 32767)),
1137 HLPFILE_HalfPointsToTwips(MulDiv(GET_SHORT(format, 0) + GET_SHORT(format, 2),
1138 table_width, 32767)));
1139 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1140 }
1141 format += ncol * 4;
1142 }
1143
1144 for (nc = 0; nc < ncol; /**/)
1145 {
1146 WINE_TRACE("looking for format at offset %lu in column %d\n", (SIZE_T)(format - (buf + 0x15)), nc);
1147 if (!HLPFILE_RtfAddControl(rd, "\\pard")) goto done;
1148 if (in_table)
1149 {
1150 nc = GET_SHORT(format, 0);
1151 if (nc == -1) break;
1152 format += 5;
1153 if (!HLPFILE_RtfAddControl(rd, "\\intbl")) goto done;
1154 }
1155 else nc++;
1156 if (buf[0x14] == 0x01)
1157 format += 6;
1158 else
1159 format += 4;
1160 bits = GET_USHORT(format, 0); format += 2;
1161 if (bits & 0x0001) fetch_long(&format);
1162 if (bits & 0x0002)
1163 {
1164 sprintf(tmp, "\\sb%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1165 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1166 }
1167 if (bits & 0x0004)
1168 {
1169 sprintf(tmp, "\\sa%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1170 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1171 }
1172 if (bits & 0x0008)
1173 {
1174 sprintf(tmp, "\\sl%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1175 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1176 }
1177 if (bits & 0x0010)
1178 {
1179 sprintf(tmp, "\\li%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1180 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1181 }
1182 if (bits & 0x0020)
1183 {
1184 sprintf(tmp, "\\ri%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1185 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1186 }
1187 if (bits & 0x0040)
1188 {
1189 sprintf(tmp, "\\fi%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1190 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1191 }
1192 if (bits & 0x0100)
1193 {
1194 BYTE brdr = *format++;
1195 short w;
1196
1197 if (brdr & 0x01 && !HLPFILE_RtfAddControl(rd, "\\box")) goto done;
1198 if (brdr & 0x02 && !HLPFILE_RtfAddControl(rd, "\\brdrt")) goto done;
1199 if (brdr & 0x04 && !HLPFILE_RtfAddControl(rd, "\\brdrl")) goto done;
1200 if (brdr & 0x08 && !HLPFILE_RtfAddControl(rd, "\\brdrb")) goto done;
1201 if (brdr & 0x10 && !HLPFILE_RtfAddControl(rd, "\\brdrr")) goto done;
1202 if (brdr & 0x20 && !HLPFILE_RtfAddControl(rd, "\\brdrth")) goto done;
1203 if (!(brdr & 0x20) && !HLPFILE_RtfAddControl(rd, "\\brdrs")) goto done;
1204 if (brdr & 0x40 && !HLPFILE_RtfAddControl(rd, "\\brdrdb")) goto done;
1205 /* 0x80: unknown */
1206
1207 w = GET_SHORT(format, 0); format += 2;
1208 if (w)
1209 {
1210 sprintf(tmp, "\\brdrw%d", HLPFILE_HalfPointsToTwips(w));
1211 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1212 }
1213 }
1214 if (bits & 0x0200)
1215 {
1216 int i, ntab = fetch_short(&format);
1217 unsigned tab, ts;
1218 const char* kind;
1219
1220 for (i = 0; i < ntab; i++)
1221 {
1222 tab = fetch_ushort(&format);
1223 ts = (tab & 0x4000) ? fetch_ushort(&format) : 0 /* left */;
1224 switch (ts)
1225 {
1226 default: WINE_FIXME("Unknown tab style %x\n", ts);
1227 /* fall through */
1228 case 0: kind = ""; break;
1229 case 1: kind = "\\tqr"; break;
1230 case 2: kind = "\\tqc"; break;
1231 }
1232 /* FIXME: do kind */
1233 sprintf(tmp, "%s\\tx%d",
1234 kind, HLPFILE_HalfPointsToTwips(tab & 0x3FFF));
1235 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1236 }
1237 }
1238 switch (bits & 0xc00)
1239 {
1240 default: WINE_FIXME("Unsupported alignment 0xC00\n"); break;
1241 case 0: if (!HLPFILE_RtfAddControl(rd, "\\ql")) goto done; break;
1242 case 0x400: if (!HLPFILE_RtfAddControl(rd, "\\qr")) goto done; break;
1243 case 0x800: if (!HLPFILE_RtfAddControl(rd, "\\qc")) goto done; break;
1244 }
1245
1246 /* 0x1000 doesn't need space */
1247 if ((bits & 0x1000) && !HLPFILE_RtfAddControl(rd, "\\keep")) goto done;
1248 if ((bits & 0xE080) != 0)
1249 WINE_FIXME("Unsupported bits %04x, potential trouble ahead\n", bits);
1250
1251 while (text < text_end && format < format_end)
1252 {
1253 WINE_TRACE("Got text: %s (%p/%p - %p/%p)\n", wine_dbgstr_a(text), text, text_end, format, format_end);
1254 textsize = strlen(text);
1255 if (textsize)
1256 {
1257 if (rd->force_color)
1258 {
1259 if ((rd->current_link->cookie == hlp_link_popup) ?
1260 !HLPFILE_RtfAddControl(rd, "{\\uld\\cf1") :
1261 !HLPFILE_RtfAddControl(rd, "{\\ul\\cf1")) goto done;
1262 }
1263 if (!HLPFILE_RtfAddText(rd, text)) goto done;
1264 if (rd->force_color && !HLPFILE_RtfAddControl(rd, "}")) goto done;
1265 rd->char_pos += textsize;
1266 }
1267 /* else: null text, keep on storing attributes */
1268 text += textsize + 1;
1269
1270 if (*format == 0xff)
1271 {
1272 format++;
1273 break;
1274 }
1275
1276 WINE_TRACE("format=%02x\n", *format);
1277 switch (*format)
1278 {
1279 case 0x20:
1280 WINE_FIXME("NIY20\n");
1281 format += 5;
1282 break;
1283
1284 case 0x21:
1285 WINE_FIXME("NIY21\n");
1286 format += 3;
1287 break;
1288
1289 case 0x80:
1290 {
1291 unsigned font = GET_USHORT(format, 1);
1292 unsigned fs;
1293
1294 WINE_TRACE("Changing font to %d\n", font);
1295 format += 3;
1296 /* Font size in hlpfile is given in the same units as
1297 rtf control word \fs uses (half-points). */
1298 switch (rd->font_scale)
1299 {
1300 case 0: fs = page->file->fonts[font].LogFont.lfHeight - 4; break;
1301 default:
1302 case 1: fs = page->file->fonts[font].LogFont.lfHeight; break;
1303 case 2: fs = page->file->fonts[font].LogFont.lfHeight + 4; break;
1304 }
1305 /* FIXME: missing at least colors, also bold attribute looses information */
1306
1307 sprintf(tmp, "\\f%d\\cf%d\\fs%d%s%s%s%s",
1308 font, font + 2, fs,
1309 page->file->fonts[font].LogFont.lfWeight > 400 ? "\\b" : "\\b0",
1310 page->file->fonts[font].LogFont.lfItalic ? "\\i" : "\\i0",
1311 page->file->fonts[font].LogFont.lfUnderline ? "\\ul" : "\\ul0",
1312 page->file->fonts[font].LogFont.lfStrikeOut ? "\\strike" : "\\strike0");
1313 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1314 }
1315 break;
1316
1317 case 0x81:
1318 if (!HLPFILE_RtfAddControl(rd, "\\line")) goto done;
1319 format += 1;
1320 rd->char_pos++;
1321 break;
1322
1323 case 0x82:
1324 if (in_table)
1325 {
1326 if (format[1] != 0xFF)
1327 {
1328 if (!HLPFILE_RtfAddControl(rd, "\\par\\intbl")) goto done;
1329 }
1330 else
1331 {
1332 if (!HLPFILE_RtfAddControl(rd, "\\cell\\pard\\intbl")) goto done;
1333 }
1334 }
1335 else if (!HLPFILE_RtfAddControl(rd, "\\par")) goto done;
1336 format += 1;
1337 rd->char_pos++;
1338 break;
1339
1340 case 0x83:
1341 if (!HLPFILE_RtfAddControl(rd, "\\tab")) goto done;
1342 format += 1;
1343 rd->char_pos++;
1344 break;
1345
1346 #if 0
1347 case 0x84:
1348 format += 3;
1349 break;
1350 #endif
1351
1352 case 0x86:
1353 case 0x87:
1354 case 0x88:
1355 {
1356 BYTE type = format[1];
1357 long size;
1358
1359 /* FIXME: we don't use 'BYTE pos = (*format - 0x86);' for the image position */
1360 format += 2;
1361 size = fetch_long(&format);
1362
1363 switch (type)
1364 {
1365 case 0x22:
1366 fetch_ushort(&format); /* hot spot */
1367 /* fall thru */
1368 case 0x03:
1369 switch (GET_SHORT(format, 0))
1370 {
1371 case 0:
1372 HLPFILE_RtfAddGfxByIndex(rd, page->file, GET_SHORT(format, 2));
1373 rd->char_pos++;
1374 break;
1375 case 1:
1376 WINE_FIXME("does it work ??? %x<%lu>#%u\n",
1377 GET_SHORT(format, 0),
1378 size, GET_SHORT(format, 2));
1379 HLPFILE_RtfAddGfxByAddr(rd, page->file, format + 2, size - 4);
1380 rd->char_pos++;
1381 break;
1382 default:
1383 WINE_FIXME("??? %u\n", GET_SHORT(format, 0));
1384 break;
1385 }
1386 break;
1387 case 0x05:
1388 WINE_FIXME("Got an embedded element %s\n", format + 6);
1389 break;
1390 default:
1391 WINE_FIXME("Got a type %d picture\n", type);
1392 break;
1393 }
1394 format += size;
1395 }
1396 break;
1397
1398 case 0x89:
1399 format += 1;
1400 if (!rd->current_link)
1401 WINE_FIXME("No existing link\n");
1402 rd->current_link->cpMax = rd->char_pos;
1403 rd->current_link = NULL;
1404 rd->force_color = FALSE;
1405 break;
1406
1407 case 0x8B:
1408 if (!HLPFILE_RtfAddControl(rd, "\\~")) goto done;
1409 format += 1;
1410 rd->char_pos++;
1411 break;
1412
1413 case 0x8C:
1414 if (!HLPFILE_RtfAddControl(rd, "\\_")) goto done;
1415 /* FIXME: it could be that hypen is also in input stream !! */
1416 format += 1;
1417 rd->char_pos++;
1418 break;
1419
1420 #if 0
1421 case 0xA9:
1422 format += 2;
1423 break;
1424 #endif
1425
1426 case 0xC8:
1427 case 0xCC:
1428 WINE_TRACE("macro => %s\n", format + 3);
1429 HLPFILE_AllocLink(rd, hlp_link_macro, (const char*)format + 3,
1430 GET_USHORT(format, 1), 0, !(*format & 4), -1);
1431 format += 3 + GET_USHORT(format, 1);
1432 break;
1433
1434 case 0xE0:
1435 case 0xE1:
1436 WINE_WARN("jump topic 1 => %u\n", GET_UINT(format, 1));
1437 HLPFILE_AllocLink(rd, (*format & 1) ? hlp_link_link : hlp_link_popup,
1438 page->file->lpszPath, -1, GET_UINT(format, 1), 1, -1);
1439
1440
1441 format += 5;
1442 break;
1443
1444 case 0xE2:
1445 case 0xE3:
1446 case 0xE6:
1447 case 0xE7:
1448 HLPFILE_AllocLink(rd, (*format & 1) ? hlp_link_link : hlp_link_popup,
1449 page->file->lpszPath, -1, GET_UINT(format, 1),
1450 !(*format & 4), -1);
1451 format += 5;
1452 break;
1453
1454 case 0xEA:
1455 case 0xEB:
1456 case 0xEE:
1457 case 0xEF:
1458 {
1459 char* ptr = (char*) format + 8;
1460 BYTE type = format[3];
1461 int wnd = -1;
1462
1463 switch (type)
1464 {
1465 case 1:
1466 wnd = *ptr;
1467 /* fall through */
1468 case 0:
1469 ptr = page->file->lpszPath;
1470 break;
1471 case 6:
1472 for (wnd = page->file->numWindows - 1; wnd >= 0; wnd--)
1473 {
1474 if (!strcmp(ptr, page->file->windows[wnd].name)) break;
1475 }
1476 if (wnd == -1)
1477 WINE_WARN("Couldn't find window info for %s\n", ptr);
1478 ptr += strlen(ptr) + 1;
1479 /* fall through */
1480 case 4:
1481 break;
1482 default:
1483 WINE_WARN("Unknown link type %d\n", type);
1484 break;
1485 }
1486 HLPFILE_AllocLink(rd, (*format & 1) ? hlp_link_link : hlp_link_popup,
1487 ptr, -1, GET_UINT(format, 4), !(*format & 4), wnd);
1488 }
1489 format += 3 + GET_USHORT(format, 1);
1490 break;
1491
1492 default:
1493 WINE_WARN("format %02x\n", *format);
1494 format++;
1495 }
1496 }
1497 }
1498 if (in_table)
1499 {
1500 if (!HLPFILE_RtfAddControl(rd, "\\row\\par\\pard\\plain")) goto done;
1501 rd->char_pos += 2;
1502 }
1503 ret = TRUE;
1504 done:
1505
1506 HeapFree(GetProcessHeap(), 0, text_base);
1507 return ret;
1508 }
1509
1510 /******************************************************************
1511 * HLPFILE_BrowsePage
1512 *
1513 */
1514 BOOL HLPFILE_BrowsePage(HLPFILE_PAGE* page, struct RtfData* rd,
1515 unsigned font_scale, unsigned relative)
1516 {
1517 HLPFILE *hlpfile = page->file;
1518 BYTE *buf, *end;
1519 DWORD ref = page->reference;
1520 unsigned index, old_index = -1, offset, count = 0, offs = 0;
1521 unsigned cpg, parlen;
1522 char tmp[1024];
1523 const char* ck = NULL;
1524
1525 rd->in_text = TRUE;
1526 rd->data = rd->ptr = HeapAlloc(GetProcessHeap(), 0, rd->allocated = 32768);
1527 rd->char_pos = 0;
1528 rd->first_link = rd->current_link = NULL;
1529 rd->force_color = FALSE;
1530 rd->font_scale = font_scale;
1531 rd->relative = relative;
1532 rd->char_pos_rel = 0;
1533
1534 switch (hlpfile->charset)
1535 {
1536 case DEFAULT_CHARSET:
1537 case ANSI_CHARSET: cpg = 1252; break;
1538 case SHIFTJIS_CHARSET: cpg = 932; break;
1539 case HANGEUL_CHARSET: cpg = 949; break;
1540 case GB2312_CHARSET: cpg = 936; break;
1541 case CHINESEBIG5_CHARSET: cpg = 950; break;
1542 case GREEK_CHARSET: cpg = 1253; break;
1543 case TURKISH_CHARSET: cpg = 1254; break;
1544 case HEBREW_CHARSET: cpg = 1255; break;
1545 case ARABIC_CHARSET: cpg = 1256; break;
1546 case BALTIC_CHARSET: cpg = 1257; break;
1547 case VIETNAMESE_CHARSET: cpg = 1258; break;
1548 case RUSSIAN_CHARSET: cpg = 1251; break;
1549 case EE_CHARSET: cpg = 1250; break;
1550 case THAI_CHARSET: cpg = 874; break;
1551 case JOHAB_CHARSET: cpg = 1361; break;
1552 case MAC_CHARSET: ck = "mac"; break;
1553 default:
1554 WINE_FIXME("Unsupported charset %u\n", hlpfile->charset);
1555 cpg = 1252;
1556 }
1557 if (ck)
1558 {
1559 sprintf(tmp, "{\\rtf1\\%s\\deff0", ck);
1560 if (!HLPFILE_RtfAddControl(rd, tmp)) return FALSE;
1561 }
1562 else
1563 {
1564 sprintf(tmp, "{\\rtf1\\ansi\\ansicpg%d\\deff0", cpg);
1565 if (!HLPFILE_RtfAddControl(rd, tmp)) return FALSE;
1566 }
1567
1568 /* generate font table */
1569 if (!HLPFILE_RtfAddControl(rd, "{\\fonttbl")) return FALSE;
1570 for (index = 0; index < hlpfile->numFonts; index++)
1571 {
1572 const char* family;
1573 switch (hlpfile->fonts[index].LogFont.lfPitchAndFamily & 0xF0)
1574 {
1575 case FF_MODERN: family = "modern"; break;
1576 case FF_ROMAN: family = "roman"; break;
1577 case FF_SWISS: family = "swiss"; break;
1578 case FF_SCRIPT: family = "script"; break;
1579 case FF_DECORATIVE: family = "decor"; break;
1580 default: family = "nil"; break;
1581 }
1582 sprintf(tmp, "{\\f%d\\f%s\\fprq%d\\fcharset%d %s;}",
1583 index, family,
1584 hlpfile->fonts[index].LogFont.lfPitchAndFamily & 0x0F,
1585 hlpfile->fonts[index].LogFont.lfCharSet,
1586 hlpfile->fonts[index].LogFont.lfFaceName);
1587 if (!HLPFILE_RtfAddControl(rd, tmp)) return FALSE;
1588 }
1589 if (!HLPFILE_RtfAddControl(rd, "}")) return FALSE;
1590 /* generate color table */
1591 if (!HLPFILE_RtfAddControl(rd, "{\\colortbl ;\\red0\\green128\\blue0;")) return FALSE;
1592 for (index = 0; index < hlpfile->numFonts; index++)
1593 {
1594 const char* family;
1595 switch (hlpfile->fonts[index].LogFont.lfPitchAndFamily & 0xF0)
1596 {
1597 case FF_MODERN: family = "modern"; break;
1598 case FF_ROMAN: family = "roman"; break;
1599 case FF_SWISS: family = "swiss"; break;
1600 case FF_SCRIPT: family = "script"; break;
1601 case FF_DECORATIVE: family = "decor"; break;
1602 default: family = "nil"; break;
1603 }
1604 sprintf(tmp, "\\red%d\\green%d\\blue%d;",
1605 GetRValue(hlpfile->fonts[index].color),
1606 GetGValue(hlpfile->fonts[index].color),
1607 GetBValue(hlpfile->fonts[index].color));
1608 if (!HLPFILE_RtfAddControl(rd, tmp)) return FALSE;
1609 }
1610 if (!HLPFILE_RtfAddControl(rd, "}")) return FALSE;
1611
1612 do
1613 {
1614 if (hlpfile->version <= 16)
1615 {
1616 index = (ref - 0x0C) / hlpfile->dsize;
1617 offset = (ref - 0x0C) % hlpfile->dsize;
1618 }
1619 else
1620 {
1621 index = (ref - 0x0C) >> 14;
1622 offset = (ref - 0x0C) & 0x3FFF;
1623 }
1624
1625 if (hlpfile->version <= 16 && index != old_index && old_index != -1)
1626 {
1627 /* we jumped to the next block, adjust pointers */
1628 ref -= 12;
1629 offset -= 12;
1630 }
1631
1632 if (index >= hlpfile->topic_maplen) {WINE_WARN("maplen\n"); break;}
1633 buf = hlpfile->topic_map[index] + offset;
1634 if (buf + 0x15 >= hlpfile->topic_end) {WINE_WARN("extra\n"); break;}
1635 end = min(buf + GET_UINT(buf, 0), hlpfile->topic_end);
1636 if (index != old_index) {offs = 0; old_index = index;}
1637
1638 switch (buf[0x14])
1639 {
1640 case 0x02:
1641 if (count++) goto done;
1642 break;
1643 case 0x01:
1644 case 0x20:
1645 case 0x23:
1646 if (!HLPFILE_BrowseParagraph(page, rd, buf, end, &parlen)) return FALSE;
1647 if (relative > index * 0x8000 + offs)
1648 rd->char_pos_rel = rd->char_pos;
1649 offs += parlen;
1650 break;
1651 default:
1652 WINE_ERR("buf[0x14] = %x\n", buf[0x14]);
1653 }
1654 if (hlpfile->version <= 16)
1655 {
1656 ref += GET_UINT(buf, 0xc);
1657 if (GET_UINT(buf, 0xc) == 0)
1658 break;
1659 }
1660 else
1661 ref = GET_UINT(buf, 0xc);
1662 } while (ref != 0xffffffff);
1663 done:
1664 page->first_link = rd->first_link;
1665 return HLPFILE_RtfAddControl(rd, "}");
1666 }
1667
1668 /******************************************************************
1669 * HLPFILE_ReadFont
1670 *
1671 *
1672 */
1673 static BOOL HLPFILE_ReadFont(HLPFILE* hlpfile)
1674 {
1675 BYTE *ref, *end;
1676 unsigned i, len, idx;
1677 unsigned face_num, dscr_num, face_offset, dscr_offset;
1678 BYTE flag, family;
1679
1680 if (!HLPFILE_FindSubFile(hlpfile, "|FONT", &ref, &end))
1681 {
1682 WINE_WARN("no subfile FONT\n");
1683 hlpfile->numFonts = 0;
1684 hlpfile->fonts = NULL;
1685 return FALSE;
1686 }
1687
1688 ref += 9;
1689
1690 face_num = GET_USHORT(ref, 0);
1691 dscr_num = GET_USHORT(ref, 2);
1692 face_offset = GET_USHORT(ref, 4);
1693 dscr_offset = GET_USHORT(ref, 6);
1694
1695 WINE_TRACE("Got NumFacenames=%u@%u NumDesc=%u@%u\n",
1696 face_num, face_offset, dscr_num, dscr_offset);
1697
1698 hlpfile->numFonts = dscr_num;
1699 hlpfile->fonts = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_FONT) * dscr_num);
1700
1701 len = (dscr_offset - face_offset) / face_num;
1702 /* EPP for (i = face_offset; i < dscr_offset; i += len) */
1703 /* EPP WINE_FIXME("[%d]: %*s\n", i / len, len, ref + i); */
1704 for (i = 0; i < dscr_num; i++)
1705 {
1706 flag = ref[dscr_offset + i * 11 + 0];
1707 family = ref[dscr_offset + i * 11 + 2];
1708
1709 hlpfile->fonts[i].LogFont.lfHeight = ref[dscr_offset + i * 11 + 1];
1710 hlpfile->fonts[i].LogFont.lfWidth = 0;
1711 hlpfile->fonts[i].LogFont.lfEscapement = 0;
1712 hlpfile->fonts[i].LogFont.lfOrientation = 0;
1713 hlpfile->fonts[i].LogFont.lfWeight = (flag & 1) ? 700 : 400;
1714 hlpfile->fonts[i].LogFont.lfItalic = (flag & 2) ? TRUE : FALSE;
1715 hlpfile->fonts[i].LogFont.lfUnderline = (flag & 4) ? TRUE : FALSE;
1716 hlpfile->fonts[i].LogFont.lfStrikeOut = (flag & 8) ? TRUE : FALSE;
1717 hlpfile->fonts[i].LogFont.lfCharSet = hlpfile->charset;
1718 hlpfile->fonts[i].LogFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
1719 hlpfile->fonts[i].LogFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
1720 hlpfile->fonts[i].LogFont.lfQuality = DEFAULT_QUALITY;
1721 hlpfile->fonts[i].LogFont.lfPitchAndFamily = DEFAULT_PITCH;
1722
1723 switch (family)
1724 {
1725 case 0x01: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_MODERN; break;
1726 case 0x02: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_ROMAN; break;
1727 case 0x03: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_SWISS; break;
1728 case 0x04: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_SCRIPT; break;
1729 case 0x05: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_DECORATIVE; break;
1730 default: WINE_FIXME("Unknown family %u\n", family);
1731 }
1732 idx = GET_USHORT(ref, dscr_offset + i * 11 + 3);
1733
1734 if (idx < face_num)
1735 {
1736 memcpy(hlpfile->fonts[i].LogFont.lfFaceName, ref + face_offset + idx * len, min(len, LF_FACESIZE - 1));
1737 hlpfile->fonts[i].LogFont.lfFaceName[min(len, LF_FACESIZE - 1)] = '\0';
1738 }
1739 else
1740 {
1741 WINE_FIXME("Too high face ref (%u/%u)\n", idx, face_num);
1742 strcpy(hlpfile->fonts[i].LogFont.lfFaceName, "Helv");
1743 }
1744 hlpfile->fonts[i].hFont = 0;
1745 hlpfile->fonts[i].color = RGB(ref[dscr_offset + i * 11 + 5],
1746 ref[dscr_offset + i * 11 + 6],
1747 ref[dscr_offset + i * 11 + 7]);
1748 #define X(b,s) ((flag & (1 << b)) ? "-"s: "")
1749 WINE_TRACE("Font[%d]: flags=%02x%s%s%s%s%s%s pSize=%u family=%u face=%s[%u] color=%08x\n",
1750 i, flag,
1751 X(0, "bold"),
1752 X(1, "italic"),
1753 X(2, "underline"),
1754 X(3, "strikeOut"),
1755 X(4, "dblUnderline"),
1756 X(5, "smallCaps"),
1757 ref[dscr_offset + i * 11 + 1],
1758 family,
1759 hlpfile->fonts[i].LogFont.lfFaceName, idx,
1760 GET_UINT(ref, dscr_offset + i * 11 + 5) & 0x00FFFFFF);
1761 }
1762 return TRUE;
1763 }
1764
1765 /***********************************************************************
1766 *
1767 * HLPFILE_ReadFileToBuffer
1768 */
1769 static BOOL HLPFILE_ReadFileToBuffer(HLPFILE* hlpfile, HFILE hFile)
1770 {
1771 BYTE header[16], dummy[1];
1772
1773 if (_hread(hFile, header, 16) != 16) {WINE_WARN("header\n"); return FALSE;};
1774
1775 /* sanity checks */
1776 if (GET_UINT(header, 0) != 0x00035F3F)
1777 {WINE_WARN("wrong header\n"); return FALSE;};
1778
1779 hlpfile->file_buffer_size = GET_UINT(header, 12);
1780 hlpfile->file_buffer = HeapAlloc(GetProcessHeap(), 0, hlpfile->file_buffer_size + 1);
1781 if (!hlpfile->file_buffer) return FALSE;
1782
1783 memcpy(hlpfile->file_buffer, header, 16);
1784 if (_hread(hFile, hlpfile->file_buffer + 16, hlpfile->file_buffer_size - 16) !=hlpfile->file_buffer_size - 16)
1785 {WINE_WARN("filesize1\n"); return FALSE;};
1786
1787 if (_hread(hFile, dummy, 1) != 0) WINE_WARN("filesize2\n");
1788
1789 hlpfile->file_buffer[hlpfile->file_buffer_size] = '\0'; /* FIXME: was '0', sounds backwards to me */
1790
1791 return TRUE;
1792 }
1793
1794 /**************************************************************************
1795 * comp_FindSubFile
1796 *
1797 * HLPFILE_BPTreeCompare function for HLPFILE directory.
1798 *
1799 */
1800 static int comp_FindSubFile(void *p, const void *key,
1801 int leaf, void** next)
1802 {
1803 *next = (char *)p+strlen(p)+(leaf?5:3);
1804 WINE_TRACE("Comparing '%s' with '%s'\n", (char *)p, (char *)key);
1805 return strcmp(p, key);
1806 }
1807
1808 /***********************************************************************
1809 *
1810 * HLPFILE_FindSubFile
1811 */
1812 static BOOL HLPFILE_FindSubFile(HLPFILE* hlpfile, LPCSTR name, BYTE **subbuf, BYTE **subend)
1813 {
1814 BYTE *ptr;
1815
1816 WINE_TRACE("looking for file '%s'\n", name);
1817 ptr = HLPFILE_BPTreeSearch(hlpfile->file_buffer + GET_UINT(hlpfile->file_buffer, 4),
1818 name, comp_FindSubFile);
1819 if (!ptr) return FALSE;
1820 *subbuf = hlpfile->file_buffer + GET_UINT(ptr, strlen(name)+1);
1821 if (*subbuf >= hlpfile->file_buffer + hlpfile->file_buffer_size)
1822 {
1823 WINE_ERR("internal file %s does not fit\n", name);
1824 return FALSE;
1825 }
1826 *subend = *subbuf + GET_UINT(*subbuf, 0);
1827 if (*subend > hlpfile->file_buffer + hlpfile->file_buffer_size)
1828 {
1829 WINE_ERR("internal file %s does not fit\n", name);
1830 return FALSE;
1831 }
1832 if (GET_UINT(*subbuf, 0) < GET_UINT(*subbuf, 4) + 9)
1833 {
1834 WINE_ERR("invalid size provided for internal file %s\n", name);
1835 return FALSE;
1836 }
1837 return TRUE;
1838 }
1839
1840 /***********************************************************************
1841 *
1842 * HLPFILE_SystemCommands
1843 */
1844 static BOOL HLPFILE_SystemCommands(HLPFILE* hlpfile)
1845 {
1846 BYTE *buf, *ptr, *end;
1847 HLPFILE_MACRO *macro, **m;
1848 LPSTR p;
1849 unsigned short magic, minor, major, flags;
1850
1851 hlpfile->lpszTitle = NULL;
1852
1853 if (!HLPFILE_FindSubFile(hlpfile, "|SYSTEM", &buf, &end)) return FALSE;
1854
1855 magic = GET_USHORT(buf + 9, 0);
1856 minor = GET_USHORT(buf + 9, 2);
1857 major = GET_USHORT(buf + 9, 4);
1858 /* gen date on 4 bytes */
1859 flags = GET_USHORT(buf + 9, 10);
1860 WINE_TRACE("Got system header: magic=%04x version=%d.%d flags=%04x\n",
1861 magic, major, minor, flags);
1862 if (magic != 0x036C || major != 1)
1863 {WINE_WARN("Wrong system header\n"); return FALSE;}
1864 if (minor <= 16)
1865 {
1866 hlpfile->tbsize = 0x800;
1867 hlpfile->compressed = 0;
1868 }
1869 else if (flags == 0)
1870 {
1871 hlpfile->tbsize = 0x1000;
1872 hlpfile->compressed = 0;
1873 }
1874 else if (flags == 4)
1875 {
1876 hlpfile->tbsize = 0x1000;
1877 hlpfile->compressed = 1;
1878 }
1879 else
1880 {
1881 hlpfile->tbsize = 0x800;
1882 hlpfile->compressed = 1;
1883 }
1884
1885 if (hlpfile->compressed)
1886 hlpfile->dsize = 0x4000;
1887 else
1888 hlpfile->dsize = hlpfile->tbsize - 0x0C;
1889
1890 hlpfile->version = minor;
1891 hlpfile->flags = flags;
1892 hlpfile->charset = DEFAULT_CHARSET;
1893
1894 if (hlpfile->version <= 16)
1895 {
1896 char *str = (char*)buf + 0x15;
1897
1898 hlpfile->lpszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(str) + 1);
1899 if (!hlpfile->lpszTitle) return FALSE;
1900 lstrcpy(hlpfile->lpszTitle, str);
1901 WINE_TRACE("Title: %s\n", hlpfile->lpszTitle);
1902 /* Nothing more to parse */
1903 return TRUE;
1904 }
1905 for (ptr = buf + 0x15; ptr + 4 <= end; ptr += GET_USHORT(ptr, 2) + 4)
1906 {
1907 char *str = (char*) ptr + 4;
1908 switch (GET_USHORT(ptr, 0))
1909 {
1910 case 1:
1911 if (hlpfile->lpszTitle) {WINE_WARN("title\n"); break;}
1912 hlpfile->lpszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(str) + 1);
1913 if (!hlpfile->lpszTitle) return FALSE;
1914 lstrcpy(hlpfile->lpszTitle, str);
1915 WINE_TRACE("Title: %s\n", hlpfile->lpszTitle);
1916 break;
1917
1918 case 2:
1919 if (hlpfile->lpszCopyright) {WINE_WARN("copyright\n"); break;}
1920 hlpfile->lpszCopyright = HeapAlloc(GetProcessHeap(), 0, strlen(str) + 1);
1921 if (!hlpfile->lpszCopyright) return FALSE;
1922 lstrcpy(hlpfile->lpszCopyright, str);
1923 WINE_TRACE("Copyright: %s\n", hlpfile->lpszCopyright);
1924 break;
1925
1926 case 3:
1927 if (GET_USHORT(ptr, 2) != 4) {WINE_WARN("system3\n");break;}
1928 hlpfile->contents_start = GET_UINT(ptr, 4);
1929 WINE_TRACE("Setting contents start at %08lx\n", hlpfile->contents_start);
1930 break;
1931
1932 case 4:
1933 macro = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_MACRO) + lstrlen(str) + 1);
1934 if (!macro) break;
1935 p = (char*)macro + sizeof(HLPFILE_MACRO);
1936 lstrcpy(p, str);
1937 macro->lpszMacro = p;
1938 macro->next = 0;
1939 for (m = &hlpfile->first_macro; *m; m = &(*m)->next);
1940 *m = macro;
1941 break;
1942
1943 case 5:
1944 if (GET_USHORT(ptr, 4 + 4) != 1)
1945 WINE_FIXME("More than one icon, picking up first\n");
1946 /* 0x16 is sizeof(CURSORICONDIR), see user32/user_private.h */
1947 hlpfile->hIcon = CreateIconFromResourceEx(ptr + 4 + 0x16,
1948 GET_USHORT(ptr, 2) - 0x16, TRUE,
1949 0x30000, 0, 0, 0);
1950 break;
1951
1952 case 6:
1953 if (GET_USHORT(ptr, 2) != 90) {WINE_WARN("system6\n");break;}
1954
1955 if (hlpfile->windows)
1956 hlpfile->windows = HeapReAlloc(GetProcessHeap(), 0, hlpfile->windows,
1957 sizeof(HLPFILE_WINDOWINFO) * ++hlpfile->numWindows);
1958 else
1959 hlpfile->windows = HeapAlloc(GetProcessHeap(), 0,
1960 sizeof(HLPFILE_WINDOWINFO) * ++hlpfile->numWindows);
1961
1962 if (hlpfile->windows)
1963 {
1964 unsigned flags = GET_USHORT(ptr, 4);
1965 HLPFILE_WINDOWINFO* wi = &hlpfile->windows[hlpfile->numWindows - 1];
1966
1967 if (flags & 0x0001) strcpy(wi->type, &str[2]);
1968 else wi->type[0] = '\0';
1969 if (flags & 0x0002) strcpy(wi->name, &str[12]);
1970 else wi->name[0] = '\0';
1971 if (flags & 0x0004) strcpy(wi->caption, &str[21]);
1972 else lstrcpynA(wi->caption, hlpfile->lpszTitle, sizeof(wi->caption));
1973 wi->origin.x = (flags & 0x0008) ? GET_USHORT(ptr, 76) : CW_USEDEFAULT;
1974 wi->origin.y = (flags & 0x0010) ? GET_USHORT(ptr, 78) : CW_USEDEFAULT;
1975 wi->size.cx = (flags & 0x0020) ? GET_USHORT(ptr, 80) : CW_USEDEFAULT;
1976 wi->size.cy = (flags & 0x0040) ? GET_USHORT(ptr, 82) : CW_USEDEFAULT;
1977 wi->style = (flags & 0x0080) ? GET_USHORT(ptr, 84) : SW_SHOW;
1978 wi->win_style = WS_OVERLAPPEDWINDOW;
1979 wi->sr_color = (flags & 0x0100) ? GET_UINT(ptr, 86) : 0xFFFFFF;
1980 wi->nsr_color = (flags & 0x0200) ? GET_UINT(ptr, 90) : 0xFFFFFF;
1981 WINE_TRACE("System-Window: flags=%c%c%c%c%c%c%c%c type=%s name=%s caption=%s (%d,%d)x(%d,%d)\n",
1982 flags & 0x0001 ? 'T' : 't',
1983 flags & 0x0002 ? 'N' : 'n',
1984 flags & 0x0004 ? 'C' : 'c',
1985 flags & 0x0008 ? 'X' : 'x',
1986 flags & 0x0010 ? 'Y' : 'y',
1987 flags & 0x0020 ? 'W' : 'w',
1988 flags & 0x0040 ? 'H' : 'h',
1989 flags & 0x0080 ? 'S' : 's',
1990 wi->type, wi->name, wi->caption, wi->origin.x, wi->origin.y,
1991 wi->size.cx, wi->size.cy);
1992 }
1993 break;
1994 case 8:
1995 WINE_WARN("Citation: '%s'\n", ptr + 4);
1996 break;
1997 case 11:
1998 hlpfile->charset = ptr[4];
1999 WINE_TRACE("Charset: %d\n", hlpfile->charset);
2000 break;
2001 default:
2002 WINE_WARN("Unsupported SystemRecord[%d]\n", GET_USHORT(ptr, 0));
2003 }
2004 }
2005 if (!hlpfile->lpszTitle)
2006 hlpfile->lpszTitle = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 1);
2007 return TRUE;
2008 }
2009
2010 /***********************************************************************
2011 *
2012 * HLPFILE_UncompressedLZ77_Size
2013 */
2014 static INT HLPFILE_UncompressedLZ77_Size(const BYTE *ptr, const BYTE *end)
2015 {
2016 int i, newsize = 0;
2017
2018 while (ptr < end)
2019 {
2020 int mask = *ptr++;
2021 for (i = 0; i < 8 && ptr < end; i++, mask >>= 1)
2022 {
2023 if (mask & 1)
2024 {
2025 int code = GET_USHORT(ptr, 0);
2026 int len = 3 + (code >> 12);
2027 newsize += len;
2028 ptr += 2;
2029 }
2030 else newsize++, ptr++;
2031 }
2032 }
2033
2034 return newsize;
2035 }
2036
2037 /***********************************************************************
2038 *
2039 * HLPFILE_UncompressLZ77
2040 */
2041 static BYTE *HLPFILE_UncompressLZ77(const BYTE *ptr, const BYTE *end, BYTE *newptr)
2042 {
2043 int i;
2044
2045 while (ptr < end)
2046 {
2047 int mask = *ptr++;
2048 for (i = 0; i < 8 && ptr < end; i++, mask >>= 1)
2049 {
2050 if (mask & 1)
2051 {
2052 int code = GET_USHORT(ptr, 0);
2053 int len = 3 + (code >> 12);
2054 int offset = code & 0xfff;
2055 /*
2056 * We must copy byte-by-byte here. We cannot use memcpy nor
2057 * memmove here. Just example:
2058 * a[]={1,2,3,4,5,6,7,8,9,10}
2059 * newptr=a+2;
2060 * offset=1;
2061 * We expect:
2062 * {1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 11, 12}
2063 */
2064 for (; len>0; len--, newptr++) *newptr = *(newptr-offset-1);
2065 ptr += 2;
2066 }
2067 else *newptr++ = *ptr++;
2068 }
2069 }
2070
2071 return newptr;
2072 }
2073
2074 /***********************************************************************
2075 *
2076 * HLPFILE_UncompressLZ77_Phrases
2077 */
2078 static BOOL HLPFILE_UncompressLZ77_Phrases(HLPFILE* hlpfile)
2079 {
2080 UINT i, num, dec_size, head_size;
2081 BYTE *buf, *end;
2082
2083 if (!HLPFILE_FindSubFile(hlpfile, "|Phrases", &buf, &end)) return FALSE;
2084
2085 if (hlpfile->version <= 16)
2086 head_size = 13;
2087 else
2088 head_size = 17;
2089
2090 num = hlpfile->num_phrases = GET_USHORT(buf, 9);
2091 if (buf + 2 * num + 0x13 >= end) {WINE_WARN("1a\n"); return FALSE;};
2092
2093 if (hlpfile->version <= 16)
2094 dec_size = end - buf - 15 - 2 * num;
2095 else
2096 dec_size = HLPFILE_UncompressedLZ77_Size(buf + 0x13 + 2 * num, end);
2097
2098 hlpfile->phrases_offsets = HeapAlloc(GetProcessHeap(), 0, sizeof(unsigned) * (num + 1));
2099 hlpfile->phrases_buffer = HeapAlloc(GetProcessHeap(), 0, dec_size);
2100 if (!hlpfile->phrases_offsets || !hlpfile->phrases_buffer)
2101 {
2102 HeapFree(GetProcessHeap(), 0, hlpfile->phrases_offsets);
2103 HeapFree(GetProcessHeap(), 0, hlpfile->phrases_buffer);
2104 return FALSE;
2105 }
2106
2107 for (i = 0; i <= num; i++)
2108 hlpfile->phrases_offsets[i] = GET_USHORT(buf, head_size + 2 * i) - 2 * num - 2;
2109
2110 if (hlpfile->version <= 16)
2111 memcpy(hlpfile->phrases_buffer, buf + 15 + 2*num, dec_size);
2112 else
2113 HLPFILE_UncompressLZ77(buf + 0x13 + 2 * num, end, (BYTE*)hlpfile->phrases_buffer);
2114
2115 hlpfile->hasPhrases = TRUE;
2116 return TRUE;
2117 }
2118
2119 /***********************************************************************
2120 *
2121 * HLPFILE_Uncompress_Phrases40
2122 */
2123 static BOOL HLPFILE_Uncompress_Phrases40(HLPFILE* hlpfile)
2124 {
2125 UINT num;
2126 INT dec_size, cpr_size;
2127 BYTE *buf_idx, *end_idx;
2128 BYTE *buf_phs, *end_phs;
2129 long* ptr, mask = 0;
2130 unsigned int i;
2131 unsigned short bc, n;
2132
2133 if (!HLPFILE_FindSubFile(hlpfile, "|PhrIndex", &buf_idx, &end_idx) ||
2134 !HLPFILE_FindSubFile(hlpfile, "|PhrImage", &buf_phs, &end_phs)) return FALSE;
2135
2136 ptr = (long*)(buf_idx + 9 + 28);
2137 bc = GET_USHORT(buf_idx, 9 + 24) & 0x0F;
2138 num = hlpfile->num_phrases = GET_USHORT(buf_idx, 9 + 4);
2139
2140 WINE_TRACE("Index: Magic=%08x #entries=%u CpsdSize=%u PhrImgSize=%u\n"
2141 "\tPhrImgCprsdSize=%u 0=%u bc=%x ukn=%x\n",
2142 GET_UINT(buf_idx, 9 + 0),
2143 GET_UINT(buf_idx, 9 + 4),
2144 GET_UINT(buf_idx, 9 + 8),
2145 GET_UINT(buf_idx, 9 + 12),
2146 GET_UINT(buf_idx, 9 + 16),
2147 GET_UINT(buf_idx, 9 + 20),
2148 GET_USHORT(buf_idx, 9 + 24),
2149 GET_USHORT(buf_idx, 9 + 26));
2150
2151 dec_size = GET_UINT(buf_idx, 9 + 12);
2152 cpr_size = GET_UINT(buf_idx, 9 + 16);
2153
2154 if (dec_size != cpr_size &&
2155 dec_size != HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs))
2156 {
2157 WINE_WARN("size mismatch %u %u\n",
2158 dec_size, HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs));
2159 dec_size = max(dec_size, HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs));
2160 }
2161
2162 hlpfile->phrases_offsets = HeapAlloc(GetProcessHeap(), 0, sizeof(unsigned) * (num + 1));
2163 hlpfile->phrases_buffer = HeapAlloc(GetProcessHeap(), 0, dec_size);
2164 if (!hlpfile->phrases_offsets || !hlpfile->phrases_buffer)
2165 {
2166 HeapFree(GetProcessHeap(), 0, hlpfile->phrases_offsets);
2167 HeapFree(GetProcessHeap(), 0, hlpfile->phrases_buffer);
2168 return FALSE;
2169 }
2170
2171 #define getbit() (ptr += (mask < 0), mask = mask*2 + (mask<=0), (*ptr & mask) != 0)
2172
2173 hlpfile->phrases_offsets[0] = 0;
2174 for (i = 0; i < num; i++)
2175 {
2176 for (n = 1; getbit(); n += 1 << bc);
2177 if (getbit()) n++;
2178 if (bc > 1 && getbit()) n += 2;
2179 if (bc > 2 && getbit()) n += 4;
2180 if (bc > 3 && getbit()) n += 8;
2181 if (bc > 4 && getbit()) n += 16;
2182 hlpfile->phrases_offsets[i + 1] = hlpfile->phrases_offsets[i] + n;
2183 }
2184 #undef getbit
2185
2186 if (dec_size == cpr_size)
2187 memcpy(hlpfile->phrases_buffer, buf_phs + 9, dec_size);
2188 else
2189 HLPFILE_UncompressLZ77(buf_phs + 9, end_phs, (BYTE*)hlpfile->phrases_buffer);
2190
2191 hlpfile->hasPhrases40 = TRUE;
2192 return TRUE;
2193 }
2194
2195 /***********************************************************************
2196 *
2197 * HLPFILE_Uncompress_Topic
2198 */
2199 static BOOL HLPFILE_Uncompress_Topic(HLPFILE* hlpfile)
2200 {
2201 BYTE *buf, *ptr, *end, *newptr;
2202 unsigned int i, newsize = 0;
2203 unsigned int topic_size;
2204
2205 if (!HLPFILE_FindSubFile(hlpfile, "|TOPIC", &buf, &end))
2206 {WINE_WARN("topic0\n"); return FALSE;}
2207
2208 buf += 9; /* Skip file header */
2209 topic_size = end - buf;
2210 if (hlpfile->compressed)
2211 {
2212 hlpfile->topic_maplen = (topic_size - 1) / hlpfile->tbsize + 1;
2213
2214 for (i = 0; i < hlpfile->topic_maplen; i++)
2215 {
2216 ptr = buf + i * hlpfile->tbsize;
2217
2218 /* I don't know why, it's necessary for printman.hlp */
2219 if (ptr + 0x44 > end) ptr = end - 0x44;
2220
2221 newsize += HLPFILE_UncompressedLZ77_Size(ptr + 0xc, min(end, ptr + hlpfile->tbsize));
2222 }
2223
2224 hlpfile->topic_map = HeapAlloc(GetProcessHeap(), 0,
2225 hlpfile->topic_maplen * sizeof(hlpfile->topic_map[0]) + newsize);
2226 if (!hlpfile->topic_map) return FALSE;
2227 newptr = (BYTE*)(hlpfile->topic_map + hlpfile->topic_maplen);
2228 hlpfile->topic_end = newptr + newsize;
2229
2230 for (i = 0; i < hlpfile->topic_maplen; i++)
2231 {
2232 ptr = buf + i * hlpfile->tbsize;
2233 if (ptr + 0x44 > end) ptr = end - 0x44;
2234
2235 hlpfile->topic_map[i] = newptr;
2236 newptr = HLPFILE_UncompressLZ77(ptr + 0xc, min(end, ptr + hlpfile->tbsize), newptr);
2237 }
2238 }
2239 else
2240 {
2241 /* basically, we need to copy the TopicBlockSize byte pages
2242 * (removing the first 0x0C) in one single area in memory
2243 */
2244 hlpfile->topic_maplen = (topic_size - 1) / hlpfile->tbsize + 1;
2245 hlpfile->topic_map = HeapAlloc(GetProcessHeap(), 0,
2246 hlpfile->topic_maplen * (sizeof(hlpfile->topic_map[0]) + hlpfile->dsize));
2247 if (!hlpfile->topic_map) return FALSE;
2248 newptr = (BYTE*)(hlpfile->topic_map + hlpfile->topic_maplen);
2249 hlpfile->topic_end = newptr + topic_size;
2250
2251 for (i = 0; i < hlpfile->topic_maplen; i++)
2252 {
2253 hlpfile->topic_map[i] = newptr + i * hlpfile->dsize;
2254 memcpy(hlpfile->topic_map[i], buf + i * hlpfile->tbsize + 0x0C, hlpfile->dsize);
2255 }
2256 }
2257 return TRUE;
2258 }
2259
2260 /***********************************************************************
2261 *
2262 * HLPFILE_Uncompress2
2263 */
2264
2265 static void HLPFILE_Uncompress2(HLPFILE* hlpfile, const BYTE *ptr, const BYTE *end, BYTE *newptr, const BYTE *newend)
2266 {
2267 BYTE *phptr, *phend;
2268 UINT code;
2269 UINT index;
2270
2271 while (ptr < end && newptr < newend)
2272 {
2273 if (!*ptr || *ptr >= 0x10)
2274 *newptr++ = *ptr++;
2275 else
2276 {
2277 code = 0x100 * ptr[0] + ptr[1];
2278 index = (code - 0x100) / 2;
2279
2280 phptr = (BYTE*)hlpfile->phrases_buffer + hlpfile->phrases_offsets[index];
2281 phend = (BYTE*)hlpfile->phrases_buffer + hlpfile->phrases_offsets[index + 1];
2282
2283 if (newptr + (phend - phptr) > newend)
2284 {
2285 WINE_FIXME("buffer overflow %p > %p for %lu bytes\n",
2286 newptr, newend, (SIZE_T)(phend - phptr));
2287 return;
2288 }
2289 memcpy(newptr, phptr, phend - phptr);
2290 newptr += phend - phptr;
2291 if (code & 1) *newptr++ = ' ';
2292
2293 ptr += 2;
2294 }
2295 }
2296 if (newptr > newend) WINE_FIXME("buffer overflow %p > %p\n", newptr, newend);
2297 }
2298
2299 /******************************************************************
2300 * HLPFILE_Uncompress3
2301 *
2302 *
2303 */
2304 static BOOL HLPFILE_Uncompress3(HLPFILE* hlpfile, char* dst, const char* dst_end,
2305 const BYTE* src, const BYTE* src_end)
2306 {
2307 unsigned int idx, len;
2308
2309 for (; src < src_end; src++)
2310 {
2311 if ((*src & 1) == 0)
2312 {
2313 idx = *src / 2;
2314 if (idx > hlpfile->num_phrases)
2315 {
2316 WINE_ERR("index in phrases %d/%d\n", idx, hlpfile->num_phrases);
2317 len = 0;
2318 }
2319 else
2320 {
2321 len = hlpfile->phrases_offsets[idx + 1] - hlpfile->phrases_offsets[idx];
2322 if (dst + len <= dst_end)
2323 memcpy(dst, &hlpfile->phrases_buffer[hlpfile->phrases_offsets[idx]], len);
2324 }
2325 }
2326 else if ((*src & 0x03) == 0x01)
2327 {
2328 idx = (*src + 1) * 64;
2329 idx += *++src;
2330 if (idx > hlpfile->num_phrases)
2331 {
2332 WINE_ERR("index in phrases %d/%d\n", idx, hlpfile->num_phrases);
2333 len = 0;
2334 }
2335 else
2336 {
2337 len = hlpfile->phrases_offsets[idx + 1] - hlpfile->phrases_offsets[idx];
2338 if (dst + len <= dst_end)
2339 memcpy(dst, &hlpfile->phrases_buffer[hlpfile->phrases_offsets[idx]], len);
2340 }
2341 }
2342 else if ((*src & 0x07) == 0x03)
2343 {
2344 len = (*src / 8) + 1;
2345 if (dst + len <= dst_end)
2346 memcpy(dst, src + 1, len);
2347 src += len;
2348 }
2349 else
2350 {
2351 len = (*src / 16) + 1;
2352 if (dst + len <= dst_end)
2353 memset(dst, ((*src & 0x0F) == 0x07) ? ' ' : 0, len);
2354 }
2355 dst += len;
2356 }
2357
2358 if (dst > dst_end) WINE_ERR("buffer overflow (%p > %p)\n", dst, dst_end);
2359 return TRUE;
2360 }
2361
2362 /******************************************************************
2363 * HLPFILE_UncompressRLE
2364 *
2365 *
2366 */
2367 static void HLPFILE_UncompressRLE(const BYTE* src, const BYTE* end, BYTE* dst, unsigned dstsz)
2368 {
2369 BYTE ch;
2370 BYTE* sdst = dst + dstsz;
2371
2372 while (src < end)
2373 {
2374 ch = *src++;
2375 if (ch & 0x80)
2376 {
2377 ch &= 0x7F;
2378 if (dst + ch <= sdst)
2379 memcpy(dst, src, ch);
2380 src += ch;
2381 }
2382 else
2383 {
2384 if (dst + ch <= sdst)
2385 memset(dst, (char)*src, ch);
2386 src++;
2387 }
2388 dst += ch;
2389 }
2390 if (dst != sdst)
2391 WINE_WARN("Buffer X-flow: d(%lu) instead of d(%u)\n",
2392 (SIZE_T)(dst - (sdst - dstsz)), dstsz);
2393 }
2394
2395 /**************************************************************************
2396 * HLPFILE_BPTreeSearch
2397 *
2398 * Searches for an element in B+ tree
2399 *
2400 * PARAMS
2401 * buf [I] pointer to the embedded file structured as a B+ tree
2402 * key [I] pointer to data to find
2403 * comp [I] compare function
2404 *
2405 * RETURNS
2406 * Pointer to block identified by key, or NULL if failure.
2407 *
2408 */
2409 void* HLPFILE_BPTreeSearch(BYTE* buf, const void* key,
2410 HLPFILE_BPTreeCompare comp)
2411 {
2412 unsigned magic;
2413 unsigned page_size;
2414 unsigned cur_page;
2415 unsigned level;
2416 BYTE *pages, *ptr, *newptr;
2417 int i, entries;
2418 int ret;
2419
2420 magic = GET_USHORT(buf, 9);
2421 if (magic != 0x293B)
2422 {
2423 WINE_ERR("Invalid magic in B+ tree: 0x%x\n", magic);
2424 return NULL;
2425 }
2426 page_size = GET_USHORT(buf, 9+4);
2427 cur_page = GET_USHORT(buf, 9+26);
2428 level = GET_USHORT(buf, 9+32);
2429 pages = buf + 9 + 38;
2430 while (--level > 0)
2431 {
2432 ptr = pages + cur_page*page_size;
2433 entries = GET_SHORT(ptr, 2);
2434 ptr += 6;
2435 for (i = 0; i < entries; i++)
2436 {
2437 if (comp(ptr, key, 0, (void **)&newptr) > 0) break;
2438 ptr = newptr;
2439 }
2440 cur_page = GET_USHORT(ptr-2, 0);
2441 }
2442 ptr = pages + cur_page*page_size;
2443 entries = GET_SHORT(ptr, 2);
2444 ptr += 8;
2445 for (i = 0; i < entries; i++)
2446 {
2447 ret = comp(ptr, key, 1, (void **)&newptr);
2448 if (ret == 0) return ptr;
2449 if (ret > 0) return NULL;
2450 ptr = newptr;
2451 }
2452 return NULL;
2453 }
2454
2455 /**************************************************************************
2456 * HLPFILE_BPTreeEnum
2457 *
2458 * Enumerates elements in B+ tree.
2459 *
2460 * PARAMS
2461 * buf [I] pointer to the embedded file structured as a B+ tree
2462 * cb [I] compare function
2463 * cookie [IO] cookie for cb function
2464 */
2465 void HLPFILE_BPTreeEnum(BYTE* buf, HLPFILE_BPTreeCallback cb, void* cookie)
2466 {
2467 unsigned magic;
2468 unsigned page_size;
2469 unsigned cur_page;
2470 unsigned level;
2471 BYTE *pages, *ptr, *newptr;
2472 int i, entries;
2473
2474 magic = GET_USHORT(buf, 9);
2475 if (magic != 0x293B)
2476 {
2477 WINE_ERR("Invalid magic in B+ tree: 0x%x\n", magic);
2478 return;
2479 }
2480 page_size = GET_USHORT(buf, 9+4);
2481 cur_page = GET_USHORT(buf, 9+26);
2482 level = GET_USHORT(buf, 9+32);
2483 pages = buf + 9 + 38;
2484 while (--level > 0)
2485 {
2486 ptr = pages + cur_page*page_size;
2487 cur_page = GET_USHORT(ptr, 4);
2488 }
2489 while (cur_page != 0xFFFF)
2490 {
2491 ptr = pages + cur_page*page_size;
2492 entries = GET_SHORT(ptr, 2);
2493 ptr += 8;
2494 for (i = 0; i < entries; i++)
2495 {
2496 cb(ptr, (void **)&newptr, cookie);
2497 ptr = newptr;
2498 }
2499 cur_page = GET_USHORT(pages+cur_page*page_size, 6);
2500 }
2501 }
2502
2503
2504 /***********************************************************************
2505 *
2506 * HLPFILE_GetContext
2507 */
2508 static BOOL HLPFILE_GetContext(HLPFILE *hlpfile)
2509 {
2510 BYTE *cbuf, *cend;
2511 unsigned clen;
2512
2513 if (!HLPFILE_FindSubFile(hlpfile, "|CONTEXT", &cbuf, &cend))
2514 {WINE_WARN("context0\n"); return FALSE;}
2515
2516 clen = cend - cbuf;
2517 hlpfile->Context = HeapAlloc(GetProcessHeap(), 0, clen);
2518 if (!hlpfile->Context) return FALSE;
2519 memcpy(hlpfile->Context, cbuf, clen);
2520
2521 return TRUE;
2522 }
2523
2524 /***********************************************************************
2525 *
2526 * HLPFILE_GetKeywords
2527 */
2528 static BOOL HLPFILE_GetKeywords(HLPFILE *hlpfile)
2529 {
2530 BYTE *cbuf, *cend;
2531 unsigned clen;
2532
2533 if (!HLPFILE_FindSubFile(hlpfile, "|KWBTREE", &cbuf, &cend)) return FALSE;
2534 clen = cend - cbuf;
2535 hlpfile->kwbtree = HeapAlloc(GetProcessHeap(), 0, clen);
2536 if (!hlpfile->kwbtree) return FALSE;
2537 memcpy(hlpfile->kwbtree, cbuf, clen);
2538
2539 if (!HLPFILE_FindSubFile(hlpfile, "|KWDATA", &cbuf, &cend))
2540 {
2541 WINE_ERR("corrupted help file: kwbtree present but kwdata absent\n");
2542 HeapFree(GetProcessHeap(), 0, hlpfile->kwbtree);
2543 return FALSE;
2544 }
2545 clen = cend - cbuf;
2546 hlpfile->kwdata = HeapAlloc(GetProcessHeap(), 0, clen);
2547 if (!hlpfile->kwdata)
2548 {
2549 HeapFree(GetProcessHeap(), 0, hlpfile->kwdata);
2550 return FALSE;
2551 }
2552 memcpy(hlpfile->kwdata, cbuf, clen);
2553
2554 return TRUE;
2555 }
2556
2557 /***********************************************************************
2558 *
2559 * HLPFILE_GetMap
2560 */
2561 static BOOL HLPFILE_GetMap(HLPFILE *hlpfile)
2562 {
2563 BYTE *cbuf, *cend;
2564 unsigned entries, i;
2565
2566 if (!HLPFILE_FindSubFile(hlpfile, "|CTXOMAP", &cbuf, &cend))
2567 {WINE_WARN("no map section\n"); return FALSE;}
2568
2569 entries = GET_USHORT(cbuf, 9);
2570 hlpfile->Map = HeapAlloc(GetProcessHeap(), 0, entries * sizeof(HLPFILE_MAP));
2571 if (!hlpfile->Map) return FALSE;
2572 hlpfile->wMapLen = entries;
2573 for (i = 0; i < entries; i++)
2574 {
2575 hlpfile->Map[i].lMap = GET_UINT(cbuf+11,i*8);
2576 hlpfile->Map[i].offset = GET_UINT(cbuf+11,i*8+4);
2577 }
2578 return TRUE;
2579 }
2580
2581 /***********************************************************************
2582 *
2583 * HLPFILE_GetTOMap
2584 */
2585 static BOOL HLPFILE_GetTOMap(HLPFILE *hlpfile)
2586 {
2587 BYTE *cbuf, *cend;
2588 unsigned clen;
2589
2590 if (!HLPFILE_FindSubFile(hlpfile, "|TOMAP", &cbuf, &cend))
2591 {WINE_WARN("no tomap section\n"); return FALSE;}
2592
2593 clen = cend - cbuf - 9;
2594 hlpfile->TOMap = HeapAlloc(GetProcessHeap(), 0, clen);
2595 if (!hlpfile->TOMap) return FALSE;
2596 memcpy(hlpfile->TOMap, cbuf+9, clen);
2597 hlpfile->wTOMapLen = clen/4;
2598 return TRUE;
2599 }
2600
2601 /***********************************************************************
2602 *
2603 * DeleteMacro
2604 */
2605 static void HLPFILE_DeleteMacro(HLPFILE_MACRO* macro)
2606 {
2607 HLPFILE_MACRO* next;
2608
2609 while (macro)
2610 {
2611 next = macro->next;
2612 HeapFree(GetProcessHeap(), 0, macro);
2613 macro = next;
2614 }
2615 }
2616
2617 /***********************************************************************
2618 *
2619 * DeletePage
2620 */
2621 static void HLPFILE_DeletePage(HLPFILE_PAGE* page)
2622 {
2623 HLPFILE_PAGE* next;
2624
2625 while (page)
2626 {
2627 next = page->next;
2628 HLPFILE_DeleteMacro(page->first_macro);
2629 HeapFree(GetProcessHeap(), 0, page);
2630 page = next;
2631 }
2632 }
2633
2634 /***********************************************************************
2635 *
2636 * HLPFILE_FreeHlpFile
2637 */
2638 void HLPFILE_FreeHlpFile(HLPFILE* hlpfile)
2639 {
2640 unsigned i;
2641
2642 if (!hlpfile || --hlpfile->wRefCount > 0) return;
2643
2644 if (hlpfile->next) hlpfile->next->prev = hlpfile->prev;
2645 if (hlpfile->prev) hlpfile->prev->next = hlpfile->next;
2646 else first_hlpfile = hlpfile->next;
2647
2648 if (hlpfile->numFonts)
2649 {
2650 for (i = 0; i < hlpfile->numFonts; i++)
2651 {
2652 DeleteObject(hlpfile->fonts[i].hFont);
2653 }
2654 HeapFree(GetProcessHeap(), 0, hlpfile->fonts);
2655 }
2656
2657 if (hlpfile->numBmps)
2658 {
2659 for (i = 0; i < hlpfile->numBmps; i++)
2660 {
2661 DeleteObject(hlpfile->bmps[i]);
2662 }
2663 HeapFree(GetProcessHeap(), 0, hlpfile->bmps);
2664 }
2665
2666 HLPFILE_DeletePage(hlpfile->first_page);
2667 HLPFILE_DeleteMacro(hlpfile->first_macro);
2668
2669 DestroyIcon(hlpfile->hIcon);
2670 if (hlpfile->numWindows) HeapFree(GetProcessHeap(), 0, hlpfile->windows);
2671 HeapFree(GetProcessHeap(), 0, hlpfile->Context);
2672 HeapFree(GetProcessHeap(), 0, hlpfile->Map);
2673 HeapFree(GetProcessHeap(), 0, hlpfile->lpszTitle);
2674 HeapFree(GetProcessHeap(), 0, hlpfile->lpszCopyright);
2675 HeapFree(GetProcessHeap(), 0, hlpfile->file_buffer);
2676 HeapFree(GetProcessHeap(), 0, hlpfile->phrases_offsets);
2677 HeapFree(GetProcessHeap(), 0, hlpfile->phrases_buffer);
2678 HeapFree(GetProcessHeap(), 0, hlpfile->topic_map);
2679 HeapFree(GetProcessHeap(), 0, hlpfile->help_on_file);
2680 HeapFree(GetProcessHeap(), 0, hlpfile);
2681 }
Maarten's multimedia branch