git.oblomov.eu Git - wine/blob - programs/winhelp/hlpfile.c

   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, const BYTE* end, BYTE** dst, unsigned dstsz);
  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 (uncompressed): %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, src + csz, &tmp, sz);
 533         if (tmp - dst != sz)
 534             WINE_FIXME("Bogus gfx sizes (RunLen): %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 (LZ77): %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, 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, tmp + sz77, &tmp2, sz);
 552         if (tmp2 - dst != sz)
 553             WINE_WARN("Bogus gfx sizes (LZ77+RunLen): %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     WINE_TRACE("planes=%d bc=%d size=(%ld,%ld)\n",
 596                bi->bmiHeader.biPlanes, bi->bmiHeader.biBitCount,
 597                bi->bmiHeader.biWidth, bi->bmiHeader.biHeight);
 598
 599     csz = fetch_ulong(&ptr);
 600     fetch_ulong(&ptr); /* hotspot size */
 601
 602     off = GET_UINT(ptr, 0);     ptr += 4;
 603     /* GET_UINT(ptr, 0); hotspot offset */ ptr += 4;
 604
 605     /* now read palette info */
 606     if (type == 0x06)
 607     {
 608         unsigned nc = bi->bmiHeader.biClrUsed;
 609         unsigned i;
 610
 611         /* not quite right, especially for bitfields type of compression */
 612         if (!nc && bi->bmiHeader.biBitCount <= 8)
 613             nc = 1 << bi->bmiHeader.biBitCount;
 614
 615         bi = HeapReAlloc(GetProcessHeap(), 0, bi, sizeof(*bi) + nc * sizeof(RGBQUAD));
 616         if (!bi) return FALSE;
 617         for (i = 0; i < nc; i++)
 618         {
 619             bi->bmiColors[i].rgbBlue     = ptr[0];
 620             bi->bmiColors[i].rgbGreen    = ptr[1];
 621             bi->bmiColors[i].rgbRed      = ptr[2];
 622             bi->bmiColors[i].rgbReserved = 0;
 623             ptr += 4;
 624         }
 625     }
 626     pict_beg = HLPFILE_DecompressGfx(beg + off, csz, bi->bmiHeader.biSizeImage, pack);
 627
 628     paragraph->u.gfx.u.bmp.hBitmap = CreateDIBitmap(hdc = GetDC(0), &bi->bmiHeader,
 629                                                     CBM_INIT, pict_beg,
 630                                                     bi, DIB_RGB_COLORS);
 631     ReleaseDC(0, hdc);
 632     if (!paragraph->u.gfx.u.bmp.hBitmap)
 633         WINE_ERR("Couldn't create bitmap\n");
 634
 635     HeapFree(GetProcessHeap(), 0, bi);
 636     if (pict_beg != beg + off) HeapFree(GetProcessHeap(), 0, pict_beg);
 637
 638     return TRUE;
 639 }
 640
 641 /******************************************************************
 642  *              HLPFILE_LoadMetaFile
 643  *
 644  *
 645  */
 646 static BOOL     HLPFILE_LoadMetaFile(BYTE* beg, BYTE pack, HLPFILE_PARAGRAPH* paragraph)
 647 {
 648     BYTE*               ptr;
 649     unsigned long       size, csize;
 650     unsigned long       off, hsoff;
 651     BYTE*               bits;
 652     METAFILEPICT        mfp;
 653
 654     WINE_TRACE("Loading metafile\n");
 655
 656     ptr = beg + 2; /* for type and pack */
 657
 658     mfp.mm = fetch_ushort(&ptr); /* mapping mode */
 659
 660     mfp.xExt = GET_USHORT(ptr, 0);
 661     mfp.yExt = GET_USHORT(ptr, 2);
 662     ptr += 4;
 663
 664     size = fetch_ulong(&ptr); /* decompressed size */
 665     csize = fetch_ulong(&ptr); /* compressed size */
 666     fetch_ulong(&ptr); /* hotspot size */
 667     off = GET_UINT(ptr, 0);
 668     hsoff = GET_UINT(ptr, 4);
 669     ptr += 8;
 670
 671     WINE_FIXME("sz=%lu csz=%lu (%ld,%ld) offs=%lu/%u,%lu\n",
 672                size, csize, mfp.xExt, mfp.yExt, off, ptr - beg, hsoff);
 673
 674     bits = HLPFILE_DecompressGfx(beg + off, csize, size, pack);
 675     if (!bits) return FALSE;
 676
 677     paragraph->cookie = para_metafile;
 678
 679     mfp.hMF = NULL;
 680
 681     paragraph->u.gfx.u.mf.hMetaFile = SetMetaFileBitsEx(size, bits);
 682
 683     if (!paragraph->u.gfx.u.mf.hMetaFile)
 684         WINE_FIXME("Couldn't load metafile\n");
 685
 686     if (bits != beg + off) HeapFree(GetProcessHeap(), 0, bits);
 687
 688     paragraph->u.gfx.u.mf.mfSize.cx = mfp.xExt;
 689     paragraph->u.gfx.u.mf.mfSize.cy = mfp.yExt;
 690
 691     return TRUE;
 692 }
 693
 694 /******************************************************************
 695  *              HLPFILE_LoadGfxByAddr
 696  *
 697  *
 698  */
 699 static  BOOL    HLPFILE_LoadGfxByAddr(HLPFILE *hlpfile, BYTE* ref,
 700                                       unsigned long size,
 701                                       HLPFILE_PARAGRAPH* paragraph)
 702 {
 703     unsigned    i, numpict;
 704
 705     numpict = GET_USHORT(ref, 2);
 706     WINE_TRACE("Got picture magic=%04x #=%d\n",
 707                GET_USHORT(ref, 0), numpict);
 708
 709     for (i = 0; i < numpict; i++)
 710     {
 711         BYTE*   beg;
 712         BYTE*   ptr;
 713         BYTE    type, pack;
 714
 715         WINE_TRACE("Offset[%d] = %x\n", i, GET_UINT(ref, (1 + i) * 4));
 716         beg = ptr = ref + GET_UINT(ref, (1 + i) * 4);
 717
 718         type = *ptr++;
 719         pack = *ptr++;
 720
 721         switch (type)
 722         {
 723         case 5: /* device dependent bmp */
 724         case 6: /* device independent bmp */
 725             HLPFILE_LoadBitmap(beg, type, pack, paragraph);
 726             break;
 727         case 8:
 728             HLPFILE_LoadMetaFile(beg, pack, paragraph);
 729             break;
 730         default: WINE_FIXME("Unknown type %u\n", type); return FALSE;
 731         }
 732
 733         /* FIXME: hotspots */
 734
 735         /* FIXME: implement support for multiple picture format */
 736         if (numpict != 1) WINE_FIXME("Supporting only one bitmap format per logical bitmap (for now). Using first format\n");
 737         break;
 738     }
 739     return TRUE;
 740 }
 741
 742 /******************************************************************
 743  *              HLPFILE_LoadGfxByIndex
 744  *
 745  *
 746  */
 747 static  BOOL    HLPFILE_LoadGfxByIndex(HLPFILE *hlpfile, unsigned index,
 748                                        HLPFILE_PARAGRAPH* paragraph)
 749 {
 750     char        tmp[16];
 751     BYTE        *ref, *end;
 752     BOOL        ret;
 753
 754     WINE_TRACE("Loading picture #%d\n", index);
 755
 756     if (index < hlpfile->numBmps && hlpfile->bmps[index] != NULL)
 757     {
 758         paragraph->u.gfx.u.bmp.hBitmap = hlpfile->bmps[index];
 759         return TRUE;
 760     }
 761
 762     sprintf(tmp, "|bm%u", index);
 763
 764     if (!HLPFILE_FindSubFile(tmp, &ref, &end)) {WINE_WARN("no sub file\n"); return FALSE;}
 765
 766     ref += 9;
 767
 768     ret = HLPFILE_LoadGfxByAddr(hlpfile, ref, end - ref, paragraph);
 769
 770     /* cache bitmap */
 771     if (ret && paragraph->cookie == para_bitmap)
 772     {
 773         if (index >= hlpfile->numBmps)
 774         {
 775             hlpfile->numBmps = index + 1;
 776             hlpfile->bmps = HeapReAlloc(GetProcessHeap(), 0, hlpfile->bmps,
 777                                         hlpfile->numBmps * sizeof(hlpfile->bmps[0]));
 778         }
 779         hlpfile->bmps[index] = paragraph->u.gfx.u.bmp.hBitmap;
 780     }
 781     return ret;
 782 }
 783
 784 /******************************************************************
 785  *              HLPFILE_AllocLink
 786  *
 787  *
 788  */
 789 static HLPFILE_LINK*       HLPFILE_AllocLink(int cookie, const char* str, LONG hash,
 790                                              BOOL clrChange, unsigned wnd)
 791 {
 792     HLPFILE_LINK*  link;
 793
 794     /* FIXME: should build a string table for the attributes.link.lpszPath
 795      * they are reallocated for each link
 796      */
 797     link = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_LINK) + strlen(str) + 1);
 798     if (!link) return NULL;
 799
 800     link->cookie     = cookie;
 801     link->lpszString = (char*)link + sizeof(HLPFILE_LINK);
 802     strcpy((char*)link->lpszString, str);
 803     link->lHash      = hash;
 804     link->bClrChange = clrChange ? 1 : 0;
 805     link->window     = wnd;
 806     link->wRefCount   = 1;
 807
 808     WINE_TRACE("Link[%d] to %s@%08lx:%d\n",
 809                link->cookie, link->lpszString,
 810                link->lHash, link->window);
 811     return link;
 812 }
 813
 814 /***********************************************************************
 815  *
 816  *           HLPFILE_AddParagraph
 817  */
 818 static BOOL HLPFILE_AddParagraph(HLPFILE *hlpfile, BYTE *buf, BYTE *end, unsigned* len)
 819 {
 820     HLPFILE_PAGE      *page;
 821     HLPFILE_PARAGRAPH *paragraph, **paragraphptr;
 822     UINT               textsize;
 823     BYTE              *format, *format_end, *text, *text_end;
 824     long               size;
 825     unsigned short     bits;
 826     unsigned           nc, ncol = 1;
 827
 828     if (!hlpfile->first_page) {WINE_WARN("no page\n"); return FALSE;};
 829
 830     for (page = hlpfile->first_page; page->next; page = page->next) /* Nothing */;
 831     for (paragraphptr = &page->first_paragraph; *paragraphptr;
 832          paragraphptr = &(*paragraphptr)->next) /* Nothing */;
 833
 834     if (buf + 0x19 > end) {WINE_WARN("header too small\n"); return FALSE;};
 835
 836     size = GET_UINT(buf, 0x4);
 837     text = HeapAlloc(GetProcessHeap(), 0, size);
 838     if (!text) return FALSE;
 839     if (hlpfile->hasPhrases)
 840     {
 841         HLPFILE_Uncompress2(buf + GET_UINT(buf, 0x10), end, text, text + size);
 842     }
 843     else
 844     {
 845         if (GET_UINT(buf, 0x4) > GET_UINT(buf, 0) - GET_UINT(buf, 0x10))
 846         {
 847             /* block is compressed */
 848             HLPFILE_Uncompress3(text, text + size, buf + GET_UINT(buf, 0x10), end);
 849         }
 850         else
 851         {
 852             text = buf + GET_UINT(buf, 0x10);
 853         }
 854     }
 855     text_end = text + size;
 856
 857     format = buf + 0x15;
 858     format_end = buf + GET_UINT(buf, 0x10);
 859
 860     fetch_long(&format);
 861     *len = fetch_ushort(&format);
 862
 863     if (buf[0x14] == 0x23)
 864     {
 865         char    type;
 866
 867         ncol = *format++;
 868
 869         WINE_TRACE("#cols %u\n", ncol);
 870         type = *format++;
 871         if (type == 0 || type == 2)
 872             format += 2;
 873         format += ncol * 4;
 874     }
 875
 876     for (nc = 0; nc < ncol; nc++)
 877     {
 878         WINE_TRACE("looking for format at offset %u for column %d\n", format - (buf + 0x15), nc);
 879         if (buf[0x14] == 0x23)
 880             format += 5;
 881         format += 4;
 882         bits = GET_USHORT(format, 0); format += 2;
 883         if (bits & 0x0001) fetch_long(&format);
 884         if (bits & 0x0002) fetch_short(&format);
 885         if (bits & 0x0004) fetch_short(&format);
 886         if (bits & 0x0008) fetch_short(&format);
 887         if (bits & 0x0010) fetch_short(&format);
 888         if (bits & 0x0020) fetch_short(&format);
 889         if (bits & 0x0040) fetch_short(&format);
 890         if (bits & 0x0100) format += 3;
 891         if (bits & 0x0200)
 892         {
 893             int                 ntab = fetch_short(&format);
 894             unsigned short      ts;
 895
 896             while (ntab-- > 0)
 897             {
 898                 ts = fetch_ushort(&format);
 899                 if (ts & 0x4000) fetch_ushort(&format);
 900             }
 901         }
 902         /* 0x0400, 0x0800 and 0x1000 don't need space */
 903         if ((bits & 0xE080) != 0)
 904             WINE_FIXME("Unsupported bits %04x, potential trouble ahead\n", bits);
 905
 906         while (text < text_end && format < format_end)
 907         {
 908             WINE_TRACE("Got text: '%s' (%p/%p - %p/%p)\n", text, text, text_end, format, format_end);
 909             textsize = strlen(text) + 1;
 910             if (textsize > 1)
 911             {
 912                 paragraph = HeapAlloc(GetProcessHeap(), 0,
 913                                       sizeof(HLPFILE_PARAGRAPH) + textsize);
 914                 if (!paragraph) return FALSE;
 915                 *paragraphptr = paragraph;
 916                 paragraphptr = &paragraph->next;
 917
 918                 paragraph->next            = NULL;
 919                 paragraph->link            = attributes.link;
 920                 if (paragraph->link) paragraph->link->wRefCount++;
 921                 paragraph->cookie          = para_normal_text;
 922                 paragraph->u.text.wFont    = attributes.wFont;
 923                 paragraph->u.text.wVSpace  = attributes.wVSpace;
 924                 paragraph->u.text.wHSpace  = attributes.wHSpace;
 925                 paragraph->u.text.wIndent  = attributes.wIndent;
 926                 paragraph->u.text.lpszText = (char*)paragraph + sizeof(HLPFILE_PARAGRAPH);
 927                 strcpy(paragraph->u.text.lpszText, text);
 928
 929                 attributes.wVSpace = 0;
 930                 attributes.wHSpace = 0;
 931             }
 932             /* else: null text, keep on storing attributes */
 933             text += textsize;
 934
 935             if (*format == 0xff)
 936             {
 937                 format++;
 938                 break;
 939             }
 940
 941             WINE_TRACE("format=%02x\n", *format);
 942             switch (*format)
 943             {
 944             case 0x20:
 945                 WINE_FIXME("NIY20\n");
 946                 format += 5;
 947                 break;
 948
 949             case 0x21:
 950                 WINE_FIXME("NIY21\n");
 951                 format += 3;
 952                 break;
 953
 954             case 0x80:
 955                 attributes.wFont = GET_USHORT(format, 1);
 956                 WINE_TRACE("Changing font to %d\n", attributes.wFont);
 957                 format += 3;
 958                 break;
 959
 960             case 0x81:
 961                 attributes.wVSpace++;
 962                 format += 1;
 963                 break;
 964
 965             case 0x82:
 966                 attributes.wVSpace++;
 967                 attributes.wIndent = 0;
 968                 format += 1;
 969                 break;
 970
 971             case 0x83:
 972                 attributes.wIndent++;
 973                 format += 1;
 974                 break;
 975
 976 #if 0
 977             case 0x84:
 978                 format += 3;
 979                 break;
 980 #endif
 981
 982             case 0x86:
 983             case 0x87:
 984             case 0x88:
 985                 {
 986                     BYTE    pos = (*format - 0x86);
 987                     BYTE    type = format[1];
 988                     long    size;
 989
 990                     format += 2;
 991                     size = fetch_long(&format);
 992
 993                     paragraph = HeapAlloc(GetProcessHeap(), 0,
 994                                           sizeof(HLPFILE_PARAGRAPH) + textsize);
 995                     if (!paragraph) return FALSE;
 996                     *paragraphptr = paragraph;
 997                     paragraphptr = &paragraph->next;
 998
 999                     paragraph->next        = NULL;
1000                     paragraph->link        = attributes.link;
1001                     if (paragraph->link) paragraph->link->wRefCount++;
1002                     paragraph->cookie      = para_bitmap;
1003                     paragraph->u.gfx.pos   = pos;
1004                     switch (type)
1005                     {
1006                     case 0x22:
1007                         fetch_ushort(&format); /* hot spot */
1008                         /* fall thru */
1009                     case 0x03:
1010                         switch (GET_SHORT(format, 0))
1011                         {
1012                         case 0:
1013                             HLPFILE_LoadGfxByIndex(hlpfile, GET_SHORT(format, 2),
1014                                                    paragraph);
1015                             break;
1016                         case 1:
1017                             WINE_FIXME("does it work ??? %x<%lu>#%u\n",
1018                                        GET_SHORT(format, 0),
1019                                        size, GET_SHORT(format, 2));
1020                             HLPFILE_LoadGfxByAddr(hlpfile, format + 2, size - 4,
1021                                                   paragraph);
1022                             break;
1023                         default:
1024                             WINE_FIXME("??? %u\n", GET_SHORT(format, 0));
1025                             break;
1026                         }
1027                         break;
1028                     case 0x05:
1029                         WINE_FIXME("Got an embedded element %s\n", format + 6);
1030                         break;
1031                     default:
1032                         WINE_FIXME("Got a type %d picture\n", type);
1033                         break;
1034                     }
1035                     if (attributes.wVSpace) paragraph->u.gfx.pos |= 0x8000;
1036
1037                     format += size;
1038                 }
1039                 break;
1040
1041             case 0x89:
1042                 HLPFILE_FreeLink(attributes.link);
1043                 attributes.link = NULL;
1044                 format += 1;
1045                 break;
1046
1047             case 0x8B:
1048             case 0x8C:
1049                 WINE_FIXME("NIY non-break space/hyphen\n");
1050                 format += 1;
1051                 break;
1052
1053 #if 0
1054             case 0xA9:
1055                 format += 2;
1056                 break;
1057 #endif
1058
1059             case 0xC8:
1060             case 0xCC:
1061                 WINE_TRACE("macro => %s\n", format + 3);
1062                 HLPFILE_FreeLink(attributes.link);
1063                 attributes.link = HLPFILE_AllocLink(hlp_link_macro, format + 3,
1064                                                     0, !(*format & 4), -1);
1065                 format += 3 + GET_USHORT(format, 1);
1066                 break;
1067
1068             case 0xE0:
1069             case 0xE1:
1070                 WINE_WARN("jump topic 1 => %u\n", GET_UINT(format, 1));
1071                 format += 5;
1072                 break;
1073
1074             case 0xE2:
1075             case 0xE3:
1076             case 0xE6:
1077             case 0xE7:
1078                 HLPFILE_FreeLink(attributes.link);
1079                 attributes.link = HLPFILE_AllocLink((*format & 1) ? hlp_link_link : hlp_link_popup,
1080                                                     hlpfile->lpszPath,
1081                                                     GET_UINT(format, 1),
1082                                                     !(*format & 4), -1);
1083                 format += 5;
1084                 break;
1085
1086             case 0xEA:
1087             case 0xEB:
1088             case 0xEE:
1089             case 0xEF:
1090                 {
1091                     char*       ptr = format + 8;
1092                     BYTE        type = format[3];
1093                     int         wnd = -1;
1094                     char*       str;
1095
1096                     if (type == 1) wnd = *ptr++;
1097                     if (type == 4 || type == 6)
1098                     {
1099                         str = ptr;
1100                         ptr += strlen(ptr) + 1;
1101                     }
1102                     else
1103                         str = hlpfile->lpszPath;
1104                     if (type == 6)
1105                     {
1106                         for (wnd = hlpfile->numWindows - 1; wnd >= 0; wnd--)
1107                         {
1108                             if (!strcmp(ptr, hlpfile->windows[wnd].name)) break;
1109                         }
1110                         if (wnd == -1)
1111                             WINE_WARN("Couldn't find window info for %s\n", ptr);
1112                     }
1113                     HLPFILE_FreeLink(attributes.link);
1114                     attributes.link = HLPFILE_AllocLink((*format & 4) ? hlp_link_link : hlp_link_popup,
1115                                                         str, GET_UINT(format, 4),
1116                                                         !(*format & 1), wnd);
1117                 }
1118                 format += 3 + GET_USHORT(format, 1);
1119                 break;
1120
1121             default:
1122                 WINE_WARN("format %02x\n", *format);
1123                 format++;
1124             }
1125         }
1126     }
1127     if (text_end != buf + GET_UINT(buf, 0x10) + size)
1128         HeapFree(GetProcessHeap(), 0, text_end - size);
1129     return TRUE;
1130 }
1131
1132 /******************************************************************
1133  *              HLPFILE_ReadFont
1134  *
1135  *
1136  */
1137 static BOOL HLPFILE_ReadFont(HLPFILE* hlpfile)
1138 {
1139     BYTE        *ref, *end;
1140     unsigned    i, len, idx;
1141     unsigned    face_num, dscr_num, face_offset, dscr_offset;
1142     BYTE        flag, family;
1143
1144     if (!HLPFILE_FindSubFile("|FONT", &ref, &end))
1145     {
1146         WINE_WARN("no subfile FONT\n");
1147         hlpfile->numFonts = 0;
1148         hlpfile->fonts = NULL;
1149         return FALSE;
1150     }
1151
1152     ref += 9;
1153
1154     face_num    = GET_USHORT(ref, 0);
1155     dscr_num    = GET_USHORT(ref, 2);
1156     face_offset = GET_USHORT(ref, 4);
1157     dscr_offset = GET_USHORT(ref, 6);
1158
1159     WINE_TRACE("Got NumFacenames=%u@%u NumDesc=%u@%u\n",
1160                face_num, face_offset, dscr_num, dscr_offset);
1161
1162     hlpfile->numFonts = dscr_num;
1163     hlpfile->fonts = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_FONT) * dscr_num);
1164
1165     len = (dscr_offset - face_offset) / face_num;
1166 /* EPP     for (i = face_offset; i < dscr_offset; i += len) */
1167 /* EPP         WINE_FIXME("[%d]: %*s\n", i / len, len, ref + i); */
1168     for (i = 0; i < dscr_num; i++)
1169     {
1170         flag = ref[dscr_offset + i * 11 + 0];
1171         family = ref[dscr_offset + i * 11 + 2];
1172
1173         hlpfile->fonts[i].LogFont.lfHeight = -ref[dscr_offset + i * 11 + 1] / 2;
1174         hlpfile->fonts[i].LogFont.lfWidth = 0;
1175         hlpfile->fonts[i].LogFont.lfEscapement = 0;
1176         hlpfile->fonts[i].LogFont.lfOrientation = 0;
1177         hlpfile->fonts[i].LogFont.lfWeight = (flag & 1) ? 700 : 400;
1178         hlpfile->fonts[i].LogFont.lfItalic = (flag & 2) ? TRUE : FALSE;
1179         hlpfile->fonts[i].LogFont.lfUnderline = (flag & 4) ? TRUE : FALSE;
1180         hlpfile->fonts[i].LogFont.lfStrikeOut = (flag & 8) ? TRUE : FALSE;
1181         hlpfile->fonts[i].LogFont.lfCharSet = ANSI_CHARSET;
1182         hlpfile->fonts[i].LogFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
1183         hlpfile->fonts[i].LogFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
1184         hlpfile->fonts[i].LogFont.lfQuality = DEFAULT_QUALITY;
1185         hlpfile->fonts[i].LogFont.lfPitchAndFamily = DEFAULT_PITCH;
1186
1187         switch (family)
1188         {
1189         case 0x01: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_MODERN;     break;
1190         case 0x02: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_ROMAN;      break;
1191         case 0x03: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_SWISS;      break;
1192         case 0x04: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_SCRIPT;     break;
1193         case 0x05: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_DECORATIVE; break;
1194         default: WINE_FIXME("Unknown family %u\n", family);
1195         }
1196         idx = GET_USHORT(ref, dscr_offset + i * 11 + 3);
1197
1198         if (idx < face_num)
1199         {
1200             strncpy(hlpfile->fonts[i].LogFont.lfFaceName, ref + face_offset + idx * len, min(len, LF_FACESIZE - 1));
1201             hlpfile->fonts[i].LogFont.lfFaceName[min(len, LF_FACESIZE - 1) + 1] = '\0';
1202         }
1203         else
1204         {
1205             WINE_FIXME("Too high face ref (%u/%u)\n", idx, face_num);
1206             strcpy(hlpfile->fonts[i].LogFont.lfFaceName, "Helv");
1207         }
1208         hlpfile->fonts[i].hFont = 0;
1209         hlpfile->fonts[i].color = RGB(ref[dscr_offset + i * 11 + 5],
1210                                       ref[dscr_offset + i * 11 + 6],
1211                                       ref[dscr_offset + i * 11 + 7]);
1212 #define X(b,s) ((flag & (1 << b)) ? "-"s: "")
1213         WINE_TRACE("Font[%d]: flags=%02x%s%s%s%s%s%s pSize=%u family=%u face=%s[%u] color=%08x\n",
1214                    i, flag,
1215                    X(0, "bold"),
1216                    X(1, "italic"),
1217                    X(2, "underline"),
1218                    X(3, "strikeOut"),
1219                    X(4, "dblUnderline"),
1220                    X(5, "smallCaps"),
1221                    ref[dscr_offset + i * 11 + 1],
1222                    family,
1223                    hlpfile->fonts[i].LogFont.lfFaceName, idx,
1224                    GET_UINT(ref, dscr_offset + i * 11 + 5) & 0x00FFFFFF);
1225     }
1226     return TRUE;
1227 }
1228
1229 /***********************************************************************
1230  *
1231  *           HLPFILE_ReadFileToBuffer
1232  */
1233 static BOOL HLPFILE_ReadFileToBuffer(HFILE hFile)
1234 {
1235     BYTE  header[16], dummy[1];
1236     UINT  size;
1237
1238     if (_hread(hFile, header, 16) != 16) {WINE_WARN("header\n"); return FALSE;};
1239
1240     /* sanity checks */
1241     if (GET_UINT(header, 0) != 0x00035F3F)
1242     {WINE_WARN("wrong header\n"); return FALSE;};
1243
1244     size = GET_UINT(header, 12);
1245     file_buffer = HeapAlloc(GetProcessHeap(), 0, size + 1);
1246     if (!file_buffer) return FALSE;
1247
1248     memcpy(file_buffer, header, 16);
1249     if (_hread(hFile, file_buffer + 16, size - 16) != size - 16)
1250     {WINE_WARN("filesize1\n"); return FALSE;};
1251
1252     if (_hread(hFile, dummy, 1) != 0) WINE_WARN("filesize2\n");
1253
1254     file_buffer[size] = '\0'; /* FIXME: was '0', sounds ackward to me */
1255
1256     return TRUE;
1257 }
1258
1259 /***********************************************************************
1260  *
1261  *           HLPFILE_FindSubFile
1262  */
1263 static BOOL HLPFILE_FindSubFile(LPCSTR name, BYTE **subbuf, BYTE **subend)
1264 {
1265     BYTE *root = file_buffer + GET_UINT(file_buffer,  4);
1266     BYTE *end  = file_buffer + GET_UINT(file_buffer, 12);
1267     BYTE *ptr;
1268     BYTE *bth;
1269
1270     unsigned    pgsize;
1271     unsigned    pglast;
1272     unsigned    nentries;
1273     unsigned    i, n;
1274
1275     bth = root + 9;
1276
1277     /* FIXME: this should be using the EnumBTree functions from this file */
1278     pgsize = GET_USHORT(bth, 4);
1279     WINE_TRACE("%s => pgsize=%u #pg=%u rootpg=%u #lvl=%u\n",
1280                name, pgsize, GET_USHORT(bth, 30), GET_USHORT(bth, 26), GET_USHORT(bth, 32));
1281
1282     ptr = bth + 38 + GET_USHORT(bth, 26) * pgsize;
1283
1284     for (n = 1; n < GET_USHORT(bth, 32); n++)
1285     {
1286         nentries = GET_USHORT(ptr, 2);
1287         pglast = GET_USHORT(ptr, 4);
1288         WINE_TRACE("[%u]: #entries=%u next=%u\n", n, nentries, pglast);
1289
1290         ptr += 6;
1291         for (i = 0; i < nentries; i++)
1292         {
1293             WINE_TRACE("<= %s\n", ptr);
1294             if (strcmp(name, ptr) < 0) break;
1295             ptr += strlen(ptr) + 1;
1296             pglast = GET_USHORT(ptr, 0);
1297             ptr += 2;
1298         }
1299         ptr = bth + 38 + pglast * pgsize;
1300     }
1301
1302     nentries = GET_USHORT(ptr, 2);
1303     ptr += 8;
1304     for (i = 0; i < nentries; i++)
1305     {
1306         char*   fname = ptr;
1307         ptr += strlen(fname) + 1;
1308         WINE_TRACE("\\- %s\n", fname);
1309         if (strcmp(fname, name) == 0)
1310         {
1311             *subbuf = file_buffer + GET_UINT(ptr, 0);
1312             *subend = *subbuf + GET_UINT(*subbuf, 0);
1313             if (file_buffer > *subbuf || *subbuf > *subend || *subend > end)
1314             {
1315                 WINE_WARN("size mismatch\n");
1316                 return FALSE;
1317             }
1318             return TRUE;
1319         }
1320         ptr += 4;
1321     }
1322
1323     return FALSE;
1324 }
1325
1326 /***********************************************************************
1327  *
1328  *           HLPFILE_SystemCommands
1329  */
1330 static BOOL HLPFILE_SystemCommands(HLPFILE* hlpfile)
1331 {
1332     BYTE *buf, *ptr, *end;
1333     HLPFILE_MACRO *macro, **m;
1334     LPSTR p;
1335     unsigned short magic, minor, major, flags;
1336
1337     hlpfile->lpszTitle = NULL;
1338
1339     if (!HLPFILE_FindSubFile("|SYSTEM", &buf, &end)) return FALSE;
1340
1341     magic = GET_USHORT(buf + 9, 0);
1342     minor = GET_USHORT(buf + 9, 2);
1343     major = GET_USHORT(buf + 9, 4);
1344     /* gen date on 4 bytes */
1345     flags = GET_USHORT(buf + 9, 10);
1346     WINE_TRACE("Got system header: magic=%04x version=%d.%d flags=%04x\n",
1347                magic, major, minor, flags);
1348     if (magic != 0x036C || major != 1)
1349     {WINE_WARN("Wrong system header\n"); return FALSE;}
1350     if (minor <= 16) {WINE_WARN("too old file format (NIY)\n"); return FALSE;}
1351     if (flags & 8) {WINE_WARN("Unsupported yet page size\n"); return FALSE;}
1352
1353     hlpfile->version = minor;
1354     hlpfile->flags = flags;
1355
1356     for (ptr = buf + 0x15; ptr + 4 <= end; ptr += GET_USHORT(ptr, 2) + 4)
1357     {
1358         switch (GET_USHORT(ptr, 0))
1359         {
1360         case 1:
1361             if (hlpfile->lpszTitle) {WINE_WARN("title\n"); break;}
1362             hlpfile->lpszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(ptr + 4) + 1);
1363             if (!hlpfile->lpszTitle) return FALSE;
1364             lstrcpy(hlpfile->lpszTitle, ptr + 4);
1365             WINE_TRACE("Title: %s\n", hlpfile->lpszTitle);
1366             break;
1367
1368         case 2:
1369             if (hlpfile->lpszCopyright) {WINE_WARN("copyright\n"); break;}
1370             hlpfile->lpszCopyright = HeapAlloc(GetProcessHeap(), 0, strlen(ptr + 4) + 1);
1371             if (!hlpfile->lpszCopyright) return FALSE;
1372             lstrcpy(hlpfile->lpszCopyright, ptr + 4);
1373             WINE_TRACE("Copyright: %s\n", hlpfile->lpszCopyright);
1374             break;
1375
1376         case 3:
1377             if (GET_USHORT(ptr, 2) != 4) {WINE_WARN("system3\n");break;}
1378             hlpfile->contents_start = GET_UINT(ptr, 4);
1379             WINE_TRACE("Setting contents start at %08lx\n", hlpfile->contents_start);
1380             break;
1381
1382         case 4:
1383             macro = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_MACRO) + lstrlen(ptr + 4) + 1);
1384             if (!macro) break;
1385             p = (char*)macro + sizeof(HLPFILE_MACRO);
1386             lstrcpy(p, (LPSTR)ptr + 4);
1387             macro->lpszMacro = p;
1388             macro->next = 0;
1389             for (m = &hlpfile->first_macro; *m; m = &(*m)->next);
1390             *m = macro;
1391             break;
1392
1393         case 6:
1394             if (GET_USHORT(ptr, 2) != 90) {WINE_WARN("system6\n");break;}
1395             hlpfile->windows = HeapReAlloc(GetProcessHeap(), 0, hlpfile->windows,
1396                                            sizeof(HLPFILE_WINDOWINFO) * ++hlpfile->numWindows);
1397             if (hlpfile->windows)
1398             {
1399                 unsigned flags = GET_USHORT(ptr, 4);
1400                 HLPFILE_WINDOWINFO* wi = &hlpfile->windows[hlpfile->numWindows - 1];
1401
1402                 if (flags & 0x0001) strcpy(wi->type, ptr + 6); else wi->type[0] = '\0';
1403                 if (flags & 0x0002) strcpy(wi->name, ptr + 16); else wi->name[0] = '\0';
1404                 if (flags & 0x0004) strcpy(wi->caption, ptr + 25); else strncpy(wi->caption, hlpfile->lpszTitle, sizeof(wi->caption));
1405                 wi->origin.x = (flags & 0x0008) ? GET_USHORT(ptr, 76) : CW_USEDEFAULT;
1406                 wi->origin.y = (flags & 0x0010) ? GET_USHORT(ptr, 78) : CW_USEDEFAULT;
1407                 wi->size.cx = (flags & 0x0020) ? GET_USHORT(ptr, 80) : CW_USEDEFAULT;
1408                 wi->size.cy = (flags & 0x0040) ? GET_USHORT(ptr, 82) : CW_USEDEFAULT;
1409                 wi->style = (flags & 0x0080) ? GET_USHORT(ptr, 84) : SW_SHOW;
1410                 wi->sr_color = (flags & 0x0100) ? GET_UINT(ptr, 86) : 0xFFFFFF;
1411                 wi->nsr_color = (flags & 0x0200) ? GET_UINT(ptr, 90) : 0xFFFFFF;
1412                 WINE_TRACE("System-Window: flags=%c%c%c%c%c%c%c%c type=%s name=%s caption=%s (%ld,%ld)x(%ld,%ld)\n",
1413                            flags & 0x0001 ? 'T' : 't',
1414                            flags & 0x0002 ? 'N' : 'n',
1415                            flags & 0x0004 ? 'C' : 'c',
1416                            flags & 0x0008 ? 'X' : 'x',
1417                            flags & 0x0010 ? 'Y' : 'y',
1418                            flags & 0x0020 ? 'W' : 'w',
1419                            flags & 0x0040 ? 'H' : 'h',
1420                            flags & 0x0080 ? 'S' : 's',
1421                            wi->type, wi->name, wi->caption, wi->origin.x, wi->origin.y,
1422                            wi->size.cx, wi->size.cy);
1423             }
1424             break;
1425         default:
1426             WINE_WARN("Unsupported SystemRecord[%d]\n", GET_USHORT(ptr, 0));
1427         }
1428     }
1429     return TRUE;
1430 }
1431
1432 /***********************************************************************
1433  *
1434  *           HLPFILE_UncompressedLZ77_Size
1435  */
1436 static INT HLPFILE_UncompressedLZ77_Size(BYTE *ptr, BYTE *end)
1437 {
1438     int  i, newsize = 0;
1439
1440     while (ptr < end)
1441     {
1442         int mask = *ptr++;
1443         for (i = 0; i < 8 && ptr < end; i++, mask >>= 1)
1444         {
1445             if (mask & 1)
1446             {
1447                 int code = GET_USHORT(ptr, 0);
1448                 int len  = 3 + (code >> 12);
1449                 newsize += len;
1450                 ptr     += 2;
1451             }
1452             else newsize++, ptr++;
1453         }
1454     }
1455
1456     return newsize;
1457 }
1458
1459 /***********************************************************************
1460  *
1461  *           HLPFILE_UncompressLZ77
1462  */
1463 static BYTE *HLPFILE_UncompressLZ77(BYTE *ptr, BYTE *end, BYTE *newptr)
1464 {
1465     int i;
1466
1467     while (ptr < end)
1468     {
1469         int mask = *ptr++;
1470         for (i = 0; i < 8 && ptr < end; i++, mask >>= 1)
1471         {
1472             if (mask & 1)
1473             {
1474                 int code   = GET_USHORT(ptr, 0);
1475                 int len    = 3 + (code >> 12);
1476                 int offset = code & 0xfff;
1477                 memcpy(newptr, newptr - offset - 1, len);
1478                 newptr += len;
1479                 ptr    += 2;
1480             }
1481             else *newptr++ = *ptr++;
1482         }
1483     }
1484
1485     return newptr;
1486 }
1487
1488 /***********************************************************************
1489  *
1490  *           HLPFILE_UncompressLZ77_Phrases
1491  */
1492 static BOOL HLPFILE_UncompressLZ77_Phrases(HLPFILE* hlpfile)
1493 {
1494     UINT i, num, dec_size;
1495     BYTE *buf, *end;
1496
1497     if (!HLPFILE_FindSubFile("|Phrases", &buf, &end)) return FALSE;
1498
1499     num = phrases.num = GET_USHORT(buf, 9);
1500     if (buf + 2 * num + 0x13 >= end) {WINE_WARN("1a\n"); return FALSE;};
1501
1502     dec_size = HLPFILE_UncompressedLZ77_Size(buf + 0x13 + 2 * num, end);
1503
1504     phrases.offsets = HeapAlloc(GetProcessHeap(), 0, sizeof(unsigned) * (num + 1));
1505     phrases.buffer  = HeapAlloc(GetProcessHeap(), 0, dec_size);
1506     if (!phrases.offsets || !phrases.buffer) return FALSE;
1507
1508     for (i = 0; i <= num; i++)
1509         phrases.offsets[i] = GET_USHORT(buf, 0x11 + 2 * i) - 2 * num - 2;
1510
1511     HLPFILE_UncompressLZ77(buf + 0x13 + 2 * num, end, phrases.buffer);
1512
1513     hlpfile->hasPhrases = TRUE;
1514     return TRUE;
1515 }
1516
1517 /***********************************************************************
1518  *
1519  *           HLPFILE_Uncompress_Phrases40
1520  */
1521 static BOOL HLPFILE_Uncompress_Phrases40(HLPFILE* hlpfile)
1522 {
1523     UINT num, dec_size, cpr_size;
1524     BYTE *buf_idx, *end_idx;
1525     BYTE *buf_phs, *end_phs;
1526     short i, n;
1527     long* ptr, mask = 0;
1528     unsigned short bc;
1529
1530     if (!HLPFILE_FindSubFile("|PhrIndex", &buf_idx, &end_idx) ||
1531         !HLPFILE_FindSubFile("|PhrImage", &buf_phs, &end_phs)) return FALSE;
1532
1533     ptr = (long*)(buf_idx + 9 + 28);
1534     bc = GET_USHORT(buf_idx, 9 + 24) & 0x0F;
1535     num = phrases.num = GET_USHORT(buf_idx, 9 + 4);
1536
1537     WINE_TRACE("Index: Magic=%08x #entries=%u CpsdSize=%u PhrImgSize=%u\n"
1538                "\tPhrImgCprsdSize=%u 0=%u bc=%x ukn=%x\n",
1539                GET_UINT(buf_idx, 9 + 0),
1540                GET_UINT(buf_idx, 9 + 4),
1541                GET_UINT(buf_idx, 9 + 8),
1542                GET_UINT(buf_idx, 9 + 12),
1543                GET_UINT(buf_idx, 9 + 16),
1544                GET_UINT(buf_idx, 9 + 20),
1545                GET_USHORT(buf_idx, 9 + 24),
1546                GET_USHORT(buf_idx, 9 + 26));
1547
1548     dec_size = GET_UINT(buf_idx, 9 + 12);
1549     cpr_size = GET_UINT(buf_idx, 9 + 16);
1550
1551     if (dec_size != cpr_size &&
1552         dec_size != HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs))
1553     {
1554         WINE_WARN("size mismatch %u %u\n",
1555                   dec_size, HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs));
1556         dec_size = max(dec_size, HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs));
1557     }
1558
1559     phrases.offsets = HeapAlloc(GetProcessHeap(), 0, sizeof(unsigned) * (num + 1));
1560     phrases.buffer  = HeapAlloc(GetProcessHeap(), 0, dec_size);
1561     if (!phrases.offsets || !phrases.buffer) return FALSE;
1562
1563 #define getbit() (ptr += (mask < 0), mask = mask*2 + (mask<=0), (*ptr & mask) != 0)
1564
1565     phrases.offsets[0] = 0;
1566     for (i = 0; i < num; i++)
1567     {
1568         for (n = 1; getbit(); n += 1 << bc);
1569         if (getbit()) n++;
1570         if (bc > 1 && getbit()) n += 2;
1571         if (bc > 2 && getbit()) n += 4;
1572         if (bc > 3 && getbit()) n += 8;
1573         if (bc > 4 && getbit()) n += 16;
1574         phrases.offsets[i + 1] = phrases.offsets[i] + n;
1575     }
1576 #undef getbit
1577
1578     if (dec_size == cpr_size)
1579         memcpy(phrases.buffer, buf_phs + 9, dec_size);
1580     else
1581         HLPFILE_UncompressLZ77(buf_phs + 9, end_phs, phrases.buffer);
1582
1583     hlpfile->hasPhrases = FALSE;
1584     return TRUE;
1585 }
1586
1587 /***********************************************************************
1588  *
1589  *           HLPFILE_Uncompress_Topic
1590  */
1591 static BOOL HLPFILE_Uncompress_Topic(HLPFILE* hlpfile)
1592 {
1593     BYTE *buf, *ptr, *end, *newptr;
1594     int  i, newsize = 0;
1595
1596     if (!HLPFILE_FindSubFile("|TOPIC", &buf, &end))
1597     {WINE_WARN("topic0\n"); return FALSE;}
1598
1599     switch (hlpfile->flags & (8|4))
1600     {
1601     case 8:
1602         WINE_FIXME("Unsupported format\n");
1603         return FALSE;
1604     case 4:
1605         buf += 9;
1606         topic.wMapLen = (end - buf - 1) / 0x1000 + 1;
1607
1608         for (i = 0; i < topic.wMapLen; i++)
1609         {
1610             ptr = buf + i * 0x1000;
1611
1612             /* I don't know why, it's necessary for printman.hlp */
1613             if (ptr + 0x44 > end) ptr = end - 0x44;
1614
1615             newsize += HLPFILE_UncompressedLZ77_Size(ptr + 0xc, min(end, ptr + 0x1000));
1616         }
1617
1618         topic.map = HeapAlloc(GetProcessHeap(), 0,
1619                               topic.wMapLen * sizeof(topic.map[0]) + newsize);
1620         if (!topic.map) return FALSE;
1621         newptr = (char*)(topic.map + topic.wMapLen);
1622         topic.end = newptr + newsize;
1623
1624         for (i = 0; i < topic.wMapLen; i++)
1625         {
1626             ptr = buf + i * 0x1000;
1627             if (ptr + 0x44 > end) ptr = end - 0x44;
1628
1629             topic.map[i] = newptr;
1630             newptr = HLPFILE_UncompressLZ77(ptr + 0xc, min(end, ptr + 0x1000), newptr);
1631         }
1632         break;
1633     case 0:
1634         /* basically, we need to copy the 0x1000 byte pages (removing the first 0x0C) in
1635          * one single are in memory
1636          */
1637 #define DST_LEN (0x1000 - 0x0C)
1638         buf += 9;
1639         newsize = end - buf;
1640         /* number of destination pages */
1641         topic.wMapLen = (newsize - 1) / DST_LEN + 1;
1642         topic.map = HeapAlloc(GetProcessHeap(), 0,
1643                               topic.wMapLen * (sizeof(topic.map[0]) + DST_LEN));
1644         if (!topic.map) return FALSE;
1645         newptr = (char*)(topic.map + topic.wMapLen);
1646         topic.end = newptr + newsize;
1647
1648         for (i = 0; i < topic.wMapLen; i++)
1649         {
1650             topic.map[i] = newptr + i * DST_LEN;
1651             memcpy(topic.map[i], buf + i * 0x1000 + 0x0C, DST_LEN);
1652         }
1653 #undef DST_LEN
1654         break;
1655     }
1656     return TRUE;
1657 }
1658
1659 /***********************************************************************
1660  *
1661  *           HLPFILE_Uncompress2
1662  */
1663
1664 static void HLPFILE_Uncompress2(const BYTE *ptr, const BYTE *end, BYTE *newptr, const BYTE *newend)
1665 {
1666     BYTE *phptr, *phend;
1667     UINT code;
1668     UINT index;
1669
1670     while (ptr < end && newptr < newend)
1671     {
1672         if (!*ptr || *ptr >= 0x10)
1673             *newptr++ = *ptr++;
1674         else
1675         {
1676             code  = 0x100 * ptr[0] + ptr[1];
1677             index = (code - 0x100) / 2;
1678
1679             phptr = phrases.buffer + phrases.offsets[index];
1680             phend = phrases.buffer + phrases.offsets[index + 1];
1681
1682             if (newptr + (phend - phptr) > newend)
1683             {
1684                 WINE_FIXME("buffer overflow %p > %p for %d bytes\n",
1685                            newptr, newend, phend - phptr);
1686                 return;
1687             }
1688             memcpy(newptr, phptr, phend - phptr);
1689             newptr += phend - phptr;
1690             if (code & 1) *newptr++ = ' ';
1691
1692             ptr += 2;
1693         }
1694     }
1695     if (newptr > newend) WINE_FIXME("buffer overflow %p > %p\n", newptr, newend);
1696 }
1697
1698 /******************************************************************
1699  *              HLPFILE_Uncompress3
1700  *
1701  *
1702  */
1703 static BOOL HLPFILE_Uncompress3(char* dst, const char* dst_end,
1704                                 const BYTE* src, const BYTE* src_end)
1705 {
1706     int         idx, len;
1707
1708     for (; src < src_end; src++)
1709     {
1710         if ((*src & 1) == 0)
1711         {
1712             idx = *src / 2;
1713             if (idx > phrases.num)
1714             {
1715                 WINE_ERR("index in phrases %d/%d\n", idx, phrases.num);
1716                 len = 0;
1717             }
1718             else
1719             {
1720                 len = phrases.offsets[idx + 1] - phrases.offsets[idx];
1721                 if (dst + len <= dst_end)
1722                     memcpy(dst, &phrases.buffer[phrases.offsets[idx]], len);
1723             }
1724         }
1725         else if ((*src & 0x03) == 0x01)
1726         {
1727             idx = (*src + 1) * 64;
1728             idx += *++src;
1729             if (idx > phrases.num)
1730             {
1731                 WINE_ERR("index in phrases %d/%d\n", idx, phrases.num);
1732                 len = 0;
1733             }
1734             else
1735             {
1736                 len = phrases.offsets[idx + 1] - phrases.offsets[idx];
1737                 if (dst + len <= dst_end)
1738                     memcpy(dst, &phrases.buffer[phrases.offsets[idx]], len);
1739             }
1740         }
1741         else if ((*src & 0x07) == 0x03)
1742         {
1743             len = (*src / 8) + 1;
1744             if (dst + len <= dst_end)
1745                 memcpy(dst, src + 1, len);
1746             src += len;
1747         }
1748         else
1749         {
1750             len = (*src / 16) + 1;
1751             if (dst + len <= dst_end)
1752                 memset(dst, ((*src & 0x0F) == 0x07) ? ' ' : 0, len);
1753         }
1754         dst += len;
1755     }
1756
1757     if (dst > dst_end) WINE_ERR("buffer overflow (%p > %p)\n", dst, dst_end);
1758     return TRUE;
1759 }
1760
1761 /******************************************************************
1762  *              HLPFILE_UncompressRLE
1763  *
1764  *
1765  */
1766 static void HLPFILE_UncompressRLE(const BYTE* src, const BYTE* end, BYTE** dst, unsigned dstsz)
1767 {
1768     BYTE        ch;
1769     BYTE*       sdst = *dst + dstsz;
1770
1771     while (src < end)
1772     {
1773         ch = *src++;
1774         if (ch & 0x80)
1775         {
1776             ch &= 0x7F;
1777             if (ch == 0) WINE_FIXME("Null length 1, next is %u\n", *src);
1778             if ((*dst) + ch < sdst)
1779                 memcpy(*dst, src, ch);
1780             src += ch;
1781         }
1782         else
1783         {
1784             if ((*dst) + ch < sdst)
1785                 memset(*dst, (char)*src, ch);
1786             src++;
1787             if (ch == 0)
1788             {
1789                 WINE_FIXME("Null length 2, next is %u\n", *src);
1790             }
1791         }
1792         *dst += ch;
1793     }
1794     if (*dst != sdst)
1795         WINE_FIXME("Buffer X-flow: d(%u) instead of d(%u)\n",
1796                    *dst - (sdst - dstsz), dstsz);
1797 }
1798
1799 /******************************************************************
1800  *              HLPFILE_EnumBTreeLeaves
1801  *
1802  *
1803  */
1804 static void HLPFILE_EnumBTreeLeaves(const BYTE* buf, const BYTE* end, unsigned (*fn)(const BYTE*, void*), void* user)
1805 {
1806     unsigned    psize, pnext;
1807     unsigned    num, nlvl;
1808     const BYTE* ptr;
1809
1810     num    = GET_UINT(buf, 9 + 34);
1811     psize  = GET_USHORT(buf, 9 + 4);
1812     nlvl   = GET_USHORT(buf, 9 + 32);
1813     pnext  = GET_USHORT(buf, 9 + 26);
1814
1815     WINE_TRACE("BTree: #entries=%u pagSize=%u #levels=%u #pages=%u root=%u struct%16s\n",
1816                num, psize, nlvl, GET_USHORT(buf, 9 + 30), pnext, buf + 9 + 6);
1817     if (!num) return;
1818
1819     while (--nlvl > 0)
1820     {
1821         ptr = (buf + 9 + 38) + pnext * psize;
1822         WINE_TRACE("BTree: (index[%u]) unused=%u #entries=%u <%u\n",
1823                    pnext, GET_USHORT(ptr, 0), GET_USHORT(ptr, 2), GET_USHORT(ptr, 4));
1824         pnext = GET_USHORT(ptr, 4);
1825     }
1826     while (pnext != 0xFFFF)
1827     {
1828         const BYTE*     node_page;
1829         unsigned short  limit;
1830
1831         node_page = ptr = (buf + 9 + 38) + pnext * psize;
1832         limit = GET_USHORT(ptr, 2);
1833         WINE_TRACE("BTree: (leaf [%u]) unused=%u #entries=%u <%u >%u\n",
1834                    pnext, GET_USHORT(ptr, 0), limit, GET_USHORT(ptr, 4), GET_USHORT(ptr, 6));
1835         ptr += 8;
1836         while (limit--)
1837             ptr += (fn)(ptr, user);
1838         pnext = GET_USHORT(node_page, 6);
1839     }
1840 }
1841
1842 struct myfncb {
1843     HLPFILE*    hlpfile;
1844     int         i;
1845 };
1846
1847 static unsigned myfn(const BYTE* ptr, void* user)
1848 {
1849     struct myfncb*      m = user;
1850
1851     m->hlpfile->Context[m->i].lHash  = GET_UINT(ptr, 0);
1852     m->hlpfile->Context[m->i].offset = GET_UINT(ptr, 4);
1853     m->i++;
1854     return 8;
1855 }
1856
1857 /***********************************************************************
1858  *
1859  *           HLPFILE_GetContext
1860  */
1861 static BOOL HLPFILE_GetContext(HLPFILE *hlpfile)
1862 {
1863     BYTE                *cbuf, *cend;
1864     struct myfncb       m;
1865     unsigned            clen;
1866
1867     if (!HLPFILE_FindSubFile("|CONTEXT",  &cbuf, &cend)) {WINE_WARN("context0\n"); return FALSE;}
1868
1869     clen = GET_UINT(cbuf, 0x2b);
1870     hlpfile->Context = HeapAlloc(GetProcessHeap(), 0, clen * sizeof(HLPFILE_CONTEXT));
1871     if (!hlpfile->Context) return FALSE;
1872     hlpfile->wContextLen = clen;
1873
1874     m.hlpfile = hlpfile;
1875     m.i = 0;
1876     HLPFILE_EnumBTreeLeaves(cbuf, cend, myfn, &m);
1877
1878     return TRUE;
1879 }
1880
1881 /******************************************************************
1882  *              HLPFILE_DeleteLink
1883  *
1884  *
1885  */
1886 void HLPFILE_FreeLink(HLPFILE_LINK* link)
1887 {
1888     if (link && !--link->wRefCount)
1889         HeapFree(GetProcessHeap(), 0, link);
1890 }
1891
1892 /***********************************************************************
1893  *
1894  *           HLPFILE_DeleteParagraph
1895  */
1896 static void HLPFILE_DeleteParagraph(HLPFILE_PARAGRAPH* paragraph)
1897 {
1898     HLPFILE_PARAGRAPH* next;
1899
1900     while (paragraph)
1901     {
1902         next = paragraph->next;
1903
1904         if (paragraph->cookie == para_metafile)
1905             DeleteMetaFile(paragraph->u.gfx.u.mf.hMetaFile);
1906
1907         HLPFILE_FreeLink(paragraph->link);
1908
1909         HeapFree(GetProcessHeap(), 0, paragraph);
1910         paragraph = next;
1911     }
1912 }
1913
1914 /***********************************************************************
1915  *
1916  *           DeleteMacro
1917  */
1918 static void HLPFILE_DeleteMacro(HLPFILE_MACRO* macro)
1919 {
1920     HLPFILE_MACRO*      next;
1921
1922     while (macro)
1923     {
1924         next = macro->next;
1925         HeapFree(GetProcessHeap(), 0, macro);
1926         macro = next;
1927     }
1928 }
1929
1930 /***********************************************************************
1931  *
1932  *           DeletePage
1933  */
1934 static void HLPFILE_DeletePage(HLPFILE_PAGE* page)
1935 {
1936     HLPFILE_PAGE* next;
1937
1938     while (page)
1939     {
1940         next = page->next;
1941         HLPFILE_DeleteParagraph(page->first_paragraph);
1942         HLPFILE_DeleteMacro(page->first_macro);
1943         HeapFree(GetProcessHeap(), 0, page);
1944         page = next;
1945     }
1946 }
1947
1948 /***********************************************************************
1949  *
1950  *           HLPFILE_FreeHlpFile
1951  */
1952 void HLPFILE_FreeHlpFile(HLPFILE* hlpfile)
1953 {
1954     unsigned i;
1955
1956     if (!hlpfile || --hlpfile->wRefCount > 0) return;
1957
1958     if (hlpfile->next) hlpfile->next->prev = hlpfile->prev;
1959     if (hlpfile->prev) hlpfile->prev->next = hlpfile->next;
1960     else first_hlpfile = hlpfile->next;
1961
1962     if (hlpfile->numFonts)
1963     {
1964         for (i = 0; i < hlpfile->numFonts; i++)
1965         {
1966             DeleteObject(hlpfile->fonts[i].hFont);
1967         }
1968         HeapFree(GetProcessHeap(), 0, hlpfile->fonts);
1969     }
1970
1971     if (hlpfile->numBmps)
1972     {
1973         for (i = 0; i < hlpfile->numBmps; i++)
1974         {
1975             DeleteObject(hlpfile->bmps[i]);
1976         }
1977         HeapFree(GetProcessHeap(), 0, hlpfile->bmps);
1978     }
1979
1980     HLPFILE_DeletePage(hlpfile->first_page);
1981     HLPFILE_DeleteMacro(hlpfile->first_macro);
1982
1983     if (hlpfile->numWindows)    HeapFree(GetProcessHeap(), 0, hlpfile->windows);
1984     if (hlpfile->Context)       HeapFree(GetProcessHeap(), 0, hlpfile->Context);
1985     if (hlpfile->lpszTitle)     HeapFree(GetProcessHeap(), 0, hlpfile->lpszTitle);
1986     if (hlpfile->lpszCopyright) HeapFree(GetProcessHeap(), 0, hlpfile->lpszCopyright);
1987     HeapFree(GetProcessHeap(), 0, hlpfile);
1988 }