1996-05-06 18:06:24 +02:00
|
|
|
/*
|
|
|
|
* Help Viewer
|
|
|
|
*
|
2002-07-16 03:46:29 +02:00
|
|
|
* Copyright 1996 Ulrich Schmid
|
|
|
|
* 2002 Eric Pouech
|
2002-03-10 00:29:33 +01:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
1996-05-06 18:06:24 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
2000-03-19 22:49:49 +01:00
|
|
|
#include <string.h>
|
2002-07-16 03:46:29 +02:00
|
|
|
#include "winbase.h"
|
|
|
|
#include "wingdi.h"
|
1996-05-06 18:06:24 +02:00
|
|
|
#include "winhelp.h"
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
#include "wine/debug.h"
|
|
|
|
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(winhelp);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
#define GET_USHORT(buffer, i)\
|
|
|
|
(((BYTE)((buffer)[(i)]) + 0x100 * (BYTE)((buffer)[(i)+1])))
|
|
|
|
#define GET_SHORT(buffer, i)\
|
|
|
|
(((BYTE)((buffer)[(i)]) + 0x100 * (signed char)((buffer)[(i)+1])))
|
|
|
|
#define GET_UINT(buffer, i)\
|
|
|
|
GET_USHORT(buffer, i) + 0x10000 * GET_USHORT(buffer, i+2)
|
|
|
|
|
|
|
|
static HLPFILE *first_hlpfile = 0;
|
|
|
|
static BYTE *file_buffer;
|
|
|
|
|
|
|
|
static struct
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
UINT num;
|
|
|
|
unsigned* offsets;
|
|
|
|
char* buffer;
|
1996-05-06 18:06:24 +02:00
|
|
|
} phrases;
|
|
|
|
|
|
|
|
static struct
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
BYTE** map;
|
|
|
|
BYTE* end;
|
|
|
|
UINT wMapLen;
|
1996-05-06 18:06:24 +02:00
|
|
|
} topic;
|
|
|
|
|
|
|
|
static struct
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
UINT bDebug;
|
|
|
|
UINT wFont;
|
|
|
|
UINT wIndent;
|
|
|
|
UINT wHSpace;
|
|
|
|
UINT wVSpace;
|
|
|
|
UINT wVBackSpace;
|
|
|
|
HLPFILE_LINK link;
|
|
|
|
HBITMAP hBitmap;
|
|
|
|
UINT bmpPos;
|
1996-05-06 18:06:24 +02:00
|
|
|
} attributes;
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
static BOOL HLPFILE_DoReadHlpFile(HLPFILE*, LPCSTR);
|
|
|
|
static BOOL HLPFILE_ReadFileToBuffer(HFILE);
|
|
|
|
static BOOL HLPFILE_FindSubFile(LPCSTR name, BYTE**, BYTE**);
|
|
|
|
static BOOL HLPFILE_SystemCommands(HLPFILE*);
|
|
|
|
static INT HLPFILE_UncompressedLZ77_Size(BYTE *ptr, BYTE *end);
|
|
|
|
static BYTE* HLPFILE_UncompressLZ77(BYTE *ptr, BYTE *end, BYTE *newptr);
|
|
|
|
static BOOL HLPFILE_UncompressLZ77_Phrases(HLPFILE*);
|
|
|
|
static BOOL HLPFILE_Uncompress_Phrases40(HLPFILE*);
|
|
|
|
static BOOL HLPFILE_UncompressLZ77_Topic(HLPFILE*);
|
|
|
|
static BOOL HLPFILE_GetContext(HLPFILE*);
|
|
|
|
static BOOL HLPFILE_AddPage(HLPFILE*, BYTE*, BYTE*, unsigned);
|
|
|
|
static BOOL HLPFILE_AddParagraph(HLPFILE*, BYTE *, BYTE*, unsigned*);
|
|
|
|
static UINT HLPFILE_Uncompressed2_Size(BYTE*, BYTE*);
|
|
|
|
static void HLPFILE_Uncompress2(BYTE**, BYTE*, BYTE*);
|
|
|
|
static BOOL HLPFILE_Uncompress3(char*, const char*, const BYTE*, const BYTE*);
|
|
|
|
static void HLPFILE_UncompressRLE(const BYTE* src, unsigned sz, BYTE** dst);
|
|
|
|
static BOOL HLPFILE_ReadFont(HLPFILE* hlpfile);
|
|
|
|
|
1996-05-06 18:06:24 +02:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_Contents
|
|
|
|
*/
|
|
|
|
HLPFILE_PAGE *HLPFILE_Contents(LPCSTR lpszPath)
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
HLPFILE *hlpfile = HLPFILE_ReadHlpFile(lpszPath);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!hlpfile) return 0;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
return hlpfile->first_page;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_PageByNumber
|
|
|
|
*/
|
|
|
|
HLPFILE_PAGE *HLPFILE_PageByNumber(LPCSTR lpszPath, UINT wNum)
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
HLPFILE_PAGE *page;
|
|
|
|
HLPFILE *hlpfile = HLPFILE_ReadHlpFile(lpszPath);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!hlpfile) return 0;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
WINE_TRACE("[%s/%u]\n", lpszPath, wNum);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
for (page = hlpfile->first_page; page && wNum; page = page->next) wNum--;
|
|
|
|
|
|
|
|
return page;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_HlpFilePageByHash
|
|
|
|
*/
|
|
|
|
HLPFILE_PAGE *HLPFILE_PageByHash(LPCSTR lpszPath, LONG lHash)
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
HLPFILE_PAGE* page;
|
|
|
|
HLPFILE_PAGE* found;
|
|
|
|
HLPFILE* hlpfile = HLPFILE_ReadHlpFile(lpszPath);
|
|
|
|
int i;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
WINE_TRACE("path<%s>[%lx]\n", lpszPath, lHash);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!hlpfile) return 0;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
page = NULL;
|
|
|
|
for (i = 0; i < hlpfile->wContextLen; i++)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
if (hlpfile->Context[i].lHash != lHash) continue;
|
|
|
|
|
|
|
|
/* FIXME:
|
|
|
|
* this finds the page containing the offset. The offset can either
|
|
|
|
* refer to the top of the page (offset == page->offset), or
|
|
|
|
* to some paragraph inside the page...
|
|
|
|
* As of today, we only return the page... we should also return
|
|
|
|
* a paragraph, and then, while opening a new page, compute the
|
|
|
|
* y-offset of the paragraph to be shown and scroll the window
|
|
|
|
* accordinly
|
|
|
|
*/
|
|
|
|
found = NULL;
|
|
|
|
for (page = hlpfile->first_page; page; page = page->next)
|
|
|
|
{
|
|
|
|
if (page->offset <= hlpfile->Context[i].offset)
|
|
|
|
{
|
|
|
|
if (!found || found->offset < page->offset)
|
|
|
|
found = page;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (found) return found;
|
|
|
|
|
|
|
|
WINE_ERR("Page of offset %lu not found in file %s\n",
|
|
|
|
hlpfile->Context[i].offset, lpszPath);
|
|
|
|
return NULL;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
WINE_ERR("Page of hash %lx not found in file %s\n", lHash, lpszPath);
|
|
|
|
return NULL;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_Hash
|
|
|
|
*/
|
|
|
|
LONG HLPFILE_Hash(LPCSTR lpszContext)
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
LONG lHash = 0;
|
|
|
|
CHAR c;
|
|
|
|
|
|
|
|
while ((c = *lpszContext++))
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
CHAR x = 0;
|
|
|
|
if (c >= 'A' && c <= 'Z') x = c - 'A' + 17;
|
|
|
|
if (c >= 'a' && c <= 'z') x = c - 'a' + 17;
|
|
|
|
if (c >= '1' && c <= '9') x = c - '0';
|
|
|
|
if (c == '0') x = 10;
|
|
|
|
if (c == '.') x = 12;
|
|
|
|
if (c == '_') x = 13;
|
|
|
|
if (x) lHash = lHash * 43 + x;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
return lHash;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_ReadHlpFile
|
|
|
|
*/
|
|
|
|
HLPFILE *HLPFILE_ReadHlpFile(LPCSTR lpszPath)
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
HLPFILE* hlpfile;
|
|
|
|
|
|
|
|
for (hlpfile = first_hlpfile; hlpfile; hlpfile = hlpfile->next)
|
|
|
|
{
|
|
|
|
if (!lstrcmp(hlpfile->lpszPath, lpszPath))
|
|
|
|
{
|
|
|
|
hlpfile->wRefCount++;
|
|
|
|
return hlpfile;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
hlpfile = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE) + lstrlen(lpszPath) + 1);
|
|
|
|
if (!hlpfile) return 0;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
hlpfile->wRefCount = 1;
|
|
|
|
hlpfile->Context = NULL;
|
|
|
|
hlpfile->wContextLen = 0;
|
|
|
|
hlpfile->first_page = NULL;
|
|
|
|
hlpfile->first_macro = NULL;
|
|
|
|
hlpfile->prev = NULL;
|
|
|
|
hlpfile->next = first_hlpfile;
|
|
|
|
hlpfile->lpszPath = (char*)hlpfile + sizeof(HLPFILE);
|
|
|
|
hlpfile->lpszTitle = NULL;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
hlpfile->numFonts = 0;
|
|
|
|
hlpfile->fonts = NULL;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
strcpy(hlpfile->lpszPath, lpszPath);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
first_hlpfile = hlpfile;
|
|
|
|
if (hlpfile->next) hlpfile->next->prev = hlpfile;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
phrases.offsets = NULL;
|
|
|
|
phrases.buffer = NULL;
|
|
|
|
topic.map = NULL;
|
|
|
|
topic.end = NULL;
|
|
|
|
file_buffer = NULL;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!HLPFILE_DoReadHlpFile(hlpfile, lpszPath))
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
HLPFILE_FreeHlpFile(hlpfile);
|
|
|
|
hlpfile = 0;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (phrases.offsets) HeapFree(GetProcessHeap(), 0, phrases.offsets);
|
|
|
|
if (phrases.buffer) HeapFree(GetProcessHeap(), 0, phrases.buffer);
|
|
|
|
if (topic.map) HeapFree(GetProcessHeap(), 0, topic.map);
|
|
|
|
if (file_buffer) HeapFree(GetProcessHeap(), 0, file_buffer);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
return hlpfile;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_DoReadHlpFile
|
|
|
|
*/
|
|
|
|
static BOOL HLPFILE_DoReadHlpFile(HLPFILE *hlpfile, LPCSTR lpszPath)
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
BOOL ret;
|
|
|
|
HFILE hFile;
|
|
|
|
OFSTRUCT ofs;
|
|
|
|
BYTE* buf;
|
|
|
|
DWORD ref = 0x0C;
|
|
|
|
unsigned index, old_index, offset, len, offs;
|
|
|
|
|
|
|
|
hFile = OpenFile(lpszPath, &ofs, OF_READ | OF_SEARCH);
|
|
|
|
if (hFile == HFILE_ERROR) return FALSE;
|
|
|
|
|
|
|
|
ret = HLPFILE_ReadFileToBuffer(hFile);
|
|
|
|
_lclose(hFile);
|
|
|
|
if (!ret) return FALSE;
|
|
|
|
|
|
|
|
if (!HLPFILE_SystemCommands(hlpfile)) return FALSE;
|
|
|
|
if (!HLPFILE_UncompressLZ77_Phrases(hlpfile) &&
|
|
|
|
!HLPFILE_Uncompress_Phrases40(hlpfile))
|
|
|
|
return FALSE;
|
|
|
|
if (!HLPFILE_UncompressLZ77_Topic(hlpfile)) return FALSE;
|
|
|
|
if (!HLPFILE_ReadFont(hlpfile)) return FALSE;
|
|
|
|
|
|
|
|
buf = topic.map[0];
|
|
|
|
old_index = -1;
|
|
|
|
offs = 0;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
BYTE* end;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
/* FIXME this depends on the blocksize, can be 2k in some cases */
|
|
|
|
index = (ref - 0x0C) >> 14;
|
|
|
|
offset = (ref - 0x0C) & 0x3fff;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
WINE_TRACE("ref=%08lx => [%u/%u]\n", ref, index, offset);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (index >= topic.wMapLen) {WINE_WARN("maplen\n"); break;}
|
|
|
|
buf = topic.map[index] + offset;
|
|
|
|
if (buf + 0x15 >= topic.end) {WINE_WARN("extra\n"); break;}
|
|
|
|
end = min(buf + GET_UINT(buf, 0), topic.end);
|
|
|
|
if (index != old_index) {offs = 0; old_index = index;}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
switch (buf[0x14])
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
|
|
|
case 0x02:
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!HLPFILE_AddPage(hlpfile, buf, end, index * 0x8000L + offs)) return FALSE;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 0x20:
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!HLPFILE_AddParagraph(hlpfile, buf, end, &len)) return FALSE;
|
|
|
|
offs += len;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 0x23:
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!HLPFILE_AddParagraph(hlpfile, buf, end, &len)) return FALSE;
|
|
|
|
offs += len;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
default:
|
2002-07-16 03:46:29 +02:00
|
|
|
WINE_ERR("buf[0x14] = %x\n", buf[0x14]);
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
ref = GET_UINT(buf, 0xc);
|
|
|
|
} while (ref != 0xffffffff);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
return HLPFILE_GetContext(hlpfile);
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_AddPage
|
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
static BOOL HLPFILE_AddPage(HLPFILE *hlpfile, BYTE *buf, BYTE *end, unsigned offset)
|
|
|
|
{
|
|
|
|
HLPFILE_PAGE* page;
|
|
|
|
BYTE* title;
|
|
|
|
UINT titlesize;
|
|
|
|
|
|
|
|
if (buf + 0x31 > end) {WINE_WARN("page1\n"); return FALSE;};
|
|
|
|
title = buf + GET_UINT(buf, 0x10);
|
|
|
|
if (title > end) {WINE_WARN("page2\n"); return FALSE;};
|
|
|
|
|
|
|
|
if (GET_UINT(buf, 0x4) > GET_UINT(buf, 0) - GET_UINT(buf, 0x10))
|
|
|
|
{
|
|
|
|
if (hlpfile->hasPhrases)
|
|
|
|
{
|
|
|
|
titlesize = HLPFILE_Uncompressed2_Size(title, end);
|
|
|
|
page = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_PAGE) + titlesize);
|
|
|
|
if (!page) return FALSE;
|
|
|
|
|
|
|
|
page->lpszTitle = (char*)page + sizeof(HLPFILE_PAGE);
|
|
|
|
HLPFILE_Uncompress2(&title, end, page->lpszTitle);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
titlesize = GET_UINT(buf, 4) + 1;
|
|
|
|
page = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_PAGE) + titlesize);
|
|
|
|
if (!page) return FALSE;
|
|
|
|
page->lpszTitle = (char*)page + sizeof(HLPFILE_PAGE);
|
|
|
|
|
|
|
|
HLPFILE_Uncompress3(page->lpszTitle, page->lpszTitle + titlesize, title, end);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
titlesize = GET_UINT(buf, 0x4);
|
|
|
|
page = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_PAGE) + titlesize);
|
|
|
|
if (!page) return FALSE;
|
|
|
|
|
|
|
|
page->lpszTitle = (char*)page + sizeof(HLPFILE_PAGE);
|
|
|
|
memcpy(page->lpszTitle, title, titlesize);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hlpfile->first_page)
|
|
|
|
{
|
|
|
|
HLPFILE_PAGE *p;
|
|
|
|
|
|
|
|
for (p = hlpfile->first_page; p->next; p = p->next);
|
|
|
|
page->prev = p;
|
|
|
|
p->next = page;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
hlpfile->first_page = page;
|
|
|
|
page->prev = NULL;
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
page->file = hlpfile;
|
|
|
|
page->next = NULL;
|
|
|
|
page->first_paragraph = NULL;
|
|
|
|
page->wNumber = GET_UINT(buf, 0x21);
|
|
|
|
page->offset = offset;
|
|
|
|
|
|
|
|
WINE_TRACE("Added page[%d]: title='%s' offset=%08x\n",
|
|
|
|
page->wNumber, page->lpszTitle, page->offset);
|
|
|
|
|
|
|
|
memset(&attributes, 0, sizeof(attributes));
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static long fetch_long(BYTE** ptr)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
long ret;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (*(*ptr) & 1)
|
|
|
|
{
|
|
|
|
ret = (*(unsigned long*)(*ptr) - 0x80000000L) / 2;
|
|
|
|
(*ptr) += 4;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = (*(unsigned short*)(*ptr) - 0x8000) / 2;
|
|
|
|
(*ptr) += 2;
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
return ret;
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
static unsigned long fetch_ulong(BYTE** ptr)
|
|
|
|
{
|
|
|
|
unsigned long ret;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (*(*ptr) & 1)
|
|
|
|
{
|
|
|
|
ret = *(unsigned long*)(*ptr) / 2;
|
|
|
|
(*ptr) += 4;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = *(unsigned short*)(*ptr) / 2;
|
|
|
|
(*ptr) += 2;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
static short fetch_short(BYTE** ptr)
|
|
|
|
{
|
|
|
|
short ret;
|
|
|
|
|
|
|
|
if (*(*ptr) & 1)
|
|
|
|
{
|
|
|
|
ret = (*(unsigned short*)(*ptr) - 0x8000) / 2;
|
|
|
|
(*ptr) += 2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = (*(unsigned char*)(*ptr) - 0x80) / 2;
|
|
|
|
(*ptr)++;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
static unsigned short fetch_ushort(BYTE** ptr)
|
|
|
|
{
|
|
|
|
unsigned short ret;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (*(*ptr) & 1)
|
|
|
|
{
|
|
|
|
ret = *(unsigned short*)(*ptr) / 2;
|
|
|
|
(*ptr) += 2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ret = *(unsigned char*)(*ptr) / 2;
|
|
|
|
(*ptr)++;
|
|
|
|
}
|
|
|
|
return ret;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
/******************************************************************
|
|
|
|
* HLPFILE_LoadPictureByAddr
|
|
|
|
*
|
1996-05-06 18:06:24 +02:00
|
|
|
*
|
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
static BOOL HLPFILE_LoadPictureByAddr(HLPFILE *hlpfile, char* ref,
|
|
|
|
unsigned long size, unsigned pos)
|
|
|
|
{
|
|
|
|
unsigned i, numpict;
|
|
|
|
|
|
|
|
numpict = *(unsigned short*)(ref + 2);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
for (i = 0; i < numpict; i++)
|
|
|
|
{
|
|
|
|
BYTE *beg, *ptr;
|
|
|
|
BYTE *pict_beg;
|
|
|
|
BYTE type, pack;
|
|
|
|
BITMAPINFO* bi;
|
|
|
|
unsigned long off, sz;
|
|
|
|
unsigned shift;
|
|
|
|
|
|
|
|
ptr = beg = ref + *((unsigned long*)ref + 1 + i);
|
|
|
|
|
|
|
|
type = *ptr++;
|
|
|
|
pack = *ptr++;
|
|
|
|
|
|
|
|
bi = HeapAlloc(GetProcessHeap(), 0, sizeof(*bi));
|
|
|
|
if (!bi) return FALSE;
|
|
|
|
|
|
|
|
bi->bmiHeader.biSize = sizeof(bi->bmiHeader);
|
|
|
|
bi->bmiHeader.biXPelsPerMeter = fetch_ulong(&ptr);
|
|
|
|
bi->bmiHeader.biYPelsPerMeter = fetch_ulong(&ptr);
|
|
|
|
bi->bmiHeader.biPlanes = fetch_ushort(&ptr);
|
|
|
|
bi->bmiHeader.biBitCount = fetch_ushort(&ptr);
|
|
|
|
bi->bmiHeader.biWidth = fetch_ulong(&ptr);
|
|
|
|
bi->bmiHeader.biHeight = fetch_ulong(&ptr);
|
|
|
|
bi->bmiHeader.biClrUsed = fetch_ulong(&ptr);
|
|
|
|
bi->bmiHeader.biClrImportant = fetch_ulong(&ptr);
|
|
|
|
bi->bmiHeader.biCompression = BI_RGB;
|
|
|
|
if (bi->bmiHeader.biBitCount > 32) WINE_FIXME("Unknown bit count %u\n", bi->bmiHeader.biBitCount);
|
|
|
|
if (bi->bmiHeader.biPlanes != 1) WINE_FIXME("Unsupported planes %u\n", bi->bmiHeader.biPlanes);
|
|
|
|
shift = 32 / bi->bmiHeader.biBitCount;
|
|
|
|
bi->bmiHeader.biSizeImage = ((bi->bmiHeader.biWidth + shift - 1) / shift) * 4 * bi->bmiHeader.biHeight;
|
|
|
|
|
|
|
|
sz = fetch_ulong(&ptr);
|
|
|
|
fetch_ulong(&ptr); /* hotspot size */
|
|
|
|
|
|
|
|
off = *(unsigned long*)ptr; ptr += 4;
|
|
|
|
/* *(unsigned long*)ptr; hotspot offset */ ptr += 4;
|
|
|
|
|
|
|
|
/* now read palette info */
|
|
|
|
if (type == 0x06)
|
|
|
|
{
|
|
|
|
unsigned nc = bi->bmiHeader.biClrUsed;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
if (!nc) nc = 1 << bi->bmiHeader.biBitCount;
|
|
|
|
bi = HeapReAlloc(GetProcessHeap(), 0, bi, sizeof(*bi) + nc * sizeof(RGBQUAD));
|
|
|
|
if (!bi) return FALSE;
|
|
|
|
for (i = 0; i < nc; i++)
|
|
|
|
{
|
|
|
|
bi->bmiColors[i].rgbBlue = ptr[0];
|
|
|
|
bi->bmiColors[i].rgbGreen = ptr[1];
|
|
|
|
bi->bmiColors[i].rgbRed = ptr[2];
|
|
|
|
bi->bmiColors[i].rgbReserved = 0;
|
|
|
|
ptr += 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (pack)
|
|
|
|
{
|
|
|
|
case 0: /* uncompressed */
|
|
|
|
pict_beg = beg + off;
|
|
|
|
if (sz != bi->bmiHeader.biSizeImage)
|
|
|
|
WINE_WARN("Bogus image sizes: %lu / %lu [sz=(%lu,%lu) bc=%u pl=%u]\n",
|
|
|
|
sz, bi->bmiHeader.biSizeImage,
|
|
|
|
bi->bmiHeader.biWidth, bi->bmiHeader.biHeight,
|
|
|
|
bi->bmiHeader.biBitCount, bi->bmiHeader.biPlanes);
|
|
|
|
break;
|
|
|
|
case 1: /* RunLen */
|
|
|
|
{
|
|
|
|
BYTE* dst;
|
|
|
|
|
|
|
|
dst = pict_beg = HeapAlloc(GetProcessHeap(), 0, bi->bmiHeader.biSizeImage);
|
|
|
|
if (!pict_beg) return FALSE;
|
|
|
|
HLPFILE_UncompressRLE(beg + off, sz, &dst);
|
|
|
|
if (dst - pict_beg != bi->bmiHeader.biSizeImage)
|
|
|
|
WINE_FIXME("buffer XXX-flow\n");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 2: /* LZ77 */
|
|
|
|
{
|
|
|
|
unsigned long esz;
|
|
|
|
esz = HLPFILE_UncompressedLZ77_Size(beg + off, beg + off + sz);
|
|
|
|
pict_beg = HeapAlloc(GetProcessHeap(), 0, esz);
|
|
|
|
if (!pict_beg) return FALSE;
|
|
|
|
HLPFILE_UncompressLZ77(beg + off, beg + off + sz, pict_beg);
|
|
|
|
if (esz != bi->bmiHeader.biSizeImage)
|
|
|
|
WINE_WARN("Bogus image sizes: %lu / %lu [sz=(%lu,%lu) bc=%u pl=%u]\n",
|
|
|
|
esz, bi->bmiHeader.biSizeImage,
|
|
|
|
bi->bmiHeader.biWidth, bi->bmiHeader.biHeight,
|
|
|
|
bi->bmiHeader.biBitCount, bi->bmiHeader.biPlanes);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 3: /* LZ77 then RLE */
|
|
|
|
{
|
|
|
|
BYTE* tmp;
|
|
|
|
unsigned long sz77;
|
|
|
|
BYTE* dst;
|
|
|
|
|
|
|
|
sz77 = HLPFILE_UncompressedLZ77_Size(beg + off, beg + off + sz);
|
|
|
|
tmp = HeapAlloc(GetProcessHeap(), 0, bi->bmiHeader.biSizeImage);
|
|
|
|
if (!tmp) return FALSE;
|
|
|
|
HLPFILE_UncompressLZ77(beg + off, beg + off + sz, tmp);
|
|
|
|
pict_beg = dst = HeapAlloc(GetProcessHeap(), 0, bi->bmiHeader.biSizeImage);
|
|
|
|
if (!pict_beg) return FALSE;
|
|
|
|
HLPFILE_UncompressRLE(tmp, sz77, &dst);
|
|
|
|
if (dst - pict_beg != bi->bmiHeader.biSizeImage)
|
|
|
|
WINE_WARN("Bogus image sizes: %u / %lu [sz=(%lu,%lu) bc=%u pl=%u]\n",
|
|
|
|
dst - pict_beg, bi->bmiHeader.biSizeImage,
|
|
|
|
bi->bmiHeader.biWidth, bi->bmiHeader.biHeight,
|
|
|
|
bi->bmiHeader.biBitCount, bi->bmiHeader.biPlanes);
|
|
|
|
HeapFree(GetProcessHeap(), 0, tmp);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WINE_FIXME("Unsupported packing %u\n", pack);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
attributes.hBitmap = CreateDIBitmap(GetDC(0), &bi->bmiHeader, CBM_INIT,
|
|
|
|
pict_beg, bi, DIB_RGB_COLORS);
|
|
|
|
if (!attributes.hBitmap)
|
|
|
|
WINE_ERR("Couldn't create bitmap\n");
|
|
|
|
attributes.bmpPos = pos;
|
|
|
|
|
|
|
|
HeapFree(GetProcessHeap(), 0, bi);
|
|
|
|
if (pict_beg != beg + off) HeapFree(GetProcessHeap(), 0, pict_beg);
|
|
|
|
|
|
|
|
/* FIXME: implement support for multiple picture format */
|
|
|
|
if (numpict != 1) WINE_FIXME("Supporting only one bitmap format per logical bitmap (for now). Using first format\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************
|
|
|
|
* HLPFILE_LoadPictureByIndex
|
|
|
|
*
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static BOOL HLPFILE_LoadPictureByIndex(HLPFILE *hlpfile, unsigned index, unsigned pos)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
char tmp[16];
|
|
|
|
BYTE *ref, *end;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
WINE_TRACE("Loading picture #%d\n", index);
|
|
|
|
sprintf(tmp, "bm%u", index);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!HLPFILE_FindSubFile(tmp, &ref, &end)) {WINE_WARN("no sub file\n"); return FALSE;}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
ref += 9;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
return HLPFILE_LoadPictureByAddr(hlpfile, ref, end - ref, pos);
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_AddParagraph
|
|
|
|
*/
|
|
|
|
static BOOL HLPFILE_AddParagraph(HLPFILE *hlpfile, BYTE *buf, BYTE *end, unsigned* len)
|
|
|
|
{
|
|
|
|
HLPFILE_PAGE *page;
|
|
|
|
HLPFILE_PARAGRAPH *paragraph, **paragraphptr;
|
|
|
|
UINT textsize;
|
|
|
|
BYTE *format, *format_end, *text, *text_end;
|
|
|
|
long size;
|
|
|
|
unsigned short bits;
|
|
|
|
unsigned nc, ncol = 1;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!hlpfile->first_page) {WINE_WARN("no page\n"); return FALSE;};
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
for (page = hlpfile->first_page; page->next; page = page->next) /* Nothing */;
|
|
|
|
for (paragraphptr = &page->first_paragraph; *paragraphptr;
|
|
|
|
paragraphptr = &(*paragraphptr)->next) /* Nothing */;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (buf + 0x19 > end) {WINE_WARN("header too small\n"); return FALSE;};
|
|
|
|
|
|
|
|
size = GET_UINT(buf, 0x4);
|
|
|
|
|
|
|
|
if (GET_UINT(buf, 0x4) > GET_UINT(buf, 0) - GET_UINT(buf, 0x10))
|
|
|
|
{
|
|
|
|
if (hlpfile->hasPhrases)
|
|
|
|
{
|
|
|
|
BYTE* lptr = buf + GET_UINT(buf, 0x10);
|
|
|
|
unsigned size2;
|
|
|
|
|
|
|
|
size2 = HLPFILE_Uncompressed2_Size(lptr, end);
|
|
|
|
if (size2 != size + 1)
|
|
|
|
WINE_FIXME("Mismatch in sizes: decomp2=%u header=%lu\n", size2, size);
|
|
|
|
text = HeapAlloc(GetProcessHeap(), 0, size + 1);
|
|
|
|
if (!text) return FALSE;
|
|
|
|
HLPFILE_Uncompress2(&lptr, end, text);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* block is compressed */
|
|
|
|
text = HeapAlloc(GetProcessHeap(), 0, size);
|
|
|
|
if (!text) return FALSE;
|
|
|
|
HLPFILE_Uncompress3(text, text + size, buf + GET_UINT(buf, 0x10), end);
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
text = buf + GET_UINT(buf, 0x10);
|
|
|
|
}
|
|
|
|
text_end = text + size;
|
|
|
|
|
|
|
|
format = buf + 0x15;
|
|
|
|
format_end = buf + GET_UINT(buf, 0x10);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
fetch_long(&format);
|
|
|
|
*len = fetch_ushort(&format);
|
|
|
|
if (buf[0x14] == 0x23)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
char type;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
ncol = *format++;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
WINE_TRACE("#cols %u\n", ncol);
|
|
|
|
type = *format++;
|
|
|
|
if (type == 0 || type == 2)
|
|
|
|
format += 2;
|
|
|
|
format += ncol * 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (nc = 0; nc < ncol; nc++)
|
|
|
|
{
|
|
|
|
WINE_TRACE("looking for format at offset %u for column %d\n", format - (buf + 0x15), nc);
|
|
|
|
if (buf[0x14] == 0x23)
|
|
|
|
format += 5;
|
|
|
|
format += 4;
|
|
|
|
bits = *(unsigned short*)format; format += 2;
|
|
|
|
if (bits & 0x0001) fetch_long(&format);
|
|
|
|
if (bits & 0x0002) fetch_short(&format);
|
|
|
|
if (bits & 0x0004) fetch_short(&format);
|
|
|
|
if (bits & 0x0008) fetch_short(&format);
|
|
|
|
if (bits & 0x0010) fetch_short(&format);
|
|
|
|
if (bits & 0x0020) fetch_short(&format);
|
|
|
|
if (bits & 0x0040) fetch_short(&format);
|
|
|
|
if (bits & 0x0100) format += 3;
|
|
|
|
if (bits & 0x0200)
|
|
|
|
{
|
|
|
|
int ntab = fetch_short(&format);
|
|
|
|
unsigned short ts;
|
|
|
|
|
|
|
|
while (ntab-- > 0)
|
|
|
|
{
|
|
|
|
ts = fetch_ushort(&format);
|
|
|
|
if (ts & 0x4000) fetch_ushort(&format);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (text < text_end && format < format_end)
|
|
|
|
{
|
|
|
|
WINE_TRACE("Got text: '%s' (%p/%p - %p/%p)\n", text, text, text_end, format, format_end);
|
|
|
|
textsize = strlen(text) + 1;
|
|
|
|
if (textsize > 1 || attributes.hBitmap)
|
|
|
|
{
|
|
|
|
paragraph = HeapAlloc(GetProcessHeap(), 0,
|
|
|
|
sizeof(HLPFILE_PARAGRAPH) + textsize);
|
|
|
|
if (!paragraph) return FALSE;
|
|
|
|
*paragraphptr = paragraph;
|
|
|
|
paragraphptr = ¶graph->next;
|
|
|
|
|
|
|
|
paragraph->next = NULL;
|
|
|
|
paragraph->link = NULL;
|
|
|
|
|
|
|
|
if (attributes.hBitmap)
|
|
|
|
{
|
|
|
|
paragraph->cookie = para_image;
|
|
|
|
paragraph->u.image.hBitmap = attributes.hBitmap;
|
|
|
|
paragraph->u.image.pos = attributes.bmpPos;
|
|
|
|
if (attributes.wVSpace) paragraph->u.image.pos |= 0x8000;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
paragraph->cookie = (attributes.bDebug) ? para_debug_text : para_normal_text;
|
|
|
|
paragraph->u.text.wFont = attributes.wFont;
|
|
|
|
paragraph->u.text.wVSpace = attributes.wVSpace;
|
|
|
|
paragraph->u.text.wHSpace = attributes.wHSpace;
|
|
|
|
paragraph->u.text.wIndent = attributes.wIndent;
|
|
|
|
paragraph->u.text.lpszText = (char*)paragraph + sizeof(HLPFILE_PARAGRAPH);
|
|
|
|
strcpy(paragraph->u.text.lpszText, text);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (attributes.link.lpszPath)
|
|
|
|
{
|
|
|
|
/* FIXME: should build a string table for the attributes.link.lpszPath
|
|
|
|
* they are reallocated for each link
|
|
|
|
*/
|
|
|
|
paragraph->link = HeapAlloc(GetProcessHeap(), 0,
|
|
|
|
sizeof(HLPFILE_LINK) + strlen(attributes.link.lpszPath) + 1);
|
|
|
|
if (!paragraph->link) return FALSE;
|
|
|
|
|
|
|
|
paragraph->link->lpszPath = (char*)paragraph->link + sizeof(HLPFILE_LINK);
|
|
|
|
strcpy((char*)paragraph->link->lpszPath, attributes.link.lpszPath);
|
|
|
|
paragraph->link->lHash = attributes.link.lHash;
|
|
|
|
|
|
|
|
paragraph->link->bPopup = attributes.link.bPopup;
|
|
|
|
WINE_TRACE("Link to %s/%08lx\n",
|
|
|
|
paragraph->link->lpszPath, paragraph->link->lHash);
|
|
|
|
}
|
|
|
|
#if 0
|
|
|
|
memset(&attributes, 0, sizeof(attributes));
|
|
|
|
#else
|
|
|
|
attributes.hBitmap = 0;
|
|
|
|
attributes.link.lpszPath = NULL;
|
|
|
|
attributes.wVSpace = 0;
|
|
|
|
attributes.wHSpace = 0;
|
|
|
|
attributes.wIndent = 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
/* else: null text, keep on storing attributes */
|
|
|
|
text += textsize;
|
|
|
|
|
|
|
|
if (*format == 0xff)
|
|
|
|
{
|
|
|
|
format++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
WINE_TRACE("format=%02x\n", *format);
|
|
|
|
switch (*format)
|
|
|
|
{
|
|
|
|
case 0x20:
|
|
|
|
WINE_FIXME("NIY\n");
|
|
|
|
format += 5;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0x21:
|
|
|
|
WINE_FIXME("NIY\n");
|
|
|
|
format += 3;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 0x80:
|
2002-07-16 03:46:29 +02:00
|
|
|
attributes.wFont = GET_USHORT(format, 1);
|
|
|
|
WINE_TRACE("Changing font to %d\n", attributes.wFont);
|
|
|
|
format += 3;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 0x81:
|
2002-07-16 03:46:29 +02:00
|
|
|
attributes.wVSpace++;
|
|
|
|
format += 1;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 0x82:
|
2002-07-16 03:46:29 +02:00
|
|
|
attributes.wVSpace += 2 - attributes.wVBackSpace;
|
|
|
|
attributes.wVBackSpace = 0;
|
|
|
|
attributes.wIndent = 0;
|
|
|
|
format += 1;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 0x83:
|
2002-07-16 03:46:29 +02:00
|
|
|
attributes.wIndent++;
|
|
|
|
format += 1;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
#if 0
|
1996-05-06 18:06:24 +02:00
|
|
|
case 0x84:
|
2002-07-16 03:46:29 +02:00
|
|
|
format += 3;
|
|
|
|
break;
|
|
|
|
#endif
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 0x86:
|
|
|
|
case 0x87:
|
|
|
|
case 0x88:
|
2002-07-16 03:46:29 +02:00
|
|
|
{
|
|
|
|
BYTE pos = (*format - 0x86);
|
|
|
|
BYTE type = format[1];
|
|
|
|
long size;
|
|
|
|
|
|
|
|
format += 2;
|
|
|
|
size = fetch_long(&format);
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case 0x22:
|
|
|
|
fetch_ushort(&format); /* hot spot */
|
|
|
|
/* fall thru */
|
|
|
|
case 0x03:
|
|
|
|
if (*(short*)format == 0)
|
|
|
|
HLPFILE_LoadPictureByIndex(hlpfile,
|
|
|
|
*(short*)(format + 2),
|
|
|
|
pos);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
WINE_FIXME("does it work ???\n");
|
|
|
|
HLPFILE_LoadPictureByAddr(hlpfile, format + 2,
|
|
|
|
size - 4, pos);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 0x05:
|
|
|
|
WINE_FIXME("Got an embedded element %s\n", format + 6);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WINE_FIXME("Got a type %d picture\n", type);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
format += size;
|
|
|
|
}
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 0x89:
|
2002-07-16 03:46:29 +02:00
|
|
|
attributes.wVBackSpace++;
|
|
|
|
format += 1;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
case 0x8B:
|
|
|
|
case 0x8C:
|
|
|
|
WINE_FIXME("NIY\n");
|
|
|
|
format += 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
#if 0
|
1996-05-06 18:06:24 +02:00
|
|
|
case 0xa9:
|
2002-07-16 03:46:29 +02:00
|
|
|
format += 2;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
case 0xc8:
|
|
|
|
case 0xcc:
|
|
|
|
WINE_FIXME("macro NIY %s\n", format + 3);
|
|
|
|
format += GET_USHORT(format, 1) + 3;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xe0:
|
|
|
|
case 0xe1:
|
|
|
|
WINE_WARN("jump topic 1 => %u\n", GET_UINT(format, 1));
|
|
|
|
format += 5;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 0xe2:
|
|
|
|
case 0xe3:
|
2002-07-16 03:46:29 +02:00
|
|
|
attributes.link.lpszPath = hlpfile->lpszPath;
|
|
|
|
attributes.link.lHash = GET_UINT(format, 1);
|
|
|
|
attributes.link.bPopup = !(*format & 1);
|
|
|
|
format += 5;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xe6:
|
|
|
|
case 0xe7:
|
|
|
|
WINE_WARN("jump topic 2 => %u\n", GET_UINT(format, 1));
|
|
|
|
format += 5;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 0xea:
|
2002-07-16 03:46:29 +02:00
|
|
|
attributes.link.lpszPath = format + 8;
|
|
|
|
attributes.link.lHash = GET_UINT(format, 4);
|
|
|
|
attributes.link.bPopup = !(*format & 1);
|
|
|
|
format += 3 + GET_USHORT(format, 1);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xee:
|
|
|
|
case 0xef:
|
|
|
|
case 0xeb:
|
|
|
|
WINE_WARN("jump to external file\n");
|
|
|
|
format += 3 + GET_USHORT(format, 1);
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
default:
|
2002-07-16 03:46:29 +02:00
|
|
|
WINE_WARN("format %02x\n", *format);
|
|
|
|
format++;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
}
|
|
|
|
if (text_end != buf + GET_UINT(buf, 0x10) + size)
|
|
|
|
HeapFree(GetProcessHeap(), 0, text_end - size);
|
|
|
|
return TRUE;
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
/******************************************************************
|
|
|
|
* HLPFILE_ReadFont
|
|
|
|
*
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static BOOL HLPFILE_ReadFont(HLPFILE* hlpfile)
|
|
|
|
{
|
|
|
|
BYTE *ref, *end;
|
|
|
|
unsigned i, len, idx;
|
|
|
|
unsigned face_num, dscr_num, face_offset, dscr_offset;
|
|
|
|
BYTE flag, family;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!HLPFILE_FindSubFile("FONT", &ref, &end))
|
|
|
|
{
|
|
|
|
WINE_WARN("no subfile FONT\n");
|
|
|
|
hlpfile->numFonts = 0;
|
|
|
|
hlpfile->fonts = NULL;
|
|
|
|
return FALSE;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
ref += 9;
|
|
|
|
|
|
|
|
face_num = GET_USHORT(ref, 0);
|
|
|
|
dscr_num = GET_USHORT(ref, 2);
|
|
|
|
face_offset = GET_USHORT(ref, 4);
|
|
|
|
dscr_offset = GET_USHORT(ref, 6);
|
|
|
|
|
|
|
|
WINE_TRACE("Got NumFacenames=%u@%u NumDesc=%u@%u\n",
|
|
|
|
face_num, face_offset, dscr_num, dscr_offset);
|
|
|
|
|
|
|
|
hlpfile->numFonts = dscr_num;
|
|
|
|
hlpfile->fonts = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_FONT) * dscr_num);
|
|
|
|
|
|
|
|
len = (dscr_offset - face_offset) / face_num;
|
|
|
|
/* EPP for (i = face_offset; i < dscr_offset; i += len) */
|
|
|
|
/* EPP WINE_FIXME("[%d]: %*s\n", i / len, len, ref + i); */
|
|
|
|
for (i = 0; i < dscr_num; i++)
|
|
|
|
{
|
|
|
|
flag = ref[dscr_offset + i * 11 + 0];
|
|
|
|
family = ref[dscr_offset + i * 11 + 2];
|
|
|
|
|
|
|
|
hlpfile->fonts[i].LogFont.lfHeight = -ref[dscr_offset + i * 11 + 1] / 2;
|
|
|
|
hlpfile->fonts[i].LogFont.lfWidth = 0;
|
|
|
|
hlpfile->fonts[i].LogFont.lfEscapement = 0;
|
|
|
|
hlpfile->fonts[i].LogFont.lfOrientation = 0;
|
|
|
|
hlpfile->fonts[i].LogFont.lfWeight = (flag & 1) ? 700 : 400;
|
|
|
|
hlpfile->fonts[i].LogFont.lfItalic = (flag & 2) ? TRUE : FALSE;
|
|
|
|
hlpfile->fonts[i].LogFont.lfUnderline = (flag & 4) ? TRUE : FALSE;
|
|
|
|
hlpfile->fonts[i].LogFont.lfStrikeOut = (flag & 8) ? TRUE : FALSE;
|
|
|
|
hlpfile->fonts[i].LogFont.lfCharSet = ANSI_CHARSET;
|
|
|
|
hlpfile->fonts[i].LogFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
|
|
|
|
hlpfile->fonts[i].LogFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
|
|
|
|
hlpfile->fonts[i].LogFont.lfQuality = DEFAULT_QUALITY;
|
|
|
|
hlpfile->fonts[i].LogFont.lfPitchAndFamily = DEFAULT_PITCH;
|
|
|
|
|
|
|
|
switch (family)
|
|
|
|
{
|
|
|
|
case 0x01: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_MODERN; break;
|
|
|
|
case 0x02: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_ROMAN; break;
|
|
|
|
case 0x03: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_SWISS; break;
|
|
|
|
case 0x04: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_SCRIPT; break;
|
|
|
|
case 0x05: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_DECORATIVE; break;
|
|
|
|
default: WINE_FIXME("Unknown family %u\n", family);
|
|
|
|
}
|
|
|
|
idx = *(unsigned short*)(ref + dscr_offset + i * 11 + 3);
|
|
|
|
|
|
|
|
if (idx < face_num)
|
|
|
|
{
|
|
|
|
strncpy(hlpfile->fonts[i].LogFont.lfFaceName, ref + face_offset + idx * len, min(len, LF_FACESIZE - 1));
|
|
|
|
hlpfile->fonts[i].LogFont.lfFaceName[min(len, LF_FACESIZE - 1) + 1] = '\0';
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
WINE_FIXME("Too high face ref (%u/%u)\n", idx, face_num);
|
|
|
|
strcpy(hlpfile->fonts[i].LogFont.lfFaceName, "Helv");
|
|
|
|
}
|
|
|
|
hlpfile->fonts[i].hFont = (HANDLE)0;
|
|
|
|
hlpfile->fonts[i].color = RGB(ref[dscr_offset + i * 11 + 5],
|
|
|
|
ref[dscr_offset + i * 11 + 6],
|
|
|
|
ref[dscr_offset + i * 11 + 7]);
|
|
|
|
#define X(b,s) ((flag & (1 << b)) ? "-"s: "")
|
|
|
|
WINE_TRACE("Font[%d]: flags=%02x%s%s%s%s%s%s pSize=%u family=%u face=%s[%u] color=%08lx\n",
|
|
|
|
i, flag,
|
|
|
|
X(0, "bold"),
|
|
|
|
X(1, "italic"),
|
|
|
|
X(2, "underline"),
|
|
|
|
X(3, "strikeOut"),
|
|
|
|
X(4, "dblUnderline"),
|
|
|
|
X(5, "smallCaps"),
|
|
|
|
ref[dscr_offset + i * 11 + 1],
|
|
|
|
family,
|
|
|
|
hlpfile->fonts[i].LogFont.lfFaceName, idx,
|
|
|
|
*(unsigned long*)(ref + dscr_offset + i * 11 + 5) & 0x00FFFFFF);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
--- only if FacenamesOffset >= 12
|
|
|
|
unsigned short NumStyles number of style descriptors
|
|
|
|
unsigned short StyleOffset start of array of style descriptors
|
|
|
|
relative to &NumFacenames
|
|
|
|
--- only if FacenamesOffset >= 16
|
|
|
|
unsigned short NumCharMapTables number of character mapping tables
|
|
|
|
unsigned short CharMapTableOffset start of array of character mapping
|
|
|
|
table names relative to &NumFacenames
|
|
|
|
*/
|
|
|
|
return TRUE;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_ReadFileToBuffer
|
|
|
|
*/
|
|
|
|
static BOOL HLPFILE_ReadFileToBuffer(HFILE hFile)
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
BYTE header[16], dummy[1];
|
|
|
|
UINT size;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (_hread(hFile, header, 16) != 16) {WINE_WARN("header\n"); return FALSE;};
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
size = GET_UINT(header, 12);
|
|
|
|
file_buffer = HeapAlloc(GetProcessHeap(), 0, size + 1);
|
|
|
|
if (!file_buffer) return FALSE;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
memcpy(file_buffer, header, 16);
|
|
|
|
if (_hread(hFile, file_buffer + 16, size - 16) != size - 16)
|
|
|
|
{WINE_WARN("filesize1\n"); return FALSE;};
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (_hread(hFile, dummy, 1) != 0) WINE_WARN("filesize2\n");
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
file_buffer[size] = '\0'; /* FIXME: was '0', sounds ackward to me */
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
return TRUE;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_FindSubFile
|
|
|
|
*/
|
|
|
|
static BOOL HLPFILE_FindSubFile(LPCSTR name, BYTE **subbuf, BYTE **subend)
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
BYTE *root = file_buffer + GET_UINT(file_buffer, 4);
|
|
|
|
BYTE *end = file_buffer + GET_UINT(file_buffer, 12);
|
|
|
|
BYTE *ptr = root + 0x37;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
while (ptr < end && ptr[0] == 0x7c)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
BYTE *fname = ptr + 1;
|
|
|
|
ptr += strlen(ptr) + 1;
|
|
|
|
if (!lstrcmpi(fname, name))
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
*subbuf = file_buffer + GET_UINT(ptr, 0);
|
|
|
|
*subend = *subbuf + GET_UINT(*subbuf, 0);
|
|
|
|
if (file_buffer > *subbuf || *subbuf > *subend || *subend > end)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
WINE_WARN("size mismatch\n");
|
|
|
|
return FALSE;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
return TRUE;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
else ptr += 4;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
return FALSE;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_SystemCommands
|
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
static BOOL HLPFILE_SystemCommands(HLPFILE* hlpfile)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
BYTE *buf, *ptr, *end;
|
|
|
|
HLPFILE_MACRO *macro, **m;
|
|
|
|
LPSTR p;
|
|
|
|
unsigned short magic, minor, major, flags;
|
|
|
|
|
|
|
|
hlpfile->lpszTitle = NULL;
|
|
|
|
|
|
|
|
if (!HLPFILE_FindSubFile("SYSTEM", &buf, &end)) return FALSE;
|
|
|
|
|
|
|
|
magic = GET_USHORT(buf + 9, 0);
|
|
|
|
minor = GET_USHORT(buf + 9, 2);
|
|
|
|
major = GET_USHORT(buf + 9, 4);
|
|
|
|
/* gen date on 4 bytes */
|
|
|
|
flags = GET_USHORT(buf + 9, 10);
|
|
|
|
WINE_TRACE("Got system header: magic=%04x version=%d.%d flags=%04x\n",
|
|
|
|
magic, major, minor, flags);
|
|
|
|
if (magic != 0x036C || major != 1)
|
|
|
|
{WINE_WARN("Wrong system header\n"); return FALSE;}
|
|
|
|
if (minor <= 16) {WINE_WARN("too old file format (NIY)\n"); return FALSE;}
|
|
|
|
|
|
|
|
hlpfile->version = minor;
|
|
|
|
hlpfile->flags = flags;
|
|
|
|
|
|
|
|
for (ptr = buf + 0x15; ptr + 4 <= end; ptr += GET_USHORT(ptr, 2) + 4)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
switch (GET_USHORT(ptr, 0))
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
|
|
|
case 1:
|
2002-07-16 03:46:29 +02:00
|
|
|
if (hlpfile->lpszTitle) {WINE_WARN("title\n"); break;}
|
|
|
|
hlpfile->lpszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(ptr + 4) + 1);
|
|
|
|
if (!hlpfile->lpszTitle) return FALSE;
|
|
|
|
lstrcpy(hlpfile->lpszTitle, ptr + 4);
|
|
|
|
WINE_TRACE("Title: %s\n", hlpfile->lpszTitle);
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 2:
|
2002-07-16 03:46:29 +02:00
|
|
|
if (GET_USHORT(ptr, 2) != 1 || ptr[4] != 0) WINE_WARN("system2\n");
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 3:
|
2002-07-16 03:46:29 +02:00
|
|
|
if (GET_USHORT(ptr, 2) != 4 || GET_UINT(ptr, 4) != 0)
|
|
|
|
WINE_WARN("system3\n");
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
case 4:
|
2002-07-16 03:46:29 +02:00
|
|
|
macro = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_MACRO) + lstrlen(ptr + 4) + 1);
|
|
|
|
if (!macro) break;
|
|
|
|
p = (char*)macro + sizeof(HLPFILE_MACRO);
|
|
|
|
lstrcpy(p, (LPSTR)ptr + 4);
|
|
|
|
macro->lpszMacro = p;
|
|
|
|
macro->next = 0;
|
|
|
|
for (m = &hlpfile->first_macro; *m; m = &(*m)->next);
|
|
|
|
*m = macro;
|
|
|
|
break;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
|
|
|
default:
|
2002-07-16 03:46:29 +02:00
|
|
|
WINE_WARN("Unsupport SystemRecord[%d]\n", GET_USHORT(ptr, 0));
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
return TRUE;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
2002-07-16 03:46:29 +02:00
|
|
|
* HLPFILE_UncompressedLZ77_Size
|
1996-05-06 18:06:24 +02:00
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
static INT HLPFILE_UncompressedLZ77_Size(BYTE *ptr, BYTE *end)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
int i, newsize = 0;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
while (ptr < end)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
int mask = *ptr++;
|
|
|
|
for (i = 0; i < 8 && ptr < end; i++, mask >>= 1)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
if (mask & 1)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
int code = GET_USHORT(ptr, 0);
|
|
|
|
int len = 3 + (code >> 12);
|
|
|
|
newsize += len;
|
|
|
|
ptr += 2;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
else newsize++, ptr++;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
return newsize;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
2002-07-16 03:46:29 +02:00
|
|
|
* HLPFILE_UncompressLZ77
|
1996-05-06 18:06:24 +02:00
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
static BYTE *HLPFILE_UncompressLZ77(BYTE *ptr, BYTE *end, BYTE *newptr)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
int i;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
while (ptr < end)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
int mask = *ptr++;
|
|
|
|
for (i = 0; i < 8 && ptr < end; i++, mask >>= 1)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
if (mask & 1)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
int code = GET_USHORT(ptr, 0);
|
|
|
|
int len = 3 + (code >> 12);
|
|
|
|
int offset = code & 0xfff;
|
|
|
|
memcpy(newptr, newptr - offset - 1, len);
|
|
|
|
newptr += len;
|
|
|
|
ptr += 2;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
else *newptr++ = *ptr++;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
return newptr;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
2002-07-16 03:46:29 +02:00
|
|
|
* HLPFILE_UncompressLZ77_Phrases
|
1996-05-06 18:06:24 +02:00
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
static BOOL HLPFILE_UncompressLZ77_Phrases(HLPFILE* hlpfile)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
UINT i, num, dec_size;
|
|
|
|
BYTE *buf, *end;
|
|
|
|
|
|
|
|
if (!HLPFILE_FindSubFile("Phrases", &buf, &end)) return FALSE;
|
|
|
|
|
|
|
|
num = phrases.num = GET_USHORT(buf, 9);
|
|
|
|
if (buf + 2 * num + 0x13 >= end) {WINE_WARN("1a\n"); return FALSE;};
|
|
|
|
|
|
|
|
dec_size = HLPFILE_UncompressedLZ77_Size(buf + 0x13 + 2 * num, end);
|
|
|
|
|
|
|
|
phrases.offsets = HeapAlloc(GetProcessHeap(), 0, sizeof(unsigned) * (num + 1));
|
|
|
|
phrases.buffer = HeapAlloc(GetProcessHeap(), 0, dec_size);
|
|
|
|
if (!phrases.offsets || !phrases.buffer) return FALSE;
|
|
|
|
|
|
|
|
for (i = 0; i <= num; i++)
|
|
|
|
phrases.offsets[i] = GET_USHORT(buf, 0x11 + 2 * i) - 2 * num - 2;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
HLPFILE_UncompressLZ77(buf + 0x13 + 2 * num, end, phrases.buffer);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
hlpfile->hasPhrases = TRUE;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_Uncompress_Phrases40
|
|
|
|
*/
|
|
|
|
static BOOL HLPFILE_Uncompress_Phrases40(HLPFILE* hlpfile)
|
|
|
|
{
|
|
|
|
UINT num, dec_size;
|
|
|
|
BYTE *buf_idx, *end_idx;
|
|
|
|
BYTE *buf_phs, *end_phs;
|
|
|
|
short i, n;
|
|
|
|
long* ptr, mask = 0;
|
|
|
|
unsigned short bc;
|
|
|
|
|
|
|
|
if (!HLPFILE_FindSubFile("PhrIndex", &buf_idx, &end_idx) ||
|
|
|
|
!HLPFILE_FindSubFile("PhrImage", &buf_phs, &end_phs)) return FALSE;
|
|
|
|
|
|
|
|
ptr = (long*)(buf_idx + 9 + 28);
|
|
|
|
bc = GET_USHORT(buf_idx, 9 + 24) & 0x0F;
|
|
|
|
num = phrases.num = GET_USHORT(buf_idx, 9 + 4);
|
|
|
|
|
|
|
|
WINE_TRACE("Index: Magic=%08x #entries=%u CpsdSize=%u PhrImgSize=%u\n"
|
|
|
|
"\tPhrImgCprsdSize=%u 0=%u bc=%x ukn=%x\n",
|
|
|
|
GET_UINT(buf_idx, 9 + 0),
|
|
|
|
GET_UINT(buf_idx, 9 + 4),
|
|
|
|
GET_UINT(buf_idx, 9 + 8),
|
|
|
|
GET_UINT(buf_idx, 9 + 12),
|
|
|
|
GET_UINT(buf_idx, 9 + 16),
|
|
|
|
GET_UINT(buf_idx, 9 + 20),
|
|
|
|
GET_USHORT(buf_idx, 9 + 24),
|
|
|
|
GET_USHORT(buf_idx, 9 + 26));
|
|
|
|
|
|
|
|
dec_size = GET_UINT(buf_idx, 9 + 12);
|
|
|
|
if (dec_size != HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs))
|
|
|
|
{
|
|
|
|
WINE_WARN("size mismatch %u %u\n",
|
|
|
|
dec_size, HLPFILE_UncompressedLZ77_Size(buf_phs, end_phs));
|
|
|
|
dec_size = max(dec_size, HLPFILE_UncompressedLZ77_Size(buf_phs, end_phs));
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
phrases.offsets = HeapAlloc(GetProcessHeap(), 0, sizeof(unsigned) * (num + 1));
|
|
|
|
phrases.buffer = HeapAlloc(GetProcessHeap(), 0, dec_size);
|
|
|
|
if (!phrases.offsets || !phrases.buffer) return FALSE;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
#define getbit() (ptr += (mask < 0), mask = mask*2 + (mask<=0), (*ptr & mask) != 0)
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
phrases.offsets[0] = 0;
|
|
|
|
for (i = 0; i < num; i++)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
for (n = 1; getbit(); n += 1 << bc);
|
|
|
|
if (getbit()) n++;
|
|
|
|
if (bc > 1 && getbit()) n += 2;
|
|
|
|
if (bc > 2 && getbit()) n += 4;
|
|
|
|
if (bc > 3 && getbit()) n += 8;
|
|
|
|
if (bc > 4 && getbit()) n += 16;
|
|
|
|
phrases.offsets[i + 1] = phrases.offsets[i] + n;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
#undef getbit
|
|
|
|
|
|
|
|
HLPFILE_UncompressLZ77(buf_phs + 9, end_phs, phrases.buffer);
|
|
|
|
|
|
|
|
hlpfile->hasPhrases = FALSE;
|
|
|
|
return TRUE;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
2002-07-16 03:46:29 +02:00
|
|
|
* HLPFILE_UncompressLZ77_Topic
|
1996-05-06 18:06:24 +02:00
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
static BOOL HLPFILE_UncompressLZ77_Topic(HLPFILE* hlpfile)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
BYTE *buf, *ptr, *end, *newptr;
|
|
|
|
int i, newsize = 0;
|
|
|
|
|
|
|
|
if (!HLPFILE_FindSubFile("TOPIC", &buf, &end))
|
|
|
|
{WINE_WARN("topic0\n"); return FALSE;}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!(hlpfile->flags & 4)) WINE_FIXME("Unsupported format\n");
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
buf += 9;
|
|
|
|
topic.wMapLen = (end - buf - 1) / 0x1000 + 1;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
for (i = 0; i < topic.wMapLen; i++)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
ptr = buf + i * 0x1000;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
/* I don't know why, it's necessary for printman.hlp */
|
|
|
|
if (ptr + 0x44 > end) ptr = end - 0x44;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
newsize += HLPFILE_UncompressedLZ77_Size(ptr + 0xc, min(end, ptr + 0x1000));
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
topic.map = HeapAlloc(GetProcessHeap(), 0,
|
|
|
|
topic.wMapLen * sizeof(topic.map[0]) + newsize);
|
|
|
|
if (!topic.map) return FALSE;
|
|
|
|
newptr = (char*)topic.map + topic.wMapLen * sizeof(topic.map[0]);
|
|
|
|
topic.end = newptr + newsize;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
for (i = 0; i < topic.wMapLen; i++)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
ptr = buf + i * 0x1000;
|
|
|
|
if (ptr + 0x44 > end) ptr = end - 0x44;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
topic.map[i] = newptr;
|
|
|
|
newptr = HLPFILE_UncompressLZ77(ptr + 0xc, min(end, ptr + 0x1000), newptr);
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
return TRUE;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_Uncompressed2_Size
|
|
|
|
*/
|
|
|
|
static UINT HLPFILE_Uncompressed2_Size(BYTE *ptr, BYTE *end)
|
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
UINT wSize = 0;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
while (ptr < end)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!*ptr || *ptr >= 0x10)
|
|
|
|
wSize++, ptr++;
|
|
|
|
else
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
BYTE *phptr, *phend;
|
|
|
|
UINT code = 0x100 * ptr[0] + ptr[1];
|
|
|
|
UINT index = (code - 0x100) / 2;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (index < phrases.num)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
phptr = phrases.buffer + phrases.offsets[index];
|
|
|
|
phend = phrases.buffer + phrases.offsets[index + 1];
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (phend < phptr) WINE_WARN("uncompress2a\n");
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
wSize += phend - phptr;
|
|
|
|
if (code & 1) wSize++;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
else WINE_WARN("uncompress2b %d|%d\n", index, phrases.num);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
ptr += 2;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
return wSize + 1;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_Uncompress2
|
|
|
|
*/
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
static void HLPFILE_Uncompress2(BYTE **pptr, BYTE *end, BYTE *newptr)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
BYTE *ptr = *pptr;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
while (ptr < end)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!*ptr || *ptr >= 0x10)
|
|
|
|
*newptr++ = *ptr++;
|
|
|
|
else
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
BYTE *phptr, *phend;
|
|
|
|
UINT code = 0x100 * ptr[0] + ptr[1];
|
|
|
|
UINT index = (code - 0x100) / 2;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
phptr = phrases.buffer + phrases.offsets[index];
|
|
|
|
phend = phrases.buffer + phrases.offsets[index + 1];
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
memcpy(newptr, phptr, phend - phptr);
|
|
|
|
newptr += phend - phptr;
|
|
|
|
if (code & 1) *newptr++ = ' ';
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
ptr += 2;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
*newptr = '\0';
|
|
|
|
*pptr = ptr;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
/******************************************************************
|
|
|
|
* HLPFILE_Uncompress3
|
|
|
|
*
|
1996-05-06 18:06:24 +02:00
|
|
|
*
|
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
static BOOL HLPFILE_Uncompress3(char* dst, const char* dst_end,
|
|
|
|
const BYTE* src, const BYTE* src_end)
|
|
|
|
{
|
|
|
|
int idx, len;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
for (; src < src_end; src++)
|
|
|
|
{
|
|
|
|
if ((*src & 1) == 0)
|
|
|
|
{
|
|
|
|
idx = *src / 2;
|
|
|
|
if (idx > phrases.num) WINE_ERR("index in phrases\n");
|
|
|
|
len = phrases.offsets[idx + 1] - phrases.offsets[idx];
|
|
|
|
memcpy(dst, &phrases.buffer[phrases.offsets[idx]], len);
|
|
|
|
}
|
|
|
|
else if ((*src & 0x03) == 0x01)
|
|
|
|
{
|
|
|
|
idx = (*src + 1) * 64 + *++src;
|
|
|
|
if (idx > phrases.num) WINE_ERR("index in phrases\n");
|
|
|
|
len = phrases.offsets[idx + 1] - phrases.offsets[idx];
|
|
|
|
memcpy(dst, &phrases.buffer[phrases.offsets[idx]], len);
|
|
|
|
}
|
|
|
|
else if ((*src & 0x07) == 0x03)
|
|
|
|
{
|
|
|
|
len = (*src / 8) + 1;
|
|
|
|
memcpy(dst, src + 1, len);
|
|
|
|
src += len;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
len = (*src / 16) + 1;
|
|
|
|
memset(dst, ((*src & 0x0F) == 0x07) ? ' ' : 0, len);
|
|
|
|
}
|
|
|
|
dst += len;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dst > dst_end) WINE_ERR("buffer overflow (%p > %p)\n", dst, dst_end);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************
|
|
|
|
* HLPFILE_UncompressRLE
|
|
|
|
*
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void HLPFILE_UncompressRLE(const BYTE* src, unsigned sz, BYTE** dst)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
unsigned i;
|
|
|
|
BYTE ch;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
for (i = 0; i < sz; i++)
|
|
|
|
{
|
|
|
|
ch = src[i];
|
|
|
|
if (ch & 0x80)
|
|
|
|
{
|
|
|
|
ch &= 0x7F;
|
|
|
|
memcpy(*dst, src + i + 1, ch);
|
|
|
|
i += ch;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
memset(*dst, (char)src[i + 1], ch);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
*dst += ch;
|
|
|
|
}
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
/******************************************************************
|
|
|
|
* HLPFILE_EnumBTreeLeaves
|
|
|
|
*
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void HLPFILE_EnumBTreeLeaves(const BYTE* buf, const BYTE* end, unsigned (*fn)(const BYTE*, void*), void* user)
|
|
|
|
{
|
|
|
|
unsigned psize, pnext;
|
|
|
|
unsigned num, nlvl;
|
|
|
|
const BYTE* ptr;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
num = GET_UINT(buf, 9 + 34);
|
|
|
|
psize = GET_USHORT(buf, 9 + 4);
|
|
|
|
nlvl = GET_USHORT(buf, 9 + 32);
|
|
|
|
pnext = GET_USHORT(buf, 26);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
WINE_TRACE("BTree: #entries=%u pagSize=%u #levels=%u #pages=%u root=%u struct%16s\n",
|
|
|
|
num, psize, nlvl, GET_USHORT(buf, 9 + 30), pnext, buf + 9 + 6);
|
|
|
|
if (!num) return;
|
|
|
|
|
|
|
|
while (--nlvl > 0)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
ptr = (buf + 9 + 38) + pnext * psize;
|
|
|
|
WINE_TRACE("BTree: (index[%u]) unused=%u #entries=%u <%u\n",
|
|
|
|
pnext, GET_USHORT(ptr, 0), GET_USHORT(ptr, 2), GET_USHORT(ptr, 4));
|
|
|
|
pnext = GET_USHORT(ptr, 6);
|
|
|
|
}
|
|
|
|
while (pnext != 0xFFFF)
|
|
|
|
{
|
|
|
|
const BYTE* node_page;
|
|
|
|
unsigned short limit;
|
|
|
|
|
|
|
|
node_page = ptr = (buf + 9 + 38) + pnext * psize;
|
|
|
|
limit = GET_USHORT(ptr, 2);
|
|
|
|
WINE_TRACE("BTree: (leaf [%u]) unused=%u #entries=%u <%u >%u\n",
|
|
|
|
pnext, GET_USHORT(ptr, 0), limit, GET_USHORT(ptr, 4), GET_USHORT(ptr, 6));
|
|
|
|
ptr += 8;
|
|
|
|
while (limit--)
|
|
|
|
ptr += (fn)(ptr, user);
|
|
|
|
pnext = GET_USHORT(node_page, 6);
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
2002-07-16 03:46:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
struct myfncb {
|
|
|
|
HLPFILE* hlpfile;
|
|
|
|
int i;
|
|
|
|
};
|
|
|
|
|
|
|
|
static unsigned myfn(const BYTE* ptr, void* user)
|
|
|
|
{
|
|
|
|
struct myfncb* m = user;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
m->hlpfile->Context[m->i].lHash = GET_UINT(ptr, 0);
|
|
|
|
m->hlpfile->Context[m->i].offset = GET_UINT(ptr, 4);
|
|
|
|
m->i++;
|
|
|
|
return 8;
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
2002-07-16 03:46:29 +02:00
|
|
|
* HLPFILE_GetContext
|
1996-05-06 18:06:24 +02:00
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
static BOOL HLPFILE_GetContext(HLPFILE *hlpfile)
|
|
|
|
{
|
|
|
|
BYTE *cbuf, *cend;
|
|
|
|
struct myfncb m;
|
|
|
|
unsigned clen;
|
|
|
|
|
|
|
|
if (!HLPFILE_FindSubFile("CONTEXT", &cbuf, &cend)) {WINE_WARN("context0\n"); return FALSE;}
|
|
|
|
|
|
|
|
clen = GET_UINT(cbuf, 0x2b);
|
|
|
|
hlpfile->Context = HeapAlloc(GetProcessHeap(), 0, clen * sizeof(HLPFILE_CONTEXT));
|
|
|
|
if (!hlpfile->Context) return FALSE;
|
|
|
|
hlpfile->wContextLen = clen;
|
|
|
|
|
|
|
|
m.hlpfile = hlpfile;
|
|
|
|
m.i = 0;
|
|
|
|
HLPFILE_EnumBTreeLeaves(cbuf, cend, myfn, &m);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_DeleteParagraph
|
|
|
|
*/
|
|
|
|
static void HLPFILE_DeleteParagraph(HLPFILE_PARAGRAPH* paragraph)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
HLPFILE_PARAGRAPH* next;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
while (paragraph)
|
|
|
|
{
|
|
|
|
next = paragraph->next;
|
|
|
|
if (paragraph->link) HeapFree(GetProcessHeap(), 0, paragraph->link);
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
HeapFree(GetProcessHeap(), 0, paragraph);
|
|
|
|
paragraph = next;
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* DeletePage
|
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
static void HLPFILE_DeletePage(HLPFILE_PAGE* page)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
HLPFILE_PAGE* next;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
while (page)
|
|
|
|
{
|
|
|
|
next = page->next;
|
|
|
|
HLPFILE_DeleteParagraph(page->first_paragraph);
|
|
|
|
HeapFree(GetProcessHeap(), 0, page);
|
|
|
|
page = next;
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* DeleteMacro
|
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
static void HLPFILE_DeleteMacro(HLPFILE_MACRO* macro)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
HLPFILE_MACRO* next;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
while (macro)
|
|
|
|
{
|
|
|
|
next = macro->next;
|
|
|
|
HeapFree(GetProcessHeap(), 0, macro);
|
|
|
|
macro = next;
|
|
|
|
}
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* HLPFILE_FreeHlpFile
|
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
void HLPFILE_FreeHlpFile(HLPFILE* hlpfile)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!hlpfile || --hlpfile->wRefCount > 0) return;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (hlpfile->next) hlpfile->next->prev = hlpfile->prev;
|
|
|
|
if (hlpfile->prev) hlpfile->prev->next = hlpfile->next;
|
|
|
|
else first_hlpfile = hlpfile->next;
|
1996-05-06 18:06:24 +02:00
|
|
|
|
2002-07-16 03:46:29 +02:00
|
|
|
if (hlpfile->numFonts)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
for (i = 0; i < hlpfile->numFonts; i++)
|
|
|
|
{
|
|
|
|
DeleteObject(hlpfile->fonts[i].hFont);
|
|
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, hlpfile->fonts);
|
|
|
|
}
|
|
|
|
|
|
|
|
HLPFILE_DeletePage(hlpfile->first_page);
|
|
|
|
HLPFILE_DeleteMacro(hlpfile->first_macro);
|
|
|
|
|
|
|
|
if (hlpfile->Context) HeapFree(GetProcessHeap(), 0, hlpfile->Context);
|
|
|
|
if (hlpfile->lpszTitle) HeapFree(GetProcessHeap(), 0, hlpfile->lpszTitle);
|
|
|
|
HeapFree(GetProcessHeap(), 0, hlpfile);
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* FreeHlpFilePage
|
|
|
|
*/
|
2002-07-16 03:46:29 +02:00
|
|
|
void HLPFILE_FreeHlpFilePage(HLPFILE_PAGE* page)
|
1996-05-06 18:06:24 +02:00
|
|
|
{
|
2002-07-16 03:46:29 +02:00
|
|
|
if (!page) return;
|
|
|
|
HLPFILE_FreeHlpFile(page->file);
|
1996-05-06 18:06:24 +02:00
|
|
|
}
|