1820 lines
48 KiB
C++
1820 lines
48 KiB
C++
/*
|
|
* @doc INTERNAL
|
|
*
|
|
* @module FONT.CPP -- font cache |
|
|
*
|
|
* Includes font cache, char width cache;
|
|
* create logical font if not in cache, look up
|
|
* character widths on an as needed basis (this
|
|
* has been abstracted away into a separate class
|
|
* so that different char width caching algos can
|
|
* be tried.) <nl>
|
|
*
|
|
* Owner: <nl>
|
|
* RichEdit 1.0 code: David R. Fulmer
|
|
* Christian Fortini (initial conversion to C++)
|
|
* Jon Matousek <nl>
|
|
*
|
|
* History: <nl>
|
|
* 7/26/95 jonmat cleanup and reorganization, factored out
|
|
* char width caching code into a separate class.
|
|
* 7/1/99 KeithCu Removed multiple levels in CWidthCache, cached
|
|
* 30K FE characters in 2 bytes, sped up cache by
|
|
* lowering acceptable collision rate, halved memory
|
|
* usage by storing widths in 2 bytes instead of 4
|
|
* Shrunk much out of CCcs (i.e. LOGFONT)
|
|
*
|
|
* Copyright (c) 1995-2000 Microsoft Corporation. All rights reserved.
|
|
*/
|
|
|
|
#include "_common.h"
|
|
#include "_font.h"
|
|
#include "_rtfconv.h" // Needed for GetCodePage
|
|
#include "_uspi.h"
|
|
|
|
#define CLIP_DFA_OVERRIDE 0x40 // Used to disable Korea & Taiwan font association
|
|
#define FF_BIDI 7
|
|
|
|
extern ICustomTextOut *g_pcto;
|
|
|
|
ASSERTDATA
|
|
|
|
// Corresponds to yHeightCharPtsMost in richedit.h
|
|
#define yHeightCharMost 32760
|
|
|
|
// NOTE: this is global across all instances in the same process.
|
|
static CFontCache *g_fc;
|
|
|
|
static FONTINFO *g_pFontInfo = NULL;
|
|
static LONG g_cFontInfo = 0;
|
|
static LONG g_cFontInfoMax = 0;
|
|
|
|
//Fonts automatically added to our font table
|
|
const WCHAR *szArial = L"Arial"; // IFONT_ARIAL
|
|
const WCHAR *szTimesNewRoman = L"Times New Roman"; // IFONT_TIMESNEWROMAN
|
|
const WCHAR *szSymbol = L"Symbol"; // IFONT_SYMBOL
|
|
const WCHAR *szSystem = L"System"; // IFONT_SYSTEM
|
|
const int cfontsDflt = 4;
|
|
|
|
//Other fonts that we do use, but aren't automatically added to our font table
|
|
const WCHAR *szMicrosSansSerif = L"Microsoft Sans Serif";
|
|
const WCHAR *szMSSansSerif = L"MS Sans Serif";
|
|
const WCHAR *szMangal = L"Mangal";
|
|
const WCHAR *szLatha = L"Latha";
|
|
const WCHAR *szRaavi = L"Raavi";
|
|
const WCHAR *szShruti = L"Shruti";
|
|
const WCHAR *szTunga = L"Tunga";
|
|
const WCHAR *szGautami = L"Gautami";
|
|
const WCHAR *szCordiaNew = L"Cordia New";
|
|
const WCHAR *szTahoma = L"Tahoma";
|
|
const WCHAR *szArialUnicode = L"Arial Unicode MS";
|
|
const WCHAR *szWingdings = L"Wingdings";
|
|
const WCHAR *szSylfaen = L"Sylfaen";
|
|
const WCHAR *szSyriac = L"Estrangelo Edessa";
|
|
const WCHAR *szThaana = L"MV Boli";
|
|
|
|
#define szFontOfChoice szArial
|
|
|
|
/*
|
|
* GetFontNameIndex(pFontName)
|
|
*
|
|
* @func
|
|
* return index into global pszFontName table for fontname pFontName.
|
|
* If fontname isn't in table, add it and return index.
|
|
*
|
|
* @rdesc
|
|
* fontname index corresponding to pFontName
|
|
*
|
|
* @devnote
|
|
* This uses a linear search, so the most common font names should be
|
|
* up front. Internally, we use the fontname indices, so the search
|
|
* isn't done that often. Note also that the fontname table only grows,
|
|
* but this is probably OK for most clients. Else we need ref counting...
|
|
*/
|
|
SHORT GetFontNameIndex(
|
|
const WCHAR *pFontName)
|
|
{
|
|
CLock Lock; // Wonder how much this slows things down...
|
|
|
|
for(LONG i = 0; i < g_cFontInfo; i++)
|
|
{
|
|
// A hash could speed this up if perf turns out poor
|
|
if(!wcscmp(pFontName, g_pFontInfo[i].szFontName))
|
|
return i;
|
|
}
|
|
|
|
if(g_cFontInfo + 1 >= g_cFontInfoMax)
|
|
{
|
|
// Note that PvReAlloc() reverts to PvAlloc() if g_pFontInfo is NULL
|
|
FONTINFO *pFI = (FONTINFO *)PvReAlloc((LPVOID)g_pFontInfo,
|
|
sizeof(FONTINFO) * (8 + g_cFontInfo));
|
|
if(!pFI)
|
|
return IFONT_ARIAL; // Out of memory...
|
|
|
|
// Initialize the structure
|
|
ZeroMemory (&pFI[g_cFontInfo], 8 * sizeof(FONTINFO));
|
|
|
|
// attempts to fill them in
|
|
if(!g_cFontInfoMax) // First allocation
|
|
{
|
|
Assert(IFONT_ARIAL == 0 && IFONT_TMSNEWRMN == 1 &&
|
|
IFONT_SYMBOL == 2 && IFONT_SYSTEM == 3);
|
|
|
|
pFI[IFONT_ARIAL].szFontName = szArial;
|
|
pFI[IFONT_TMSNEWRMN].szFontName = szTimesNewRoman;
|
|
pFI[IFONT_SYMBOL].szFontName = szSymbol;
|
|
pFI[IFONT_SYSTEM].szFontName = szSystem;
|
|
g_cFontInfo = cfontsDflt;
|
|
}
|
|
g_pFontInfo = pFI;
|
|
g_cFontInfoMax += 8;
|
|
}
|
|
|
|
LONG cb = (wcslen(pFontName) + 1)*sizeof(WCHAR);
|
|
WCHAR * pch = (WCHAR *)PvAlloc(cb, GMEM_MOVEABLE);
|
|
|
|
if(!pch)
|
|
return IFONT_ARIAL; // Out of memory...
|
|
|
|
g_pFontInfo[g_cFontInfo].szFontName = pch;
|
|
CopyMemory((void *)pch, pFontName, cb);
|
|
return g_cFontInfo++;
|
|
}
|
|
|
|
/*
|
|
* GetFontName(iFont)
|
|
*
|
|
* @func
|
|
* return fontname given by g_pFontInfo[iFont].szFontName.
|
|
*
|
|
* @rdesc
|
|
* fontname corresponding to fontname index iFont
|
|
*/
|
|
const WCHAR *GetFontName(
|
|
LONG iFont)
|
|
{
|
|
return (iFont >= 0 && iFont < g_cFontInfo) ? g_pFontInfo[iFont].szFontName : NULL;
|
|
}
|
|
|
|
void SetFontSignature(
|
|
LONG iFont,
|
|
QWORD qwFontSig)
|
|
{
|
|
if(iFont >= 0 && iFont < g_cFontInfo)
|
|
g_pFontInfo[iFont].qwFontSig |= qwFontSig;
|
|
}
|
|
|
|
/*
|
|
* SetFontLegitimateSize(iFont, fUIFont, bSize, fFEcpg)
|
|
*
|
|
* @func
|
|
* Set the legitimate size (readable smallest size to use) of a given font
|
|
*
|
|
* @rdesc
|
|
* TRUE if successful
|
|
*/
|
|
BOOL SetFontLegitimateSize(
|
|
LONG iFont,
|
|
BOOL fUIFont,
|
|
BYTE bSize,
|
|
BOOL fFEcpg)
|
|
{
|
|
if (iFont < g_cFontInfo)
|
|
{
|
|
// East Asia wanted to do it per codepage.
|
|
//
|
|
// FUTURE: Bear in mind that this approach is bug-prone. Once there's
|
|
// any new FE font created with different metric from the existing one.
|
|
// Font scaling will not perform well or even broken for such font [wchao].
|
|
|
|
g_pFontInfo[iFont].ff.fScaleByCpg = fFEcpg;
|
|
|
|
if (fUIFont)
|
|
{
|
|
if (!g_pFontInfo[iFont].bSizeUI)
|
|
g_pFontInfo[iFont].bSizeUI = bSize;
|
|
else
|
|
// more than one legit size were updated per font,
|
|
// We fallback to the codepage-driven approach.
|
|
g_pFontInfo[iFont].ff.fScaleByCpg = g_pFontInfo[iFont].bSizeUI != bSize;
|
|
}
|
|
else
|
|
{
|
|
if (!g_pFontInfo[iFont].bSizeNonUI)
|
|
g_pFontInfo[iFont].bSizeNonUI = bSize;
|
|
else
|
|
g_pFontInfo[iFont].ff.fScaleByCpg = g_pFontInfo[iFont].bSizeNonUI != bSize;
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* GetFontLegitimateSize(iFont, fUIFont, iCharRep)
|
|
*
|
|
* @func
|
|
* Get the legitimate size (readable smallest size to use) of a given font
|
|
*
|
|
* @rdesc
|
|
* Legitimate size of font
|
|
*/
|
|
BYTE GetFontLegitimateSize(
|
|
LONG iFont, //@parm Font to get size for
|
|
BOOL fUIFont, //@parm TRUE if for UI font
|
|
int iCharRep) //@parm Char repertoire to use
|
|
{
|
|
BYTE bDefPaf;
|
|
SHORT iDefFont;
|
|
BYTE yHeight = 0;
|
|
|
|
if (iFont < g_cFontInfo && !g_pFontInfo[iFont].ff.fScaleByCpg)
|
|
yHeight = fUIFont ? g_pFontInfo[iFont].bSizeUI : g_pFontInfo[iFont].bSizeNonUI;
|
|
|
|
if (!yHeight && fc().GetInfoFlags(iFont).fNonBiDiAscii)
|
|
{
|
|
// Non-BiDi ASCII font uses table font (of the same charset) legitimate height
|
|
QWORD qwFontSig = GetFontSignatureFromFace(iFont) & ~(FASCII | FFE);
|
|
LONG iCharRepT = GetFirstAvailCharRep(qwFontSig);
|
|
|
|
if(W32->GetPreferredFontInfo(iCharRepT, fUIFont ? true : false, iDefFont, yHeight, bDefPaf))
|
|
{
|
|
SetFontLegitimateSize(iFont, fUIFont, yHeight ? yHeight : fUIFont ? 8 : 10,
|
|
IsFECharRep(iCharRepT));
|
|
}
|
|
}
|
|
|
|
if (!yHeight)
|
|
{
|
|
if (fc().GetInfoFlags(iFont).fThaiDTP)
|
|
{
|
|
iCharRep = THAI_INDEX;
|
|
fUIFont = FALSE;
|
|
}
|
|
W32->GetPreferredFontInfo(iCharRep, fUIFont ? true : false, iDefFont, yHeight, bDefPaf);
|
|
}
|
|
return yHeight ? yHeight : fUIFont ? 8 : 10;
|
|
}
|
|
|
|
/*
|
|
* GetTextCharsetInfoPri(hdc, pFontSig, dwFlags)
|
|
*
|
|
* @func
|
|
* Wrapper to GDI's GetTextCharsetInfo. This to handle BiDi old-style fonts
|
|
*
|
|
* @rdesc
|
|
* CharSet for info
|
|
*/
|
|
UINT GetTextCharsetInfoPri(
|
|
HDC hdc,
|
|
FONTSIGNATURE* pFontSig,
|
|
DWORD dwFlags)
|
|
{
|
|
#ifndef NOCOMPLEXSCRIPTS
|
|
OUTLINETEXTMETRICA otm;
|
|
INT uCharSet = -1;
|
|
|
|
if (pFontSig && GetOutlineTextMetricsA(hdc, sizeof(OUTLINETEXTMETRICA), &otm))
|
|
{
|
|
ZeroMemory (pFontSig, sizeof(FONTSIGNATURE));
|
|
|
|
switch (otm.otmfsSelection & 0xFF00)
|
|
{
|
|
case 0xB200: // Arabic Simplified
|
|
case 0xB300: // Arabic Traditional
|
|
case 0xB400: // Arabic Old UDF
|
|
uCharSet = ARABIC_CHARSET; break;
|
|
case 0xB100: // Hebrew Old style
|
|
uCharSet = HEBREW_CHARSET;
|
|
}
|
|
}
|
|
if (uCharSet == -1)
|
|
uCharSet = W32->GetTextCharsetInfo(hdc, pFontSig, dwFlags);
|
|
|
|
if (uCharSet == DEFAULT_CHARSET)
|
|
uCharSet = ANSI_CHARSET; // never return ambiguous
|
|
|
|
return (UINT)uCharSet;
|
|
#else
|
|
return DEFAULT_CHARSET;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* GetFontSignatureFromDC(hdc, &fNonBiDiAscii)
|
|
*
|
|
* @func
|
|
* Compute RichEdit font signature for font selected into hdc. Uses
|
|
* info from OS font signature
|
|
*
|
|
* @rdesc
|
|
* RichEdit font signature for font selected into hdc
|
|
*/
|
|
QWORD GetFontSignatureFromDC(
|
|
HDC hdc,
|
|
BOOL & fNonBiDiAscii)
|
|
{
|
|
union
|
|
{ // Endian-dependent way of
|
|
QWORD qwFontSig; // avoiding 64-bit shifts
|
|
DWORD dwFontSig[2];
|
|
};
|
|
|
|
#ifndef NOCOMPLEXSCRIPTS
|
|
|
|
// Try to get FONTSIGNATURE data
|
|
CHARSETINFO csi;
|
|
UINT uCharSet = GetTextCharsetInfoPri(hdc, &(csi.fs), 0);
|
|
DWORD dwUsb0 = 0;
|
|
DWORD dwUsb2 = 0;
|
|
if(!W32->OnWin9x())
|
|
{
|
|
dwUsb0 = csi.fs.fsUsb[0];
|
|
dwUsb2 = csi.fs.fsUsb[2];
|
|
}
|
|
|
|
if ((csi.fs.fsCsb[0] | dwUsb0 | dwUsb2) ||
|
|
TranslateCharsetInfo((DWORD *)(DWORD_PTR)uCharSet, &csi, TCI_SRCCHARSET))
|
|
{
|
|
DWORD fsCsb0 = csi.fs.fsCsb[0];
|
|
CUniscribe * pusp;
|
|
SCRIPT_CACHE sc = NULL;
|
|
WORD wGlyph;
|
|
|
|
qwFontSig = ((fsCsb0 & 0x1FF) << 8) // Shift left since we use
|
|
| ((fsCsb0 & 0x1F0000) << 3); // low byte for fBiDi, etc.
|
|
// Also look at Unicode subrange if available
|
|
// FUTURE: we may want to drive Unicode ranges with a
|
|
// table approach, i.e., use for loop shifting dwUsb0 right
|
|
// to convert each bit into an index into a table of BYTEs
|
|
// that return the appropriate script index for rgCpgCharSet:
|
|
//
|
|
// for(LONG i = 0; dwUsb0; dwUsb0 >>= 1, i++)
|
|
// {
|
|
// static const BYTE rgiCharRep[32] = {...};
|
|
// if(dwUsb0 & 1)
|
|
// dwFontSig |= FontSigFromCharRep(rgiCharRep[i]);
|
|
// }
|
|
if(dwUsb0)
|
|
{
|
|
if (dwUsb0 & 0x00000400)
|
|
qwFontSig |= FARMENIAN;
|
|
|
|
Assert(FDEVANAGARI == 0x0000000800000000);
|
|
dwFontSig[1] |= (dwUsb0 & 0x00FF8000) >> 12; // 9 Indic scripts
|
|
|
|
if (dwUsb0 & 0x02000000)
|
|
qwFontSig |= FLAO;
|
|
|
|
if (dwUsb0 & 0x04000000)
|
|
qwFontSig |= FGEORGIAN;
|
|
|
|
if (dwUsb0 & 0x10000000)
|
|
qwFontSig |= FJAMO;
|
|
}
|
|
|
|
// The new Unicode 3.0 scripts are defined by dwUsb2 as follows
|
|
// (see \\sparrow\sysnls\nlsapi\font-sig.txt):
|
|
// 128 32 Script
|
|
//----------------------
|
|
// 70 6 Tibetan
|
|
// 71 7 Syriac
|
|
// 72 8 Thaana
|
|
// 73 9 Sinhala
|
|
// 74 10 Myanmar
|
|
// 75 11 Ethiopic
|
|
// 76 12 Cherokee
|
|
// 77 13 Canadian Aboriginal Syllabics
|
|
// 78 14 Ogham
|
|
// 79 15 Runic
|
|
// 80 16 Khmer
|
|
// 81 17 Mongolian
|
|
// 82 18 Braille
|
|
// 83 19 Yi
|
|
if(dwUsb2 & 0xFFFC0) // Bits 6 - 19
|
|
{
|
|
if(dwUsb2 & 0x40) // Bit 6 of dwUsb[2]
|
|
dwFontSig[1] |= FTIBETAN > 32; // is Tibetan
|
|
|
|
dwFontSig[1] |= (dwUsb2 & 0x180) >> 6; // Syriac (7), Thaana (8)
|
|
|
|
if(dwUsb2 & 0x200) // Bit 9 of dwUsb[2]
|
|
dwFontSig[1] |= FSINHALA > 32; // is Sinhala
|
|
|
|
if(dwUsb2 & 0x400) // Bit 10 of dwUsb[2]
|
|
dwFontSig[1] |= FMYANMAR > 32; // is Myanmar
|
|
|
|
dwFontSig[1] |= (dwUsb2 & 0xFF800) << 6;// Bits 11-19 of dwUsb[2]
|
|
}
|
|
if((qwFontSig & FCOMPLEX_SCRIPT) && !(qwFontSig & FHILATIN1)
|
|
&& (pusp = GetUniscribe()))
|
|
{
|
|
// Signature says no Latin-1 support
|
|
|
|
// Search for the 'a' and '0' glyph in the font to
|
|
// determine if the font supports ASCII or European
|
|
// Digit. This is necessary to overcome the font having
|
|
// an incomplete font signature.
|
|
if(ScriptGetCMap(hdc, &sc, L"a", 1, 0, &wGlyph) == S_OK)
|
|
qwFontSig |= FASCIIUPR;
|
|
|
|
if(ScriptGetCMap(hdc, &sc, L"0", 1, 0, &wGlyph) == S_OK)
|
|
qwFontSig |= FBELOWX40;
|
|
|
|
if(!IsBiDiCharSet(uCharSet) &&
|
|
(qwFontSig & FASCII) == FASCII)
|
|
fNonBiDiAscii = TRUE; // Non-BiDi ASCII font
|
|
|
|
ScriptFreeCache(&sc);
|
|
}
|
|
|
|
if (qwFontSig & FHILATIN1)
|
|
qwFontSig |= FASCII; // FLATIN1 has 3 bits
|
|
|
|
// HACK for symbol font. We assign FSYMBOL for Symbol font signature.
|
|
// REVIEW: should we just use csi.fs.fsCsb[0] bit 31 for symbol bit?
|
|
if (uCharSet == SYMBOL_CHARSET && !qwFontSig || fsCsb0 & 0x80000000)
|
|
qwFontSig = FSYMBOL;
|
|
}
|
|
else // No font signature info
|
|
qwFontSig = FontSigFromCharRep(CharRepFromCharSet(uCharSet));
|
|
|
|
#else
|
|
qwFontSig = FLATIN1; // Default Latin1
|
|
#endif // NOCOMPLEXSCRIPTS
|
|
|
|
return qwFontSig;
|
|
}
|
|
|
|
/*
|
|
* GetFontSignatureFromFace(iFont, pqwFontSig)
|
|
*
|
|
* @func
|
|
* Giving font signature matching the index of given facename.
|
|
* This signature may not match the one in Cccs since this is the
|
|
* signature of the font of given facename. The Cccs one is
|
|
* per GDI realization.
|
|
*
|
|
* @rdesc
|
|
* - font signature if pqwFontSig is NULL.
|
|
* - If pqwFontSig != NULL. It's a boolean.
|
|
* ZERO means returned signature is not sensible by following reasons
|
|
* 1. Bad facename (junk like "!@#$" or name that doesnt exist in the system)
|
|
* 2. Given face doesnt support even one valid ANSI codepage (symbol fonts,
|
|
* e.g., Marlett)
|
|
*/
|
|
QWORD GetFontSignatureFromFace(
|
|
int iFont,
|
|
QWORD * pqwFontSig)
|
|
{
|
|
Assert((unsigned)iFont < (unsigned)g_cFontInfo);
|
|
|
|
FONTINFO_FLAGS ff;
|
|
QWORD qwFontSig = g_pFontInfo[iFont].qwFontSig;
|
|
ff.wFlags = g_pFontInfo[iFont].ff.wFlags;
|
|
|
|
if(!ff.fCached)
|
|
{
|
|
int i = 0;
|
|
HDC hdc = GetDC(NULL);
|
|
LOGFONT lf;
|
|
WCHAR* pwchTag = lf.lfFaceName;
|
|
|
|
ZeroMemory(&lf, sizeof(LOGFONT));
|
|
|
|
wcscpy(lf.lfFaceName, GetFontName(iFont));
|
|
|
|
// Exclude Win95's tag name e.g. "Arial(Greek)"
|
|
while (pwchTag[i] && pwchTag[i] != '(')
|
|
i++;
|
|
if(pwchTag[i] && i > 0)
|
|
{
|
|
while (i > 0 && pwchTag[i-1] == 0x20)
|
|
i--;
|
|
pwchTag[i] = 0;
|
|
}
|
|
|
|
lf.lfCharSet = DEFAULT_CHARSET;
|
|
|
|
// Obtain a charset supported by given facename
|
|
// to force GDI gives facename priority over charset.
|
|
W32->GetFacePriCharSet(hdc, &lf);
|
|
|
|
HFONT hfont = CreateFontIndirect(&lf);
|
|
if(hfont)
|
|
{
|
|
HFONT hfontOld = SelectFont(hdc, hfont);
|
|
WCHAR szNewFaceName[LF_FACESIZE];
|
|
|
|
GetTextFace(hdc, LF_FACESIZE, szNewFaceName);
|
|
|
|
if(!wcsicmp(szNewFaceName, lf.lfFaceName) || // Got it
|
|
((GetCharFlags(szNewFaceName, 2) & FFE) && // or Get back FE font name for English name
|
|
(GetCharFlags(lf.lfFaceName, 2) & FASCII)))// because NT5 supports dual font names.
|
|
{
|
|
BOOL fNonBiDiAscii = FALSE;
|
|
qwFontSig = GetFontSignatureFromDC(hdc, fNonBiDiAscii);
|
|
if(fNonBiDiAscii)
|
|
ff.fNonBiDiAscii = TRUE;
|
|
}
|
|
else
|
|
ff.fBadFaceName = TRUE;
|
|
|
|
TEXTMETRIC tm;
|
|
|
|
GetTextMetrics(hdc, &tm);
|
|
ff.fTrueType = tm.tmPitchAndFamily & TMPF_TRUETYPE ? 1 : 0;
|
|
ff.fBitmap = tm.tmPitchAndFamily & (TMPF_TRUETYPE | TMPF_VECTOR | TMPF_DEVICE) ? 0 : 1;
|
|
|
|
if(!ff.fBadFaceName && qwFontSig & FTHAI)
|
|
{
|
|
// Some heuristic test on Thai fonts.
|
|
// Most Thai fonts will fall to this category currently except for
|
|
// Tahoma and Microsoft Sans Serif.
|
|
ff.fThaiDTP = tm.tmDescent && tm.tmAscent/tm.tmDescent < 3;
|
|
}
|
|
SelectObject(hdc, hfontOld);
|
|
SideAssert(DeleteObject(hfont));
|
|
}
|
|
ReleaseDC(NULL, hdc);
|
|
|
|
// Cache code pages supported by this font
|
|
ff.fCached = TRUE;
|
|
g_pFontInfo[iFont].qwFontSig |= qwFontSig;
|
|
g_pFontInfo[iFont].ff.wFlags = ff.wFlags;
|
|
}
|
|
|
|
if (!pqwFontSig)
|
|
return qwFontSig;
|
|
|
|
*pqwFontSig = qwFontSig;
|
|
|
|
// 22-29 are reserved for alternate ANSI/OEM, as of now we use 21, 22 for Devanagari and Tamil
|
|
return qwFontSig && !ff.fBadFaceName;
|
|
}
|
|
|
|
/*
|
|
* FreeFontNames()
|
|
*
|
|
* @func
|
|
* Free fontnames given by g_pFontInfo[i].szFontName allocated by
|
|
* GetFontNameIndex() as well as g_pFontInfo itself.
|
|
*/
|
|
void FreeFontNames()
|
|
{
|
|
for(LONG i = cfontsDflt; i < g_cFontInfo; i++)
|
|
FreePv((LPVOID)g_pFontInfo[i].szFontName);
|
|
FreePv(g_pFontInfo);
|
|
g_pFontInfo = NULL;
|
|
}
|
|
|
|
SHORT g_iFontJapanese;
|
|
SHORT g_iFontHangul;
|
|
SHORT g_iFontBig5;
|
|
SHORT g_iFontGB2312;
|
|
|
|
/*
|
|
* InitFontCache()
|
|
*
|
|
* @func
|
|
* Initializes font cache.
|
|
*
|
|
* @devnote
|
|
* This is exists so reinit.cpp doesn't have to know all about the
|
|
* font cache.
|
|
*/
|
|
void InitFontCache()
|
|
{
|
|
g_fc = new CFontCache;
|
|
g_fc->Init();
|
|
}
|
|
|
|
/*
|
|
* FreeFontCache()
|
|
*
|
|
* @mfunc
|
|
* Frees font cache.
|
|
*
|
|
* @devnote
|
|
* This is exists so reinit.cpp doesn't have to know all about the
|
|
* font cache.
|
|
*/
|
|
void FreeFontCache()
|
|
{
|
|
for (int i = 0; i < g_cFontInfo; i++)
|
|
delete g_pFontInfo[i]._pffm;
|
|
|
|
delete g_fc;
|
|
g_fc = NULL;
|
|
FreeFontNames();
|
|
}
|
|
|
|
/*
|
|
* CFontCache & fc()
|
|
*
|
|
* @func
|
|
* initialize the global g_fc.
|
|
* @comm
|
|
* current #defined to store 16 logical fonts and
|
|
* respective character widths.
|
|
*/
|
|
CFontCache & fc()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "fc");
|
|
return *g_fc;
|
|
}
|
|
|
|
FONTINFO_FLAGS CFontCache::GetInfoFlags(int ifont)
|
|
{
|
|
if (!g_pFontInfo[ifont].ff.fCached)
|
|
GetFontSignatureFromFace(ifont);
|
|
|
|
return g_pFontInfo[ifont].ff;
|
|
}
|
|
|
|
CFontFamilyMgr::~CFontFamilyMgr()
|
|
{
|
|
for (int i = 0; i < _rgf.Count(); i++)
|
|
{
|
|
CFontFamilyMember *pf = _rgf.Elem(i);
|
|
pf->Free();
|
|
}
|
|
}
|
|
|
|
CFontFamilyMember* CFontFamilyMgr::GetFontFamilyMember(LONG weight, BOOL fItalic)
|
|
{
|
|
for (int i = 0; i < _rgf.Count(); i++)
|
|
{
|
|
CFontFamilyMember *pf = _rgf.Elem(i);
|
|
if (pf->_weight == weight && pf->_fItalic == fItalic)
|
|
return pf;
|
|
}
|
|
|
|
CFontFamilyMember f(weight, fItalic);
|
|
CFontFamilyMember *pf = _rgf.Add(1, 0);
|
|
*pf = f;
|
|
return pf;
|
|
}
|
|
|
|
CKernCache * CFontCache::GetKernCache(LONG iFont, LONG weight, BOOL fItalic)
|
|
{
|
|
if (!g_fc->GetInfoFlags(iFont).fTrueType)
|
|
return 0;
|
|
CFontFamilyMgr *pffm = GetFontFamilyMgr(iFont);
|
|
CFontFamilyMember *pf = pffm->GetFontFamilyMember(weight, fItalic);
|
|
return pf->GetKernCache();
|
|
}
|
|
|
|
CFontFamilyMgr* CFontCache::GetFontFamilyMgr(LONG iFont)
|
|
{
|
|
if (!g_pFontInfo[iFont]._pffm)
|
|
g_pFontInfo[iFont]._pffm = new CFontFamilyMgr();
|
|
|
|
return g_pFontInfo[iFont]._pffm;
|
|
}
|
|
|
|
|
|
// =================================== CFontCache ====================================
|
|
/*
|
|
* CFontCache::Init()
|
|
*
|
|
* @mfunc
|
|
* Initializes font cache.
|
|
*
|
|
* @devnote
|
|
* This is not a constructor because something bad seems to happen
|
|
* if we try to construct a global object.
|
|
*/
|
|
void CFontCache::Init()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CFontCache::CFontCache");
|
|
|
|
_dwAgeNext = 0;
|
|
}
|
|
|
|
/*
|
|
* CFontCache::MakeHashKey(pCF)
|
|
*
|
|
* @mfunc
|
|
* Build a hash key for quick searches for a CCcs matching
|
|
* the pCF.
|
|
* Format:
|
|
* iFont : 14
|
|
* Bold/Italic : 2
|
|
* Height : 16
|
|
*
|
|
*/
|
|
CCSHASHKEY CFontCache::MakeHashKey(
|
|
const CCharFormat *pCF)
|
|
{
|
|
CCSHASHKEY ccshashkey;
|
|
ccshashkey = pCF->_iFont | ((pCF->_dwEffects & 3) << 14);
|
|
ccshashkey |= pCF->_yHeight << 16;
|
|
return ccshashkey;
|
|
}
|
|
|
|
/*
|
|
* CFontCache::GetCcs(pCF, dvpInch, dwFlags, hdc)
|
|
*
|
|
* @mfunc
|
|
* Search the font cache for a matching logical font and return it.
|
|
* If a match is not found in the cache, create one.
|
|
*
|
|
* @rdesc
|
|
* A logical font matching the given CHARFORMAT info.
|
|
*
|
|
* @devnote
|
|
* The calling chain must be protected by a CLock, since this present
|
|
* routine access the global (shared) FontCache facility.
|
|
*/
|
|
CCcs* CFontCache::GetCcs(
|
|
CCharFormat *pCF, //@parm Logical font (routine is allowed to change it)
|
|
const LONG dvpInch, //@parm Y pixels per inch
|
|
DWORD dwFlags, //@parm flags
|
|
HDC hdc) //@parm HDC font is to be created for
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CFontCache::GetCcs");
|
|
// display font
|
|
const CCcs * const pccsMost = &_rgccs[FONTCACHESIZE - 1];
|
|
CCcs * pccs;
|
|
CCSHASHKEY ccshashkey;
|
|
int iccsHash;
|
|
|
|
if (dwFlags & FGCCSUSETRUETYPE)
|
|
{
|
|
//On Win '9x Thai/Vietnamese, you cannot force truetype fonts! Therefore,
|
|
//we will force Tahoma if the font doesn't support the right charset.
|
|
if (W32->OnWin9x())
|
|
{
|
|
UINT acp = GetACP();
|
|
if (acp == 1258 || acp == 874)
|
|
{
|
|
QWORD qwFontSig = GetFontSignatureFromFace(pCF->_iFont);
|
|
if (pCF->_iCharRep == THAI_INDEX && (qwFontSig & FTHAI) == 0 ||
|
|
pCF->_iCharRep == VIET_INDEX && (qwFontSig & FVIETNAMESE) == 0 ||
|
|
!g_fc->GetInfoFlags(pCF->_iFont).fTrueType)
|
|
{
|
|
pCF->_iFont = GetFontNameIndex(szTahoma);
|
|
}
|
|
}
|
|
}
|
|
else if (!g_fc->GetInfoFlags(pCF->_iFont).fTrueType)
|
|
dwFlags |= FGCCSUSETRUETYPE;
|
|
}
|
|
|
|
if (hdc == NULL)
|
|
hdc = W32->GetScreenDC();
|
|
|
|
// Change _yHeight in the case of sub/superscript
|
|
if(pCF->_dwEffects & (CFE_SUPERSCRIPT | CFE_SUBSCRIPT))
|
|
pCF->_yHeight = 2 * pCF->_yHeight / 3;
|
|
|
|
//Convert CCharFormat into logical units (round)
|
|
pCF->_yHeight = (pCF->_yHeight * dvpInch + LY_PER_INCH / 2) / LY_PER_INCH;
|
|
if (pCF->_yHeight == 0)
|
|
pCF->_yHeight = 1;
|
|
|
|
if ((dwFlags & FGCCSUSEATFONT) && !IsFECharRep(pCF->_iCharRep))
|
|
{
|
|
QWORD qwFontSig = GetFontSignatureFromFace(pCF->_iFont);
|
|
|
|
if (!(qwFontSig & FFE)) // No At font for non-FE charset and
|
|
dwFlags &= ~FGCCSUSEATFONT; // font signature doesen't support FE
|
|
}
|
|
|
|
ccshashkey = MakeHashKey(pCF);
|
|
|
|
// Check our hash before going sequential.
|
|
iccsHash = ccshashkey % CCSHASHSEARCHSIZE;
|
|
if(ccshashkey == quickHashSearch[iccsHash].ccshashkey)
|
|
{
|
|
pccs = quickHashSearch[iccsHash].pccs;
|
|
if(pccs && pccs->_fValid)
|
|
{
|
|
if(pccs->Compare(pCF, hdc, dwFlags))
|
|
goto matched;
|
|
}
|
|
}
|
|
else //Setup this hash hint for next time
|
|
quickHashSearch[iccsHash].ccshashkey = ccshashkey;
|
|
|
|
|
|
// Sequentially search ccs for same character format
|
|
for(pccs = &_rgccs[0]; pccs <= pccsMost; pccs++)
|
|
{
|
|
if(pccs->_ccshashkey == ccshashkey && pccs->_fValid)
|
|
{
|
|
if(!pccs->Compare(pCF, hdc, dwFlags))
|
|
continue;
|
|
|
|
quickHashSearch[iccsHash].pccs = pccs;
|
|
|
|
matched:
|
|
//$ FUTURE: make this work even with wrap around of dwAgeNext
|
|
// Mark as most recently used if it isn't already in use.
|
|
if(pccs->_dwAge != _dwAgeNext - 1)
|
|
pccs->_dwAge = _dwAgeNext++;
|
|
pccs->_cRefs++; // bump up ref. count
|
|
return pccs;
|
|
}
|
|
}
|
|
|
|
// We did not find a match: init a new font cache.
|
|
pccs = GrabInitNewCcs(pCF, hdc, dwFlags);
|
|
quickHashSearch[iccsHash].pccs = pccs;
|
|
pccs->_ccshashkey = ccshashkey;
|
|
return pccs;
|
|
}
|
|
|
|
/*
|
|
* CFontCache::GrabInitNewCcs(pCF, hdc, dwFlags)
|
|
*
|
|
* @mfunc
|
|
* Create a logical font and store it in our cache.
|
|
*
|
|
* @rdesc
|
|
* New CCcs created
|
|
*/
|
|
CCcs* CFontCache::GrabInitNewCcs(
|
|
const CCharFormat * const pCF, //@parm Description of desired logical font
|
|
HDC hdc,
|
|
DWORD dwFlags)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CFontCache::GrabInitNewCcs");
|
|
|
|
DWORD dwAgeOldest = 0xffffffff;
|
|
CCcs * pccs;
|
|
const CCcs * const pccsMost = &_rgccs[FONTCACHESIZE - 1];
|
|
CCcs * pccsOldest = NULL;
|
|
|
|
// Look for unused entry and oldest in use entry
|
|
for(pccs = &_rgccs[0]; pccs <= pccsMost && pccs->_fValid; pccs++)
|
|
if(pccs->_cRefs == 0 && pccs->_dwAge < dwAgeOldest)
|
|
{
|
|
dwAgeOldest = pccs->_dwAge;
|
|
pccsOldest = pccs;
|
|
}
|
|
|
|
if(pccs > pccsMost) // Didn't find an unused entry, use oldest entry
|
|
{
|
|
pccs = pccsOldest;
|
|
if(!pccs)
|
|
{
|
|
AssertSz(FALSE, "CFontCache::GrabInitNewCcs oldest entry is NULL");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
// Initialize new CCcs
|
|
pccs->_hdc = hdc;
|
|
pccs->_fFECharSet = IsFECharRep(pCF->_iCharRep);
|
|
pccs->_fUseAtFont = (dwFlags & FGCCSUSEATFONT) != 0;
|
|
pccs->_tflow = dwFlags & 0x3;
|
|
if(!pccs->Init(pCF))
|
|
return NULL;
|
|
|
|
pccs->_cRefs++;
|
|
return pccs;
|
|
}
|
|
|
|
// ============================= CCcs class ===================================================
|
|
/*
|
|
* BOOL CCcs::Init(pCF)
|
|
*
|
|
* @mfunc
|
|
* Init one font cache object. The global font cache stores
|
|
* individual CCcs objects.
|
|
*/
|
|
BOOL CCcs::Init (
|
|
const CCharFormat * const pCF) //@parm description of desired logical font
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CCcs::Init");
|
|
|
|
if(_fValid)
|
|
Free(); // recycle already in-use fonts.
|
|
|
|
if(MakeFont(pCF))
|
|
{
|
|
_iFont = pCF->_iFont;
|
|
_dwAge = g_fc->_dwAgeNext++;
|
|
_fValid = TRUE; // successfully created a new font cache.
|
|
}
|
|
return _fValid;
|
|
}
|
|
|
|
/*
|
|
* void CCcs::Free()
|
|
*
|
|
* @mfunc
|
|
* Free any dynamic memory allocated by an individual font's cache.
|
|
*/
|
|
void CCcs::Free()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CCcs::Free");
|
|
|
|
Assert(_fValid);
|
|
|
|
_widths.Free();
|
|
|
|
if(_hfont)
|
|
{
|
|
DestroyFont();
|
|
if (_fCustomTextOut)
|
|
g_pcto->NotifyDestroyFont(_hfont);
|
|
}
|
|
|
|
#ifndef NOCOMPLEXSCRIPTS
|
|
if (_sc && g_pusp)
|
|
ScriptFreeCache(&_sc);
|
|
#endif
|
|
|
|
_fValid = FALSE;
|
|
_cRefs = 0;
|
|
}
|
|
|
|
/*
|
|
* CCcs::BestCharRep(iCharRep, iCharRepDefault, fFontMatching)
|
|
*
|
|
* @mfunc
|
|
* This function returns the best charset that the currently selected font
|
|
* is capable of rendering. If the currently selected font cannot support
|
|
* the requested charset, then the function returns bCharSetDefault, which
|
|
* is generally taken from the charformat.
|
|
*
|
|
* @rdesc
|
|
* The closest charset to bCharSet that can be rendered by the current
|
|
* font.
|
|
*
|
|
* @devnote
|
|
* Currently this function is only used with plain text, however I don't
|
|
* believe there is any special reason it couldn't be used to improve
|
|
* rendering of rich text as well.
|
|
*/
|
|
BYTE CCcs::BestCharRep(
|
|
BYTE iCharRep,
|
|
BYTE iCharRepDefault,
|
|
int fFontMatching)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CCcs::BestCharSet");
|
|
|
|
// Does desired charset match currently selected charset or is it
|
|
// supported by the currently selected font?
|
|
if((iCharRep != CharRepFromCharSet(_bCharSet) || !iCharRep) &&
|
|
(fFontMatching == MATCH_CURRENT_CHARSET || !(_qwFontSig & FontSigFromCharRep(iCharRep))))
|
|
{
|
|
// If desired charset is not selected and we can't switch to it,
|
|
// switch to fallback charset (probably from backing store).
|
|
return iCharRepDefault;
|
|
}
|
|
|
|
// We already match desired charset, or it is supported by the font.
|
|
// Either way, we can just return the requested charset.
|
|
return iCharRep;
|
|
}
|
|
|
|
|
|
/*
|
|
* CCcs::FillWidth (ch, &dup)
|
|
*
|
|
* @mfunc
|
|
* Fill in width for given character. Sometimes we don't
|
|
* call the OS for the certain characters because fonts have bugs.
|
|
*
|
|
* @rdesc
|
|
* TRUE if OK, FALSE if failed
|
|
*/
|
|
BOOL CCcs::FillWidth(
|
|
WCHAR ch, //@parm WCHAR character we need a width for.
|
|
LONG &dup) //@parm the width of the character
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CCcs::FillWidth");
|
|
AssertSz(_hfont, "CCcs::Fill - CCcs has no font");
|
|
dup = 0;
|
|
WCHAR chWidth = ch;
|
|
|
|
HFONT hfontOld = SelectFont(_hdc, _hfont);
|
|
|
|
BOOL fLookaside = _widths.FLookasideCharacter(ch);
|
|
|
|
if (fLookaside)
|
|
chWidth = 0x4E00;
|
|
else switch(ch)
|
|
{
|
|
case NBHYPHEN:
|
|
case SOFTHYPHEN:
|
|
chWidth = '-';
|
|
break;
|
|
|
|
case NBSPACE:
|
|
chWidth = ' ';
|
|
break;
|
|
|
|
case EMSPACE:
|
|
chWidth = EMDASH;
|
|
break;
|
|
|
|
case ENSPACE:
|
|
chWidth = ENDASH;
|
|
break;
|
|
}
|
|
|
|
W32->REGetCharWidth(_hdc, chWidth, (INT*) &dup, _wCodePage, _fCustomTextOut);
|
|
|
|
dup -= _xOverhangAdjust;
|
|
if (dup <= 0)
|
|
dup = max(_xAveCharWidth, 1);
|
|
|
|
if (fLookaside)
|
|
_widths._dupCJK = dup;
|
|
else
|
|
{
|
|
CacheEntry *pWidthData = _widths.GetEntry(ch);
|
|
pWidthData->ch = ch;
|
|
pWidthData->width = dup;
|
|
}
|
|
|
|
SelectFont(_hdc, hfontOld);
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* BOOL CCcs::MakeFont(pCF)
|
|
*
|
|
* @mfunc
|
|
* Wrapper, setup for CreateFontIndirect() to create the font to be
|
|
* selected into the HDC.
|
|
*
|
|
* @devnote The pCF here is in logical units
|
|
*
|
|
* @rdesc
|
|
* TRUE if OK, FALSE if allocation failure
|
|
*/
|
|
BOOL CCcs::MakeFont(
|
|
const CCharFormat * const pCF) //@parm description of desired logical font
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CCcs::MakeFont");
|
|
LONG iFont = pCF->_iFont;
|
|
LOGFONT lf;
|
|
ZeroMemory(&lf, sizeof(lf));
|
|
|
|
_bCMDefault = pCF->_dwEffects & CFE_RUNISDBCS ? CVT_LOWBYTE : CVT_NONE;
|
|
|
|
_yHeightRequest = pCF->_yHeight;
|
|
_bCharSetRequest = CharSetFromCharRep(pCF->_iCharRep);
|
|
|
|
_fCustomTextOut = (pCF->_dwEffects & CFE_CUSTOMTEXTOUT) ? TRUE : FALSE;
|
|
|
|
lf.lfHeight = -_yHeightRequest;
|
|
|
|
if(pCF->_wWeight)
|
|
_weight = pCF->_wWeight;
|
|
else
|
|
_weight = (pCF->_dwEffects & CFE_BOLD) ? FW_BOLD : FW_NORMAL;
|
|
|
|
lf.lfWeight = _weight;
|
|
lf.lfItalic = _fItalic = (pCF->_dwEffects & CFE_ITALIC) != 0;
|
|
lf.lfCharSet = _bCMDefault == CVT_LOWBYTE ? ANSI_CHARSET : CharSetFromCharRep(pCF->_iCharRep);
|
|
if (lf.lfCharSet == PC437_CHARSET)
|
|
lf.lfCharSet = DEFAULT_CHARSET;
|
|
|
|
lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
|
|
|
|
if (_tflow)
|
|
lf.lfOrientation = lf.lfEscapement = (4 - _tflow) * 900;
|
|
|
|
#ifndef UNDER_CE
|
|
if (_fForceTrueType || _tflow && g_fc->GetInfoFlags(GetFontNameIndex(lf.lfFaceName)).fBitmap)
|
|
{
|
|
lf.lfOutPrecision = OUT_TT_ONLY_PRECIS;
|
|
if (!W32->OnWin9x() && g_fc->GetInfoFlags(iFont).fTrueType)
|
|
lf.lfOutPrecision = OUT_SCREEN_OUTLINE_PRECIS;
|
|
}
|
|
#endif
|
|
|
|
lf.lfClipPrecision = CLIP_DFA_OVERRIDE;
|
|
lf.lfPitchAndFamily = _bPitchAndFamily = pCF->_bPitchAndFamily;
|
|
lf.lfQuality = _bQuality = pCF->_bQuality;
|
|
|
|
#ifdef UNDER_CE
|
|
// DEBUGGGGGG for EBOOK!! Presumably this should be a registry setting
|
|
// that overrules DEFAULT_QUALITY (0) the way ANTIALIASED_QUALITY, etc., do
|
|
#ifndef CLEARTYPE_QUALITY
|
|
#define CLEARTYPE_QUALITY 5
|
|
#endif
|
|
lf.lfQuality = CLEARTYPE_QUALITY;
|
|
#endif
|
|
|
|
// If family is virtual BiDi family (FF_BIDI), replace by FF_ROMAN
|
|
if((lf.lfPitchAndFamily & 0xF0) == (FF_BIDI << 4))
|
|
lf.lfPitchAndFamily = (FF_ROMAN << 4) | (lf.lfPitchAndFamily & 0xF);
|
|
|
|
// If the run is DBCS, that means the font's codepage is not available in
|
|
// this system. Use the English ANSI codepage instead so we will display
|
|
// ANSI characters correctly. NOTE: _wCodePage is only used for Win95.
|
|
_wCodePage = CodePageFromCharRep(CharRepFromCharSet(lf.lfCharSet));
|
|
|
|
wcscpy(lf.lfFaceName, GetFontName(iFont));
|
|
|
|
if (_fUseAtFont && lf.lfFaceName[0] != L'@')
|
|
{
|
|
wcscpy(&(lf.lfFaceName[1]), GetFontName(iFont));
|
|
lf.lfFaceName[0] = L'@';
|
|
}
|
|
// In BiDi system, always create ANSI bitmap font with system charset
|
|
BYTE bCharSetSys = W32->GetSysCharSet();
|
|
|
|
if (IsBiDiCharSet(bCharSetSys) && lf.lfCharSet == ANSI_CHARSET &&
|
|
fc().GetInfoFlags(iFont).fBitmap &&
|
|
!fc().GetInfoFlags(iFont).fBadFaceName)
|
|
lf.lfCharSet = bCharSetSys;
|
|
|
|
// Reader! A bundle of spagghetti code lies ahead of you!
|
|
// But go on boldly, for these spagghetti are seasoned with
|
|
// lots of comments, and ... good luck to you...
|
|
|
|
HFONT hfontOriginalCharset = NULL;
|
|
BYTE bCharSetOriginal = lf.lfCharSet;
|
|
WCHAR szNewFaceName[LF_FACESIZE];
|
|
|
|
if(pCF->_dwEffects & (CFE_BOLD | CFE_ITALIC))
|
|
iFont = -1; // Don't use cached font info unless
|
|
// normal font
|
|
GetFontWithMetrics(&lf, szNewFaceName);
|
|
|
|
if(0 != wcsicmp(szNewFaceName, lf.lfFaceName))
|
|
{
|
|
BOOL fCorrectFont = FALSE;
|
|
iFont = -1; // pCF->_iFont wasn't used
|
|
|
|
if(lf.lfCharSet == SYMBOL_CHARSET)
|
|
{
|
|
// #1. if the face changed, and the specified charset was SYMBOL,
|
|
// but the face name exists and suports ANSI, we give preference
|
|
// to the face name
|
|
|
|
lf.lfCharSet = ANSI_CHARSET;
|
|
|
|
hfontOriginalCharset = _hfont;
|
|
GetFontWithMetrics(&lf, szNewFaceName);
|
|
|
|
if(0 == wcsicmp(szNewFaceName, lf.lfFaceName))
|
|
// That's right, ANSI is the asnwer
|
|
fCorrectFont = TRUE;
|
|
else
|
|
// No, fall back by default; the charset we got was right
|
|
lf.lfCharSet = bCharSetOriginal;
|
|
}
|
|
else if(lf.lfCharSet == DEFAULT_CHARSET && _bCharSet == DEFAULT_CHARSET)
|
|
{
|
|
// #2. If we got the "default" font back, we don't know what it means
|
|
// (could be anything) so we veryfy that this guy's not SYMBOL
|
|
// (symbol is never default, but the OS could be lying to us!!!)
|
|
// we would like to veryfy more like whether it actually gave us
|
|
// Japanese instead of ANSI and labeled it "default"...
|
|
// but SYMBOL is the least we can do
|
|
|
|
lf.lfCharSet = SYMBOL_CHARSET;
|
|
wcscpy(lf.lfFaceName, szNewFaceName);
|
|
|
|
hfontOriginalCharset = _hfont;
|
|
GetFontWithMetrics(&lf, szNewFaceName);
|
|
|
|
if(0 == wcsicmp(szNewFaceName, lf.lfFaceName))
|
|
// That's right, it IS symbol!
|
|
// 'correct' the font to the 'true' one,
|
|
// and we'll get fMappedToSymbol
|
|
fCorrectFont = TRUE;
|
|
|
|
// Always restore the charset name, we didn't want to
|
|
// question the original choice of charset here
|
|
lf.lfCharSet = bCharSetOriginal;
|
|
}
|
|
else if(lf.lfCharSet == ARABIC_CHARSET || lf.lfCharSet == HEBREW_CHARSET)
|
|
{
|
|
DestroyFont();
|
|
wcscpy(lf.lfFaceName, szNewFaceName);
|
|
GetFontWithMetrics(&lf, szNewFaceName);
|
|
fCorrectFont = TRUE;
|
|
}
|
|
else if(_bConvertMode != CVT_LOWBYTE && IsFECharSet(lf.lfCharSet)
|
|
&& !OnWinNTFE() && !W32->OnWin9xFE())
|
|
{
|
|
const WCHAR *pch = NULL;
|
|
if(_bCharSet != lf.lfCharSet && W32->OnWin9x())
|
|
{
|
|
// On Win95 when rendering to PS driver, we'll get something
|
|
// other than what we asked. So try a known font we got from GDI
|
|
switch (lf.lfCharSet)
|
|
{
|
|
case CHINESEBIG5_CHARSET:
|
|
pch = GetFontName(g_iFontBig5);
|
|
break;
|
|
|
|
case SHIFTJIS_CHARSET:
|
|
pch = GetFontName(g_iFontJapanese);
|
|
break;
|
|
|
|
case HANGEUL_CHARSET:
|
|
pch = GetFontName(g_iFontHangul);
|
|
break;
|
|
|
|
case GB2312_CHARSET:
|
|
pch = GetFontName(g_iFontGB2312);
|
|
break;
|
|
}
|
|
}
|
|
else // FE Font (from Lang pack)
|
|
pch = szNewFaceName; // on a nonFEsystem
|
|
|
|
if(pch)
|
|
wcscpy(lf.lfFaceName, pch);
|
|
hfontOriginalCharset = _hfont;
|
|
|
|
GetFontWithMetrics(&lf, szNewFaceName);
|
|
|
|
if(0 == wcsicmp(szNewFaceName, lf.lfFaceName))
|
|
{
|
|
// That's right, it IS the FE font we want!
|
|
// 'correct' the font to the 'true' one.
|
|
fCorrectFont = TRUE;
|
|
if(W32->OnWin9x())
|
|
{
|
|
// Save up the GDI font names for later printing use
|
|
switch(lf.lfCharSet)
|
|
{
|
|
case CHINESEBIG5_CHARSET:
|
|
g_iFontBig5 = GetFontNameIndex(lf.lfFaceName);
|
|
break;
|
|
|
|
case SHIFTJIS_CHARSET:
|
|
g_iFontJapanese = GetFontNameIndex(lf.lfFaceName);
|
|
break;
|
|
|
|
case HANGEUL_CHARSET:
|
|
g_iFontHangul = GetFontNameIndex(lf.lfFaceName);
|
|
break;
|
|
|
|
case GB2312_CHARSET:
|
|
g_iFontGB2312 = GetFontNameIndex(lf.lfFaceName);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(hfontOriginalCharset)
|
|
{
|
|
// Either keep old font or new one
|
|
if(fCorrectFont)
|
|
{
|
|
SideAssert(DeleteObject(hfontOriginalCharset));
|
|
}
|
|
else
|
|
{
|
|
// Fall back to original font
|
|
DestroyFont();
|
|
_hfont = hfontOriginalCharset;
|
|
GetMetrics();
|
|
}
|
|
hfontOriginalCharset = NULL;
|
|
}
|
|
}
|
|
|
|
RetryCreateFont:
|
|
{
|
|
// Could be that we just plain simply get mapped to symbol.
|
|
// Avoid it
|
|
BOOL fMappedToSymbol = (_bCharSet == SYMBOL_CHARSET &&
|
|
lf.lfCharSet != SYMBOL_CHARSET);
|
|
|
|
BOOL fChangedCharset = (_bCharSet != lf.lfCharSet &&
|
|
lf.lfCharSet != DEFAULT_CHARSET);
|
|
|
|
if(fChangedCharset || fMappedToSymbol)
|
|
{
|
|
// Here, the system did not preserve the font language or mapped
|
|
// our non-symbol font onto a symbol font, which will look awful
|
|
// when displayed. Giving us a symbol font when we asked for a
|
|
// non-symbol font (default can never be symbol) is very bizarre
|
|
// and means that either the font name is not known or the system
|
|
// has gone complete nuts. The charset language takes priority
|
|
// over the font name. Hence, I would argue that nothing can be
|
|
// done to save the situation at this point, and we have to
|
|
// delete the font name and retry.
|
|
|
|
if (fChangedCharset && lf.lfCharSet == THAI_CHARSET && _bCharSet == ANSI_CHARSET)
|
|
{
|
|
// We have charset substitution entries in Thai platforms that
|
|
// will substitute all the core fonts with THAI_CHARSET to
|
|
// ANSI_CHARSET. This is because we dont have Thai in such fonts.
|
|
// Here we'll internally substitute the core font to Thai default
|
|
// font so it matches its underlying THAI_CHARSET request (wchao).
|
|
|
|
SHORT iDefFont;
|
|
BYTE yDefHeight;
|
|
BYTE bDefPaf;
|
|
|
|
W32->GetPreferredFontInfo(THAI_INDEX, TRUE, iDefFont, (BYTE&)yDefHeight, bDefPaf);
|
|
|
|
const WCHAR* szThaiDefault = GetFontName(iDefFont);
|
|
|
|
if (szThaiDefault)
|
|
{
|
|
DestroyFont();
|
|
wcscpy(lf.lfFaceName, szThaiDefault);
|
|
GetFontWithMetrics(&lf, szNewFaceName);
|
|
goto GetOutOfHere;
|
|
}
|
|
}
|
|
|
|
if(!wcsicmp(lf.lfFaceName, szFontOfChoice))
|
|
{
|
|
// We've been here already; no font with an appropriate
|
|
// charset is on the system. Try getting the ANSI one for
|
|
// the original font name. Next time around, we'll null
|
|
// out the name as well!!
|
|
if (lf.lfCharSet == ANSI_CHARSET)
|
|
{
|
|
TRACEINFOSZ("Asking for ANSI ARIAL and not getting it?!");
|
|
|
|
// Those Win95 guys have definitely outbugged me
|
|
goto GetOutOfHere;
|
|
}
|
|
|
|
DestroyFont();
|
|
wcscpy(lf.lfFaceName, GetFontName(pCF->_iFont));
|
|
lf.lfCharSet = ANSI_CHARSET;
|
|
}
|
|
else
|
|
{
|
|
DestroyFont();
|
|
wcscpy(lf.lfFaceName, szFontOfChoice);
|
|
}
|
|
GetFontWithMetrics(&lf, szNewFaceName);
|
|
goto RetryCreateFont;
|
|
}
|
|
}
|
|
|
|
GetOutOfHere:
|
|
if (hfontOriginalCharset)
|
|
SideAssert(DeleteObject(hfontOriginalCharset));
|
|
|
|
// If we're really really stuck, get system font and hope for the best
|
|
if(!_hfont)
|
|
{
|
|
iFont = IFONT_SYSTEM;
|
|
_hfont = W32->GetSystemFont();
|
|
}
|
|
|
|
// Cache essential FONTSIGNATURE and GetFontLanguageInfo() information
|
|
Assert(_hfont);
|
|
if(iFont >= 0) // Use cached value
|
|
_qwFontSig = GetFontSignatureFromFace(iFont, NULL);
|
|
|
|
if(_hfont && (iFont < 0 || _fCustomTextOut))
|
|
{
|
|
BOOL fNonBiDiAscii;
|
|
HFONT hfontOld = SelectFont(_hdc, _hfont);
|
|
|
|
if (_fCustomTextOut)
|
|
g_pcto->NotifyCreateFont(_hdc);
|
|
|
|
if(iFont < 0)
|
|
_qwFontSig = GetFontSignatureFromDC(_hdc, fNonBiDiAscii);
|
|
|
|
SelectFont(_hdc, hfontOld);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* HFONT CCcs::GetFontWithMetrics (plf, szNewFaceName)
|
|
*
|
|
* @mfunc
|
|
* Get metrics used by the measurer and renderer and the new face name.
|
|
*
|
|
* @rdesc
|
|
* HFONT if successful
|
|
*/
|
|
HFONT CCcs::GetFontWithMetrics (
|
|
LOGFONT *plf,
|
|
WCHAR * szNewFaceName)
|
|
{
|
|
_hfont = CreateFontIndirect(plf);
|
|
if(_hfont)
|
|
GetMetrics(szNewFaceName);
|
|
|
|
return (_hfont);
|
|
}
|
|
|
|
/*
|
|
* CCcs::GetOffset(pCF, dvpInch, pyOffset, pyAdjust);
|
|
*
|
|
* @mfunc
|
|
* Return the offset information for
|
|
*
|
|
* @comm
|
|
* Return the offset value (used in line height calculations)
|
|
* and the amount to raise or lower the text because of superscript
|
|
* or subscript considerations.
|
|
*/
|
|
void CCcs::GetOffset(
|
|
const CCharFormat * const pCF,
|
|
LONG dvpInch,
|
|
LONG * pyOffset,
|
|
LONG * pyAdjust)
|
|
{
|
|
*pyOffset = 0;
|
|
*pyAdjust = 0;
|
|
|
|
if (pCF->_yOffset)
|
|
*pyOffset = MulDiv(pCF->_yOffset, dvpInch, LY_PER_INCH);
|
|
|
|
if (pCF->_dwEffects & CFE_SUPERSCRIPT)
|
|
*pyAdjust = _yHeight * 2 / 5;
|
|
|
|
else if (pCF->_dwEffects & CFE_SUBSCRIPT)
|
|
*pyAdjust = -_yDescent * 3 / 5;
|
|
}
|
|
|
|
/*
|
|
* void CCcs::GetFontOverhang(pdupOverhang, pdupUnderhang)
|
|
*
|
|
* @mfunc
|
|
* Synthesize font overhang/underhang information.
|
|
* Only applies to italic fonts.
|
|
*/
|
|
void CCcs::GetFontOverhang(
|
|
LONG *pdupOverhang,
|
|
LONG *pdupUnderhang)
|
|
{
|
|
if(_fItalic)
|
|
{
|
|
*pdupOverhang = (_yHeight - _yDescent + 1) / 4;
|
|
*pdupUnderhang = (_yDescent + 1) / 4;
|
|
}
|
|
else
|
|
{
|
|
*pdupOverhang = 0;
|
|
*pdupUnderhang = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* BOOL CCcs::GetMetrics(szNewFaceName)
|
|
*
|
|
* @mfunc
|
|
* Get metrics used by the measurer and renderer.
|
|
*
|
|
* @rdesc
|
|
* TRUE if successful
|
|
*
|
|
* @comm
|
|
* These are in logical coordinates which are dependent
|
|
* on the mapping mode and font selected into the hdc.
|
|
*/
|
|
BOOL CCcs::GetMetrics(
|
|
WCHAR *szNewFaceName)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CCcs::GetMetrics");
|
|
AssertSz(_hfont, "No font has been created.");
|
|
|
|
if (szNewFaceName)
|
|
*szNewFaceName = 0;
|
|
|
|
HFONT hfontOld = SelectFont(_hdc, _hfont);
|
|
if(!hfontOld)
|
|
{
|
|
DestroyFont();
|
|
return FALSE;
|
|
}
|
|
|
|
if (szNewFaceName)
|
|
GetTextFace(_hdc, LF_FACESIZE, szNewFaceName);
|
|
|
|
TEXTMETRIC tm;
|
|
if(!GetTextMetrics(_hdc, &tm))
|
|
{
|
|
SelectFont(_hdc, hfontOld);
|
|
DestroyFont();
|
|
return FALSE;
|
|
}
|
|
|
|
// The metrics, in logical units, dependent on the map mode and font.
|
|
_yHeight = (SHORT) tm.tmHeight;
|
|
_yDescent = (SHORT) tm.tmDescent;
|
|
_xAveCharWidth = (SHORT) tm.tmAveCharWidth;
|
|
_xOverhangAdjust= (SHORT) tm.tmOverhang;
|
|
|
|
// If fixed pitch, the tm bit is clear
|
|
_fFixPitchFont = !(TMPF_FIXED_PITCH & tm.tmPitchAndFamily);
|
|
|
|
_bCharSet = tm.tmCharSet;
|
|
_fFECharSet = IsFECharSet(_bCharSet);
|
|
|
|
// Use convert-mode proposed by CF, for which we are creating the font and
|
|
// then tweak as necessary below.
|
|
_bConvertMode = _bCMDefault;
|
|
|
|
// If SYMBOL_CHARSET is used, use the A APIs with the low bytes of the
|
|
// characters in the run
|
|
if(_bCharSet == SYMBOL_CHARSET)
|
|
_bConvertMode = CVT_LOWBYTE;
|
|
|
|
else if (_bConvertMode == CVT_NONE)
|
|
_bConvertMode = W32->DetermineConvertMode(_hdc, tm.tmCharSet);
|
|
|
|
W32->CalcUnderlineInfo(_hdc, this, &tm);
|
|
|
|
SelectFont(_hdc, hfontOld);
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CCcs::DestroyFont()
|
|
*
|
|
* @mfunc
|
|
* Destroy font handle for this CCcs
|
|
*/
|
|
void CCcs::DestroyFont()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CCcs::DestroyFont");
|
|
|
|
// Clear out any old font
|
|
if(_hfont)
|
|
{
|
|
SideAssert(DeleteObject(_hfont));
|
|
_hfont = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CCcs::Compare (pCF, hdc, dwFlags)
|
|
*
|
|
* @mfunc
|
|
* Compares this font cache with the font properties of a
|
|
* given CHARFORMAT
|
|
|
|
* @devnote The pCF size here is in logical units
|
|
*
|
|
* @rdesc
|
|
* FALSE iff did not match exactly.
|
|
*/
|
|
BOOL CCcs::Compare (
|
|
const CCharFormat * const pCF, //@parm Description of desired font
|
|
HDC hdc,
|
|
DWORD dwFlags)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CCcs::Compare");
|
|
|
|
BYTE bCharSet = CharSetFromCharRep(pCF->_iCharRep);
|
|
BOOL result =
|
|
_iFont == pCF->_iFont &&
|
|
_weight == pCF->_wWeight &&
|
|
_fItalic == ((pCF->_dwEffects & CFE_ITALIC) != 0) &&
|
|
_hdc == hdc &&
|
|
_yHeightRequest == pCF->_yHeight &&
|
|
(_bCharSetRequest == bCharSet || _bCharSet == bCharSet
|
|
// || _qwFontSig & FontSigFromCharRep(pCF->_iCharRep)// FUTURE:
|
|
) && // ok except for codepage conversions (metafiles and Win9x)
|
|
_fCustomTextOut == ((pCF->_dwEffects & CFE_CUSTOMTEXTOUT) != 0) &&
|
|
_fForceTrueType == ((dwFlags & FGCCSUSETRUETYPE) != 0) &&
|
|
_fUseAtFont == ((dwFlags & FGCCSUSEATFONT) != 0) &&
|
|
_tflow == (dwFlags & 0x3) &&
|
|
_bPitchAndFamily == pCF->_bPitchAndFamily &&
|
|
(!(pCF->_dwEffects & CFE_RUNISDBCS) || _bConvertMode == CVT_LOWBYTE);
|
|
|
|
return result;
|
|
}
|
|
|
|
// ========================= WidthCache by jonmat =========================
|
|
/*
|
|
* CWidthCache::CheckWidth(ch, &dup)
|
|
*
|
|
* @mfunc
|
|
* Check to see if we have a width for a WCHAR character.
|
|
*
|
|
* @comm
|
|
* Used prior to calling FillWidth(). Since FillWidth
|
|
* may require selecting the map mode and font in the HDC,
|
|
* checking here first saves time.
|
|
*
|
|
* @comm
|
|
* Statistics are maintained to determine when to
|
|
* expand the cache. The determination is made after a constant
|
|
* number of calls in order to make calculations faster.
|
|
*
|
|
* @rdesc
|
|
* returns TRUE if we have the width of the given WCHAR.
|
|
*/
|
|
BOOL CWidthCache::CheckWidth (
|
|
const WCHAR ch, //@parm char, can be Unicode, to check width for
|
|
LONG & dup) //@parm Width of character
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CWidthCache::CheckWidth");
|
|
BOOL fExist;
|
|
|
|
// 30,000 FE characters all have the same width
|
|
if (FLookasideCharacter(ch))
|
|
{
|
|
dup = _dupCJK;
|
|
return dup != 0;
|
|
}
|
|
|
|
const CacheEntry * pWidthData = GetEntry ( ch );
|
|
|
|
fExist = (ch == pWidthData->ch // Have we fetched the width?
|
|
&& pWidthData->width); // only because we may have ch == 0.
|
|
|
|
dup = fExist ? pWidthData->width : 0;
|
|
|
|
if(!_fMaxPerformance) // if we have not grown to the max...
|
|
{
|
|
_accesses++;
|
|
if(!fExist) // Only interesting on collision.
|
|
{
|
|
if(0 == pWidthData->width) // Test width not ch, 0 is valid ch.
|
|
{
|
|
_cacheUsed++; // Used another entry.
|
|
AssertSz( _cacheUsed <= _cacheSize+1, "huh?");
|
|
}
|
|
else
|
|
_collisions++; // We had a collision.
|
|
|
|
if(_accesses >= PERFCHECKEPOCH)
|
|
CheckPerformance(); // After some history, tune cache.
|
|
}
|
|
}
|
|
#ifdef DEBUG // Continue to monitor performance
|
|
else
|
|
{
|
|
_accesses++;
|
|
if(!fExist) // Only interesting on collision.
|
|
{
|
|
if(0 == pWidthData->width) // Test width not ch, 0 is valid ch.
|
|
{
|
|
_cacheUsed++; // Used another entry.
|
|
AssertSz( _cacheUsed <= _cacheSize+1, "huh?");
|
|
}
|
|
else
|
|
_collisions++; // We had a collision.
|
|
}
|
|
|
|
if(_accesses > PERFCHECKEPOCH)
|
|
{
|
|
_accesses = 0;
|
|
_collisions = 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return fExist;
|
|
}
|
|
|
|
/*
|
|
* CWidthCache::CheckPerformance()
|
|
*
|
|
* @mfunc
|
|
* check performance and increase cache size if deemed necessary.
|
|
*
|
|
*/
|
|
void CWidthCache::CheckPerformance()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CWidthCache::CheckPerformance");
|
|
|
|
if(_fMaxPerformance) // Exit if already grown to our max.
|
|
return;
|
|
|
|
// Grow the cache when cacheSize > 0 && 75% utilized or approx 8%
|
|
// collision rate
|
|
if (_cacheSize > DEFAULTCACHESIZE && (_cacheSize >> 1) + (_cacheSize >> 2) < _cacheUsed ||
|
|
_collisions > 0 && _accesses / _collisions <= 12)
|
|
{
|
|
GrowCache( &_pWidthCache, &_cacheSize, &_cacheUsed );
|
|
}
|
|
_collisions = 0; // This prevents wraps but makes
|
|
_accesses = 0; // calc a local rate, not global.
|
|
|
|
if(_cacheSize >= maxCacheSize) // Note if we've max'ed out
|
|
_fMaxPerformance = TRUE;
|
|
|
|
AssertSz( _cacheSize <= maxCacheSize, "max must be 2^n-1");
|
|
AssertSz( _cacheUsed <= _cacheSize+1, "huh?");
|
|
}
|
|
|
|
/*
|
|
* CWidthCache::GrowCache(ppWidthCache, pCacheSize, pCacheUsed)
|
|
*
|
|
* @mfunc
|
|
* Exponentially expand the size of the cache.
|
|
*
|
|
* @comm
|
|
* The cache size must be of the form 2^n as we use a
|
|
* logical & to get the hash MOD by storing 2^n-1 as
|
|
* the size and using this as the modulo.
|
|
*
|
|
* @rdesc
|
|
* Returns TRUE if we were able to allocate the new cache.
|
|
* All in params are also out params.
|
|
*
|
|
*/
|
|
BOOL CWidthCache::GrowCache(
|
|
CacheEntry **ppWidthCache, //@parm cache
|
|
INT * pCacheSize, //@parm cache's respective size.
|
|
INT * pCacheUsed) //@parm cache's respective utilization.
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CWidthCache::GrowCache");
|
|
|
|
CacheEntry *pNewWidthCache, *pOldWidthCache, *pWidthData;
|
|
INT j, newCacheSize, newCacheUsed;
|
|
WCHAR ch;
|
|
|
|
j = *pCacheSize; // Allocate cache of 2^n.
|
|
newCacheSize = max ( INITIALCACHESIZE, (j << 1) + 1);
|
|
pNewWidthCache = (CacheEntry *)
|
|
PvAlloc( sizeof(CacheEntry) * (newCacheSize + 1 ), GMEM_ZEROINIT);
|
|
|
|
if(pNewWidthCache)
|
|
{
|
|
newCacheUsed = 0;
|
|
*pCacheSize = newCacheSize; // Update out params.
|
|
pOldWidthCache = *ppWidthCache;
|
|
*ppWidthCache = pNewWidthCache;
|
|
for (; j >= 0; j--) // Move old cache info to new.
|
|
{
|
|
ch = pOldWidthCache[j].ch;
|
|
if ( ch )
|
|
{
|
|
pWidthData = &pNewWidthCache [ch & newCacheSize];
|
|
if ( 0 == pWidthData->ch )
|
|
newCacheUsed++; // Used another entry.
|
|
pWidthData->ch = ch;
|
|
pWidthData->width = pOldWidthCache[j].width;
|
|
}
|
|
}
|
|
*pCacheUsed = newCacheUsed; // Update out param.
|
|
// Free old cache.
|
|
if (pOldWidthCache < &_defaultWidthCache[0] ||
|
|
pOldWidthCache >= &_defaultWidthCache[DEFAULTCACHESIZE+1])
|
|
{
|
|
FreePv(pOldWidthCache);
|
|
}
|
|
}
|
|
return NULL != pNewWidthCache;
|
|
}
|
|
|
|
|
|
/*
|
|
* CWidthCache::Free()
|
|
*
|
|
* @mfunc
|
|
* Free any dynamic memory allocated by the width cache and prepare
|
|
* it to be recycled.
|
|
*/
|
|
void CWidthCache::Free()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CWidthCache::Free");
|
|
|
|
_fMaxPerformance = FALSE;
|
|
_dupCJK = 0;
|
|
_cacheSize = DEFAULTCACHESIZE;
|
|
_cacheUsed = 0;
|
|
_collisions = 0;
|
|
_accesses = 0;
|
|
if(_pWidthCache != &_defaultWidthCache[0])
|
|
{
|
|
FreePv(_pWidthCache);
|
|
_pWidthCache = &_defaultWidthCache[0];
|
|
}
|
|
ZeroMemory(_pWidthCache, sizeof(CacheEntry)*(DEFAULTCACHESIZE + 1));
|
|
}
|
|
|
|
/*
|
|
* CWidthCache::CWidthCache()
|
|
*
|
|
* @mfunc
|
|
* Point the caches to the defaults.
|
|
*/
|
|
CWidthCache::CWidthCache()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CWidthCache::CWidthCache");
|
|
|
|
_pWidthCache = &_defaultWidthCache[0];
|
|
}
|
|
|
|
/*
|
|
* CWidthCache::~CWidthCache()
|
|
*
|
|
* @mfunc
|
|
* Free any allocated caches.
|
|
*/
|
|
CWidthCache::~CWidthCache()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSFONT, TRCSCOPEINTERN, "CWidthCache::~CWidthCache");
|
|
|
|
if (_pWidthCache != &_defaultWidthCache[0])
|
|
FreePv(_pWidthCache);
|
|
}
|
|
|