ref: f4f19cdf1a8f0d2aa5f9fce10c896201528b5347
dir: /sys/src/cmd/aux/antiword/fonts.c/
/*
* fonts.c
* Copyright (C) 1998-2004 A.J. van Os; Released under GNU GPL
*
* Description:
* Functions to deal with fonts (generic)
*/
#include <ctype.h>
#include <string.h>
#include "antiword.h"
/* Maximum line length in the font file */
#define FONT_LINE_LENGTH 81
/* Pitch */
#define PITCH_UNKNOWN 0
#define PITCH_FIXED 1
#define PITCH_VARIABLE 2
/* Font Family */
#define FAMILY_UNKNOWN 0
#define FAMILY_ROMAN 1
#define FAMILY_SWISS 2
#define FAMILY_MODERN 3
#define FAMILY_SCRIPT 4
#define FAMILY_DECORATIVE 5
/* Font Translation Table */
static size_t tFontTableRecords = 0;
static font_table_type *pFontTable = NULL;
/*
* Find the given font in the font table
*
* returns the index into the FontTable, -1 if not found
*/
int
iGetFontByNumber(UCHAR ucWordFontNumber, USHORT usFontStyle)
{
int iIndex;
for (iIndex = 0; iIndex < (int)tFontTableRecords; iIndex++) {
if (ucWordFontNumber == pFontTable[iIndex].ucWordFontNumber &&
usFontStyle == pFontTable[iIndex].usFontStyle &&
pFontTable[iIndex].szOurFontname[0] != '\0') {
return iIndex;
}
}
DBG_DEC(ucWordFontNumber);
DBG_HEX(usFontStyle);
return -1;
} /* end of iGetFontByNumber */
/*
* szGetOurFontname - Get our font name
*
* return our font name from the given index, NULL if not found
*/
const char *
szGetOurFontname(int iIndex)
{
if (iIndex < 0 || iIndex >= (int)tFontTableRecords) {
return NULL;
}
return pFontTable[iIndex].szOurFontname;
} /* end of szGetOurFontname */
/*
* Find the given font in the font table
*
* returns the Word font number, -1 if not found
*/
int
iFontname2Fontnumber(const char *szOurFontname, USHORT usFontStyle)
{
int iIndex;
for (iIndex = 0; iIndex < (int)tFontTableRecords; iIndex++) {
if (pFontTable[iIndex].usFontStyle == usFontStyle &&
STREQ(pFontTable[iIndex].szOurFontname, szOurFontname)) {
return (int)pFontTable[iIndex].ucWordFontNumber;
}
}
return -1;
} /* end of iFontname2Fontnumber */
/*
* szGetDefaultFont - get the default font that matches the parameters
*/
static const char *
szGetDefaultFont(UCHAR ucFFN, int iEmphasis)
{
UCHAR ucPrq, ucFf;
fail(iEmphasis < 0 || iEmphasis > 3);
ucPrq = ucFFN & 0x03;
ucFf = (ucFFN & 0x70) >> 4;
NO_DBG_DEC(ucPrq);
NO_DBG_DEC(ucFf);
if (ucPrq == PITCH_FIXED) {
/* Set to the default monospaced font */
switch (iEmphasis) {
case 1: return FONT_MONOSPACED_BOLD;
case 2: return FONT_MONOSPACED_ITALIC;
case 3: return FONT_MONOSPACED_BOLDITALIC;
default: return FONT_MONOSPACED_PLAIN;
}
} else if (ucFf == FAMILY_ROMAN) {
/* Set to the default serif font */
switch (iEmphasis) {
case 1: return FONT_SERIF_BOLD;
case 2: return FONT_SERIF_ITALIC;
case 3: return FONT_SERIF_BOLDITALIC;
default: return FONT_SERIF_PLAIN;
}
} else if (ucFf == FAMILY_SWISS) {
/* Set to the default sans serif font */
switch (iEmphasis) {
case 1: return FONT_SANS_SERIF_BOLD;
case 2: return FONT_SANS_SERIF_ITALIC;
case 3: return FONT_SANS_SERIF_BOLDITALIC;
default: return FONT_SANS_SERIF_PLAIN;
}
} else {
/* Set to the default default font */
switch (iEmphasis) {
case 1: return FONT_SERIF_BOLD;
case 2: return FONT_SERIF_ITALIC;
case 3: return FONT_SERIF_BOLDITALIC;
default: return FONT_SERIF_PLAIN;
}
}
} /* end of szGetDefaultFont */
/*
* See if the fontname from the Word file matches the fontname from the
* font translation file.
* If iBytesPerChar is one than aucWord is in ISO-8859-x (Word 2/6/7),
* if iBytesPerChar is two than aucWord is in Unicode (Word 8/9/10).
*/
static BOOL
bFontEqual(const UCHAR *aucWord, const char *szTable, int iBytesPerChar)
{
const UCHAR *pucTmp;
const char *pcTmp;
fail(aucWord == NULL || szTable == NULL);
fail(iBytesPerChar != 1 && iBytesPerChar != 2);
for (pucTmp = aucWord, pcTmp = szTable;
*pucTmp != 0;
pucTmp += iBytesPerChar, pcTmp++) {
if (ulToUpper((ULONG)*pucTmp) !=
ulToUpper((ULONG)(UCHAR)*pcTmp)) {
return FALSE;
}
}
return *pcTmp == '\0';
} /* end of bFontEqual */
/*
* vFontname2Table - add fontnames to the font table
*/
static void
vFontname2Table(const UCHAR *aucFont, const UCHAR *aucAltFont,
int iBytesPerChar, int iEmphasis, UCHAR ucFFN,
const char *szWordFont, const char *szOurFont,
font_table_type *pFontTableRecord)
{
BOOL bMatchFound;
fail(aucFont == NULL || aucFont[0] == 0);
fail(aucAltFont != NULL && aucAltFont[0] == 0);
fail(iBytesPerChar != 1 && iBytesPerChar != 2);
fail(iEmphasis < 0 || iEmphasis > 3);
fail(szWordFont == NULL || szWordFont[0] == '\0');
fail(szOurFont == NULL || szOurFont[0] == '\0');
fail(pFontTableRecord == NULL);
bMatchFound = bFontEqual(aucFont, szWordFont, iBytesPerChar);
if (!bMatchFound && aucAltFont != NULL) {
bMatchFound = bFontEqual(aucAltFont, szWordFont, iBytesPerChar);
}
if (!bMatchFound &&
pFontTableRecord->szWordFontname[0] == '\0' &&
szWordFont[0] == '*' &&
szWordFont[1] == '\0') {
/*
* szWordFont contains a "*", so szOurFont will contain the
* "default default" font. See if we can do better than that.
*/
szOurFont = szGetDefaultFont(ucFFN, iEmphasis);
bMatchFound = TRUE;
}
if (bMatchFound) {
switch (iBytesPerChar) {
case 1:
(void)strncpy(pFontTableRecord->szWordFontname,
(const char *)aucFont,
sizeof(pFontTableRecord->szWordFontname) - 1);
break;
case 2:
(void)unincpy(pFontTableRecord->szWordFontname,
aucFont,
sizeof(pFontTableRecord->szWordFontname) - 1);
break;
default:
DBG_FIXME();
pFontTableRecord->szWordFontname[0] = '\0';
break;
}
pFontTableRecord->szWordFontname[
sizeof(pFontTableRecord->szWordFontname) - 1] = '\0';
(void)strncpy(pFontTableRecord->szOurFontname, szOurFont,
sizeof(pFontTableRecord->szOurFontname) - 1);
pFontTableRecord->szOurFontname[
sizeof(pFontTableRecord->szOurFontname) - 1] = '\0';
NO_DBG_MSG(pFontTableRecord->szWordFontname);
NO_DBG_MSG(pFontTableRecord->szOurFontname);
pFontTableRecord->ucFFN = ucFFN;
pFontTableRecord->ucEmphasis = (UCHAR)iEmphasis;
}
} /* end of vFontname2Table */
/*
* vCreateFontTable - Create and initialize the internal font table
*/
static void
vCreateFontTable(void)
{
font_table_type *pTmp;
int iNbr;
if (tFontTableRecords == 0) {
pFontTable = xfree(pFontTable);
return;
}
/* Create the font table */
pFontTable = xcalloc(tFontTableRecords, sizeof(*pFontTable));
/* Initialize the font table */
for (iNbr = 0, pTmp = pFontTable;
pTmp < pFontTable + tFontTableRecords;
iNbr++, pTmp++) {
pTmp->ucWordFontNumber = (UCHAR)(iNbr / 4);
switch (iNbr % 4) {
case 0:
pTmp->usFontStyle = FONT_REGULAR;
break;
case 1:
pTmp->usFontStyle = FONT_BOLD;
break;
case 2:
pTmp->usFontStyle = FONT_ITALIC;
break;
case 3:
pTmp->usFontStyle = FONT_BOLD|FONT_ITALIC;
break;
default:
DBG_DEC(iNbr);
break;
}
}
} /* end of vCreateFontTable */
/*
* vMinimizeFontTable - make the font table as small as possible
*/
static void
vMinimizeFontTable(void)
{
font_block_type tFontNext;
const style_block_type *pStyle;
const font_block_type *pFont;
font_table_type *pTmp;
int iUnUsed;
BOOL bMustAddTableFont;
NO_DBG_MSG("vMinimizeFontTable");
if (tFontTableRecords == 0) {
pFontTable = xfree(pFontTable);
return;
}
/* See if we must add a font for our tables */
bMustAddTableFont = TRUE;
#if 0
DBG_MSG("Before");
DBG_DEC(tFontTableRecords);
for (pTmp = pFontTable;
pTmp < pFontTable + tFontTableRecords;
pTmp++) {
DBG_DEC(pTmp->ucWordFontNumber);
DBG_HEX(pTmp->usFontStyle);
DBG_MSG(pTmp->szWordFontname);
DBG_MSG(pTmp->szOurFontname);
}
#endif /* DEBUG */
/* See which fonts/styles we really need */
/* Default font/style is by definition in use */
pFontTable[0].ucInUse = 1;
/* Make InUse 1 for all the fonts/styles that WILL be used */
pFont = NULL;
while((pFont = pGetNextFontInfoListItem(pFont)) != NULL) {
pTmp = pFontTable + 4 * (int)pFont->ucFontNumber;
if (bIsBold(pFont->usFontStyle)) {
pTmp++;
}
if (bIsItalic(pFont->usFontStyle)) {
pTmp += 2;
}
if (pTmp >= pFontTable + tFontTableRecords) {
continue;
}
if (STREQ(pTmp->szOurFontname, TABLE_FONT)) {
/* The table font is already present */
bMustAddTableFont = FALSE;
}
pTmp->ucInUse = 1;
}
/* Make InUse 1 for all the fonts/styles that MIGHT be used */
pStyle = NULL;
while((pStyle = pGetNextStyleInfoListItem(pStyle)) != NULL) {
vFillFontFromStylesheet(pStyle->usIstdNext, &tFontNext);
vCorrectFontValues(&tFontNext);
pTmp = pFontTable + 4 * (int)tFontNext.ucFontNumber;
if (bIsBold(tFontNext.usFontStyle)) {
pTmp++;
}
if (bIsItalic(tFontNext.usFontStyle)) {
pTmp += 2;
}
if (pTmp >= pFontTable + tFontTableRecords) {
continue;
}
if (STREQ(pTmp->szOurFontname, TABLE_FONT)) {
/* The table font is already present */
bMustAddTableFont = FALSE;
}
pTmp->ucInUse = 1;
}
/* Remove the unused font entries from the font table */
iUnUsed = 0;
for (pTmp = pFontTable;
pTmp < pFontTable + tFontTableRecords;
pTmp++) {
if (pTmp->ucInUse == 0) {
iUnUsed++;
continue;
}
if (iUnUsed > 0) {
fail(pTmp - iUnUsed <= pFontTable);
*(pTmp - iUnUsed) = *pTmp;
}
}
fail(iUnUsed < 0);
fail(tFontTableRecords <= (size_t)iUnUsed);
tFontTableRecords -= (size_t)iUnUsed;
if (bMustAddTableFont) {
pTmp = pFontTable + tFontTableRecords;
fail(pTmp <= pFontTable);
pTmp->ucWordFontNumber = (pTmp - 1)->ucWordFontNumber + 1;
pTmp->usFontStyle = FONT_REGULAR;
pTmp->ucInUse = 1;
strcpy(pTmp->szWordFontname, "Extra Table Font");
strcpy(pTmp->szOurFontname, TABLE_FONT);
tFontTableRecords++;
iUnUsed--;
}
if (iUnUsed > 0) {
/* Resize the font table */
pFontTable = xrealloc(pFontTable,
tFontTableRecords * sizeof(*pFontTable));
}
#if defined(DEBUG)
DBG_MSG("After");
DBG_DEC(tFontTableRecords);
for (pTmp = pFontTable;
pTmp < pFontTable + tFontTableRecords;
pTmp++) {
DBG_DEC(pTmp->ucWordFontNumber);
DBG_HEX(pTmp->usFontStyle);
DBG_MSG(pTmp->szWordFontname);
DBG_MSG(pTmp->szOurFontname);
}
#endif /* DEBUG */
} /* end of vMinimizeFontTable */
/*
* bReadFontFile - read and check a line from the font translation file
*
* returns TRUE when a correct line has been read, otherwise FALSE
*/
static BOOL
bReadFontFile(FILE *pFontTableFile, char *szWordFont,
int *piItalic, int *piBold, char *szOurFont, int *piSpecial)
{
char *pcTmp;
int iFields;
char szLine[FONT_LINE_LENGTH];
fail(szWordFont == NULL || szOurFont == NULL);
fail(piItalic == NULL || piBold == NULL || piSpecial == NULL);
while (fgets(szLine, (int)sizeof(szLine), pFontTableFile) != NULL) {
if (szLine[0] == '#' ||
szLine[0] == '\n' ||
szLine[0] == '\r') {
continue;
}
iFields = sscanf(szLine, "%[^,],%d,%d,%1s%[^,],%d",
szWordFont, piItalic, piBold,
&szOurFont[0], &szOurFont[1], piSpecial);
if (iFields != 6) {
pcTmp = strchr(szLine, '\r');
if (pcTmp != NULL) {
*pcTmp = '\0';
}
pcTmp = strchr(szLine, '\n');
if (pcTmp != NULL) {
*pcTmp = '\0';
}
DBG_DEC(iFields);
werr(0, "Syntax error in: '%s'", szLine);
continue;
}
if (strlen(szWordFont) >=
sizeof(pFontTable[0].szWordFontname)) {
werr(0, "Word fontname too long: '%s'", szWordFont);
continue;
}
if (strlen(szOurFont) >=
sizeof(pFontTable[0].szOurFontname)) {
werr(0, "Local fontname too long: '%s'", szOurFont);
continue;
}
/* The current line passed all the tests */
return TRUE;
}
return FALSE;
} /* end of bReadFontFile */
/*
* vCreate0FontTable - create a font table from Word for DOS
*/
void
vCreate0FontTable(void)
{
FILE *pFontTableFile;
font_table_type *pTmp;
UCHAR *aucFont;
int iBold, iItalic, iSpecial, iEmphasis, iFtc;
UCHAR ucPrq, ucFf, ucFFN;
char szWordFont[FONT_LINE_LENGTH], szOurFont[FONT_LINE_LENGTH];
tFontTableRecords = 0;
pFontTable = xfree(pFontTable);
pFontTableFile = pOpenFontTableFile();
if (pFontTableFile == NULL) {
/* No translation table file, no translation table */
return;
}
/* Get the maximum number of entries in the font table */
tFontTableRecords = 64;
tFontTableRecords *= 4; /* Plain, Bold, Italic and Bold/italic */
tFontTableRecords++; /* One extra for the table-font */
vCreateFontTable();
/* Read the font translation file */
iItalic = 0;
iBold = 0;
iSpecial = 0;
while (bReadFontFile(pFontTableFile, szWordFont,
&iItalic, &iBold, szOurFont, &iSpecial)) {
iEmphasis = 0;
if (iBold != 0) {
iEmphasis++;
}
if (iItalic != 0) {
iEmphasis += 2;
}
for (iFtc = 0, pTmp = pFontTable + iEmphasis;
pTmp < pFontTable + tFontTableRecords;
iFtc++, pTmp += 4) {
if (iFtc >= 16 && iFtc <= 55) {
ucPrq = PITCH_VARIABLE;
ucFf = FAMILY_ROMAN;
aucFont = (UCHAR *)"Times";
} else {
ucPrq = PITCH_FIXED;
ucFf = FAMILY_MODERN;
aucFont = (UCHAR *)"Courier";
}
ucFFN = (ucFf << 4) | ucPrq;
vFontname2Table(aucFont, NULL, 1, iEmphasis,
ucFFN, szWordFont, szOurFont, pTmp);
}
}
(void)fclose(pFontTableFile);
vMinimizeFontTable();
} /* end of vCreate0FontTable */
/*
* vCreate2FontTable - create a font table from WinWord 1/2
*/
void
vCreate2FontTable(FILE *pFile, int iWordVersion, const UCHAR *aucHeader)
{
FILE *pFontTableFile;
font_table_type *pTmp;
UCHAR *aucFont;
UCHAR *aucBuffer;
ULONG ulBeginFontInfo;
size_t tFontInfoLen;
int iPos, iOff, iRecLen;
int iBold, iItalic, iSpecial, iEmphasis;
UCHAR ucFFN;
char szWordFont[FONT_LINE_LENGTH], szOurFont[FONT_LINE_LENGTH];
fail(pFile == NULL || aucHeader == NULL);
fail(iWordVersion != 1 && iWordVersion != 2);
tFontTableRecords = 0;
pFontTable = xfree(pFontTable);
pFontTableFile = pOpenFontTableFile();
if (pFontTableFile == NULL) {
/* No translation table file, no translation table */
return;
}
ulBeginFontInfo = ulGetLong(0xb2, aucHeader); /* fcSttbfffn */
DBG_HEX(ulBeginFontInfo);
tFontInfoLen = (size_t)usGetWord(0xb6, aucHeader); /* cbSttbfffn */
DBG_DEC(tFontInfoLen);
if (ulBeginFontInfo > (ULONG)LONG_MAX || tFontInfoLen == 0) {
/* Don't ask me why this is needed */
DBG_HEX_C(tFontInfoLen != 0, ulBeginFontInfo);
(void)fclose(pFontTableFile);
return;
}
aucBuffer = xmalloc(tFontInfoLen);
if (!bReadBytes(aucBuffer, tFontInfoLen, ulBeginFontInfo, pFile)) {
aucBuffer = xfree(aucBuffer);
(void)fclose(pFontTableFile);
return;
}
NO_DBG_PRINT_BLOCK(aucBuffer, tFontInfoLen);
DBG_DEC(usGetWord(0, aucBuffer));
/* Compute the maximum number of entries in the font table */
if (iWordVersion == 1) {
fail(tFontInfoLen < 2);
/* WinWord 1 has three implicit fonts */
tFontTableRecords = 3;
iOff = 2;
} else {
fail(tFontInfoLen < 6);
/* WinWord 2 and up have no implicit fonts */
tFontTableRecords = 0;
iOff = 3;
}
iPos = 2;
while (iPos + iOff < (int)tFontInfoLen) {
iRecLen = (int)ucGetByte(iPos, aucBuffer);
NO_DBG_DEC(iRecLen);
NO_DBG_MSG(aucBuffer + iPos + iOff);
iPos += iRecLen + 1;
tFontTableRecords++;
}
tFontTableRecords *= 4; /* Plain, Bold, Italic and Bold/Italic */
tFontTableRecords++; /* One extra for the table-font */
vCreateFontTable();
/* Add the tree implicit fonts (in four variations) */
if (iWordVersion == 1) {
fail(tFontTableRecords < 13);
vFontname2Table((UCHAR *)"Tms Rmn", NULL, 1, 0,
(UCHAR)((FAMILY_ROMAN << 4) | PITCH_VARIABLE),
"*", "Times-Roman", pFontTable + 0);
vFontname2Table((UCHAR *)"Tms Rmn", NULL, 1, 1,
(UCHAR)((FAMILY_ROMAN << 4) | PITCH_VARIABLE),
"*", "Times-Bold", pFontTable + 1);
vFontname2Table((UCHAR *)"Tms Rmn", NULL, 1, 2,
(UCHAR)((FAMILY_ROMAN << 4) | PITCH_VARIABLE),
"*", "Times-Italic", pFontTable + 2);
vFontname2Table((UCHAR *)"Tms Rmn", NULL, 1, 3,
(UCHAR)((FAMILY_ROMAN << 4) | PITCH_VARIABLE),
"*", "Times-BoldItalic", pFontTable + 3);
vFontname2Table((UCHAR *)"Symbol", NULL, 1, 0,
(UCHAR)((FAMILY_ROMAN << 4) | PITCH_VARIABLE),
"*", "Times-Roman", pFontTable + 4);
vFontname2Table((UCHAR *)"Symbol", NULL, 1, 1,
(UCHAR)((FAMILY_ROMAN << 4) | PITCH_VARIABLE),
"*", "Times-Bold", pFontTable + 5);
vFontname2Table((UCHAR *)"Symbol", NULL, 1, 2,
(UCHAR)((FAMILY_ROMAN << 4) | PITCH_VARIABLE),
"*", "Times-Italic", pFontTable + 6);
vFontname2Table((UCHAR *)"Symbol", NULL, 1, 3,
(UCHAR)((FAMILY_ROMAN << 4) | PITCH_VARIABLE),
"*", "Times-BoldItalic", pFontTable + 7);
vFontname2Table((UCHAR *)"Helv", NULL, 1, 0,
(UCHAR)((FAMILY_SWISS << 4) | PITCH_VARIABLE),
"*", "Helvetica", pFontTable + 8);
vFontname2Table((UCHAR *)"Helv", NULL, 1, 1,
(UCHAR)((FAMILY_SWISS << 4) | PITCH_VARIABLE),
"*", "Helvetica-Bold", pFontTable + 9);
vFontname2Table((UCHAR *)"Helv", NULL, 1, 2,
(UCHAR)((FAMILY_SWISS << 4) | PITCH_VARIABLE),
"*", "Helvetica-Oblique", pFontTable + 10);
vFontname2Table((UCHAR *)"Helv", NULL, 1, 3,
(UCHAR)((FAMILY_SWISS << 4) | PITCH_VARIABLE),
"*", "Helvetica-BoldOblique", pFontTable + 11);
}
/* Read the font translation file */
iItalic = 0;
iBold = 0;
iSpecial = 0;
while (bReadFontFile(pFontTableFile, szWordFont,
&iItalic, &iBold, szOurFont, &iSpecial)) {
iEmphasis = 0;
if (iBold != 0) {
iEmphasis++;
}
if (iItalic != 0) {
iEmphasis += 2;
}
pTmp = pFontTable + iEmphasis;
iPos = 2;
while (iPos + iOff < (int)tFontInfoLen) {
iRecLen = (int)ucGetByte(iPos, aucBuffer);
ucFFN = ucGetByte(iPos + 1, aucBuffer);
aucFont = aucBuffer + iPos + iOff;
vFontname2Table(aucFont, NULL, 1, iEmphasis,
ucFFN, szWordFont, szOurFont, pTmp);
pTmp += 4;
iPos += iRecLen + 1;
}
}
(void)fclose(pFontTableFile);
aucBuffer = xfree(aucBuffer);
vMinimizeFontTable();
} /* end of vCreate2FontTable */
/*
* vCreate6FontTable - create a font table from Word 6/7
*/
void
vCreate6FontTable(FILE *pFile, ULONG ulStartBlock,
const ULONG *aulBBD, size_t tBBDLen,
const UCHAR *aucHeader)
{
FILE *pFontTableFile;
font_table_type *pTmp;
UCHAR *aucFont, *aucAltFont;
UCHAR *aucBuffer;
ULONG ulBeginFontInfo;
size_t tFontInfoLen;
int iPos, iRecLen, iOffsetAltName;
int iBold, iItalic, iSpecial, iEmphasis;
UCHAR ucFFN;
char szWordFont[FONT_LINE_LENGTH], szOurFont[FONT_LINE_LENGTH];
fail(pFile == NULL || aucHeader == NULL);
fail(ulStartBlock > MAX_BLOCKNUMBER && ulStartBlock != END_OF_CHAIN);
fail(aulBBD == NULL);
tFontTableRecords = 0;
pFontTable = xfree(pFontTable);
pFontTableFile = pOpenFontTableFile();
if (pFontTableFile == NULL) {
/* No translation table file, no translation table */
return;
}
ulBeginFontInfo = ulGetLong(0xd0, aucHeader); /* fcSttbfffn */
DBG_HEX(ulBeginFontInfo);
tFontInfoLen = (size_t)ulGetLong(0xd4, aucHeader); /* lcbSttbfffn */
DBG_DEC(tFontInfoLen);
fail(tFontInfoLen < 9);
aucBuffer = xmalloc(tFontInfoLen);
if (!bReadBuffer(pFile, ulStartBlock,
aulBBD, tBBDLen, BIG_BLOCK_SIZE,
aucBuffer, ulBeginFontInfo, tFontInfoLen)) {
aucBuffer = xfree(aucBuffer);
(void)fclose(pFontTableFile);
return;
}
DBG_DEC(usGetWord(0, aucBuffer));
/* Compute the maximum number of entries in the font table */
tFontTableRecords = 0;
iPos = 2;
while (iPos + 6 < (int)tFontInfoLen) {
iRecLen = (int)ucGetByte(iPos, aucBuffer);
NO_DBG_DEC(iRecLen);
iOffsetAltName = (int)ucGetByte(iPos + 5, aucBuffer);
NO_DBG_MSG(aucBuffer + iPos + 6);
NO_DBG_MSG_C(iOffsetAltName > 0,
aucBuffer + iPos + 6 + iOffsetAltName);
iPos += iRecLen + 1;
tFontTableRecords++;
}
tFontTableRecords *= 4; /* Plain, Bold, Italic and Bold/italic */
tFontTableRecords++; /* One extra for the table-font */
vCreateFontTable();
/* Read the font translation file */
iItalic = 0;
iBold = 0;
iSpecial = 0;
while (bReadFontFile(pFontTableFile, szWordFont,
&iItalic, &iBold, szOurFont, &iSpecial)) {
iEmphasis = 0;
if (iBold != 0) {
iEmphasis++;
}
if (iItalic != 0) {
iEmphasis += 2;
}
pTmp = pFontTable + iEmphasis;
iPos = 2;
while (iPos + 6 < (int)tFontInfoLen) {
iRecLen = (int)ucGetByte(iPos, aucBuffer);
ucFFN = ucGetByte(iPos + 1, aucBuffer);
aucFont = aucBuffer + iPos + 6;
iOffsetAltName = (int)ucGetByte(iPos + 5, aucBuffer);
if (iOffsetAltName <= 0) {
aucAltFont = NULL;
} else {
aucAltFont = aucFont + iOffsetAltName;
NO_DBG_MSG(aucFont);
NO_DBG_MSG(aucAltFont);
}
vFontname2Table(aucFont, aucAltFont, 1, iEmphasis,
ucFFN, szWordFont, szOurFont, pTmp);
pTmp += 4;
iPos += iRecLen + 1;
}
}
(void)fclose(pFontTableFile);
aucBuffer = xfree(aucBuffer);
vMinimizeFontTable();
} /* end of vCreate6FontTable */
/*
* vCreate8FontTable - create a font table from Word 8/9/10
*/
void
vCreate8FontTable(FILE *pFile, const pps_info_type *pPPS,
const ULONG *aulBBD, size_t tBBDLen,
const ULONG *aulSBD, size_t tSBDLen,
const UCHAR *aucHeader)
{
FILE *pFontTableFile;
font_table_type *pTmp;
const ULONG *aulBlockDepot;
UCHAR *aucFont, *aucAltFont;
UCHAR *aucBuffer;
ULONG ulBeginFontInfo;
size_t tFontInfoLen, tBlockDepotLen, tBlockSize;
int iPos, iRecLen, iOffsetAltName;
int iBold, iItalic, iSpecial, iEmphasis;
UCHAR ucFFN;
char szWordFont[FONT_LINE_LENGTH], szOurFont[FONT_LINE_LENGTH];
fail(pFile == NULL || pPPS == NULL || aucHeader == NULL);
fail(aulBBD == NULL || aulSBD == NULL);
tFontTableRecords = 0;
pFontTable = xfree(pFontTable);
pFontTableFile = pOpenFontTableFile();
if (pFontTableFile == NULL) {
/* No translation table file, no translation table */
return;
}
ulBeginFontInfo = ulGetLong(0x112, aucHeader); /* fcSttbfffn */
DBG_HEX(ulBeginFontInfo);
tFontInfoLen = (size_t)ulGetLong(0x116, aucHeader); /* lcbSttbfffn */
DBG_DEC(tFontInfoLen);
fail(tFontInfoLen < 46);
DBG_DEC(pPPS->tTable.ulSB);
DBG_HEX(pPPS->tTable.ulSize);
if (pPPS->tTable.ulSize == 0) {
DBG_MSG("No fontname table");
(void)fclose(pFontTableFile);
return;
}
if (pPPS->tTable.ulSize < MIN_SIZE_FOR_BBD_USE) {
/* Use the Small Block Depot */
aulBlockDepot = aulSBD;
tBlockDepotLen = tSBDLen;
tBlockSize = SMALL_BLOCK_SIZE;
} else {
/* Use the Big Block Depot */
aulBlockDepot = aulBBD;
tBlockDepotLen = tBBDLen;
tBlockSize = BIG_BLOCK_SIZE;
}
aucBuffer = xmalloc(tFontInfoLen);
if (!bReadBuffer(pFile, pPPS->tTable.ulSB,
aulBlockDepot, tBlockDepotLen, tBlockSize,
aucBuffer, ulBeginFontInfo, tFontInfoLen)) {
aucBuffer = xfree(aucBuffer);
(void)fclose(pFontTableFile);
return;
}
NO_DBG_PRINT_BLOCK(aucBuffer, tFontInfoLen);
/* Get the maximum number of entries in the font table */
tFontTableRecords = (size_t)usGetWord(0, aucBuffer);
tFontTableRecords *= 4; /* Plain, Bold, Italic and Bold/italic */
tFontTableRecords++; /* One extra for the table-font */
vCreateFontTable();
/* Read the font translation file */
iItalic = 0;
iBold = 0;
iSpecial = 0;
while (bReadFontFile(pFontTableFile, szWordFont,
&iItalic, &iBold, szOurFont, &iSpecial)) {
iEmphasis = 0;
if (iBold != 0) {
iEmphasis++;
}
if (iItalic != 0) {
iEmphasis += 2;
}
pTmp = pFontTable + iEmphasis;
iPos = 4;
while (iPos + 40 < (int)tFontInfoLen) {
iRecLen = (int)ucGetByte(iPos, aucBuffer);
ucFFN = ucGetByte(iPos + 1, aucBuffer);
aucFont = aucBuffer + iPos + 40;
iOffsetAltName = (int)unilen(aucFont);
if (iPos + 40 + iOffsetAltName + 4 >= iRecLen) {
aucAltFont = NULL;
} else {
aucAltFont = aucFont + iOffsetAltName + 2;
NO_DBG_UNICODE(aucFont);
NO_DBG_UNICODE(aucAltFont);
}
vFontname2Table(aucFont, aucAltFont, 2, iEmphasis,
ucFFN, szWordFont, szOurFont, pTmp);
pTmp += 4;
iPos += iRecLen + 1;
}
}
(void)fclose(pFontTableFile);
aucBuffer = xfree(aucBuffer);
vMinimizeFontTable();
} /* end of vCreate8FontTable */
/*
* Destroy the internal font table by freeing its memory
*/
void
vDestroyFontTable(void)
{
DBG_MSG("vDestroyFontTable");
tFontTableRecords = 0;
pFontTable = xfree(pFontTable);
} /* end of vDestroyFontTable */
/*
* pGetNextFontTableRecord
*
* returns the next record in the table or NULL if there is no next record
*/
const font_table_type *
pGetNextFontTableRecord(const font_table_type *pRecordCurr)
{
size_t tIndexCurr;
if (pRecordCurr == NULL) {
/* No current record, so start with the first one */
return &pFontTable[0];
}
if (pRecordCurr < pFontTable ||
pRecordCurr >= pFontTable + tFontTableRecords) {
/* Not a pointer in the array */
DBG_HEX(pRecordCurr);
DBG_HEX(pFontTable);
return NULL;
}
tIndexCurr = (size_t)(pRecordCurr - pFontTable);
if (tIndexCurr + 1 < tFontTableRecords) {
/* There is a next record, so return it */
return &pFontTable[tIndexCurr + 1];
}
/* There is no next record */
return NULL;
} /* end of pGetNextFontTableRecord */
/*
* tGetFontTableLength
*
* returns the number of records in the internal font table
*/
size_t
tGetFontTableLength(void)
{
return tFontTableRecords;
} /* end of tGetFontTableLength */
#if !defined(__riscos)
/*
* vCorrect4PDF - only include PDF default fonts
*/
static void
vCorrect4PDF(void)
{
font_table_type *pTmp;
const char *szOurFont;
for (pTmp = pFontTable; pTmp < pFontTable + tFontTableRecords; pTmp++) {
if (STRCEQ(pTmp->szOurFontname, FONT_MONOSPACED_PLAIN) ||
STRCEQ(pTmp->szOurFontname, FONT_MONOSPACED_BOLD) ||
STRCEQ(pTmp->szOurFontname, FONT_MONOSPACED_ITALIC) ||
STRCEQ(pTmp->szOurFontname, FONT_MONOSPACED_BOLDITALIC) ||
STRCEQ(pTmp->szOurFontname, FONT_SERIF_PLAIN) ||
STRCEQ(pTmp->szOurFontname, FONT_SERIF_BOLD) ||
STRCEQ(pTmp->szOurFontname, FONT_SERIF_ITALIC) ||
STRCEQ(pTmp->szOurFontname, FONT_SERIF_BOLDITALIC) ||
STRCEQ(pTmp->szOurFontname, FONT_SANS_SERIF_PLAIN) ||
STRCEQ(pTmp->szOurFontname, FONT_SANS_SERIF_BOLD) ||
STRCEQ(pTmp->szOurFontname, FONT_SANS_SERIF_ITALIC) ||
STRCEQ(pTmp->szOurFontname, FONT_SANS_SERIF_BOLDITALIC)) {
/* Already a default font */
continue;
}
szOurFont =
szGetDefaultFont(pTmp->ucFFN, (int)pTmp->ucEmphasis);
(void)strncpy(pTmp->szOurFontname, szOurFont,
sizeof(pTmp->szOurFontname) - 1);
pTmp->szOurFontname[sizeof(pTmp->szOurFontname) - 1] = '\0';
}
} /* end of vCorrect4PDF */
/*
* vCorrect4CyrPS - only include monospaced fonts
*/
static void
vCorrect4CyrPS(void)
{
font_table_type *pTmp;
const char *szOurFont;
UCHAR ucFFN;
ucFFN = (FAMILY_UNKNOWN << 4) | PITCH_FIXED;
for (pTmp = pFontTable; pTmp < pFontTable + tFontTableRecords; pTmp++) {
szOurFont = szGetDefaultFont(ucFFN, (int)pTmp->ucEmphasis);
(void)strncpy(pTmp->szOurFontname, szOurFont,
sizeof(pTmp->szOurFontname) - 1);
pTmp->szOurFontname[sizeof(pTmp->szOurFontname) - 1] = '\0';
}
} /* end of vCorrect4CyrPS */
#endif /* __riscos */
/*
* vCorrectFontTable - correct the font table in special cases
*/
void
vCorrectFontTable(conversion_type eConversionType, encoding_type eEncoding)
{
#if !defined(__riscos)
if (eConversionType == conversion_pdf) {
vCorrect4PDF();
}
if (eConversionType == conversion_ps &&
eEncoding == encoding_cyrillic) {
vCorrect4CyrPS();
}
#endif /* __riscos */
} /* end of vCorrectFontTable */
/*
* lComputeSpaceWidth - compute the width of a space character
*
* Returns the space width in millipoints
*/
long
lComputeSpaceWidth(drawfile_fontref tFontRef, USHORT usFontSize)
{
char szSpace[] = " ";
fail(usFontSize < MIN_FONT_SIZE || usFontSize > MAX_FONT_SIZE);
return lComputeStringWidth(szSpace, 1, tFontRef, usFontSize);
} /* end of lComputeSpaceWidth */