freetype.c File Reference

#include <win32k.h>
#include <freetype/internal/ftcalc.h>
#include <gdi/eng/floatobj.h>
#include "font.h"
#include "utils.h"
#include <debug.h>

Include dependency graph for freetype.c:

Go to the source code of this file.

Classes
struct	_FONTLINK
struct	_FONTLINK_ENTRY
struct	_FONTLINK_CHAIN
struct	FONT_NAMES

Macros
#define	NDEBUG
#define	FONTLINK_DEFAULT_CHAR   0x30FB
#define	_TMPF_VARIABLE_PITCH   TMPF_FIXED_PITCH
#define	EMUBOLD_NEEDED(original, request)    (((request) != FW_DONTCARE) && ((request) - (original) >= FW_BOLD - FW_MEDIUM))
#define	gmxWorldToDeviceDefault   gmxWorldToPageDefault
#define	ASSERT_FREETYPE_LOCK_HELD()    ASSERT(g_FreeTypeLock->Owner == KeGetCurrentThread())
#define	ASSERT_FREETYPE_LOCK_NOT_HELD()    ASSERT(g_FreeTypeLock->Owner != KeGetCurrentThread())
#define	IntLockFreeType()
#define	IntUnLockFreeType()
#define	MAX_FONT_CACHE   256
#define	CP_SYMBOL   42
#define	MAXTCIINDEX   32
#define	CP_OEMCP   1
#define	CP_MACCP   2
#define	SCALE_X(value)   ((FT_MulFix((value), XScale) + 32) >> 6)
#define	SCALE_Y(value)   ((FT_MulFix((value), YScale) + 32) >> 6)
#define	FM_SEL_USE_TYPO_METRICS   0x80
#define	GOT_PENALTY(name, value)   Penalty += (value)
#define	VALIGN_MASK   (TA_TOP | TA_BASELINE | TA_BOTTOM)
#define	STACK_TEXT_BUFFER_SIZE   512

Typedefs
typedef struct _FONTLINK	FONTLINK
typedef struct _FONTLINK *	PFONTLINK
typedef struct _FONTLINK_ENTRY	FONTLINK_ENTRY
typedef struct _FONTLINK_ENTRY *	PFONTLINK_ENTRY
typedef struct _FONTLINK_CHAIN	FONTLINK_CHAIN
typedef struct _FONTLINK_CHAIN *	PFONTLINK_CHAIN
typedef struct FONT_NAMES	FONT_NAMES
typedef struct FONT_NAMES *	LPFONT_NAMES

Functions
	DBG_DEFAULT_CHANNEL (GdiFont)
static	RTL_STATIC_LIST_HEAD (g_FontLinkEntries)
static NTSTATUS	FontLink_LoadSettings (VOID)
static NTSTATUS	FontLink_LoadDefaultFonts (VOID)
static NTSTATUS	FontLink_LoadDefaultCharset (VOID)
static VOID	FontLink_Destroy (_Inout_ PFONTLINK pLink)
static BOOL	FontLink_Chain_IsPopulated (const FONTLINK_CHAIN *pChain)
static	RTL_STATIC_LIST_HEAD (g_FontListHead)
static	RTL_STATIC_LIST_HEAD (g_FontCacheListHead)
BYTE FASTCALL	IntCharSetFromCodePage (UINT uCodePage)
static __inline VOID	FindBestFontFromList (FONTOBJ **FontObj, ULONG *MatchPenalty, const LOGFONTW *LogFont, const PLIST_ENTRY Head)
static BOOL	MatchFontName (PSHARED_FACE SharedFace, PUNICODE_STRING Name1, FT_UShort NameID, FT_UShort LangID)
static BOOL	FontLink_PrepareFontInfo (_Inout_ PFONTLINK pFontLink)
static	RTL_STATIC_LIST_HEAD (g_FontSubstListHead)
static void	SharedMem_AddRef (PSHARED_MEM Ptr)
static void	SharedFaceCache_Init (PSHARED_FACE_CACHE Cache)
static PSHARED_FACE	SharedFace_Create (FT_Face Face, PSHARED_MEM Memory)
static PSHARED_MEM	SharedMem_Create (PBYTE Buffer, ULONG BufferSize, BOOL IsMapping)
static void	SharedFace_AddRef (PSHARED_FACE Ptr)
static void	RemoveCachedEntry (PFONT_CACHE_ENTRY Entry)
static void	RemoveCacheEntries (FT_Face Face)
static void	SharedMem_Release (PSHARED_MEM Ptr)
static void	SharedFaceCache_Release (PSHARED_FACE_CACHE Cache)
static void	SharedFace_Release (PSHARED_FACE Ptr, BOOL bDoLock)
static VOID FASTCALL	CleanupFontEntryEx (PFONT_ENTRY FontEntry, PFONTGDI FontGDI)
static __inline VOID FASTCALL	CleanupFontEntry (PFONT_ENTRY FontEntry)
static __inline void	FTVectorToPOINTFX (FT_Vector *vec, POINTFX *pt)
static __inline FT_Fixed	FT_FixedFromFIXED (FIXED f)
BOOL FASTCALL	IntLoadFontSubstList (PLIST_ENTRY pHead)
static NTSTATUS	FontLink_AddEntry (LPCWSTR lfFaceName, PZZWSTR pszzFontLink)
static void	FontLink_DeleteEntries (VOID)
static NTSTATUS	FontLink_PopulateEntries (VOID)
BOOL FASTCALL	InitFontSupport (VOID)
VOID FASTCALL	FreeFontSupport (VOID)
static VOID FASTCALL	IntEscapeMatrix (FT_Matrix *pmat, LONG lfEscapement)
static VOID FASTCALL	IntMatrixFromMx (FT_Matrix *pmat, const MATRIX *pmx)
static BOOL	SubstituteFontByList (PLIST_ENTRY pHead, PUNICODE_STRING pOutputName, PUNICODE_STRING pInputName, BYTE RequestedCharSet, BYTE CharSetMap[FONTSUBST_FROM_AND_TO])
static BOOL	SubstituteFontRecurse (PLOGFONTW pLogFont)
static VOID	FontLink_Chain_Init (_Out_ PFONTLINK_CHAIN pChain, _Inout_ PTEXTOBJ pTextObj, _In_ FT_Face face)
static PFONTLINK	FontLink_Chain_FindLink (PFONTLINK_CHAIN pChain, PLOGFONTW plf)
static PFONTLINK	FontLink_Create (_Inout_ PFONTLINK_CHAIN pChain, _In_ const LOGFONTW *plfBase, _In_ LPCWSTR pszLink)
static PFONTLINK_ENTRY	FontLink_FindEntry (const LOGFONTW *pLogFont)
static NTSTATUS	FontLink_Chain_FindEntry (_Inout_ PFONTLINK_CHAIN pChain, _Inout_ PLOGFONTW pLF)
static NTSTATUS	FontLink_Chain_Populate (_Inout_ PFONTLINK_CHAIN pChain)
VOID FASTCALL	IntLoadSystemFonts (VOID)
UINT FASTCALL	IntGetCharSet (INT nIndex, FT_ULong CodePageRange1)
static BOOL	select_charmap (FT_Face ft_face, FT_Encoding encoding)
static FT_Encoding	pick_charmap (FT_Face face, int charset)
static INT FASTCALL	IntGdiLoadFontsFromMemory (PGDI_LOAD_FONT pLoadFont, PSHARED_FACE SharedFace, FT_Long FontIndex, INT CharSetIndex)
static INT FASTCALL	IntGdiLoadFontByIndexFromMemory (PGDI_LOAD_FONT pLoadFont, FT_Long FontIndex)
static INT FASTCALL	IntGdiAddFontResourceSingle (_In_ PCUNICODE_STRING FileName, _In_ DWORD Characteristics, _In_ DWORD dwFlags)
INT FASTCALL	IntGdiAddFontResourceEx (_In_ PCUNICODE_STRING FileName, _In_ DWORD cFiles, _In_ DWORD Characteristics, _In_ DWORD dwFlags)
VOID	IntDeleteRegFontEntries (_In_ PCWSTR pszFileName, _In_ DWORD dwFlags)
static BOOL FASTCALL	IntGdiRemoveFontResourceSingle (_In_ PCUNICODE_STRING FileName, _In_ DWORD dwFlags)
BOOL FASTCALL	IntGdiRemoveFontResource (_In_ PCUNICODE_STRING FileName, _In_ DWORD cFiles, _In_ DWORD dwFlags)
BOOL FASTCALL	IntLoadFontsInRegistry (VOID)
HANDLE FASTCALL	IntGdiAddFontMemResource (PVOID Buffer, DWORD dwSize, PDWORD pNumAdded)
VOID FASTCALL	IntGdiCleanupMemEntry (PFONT_ENTRY_MEM Head)
static VOID FASTCALL	UnlinkFontMemCollection (PFONT_ENTRY_COLL_MEM Collection)
BOOL FASTCALL	IntGdiRemoveFontMemResource (HANDLE hMMFont)
VOID FASTCALL	IntGdiCleanupPrivateFontsForProcess (VOID)
BOOL FASTCALL	IntIsFontRenderingEnabled (VOID)
VOID FASTCALL	IntEnableFontRendering (BOOL Enable)
FT_Render_Mode FASTCALL	IntGetFontRenderMode (LOGFONTW *logfont)
NTSTATUS FASTCALL	TextIntCreateFontIndirect (CONST LPLOGFONTW lf, HFONT *NewFont)
static BOOLEAN	IntTranslateCharsetInfo (PDWORD Src, LPCHARSETINFO Cs, DWORD Flags)
static BOOL	face_has_symbol_charmap (FT_Face ft_face)
static void FASTCALL	FillTM (TEXTMETRICW *TM, PFONTGDI FontGDI, TT_OS2 *pOS2, TT_HoriHeader *pHori, FT_WinFNT_HeaderRec *pFNT)
static NTSTATUS	IntGetFontLocalizedName (PUNICODE_STRING pNameW, PSHARED_FACE SharedFace, FT_UShort NameID, FT_UShort LangID)
static __inline void FASTCALL	IntInitFontNames (FONT_NAMES *Names, PSHARED_FACE SharedFace)
static SIZE_T FASTCALL	IntStoreName (_In_ const UNICODE_STRING *pName, _Out_ PBYTE pb)
PBYTE FASTCALL	IntStoreFontNames (_In_ const FONT_NAMES *Names, _Out_ OUTLINETEXTMETRICW *Otm)
static __inline void FASTCALL	IntFreeFontNames (FONT_NAMES *Names)
INT FASTCALL	IntGetOutlineTextMetrics (PFONTGDI FontGDI, UINT Size, OUTLINETEXTMETRICW *Otm, BOOL bLocked)
static void FASTCALL	FontFamilyFillInfo (PFONTFAMILYINFO Info, LPCWSTR FaceName, LPCWSTR FullName, PFONTGDI FontGDI)
static BOOLEAN FASTCALL	GetFontFamilyInfoForList (const LOGFONTW *LogFont, PFONTFAMILYINFO Info, LPCWSTR NominalName, LONG *pCount, LONG MaxCount, PLIST_ENTRY Head)
static BOOLEAN FASTCALL	GetFontFamilyInfoForSubstitutes (const LOGFONTW *LogFont, PFONTFAMILYINFO Info, LONG *pCount, LONG MaxCount)
BOOL FASTCALL	ftGdiGetRasterizerCaps (LPRASTERIZER_STATUS lprs)
static DWORD	IntGetHash (IN LPCVOID pv, IN DWORD cdw)
static FT_BitmapGlyph	IntFindGlyphCache (IN const FONT_CACHE_ENTRY *pCache)
static FT_BitmapGlyph	IntGetBitmapGlyphWithCache (IN OUT PFONT_CACHE_ENTRY Cache, IN FT_GlyphSlot GlyphSlot)
static unsigned int	get_native_glyph_outline (FT_Outline *outline, unsigned int buflen, char *buf)
static unsigned int	get_bezier_glyph_outline (FT_Outline *outline, unsigned int buflen, char *buf)
static FT_Error	IntRequestFontSizeEx (_In_ FT_Face face, _In_ LONG lfWidth, _In_ LONG lfHeight, _Out_opt_ PLONG ptmHeight, _Out_opt_ PLONG ptmAscent, _Out_opt_ PLONG ptmDescent, _Out_opt_ PLONG ptmInternalLeading, _Out_opt_ PLONG plfHeight, _Out_opt_ PLONG plfWidth)
static FT_Error	IntRequestFontSize (_Inout_ PFONTGDI FontGDI, _In_ LONG lfWidth, _In_ LONG lfHeight)
BOOL FASTCALL	TextIntUpdateSize (_In_ PTEXTOBJ TextObj, _In_ PFONTGDI FontGDI, _In_ BOOL bDoLock)
static FT_UInt FASTCALL	get_glyph_index_symbol (FT_Face ft_face, UINT glyph)
static FT_UInt FASTCALL	get_glyph_index (FT_Face ft_face, UINT glyph)
static FT_UInt FASTCALL	get_glyph_index_flagged (FT_Face face, FT_ULong code, BOOL fCodeAsIndex)
static VOID	FontLink_Chain_Dump (_In_ PFONTLINK_CHAIN pChain)
static BOOL	IntNeedRequestFontSize (PFONTLINK_CHAIN pChain, FT_Face face, PLIST_ENTRY TargetEntry)
static UINT	FontLink_Chain_FindGlyph (_Inout_ PFONTLINK_CHAIN pChain, _Out_ PFONT_CACHE_ENTRY pCache, _Inout_ FT_Face *pFace, _In_ UINT code, _In_ BOOL fCodeAsIndex)
ULONG FASTCALL	ftGdiGetGlyphOutline (PDC dc, WCHAR wch, UINT iFormat, LPGLYPHMETRICS pgm, ULONG cjBuf, PVOID pvBuf, const MAT2 *pmat2, BOOL bIgnoreRotation)
static FT_BitmapGlyph	IntGetRealGlyph (IN OUT PFONT_CACHE_ENTRY Cache)
BOOL FASTCALL	TextIntGetTextExtentPoint (_In_ PDC dc, _In_ PTEXTOBJ TextObj, _In_reads_(Count) PCWCH String, _In_ INT Count, _In_ ULONG MaxExtent, _Out_ PINT Fit, _Out_writes_to_opt_(Count, *Fit) PINT Dx, _Out_ PSIZE Size, _In_ FLONG fl)
INT FASTCALL	ftGdiGetTextCharsetInfo (PDC Dc, LPFONTSIGNATURE lpSig, DWORD dwFlags)
DWORD FASTCALL	ftGetFontUnicodeRanges (PFONTGDI Font, PGLYPHSET glyphset)
BOOL FASTCALL	ftGdiGetTextMetricsW (HDC hDC, PTMW_INTERNAL ptmwi)
DWORD FASTCALL	ftGdiGetFontData (PFONTGDI FontGdi, DWORD Table, DWORD Offset, PVOID Buffer, DWORD Size)
static UINT	GetFontPenalty (const LOGFONTW *LogFont, const OUTLINETEXTMETRICW *Otm, const char *style_name)
static VOID FASTCALL	IntFontType (PFONTGDI Font)
static BOOL	MatchFontNames (PSHARED_FACE SharedFace, LPCWSTR lfFaceName)
static BOOL FASTCALL	IntGetFullFileName (POBJECT_NAME_INFORMATION NameInfo, ULONG Size, PUNICODE_STRING FileName)
static BOOL	EqualFamilyInfo (const FONTFAMILYINFO *pInfo1, const FONTFAMILYINFO *pInfo2)
static VOID	IntAddNameFromFamInfo (LPWSTR psz, FONTFAMILYINFO *FamInfo)
NTSTATUS FASTCALL	TextIntRealizeFont (HFONT FontHandle, PTEXTOBJ pTextObj)
BOOL FASTCALL	IntGdiGetFontResourceInfo (PUNICODE_STRING FileName, PVOID pBuffer, DWORD *pdwBytes, DWORD dwType)
BOOL FASTCALL	ftGdiRealizationInfo (PFONTGDI Font, PREALIZATION_INFO Info)
DWORD FASTCALL	ftGdiGetKerningPairs (PFONTGDI Font, DWORD cPairs, LPKERNINGPAIR pKerningPair)
LONG FASTCALL	IntGetFontFamilyInfo (HDC Dc, const LOGFONTW *SafeLogFont, PFONTFAMILYINFO SafeInfo, LONG InfoCount)
LONG NTAPI	NtGdiGetFontFamilyInfo (_In_ HDC Dc, _In_ const LOGFONTW *UnsafeLogFont, _Out_ PFONTFAMILYINFO UnsafeInfo, _Inout_ PLONG UnsafeInfoCount)
static BOOL	IntGetTextDisposition (_Out_ LONGLONG *pX64, _Out_ LONGLONG *pY64, _In_reads_(Count) PCWCH String, _In_ INT Count, _In_opt_ const INT *Dx, _Inout_ PFONT_CACHE_ENTRY Cache, _In_ UINT fuOptions, _In_ BOOL bNoTransform, _Inout_ PFONTLINK_CHAIN pChain)
BOOL APIENTRY	IntExtTextOutW (_In_ PDC dc, _In_ INT XStart, _In_ INT YStart, _In_ UINT fuOptions, _In_opt_ PRECTL lprc, _In_reads_opt_(Count) PCWCH String, _In_ INT Count, _In_opt_ const INT *Dx, _In_ DWORD dwCodePage)
BOOL APIENTRY	GreExtTextOutW (_In_ HDC hDC, _In_ INT XStart, _In_ INT YStart, _In_ UINT fuOptions, _In_opt_ PRECTL lprc, _In_reads_opt_(Count) PCWCH String, _In_ INT Count, _In_opt_ const INT *Dx, _In_ DWORD dwCodePage)
BOOL APIENTRY	NtGdiExtTextOutW (_In_ HDC hDC, _In_ INT XStart, _In_ INT YStart, _In_ UINT fuOptions, _In_opt_ LPCRECT UnsafeRect, _In_reads_opt_(Count) PCWCH UnsafeString, _In_range_(0, 0xFFFF) UINT Count, _In_reads_opt_(_Inexpressible_(cwc)) const INT *UnsafeDx, _In_ DWORD dwCodePage)
BOOL APIENTRY	GreGetCharABCWidthsW (_In_ HDC hDC, _In_ UINT FirstChar, _In_ UINT Count, _In_reads_opt_(Count) PCWCH Safepwch, _In_ FLONG fl, _Out_writes_bytes_(Count *sizeof(ABC)) PVOID SafeBuffer)
BOOL APIENTRY	GreGetCharWidthW (_In_ HDC hDC, _In_ UINT FirstChar, _In_ UINT Count, _In_reads_opt_(Count) PCWCH Safepwc, _In_ FLONG fl, _Out_writes_bytes_(Count *sizeof(INT)) PVOID Buffer)
static BOOL	IntGetFontDefaultChar (_In_ FT_Face Face, _Out_ PWCHAR pDefChar)
DWORD APIENTRY	GreGetGlyphIndicesW (_In_ HDC hdc, _In_reads_opt_(cwc) PCWCH pwc, _In_ INT cwc, _Out_writes_opt_(cwc) PWORD pgi, _In_ DWORD iMode, _In_ BOOL bSubset)

Variables
static DWORD	s_chFontLinkDefaultChar = FONTLINK_DEFAULT_CHAR
static WCHAR	s_szDefFontLinkFileName [MAX_PATH] = L""
static WCHAR	s_szDefFontLinkFontName [MAX_PATH] = L""
static BOOL	s_fFontLinkUseAnsi = FALSE
static BOOL	s_fFontLinkUseOem = FALSE
static BOOL	s_fFontLinkUseSymbol = FALSE
const MATRIX	gmxWorldToDeviceDefault
const MATRIX	gmxWorldToPageDefault
static const FT_Matrix	identityMat = {(1 << 16), 0, 0, (1 << 16)}
FT_Library	g_FreeTypeLibrary
UNICODE_STRING	g_FontRegPath
static PFAST_MUTEX	g_FreeTypeLock
static BOOL	g_RenderingEnabled = TRUE
static UINT	g_FontCacheNumEntries
static PWCHAR	g_ElfScripts [32]
static const CHARSETINFO	g_FontTci [MAXTCIINDEX]
static const WCHAR	s_szzDefFontLink []
static const WCHAR	s_szzDefFixedFontLink []
static const UNICODE_STRING	DosPathPrefix = RTL_CONSTANT_STRING(L"\\??\\")

Macro Definition Documentation

_TMPF_VARIABLE_PITCH

#define _TMPF_VARIABLE_PITCH   TMPF_FIXED_PITCH

Definition at line 192 of file freetype.c.

ASSERT_FREETYPE_LOCK_HELD

#define ASSERT_FREETYPE_LOCK_HELD

(

)

ASSERT(g_FreeTypeLock->Owner == KeGetCurrentThread())

Definition at line 219 of file freetype.c.

ASSERT_FREETYPE_LOCK_NOT_HELD

#define ASSERT_FREETYPE_LOCK_NOT_HELD

(

)

ASSERT(g_FreeTypeLock->Owner != KeGetCurrentThread())

Definition at line 222 of file freetype.c.

CP_MACCP

#define CP_MACCP   2

Definition at line 313 of file freetype.c.

CP_OEMCP

#define CP_OEMCP   1

Definition at line 312 of file freetype.c.

CP_SYMBOL

#define CP_SYMBOL   42

Definition at line 268 of file freetype.c.

EMUBOLD_NEEDED

#define EMUBOLD_NEEDED	(		original,
			request
	)		(((request) != FW_DONTCARE) && ((request) - (original) >= FW_BOLD - FW_MEDIUM))

Definition at line 196 of file freetype.c.

FM_SEL_USE_TYPO_METRICS

#define FM_SEL_USE_TYPO_METRICS   0x80

FONTLINK_DEFAULT_CHAR

#define FONTLINK_DEFAULT_CHAR   0x30FB

Definition at line 58 of file freetype.c.

gmxWorldToDeviceDefault

#define gmxWorldToDeviceDefault   gmxWorldToPageDefault

Definition at line 204 of file freetype.c.

GOT_PENALTY

#define GOT_PENALTY	(		name,
			value
	)		Penalty += (value)

Definition at line 5411 of file freetype.c.

IntLockFreeType

#define IntLockFreeType

(

)

Value:

do { \
    ASSERT_FREETYPE_LOCK_NOT_HELD(); \
    ExEnterCriticalRegionAndAcquireFastMutexUnsafe(g_FreeTypeLock); \
} while (0)

Definition at line 225 of file freetype.c.

IntUnLockFreeType

#define IntUnLockFreeType

(

)

Value:

do { \
    ASSERT_FREETYPE_LOCK_HELD(); \
    ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(g_FreeTypeLock); \
} while(0)

Definition at line 231 of file freetype.c.

MAX_FONT_CACHE

#define MAX_FONT_CACHE   256

Definition at line 237 of file freetype.c.

MAXTCIINDEX

#define MAXTCIINDEX   32

Definition at line 269 of file freetype.c.

NDEBUG

#define NDEBUG

Definition at line 30 of file freetype.c.

SCALE_X

#define SCALE_X

(

value

)

((FT_MulFix((value), XScale) + 32) >> 6)

SCALE_Y

#define SCALE_Y

(

value

)

((FT_MulFix((value), YScale) + 32) >> 6)

STACK_TEXT_BUFFER_SIZE

#define STACK_TEXT_BUFFER_SIZE   512

Definition at line 7253 of file freetype.c.

VALIGN_MASK

#define VALIGN_MASK   (TA_TOP | TA_BASELINE | TA_BOTTOM)

Typedef Documentation

FONT_NAMES

typedef struct FONT_NAMES FONT_NAMES

FONTLINK

typedef struct _FONTLINK FONTLINK

FONTLINK_CHAIN

typedef struct _FONTLINK_CHAIN FONTLINK_CHAIN

FONTLINK_ENTRY

typedef struct _FONTLINK_ENTRY FONTLINK_ENTRY

LPFONT_NAMES

typedef struct FONT_NAMES * LPFONT_NAMES

PFONTLINK

typedef struct _FONTLINK * PFONTLINK

PFONTLINK_CHAIN

typedef struct _FONTLINK_CHAIN * PFONTLINK_CHAIN

PFONTLINK_ENTRY

typedef struct _FONTLINK_ENTRY * PFONTLINK_ENTRY

Function Documentation

CleanupFontEntry()

static __inline VOID FASTCALL CleanupFontEntry ( PFONT_ENTRY  FontEntry )

static

Definition at line 573 of file freetype.c.

{
    CleanupFontEntryEx(FontEntry, FontEntry->Font);
}

Referenced by FreeFontSupport(), IntGdiCleanupMemEntry(), IntGdiCleanupPrivateFontsForProcess(), and IntGdiRemoveFontResourceSingle().

CleanupFontEntryEx()

static VOID FASTCALL CleanupFontEntryEx ( PFONT_ENTRY  FontEntry, PFONTGDI  FontGDI  )

static

Definition at line 553 of file freetype.c.

{
    // PFONTGDI FontGDI = FontEntry->Font;
    PSHARED_FACE SharedFace = FontGDI->SharedFace;
 
    if (FontGDI->Filename)
        ExFreePoolWithTag(FontGDI->Filename, GDITAG_PFF);
 
    if (FontEntry->StyleName.Buffer)
        RtlFreeUnicodeString(&FontEntry->StyleName);
 
    if (FontEntry->FaceName.Buffer)
        RtlFreeUnicodeString(&FontEntry->FaceName);
 
    EngFreeMem(FontGDI);
    SharedFace_Release(SharedFace, TRUE);
    ExFreePoolWithTag(FontEntry, TAG_FONT);
}

Referenced by CleanupFontEntry().

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

GdiFont

)

EqualFamilyInfo()

static BOOL EqualFamilyInfo ( const FONTFAMILYINFO *  pInfo1, const FONTFAMILYINFO *  pInfo2  )

static

Definition at line 5956 of file freetype.c.

{
    const ENUMLOGFONTEXW *pLog1 = &pInfo1->EnumLogFontEx;
    const ENUMLOGFONTEXW *pLog2 = &pInfo2->EnumLogFontEx;
    const LOGFONTW *plf1 = &pLog1->elfLogFont;
    const LOGFONTW *plf2 = &pLog2->elfLogFont;
 
    if (_wcsicmp(plf1->lfFaceName, plf2->lfFaceName) != 0)
    {
        return FALSE;
    }
 
    if (_wcsicmp(pLog1->elfStyle, pLog2->elfStyle) != 0)
    {
        return FALSE;
    }
 
    return TRUE;
}

Referenced by IntGdiGetFontResourceInfo().

face_has_symbol_charmap()

static BOOL face_has_symbol_charmap ( FT_Face  ft_face )

static

Definition at line 2822 of file freetype.c.

{
    int i;
 
    for(i = 0; i < ft_face->num_charmaps; i++)
    {
        if (ft_face->charmaps[i]->platform_id == TT_PLATFORM_MICROSOFT &&
            ft_face->charmaps[i]->encoding == FT_ENCODING_MS_SYMBOL)
        {
            return TRUE;
        }
    }
    return FALSE;
}

Referenced by FillTM(), and get_glyph_index().

FillTM()

static void FASTCALL FillTM ( TEXTMETRICW *  TM, PFONTGDI  FontGDI, TT_OS2 *  pOS2, TT_HoriHeader *  pHori, FT_WinFNT_HeaderRec *  pFNT  )

static

Definition at line 2838 of file freetype.c.

{
    FT_Fixed XScale, YScale;
    int Ascent, Descent;
    FT_Face Face = FontGDI->SharedFace->Face;
 
    ASSERT_FREETYPE_LOCK_HELD();
 
    XScale = Face->size->metrics.x_scale;
    YScale = Face->size->metrics.y_scale;
 
    if (pFNT)
    {
        TM->tmHeight           = pFNT->pixel_height;
        TM->tmAscent           = pFNT->ascent;
        TM->tmDescent          = TM->tmHeight - TM->tmAscent;
        TM->tmInternalLeading  = pFNT->internal_leading;
        TM->tmExternalLeading  = pFNT->external_leading;
        TM->tmAveCharWidth     = pFNT->avg_width;
        TM->tmMaxCharWidth     = pFNT->max_width;
        TM->tmOverhang         = 0;
        TM->tmDigitizedAspectX = pFNT->horizontal_resolution;
        TM->tmDigitizedAspectY = pFNT->vertical_resolution;
        TM->tmFirstChar        = pFNT->first_char;
        TM->tmLastChar         = pFNT->last_char;
        TM->tmDefaultChar      = pFNT->default_char + pFNT->first_char;
        TM->tmBreakChar        = pFNT->break_char + pFNT->first_char;
        TM->tmPitchAndFamily   = pFNT->pitch_and_family;
        TM->tmWeight       = FontGDI->RequestWeight;
        TM->tmItalic       = FontGDI->RequestItalic;
        TM->tmUnderlined   = FontGDI->RequestUnderline;
        TM->tmStruckOut    = FontGDI->RequestStrikeOut;
        TM->tmCharSet      = FontGDI->CharSet;
        return;
    }
 
    ASSERT(pOS2);
    if (!pOS2)
        return;
 
    if ((FT_Short)pOS2->usWinAscent + (FT_Short)pOS2->usWinDescent == 0)
    {
        Ascent = pHori->Ascender;
        Descent = -pHori->Descender;
    }
    else
    {
        Ascent = (FT_Short)pOS2->usWinAscent;
        Descent = (FT_Short)pOS2->usWinDescent;
    }
 
    TM->tmAscent = FontGDI->tmAscent;
    TM->tmDescent = FontGDI->tmDescent;
    TM->tmHeight = TM->tmAscent + TM->tmDescent;
    TM->tmInternalLeading = FontGDI->tmInternalLeading;
 
    /* MSDN says:
     *  el = MAX(0, LineGap - ((WinAscent + WinDescent) - (Ascender - Descender)))
     */
    TM->tmExternalLeading = max(0, (FT_MulFix(pHori->Line_Gap
                                    - ((Ascent + Descent)
                                       - (pHori->Ascender - pHori->Descender)),
                                    YScale) + 32) >> 6);
    if (FontGDI->lfWidth != 0)
        TM->tmAveCharWidth = FontGDI->lfWidth;
    else
        TM->tmAveCharWidth = (FT_MulFix(pOS2->xAvgCharWidth, XScale) + 32) >> 6;
 
    if (TM->tmAveCharWidth == 0)
        TM->tmAveCharWidth = 1;
 
    /* Correct forumla to get the maxcharwidth from unicode and ansi font */
    TM->tmMaxCharWidth = (FT_MulFix(Face->max_advance_width, XScale) + 32) >> 6;
 
    if (FontGDI->OriginalWeight != FW_DONTCARE &&
        FontGDI->OriginalWeight > FontGDI->RequestWeight)
    {
        TM->tmWeight = FontGDI->OriginalWeight;
    }
    else
    {
        TM->tmWeight = FontGDI->RequestWeight;
    }
 
    TM->tmOverhang = 0;
    TM->tmDigitizedAspectX = 96;
    TM->tmDigitizedAspectY = 96;
    if (face_has_symbol_charmap(Face) ||
        (pOS2->usFirstCharIndex >= 0xf000 && pOS2->usFirstCharIndex < 0xf100))
    {
        USHORT cpOEM, cpAnsi;
 
        EngGetCurrentCodePage(&cpOEM, &cpAnsi);
        TM->tmFirstChar = 0;
        switch(cpAnsi)
        {
        case 1257: /* Baltic */
            TM->tmLastChar = 0xf8fd;
            break;
        default:
            TM->tmLastChar = 0xf0ff;
        }
        TM->tmBreakChar = 0x20;
        TM->tmDefaultChar = 0x1f;
    }
    else
    {
        TM->tmFirstChar = pOS2->usFirstCharIndex; /* Should be the first char in the cmap */
        TM->tmLastChar = pOS2->usLastCharIndex;   /* Should be min(cmap_last, os2_last) */
 
        if(pOS2->usFirstCharIndex <= 1)
            TM->tmBreakChar = pOS2->usFirstCharIndex + 2;
        else if (pOS2->usFirstCharIndex > 0xff)
            TM->tmBreakChar = 0x20;
        else
            TM->tmBreakChar = pOS2->usFirstCharIndex;
        TM->tmDefaultChar = TM->tmBreakChar - 1;
    }
 
    if (FontGDI->OriginalItalic || FontGDI->RequestItalic)
    {
        TM->tmItalic = 0xFF;
    }
    else
    {
        TM->tmItalic = 0;
    }
    TM->tmUnderlined = (FontGDI->RequestUnderline ? 0xFF : 0);
    TM->tmStruckOut  = (FontGDI->RequestStrikeOut ? 0xFF : 0);
 
    if (!FT_IS_FIXED_WIDTH(Face))
    {
        switch (pOS2->panose[PAN_PROPORTION_INDEX])
        {
            case PAN_PROP_MONOSPACED:
                TM->tmPitchAndFamily = 0;
                break;
            default:
                TM->tmPitchAndFamily = _TMPF_VARIABLE_PITCH;
                break;
        }
    }
    else
    {
        TM->tmPitchAndFamily = 0;
    }
 
    switch (pOS2->panose[PAN_FAMILYTYPE_INDEX])
    {
    case PAN_FAMILY_SCRIPT:
        TM->tmPitchAndFamily |= FF_SCRIPT;
        break;
    case PAN_FAMILY_DECORATIVE:
        TM->tmPitchAndFamily |= FF_DECORATIVE;
        break;
 
    case PAN_ANY:
    case PAN_NO_FIT:
    case PAN_FAMILY_TEXT_DISPLAY:
    case PAN_FAMILY_PICTORIAL: /* Symbol fonts get treated as if they were text */
                               /* Which is clearly not what the panose spec says. */
        if (TM->tmPitchAndFamily == 0) /* Fixed */
        {
            TM->tmPitchAndFamily = FF_MODERN;
        }
        else
        {
            switch (pOS2->panose[PAN_SERIFSTYLE_INDEX])
            {
            case PAN_ANY:
            case PAN_NO_FIT:
            default:
                TM->tmPitchAndFamily |= FF_DONTCARE;
                break;
 
            case PAN_SERIF_COVE:
            case PAN_SERIF_OBTUSE_COVE:
            case PAN_SERIF_SQUARE_COVE:
            case PAN_SERIF_OBTUSE_SQUARE_COVE:
            case PAN_SERIF_SQUARE:
            case PAN_SERIF_THIN:
            case PAN_SERIF_BONE:
            case PAN_SERIF_EXAGGERATED:
            case PAN_SERIF_TRIANGLE:
                TM->tmPitchAndFamily |= FF_ROMAN;
                break;
 
            case PAN_SERIF_NORMAL_SANS:
            case PAN_SERIF_OBTUSE_SANS:
            case PAN_SERIF_PERP_SANS:
            case PAN_SERIF_FLARED:
            case PAN_SERIF_ROUNDED:
                TM->tmPitchAndFamily |= FF_SWISS;
                break;
            }
        }
        break;
    default:
        TM->tmPitchAndFamily |= FF_DONTCARE;
    }
 
    if (FT_IS_SCALABLE(Face))
    {
        TM->tmPitchAndFamily |= TMPF_VECTOR;
    }
    if (FT_IS_SFNT(Face))
    {
        TM->tmPitchAndFamily |= TMPF_TRUETYPE;
    }
 
    TM->tmCharSet = FontGDI->CharSet;
}

Referenced by ftGdiGetTextMetricsW(), and IntGetOutlineTextMetrics().

FindBestFontFromList()

static __inline VOID FindBestFontFromList ( FONTOBJ **  FontObj, ULONG *  MatchPenalty, const LOGFONTW *  LogFont, const PLIST_ENTRY  Head  )

static

Definition at line 5761 of file freetype.c.

{
    ULONG Penalty;
    PLIST_ENTRY Entry;
    PFONT_ENTRY CurrentEntry;
    FONTGDI *FontGDI;
    OUTLINETEXTMETRICW *Otm = NULL;
    UINT OtmSize, OldOtmSize = 0;
    FT_Face Face;
 
    ASSERT(FontObj);
    ASSERT(MatchPenalty);
    ASSERT(LogFont);
    ASSERT(Head);
 
    /* Start with a pretty big buffer */
    OldOtmSize = 0x200;
    Otm = ExAllocatePoolWithTag(PagedPool, OldOtmSize, GDITAG_TEXT);
 
    /* get the FontObj of lowest penalty */
    for (Entry = Head->Flink; Entry != Head; Entry = Entry->Flink)
    {
        CurrentEntry = CONTAINING_RECORD(Entry, FONT_ENTRY, ListEntry);
 
        FontGDI = CurrentEntry->Font;
        ASSERT(FontGDI);
        Face = FontGDI->SharedFace->Face;
 
        /* get text metrics */
        ASSERT_FREETYPE_LOCK_HELD();
        OtmSize = IntGetOutlineTextMetrics(FontGDI, 0, NULL, TRUE);
        if (OtmSize > OldOtmSize)
        {
            if (Otm)
                ExFreePoolWithTag(Otm, GDITAG_TEXT);
            Otm = ExAllocatePoolWithTag(PagedPool, OtmSize, GDITAG_TEXT);
        }
 
        /* update FontObj if lowest penalty */
        if (Otm)
        {
            ASSERT_FREETYPE_LOCK_HELD();
            IntRequestFontSize(FontGDI, LogFont->lfWidth, LogFont->lfHeight);
 
            ASSERT_FREETYPE_LOCK_HELD();
            OtmSize = IntGetOutlineTextMetrics(FontGDI, OtmSize, Otm, TRUE);
            if (!OtmSize)
                continue;
 
            OldOtmSize = OtmSize;
 
            Penalty = GetFontPenalty(LogFont, Otm, Face->style_name);
            if (*MatchPenalty == MAXULONG || Penalty < *MatchPenalty)
            {
                *FontObj = GDIToObj(FontGDI, FONT);
                *MatchPenalty = Penalty;
            }
        }
    }
 
    if (Otm)
        ExFreePoolWithTag(Otm, GDITAG_TEXT);
}

Referenced by FontLink_PrepareFontInfo(), and TextIntRealizeFont().

FontFamilyFillInfo()

static void FASTCALL FontFamilyFillInfo ( PFONTFAMILYINFO  Info, LPCWSTR  FaceName, LPCWSTR  FullName, PFONTGDI  FontGDI  )

static

Definition at line 3444 of file freetype.c.

{
    ANSI_STRING StyleA;
    UNICODE_STRING StyleW;
    TT_OS2 *pOS2;
    FONTSIGNATURE fs;
    CHARSETINFO CharSetInfo;
    unsigned i, Size;
    OUTLINETEXTMETRICW *Otm;
    LOGFONTW *Lf;
    TEXTMETRICW *TM;
    NEWTEXTMETRICW *Ntm;
    DWORD fs0;
    NTSTATUS status;
    PSHARED_FACE SharedFace = FontGDI->SharedFace;
    FT_Face Face = SharedFace->Face;
    UNICODE_STRING NameW;
 
    RtlInitUnicodeString(&NameW, NULL);
    RtlZeroMemory(Info, sizeof(FONTFAMILYINFO));
    ASSERT_FREETYPE_LOCK_HELD();
    Size = IntGetOutlineTextMetrics(FontGDI, 0, NULL, TRUE);
    if (!Size)
        return;
    Otm = ExAllocatePoolWithTag(PagedPool, Size, GDITAG_TEXT);
    if (!Otm)
        return;
    ASSERT_FREETYPE_LOCK_HELD();
    Size = IntGetOutlineTextMetrics(FontGDI, Size, Otm, TRUE);
    if (!Size)
    {
        ExFreePoolWithTag(Otm, GDITAG_TEXT);
        return;
    }
 
    Lf = &Info->EnumLogFontEx.elfLogFont;
    TM = &Otm->otmTextMetrics;
 
    Lf->lfHeight = TM->tmHeight;
    Lf->lfWidth = TM->tmAveCharWidth;
    Lf->lfWeight = TM->tmWeight;
    Lf->lfItalic = TM->tmItalic;
    Lf->lfPitchAndFamily = (TM->tmPitchAndFamily & 0xf1) + 1;
    Lf->lfCharSet = TM->tmCharSet;
    Lf->lfOutPrecision = OUT_OUTLINE_PRECIS;
    Lf->lfClipPrecision = CLIP_DEFAULT_PRECIS;
    Lf->lfQuality = PROOF_QUALITY;
 
    Ntm = &Info->NewTextMetricEx.ntmTm;
    Ntm->tmHeight = TM->tmHeight;
    Ntm->tmAscent = TM->tmAscent;
    Ntm->tmDescent = TM->tmDescent;
    Ntm->tmInternalLeading = TM->tmInternalLeading;
    Ntm->tmExternalLeading = TM->tmExternalLeading;
    Ntm->tmAveCharWidth = TM->tmAveCharWidth;
    Ntm->tmMaxCharWidth = TM->tmMaxCharWidth;
    Ntm->tmWeight = TM->tmWeight;
    Ntm->tmOverhang = TM->tmOverhang;
    Ntm->tmDigitizedAspectX = TM->tmDigitizedAspectX;
    Ntm->tmDigitizedAspectY = TM->tmDigitizedAspectY;
    Ntm->tmFirstChar = TM->tmFirstChar;
    Ntm->tmLastChar = TM->tmLastChar;
    Ntm->tmDefaultChar = TM->tmDefaultChar;
    Ntm->tmBreakChar = TM->tmBreakChar;
    Ntm->tmItalic = TM->tmItalic;
    Ntm->tmUnderlined = TM->tmUnderlined;
    Ntm->tmStruckOut = TM->tmStruckOut;
    Ntm->tmPitchAndFamily = TM->tmPitchAndFamily;
    Ntm->tmCharSet = TM->tmCharSet;
    Ntm->ntmFlags = TM->tmItalic ? NTM_ITALIC : 0;
 
    if (550 < TM->tmWeight) Ntm->ntmFlags |= NTM_BOLD;
 
    if (0 == Ntm->ntmFlags) Ntm->ntmFlags = NTM_REGULAR;
 
    Info->FontType = (0 != (TM->tmPitchAndFamily & TMPF_TRUETYPE)
                      ? TRUETYPE_FONTTYPE : 0);
 
    if (0 == (TM->tmPitchAndFamily & TMPF_VECTOR))
        Info->FontType |= RASTER_FONTTYPE;
 
 
    /* face name */
    if (!FaceName)
        FaceName = (WCHAR*)((ULONG_PTR)Otm + (ULONG_PTR)Otm->otmpFamilyName);
 
    RtlStringCbCopyW(Lf->lfFaceName, sizeof(Lf->lfFaceName), FaceName);
 
    /* full name */
    if (!FullName)
        FullName = (WCHAR*)((ULONG_PTR) Otm + (ULONG_PTR)Otm->otmpFaceName);
 
    RtlStringCbCopyW(Info->EnumLogFontEx.elfFullName,
                     sizeof(Info->EnumLogFontEx.elfFullName),
                     FullName);
 
    RtlInitAnsiString(&StyleA, Face->style_name);
    StyleW.Buffer = Info->EnumLogFontEx.elfStyle;
    StyleW.MaximumLength = sizeof(Info->EnumLogFontEx.elfStyle);
    status = RtlAnsiStringToUnicodeString(&StyleW, &StyleA, FALSE);
    if (!NT_SUCCESS(status))
    {
        ExFreePoolWithTag(Otm, GDITAG_TEXT);
        return;
    }
    Info->EnumLogFontEx.elfScript[0] = UNICODE_NULL;
 
    pOS2 = FT_Get_Sfnt_Table(Face, ft_sfnt_os2);
 
    if (!pOS2)
    {
        ExFreePoolWithTag(Otm, GDITAG_TEXT);
        return;
    }
 
    Ntm->ntmSizeEM = Otm->otmEMSquare;
    Ntm->ntmCellHeight = (FT_Short)pOS2->usWinAscent + (FT_Short)pOS2->usWinDescent;
    Ntm->ntmAvgWidth = 0;
 
    ExFreePoolWithTag(Otm, GDITAG_TEXT);
 
    fs.fsCsb[0] = pOS2->ulCodePageRange1;
    fs.fsCsb[1] = pOS2->ulCodePageRange2;
    fs.fsUsb[0] = pOS2->ulUnicodeRange1;
    fs.fsUsb[1] = pOS2->ulUnicodeRange2;
    fs.fsUsb[2] = pOS2->ulUnicodeRange3;
    fs.fsUsb[3] = pOS2->ulUnicodeRange4;
 
    if (0 == pOS2->version)
    {
        FT_UInt Dummy;
 
        if (FT_Get_First_Char(Face, &Dummy) < 0x100)
            fs.fsCsb[0] |= FS_LATIN1;
        else
            fs.fsCsb[0] |= FS_SYMBOL;
    }
 
    if (fs.fsCsb[0] == 0)
    {
        /* Let's see if we can find any interesting cmaps */
        for (i = 0; i < (UINT)Face->num_charmaps; i++)
        {
            switch (Face->charmaps[i]->encoding)
            {
            case FT_ENCODING_UNICODE:
            case FT_ENCODING_APPLE_ROMAN:
                fs.fsCsb[0] |= FS_LATIN1;
                break;
            case FT_ENCODING_MS_SYMBOL:
                fs.fsCsb[0] |= FS_SYMBOL;
                break;
            default:
                break;
            }
        }
    }
 
    for (i = 0; i < MAXTCIINDEX; i++)
    {
        fs0 = 1L << i;
        if (fs.fsCsb[0] & fs0)
        {
            if (!IntTranslateCharsetInfo(&fs0, &CharSetInfo, TCI_SRCFONTSIG))
            {
                CharSetInfo.ciCharset = DEFAULT_CHARSET;
            }
            if (DEFAULT_CHARSET != CharSetInfo.ciCharset)
            {
                if (g_ElfScripts[i])
                    wcscpy(Info->EnumLogFontEx.elfScript, g_ElfScripts[i]);
                else
                {
                    DPRINT1("Unknown elfscript for bit %u\n", i);
                }
            }
        }
    }
    Info->NewTextMetricEx.ntmFontSig = fs;
}

Referenced by GetFontFamilyInfoForList(), and IntGdiGetFontResourceInfo().

FontLink_AddEntry()

static NTSTATUS FontLink_AddEntry ( LPCWSTR  lfFaceName, PZZWSTR  pszzFontLink  )

static

Definition at line 875 of file freetype.c.

{
    SIZE_T FontLinkSize = SZZ_GetSize(pszzFontLink);
    PZZWSTR pszz = ExAllocatePoolWithTag(PagedPool, FontLinkSize, TAG_FONT);
    if (!pszz)
        return STATUS_NO_MEMORY;
    RtlCopyMemory(pszz, pszzFontLink, FontLinkSize);
 
    PFONTLINK_ENTRY pEntry = ExAllocatePoolWithTag(PagedPool, sizeof(FONTLINK_ENTRY), TAG_FONT);
    if (!pEntry)
    {
        ExFreePoolWithTag(pszz, TAG_FONT);
        return STATUS_NO_MEMORY;
    }
 
    pEntry->pszzFontLink = pszz;
    RtlStringCchCopyW(pEntry->lfFaceName, _countof(pEntry->lfFaceName), lfFaceName);
    InsertHeadList(&g_FontLinkEntries, &pEntry->ListEntry);
    return STATUS_SUCCESS;
}

Referenced by FontLink_PopulateEntries().

FontLink_Chain_Dump()

static VOID FontLink_Chain_Dump ( _In_ PFONTLINK_CHAIN  pChain )

inlinestatic

Definition at line 4323 of file freetype.c.

{
#if 0
    PLIST_ENTRY Entry, Head;
    PFONTLINK pFontLink;
    INT iLink = 0;
 
    DPRINT1("%S, %p, %p\n", pChain->LogFont.lfFaceName, pChain->pBaseTextObj, pChain->pDefFace);
 
    Head = &pChain->FontLinkList;
    for (Entry = Head->Flink; Entry != Head; Entry = Entry->Flink)
    {
        pFontLink = CONTAINING_RECORD(Entry, FONTLINK, ListEntry);
        DPRINT1("FontLink #%d: %p, %d, %S, %p, %p\n",
                iLink, pFontLink, pFontLink->bIgnore, pFontLink->LogFont.lfFaceName,
                pFontLink->pFontGDI, pFontLink->SharedFace);
        ++iLink;
    }
#endif
}

Referenced by FontLink_Chain_FindGlyph().

FontLink_Chain_FindEntry()

static NTSTATUS FontLink_Chain_FindEntry ( _Inout_ PFONTLINK_CHAIN  pChain, _Inout_ PLOGFONTW  pLF  )

static

Definition at line 1283 of file freetype.c.

{
    PFONTLINK_ENTRY pEntry = FontLink_FindEntry(pLF);
    if (!pEntry)
    {
        if (!(pLF->lfPitchAndFamily & FIXED_PITCH))
            pChain->pszzFontLink = s_szzDefFontLink;
        else
            pChain->pszzFontLink = s_szzDefFixedFontLink;
        return STATUS_SUCCESS;
    }
 
    pChain->pszzFontLink = pEntry->pszzFontLink;
    return STATUS_SUCCESS;
}

Referenced by FontLink_Chain_Populate().

FontLink_Chain_FindGlyph()

static UINT FontLink_Chain_FindGlyph ( _Inout_ PFONTLINK_CHAIN  pChain, _Out_ PFONT_CACHE_ENTRY  pCache, _Inout_ FT_Face *  pFace, _In_ UINT  code, _In_ BOOL  fCodeAsIndex  )

static

Search the target glyph and update the current font info.

Returns

The glyph index

Definition at line 4367 of file freetype.c.

{
    PFONTLINK pFontLink;
    PLIST_ENTRY Entry, Head;
    UINT index;
    FT_Face face;
 
    // Try the default font at first
    index = get_glyph_index_flagged(pChain->pDefFace, code, fCodeAsIndex);
    if (index)
    {
        DPRINT("code: 0x%08X, index: 0x%08X, fCodeAsIndex:%d\n", code, index, fCodeAsIndex);
        pCache->Hashed.Face = *pFace = pChain->pDefFace;
        return index; // The glyph is found on the default font
    }
 
    if (!FontLink_Chain_IsPopulated(pChain)) // The chain is not populated yet
    {
        FontLink_Chain_Populate(pChain);
        FontLink_Chain_Dump(pChain);
    }
 
    // Now the chain is populated. Looking for the target glyph...
    Head = &pChain->FontLinkList;
    for (Entry = Head->Flink; Entry != Head; Entry = Entry->Flink)
    {
        pFontLink = CONTAINING_RECORD(Entry, FONTLINK, ListEntry);
        if (!FontLink_PrepareFontInfo(pFontLink))
            continue; // This link is not useful, check the next one
 
        face = pFontLink->SharedFace->Face;
        index = get_glyph_index(face, code);
        if (!index)
            continue; // The glyph does not exist, continue searching
 
        // The target glyph is found in the chain
        DPRINT("code: 0x%08X, index: 0x%08X\n", code, index);
        pCache->Hashed.Face = *pFace = face;
        if (IntNeedRequestFontSize(pChain, face, Entry))
        {
            IntRequestFontSizeEx(face,
                                 pChain->LogFont.lfWidth,
                                 pChain->LogFont.lfHeight,
                                 NULL, NULL, NULL, NULL, NULL, NULL);
        }
        FT_Set_Transform(face, &pCache->Hashed.matTransform, NULL);
        return index;
    }
 
    // No target glyph found in the chain: use default glyph
    code = s_chFontLinkDefaultChar;
    index = get_glyph_index(*pFace, code);
    DPRINT("code: 0x%08X, index: 0x%08X\n", code, index);
    pCache->Hashed.Face = *pFace = pChain->pDefFace;
    return index;
}

Referenced by IntExtTextOutW(), IntGetTextDisposition(), and TextIntGetTextExtentPoint().

FontLink_Chain_FindLink()

static PFONTLINK FontLink_Chain_FindLink ( PFONTLINK_CHAIN  pChain, PLOGFONTW  plf  )

inlinestatic

Definition at line 1205 of file freetype.c.

{
    PLIST_ENTRY Entry, Head = &pChain->FontLinkList;
    PFONTLINK pLink;
 
    for (Entry = Head->Flink; Entry != Head; Entry = Entry->Flink)
    {
        pLink = CONTAINING_RECORD(Entry, FONTLINK, ListEntry);
        if (RtlEqualMemory(&pLink->LogFont, plf, sizeof(*plf)))
            return pLink;
    }
 
    return NULL;
}

Referenced by FontLink_Create().

FontLink_Chain_Init()

static VOID FontLink_Chain_Init ( _Out_ PFONTLINK_CHAIN  pChain, _Inout_ PTEXTOBJ  pTextObj, _In_ FT_Face  face  )

inlinestatic

Definition at line 1176 of file freetype.c.

{
    RtlZeroMemory(pChain, sizeof(*pChain));
    pChain->pBaseTextObj = pTextObj;
    pChain->pDefFace = face;
    ASSERT(!FontLink_Chain_IsPopulated(pChain));
}

Referenced by IntExtTextOutW(), and TextIntGetTextExtentPoint().

FontLink_Chain_IsPopulated()

static BOOL FontLink_Chain_IsPopulated ( const FONTLINK_CHAIN *  pChain )

inlinestatic

Definition at line 185 of file freetype.c.

{
    return pChain->LogFont.lfFaceName[0];
}

Referenced by FontLink_Chain_FindGlyph(), FontLink_Chain_Init(), and FontLink_Chain_Populate().

FontLink_Chain_Populate()

static NTSTATUS FontLink_Chain_Populate ( _Inout_ PFONTLINK_CHAIN  pChain )

static

Definition at line 1302 of file freetype.c.

{
    NTSTATUS Status;
    PFONTLINK pLink;
    LOGFONTW lfBase;
    PTEXTOBJ pTextObj = pChain->pBaseTextObj;
    PFONTGDI pFontGDI;
    PCWSTR pszLink;
    WCHAR szEntry[MAX_PATH];
    BOOL bFixCharSet;
 
    InitializeListHead(&pChain->FontLinkList);
 
    lfBase = pTextObj->logfont.elfEnumLogfontEx.elfLogFont;
    pFontGDI = ObjToGDI(pTextObj->Font, FONT);
    lfBase.lfHeight = pFontGDI->lfHeight;
    lfBase.lfWidth = pFontGDI->lfWidth;
 
    // Use pTextObj->TextFace if lfFaceName was empty
    if (!lfBase.lfFaceName[0])
    {
        ASSERT(pTextObj->TextFace[0]);
        RtlStringCchCopyW(lfBase.lfFaceName, _countof(lfBase.lfFaceName), pTextObj->TextFace);
    }
 
    // Fix lfCharSet
    switch (lfBase.lfCharSet)
    {
        case ANSI_CHARSET:   bFixCharSet = !s_fFontLinkUseAnsi;    break;
        case OEM_CHARSET:    bFixCharSet = !s_fFontLinkUseOem;     break;
        case SYMBOL_CHARSET: bFixCharSet = !s_fFontLinkUseSymbol;  break;
        default:             bFixCharSet = TRUE;                   break;
    }
    if (bFixCharSet)
        lfBase.lfCharSet = DEFAULT_CHARSET;
 
    pChain->LogFont = lfBase;
 
    // Load FontLink entry
    Status = FontLink_Chain_FindEntry(pChain, &pChain->LogFont);
    if (!NT_SUCCESS(Status))
        return Status;
 
    pszLink = pChain->pszzFontLink;
    while (*pszLink)
    {
        DPRINT("pszLink: '%S'\n", pszLink);
        pLink = FontLink_Create(pChain, &lfBase, pszLink);
        if (pLink)
            InsertTailList(&pChain->FontLinkList, &pLink->ListEntry);
        pszLink += wcslen(pszLink) + 1;
    }
 
    // Use default settings (if any)
    if (s_szDefFontLinkFileName[0] && s_szDefFontLinkFontName[0])
    {
        RtlStringCchCopyW(szEntry, _countof(szEntry), s_szDefFontLinkFileName);
        RtlStringCchCatW(szEntry, _countof(szEntry), L",");
        RtlStringCchCatW(szEntry, _countof(szEntry), s_szDefFontLinkFontName);
        DPRINT("szEntry: '%S'\n", szEntry);
        pLink = FontLink_Create(pChain, &lfBase, szEntry);
        if (pLink)
            InsertTailList(&pChain->FontLinkList, &pLink->ListEntry);
    }
 
    ASSERT(FontLink_Chain_IsPopulated(pChain));
    return Status;
}

Referenced by FontLink_Chain_FindGlyph().

FontLink_Create()

static PFONTLINK FontLink_Create ( _Inout_ PFONTLINK_CHAIN  pChain, _In_ const LOGFONTW *  plfBase, _In_ LPCWSTR  pszLink  )

inlinestatic

Definition at line 1223 of file freetype.c.

{
    LPWSTR pch0, pch1;
    LOGFONTW lf;
    PFONTLINK pLink;
 
    lf = *plfBase;
 
    // pszLink: "<FontFileName>,<FaceName>[,...]"
    pch0 = wcschr(pszLink, L',');
    if (!pch0)
    {
        DPRINT1("%S\n", pszLink);
        return NULL; // Invalid FontLink data
    }
    ++pch0;
 
    pch1 = wcschr(pch0, L',');
    if (pch1)
        RtlStringCchCopyNW(lf.lfFaceName, _countof(lf.lfFaceName), pch0, pch1 - pch0);
    else
        RtlStringCchCopyW(lf.lfFaceName, _countof(lf.lfFaceName), pch0);
 
    SubstituteFontRecurse(&lf);
    DPRINT("lfFaceName: %S\n", lf.lfFaceName);
 
    if (RtlEqualMemory(plfBase, &lf, sizeof(lf)) || FontLink_Chain_FindLink(pChain, &lf))
        return NULL; // Already exists
 
    pLink = ExAllocatePoolZero(PagedPool, sizeof(FONTLINK), TAG_FONT);
    if (!pLink)
        return NULL; // Out of memory
 
    pLink->LogFont = lf;
    return pLink;
}

Referenced by FontLink_Chain_Populate().

FontLink_DeleteEntries()

static void FontLink_DeleteEntries ( VOID  )

static

Definition at line 896 of file freetype.c.

{
    PLIST_ENTRY Entry;
    PFONTLINK_ENTRY pEntry;
 
    for (Entry = g_FontLinkEntries.Flink; Entry != &g_FontLinkEntries; Entry = Entry->Flink)
    {
        pEntry = CONTAINING_RECORD(Entry, FONTLINK_ENTRY, ListEntry);
        ExFreePoolWithTag(pEntry->pszzFontLink, TAG_FONT);
        ExFreePoolWithTag(pEntry, TAG_FONT);
    }
}

Referenced by FreeFontSupport().

FontLink_Destroy()

static VOID FontLink_Destroy ( _Inout_ PFONTLINK  pLink )

inlinestatic

Definition at line 179 of file freetype.c.

{
    ExFreePoolWithTag(pLink, TAG_FONT);
}

FontLink_FindEntry()

static PFONTLINK_ENTRY FontLink_FindEntry ( const LOGFONTW *  pLogFont )

static

Definition at line 1264 of file freetype.c.

{
    PLIST_ENTRY Entry;
    PFONTLINK_ENTRY pEntry;
    LOGFONTW lf = *pLogFont;
 
    SubstituteFontRecurse(&lf);
 
    for (Entry = g_FontLinkEntries.Flink; Entry != &g_FontLinkEntries; Entry = Entry->Flink)
    {
        pEntry = CONTAINING_RECORD(Entry, FONTLINK_ENTRY, ListEntry);
        if (!_wcsicmp(pEntry->lfFaceName, lf.lfFaceName))
            return pEntry;
    }
 
    return NULL;
}

Referenced by FontLink_Chain_FindEntry().

FontLink_LoadDefaultCharset()

static NTSTATUS FontLink_LoadDefaultCharset ( VOID  )

inlinestatic

Definition at line 133 of file freetype.c.

{
    NTSTATUS Status;
    HKEY hKey;
    DWORD cbData;
    WCHAR szValue[8];
 
    // Set the default values
    s_fFontLinkUseAnsi = s_fFontLinkUseOem = s_fFontLinkUseSymbol = FALSE;
 
    // Open the registry key
    Status = RegOpenKey(
        L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\FontAssoc\\Associated Charset",
        &hKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    cbData = sizeof(szValue);
    Status = RegQueryValue(hKey, L"ANSI(00)", REG_SZ, szValue, &cbData);
    if (NT_SUCCESS(Status))
    {
        szValue[_countof(szValue) - 1] = UNICODE_NULL; // Avoid buffer overrun
        s_fFontLinkUseAnsi = !_wcsicmp(szValue, L"YES");
    }
 
    cbData = sizeof(szValue);
    Status = RegQueryValue(hKey, L"OEM(FF)", REG_SZ, szValue, &cbData);
    if (NT_SUCCESS(Status))
    {
        szValue[_countof(szValue) - 1] = UNICODE_NULL; // Avoid buffer overrun
        s_fFontLinkUseOem = !_wcsicmp(szValue, L"YES");
    }
 
    cbData = sizeof(szValue);
    Status = RegQueryValue(hKey, L"SYMBOL(02)", REG_SZ, szValue, &cbData);
    if (NT_SUCCESS(Status))
    {
        szValue[_countof(szValue) - 1] = UNICODE_NULL; // Avoid buffer overrun
        s_fFontLinkUseSymbol = !_wcsicmp(szValue, L"YES");
    }
 
    ZwClose(hKey); // Close the registry key
    return STATUS_SUCCESS;
}

Referenced by InitFontSupport().

FontLink_LoadDefaultFonts()

static NTSTATUS FontLink_LoadDefaultFonts ( VOID  )

inlinestatic

Definition at line 95 of file freetype.c.

{
    NTSTATUS Status;
    HKEY hKey;
    DWORD cbData;
    WCHAR szValue[MAX_PATH];
 
    // Set the default values
    s_szDefFontLinkFileName[0] = s_szDefFontLinkFontName[0] = UNICODE_NULL;
 
    // Open the registry key
    Status = RegOpenKey(
        L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\FontAssoc\\Associated DefaultFonts",
        &hKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    cbData = sizeof(szValue);
    Status = RegQueryValue(hKey, L"AssocSystemFont", REG_SZ, szValue, &cbData);
    if (NT_SUCCESS(Status))
    {
        szValue[_countof(szValue) - 1] = UNICODE_NULL; // Avoid buffer overrun
        RtlStringCchCopyW(s_szDefFontLinkFileName, _countof(s_szDefFontLinkFileName), szValue);
    }
 
    cbData = sizeof(szValue);
    Status = RegQueryValue(hKey, L"FontPackage", REG_SZ, szValue, &cbData);
    if (NT_SUCCESS(Status))
    {
        szValue[_countof(szValue) - 1] = UNICODE_NULL; // Avoid buffer overrun
        RtlStringCchCopyW(s_szDefFontLinkFontName, _countof(s_szDefFontLinkFontName), szValue);
    }
 
    ZwClose(hKey); // Close the registry key
    return STATUS_SUCCESS;
}

Referenced by InitFontSupport().

FontLink_LoadSettings()

static NTSTATUS FontLink_LoadSettings ( VOID  )

inlinestatic

Definition at line 69 of file freetype.c.

{
    NTSTATUS Status;
    HKEY hKey;
    DWORD cbData, dwValue;
 
    // Set the default values
    s_chFontLinkDefaultChar = FONTLINK_DEFAULT_CHAR;
 
    // Open the registry key
    Status = RegOpenKey(
        L"\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\FontLink",
        &hKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    cbData = sizeof(dwValue);
    Status = RegQueryValue(hKey, L"FontLinkDefaultChar", REG_DWORD, &dwValue, &cbData);
    if (NT_SUCCESS(Status) && cbData == sizeof(dwValue))
        s_chFontLinkDefaultChar = dwValue;
 
    ZwClose(hKey); // Close the registry key
    return STATUS_SUCCESS;
}

Referenced by InitFontSupport().

FontLink_PopulateEntries()

static NTSTATUS FontLink_PopulateEntries ( VOID  )

static

Definition at line 909 of file freetype.c.

{
    NTSTATUS Status;
    HKEY hKey;
    DWORD cchName, cbData, dwType;
    WCHAR szName[LF_FACESIZE], szzFontLink[300];
 
    // Open the registry key
    Status = RegOpenKey(
        L"\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\FontLink\\SystemLink",
        &hKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    for (DWORD dwIndex = 0;; ++dwIndex)
    {
        cchName = _countof(szName);
        cbData = sizeof(szzFontLink);
        Status = RegEnumValueW(hKey, dwIndex, szName, &cchName, &dwType, szzFontLink, &cbData);
        if (!NT_SUCCESS(Status))
            break;
        if (dwType != REG_MULTI_SZ)
            continue;
 
        // Ensure double-NUL-terminated
        szzFontLink[_countof(szzFontLink) - 1] = UNICODE_NULL;
        szzFontLink[_countof(szzFontLink) - 2] = UNICODE_NULL;
 
        DPRINT("szName: %S\n", szName);
        DPRINT("szzFontLink: %S\n", szzFontLink);
 
        FontLink_AddEntry(szName, szzFontLink);
    }
 
    ZwClose(hKey); // Close the registry key
    return STATUS_SUCCESS;
}

Referenced by InitFontSupport().

FontLink_PrepareFontInfo()

static BOOL FontLink_PrepareFontInfo ( _Inout_ PFONTLINK  pFontLink )

static

Definition at line 349 of file freetype.c.

{
    FONTOBJ *pFontObj;
    ULONG MatchPenalty;
    UNICODE_STRING FaceName;
    PPROCESSINFO Win32Process;
    PFONTGDI pFontGDI;
 
    ASSERT_FREETYPE_LOCK_HELD();
 
    if (pFontLink->bIgnore)
        return FALSE;
 
    if (pFontLink->SharedFace)
        return TRUE;
 
    MatchPenalty = MAXULONG;
    pFontObj = NULL;
 
    // Search private fonts
    Win32Process = PsGetCurrentProcessWin32Process();
    FindBestFontFromList(&pFontObj, &MatchPenalty, &pFontLink->LogFont,
                         &Win32Process->PrivateFontListHead);
 
    // Search system fonts
    FindBestFontFromList(&pFontObj, &MatchPenalty, &pFontLink->LogFont,
                         &g_FontListHead);
 
    if (!pFontObj) // Not found?
    {
        pFontLink->bIgnore = TRUE;
        return FALSE;
    }
 
    pFontGDI = ObjToGDI(pFontObj, FONT);
    pFontLink->SharedFace = pFontGDI->SharedFace;
 
    // FontLink uses family name
    RtlInitUnicodeString(&FaceName, pFontLink->LogFont.lfFaceName);
    if (!MatchFontName(pFontLink->SharedFace, &FaceName, TT_NAME_ID_FONT_FAMILY, LANG_ENGLISH) &&
        !MatchFontName(pFontLink->SharedFace, &FaceName, TT_NAME_ID_FONT_FAMILY, gusLanguageID))
    {
        pFontLink->bIgnore = TRUE;
        return FALSE;
    }
 
    return TRUE;
}

Referenced by FontLink_Chain_FindGlyph(), and IntNeedRequestFontSize().

FreeFontSupport()

VOID FASTCALL FreeFontSupport

(

VOID

)

Definition at line 991 of file freetype.c.

{
    PLIST_ENTRY pHead, pEntry;
    PFONT_CACHE_ENTRY pFontCache;
    PFONTSUBST_ENTRY pSubstEntry;
    PFONT_ENTRY pFontEntry;
 
    // Free font cache list
    pHead = &g_FontCacheListHead;
    while (!IsListEmpty(pHead))
    {
        pEntry = RemoveHeadList(pHead);
        pFontCache = CONTAINING_RECORD(pEntry, FONT_CACHE_ENTRY, ListEntry);
        RemoveCachedEntry(pFontCache);
    }
 
    // Free font subst list
    pHead = &g_FontSubstListHead;
    while (!IsListEmpty(pHead))
    {
        pEntry = RemoveHeadList(pHead);
        pSubstEntry = CONTAINING_RECORD(pEntry, FONTSUBST_ENTRY, ListEntry);
        ExFreePoolWithTag(pSubstEntry, TAG_FONT);
    }
 
    // Free font list
    pHead = &g_FontListHead;
    while (!IsListEmpty(pHead))
    {
        pEntry = RemoveHeadList(pHead);
        pFontEntry = CONTAINING_RECORD(pEntry, FONT_ENTRY, ListEntry);
        CleanupFontEntry(pFontEntry);
    }
 
    FontLink_DeleteEntries();
 
    if (g_FreeTypeLibrary)
    {
        FT_Done_Library(g_FreeTypeLibrary);
        g_FreeTypeLibrary = NULL;
    }
 
    ExFreePoolWithTag(g_FreeTypeLock, TAG_INTERNAL_SYNC);
    g_FreeTypeLock = NULL;
}

Referenced by _Function_class_().

FT_FixedFromFIXED()

static __inline FT_Fixed FT_FixedFromFIXED ( FIXED  f )

static

Definition at line 592 of file freetype.c.

{
    return (FT_Fixed)((long)f.value << 16 | (unsigned long)f.fract);
}

Referenced by ftGdiGetGlyphOutline().

ftGdiGetFontData()

DWORD FASTCALL ftGdiGetFontData	(	PFONTGDI	FontGdi,
		DWORD	Table,
		DWORD	Offset,
		PVOID	Buffer,
		DWORD	Size
	)

Definition at line 5373 of file freetype.c.

{
    DWORD Result = GDI_ERROR;
    FT_Face Face = FontGdi->SharedFace->Face;
 
    IntLockFreeType();
 
    if (FT_IS_SFNT(Face))
    {
        if (Table)
            Table = Table >> 24 | Table << 24 | (Table >> 8 & 0xFF00) |
                    (Table << 8 & 0xFF0000);
 
        if (!Buffer) Size = 0;
 
        if (Buffer && Size)
        {
            FT_Error Error;
            FT_ULong Needed = 0;
 
            Error = FT_Load_Sfnt_Table(Face, Table, Offset, NULL, &Needed);
 
            if ( !Error && Needed < Size) Size = Needed;
        }
        if (!FT_Load_Sfnt_Table(Face, Table, Offset, Buffer, &Size))
            Result = Size;
    }
 
    IntUnLockFreeType();
 
    return Result;
}

Referenced by NtGdiGetFontData().

ftGdiGetGlyphOutline()

ULONG FASTCALL ftGdiGetGlyphOutline	(	PDC	dc,
		WCHAR	wch,
		UINT	iFormat,
		LPGLYPHMETRICS	pgm,
		ULONG	cjBuf,
		PVOID	pvBuf,
		const MAT2 *	pmat2,
		BOOL	bIgnoreRotation
	)

Definition at line 4434 of file freetype.c.

{
    PDC_ATTR pdcattr;
    PTEXTOBJ TextObj;
    PFONTGDI FontGDI;
    HFONT hFont = 0;
    GLYPHMETRICS gm;
    ULONG Size;
    FT_Face ft_face;
    FT_UInt glyph_index;
    DWORD width, height, pitch, needed = 0;
    FT_Bitmap ft_bitmap;
    FT_Error error;
    INT left, right, top = 0, bottom = 0;
    FT_Int load_flags = FT_LOAD_DEFAULT | FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH;
    FLOATOBJ eM11, widthRatio, eTemp;
    FT_Matrix mat, transMat = identityMat;
    BOOL needsTransform = FALSE;
    INT orientation;
    LONG aveWidth;
    INT adv, lsb, bbx; /* These three hold to widths of the unrotated chars */
    OUTLINETEXTMETRICW *potm;
    XFORMOBJ xo;
    XFORML xform;
    LOGFONTW *plf;
 
    DPRINT("%u, %08x, %p, %08lx, %p, %p\n", wch, iFormat, pgm,
           cjBuf, pvBuf, pmat2);
 
    pdcattr = dc->pdcattr;
 
    XFORMOBJ_vInit(&xo, &dc->pdcattr->mxWorldToDevice);
    XFORMOBJ_iGetXform(&xo, &xform);
    FLOATOBJ_SetFloat(&eM11, xform.eM11);
 
    hFont = pdcattr->hlfntNew;
    TextObj = RealizeFontInit(hFont);
 
    if (!TextObj)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return GDI_ERROR;
    }
    FontGDI = ObjToGDI(TextObj->Font, FONT);
    ft_face = FontGDI->SharedFace->Face;
 
    plf = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
    aveWidth = FT_IS_SCALABLE(ft_face) ? abs(plf->lfWidth) : 0;
    orientation = FT_IS_SCALABLE(ft_face) ? plf->lfOrientation : 0;
 
    ASSERT_FREETYPE_LOCK_NOT_HELD();
    Size = IntGetOutlineTextMetrics(FontGDI, 0, NULL, FALSE);
    if (!Size)
    {
        TEXTOBJ_UnlockText(TextObj);
        EngSetLastError(ERROR_GEN_FAILURE);
        return GDI_ERROR;
    }
    potm = ExAllocatePoolWithTag(PagedPool, Size, GDITAG_TEXT);
    if (!potm)
    {
        TEXTOBJ_UnlockText(TextObj);
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return GDI_ERROR;
    }
    ASSERT_FREETYPE_LOCK_NOT_HELD();
    Size = IntGetOutlineTextMetrics(FontGDI, Size, potm, FALSE);
    if (!Size)
    {
        ExFreePoolWithTag(potm, GDITAG_TEXT);
        TEXTOBJ_UnlockText(TextObj);
        EngSetLastError(ERROR_GEN_FAILURE);
        return GDI_ERROR;
    }
 
    IntLockFreeType();
    if (!TextIntUpdateSize(TextObj, FontGDI, FALSE))
    {
        IntUnLockFreeType();
        ExFreePoolWithTag(potm, GDITAG_TEXT);
        TEXTOBJ_UnlockText(TextObj);
        EngSetLastError(ERROR_GEN_FAILURE);
        return GDI_ERROR;
    }
    IntMatrixFromMx(&mat, DC_pmxWorldToDevice(dc));
    FT_Set_Transform(ft_face, &mat, NULL);
 
    TEXTOBJ_UnlockText(TextObj);
 
    glyph_index = get_glyph_index_flagged(ft_face, wch, (iFormat & GGO_GLYPH_INDEX));
    iFormat &= ~GGO_GLYPH_INDEX;
 
    if (orientation || (iFormat != GGO_METRICS && iFormat != GGO_BITMAP) || aveWidth || pmat2)
        load_flags |= FT_LOAD_NO_BITMAP;
 
    if (iFormat & GGO_UNHINTED)
    {
        load_flags |= FT_LOAD_NO_HINTING;
        iFormat &= ~GGO_UNHINTED;
    }
 
    error = FT_Load_Glyph(ft_face, glyph_index, load_flags);
    IntUnLockFreeType();
 
    if (error)
    {
        DPRINT1("WARNING: Failed to load and render glyph! [index: %u]\n", glyph_index);
        ExFreePoolWithTag(potm, GDITAG_TEXT);
        return GDI_ERROR;
    }
 
    FLOATOBJ_Set1(&widthRatio);
    if (aveWidth && potm)
    {
        // widthRatio = aveWidth * eM11 / potm->otmTextMetrics.tmAveCharWidth
        FLOATOBJ_SetLong(&widthRatio, aveWidth);
        FLOATOBJ_Mul(&widthRatio, &eM11);
        FLOATOBJ_DivLong(&widthRatio, potm->otmTextMetrics.tmAveCharWidth);
    }
 
    //left = (INT)(ft_face->glyph->metrics.horiBearingX * widthRatio) & -64;
    FLOATOBJ_SetLong(&eTemp, ft_face->glyph->metrics.horiBearingX);
    FLOATOBJ_Mul(&eTemp, &widthRatio);
    left = FLOATOBJ_GetLong(&eTemp) & -64;
 
    //right = (INT)((ft_face->glyph->metrics.horiBearingX +
    //               ft_face->glyph->metrics.width) * widthRatio + 63) & -64;
    FLOATOBJ_SetLong(&eTemp, ft_face->glyph->metrics.horiBearingX * ft_face->glyph->metrics.width);
    FLOATOBJ_Mul(&eTemp, &widthRatio);
    FLOATOBJ_AddLong(&eTemp, 63);
    right = FLOATOBJ_GetLong(&eTemp) & -64;
 
    //adv = (INT)((ft_face->glyph->metrics.horiAdvance * widthRatio) + 63) >> 6;
    FLOATOBJ_SetLong(&eTemp, ft_face->glyph->metrics.horiAdvance);
    FLOATOBJ_Mul(&eTemp, &widthRatio);
    FLOATOBJ_AddLong(&eTemp, 63);
    adv = FLOATOBJ_GetLong(&eTemp) >> 6;
 
    lsb = left >> 6;
    bbx = (right - left) >> 6;
 
    DPRINT("Advance = %d, lsb = %d, bbx = %d\n",adv, lsb, bbx);
 
    IntLockFreeType();
 
    /* Width scaling transform */
    if (!FLOATOBJ_Equal1(&widthRatio))
    {
        FT_Matrix scaleMat;
 
        eTemp = widthRatio;
        FLOATOBJ_MulLong(&eTemp, 1 << 16);
 
        scaleMat.xx = FLOATOBJ_GetLong(&eTemp);
        scaleMat.xy = 0;
        scaleMat.yx = 0;
        scaleMat.yy = INT_TO_FIXED(1);
        FT_Matrix_Multiply(&scaleMat, &transMat);
        needsTransform = TRUE;
    }
 
    /* World transform */
    {
        FT_Matrix ftmatrix;
        PMATRIX pmx = DC_pmxWorldToDevice(dc);
 
        /* Create a freetype matrix, by converting to 16.16 fixpoint format */
        IntMatrixFromMx(&ftmatrix, pmx);
 
        if (memcmp(&ftmatrix, &identityMat, sizeof(identityMat)) != 0)
        {
            FT_Matrix_Multiply(&ftmatrix, &transMat);
            needsTransform = TRUE;
        }
    }
 
    /* Rotation transform */
    if (orientation)
    {
        FT_Matrix rotationMat;
        DPRINT("Rotation Trans!\n");
        IntEscapeMatrix(&rotationMat, orientation);
        FT_Matrix_Multiply(&rotationMat, &transMat);
        needsTransform = TRUE;
    }
 
    /* Extra transformation specified by caller */
    if (pmat2)
    {
        FT_Matrix extraMat;
        DPRINT("MAT2 Matrix Trans!\n");
        extraMat.xx = FT_FixedFromFIXED(pmat2->eM11);
        extraMat.xy = FT_FixedFromFIXED(pmat2->eM21);
        extraMat.yx = FT_FixedFromFIXED(pmat2->eM12);
        extraMat.yy = FT_FixedFromFIXED(pmat2->eM22);
        FT_Matrix_Multiply(&extraMat, &transMat);
        needsTransform = TRUE;
    }
 
    if (potm) ExFreePoolWithTag(potm, GDITAG_TEXT); /* It looks like we are finished with potm ATM. */
 
    if (!needsTransform)
    {
        DPRINT("No Need to be Transformed!\n");
        top = (ft_face->glyph->metrics.horiBearingY + 63) & -64;
        bottom = (ft_face->glyph->metrics.horiBearingY -
                  ft_face->glyph->metrics.height) & -64;
        gm.gmCellIncX = adv;
        gm.gmCellIncY = 0;
    }
    else
    {
        INT xc, yc;
        FT_Vector vec;
        for (xc = 0; xc < 2; xc++)
        {
            for (yc = 0; yc < 2; yc++)
            {
                vec.x = (ft_face->glyph->metrics.horiBearingX +
                         xc * ft_face->glyph->metrics.width);
                vec.y = ft_face->glyph->metrics.horiBearingY -
                        yc * ft_face->glyph->metrics.height;
                DPRINT("Vec %ld,%ld\n", vec.x, vec.y);
                FT_Vector_Transform(&vec, &transMat);
                if (xc == 0 && yc == 0)
                {
                    left = right = vec.x;
                    top = bottom = vec.y;
                }
                else
                {
                    if (vec.x < left) left = vec.x;
                    else if (vec.x > right) right = vec.x;
                    if (vec.y < bottom) bottom = vec.y;
                    else if (vec.y > top) top = vec.y;
                }
            }
        }
        left = left & -64;
        right = (right + 63) & -64;
        bottom = bottom & -64;
        top = (top + 63) & -64;
 
        DPRINT("Transformed box: (%d,%d - %d,%d)\n", left, top, right, bottom);
        vec.x = ft_face->glyph->metrics.horiAdvance;
        vec.y = 0;
        FT_Vector_Transform(&vec, &transMat);
        gm.gmCellIncX = (vec.x+63) >> 6;
        gm.gmCellIncY = -((vec.y+63) >> 6);
    }
    gm.gmBlackBoxX = (right - left) >> 6;
    gm.gmBlackBoxY = (top - bottom) >> 6;
    gm.gmptGlyphOrigin.x = left >> 6;
    gm.gmptGlyphOrigin.y = top >> 6;
 
    DPRINT("CX %d CY %d BBX %u BBY %u GOX %d GOY %d\n",
           gm.gmCellIncX, gm.gmCellIncY,
           gm.gmBlackBoxX, gm.gmBlackBoxY,
           gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
 
    IntUnLockFreeType();
 
    if (iFormat == GGO_METRICS)
    {
        DPRINT("GGO_METRICS Exit!\n");
        *pgm = gm;
        return 1; /* FIXME */
    }
 
    if (ft_face->glyph->format != ft_glyph_format_outline && iFormat != GGO_BITMAP)
    {
        DPRINT1("Loaded a bitmap\n");
        return GDI_ERROR;
    }
 
    switch (iFormat)
    {
    case GGO_BITMAP:
    {
        width = gm.gmBlackBoxX;
        height = gm.gmBlackBoxY;
        pitch = ((width + 31) >> 5) << 2;
        needed = pitch * height;
 
        if (!pvBuf || !cjBuf) break;
        if (!needed) return GDI_ERROR;  /* empty glyph */
        if (needed > cjBuf)
            return GDI_ERROR;
 
        switch (ft_face->glyph->format)
        {
        case ft_glyph_format_bitmap:
        {
            BYTE *src = ft_face->glyph->bitmap.buffer, *dst = pvBuf;
            INT w = min( pitch, (ft_face->glyph->bitmap.width + 7) >> 3 );
            INT h = min( height, ft_face->glyph->bitmap.rows );
            while (h--)
            {
                RtlCopyMemory(dst, src, w);
                src += ft_face->glyph->bitmap.pitch;
                dst += pitch;
            }
            break;
        }
 
        case ft_glyph_format_outline:
        {
            ft_bitmap.width = width;
            ft_bitmap.rows = height;
            ft_bitmap.pitch = pitch;
            ft_bitmap.pixel_mode = FT_PIXEL_MODE_MONO;
            ft_bitmap.buffer = pvBuf;
 
            IntLockFreeType();
            if (needsTransform)
            {
                FT_Outline_Transform(&ft_face->glyph->outline, &transMat);
            }
            FT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
            /* Note: FreeType will only set 'black' bits for us. */
            RtlZeroMemory(pvBuf, needed);
            FT_Outline_Get_Bitmap(g_FreeTypeLibrary, &ft_face->glyph->outline, &ft_bitmap);
            IntUnLockFreeType();
            break;
        }
 
        default:
            DPRINT1("Loaded glyph format %x\n", ft_face->glyph->format);
            return GDI_ERROR;
        }
 
        break;
    }
 
    case GGO_GRAY2_BITMAP:
    case GGO_GRAY4_BITMAP:
    case GGO_GRAY8_BITMAP:
    {
        unsigned int mult, row, col;
        BYTE *start, *ptr;
 
        width = gm.gmBlackBoxX;
        height = gm.gmBlackBoxY;
        pitch = (width + 3) / 4 * 4;
        needed = pitch * height;
 
        if (!pvBuf || !cjBuf) break;
        if (!needed) return GDI_ERROR;  /* empty glyph */
        if (needed > cjBuf)
            return GDI_ERROR;
 
        switch (ft_face->glyph->format)
        {
        case ft_glyph_format_bitmap:
        {
            BYTE *src = ft_face->glyph->bitmap.buffer, *dst = pvBuf;
            INT h = min( height, ft_face->glyph->bitmap.rows );
            INT x;
            while (h--)
            {
                for (x = 0; (UINT)x < pitch; x++)
                {
                    if (x < ft_face->glyph->bitmap.width)
                        dst[x] = (src[x / 8] & (1 << ( (7 - (x % 8))))) ? 0xff : 0;
                    else
                        dst[x] = 0;
                }
                src += ft_face->glyph->bitmap.pitch;
                dst += pitch;
            }
            break;
        }
        case ft_glyph_format_outline:
        {
            ft_bitmap.width = width;
            ft_bitmap.rows = height;
            ft_bitmap.pitch = pitch;
            ft_bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
            ft_bitmap.buffer = pvBuf;
 
            IntLockFreeType();
            if (needsTransform)
            {
                FT_Outline_Transform(&ft_face->glyph->outline, &transMat);
            }
            FT_Outline_Translate(&ft_face->glyph->outline, -left, -bottom );
            RtlZeroMemory(ft_bitmap.buffer, cjBuf);
            FT_Outline_Get_Bitmap(g_FreeTypeLibrary, &ft_face->glyph->outline, &ft_bitmap);
            IntUnLockFreeType();
 
            if (iFormat == GGO_GRAY2_BITMAP)
                mult = 4;
            else if (iFormat == GGO_GRAY4_BITMAP)
                mult = 16;
            else if (iFormat == GGO_GRAY8_BITMAP)
                mult = 64;
            else
            {
                return GDI_ERROR;
            }
 
            start = pvBuf;
            for (row = 0; row < height; row++)
            {
                ptr = start;
                for (col = 0; col < width; col++, ptr++)
                {
                    *ptr = (((int)*ptr) * mult + 128) / 256;
                }
                start += pitch;
            }
 
            break;
        }
        default:
            DPRINT1("Loaded glyph format %x\n", ft_face->glyph->format);
            return GDI_ERROR;
        }
 
        break;
    }
 
    case GGO_NATIVE:
    {
        FT_Outline *outline = &ft_face->glyph->outline;
 
        if (cjBuf == 0) pvBuf = NULL; /* This is okay, need cjBuf to allocate. */
 
        IntLockFreeType();
        if (needsTransform && pvBuf) FT_Outline_Transform(outline, &transMat);
 
        needed = get_native_glyph_outline(outline, cjBuf, NULL);
 
        if (!pvBuf || !cjBuf)
        {
            IntUnLockFreeType();
            break;
        }
        if (needed > cjBuf)
        {
            IntUnLockFreeType();
            return GDI_ERROR;
        }
        get_native_glyph_outline(outline, cjBuf, pvBuf);
        IntUnLockFreeType();
        break;
    }
 
    case GGO_BEZIER:
    {
        FT_Outline *outline = &ft_face->glyph->outline;
        if (cjBuf == 0) pvBuf = NULL;
 
        if (needsTransform && pvBuf)
        {
            IntLockFreeType();
            FT_Outline_Transform(outline, &transMat);
            IntUnLockFreeType();
        }
        needed = get_bezier_glyph_outline(outline, cjBuf, NULL);
 
        if (!pvBuf || !cjBuf)
            break;
        if (needed > cjBuf)
            return GDI_ERROR;
 
        get_bezier_glyph_outline(outline, cjBuf, pvBuf);
        break;
    }
 
    default:
        DPRINT1("Unsupported format %u\n", iFormat);
        return GDI_ERROR;
    }
 
    DPRINT("ftGdiGetGlyphOutline END and needed %lu\n", needed);
 
    if (gm.gmBlackBoxX == 0)
        gm.gmBlackBoxX = 1;
    if (gm.gmBlackBoxY == 0)
        gm.gmBlackBoxY = 1;
 
    *pgm = gm;
    return needed;
}

Referenced by NtGdiGetGlyphOutline(), and PATH_ExtTextOut().

ftGdiGetKerningPairs()

DWORD FASTCALL ftGdiGetKerningPairs	(	PFONTGDI	Font,
		DWORD	cPairs,
		LPKERNINGPAIR	pKerningPair
	)

Definition at line 6391 of file freetype.c.

{
    DWORD Count = 0;
    INT i = 0;
    FT_Face face = Font->SharedFace->Face;
 
    if (FT_HAS_KERNING(face) && face->charmap->encoding == FT_ENCODING_UNICODE)
    {
        FT_UInt previous_index = 0, glyph_index = 0;
        FT_ULong char_code, char_previous;
        FT_Vector delta;
 
        char_previous = char_code = FT_Get_First_Char(face, &glyph_index);
 
        IntLockFreeType();
 
        while (glyph_index)
        {
            if (previous_index && glyph_index)
            {
                FT_Get_Kerning(face, previous_index, glyph_index, FT_KERNING_DEFAULT, &delta);
 
                if (pKerningPair && cPairs)
                {
                    pKerningPair[i].wFirst      = char_previous;
                    pKerningPair[i].wSecond     = char_code;
                    pKerningPair[i].iKernAmount = delta.x;
                    i++;
                    if (i == cPairs) break;
                }
                Count++;
            }
            previous_index = glyph_index;
            char_previous = char_code;
            char_code = FT_Get_Next_Char(face, char_code, &glyph_index);
        }
        IntUnLockFreeType();
    }
    return Count;
}

Referenced by GreGetKerningPairs(), and NtGdiGetKerningPairs().

ftGdiGetRasterizerCaps()

BOOL FASTCALL ftGdiGetRasterizerCaps

(

LPRASTERIZER_STATUS

lprs

)

Definition at line 3752 of file freetype.c.

{
    if ( lprs )
    {
        lprs->nSize = sizeof(RASTERIZER_STATUS);
        lprs->wFlags = TT_AVAILABLE | TT_ENABLED;
        lprs->nLanguageID = gusLanguageID;
        return TRUE;
    }
    EngSetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
}

Referenced by NtGdiGetRasterizerCaps().

ftGdiGetTextCharsetInfo()

INT FASTCALL ftGdiGetTextCharsetInfo	(	PDC	Dc,
		LPFONTSIGNATURE	lpSig,
		DWORD	dwFlags
	)

Definition at line 5093 of file freetype.c.

{
    PDC_ATTR pdcattr;
    UINT Ret = DEFAULT_CHARSET;
    INT i;
    HFONT hFont;
    PTEXTOBJ TextObj;
    PFONTGDI FontGdi;
    FONTSIGNATURE fs;
    TT_OS2 *pOS2;
    FT_Face Face;
    CHARSETINFO csi;
    DWORD cp, fs0;
    USHORT usACP, usOEM;
 
    pdcattr = Dc->pdcattr;
    hFont = pdcattr->hlfntNew;
    TextObj = RealizeFontInit(hFont);
 
    if (!TextObj)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return Ret;
    }
    FontGdi = ObjToGDI(TextObj->Font, FONT);
    Face = FontGdi->SharedFace->Face;
    TEXTOBJ_UnlockText(TextObj);
 
    memset(&fs, 0, sizeof(FONTSIGNATURE));
    IntLockFreeType();
    pOS2 = FT_Get_Sfnt_Table(Face, ft_sfnt_os2);
    if (NULL != pOS2)
    {
        fs.fsCsb[0] = pOS2->ulCodePageRange1;
        fs.fsCsb[1] = pOS2->ulCodePageRange2;
        fs.fsUsb[0] = pOS2->ulUnicodeRange1;
        fs.fsUsb[1] = pOS2->ulUnicodeRange2;
        fs.fsUsb[2] = pOS2->ulUnicodeRange3;
        fs.fsUsb[3] = pOS2->ulUnicodeRange4;
        if (pOS2->version == 0)
        {
            FT_UInt dummy;
 
            if (FT_Get_First_Char( Face, &dummy ) < 0x100)
                fs.fsCsb[0] |= FS_LATIN1;
            else
                fs.fsCsb[0] |= FS_SYMBOL;
        }
    }
    pOS2 = NULL;
    IntUnLockFreeType();
    DPRINT("Csb 1=%x  0=%x\n", fs.fsCsb[1],fs.fsCsb[0]);
    if (fs.fsCsb[0] == 0)
    { /* Let's see if we can find any interesting cmaps */
        for (i = 0; i < Face->num_charmaps; i++)
        {
            switch (Face->charmaps[i]->encoding)
            {
            case FT_ENCODING_UNICODE:
            case FT_ENCODING_APPLE_ROMAN:
                fs.fsCsb[0] |= FS_LATIN1;
                break;
            case FT_ENCODING_MS_SYMBOL:
                fs.fsCsb[0] |= FS_SYMBOL;
                break;
            default:
                break;
            }
        }
    }
    if (lpSig)
    {
        RtlCopyMemory(lpSig, &fs, sizeof(FONTSIGNATURE));
    }
 
    RtlGetDefaultCodePage(&usACP, &usOEM);
    cp = usACP;
 
    if (IntTranslateCharsetInfo(&cp, &csi, TCI_SRCCODEPAGE))
        if (csi.fs.fsCsb[0] & fs.fsCsb[0])
        {
            DPRINT("Hit 1\n");
            Ret = csi.ciCharset;
            goto Exit;
        }
 
    for (i = 0; i < MAXTCIINDEX; i++)
    {
        fs0 = 1L << i;
        if (fs.fsCsb[0] & fs0)
        {
            if (IntTranslateCharsetInfo(&fs0, &csi, TCI_SRCFONTSIG))
            {
                // *cp = csi.ciACP;
                DPRINT("Hit 2\n");
                Ret = csi.ciCharset;
                goto Exit;
            }
            else
                DPRINT1("TCI failing on %x\n", fs0);
        }
    }
Exit:
    DPRINT("CharSet %u CodePage %u\n", csi.ciCharset, csi.ciACP);
    return (MAKELONG(csi.ciACP, csi.ciCharset));
}

Referenced by DC_InitHack(), IntGetFontLanguageInfo(), NtGdiGetCharSet(), and NtGdiGetTextCharsetInfo().

ftGdiGetTextMetricsW()

BOOL FASTCALL ftGdiGetTextMetricsW	(	HDC	hDC,
		PTMW_INTERNAL	ptmwi
	)

Definition at line 5289 of file freetype.c.

{
    PDC dc;
    PDC_ATTR pdcattr;
    PTEXTOBJ TextObj;
    TT_OS2 *pOS2;
    TT_HoriHeader *pHori;
    FT_WinFNT_HeaderRec Win;
    NTSTATUS Status = STATUS_SUCCESS;
 
    if (!ptmwi)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    RtlZeroMemory(ptmwi, sizeof(TMW_INTERNAL));
 
    if (!(dc = DC_LockDc(hDC)))
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    pdcattr = dc->pdcattr;
    TextObj = RealizeFontInit(pdcattr->hlfntNew);
    if (NULL != TextObj)
    {
        PFONTGDI FontGDI = ObjToGDI(TextObj->Font, FONT);
 
        // NOTE: GetTextMetrics simply ignores lfEscapement and XFORM.
        IntLockFreeType();
        if (!TextIntUpdateSize(TextObj, FontGDI, FALSE))
        {
            Status = STATUS_UNSUCCESSFUL;
        }
        else
        {
            FT_Face Face = FontGDI->SharedFace->Face;
            FT_Error Error;
 
            Status = STATUS_SUCCESS;
 
            FT_Set_Transform(Face, NULL, NULL);
 
            Error = FT_Get_WinFNT_Header(Face, &Win);
            pOS2 = FT_Get_Sfnt_Table(Face, ft_sfnt_os2);
            pHori = FT_Get_Sfnt_Table(Face, ft_sfnt_hhea);
 
            if (!pOS2 && Error)
            {
                DPRINT1("Can't find OS/2 table - not TT font?\n");
                Status = STATUS_INTERNAL_ERROR;
            }
            if (!pHori && Error)
            {
                DPRINT1("Can't find HHEA table - not TT font?\n");
                Status = STATUS_INTERNAL_ERROR;
            }
            if (NT_SUCCESS(Status))
            {
                FillTM(&ptmwi->TextMetric, FontGDI, pOS2, pHori, (Error ? NULL : &Win));
                /* FIXME: Fill Diff member */
            }
        }
        IntUnLockFreeType();
        TEXTOBJ_UnlockText(TextObj);
    }
    else
    {
        Status = STATUS_INVALID_HANDLE;
    }
    DC_UnlockDc(dc);
 
    if (!NT_SUCCESS(Status))
    {
        SetLastNtError(Status);
        return FALSE;
    }
    return TRUE;
}

Referenced by GreGetTextMetricsW(), IntGetCharDimensions(), and NtGdiGetTextMetricsW().

ftGdiRealizationInfo()

BOOL FASTCALL ftGdiRealizationInfo	(	PFONTGDI	Font,
		PREALIZATION_INFO	Info
	)

Definition at line 6372 of file freetype.c.

{
    if (FT_HAS_FIXED_SIZES(Font->SharedFace->Face))
        Info->iTechnology = RI_TECH_BITMAP;
    else
    {
        if (FT_IS_SCALABLE(Font->SharedFace->Face))
            Info->iTechnology = RI_TECH_SCALABLE;
        else
            Info->iTechnology = RI_TECH_FIXED;
    }
    Info->iUniq = Font->FontObj.iUniq;
    Info->dwUnknown = -1;
    return TRUE;
}

Referenced by NtGdiGetRealizationInfo().

ftGetFontUnicodeRanges()

DWORD FASTCALL ftGetFontUnicodeRanges	(	PFONTGDI	Font,
		PGLYPHSET	glyphset
	)

Definition at line 5206 of file freetype.c.

{
    DWORD size = 0;
    DWORD num_ranges = 0;
    FT_Face face = Font->SharedFace->Face;
 
    if (face->charmap == NULL)
    {
        DPRINT1("FIXME: No charmap selected! This is a BUG!\n");
        return 0;
    }
 
    /* Lock FreeType for face lookup */
    IntLockFreeType();
 
    if (face->charmap->encoding == FT_ENCODING_UNICODE)
    {
        FT_UInt glyph_code = 0;
        FT_ULong char_code, char_code_prev;
 
        char_code_prev = char_code = FT_Get_First_Char(face, &glyph_code);
 
        DPRINT("Face encoding FT_ENCODING_UNICODE, number of glyphs %ld, first glyph %u, first char %04lx\n",
               face->num_glyphs, glyph_code, char_code);
 
        if (!glyph_code)
            goto Quit;
 
        if (glyphset)
        {
            glyphset->ranges[0].wcLow = (USHORT)char_code;
            glyphset->ranges[0].cGlyphs = 0;
            glyphset->cGlyphsSupported = 0;
        }
 
        num_ranges = 1;
        while (glyph_code)
        {
            if (char_code < char_code_prev)
            {
                DPRINT1("Expected increasing char code from FT_Get_Next_Char\n");
                goto Quit;
            }
            if (char_code - char_code_prev > 1)
            {
                num_ranges++;
                if (glyphset)
                {
                    glyphset->ranges[num_ranges - 1].wcLow = (USHORT)char_code;
                    glyphset->ranges[num_ranges - 1].cGlyphs = 1;
                    glyphset->cGlyphsSupported++;
                }
            }
            else if (glyphset)
            {
                glyphset->ranges[num_ranges - 1].cGlyphs++;
                glyphset->cGlyphsSupported++;
            }
            char_code_prev = char_code;
            char_code = FT_Get_Next_Char(face, char_code, &glyph_code);
        }
    }
    else
        DPRINT1("Encoding %i not supported\n", face->charmap->encoding);
 
    size = sizeof(GLYPHSET) + sizeof(WCRANGE) * (num_ranges - 1);
    if (glyphset)
    {
        glyphset->cbThis = size;
        glyphset->cRanges = num_ranges;
        glyphset->flAccel = 0;
    }
 
Quit:
    /* Unlock FreeType */
    IntUnLockFreeType();
 
    return size;
}

Referenced by NtGdiGetFontUnicodeRanges().

FTVectorToPOINTFX()

static __inline void FTVectorToPOINTFX ( FT_Vector *  vec, POINTFX *  pt  )

static

Definition at line 578 of file freetype.c.

{
    pt->x.value = vec->x >> 6;
    pt->x.fract = (vec->x & 0x3f) << 10;
    pt->x.fract |= ((pt->x.fract >> 6) | (pt->x.fract >> 12));
    pt->y.value = vec->y >> 6;
    pt->y.fract = (vec->y & 0x3f) << 10;
    pt->y.fract |= ((pt->y.fract >> 6) | (pt->y.fract >> 12));
}

Referenced by get_bezier_glyph_outline(), and get_native_glyph_outline().

get_bezier_glyph_outline()

static unsigned int get_bezier_glyph_outline ( FT_Outline *  outline, unsigned int  buflen, char *  buf  )

static

Definition at line 3956 of file freetype.c.

{
    /* Convert the quadratic Beziers to cubic Beziers.
       The parametric eqn for a cubic Bezier is, from PLRM:
       r(t) = at^3 + bt^2 + ct + r0
       with the control points:
       r1 = r0 + c/3
       r2 = r1 + (c + b)/3
       r3 = r0 + c + b + a
 
       A quadratic Bezier has the form:
       p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
 
       So equating powers of t leads to:
       r1 = 2/3 p1 + 1/3 p0
       r2 = 2/3 p1 + 1/3 p2
       and of course r0 = p0, r3 = p2
    */
    int contour, point = 0, first_pt;
    TTPOLYGONHEADER *pph;
    TTPOLYCURVE *ppc;
    DWORD pph_start, cpfx, type;
    FT_Vector cubic_control[4];
    unsigned int needed = 0;
 
    for (contour = 0; contour < outline->n_contours; contour++)
    {
        pph_start = needed;
        pph = (TTPOLYGONHEADER *)(buf + needed);
        first_pt = point;
        if (buf)
        {
            pph->dwType = TT_POLYGON_TYPE;
            FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
        }
        needed += sizeof(*pph);
        point++;
        while (point <= outline->contours[contour])
        {
            ppc = (TTPOLYCURVE *)(buf + needed);
            type = (outline->tags[point] & FT_Curve_Tag_On) ?
                TT_PRIM_LINE : TT_PRIM_CSPLINE;
            cpfx = 0;
            do
            {
                if (type == TT_PRIM_LINE)
                {
                    if (buf)
                        FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
                    cpfx++;
                    point++;
                }
                else
                {
                    /* Unlike QSPLINEs, CSPLINEs always have their endpoint
                       so cpfx = 3n */
 
                    /* FIXME: Possible optimization in endpoint calculation
                       if there are two consecutive curves */
                    cubic_control[0] = outline->points[point-1];
                    if (!(outline->tags[point-1] & FT_Curve_Tag_On))
                    {
                        cubic_control[0].x += outline->points[point].x + 1;
                        cubic_control[0].y += outline->points[point].y + 1;
                        cubic_control[0].x >>= 1;
                        cubic_control[0].y >>= 1;
                    }
                    if (point+1 > outline->contours[contour])
                        cubic_control[3] = outline->points[first_pt];
                    else
                    {
                        cubic_control[3] = outline->points[point+1];
                        if (!(outline->tags[point+1] & FT_Curve_Tag_On))
                        {
                            cubic_control[3].x += outline->points[point].x + 1;
                            cubic_control[3].y += outline->points[point].y + 1;
                            cubic_control[3].x >>= 1;
                            cubic_control[3].y >>= 1;
                        }
                    }
                    /* r1 = 1/3 p0 + 2/3 p1
                       r2 = 1/3 p2 + 2/3 p1 */
                    cubic_control[1].x = (2 * outline->points[point].x + 1) / 3;
                    cubic_control[1].y = (2 * outline->points[point].y + 1) / 3;
                    cubic_control[2] = cubic_control[1];
                    cubic_control[1].x += (cubic_control[0].x + 1) / 3;
                    cubic_control[1].y += (cubic_control[0].y + 1) / 3;
                    cubic_control[2].x += (cubic_control[3].x + 1) / 3;
                    cubic_control[2].y += (cubic_control[3].y + 1) / 3;
                    if (buf)
                    {
                        FTVectorToPOINTFX(&cubic_control[1], &ppc->apfx[cpfx]);
                        FTVectorToPOINTFX(&cubic_control[2], &ppc->apfx[cpfx+1]);
                        FTVectorToPOINTFX(&cubic_control[3], &ppc->apfx[cpfx+2]);
                    }
                    cpfx += 3;
                    point++;
                }
            } while (point <= outline->contours[contour] &&
                    (outline->tags[point] & FT_Curve_Tag_On) ==
                    (outline->tags[point-1] & FT_Curve_Tag_On));
            /* At the end of a contour Windows adds the start point,
               but only for Beziers and we've already done that.
            */
            if (point <= outline->contours[contour] &&
               outline->tags[point] & FT_Curve_Tag_On)
            {
                /* This is the closing pt of a bezier, but we've already
                   added it, so just inc point and carry on */
                point++;
            }
            if (buf)
            {
                ppc->wType = type;
                ppc->cpfx = cpfx;
            }
            needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
        }
        if (buf)
            pph->cb = needed - pph_start;
    }
    return needed;
}

Referenced by ftGdiGetGlyphOutline().

get_glyph_index()

static FT_UInt FASTCALL get_glyph_index ( FT_Face  ft_face, UINT  glyph  )

inlinestatic

Definition at line 4302 of file freetype.c.

{
    FT_UInt ret;
 
    if (face_has_symbol_charmap(ft_face))
    {
        ret = get_glyph_index_symbol(ft_face, glyph);
        if (ret != 0)
            return ret;
    }
 
    return FT_Get_Char_Index(ft_face, glyph);
}

Referenced by FontLink_Chain_FindGlyph(), get_glyph_index_flagged(), and GreGetGlyphIndicesW().

get_glyph_index_flagged()

static FT_UInt FASTCALL get_glyph_index_flagged ( FT_Face  face, FT_ULong  code, BOOL  fCodeAsIndex  )

inlinestatic

Definition at line 4317 of file freetype.c.

{
    return (fCodeAsIndex ? code : get_glyph_index(face, code));
}

Referenced by FontLink_Chain_FindGlyph(), ftGdiGetGlyphOutline(), GreGetCharABCWidthsW(), and GreGetCharWidthW().

get_glyph_index_symbol()

static FT_UInt FASTCALL get_glyph_index_symbol ( FT_Face  ft_face, UINT  glyph  )

inlinestatic

Definition at line 4288 of file freetype.c.

{
    FT_UInt ret;
 
    if (glyph < 0x100) glyph += 0xf000;
    /* there are a number of old pre-Unicode "broken" TTFs, which
       do have symbols at U+00XX instead of U+f0XX */
    if (!(ret = FT_Get_Char_Index(ft_face, glyph)))
        ret = FT_Get_Char_Index(ft_face, glyph - 0xf000);
 
    return ret;
}

Referenced by get_glyph_index().

get_native_glyph_outline()

static unsigned int get_native_glyph_outline ( FT_Outline *  outline, unsigned int  buflen, char *  buf  )

static

Definition at line 3883 of file freetype.c.

{
    TTPOLYGONHEADER *pph;
    TTPOLYCURVE *ppc;
    int needed = 0, point = 0, contour, first_pt;
    unsigned int pph_start, cpfx;
    DWORD type;
 
    for (contour = 0; contour < outline->n_contours; contour++)
    {
        /* Ignore contours containing one point */
        if (point == outline->contours[contour])
        {
            point++;
            continue;
        }
 
        pph_start = needed;
        pph = (TTPOLYGONHEADER *)(buf + needed);
        first_pt = point;
        if (buf)
        {
            pph->dwType = TT_POLYGON_TYPE;
            FTVectorToPOINTFX(&outline->points[point], &pph->pfxStart);
        }
        needed += sizeof(*pph);
        point++;
        while (point <= outline->contours[contour])
        {
            ppc = (TTPOLYCURVE *)(buf + needed);
            type = (outline->tags[point] & FT_Curve_Tag_On) ?
                TT_PRIM_LINE : TT_PRIM_QSPLINE;
            cpfx = 0;
            do
            {
                if (buf)
                    FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
                cpfx++;
                point++;
            } while (point <= outline->contours[contour] &&
                    (outline->tags[point] & FT_Curve_Tag_On) ==
                    (outline->tags[point-1] & FT_Curve_Tag_On));
            /* At the end of a contour Windows adds the start point, but
               only for Beziers */
            if (point > outline->contours[contour] &&
               !(outline->tags[point-1] & FT_Curve_Tag_On))
            {
                if (buf)
                    FTVectorToPOINTFX(&outline->points[first_pt], &ppc->apfx[cpfx]);
                cpfx++;
            }
            else if (point <= outline->contours[contour] &&
                      outline->tags[point] & FT_Curve_Tag_On)
            {
                /* add closing pt for bezier */
                if (buf)
                    FTVectorToPOINTFX(&outline->points[point], &ppc->apfx[cpfx]);
                cpfx++;
                point++;
            }
            if (buf)
            {
                ppc->wType = type;
                ppc->cpfx = cpfx;
            }
            needed += sizeof(*ppc) + (cpfx - 1) * sizeof(POINTFX);
        }
        if (buf)
            pph->cb = needed - pph_start;
    }
    return needed;
}

Referenced by ftGdiGetGlyphOutline().

GetFontFamilyInfoForList()

static BOOLEAN FASTCALL GetFontFamilyInfoForList ( const LOGFONTW *  LogFont, PFONTFAMILYINFO  Info, LPCWSTR  NominalName, LONG *  pCount, LONG  MaxCount, PLIST_ENTRY  Head  )

static

Definition at line 3627 of file freetype.c.

{
    PLIST_ENTRY Entry;
    PFONT_ENTRY CurrentEntry;
    FONTGDI *FontGDI;
    FONTFAMILYINFO InfoEntry;
    LONG Count = *pCount;
 
    for (Entry = Head->Flink; Entry != Head; Entry = Entry->Flink)
    {
        CurrentEntry = CONTAINING_RECORD(Entry, FONT_ENTRY, ListEntry);
        FontGDI = CurrentEntry->Font;
        ASSERT(FontGDI);
 
        if (LogFont->lfCharSet != DEFAULT_CHARSET &&
            LogFont->lfCharSet != FontGDI->CharSet)
        {
            continue;   /* charset mismatch */
        }
 
        /* get one info entry */
        FontFamilyFillInfo(&InfoEntry, NULL, NULL, FontGDI);
 
        if (LogFont->lfFaceName[0] != UNICODE_NULL)
        {
            /* check name */
            if (_wcsnicmp(LogFont->lfFaceName,
                          InfoEntry.EnumLogFontEx.elfLogFont.lfFaceName,
                          RTL_NUMBER_OF(LogFont->lfFaceName) - 1) != 0 &&
                _wcsnicmp(LogFont->lfFaceName,
                          InfoEntry.EnumLogFontEx.elfFullName,
                          RTL_NUMBER_OF(LogFont->lfFaceName) - 1) != 0)
            {
                continue;
            }
        }
 
        if (NominalName)
        {
            /* store the nominal name */
            RtlStringCbCopyW(InfoEntry.EnumLogFontEx.elfLogFont.lfFaceName,
                             sizeof(InfoEntry.EnumLogFontEx.elfLogFont.lfFaceName),
                             NominalName);
        }
 
        /* store one entry to Info */
        if (0 <= Count && Count < MaxCount)
        {
            RtlCopyMemory(&Info[Count], &InfoEntry, sizeof(InfoEntry));
        }
        Count++;
    }
 
    *pCount = Count;
 
    return TRUE;
}

Referenced by GetFontFamilyInfoForSubstitutes(), and IntGetFontFamilyInfo().

GetFontFamilyInfoForSubstitutes()

static BOOLEAN FASTCALL GetFontFamilyInfoForSubstitutes ( const LOGFONTW *  LogFont, PFONTFAMILYINFO  Info, LONG *  pCount, LONG  MaxCount  )

static

Definition at line 3691 of file freetype.c.

{
    PLIST_ENTRY pEntry, pHead = &g_FontSubstListHead;
    PFONTSUBST_ENTRY pCurrentEntry;
    PUNICODE_STRING pFromW, pToW;
    LOGFONTW lf = *LogFont;
    PPROCESSINFO Win32Process = PsGetCurrentProcessWin32Process();
 
    for (pEntry = pHead->Flink; pEntry != pHead; pEntry = pEntry->Flink)
    {
        pCurrentEntry = CONTAINING_RECORD(pEntry, FONTSUBST_ENTRY, ListEntry);
 
        pFromW = &pCurrentEntry->FontNames[FONTSUBST_FROM];
        if (LogFont->lfFaceName[0] != UNICODE_NULL)
        {
            /* check name */
            if (_wcsicmp(LogFont->lfFaceName, pFromW->Buffer) != 0)
                continue;   /* mismatch */
        }
 
        pToW = &pCurrentEntry->FontNames[FONTSUBST_TO];
        if (RtlEqualUnicodeString(pFromW, pToW, TRUE) &&
            pCurrentEntry->CharSets[FONTSUBST_FROM] ==
            pCurrentEntry->CharSets[FONTSUBST_TO])
        {
            /* identical mapping */
            continue;
        }
 
        /* substitute and get the real name */
        IntUnicodeStringToBuffer(lf.lfFaceName, sizeof(lf.lfFaceName), pFromW);
        SubstituteFontRecurse(&lf);
        if (LogFont->lfCharSet != DEFAULT_CHARSET && LogFont->lfCharSet != lf.lfCharSet)
            continue;
 
        /* search in global fonts */
        IntLockFreeType();
        GetFontFamilyInfoForList(&lf, Info, pFromW->Buffer, pCount, MaxCount, &g_FontListHead);
 
        /* search in private fonts */
        IntLockProcessPrivateFonts(Win32Process);
        GetFontFamilyInfoForList(&lf, Info, pFromW->Buffer, pCount, MaxCount,
                                 &Win32Process->PrivateFontListHead);
        IntUnLockProcessPrivateFonts(Win32Process);
        IntUnLockFreeType();
 
        if (LogFont->lfFaceName[0] != UNICODE_NULL)
        {
            /* it's already matched to the exact name and charset if the name
               was specified at here, then so don't scan more for another name */
            break;
        }
    }
 
    return TRUE;
}

Referenced by IntGetFontFamilyInfo().

GetFontPenalty()

static UINT GetFontPenalty ( const LOGFONTW *  LogFont, const OUTLINETEXTMETRICW *  Otm, const char *  style_name  )

static

Definition at line 5415 of file freetype.c.

{
    ULONG   Penalty = 0;
    BYTE    Byte;
    LONG    Long;
    BOOL    fNeedScaling = FALSE;
    const BYTE UserCharSet = IntCharSetFromLangID(gusLanguageID);
    const TEXTMETRICW * TM = &Otm->otmTextMetrics;
    WCHAR* ActualNameW;
 
    ASSERT(Otm);
    ASSERT(LogFont);
 
    /* FIXME: IntSizeSynth Penalty 20 */
    /* FIXME: SmallPenalty Penalty 1 */
    /* FIXME: FaceNameSubst Penalty 500 */
 
    Byte = LogFont->lfCharSet;
 
    if (Byte != TM->tmCharSet)
    {
        if (Byte != DEFAULT_CHARSET && Byte != ANSI_CHARSET)
        {
            /* CharSet Penalty 65000 */
            /* Requested charset does not match the candidate's. */
            GOT_PENALTY("CharSet", 65000);
        }
        else
        {
            if (UserCharSet != TM->tmCharSet)
            {
                /* UNDOCUMENTED: Not user language */
                GOT_PENALTY("UNDOCUMENTED:NotUserLanguage", 100);
 
                if (ANSI_CHARSET != TM->tmCharSet)
                {
                    /* UNDOCUMENTED: Not ANSI charset */
                    GOT_PENALTY("UNDOCUMENTED:NotAnsiCharSet", 100);
                }
            }
        }
    }
 
    Byte = LogFont->lfOutPrecision;
    switch (Byte)
    {
        case OUT_DEFAULT_PRECIS:
            /* nothing to do */
            break;
        case OUT_DEVICE_PRECIS:
            if (!(TM->tmPitchAndFamily & TMPF_DEVICE) ||
                !(TM->tmPitchAndFamily & (TMPF_VECTOR | TMPF_TRUETYPE)))
            {
                /* OutputPrecision Penalty 19000 */
                /* Requested OUT_STROKE_PRECIS, but the device can't do it
                   or the candidate is not a vector font. */
                GOT_PENALTY("OutputPrecision", 19000);
            }
            break;
        default:
            if (TM->tmPitchAndFamily & (TMPF_VECTOR | TMPF_TRUETYPE))
            {
                /* OutputPrecision Penalty 19000 */
                /* Or OUT_STROKE_PRECIS not requested, and the candidate
                   is a vector font that requires GDI support. */
                GOT_PENALTY("OutputPrecision", 19000);
            }
            break;
    }
 
    Byte = (LogFont->lfPitchAndFamily & 0x0F);
    if (Byte == DEFAULT_PITCH)
        Byte = VARIABLE_PITCH;
    if (Byte == FIXED_PITCH)
    {
        if (TM->tmPitchAndFamily & _TMPF_VARIABLE_PITCH)
        {
            /* FixedPitch Penalty 15000 */
            /* Requested a fixed pitch font, but the candidate is a
               variable pitch font. */
            GOT_PENALTY("FixedPitch", 15000);
        }
    }
    if (Byte == VARIABLE_PITCH)
    {
        if (!(TM->tmPitchAndFamily & _TMPF_VARIABLE_PITCH))
        {
            /* PitchVariable Penalty 350 */
            /* Requested a variable pitch font, but the candidate is not a
               variable pitch font. */
            GOT_PENALTY("PitchVariable", 350);
        }
    }
 
    Byte = (LogFont->lfPitchAndFamily & 0x0F);
    if (Byte == DEFAULT_PITCH)
    {
        if (!(TM->tmPitchAndFamily & _TMPF_VARIABLE_PITCH))
        {
            /* DefaultPitchFixed Penalty 1 */
            /* Requested DEFAULT_PITCH, but the candidate is fixed pitch. */
            GOT_PENALTY("DefaultPitchFixed", 1);
        }
    }
 
    ActualNameW = (WCHAR*)((ULONG_PTR)Otm + (ULONG_PTR)Otm->otmpFamilyName);
 
    if (LogFont->lfFaceName[0] != UNICODE_NULL)
    {
        BOOL Found = FALSE;
 
        /* localized family name */
        if (!Found)
        {
            Found = (_wcsicmp(LogFont->lfFaceName, ActualNameW) == 0);
        }
        /* localized full name */
        if (!Found)
        {
            ActualNameW = (WCHAR*)((ULONG_PTR)Otm + (ULONG_PTR)Otm->otmpFaceName);
            Found = (_wcsicmp(LogFont->lfFaceName, ActualNameW) == 0);
        }
        if (!Found)
        {
            /* FaceName Penalty 10000 */
            /* Requested a face name, but the candidate's face name
               does not match. */
            GOT_PENALTY("FaceName", 10000);
        }
    }
 
    Byte = (LogFont->lfPitchAndFamily & 0xF0);
    if (Byte != FF_DONTCARE)
    {
        if (Byte != (TM->tmPitchAndFamily & 0xF0))
        {
            /* Family Penalty 9000 */
            /* Requested a family, but the candidate's family is different. */
            GOT_PENALTY("Family", 9000);
        }
    }
 
    if ((TM->tmPitchAndFamily & 0xF0) == FF_DONTCARE)
    {
        /* FamilyUnknown Penalty 8000 */
        /* Requested a family, but the candidate has no family. */
        GOT_PENALTY("FamilyUnknown", 8000);
    }
 
    /* Is the candidate a non-vector font? */
    if (!(TM->tmPitchAndFamily & (TMPF_TRUETYPE | TMPF_VECTOR)))
    {
        /* Is lfHeight specified? */
        if (LogFont->lfHeight != 0)
        {
            if (labs(LogFont->lfHeight) < TM->tmHeight)
            {
                /* HeightBigger Penalty 600 */
                /* The candidate is a nonvector font and is bigger than the
                   requested height. */
                GOT_PENALTY("HeightBigger", 600);
                /* HeightBiggerDifference Penalty 150 */
                /* The candidate is a raster font and is larger than the
                   requested height. Penalty * height difference */
                GOT_PENALTY("HeightBiggerDifference", 150 * labs(TM->tmHeight - labs(LogFont->lfHeight)));
 
                fNeedScaling = TRUE;
            }
            if (TM->tmHeight < labs(LogFont->lfHeight))
            {
                /* HeightSmaller Penalty 150 */
                /* The candidate is a raster font and is smaller than the
                   requested height. Penalty * height difference */
                GOT_PENALTY("HeightSmaller", 150 * labs(TM->tmHeight - labs(LogFont->lfHeight)));
 
                fNeedScaling = TRUE;
            }
        }
    }
 
    switch (LogFont->lfPitchAndFamily & 0xF0)
    {
        case FF_ROMAN: case FF_MODERN: case FF_SWISS:
            switch (TM->tmPitchAndFamily & 0xF0)
            {
                case FF_DECORATIVE: case FF_SCRIPT:
                    /* FamilyUnlikely Penalty 50 */
                    /* Requested a roman/modern/swiss family, but the
                       candidate is decorative/script. */
                    GOT_PENALTY("FamilyUnlikely", 50);
                    break;
                default:
                    break;
            }
            break;
        case FF_DECORATIVE: case FF_SCRIPT:
            switch (TM->tmPitchAndFamily & 0xF0)
            {
                case FF_ROMAN: case FF_MODERN: case FF_SWISS:
                    /* FamilyUnlikely Penalty 50 */
                    /* Or requested decorative/script, and the candidate is
                       roman/modern/swiss. */
                    GOT_PENALTY("FamilyUnlikely", 50);
                    break;
                default:
                    break;
            }
        default:
            break;
    }
 
    if (LogFont->lfWidth != 0)
    {
        if (LogFont->lfWidth != TM->tmAveCharWidth)
        {
            /* Width Penalty 50 */
            /* Requested a nonzero width, but the candidate's width
               doesn't match. Penalty * width difference */
            GOT_PENALTY("Width", 50 * labs(LogFont->lfWidth - TM->tmAveCharWidth));
 
            if (!(TM->tmPitchAndFamily & (TMPF_TRUETYPE | TMPF_VECTOR)))
                fNeedScaling = TRUE;
        }
    }
 
    if (fNeedScaling)
    {
        /* SizeSynth Penalty 50 */
        /* The candidate is a raster font that needs scaling by GDI. */
        GOT_PENALTY("SizeSynth", 50);
    }
 
    if (!LogFont->lfItalic && TM->tmItalic)
    {
        /* Italic Penalty 4 */
        /* Requested font and candidate font do not agree on italic status,
           and the desired result cannot be simulated. */
        /* Adjusted to 40 to satisfy (Oblique Penalty > Book Penalty). */
        GOT_PENALTY("Italic", 40);
    }
    else if (LogFont->lfItalic && !TM->tmItalic)
    {
        /* ItalicSim Penalty 1 */
        /* Requested italic font but the candidate is not italic,
           although italics can be simulated. */
        GOT_PENALTY("ItalicSim", 1);
    }
 
    if (LogFont->lfOutPrecision == OUT_TT_PRECIS)
    {
        if (!(TM->tmPitchAndFamily & TMPF_TRUETYPE))
        {
            /* NotTrueType Penalty 4 */
            /* Requested OUT_TT_PRECIS, but the candidate is not a
               TrueType font. */
            GOT_PENALTY("NotTrueType", 4);
        }
    }
 
    Long = LogFont->lfWeight;
    if (LogFont->lfWeight == FW_DONTCARE)
        Long = FW_NORMAL;
    if (Long != TM->tmWeight)
    {
        /* Weight Penalty 3 */
        /* The candidate's weight does not match the requested weight.
           Penalty * (weight difference/10) */
        GOT_PENALTY("Weight", 3 * (labs(Long - TM->tmWeight) / 10));
    }
 
    if (!LogFont->lfUnderline && TM->tmUnderlined)
    {
        /* Underline Penalty 3 */
        /* Requested font has no underline, but the candidate is
           underlined. */
        GOT_PENALTY("Underline", 3);
    }
 
    if (!LogFont->lfStrikeOut && TM->tmStruckOut)
    {
        /* StrikeOut Penalty 3 */
        /* Requested font has no strike-out, but the candidate is
           struck out. */
        GOT_PENALTY("StrikeOut", 3);
    }
 
    /* Is the candidate a non-vector font? */
    if (!(TM->tmPitchAndFamily & (TMPF_TRUETYPE | TMPF_VECTOR)))
    {
        if (LogFont->lfHeight != 0 && TM->tmHeight < LogFont->lfHeight)
        {
            /* VectorHeightSmaller Penalty 2 */
            /* Candidate is a vector font that is smaller than the
               requested height. Penalty * height difference */
            GOT_PENALTY("VectorHeightSmaller", 2 * labs(TM->tmHeight - LogFont->lfHeight));
        }
        if (LogFont->lfHeight != 0 && TM->tmHeight > LogFont->lfHeight)
        {
            /* VectorHeightBigger Penalty 1 */
            /* Candidate is a vector font that is bigger than the
               requested height. Penalty * height difference */
            GOT_PENALTY("VectorHeightBigger", 1 * labs(TM->tmHeight - LogFont->lfHeight));
        }
    }
 
    if (!(TM->tmPitchAndFamily & TMPF_DEVICE))
    {
        /* DeviceFavor Penalty 2 */
        /* Extra penalty for all nondevice fonts. */
        GOT_PENALTY("DeviceFavor", 2);
    }
 
    if (TM->tmAveCharWidth >= 5 && TM->tmHeight >= 5)
    {
        if (TM->tmAveCharWidth / TM->tmHeight >= 3)
        {
            /* Aspect Penalty 30 */
            /* The aspect rate is >= 3. It seems like a bad font. */
            GOT_PENALTY("Aspect", ((TM->tmAveCharWidth / TM->tmHeight) - 2) * 30);
        }
        else if (TM->tmHeight / TM->tmAveCharWidth >= 3)
        {
            /* Aspect Penalty 30 */
            /* The aspect rate is >= 3. It seems like a bad font. */
            GOT_PENALTY("Aspect", ((TM->tmHeight / TM->tmAveCharWidth) - 2) * 30);
        }
    }
 
    if (Penalty < 200)
    {
        DPRINT("WARNING: Penalty:%ld < 200: RequestedNameW:%ls, "
            "ActualNameW:%ls, lfCharSet:%d, lfWeight:%ld, "
            "tmCharSet:%d, tmWeight:%ld\n",
            Penalty, LogFont->lfFaceName, ActualNameW,
            LogFont->lfCharSet, LogFont->lfWeight,
            TM->tmCharSet, TM->tmWeight);
    }
 
    return Penalty;     /* success */
}

Referenced by FindBestFontFromList().

GreExtTextOutW()

BOOL APIENTRY GreExtTextOutW	(	_In_ HDC	hDC,
		_In_ INT	XStart,
		_In_ INT	YStart,
		_In_ UINT	fuOptions,
		_In_opt_ PRECTL	lprc,
		_In_reads_opt_(Count) PCWCH	String,
		_In_ INT	Count,
		_In_opt_ const INT *	Dx,
		_In_ DWORD	dwCodePage
	)

Definition at line 7215 of file freetype.c.

{
    BOOL bResult;
    DC *dc;
 
    // TODO: Write test-cases to exactly match real Windows in different
    // bad parameters (e.g. does Windows check the DC or the RECT first?).
    dc = DC_LockDc(hDC);
    if (!dc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    bResult = IntExtTextOutW( dc,
                              XStart,
                              YStart,
                              fuOptions,
                              lprc,
                              String,
                              Count,
                              Dx,
                              dwCodePage );
 
    DC_UnlockDc(dc);
 
    return bResult;
}

Referenced by GreTextOutW(), IntPaintDesktop(), and NtGdiExtTextOutW().

GreGetCharABCWidthsW()

BOOL APIENTRY GreGetCharABCWidthsW	(	_In_ HDC	hDC,
		_In_ UINT	FirstChar,
		_In_ UINT	Count,
		_In_reads_opt_(Count) PCWCH	Safepwch,
		_In_ FLONG	fl,
		_Out_writes_bytes_(Count *sizeof(ABC)) PVOID	SafeBuffer
	)

Definition at line 7380 of file freetype.c.

{
    PABC SafeBuffI;
    PABCFLOAT SafeBuffF;
    PDC dc;
    PDC_ATTR pdcattr;
    PTEXTOBJ TextObj;
    PFONTGDI FontGDI;
    FT_Face face;
    UINT i, glyph_index;
    HFONT hFont = NULL;
 
    dc = DC_LockDc(hDC);
    if (dc == NULL)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    pdcattr = dc->pdcattr;
    hFont = pdcattr->hlfntNew;
    TextObj = RealizeFontInit(hFont);
 
    DC_UnlockDc(dc);
 
    if (TextObj == NULL)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    FontGDI = ObjToGDI(TextObj->Font, FONT);
 
    // NOTE: GetCharABCWidths simply ignores lfEscapement and XFORM.
    IntLockFreeType();
    if (!TextIntUpdateSize(TextObj, FontGDI, FALSE))
    {
        IntUnLockFreeType();
        TEXTOBJ_UnlockText(TextObj);
        EngSetLastError(ERROR_GEN_FAILURE);
        return FALSE;
    }
 
    face = FontGDI->SharedFace->Face;
    FT_Set_Transform(face, NULL, NULL);
 
    if (!fl)
        SafeBuffF = SafeBuffer;
    else
        SafeBuffI = SafeBuffer;
 
    for (i = FirstChar; i < FirstChar+Count; i++)
    {
        int adv, lsb, bbx, left, right;
 
        if (Safepwch)
            glyph_index = get_glyph_index_flagged(face, Safepwch[i - FirstChar], (fl & GCABCW_INDICES));
        else
            glyph_index = get_glyph_index_flagged(face, i, (fl & GCABCW_INDICES));
 
        FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
 
        left = (INT)face->glyph->metrics.horiBearingX  & -64;
        right = (INT)((face->glyph->metrics.horiBearingX + face->glyph->metrics.width) + 63) & -64;
        adv  = (face->glyph->advance.x + 32) >> 6;
 
//      int test = (INT)(face->glyph->metrics.horiAdvance + 63) >> 6;
//      DPRINT1("Advance Wine %d and Advance Ros %d\n",test, adv ); /* It's the same! */
 
        lsb = left >> 6;
        bbx = (right - left) >> 6;
        /*
              DPRINT1("lsb %d and bbx %d\n", lsb, bbx );
         */
        if (!fl)
        {
            SafeBuffF[i - FirstChar].abcfA = (FLOAT) lsb;
            SafeBuffF[i - FirstChar].abcfB = (FLOAT) bbx;
            SafeBuffF[i - FirstChar].abcfC = (FLOAT) (adv - lsb - bbx);
        }
        else
        {
            SafeBuffI[i - FirstChar].abcA = lsb;
            SafeBuffI[i - FirstChar].abcB = bbx;
            SafeBuffI[i - FirstChar].abcC = adv - lsb - bbx;
        }
    }
 
    IntUnLockFreeType();
    TEXTOBJ_UnlockText(TextObj);
 
    return TRUE;
}

Referenced by NtGdiGetCharABCWidthsW().

GreGetCharWidthW()

BOOL APIENTRY GreGetCharWidthW	(	_In_ HDC	hDC,
		_In_ UINT	FirstChar,
		_In_ UINT	Count,
		_In_reads_opt_(Count) PCWCH	Safepwc,
		_In_ FLONG	fl,
		_Out_writes_bytes_(Count *sizeof(INT)) PVOID	Buffer
	)

Definition at line 7484 of file freetype.c.

{
    PDC dc;
    PDC_ATTR pdcattr;
    PTEXTOBJ TextObj;
    PFONTGDI FontGDI;
    FT_Face face;
    UINT i, glyph_index;
    HFONT hFont = NULL;
    PINT SafeBuffI;
    PFLOAT SafeBuffF;
 
    dc = DC_LockDc(hDC);
    if (dc == NULL)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    pdcattr = dc->pdcattr;
    hFont = pdcattr->hlfntNew;
    TextObj = RealizeFontInit(hFont);
    DC_UnlockDc(dc);
 
    if (TextObj == NULL)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    FontGDI = ObjToGDI(TextObj->Font, FONT);
 
    // NOTE: GetCharWidth simply ignores lfEscapement and XFORM.
    IntLockFreeType();
    if (!TextIntUpdateSize(TextObj, FontGDI, FALSE))
    {
        IntUnLockFreeType();
        TEXTOBJ_UnlockText(TextObj);
        EngSetLastError(ERROR_GEN_FAILURE);
        return FALSE;
    }
 
    face = FontGDI->SharedFace->Face;
    FT_Set_Transform(face, NULL, NULL);
 
    if (!fl)
        SafeBuffF = (PFLOAT)Buffer;
    else
        SafeBuffI = (PINT)Buffer;
 
    for (i = FirstChar; i < FirstChar+Count; i++)
    {
        if (Safepwc)
            glyph_index = get_glyph_index_flagged(face, Safepwc[i - FirstChar], (fl & GCW_INDICES));
        else
            glyph_index = get_glyph_index_flagged(face, i, (fl & GCW_INDICES));
 
        FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
 
        if (!fl)
            SafeBuffF[i - FirstChar] = (FLOAT) ((face->glyph->advance.x + 32) >> 6);
        else
            SafeBuffI[i - FirstChar] = (face->glyph->advance.x + 32) >> 6;
    }
 
    IntUnLockFreeType();
    TEXTOBJ_UnlockText(TextObj);
 
    return TRUE;
}

Referenced by NtGdiGetCharWidthW().

GreGetGlyphIndicesW()

DWORD APIENTRY GreGetGlyphIndicesW	(	_In_ HDC	hdc,
		_In_reads_opt_(cwc) PCWCH	pwc,
		_In_ INT	cwc,
		_Out_writes_opt_(cwc) PWORD	pgi,
		_In_ DWORD	iMode,
		_In_ BOOL	bSubset
	)

Definition at line 7594 of file freetype.c.

{
    // FIXME: bSubset
    PDC dc = DC_LockDc(hdc);
    if (!dc)
        return GDI_ERROR;
 
    PDC_ATTR pdcattr = dc->pdcattr;
    HFONT hFont = pdcattr->hlfntNew;
    PTEXTOBJ TextObj = RealizeFontInit(hFont);
    DC_UnlockDc(dc);
 
    if (!TextObj)
    {
        DPRINT1("!TextObj\n");
        return GDI_ERROR;
    }
 
    PFONTGDI FontGDI = ObjToGDI(TextObj->Font, FONT);
    FT_Face Face = FontGDI->SharedFace->Face;
    TEXTOBJ_UnlockText(TextObj);
 
    if (cwc == 0)
    {
        // Only the exceptional query case (pwc == NULL && pgi == NULL && iMode == 0)
        // should return the number of glyphs. All other cwc == 0 cases must fail.
        if (!pwc && !pgi && !iMode)
            return Face->num_glyphs; // Returns number of glyphs
 
        return GDI_ERROR;
    }
 
    // Get default character
    WCHAR DefChar = 0xFFFF;
    if (!(iMode & GGI_MARK_NONEXISTING_GLYPHS) && IntGetFontDefaultChar(Face, &DefChar))
    {
        IntLockFreeType();
        DefChar = get_glyph_index(Face, DefChar); // Convert to glyph index
        IntUnLockFreeType();
    }
 
    // Get glyph indices
    // NOTE: Windows GetGlyphIndices doesn't support Surrogate Pairs.
    IntLockFreeType();
    for (INT i = 0; i < cwc; i++)
    {
        pgi[i] = get_glyph_index(Face, pwc[i]);
        if (pgi[i] == 0)
            pgi[i] = DefChar;
    }
    IntUnLockFreeType();
 
    return cwc;
}

Referenced by NtGdiGetGlyphIndicesWInternal().

InitFontSupport()

BOOL FASTCALL InitFontSupport

(

VOID

)

Definition at line 948 of file freetype.c.

{
    ULONG ulError;
 
    g_FontCacheNumEntries = 0;
 
    g_FreeTypeLock = ExAllocatePoolWithTag(NonPagedPool, sizeof(FAST_MUTEX), TAG_INTERNAL_SYNC);
    if (g_FreeTypeLock == NULL)
    {
        return FALSE;
    }
    ExInitializeFastMutex(g_FreeTypeLock);
 
    ulError = FT_Init_FreeType(&g_FreeTypeLibrary);
    if (ulError)
    {
        DPRINT1("FT_Init_FreeType failed with error code 0x%x\n", ulError);
        return FALSE;
    }
 
    if (!IntLoadFontsInRegistry())
    {
        DPRINT1("Fonts registry is empty.\n");
 
        /* Load font(s) with writing registry */
        IntLoadSystemFonts();
    }
 
    IntLoadFontSubstList(&g_FontSubstListHead);
 
#if 0
    DumpFontInfo(TRUE);
#endif
 
    FontLink_LoadSettings();
    FontLink_LoadDefaultFonts();
    FontLink_LoadDefaultCharset();
    FontLink_PopulateEntries();
 
    return TRUE;
}

Referenced by InitializeGreCSRSS().

IntAddNameFromFamInfo()

static VOID IntAddNameFromFamInfo ( LPWSTR  psz, FONTFAMILYINFO *  FamInfo  )

static

Definition at line 5977 of file freetype.c.

{
    wcscat(psz, FamInfo->EnumLogFontEx.elfLogFont.lfFaceName);
    if (FamInfo->EnumLogFontEx.elfStyle[0] &&
        _wcsicmp(FamInfo->EnumLogFontEx.elfStyle, L"Regular") != 0)
    {
        wcscat(psz, L" ");
        wcscat(psz, FamInfo->EnumLogFontEx.elfStyle);
    }
}

Referenced by IntGdiGetFontResourceInfo().

IntCharSetFromCodePage()

BYTE FASTCALL IntCharSetFromCodePage

(

UINT

uCodePage

)

Definition at line 318 of file freetype.c.

{
    UINT i;
 
    if (uCodePage == CP_OEMCP)
        return OEM_CHARSET;
 
    if (uCodePage == CP_MACCP)
        return MAC_CHARSET;
 
    for (i = 0; i < MAXTCIINDEX; ++i)
    {
        if (g_FontTci[i].ciACP == 0)
            continue;
 
        if (g_FontTci[i].ciACP == uCodePage)
            return g_FontTci[i].ciCharset;
    }
 
    return DEFAULT_CHARSET;
}

Referenced by CreateStockFonts().

IntDeleteRegFontEntries()

VOID IntDeleteRegFontEntries	(	_In_ PCWSTR	pszFileName,
		_In_ DWORD	dwFlags
	)

Definition at line 2237 of file freetype.c.

{
    NTSTATUS Status;
    HKEY hKey;
    WCHAR szName[MAX_PATH], szValue[MAX_PATH];
    ULONG dwIndex, NameLength, ValueSize, dwType;
 
    Status = RegOpenKey(g_FontRegPath.Buffer, &hKey);
    if (!NT_SUCCESS(Status))
        return;
 
    for (dwIndex = 0;;)
    {
        NameLength = RTL_NUMBER_OF(szName);
        ValueSize = sizeof(szValue);
        Status = RegEnumValueW(hKey, dwIndex, szName, &NameLength, &dwType, szValue, &ValueSize);
        if (!NT_SUCCESS(Status))
            break;
 
        if (dwType != REG_SZ || _wcsicmp(szValue, pszFileName) != 0)
        {
            ++dwIndex;
            continue;
        }
 
        /* Delete the found value */
        Status = RegDeleteValueW(hKey, szName);
        if (!NT_SUCCESS(Status))
            break;
    }
 
    ZwClose(hKey);
}

Referenced by IntGdiRemoveFontResourceSingle().

IntEnableFontRendering()

VOID FASTCALL IntEnableFontRendering

(

BOOL

Enable

)

Definition at line 2707 of file freetype.c.

{
    g_RenderingEnabled = Enable;
}

IntEscapeMatrix()

static VOID FASTCALL IntEscapeMatrix ( FT_Matrix *  pmat, LONG  lfEscapement  )

static

Definition at line 1037 of file freetype.c.

{
    FT_Vector vecAngle;
    /* Convert the angle in tenths of degrees into degrees as a 16.16 fixed-point value */
    FT_Angle angle = INT_TO_FIXED(lfEscapement) / 10;
    FT_Vector_Unit(&vecAngle, angle);
    pmat->xx = vecAngle.x;
    pmat->xy = -vecAngle.y;
    pmat->yx = -pmat->xy;
    pmat->yy = pmat->xx;
}

Referenced by ftGdiGetGlyphOutline(), and IntExtTextOutW().

IntExtTextOutW()

BOOL APIENTRY IntExtTextOutW	(	_In_ PDC	dc,
		_In_ INT	XStart,
		_In_ INT	YStart,
		_In_ UINT	fuOptions,
		_In_opt_ PRECTL	lprc,
		_In_reads_opt_(Count) PCWCH	String,
		_In_ INT	Count,
		_In_opt_ const INT *	Dx,
		_In_ DWORD	dwCodePage
	)

Definition at line 6669 of file freetype.c.

{
    /*
     * FIXME:
     * Call EngTextOut, which does the real work (calling DrvTextOut where
     * appropriate)
     */
 
    PDC_ATTR pdcattr;
    SURFOBJ *psoDest, *psoGlyph;
    SURFACE *psurf;
    INT glyph_index, i;
    FT_Face face;
    FT_BitmapGlyph realglyph;
    LONGLONG X64, Y64, RealXStart64, RealYStart64, DeltaX64, DeltaY64;
    ULONG previous;
    RECTL DestRect, MaskRect;
    HBITMAP hbmGlyph;
    SIZEL glyphSize;
    FONTOBJ *FontObj;
    PFONTGDI FontGDI;
    PTEXTOBJ TextObj = NULL;
    EXLATEOBJ exloRGB2Dst, exloDst2RGB;
    POINT Start;
    PMATRIX pmxWorldToDevice;
    FT_Vector delta, vecAscent64, vecDescent64, vec;
    LOGFONTW *plf;
    BOOL use_kerning, bResult, DoBreak;
    FONT_CACHE_ENTRY Cache;
    FT_Matrix mat;
    BOOL bNoTransform;
    DWORD ch0, ch1;
    const DWORD del = 0x7f, nbsp = 0xa0; // DEL is ASCII DELETE and nbsp is a non-breaking space
    FONTLINK_CHAIN Chain;
    SIZE spaceWidth;
 
    /* Check if String is valid */
    if (Count > 0xFFFF || (Count > 0 && String == NULL))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (PATH_IsPathOpen(dc->dclevel))
    {
        return PATH_ExtTextOut(dc,
                               XStart, YStart,
                               fuOptions,
                               lprc,
                               String, Count,
                               Dx);
    }
 
    DC_vPrepareDCsForBlit(dc, NULL, NULL, NULL);
 
    if (!dc->dclevel.pSurface)
    {
        /* Memory DC with no surface selected */
        bResult = TRUE;
        goto Cleanup;
    }
 
    pdcattr = dc->pdcattr;
    if (pdcattr->flTextAlign & TA_UPDATECP)
    {
        Start.x = pdcattr->ptlCurrent.x;
        Start.y = pdcattr->ptlCurrent.y;
    }
    else
    {
        Start.x = XStart;
        Start.y = YStart;
    }
 
    IntLPtoDP(dc, &Start, 1);
    RealXStart64 = ((LONGLONG)Start.x + dc->ptlDCOrig.x) << 6;
    RealYStart64 = ((LONGLONG)Start.y + dc->ptlDCOrig.y) << 6;
 
    MaskRect.left = 0;
    MaskRect.top = 0;
 
    psurf = dc->dclevel.pSurface;
    psoDest = &psurf->SurfObj;
 
    if (pdcattr->iGraphicsMode == GM_ADVANCED)
        pmxWorldToDevice = DC_pmxWorldToDevice(dc);
    else
        pmxWorldToDevice = (PMATRIX)&gmxWorldToDeviceDefault;
 
    if (pdcattr->ulDirty_ & DIRTY_BACKGROUND)
        DC_vUpdateBackgroundBrush(dc);
 
    if (lprc && (fuOptions & (ETO_CLIPPED | ETO_OPAQUE)))
    {
        IntLPtoDP(dc, (POINT*)lprc, 2);
        lprc->left   += dc->ptlDCOrig.x;
        lprc->top    += dc->ptlDCOrig.y;
        lprc->right  += dc->ptlDCOrig.x;
        lprc->bottom += dc->ptlDCOrig.y;
    }
 
    if (lprc && (fuOptions & ETO_OPAQUE))
    {
        IntEngFillBox(dc,
                      lprc->left, lprc->top,
                      lprc->right - lprc->left, lprc->bottom - lprc->top,
                      &dc->eboBackground.BrushObject);
        fuOptions &= ~ETO_OPAQUE;
    }
    else
    {
        if (pdcattr->jBkMode == OPAQUE)
        {
            fuOptions |= ETO_OPAQUE;
        }
    }
 
    TextObj = RealizeFontInit(pdcattr->hlfntNew);
    if (TextObj == NULL)
    {
        bResult = FALSE;
        goto Cleanup;
    }
 
    FontObj = TextObj->Font;
    ASSERT(FontObj);
    FontGDI = ObjToGDI(FontObj, FONT);
    ASSERT(FontGDI);
 
    IntLockFreeType();
    Cache.Hashed.Face = face = FontGDI->SharedFace->Face;
 
    plf = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
    Cache.Hashed.lfHeight = plf->lfHeight;
    Cache.Hashed.lfWidth = plf->lfWidth;
    Cache.Hashed.Aspect.Emu.Bold = EMUBOLD_NEEDED(FontGDI->OriginalWeight, plf->lfWeight);
    Cache.Hashed.Aspect.Emu.Italic = (plf->lfItalic && !FontGDI->OriginalItalic);
 
    if (IntIsFontRenderingEnabled())
        Cache.Hashed.Aspect.RenderMode = (BYTE)IntGetFontRenderMode(plf);
    else
        Cache.Hashed.Aspect.RenderMode = (BYTE)FT_RENDER_MODE_MONO;
 
    if (!TextIntUpdateSize(TextObj, FontGDI, FALSE))
    {
        IntUnLockFreeType();
        bResult = FALSE;
        goto Cleanup;
    }
 
    FontLink_Chain_Init(&Chain, TextObj, face);
 
    /* Apply lfEscapement */
    if (FT_IS_SCALABLE(face) && plf->lfEscapement != 0)
        IntEscapeMatrix(&Cache.Hashed.matTransform, plf->lfEscapement);
    else
        Cache.Hashed.matTransform = identityMat;
 
    /* Apply the world transformation */
    IntMatrixFromMx(&mat, pmxWorldToDevice);
    FT_Matrix_Multiply(&mat, &Cache.Hashed.matTransform);
    FT_Set_Transform(face, &Cache.Hashed.matTransform, NULL);
 
    /* Is there no transformation? */
    bNoTransform = ((mat.xy == 0) && (mat.yx == 0) &&
                    (mat.xx == (1 << 16)) && (mat.yy == (1 << 16)));
 
    /* Calculate the ascent point and the descent point */
    vecAscent64.x = 0;
    vecAscent64.y = (FontGDI->tmAscent << 6);
    FT_Vector_Transform(&vecAscent64, &Cache.Hashed.matTransform);
    vecDescent64.x = 0;
    vecDescent64.y = -(FontGDI->tmDescent << 6);
    FT_Vector_Transform(&vecDescent64, &Cache.Hashed.matTransform);
 
    /* Process the vertical alignment and fix the real starting point. */
#define VALIGN_MASK  (TA_TOP | TA_BASELINE | TA_BOTTOM)
    if ((pdcattr->flTextAlign & VALIGN_MASK) == TA_BASELINE)
    {
        NOTHING;
    }
    else if ((pdcattr->flTextAlign & VALIGN_MASK) == TA_BOTTOM)
    {
        RealXStart64 -= vecDescent64.x;
        RealYStart64 += vecDescent64.y;
    }
    else /* TA_TOP */
    {
        RealXStart64 -= vecAscent64.x;
        RealYStart64 += vecAscent64.y;
    }
#undef VALIGN_MASK
 
    use_kerning = FT_HAS_KERNING(face);
 
    /* Calculate the text width if necessary */
    if ((fuOptions & ETO_OPAQUE) || (pdcattr->flTextAlign & (TA_CENTER | TA_RIGHT)))
    {
        if (!IntGetTextDisposition(&DeltaX64, &DeltaY64, String, Count, Dx, &Cache,
                                   fuOptions, bNoTransform, &Chain))
        {
            IntUnLockFreeType();
            bResult = FALSE;
            goto Cleanup;
        }
 
        /* Adjust the horizontal position by horizontal alignment */
        if ((pdcattr->flTextAlign & TA_CENTER) == TA_CENTER)
        {
            RealXStart64 -= DeltaX64 / 2;
            RealYStart64 -= DeltaY64 / 2;
        }
        else if ((pdcattr->flTextAlign & TA_RIGHT) == TA_RIGHT)
        {
            RealXStart64 -= DeltaX64;
            RealYStart64 -= DeltaY64;
        }
 
        /* Fill background */
        if (fuOptions & ETO_OPAQUE)
        {
            INT X0 = (RealXStart64 + vecAscent64.x + 32) >> 6;
            INT Y0 = (RealYStart64 - vecAscent64.y + 32) >> 6;
            INT DX = (DeltaX64 >> 6);
            if (Cache.Hashed.matTransform.xy == 0 && Cache.Hashed.matTransform.yx == 0)
            {
                INT CY = (vecAscent64.y - vecDescent64.y + 32) >> 6;
                IntEngFillBox(dc, X0, Y0, DX, CY, &dc->eboBackground.BrushObject);
            }
            else
            {
                INT DY = (DeltaY64 >> 6);
                INT X1 = ((RealXStart64 + vecDescent64.x + 32) >> 6);
                INT Y1 = ((RealYStart64 - vecDescent64.y + 32) >> 6);
                POINT Points[4] =
                {
                    { X0,       Y0      },
                    { X0 + DX,  Y0 + DY },
                    { X1 + DX,  Y1 + DY },
                    { X1,       Y1      },
                };
                IntEngFillPolygon(dc, Points, 4, &dc->eboBackground.BrushObject);
            }
        }
    }
 
    EXLATEOBJ_vInitialize(&exloRGB2Dst, &gpalRGB, psurf->ppal, 0, 0, 0);
    EXLATEOBJ_vInitialize(&exloDst2RGB, psurf->ppal, &gpalRGB, 0, 0, 0);
 
    if (pdcattr->ulDirty_ & DIRTY_TEXT)
        DC_vUpdateTextBrush(dc);
 
    /*
     * The main rendering loop.
     */
    X64 = RealXStart64;
    Y64 = RealYStart64;
    previous = 0;
    DoBreak = FALSE;
    bResult = TRUE; /* Assume success */
    for (i = 0; i < Count; ++i)
    {
        ch0 = *String++;
        if (IS_HIGH_SURROGATE(ch0))
        {
            ++i;
            if (i >= Count)
                break;
 
            ch1 = *String++;
            if (IS_LOW_SURROGATE(ch1))
                ch0 = Utf32FromSurrogatePair(ch0, ch1);
        }
 
        glyph_index = FontLink_Chain_FindGlyph(&Chain, &Cache, &face, ch0,
                                               (fuOptions & ETO_GLYPH_INDEX));
        Cache.Hashed.GlyphIndex = glyph_index;
 
        realglyph = IntGetRealGlyph(&Cache);
        if (!realglyph)
        {
            bResult = FALSE;
            break;
        }
 
        /* retrieve kerning distance and move pen position */
        if (use_kerning && previous && glyph_index && NULL == Dx)
        {
            FT_Get_Kerning(face, previous, glyph_index, 0, &delta);
            X64 += delta.x;
            Y64 -= delta.y;
        }
 
        DPRINT("X64, Y64: %I64d, %I64d\n", X64, Y64);
        DPRINT("Advance: %d, %d\n", realglyph->root.advance.x, realglyph->root.advance.y);
 
        glyphSize.cx = realglyph->bitmap.width;
        glyphSize.cy = realglyph->bitmap.rows;
 
        /* Do chars > space & not DEL & not nbsp have a glyphSize.cx of zero? */
        if (ch0 > L' ' && ch0 != del && ch0 != nbsp && glyphSize.cx == 0)
        {
            DPRINT1("WARNING: family_name '%s' WChar 0x%04x has a glyphSize.cx of zero\n",
                    face->family_name, ch0);
        }
 
        /* Don't ignore spaces or non-breaking spaces when computing offset.
         * This completes the fix of CORE-11787. */
        if ((pdcattr->flTextAlign & TA_UPDATECP) && glyphSize.cx == 0 &&
            (ch0 == L' ' || ch0 == nbsp)) // Space chars needing x-dim widths
        {
            IntUnLockFreeType();
            /* Get the width of the space character */
            TextIntGetTextExtentPoint(dc, TextObj, L" ", 1, 0, NULL, NULL, &spaceWidth, 0);
            IntLockFreeType();
            glyphSize.cx = spaceWidth.cx;
            realglyph->left = 0;
        }
 
        MaskRect.right = realglyph->bitmap.width;
        MaskRect.bottom = realglyph->bitmap.rows;
 
        DestRect.left   = ((X64 + 32) >> 6) + realglyph->left;
        DestRect.right  = DestRect.left + glyphSize.cx;
        DestRect.top    = ((Y64 + 32) >> 6) - realglyph->top;
        DestRect.bottom = DestRect.top + glyphSize.cy;
 
        /* Check if the bitmap has any pixels */
        if ((glyphSize.cx != 0) && (glyphSize.cy != 0))
        {
            /*
             * We should create the bitmap out of the loop at the biggest possible
             * glyph size. Then use memset with 0 to clear it and sourcerect to
             * limit the work of the transbitblt.
             */
            hbmGlyph = EngCreateBitmap(glyphSize, realglyph->bitmap.pitch,
                                       BMF_8BPP, BMF_TOPDOWN,
                                       realglyph->bitmap.buffer);
            if (!hbmGlyph)
            {
                DPRINT1("WARNING: EngCreateBitmap() failed!\n");
                bResult = FALSE;
                break;
            }
 
            psoGlyph = EngLockSurface((HSURF)hbmGlyph);
            if (!psoGlyph)
            {
                EngDeleteSurface((HSURF)hbmGlyph);
                DPRINT1("WARNING: EngLockSurface() failed!\n");
                bResult = FALSE;
                break;
            }
 
            /*
             * Use the font data as a mask to paint onto the DCs surface using a
             * brush.
             */
            if (lprc && (fuOptions & ETO_CLIPPED))
            {
                // We do the check '>=' instead of '>' to possibly save an iteration
                // through this loop, since it's breaking after the drawing is done,
                // and x is always incremented.
                if (DestRect.right >= lprc->right)
                {
                    DestRect.right = lprc->right;
                    DoBreak = TRUE;
                }
 
                if (DestRect.bottom >= lprc->bottom)
                {
                    DestRect.bottom = lprc->bottom;
                }
            }
 
            if (!IntEngMaskBlt(psoDest,
                               psoGlyph,
                               (CLIPOBJ *)&dc->co,
                               &exloRGB2Dst.xlo,
                               &exloDst2RGB.xlo,
                               &DestRect,
                               (PPOINTL)&MaskRect,
                               &dc->eboText.BrushObject,
                               &g_PointZero))
            {
                DPRINT1("Failed to MaskBlt a glyph!\n");
            }
 
            EngUnlockSurface(psoGlyph);
            EngDeleteSurface((HSURF)hbmGlyph);
        }
 
        if (DoBreak)
            break;
 
        if (NULL == Dx)
        {
            X64 += realglyph->root.advance.x >> 10;
            Y64 -= realglyph->root.advance.y >> 10;
        }
        else if (fuOptions & ETO_PDY)
        {
            vec.x = (Dx[2 * i + 0] << 6);
            vec.y = (Dx[2 * i + 1] << 6);
            if (!bNoTransform)
                FT_Vector_Transform(&vec, &Cache.Hashed.matTransform);
            X64 += vec.x;
            Y64 -= vec.y;
        }
        else
        {
            vec.x = (Dx[i] << 6);
            vec.y = 0;
            if (!bNoTransform)
                FT_Vector_Transform(&vec, &Cache.Hashed.matTransform);
            X64 += vec.x;
            Y64 -= vec.y;
        }
 
        DPRINT("New X64, New Y64: %I64d, %I64d\n", X64, Y64);
 
        previous = glyph_index;
    }
    /* Don't update position if String == NULL. Fixes CORE-19721. */
    if ((pdcattr->flTextAlign & TA_UPDATECP) && String)
        pdcattr->ptlCurrent.x = DestRect.right - dc->ptlDCOrig.x;
 
    if (plf->lfUnderline || plf->lfStrikeOut) /* Underline or strike-out? */
    {
        /* Calculate the position and the thickness */
        INT underline_position, thickness;
        FT_Vector vecA64, vecB64;
 
        DeltaX64 = X64 - RealXStart64;
        DeltaY64 = Y64 - RealYStart64;
 
        if (!face->units_per_EM)
        {
            underline_position = 0;
            thickness = 1;
        }
        else
        {
            underline_position =
                face->underline_position * face->size->metrics.y_ppem / face->units_per_EM;
            thickness =
                face->underline_thickness * face->size->metrics.y_ppem / face->units_per_EM;
            if (thickness <= 0)
                thickness = 1;
        }
 
        if (plf->lfUnderline) /* Draw underline */
        {
            vecA64.x = 0;
            vecA64.y = (-underline_position - thickness / 2) << 6;
            vecB64.x = 0;
            vecB64.y = vecA64.y + (thickness << 6);
            FT_Vector_Transform(&vecA64, &Cache.Hashed.matTransform);
            FT_Vector_Transform(&vecB64, &Cache.Hashed.matTransform);
            {
                INT X0 = (RealXStart64 - vecA64.x + 32) >> 6;
                INT Y0 = (RealYStart64 + vecA64.y + 32) >> 6;
                INT DX = (DeltaX64 >> 6);
                if (Cache.Hashed.matTransform.xy == 0 && Cache.Hashed.matTransform.yx == 0)
                {
                    INT CY = (vecB64.y - vecA64.y + 32) >> 6;
                    IntEngFillBox(dc, X0, Y0, DX, CY, &dc->eboText.BrushObject);
                }
                else
                {
                    INT DY = (DeltaY64 >> 6);
                    INT X1 = X0 + ((vecA64.x - vecB64.x + 32) >> 6);
                    INT Y1 = Y0 + ((vecB64.y - vecA64.y + 32) >> 6);
                    POINT Points[4] =
                    {
                        { X0,       Y0      },
                        { X0 + DX,  Y0 + DY },
                        { X1 + DX,  Y1 + DY },
                        { X1,       Y1      },
                    };
                    IntEngFillPolygon(dc, Points, 4, &dc->eboText.BrushObject);
                }
            }
        }
 
        if (plf->lfStrikeOut) /* Draw strike-out */
        {
            vecA64.x = 0;
            vecA64.y = -(FontGDI->tmAscent << 6) / 3;
            vecB64.x = 0;
            vecB64.y = vecA64.y + (thickness << 6);
            FT_Vector_Transform(&vecA64, &Cache.Hashed.matTransform);
            FT_Vector_Transform(&vecB64, &Cache.Hashed.matTransform);
            {
                INT X0 = (RealXStart64 - vecA64.x + 32) >> 6;
                INT Y0 = (RealYStart64 + vecA64.y + 32) >> 6;
                INT DX = (DeltaX64 >> 6);
                if (Cache.Hashed.matTransform.xy == 0 && Cache.Hashed.matTransform.yx == 0)
                {
                    INT CY = (vecB64.y - vecA64.y + 32) >> 6;
                    IntEngFillBox(dc, X0, Y0, DX, CY, &dc->eboText.BrushObject);
                }
                else
                {
                    INT DY = (DeltaY64 >> 6);
                    INT X1 = X0 + ((vecA64.x - vecB64.x + 32) >> 6);
                    INT Y1 = Y0 + ((vecB64.y - vecA64.y + 32) >> 6);
                    POINT Points[4] =
                    {
                        { X0,       Y0      },
                        { X0 + DX,  Y0 + DY },
                        { X1 + DX,  Y1 + DY },
                        { X1,       Y1      },
                    };
                    IntEngFillPolygon(dc, Points, 4, &dc->eboText.BrushObject);
                }
            }
        }
    }
 
    IntUnLockFreeType();
 
    EXLATEOBJ_vCleanup(&exloRGB2Dst);
    EXLATEOBJ_vCleanup(&exloDst2RGB);
 
Cleanup:
    DC_vFinishBlit(dc, NULL);
 
    if (TextObj != NULL)
        TEXTOBJ_UnlockText(TextObj);
 
    return bResult;
}

Referenced by GreExtTextOutW().

IntFindGlyphCache()

static FT_BitmapGlyph IntFindGlyphCache ( IN const FONT_CACHE_ENTRY *  pCache )

static

Definition at line 3781 of file freetype.c.

{
    PLIST_ENTRY CurrentEntry;
    PFONT_CACHE_ENTRY FontEntry;
    DWORD dwHash = pCache->dwHash;
 
    ASSERT_FREETYPE_LOCK_HELD();
 
    for (CurrentEntry = g_FontCacheListHead.Flink;
         CurrentEntry != &g_FontCacheListHead;
         CurrentEntry = CurrentEntry->Flink)
    {
        FontEntry = CONTAINING_RECORD(CurrentEntry, FONT_CACHE_ENTRY, ListEntry);
        if (FontEntry->dwHash == dwHash &&
            FontEntry->Hashed.GlyphIndex == pCache->Hashed.GlyphIndex &&
            FontEntry->Hashed.Face == pCache->Hashed.Face &&
            FontEntry->Hashed.lfHeight == pCache->Hashed.lfHeight &&
            FontEntry->Hashed.lfWidth == pCache->Hashed.lfWidth &&
            FontEntry->Hashed.AspectValue == pCache->Hashed.AspectValue &&
            memcmp(&FontEntry->Hashed.matTransform, &pCache->Hashed.matTransform,
                   sizeof(FT_Matrix)) == 0)
        {
            break;
        }
    }
 
    if (CurrentEntry == &g_FontCacheListHead)
    {
        return NULL;
    }
 
    RemoveEntryList(CurrentEntry);
    InsertHeadList(&g_FontCacheListHead, CurrentEntry);
    return FontEntry->BitmapGlyph;
}

Referenced by IntGetRealGlyph().

IntFontType()

static VOID FASTCALL IntFontType ( PFONTGDI  Font )

static

Definition at line 5830 of file freetype.c.

{
    PS_FontInfoRec psfInfo;
    FT_ULong tmp_size = 0;
    FT_Face Face = Font->SharedFace->Face;
 
    ASSERT_FREETYPE_LOCK_NOT_HELD();
 
    if (FT_HAS_MULTIPLE_MASTERS(Face))
        Font->FontObj.flFontType |= FO_MULTIPLEMASTER;
    if (FT_HAS_VERTICAL(Face))
        Font->FontObj.flFontType |= FO_VERT_FACE;
    if (!FT_IS_SCALABLE(Face))
        Font->FontObj.flFontType |= FO_TYPE_RASTER;
    if (FT_IS_SFNT(Face))
    {
        Font->FontObj.flFontType |= FO_TYPE_TRUETYPE;
        if (FT_Get_Sfnt_Table(Face, ft_sfnt_post))
            Font->FontObj.flFontType |= FO_POSTSCRIPT;
    }
    if (!FT_Get_PS_Font_Info(Face, &psfInfo ))
    {
        Font->FontObj.flFontType |= FO_POSTSCRIPT;
    }
    /* Check for the presence of the 'CFF ' table to check if the font is Type1 */
    if (!FT_Load_Sfnt_Table(Face, TTAG_CFF, 0, NULL, &tmp_size))
    {
        Font->FontObj.flFontType |= (FO_CFF|FO_POSTSCRIPT);
    }
}

Referenced by TextIntRealizeFont().

IntFreeFontNames()

static __inline void FASTCALL IntFreeFontNames ( FONT_NAMES *  Names )

static

Definition at line 3127 of file freetype.c.

{
    RtlFreeUnicodeString(&Names->FamilyNameW);
    RtlFreeUnicodeString(&Names->FaceNameW);
    RtlFreeUnicodeString(&Names->StyleNameW);
    RtlFreeUnicodeString(&Names->FullNameW);
}

Referenced by IntGetOutlineTextMetrics().

IntGdiAddFontMemResource()

HANDLE FASTCALL IntGdiAddFontMemResource	(	PVOID	Buffer,
		DWORD	dwSize,
		PDWORD	pNumAdded
	)

Definition at line 2529 of file freetype.c.

{
    HANDLE Ret = NULL;
    GDI_LOAD_FONT LoadFont;
    PFONT_ENTRY_COLL_MEM EntryCollection;
    INT FaceCount;
 
    PVOID BufferCopy = ExAllocatePoolWithTag(PagedPool, dwSize, TAG_FONT);
    if (!BufferCopy)
    {
        *pNumAdded = 0;
        return NULL;
    }
    RtlCopyMemory(BufferCopy, Buffer, dwSize);
 
    RtlZeroMemory(&LoadFont, sizeof(LoadFont));
    LoadFont.Memory             = SharedMem_Create(BufferCopy, dwSize, FALSE);
    LoadFont.Characteristics    = FR_PRIVATE | FR_NOT_ENUM;
    RtlInitUnicodeString(&LoadFont.RegValueName, NULL);
    FaceCount = IntGdiLoadFontByIndexFromMemory(&LoadFont, -1);
 
    RtlFreeUnicodeString(&LoadFont.RegValueName);
 
    /* Release our copy */
    IntLockFreeType();
    SharedMem_Release(LoadFont.Memory);
    IntUnLockFreeType();
 
    if (FaceCount > 0)
    {
        EntryCollection = ExAllocatePoolWithTag(PagedPool, sizeof(FONT_ENTRY_COLL_MEM), TAG_FONT);
        if (EntryCollection)
        {
            PPROCESSINFO Win32Process = PsGetCurrentProcessWin32Process();
            EntryCollection->Entry = LoadFont.PrivateEntry;
            IntLockFreeType();
            IntLockProcessPrivateFonts(Win32Process);
            EntryCollection->Handle = ULongToHandle(++Win32Process->PrivateMemFontHandleCount);
            InsertTailList(&Win32Process->PrivateMemFontListHead, &EntryCollection->ListEntry);
            IntUnLockProcessPrivateFonts(Win32Process);
            IntUnLockFreeType();
            Ret = EntryCollection->Handle;
        }
    }
    *pNumAdded = FaceCount;
 
    return Ret;
}

Referenced by NtGdiAddFontMemResourceEx().

IntGdiAddFontResourceEx()

INT FASTCALL IntGdiAddFontResourceEx	(	_In_ PCUNICODE_STRING	FileName,
		_In_ DWORD	cFiles,
		_In_ DWORD	Characteristics,
		_In_ DWORD	dwFlags
	)

Definition at line 2198 of file freetype.c.

{
    PWSTR pchFile = FileName->Buffer;
    SIZE_T cchFile;
    INT ret = 0;
 
    while (cFiles--)
    {
        _SEH2_TRY
        {
            cchFile = wcslen(pchFile);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            _SEH2_YIELD(return FALSE);
        }
        _SEH2_END;
 
        UNICODE_STRING ustrPathName;
        ustrPathName.Length = (USHORT)(cchFile * sizeof(WCHAR));
        ustrPathName.MaximumLength = ustrPathName.Length + sizeof(WCHAR);
        ustrPathName.Buffer = pchFile;
 
        INT count = IntGdiAddFontResourceSingle(&ustrPathName, Characteristics, dwFlags);
        if (!count)
            return 0;
        ret += count;
 
        pchFile += cchFile + 1;
    }
 
    return ret;
}

Referenced by IntLoadFontsInRegistry(), IntLoadSystemFonts(), and NtGdiAddFontResourceW().

IntGdiAddFontResourceSingle()

static INT FASTCALL IntGdiAddFontResourceSingle ( _In_ PCUNICODE_STRING  FileName, _In_ DWORD  Characteristics, _In_ DWORD  dwFlags  )

static

Definition at line 1999 of file freetype.c.

{
    NTSTATUS Status;
    HANDLE FileHandle;
    PVOID Buffer = NULL;
    IO_STATUS_BLOCK Iosb;
    PVOID SectionObject;
    SIZE_T ViewSize = 0, Length;
    LARGE_INTEGER SectionSize;
    OBJECT_ATTRIBUTES ObjectAttributes;
    GDI_LOAD_FONT LoadFont;
    INT FontCount;
    HANDLE KeyHandle;
    UNICODE_STRING PathName;
    LPWSTR pszBuffer;
    PFILE_OBJECT FileObject;
    static const UNICODE_STRING TrueTypePostfix = RTL_CONSTANT_STRING(L" (TrueType)");
 
    /* Build PathName */
    if (dwFlags & AFRX_DOS_DEVICE_PATH)
    {
        Length = DosPathPrefix.Length + FileName->Length + sizeof(UNICODE_NULL);
        pszBuffer = ExAllocatePoolWithTag(PagedPool, Length, TAG_USTR);
        if (!pszBuffer)
            return 0;   /* failure */
 
        RtlInitEmptyUnicodeString(&PathName, pszBuffer, Length);
        RtlAppendUnicodeStringToString(&PathName, &DosPathPrefix);
        RtlAppendUnicodeStringToString(&PathName, FileName);
    }
    else
    {
        Status = IntDuplicateUnicodeString(FileName, &PathName);
        if (!NT_SUCCESS(Status))
            return 0;   /* failure */
    }
 
    /* Open the font file */
    InitializeObjectAttributes(&ObjectAttributes, &PathName,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
    Status = ZwOpenFile(
                 &FileHandle,
                 FILE_GENERIC_READ | SYNCHRONIZE,
                 &ObjectAttributes,
                 &Iosb,
                 FILE_SHARE_READ,
                 FILE_SYNCHRONOUS_IO_NONALERT);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Could not load font file: %wZ\n", &PathName);
        RtlFreeUnicodeString(&PathName);
        return 0;
    }
 
    Status = ObReferenceObjectByHandle(FileHandle, FILE_READ_DATA, NULL,
                                       KernelMode, (PVOID*)&FileObject, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ObReferenceObjectByHandle failed.\n");
        ZwClose(FileHandle);
        RtlFreeUnicodeString(&PathName);
        return 0;
    }
 
    SectionSize.QuadPart = 0LL;
    Status = MmCreateSection(&SectionObject,
                             STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
                             NULL, &SectionSize, PAGE_READONLY,
                             SEC_COMMIT, FileHandle, FileObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Could not map file: %wZ\n", &PathName);
        ZwClose(FileHandle);
        ObDereferenceObject(FileObject);
        RtlFreeUnicodeString(&PathName);
        return 0;
    }
    ZwClose(FileHandle);
 
    Status = MmMapViewInSystemSpace(SectionObject, &Buffer, &ViewSize);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Could not map file: %wZ\n", &PathName);
        ObDereferenceObject(SectionObject);
        ObDereferenceObject(FileObject);
        RtlFreeUnicodeString(&PathName);
        return 0;
    }
 
    RtlZeroMemory(&LoadFont, sizeof(LoadFont));
    LoadFont.pFileName          = &PathName;
    LoadFont.Memory             = SharedMem_Create(Buffer, ViewSize, TRUE);
    LoadFont.Characteristics    = Characteristics;
    RtlInitUnicodeString(&LoadFont.RegValueName, NULL);
    LoadFont.CharSet            = DEFAULT_CHARSET;
    FontCount = IntGdiLoadFontByIndexFromMemory(&LoadFont, -1);
 
    /* Release our copy */
    IntLockFreeType();
    SharedMem_Release(LoadFont.Memory);
    IntUnLockFreeType();
 
    ObDereferenceObject(SectionObject);
 
    ObDereferenceObject(FileObject);
 
    /* Save the loaded font name into the registry */
    if (FontCount > 0 && (dwFlags & AFRX_WRITE_REGISTRY))
    {
        UNICODE_STRING NewString;
        SIZE_T Length;
        PWCHAR pszBuffer;
        LPCWSTR CharSetName;
        if (LoadFont.IsTrueType)
        {
            /* Append " (TrueType)" */
            Length = LoadFont.RegValueName.Length + TrueTypePostfix.Length + sizeof(UNICODE_NULL);
            pszBuffer = ExAllocatePoolWithTag(PagedPool, Length, TAG_USTR);
            if (pszBuffer)
            {
                RtlInitEmptyUnicodeString(&NewString, pszBuffer, Length);
                NewString.Buffer[0] = UNICODE_NULL;
                RtlAppendUnicodeStringToString(&NewString, &LoadFont.RegValueName);
                RtlAppendUnicodeStringToString(&NewString, &TrueTypePostfix);
                RtlFreeUnicodeString(&LoadFont.RegValueName);
                LoadFont.RegValueName = NewString;
            }
            else
            {
                // FIXME!
            }
        }
        else if (LoadFont.CharSet != DEFAULT_CHARSET)
        {
            /* Append " (CharSetName)" */
            CharSetName = IntNameFromCharSet(LoadFont.CharSet);
            Length = LoadFont.RegValueName.Length +
                     (wcslen(CharSetName) + 3) * sizeof(WCHAR) +
                     sizeof(UNICODE_NULL);
 
            pszBuffer = ExAllocatePoolWithTag(PagedPool, Length, TAG_USTR);
            if (pszBuffer)
            {
                RtlInitEmptyUnicodeString(&NewString, pszBuffer, Length);
                NewString.Buffer[0] = UNICODE_NULL;
                RtlAppendUnicodeStringToString(&NewString, &LoadFont.RegValueName);
                RtlAppendUnicodeToString(&NewString, L" (");
                RtlAppendUnicodeToString(&NewString, CharSetName);
                RtlAppendUnicodeToString(&NewString, L")");
                RtlFreeUnicodeString(&LoadFont.RegValueName);
                LoadFont.RegValueName = NewString;
            }
            else
            {
                // FIXME!
            }
        }
 
        InitializeObjectAttributes(&ObjectAttributes, &g_FontRegPath,
                                   OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                   NULL, NULL);
        Status = ZwOpenKey(&KeyHandle, KEY_WRITE, &ObjectAttributes);
        if (NT_SUCCESS(Status))
        {
            SIZE_T DataSize;
            LPWSTR pFileName;
 
            if (dwFlags & AFRX_ALTERNATIVE_PATH)
            {
                pFileName = PathName.Buffer;
            }
            else
            {
                pFileName = wcsrchr(PathName.Buffer, L'\\');
            }
 
            if (pFileName)
            {
                if (!(dwFlags & AFRX_ALTERNATIVE_PATH))
                {
                    pFileName++;
                }
                DataSize = (wcslen(pFileName) + 1) * sizeof(WCHAR);
                ZwSetValueKey(KeyHandle, &LoadFont.RegValueName, 0, REG_SZ,
                              pFileName, DataSize);
            }
            ZwClose(KeyHandle);
        }
    }
    RtlFreeUnicodeString(&LoadFont.RegValueName);
 
    RtlFreeUnicodeString(&PathName);
    return FontCount;
}

Referenced by IntGdiAddFontResourceEx().

IntGdiCleanupMemEntry()

VOID FASTCALL IntGdiCleanupMemEntry

(

PFONT_ENTRY_MEM

Head

)

Definition at line 2579 of file freetype.c.

{
    PLIST_ENTRY Entry;
    PFONT_ENTRY_MEM FontEntry;
 
    while (!IsListEmpty(&Head->ListEntry))
    {
        Entry = RemoveHeadList(&Head->ListEntry);
        FontEntry = CONTAINING_RECORD(Entry, FONT_ENTRY_MEM, ListEntry);
 
        CleanupFontEntry(FontEntry->Entry);
        ExFreePoolWithTag(FontEntry, TAG_FONT);
    }
 
    CleanupFontEntry(Head->Entry);
    ExFreePoolWithTag(Head, TAG_FONT);
}

Referenced by IntGdiCleanupPrivateFontsForProcess(), and IntGdiRemoveFontMemResource().

IntGdiCleanupPrivateFontsForProcess()

VOID FASTCALL IntGdiCleanupPrivateFontsForProcess

(

VOID

)

Definition at line 2651 of file freetype.c.

{
    PPROCESSINFO Win32Process = PsGetCurrentProcessWin32Process();
    PLIST_ENTRY Entry;
    PFONT_ENTRY_COLL_MEM EntryCollection;
 
    DPRINT("IntGdiCleanupPrivateFontsForProcess()\n");
    do {
        Entry = NULL;
        EntryCollection = NULL;
 
        IntLockFreeType();
        IntLockProcessPrivateFonts(Win32Process);
        if (!IsListEmpty(&Win32Process->PrivateMemFontListHead))
        {
            Entry = Win32Process->PrivateMemFontListHead.Flink;
            EntryCollection = CONTAINING_RECORD(Entry, FONT_ENTRY_COLL_MEM, ListEntry);
            UnlinkFontMemCollection(EntryCollection);
        }
        IntUnLockProcessPrivateFonts(Win32Process);
        IntUnLockFreeType();
 
        if (EntryCollection)
        {
            IntGdiCleanupMemEntry(EntryCollection->Entry);
            ExFreePoolWithTag(EntryCollection, TAG_FONT);
        }
        else
        {
            /* No Mem fonts anymore, see if we have any other private fonts left */
            Entry = NULL;
            IntLockFreeType();
            IntLockProcessPrivateFonts(Win32Process);
            if (!IsListEmpty(&Win32Process->PrivateFontListHead))
            {
                Entry = RemoveHeadList(&Win32Process->PrivateFontListHead);
            }
            IntUnLockProcessPrivateFonts(Win32Process);
            IntUnLockFreeType();
 
            if (Entry)
            {
                CleanupFontEntry(CONTAINING_RECORD(Entry, FONT_ENTRY, ListEntry));
            }
        }
 
    } while (Entry);
}

Referenced by GdiProcessDestroy().

IntGdiGetFontResourceInfo()

BOOL FASTCALL IntGdiGetFontResourceInfo	(	PUNICODE_STRING	FileName,
		PVOID	pBuffer,
		DWORD *	pdwBytes,
		DWORD	dwType
	)

Definition at line 6104 of file freetype.c.

{
    UNICODE_STRING EntryFileName;
    POBJECT_NAME_INFORMATION NameInfo1 = NULL, NameInfo2 = NULL;
    PLIST_ENTRY ListEntry;
    PFONT_ENTRY FontEntry;
    ULONG Size, i, Count;
    LPBYTE pbBuffer;
    BOOL IsEqual;
    FONTFAMILYINFO *FamInfo;
    const ULONG MaxFamInfo = 64;
    const ULONG MAX_FAM_INFO_BYTES = sizeof(FONTFAMILYINFO) * MaxFamInfo;
    BOOL bSuccess;
    const ULONG NAMEINFO_SIZE = sizeof(OBJECT_NAME_INFORMATION) + MAX_PATH * sizeof(WCHAR);
 
    DPRINT("IntGdiGetFontResourceInfo: dwType == %lu\n", dwType);
 
    do
    {
        /* Create buffer for full path name */
        NameInfo1 = ExAllocatePoolWithTag(PagedPool, NAMEINFO_SIZE, TAG_FINF);
        if (!NameInfo1)
            break;
 
        /* Get the full path name */
        if (!IntGetFullFileName(NameInfo1, NAMEINFO_SIZE, FileName))
            break;
 
        /* Create a buffer for the entries' names */
        NameInfo2 = ExAllocatePoolWithTag(PagedPool, NAMEINFO_SIZE, TAG_FINF);
        if (!NameInfo2)
            break;
 
        FamInfo = ExAllocatePoolWithTag(PagedPool, MAX_FAM_INFO_BYTES, TAG_FINF);
    } while (0);
 
    if (!NameInfo1 || !NameInfo2 || !FamInfo)
    {
        if (NameInfo2)
            ExFreePoolWithTag(NameInfo2, TAG_FINF);
 
        if (NameInfo1)
            ExFreePoolWithTag(NameInfo1, TAG_FINF);
 
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    Count = 0;
 
    /* Try to find the pathname in the global font list */
    IntLockFreeType();
    for (ListEntry = g_FontListHead.Flink; ListEntry != &g_FontListHead;
         ListEntry = ListEntry->Flink)
    {
        FontEntry = CONTAINING_RECORD(ListEntry, FONT_ENTRY, ListEntry);
        if (FontEntry->Font->Filename == NULL)
            continue;
 
        RtlInitUnicodeString(&EntryFileName , FontEntry->Font->Filename);
        if (!IntGetFullFileName(NameInfo2, NAMEINFO_SIZE, &EntryFileName))
            continue;
 
        if (!RtlEqualUnicodeString(&NameInfo1->Name, &NameInfo2->Name, FALSE))
            continue;
 
        IsEqual = FALSE;
        FontFamilyFillInfo(&FamInfo[Count], FontEntry->FaceName.Buffer,
                           NULL, FontEntry->Font);
        for (i = 0; i < Count; ++i)
        {
            if (EqualFamilyInfo(&FamInfo[i], &FamInfo[Count]))
            {
                IsEqual = TRUE;
                break;
            }
        }
        if (!IsEqual)
        {
            /* Found */
            ++Count;
            if (Count >= MaxFamInfo)
                break;
        }
    }
    IntUnLockFreeType();
 
    /* Free the buffers */
    ExFreePoolWithTag(NameInfo1, TAG_FINF);
    ExFreePoolWithTag(NameInfo2, TAG_FINF);
 
    if (Count == 0 && dwType != 5)
    {
        /* Font could not be found in system table
           dwType == 5 will still handle this */
        ExFreePoolWithTag(FamInfo, TAG_FINF);
        return FALSE;
    }
 
    bSuccess = FALSE;
    switch (dwType)
    {
    case 0: /* FIXME: Returns 1 or 2, don't know what this is atm */
        Size = sizeof(DWORD);
        if (*pdwBytes == 0)
        {
            *pdwBytes = Size;
            bSuccess = TRUE;
        }
        else if (pBuffer)
        {
            if (*pdwBytes >= Size)
            {
                *(DWORD*)pBuffer = Count;
            }
            *pdwBytes = Size;
            bSuccess = TRUE;
        }
        break;
 
    case 1: /* copy the font title */
        /* calculate the required size */
        Size = 0;
        for (i = 0; i < Count; ++i)
        {
            if (i > 0)
                Size += 3;  /* " & " */
            Size += wcslen(FamInfo[i].EnumLogFontEx.elfLogFont.lfFaceName);
            if (FamInfo[i].EnumLogFontEx.elfStyle[0] &&
                _wcsicmp(FamInfo[i].EnumLogFontEx.elfStyle, L"Regular") != 0)
            {
                Size += 1 + wcslen(FamInfo[i].EnumLogFontEx.elfStyle);
            }
        }
        Size += 2;  /* "\0\0" */
        Size *= sizeof(WCHAR);
 
        if (*pdwBytes == 0)
        {
            *pdwBytes = Size;
            bSuccess = TRUE;
        }
        else if (pBuffer)
        {
            if (*pdwBytes >= Size)
            {
                /* store font title to buffer */
                WCHAR *psz = pBuffer;
                *psz = 0;
                for (i = 0; i < Count; ++i)
                {
                    if (i > 0)
                        wcscat(psz, L" & ");
                    IntAddNameFromFamInfo(psz, &FamInfo[i]);
                }
                psz[wcslen(psz) + 1] = UNICODE_NULL;
                *pdwBytes = Size;
                bSuccess = TRUE;
            }
            else
            {
                *pdwBytes = 1024;       /* this is confirmed value */
            }
        }
        break;
 
    case 2: /* Copy an array of LOGFONTW */
        Size = Count * sizeof(LOGFONTW);
        if (*pdwBytes == 0)
        {
            *pdwBytes = Size;
            bSuccess = TRUE;
        }
        else if (pBuffer)
        {
            if (*pdwBytes >= Size)
            {
                pbBuffer = (LPBYTE)pBuffer;
                for (i = 0; i < Count; ++i)
                {
                    FamInfo[i].EnumLogFontEx.elfLogFont.lfWidth = 0;
                    RtlCopyMemory(pbBuffer, &FamInfo[i].EnumLogFontEx.elfLogFont, sizeof(LOGFONTW));
                    pbBuffer += sizeof(LOGFONTW);
                }
            }
            *pdwBytes = Size;
            bSuccess = TRUE;
        }
        else
        {
            *pdwBytes = 1024;       /* this is confirmed value */
        }
        break;
 
    case 3:
        Size = sizeof(DWORD);
        if (*pdwBytes == 0)
        {
            *pdwBytes = Size;
            bSuccess = TRUE;
        }
        else if (pBuffer)
        {
            if (*pdwBytes >= Size)
            {
                /* FIXME: What exactly is copied here? */
                *(DWORD*)pBuffer = 1;
            }
            *pdwBytes = Size;
            bSuccess = TRUE;
        }
        break;
 
    case 4:     /* full file path */
        if (FileName->Length >= 4 * sizeof(WCHAR))
        {
            /* The beginning of FileName is \??\ */
            LPWSTR pch = FileName->Buffer + 4;
            DWORD Length = FileName->Length - 4 * sizeof(WCHAR);
 
            Size = Length + sizeof(WCHAR);
            if (*pdwBytes == 0)
            {
                *pdwBytes = Size;
                bSuccess = TRUE;
            }
            else if (pBuffer)
            {
                if (*pdwBytes >= Size)
                {
                    RtlCopyMemory(pBuffer, pch, Size);
                }
                *pdwBytes = Size;
                bSuccess = TRUE;
            }
        }
        break;
 
    case 5: /* Looks like a BOOL that is copied, TRUE, if the font was not found */
        Size = sizeof(BOOL);
        if (*pdwBytes == 0)
        {
            *pdwBytes = Size;
            bSuccess = TRUE;
        }
        else if (pBuffer)
        {
            if (*pdwBytes >= Size)
            {
                *(BOOL*)pBuffer = Count == 0;
            }
            *pdwBytes = Size;
            bSuccess = TRUE;
        }
        break;
    }
    ExFreePoolWithTag(FamInfo, TAG_FINF);
 
    return bSuccess;
}

Referenced by NtGdiGetFontResourceInfoInternalW().

IntGdiLoadFontByIndexFromMemory()

static INT FASTCALL IntGdiLoadFontByIndexFromMemory ( PGDI_LOAD_FONT  pLoadFont, FT_Long  FontIndex  )

static

Definition at line 1922 of file freetype.c.

{
    FT_Error Error;
    FT_Face Face;
    FT_Long iFace, num_faces;
    PSHARED_FACE SharedFace;
    INT FaceCount = 0;
 
    IntLockFreeType();
 
    /* Load a face from memory */
    Error = FT_New_Memory_Face(g_FreeTypeLibrary,
                               pLoadFont->Memory->Buffer, pLoadFont->Memory->BufferSize,
                               ((FontIndex == -1) ? 0 : FontIndex), &Face);
    if (Error)
    {
        IntUnLockFreeType();
        if (Error == FT_Err_Unknown_File_Format)
            DPRINT1("Unknown font file format\n");
        else
            DPRINT1("Error reading font (error code: %d)\n", Error);
        return 0; /* Failure */
    }
 
    /*
     * When CharSetIndex == -1 in IntGdiLoadFontsFromMemory(),
     * we will always activate a charmap in the font face.
     *
     * Note from FreeType documentation:
     * https://freetype.org/freetype2/docs/reference/ft2-character_mapping.html#ft_charmap
     *
     * When a new face is created (either through FT_New_Face or
     * FT_Open_Face), the library looks for a Unicode charmap within
     * the list and automatically activates it. If there is no
     * Unicode charmap, FreeType doesn't set an 'active' charmap.
     */
    pick_charmap(Face, DEFAULT_CHARSET);
    if (!Face->charmap)
    {
        /* Fail font creation */
        FT_Done_Face(Face);
        IntUnLockFreeType();
        WARN("Could not find default charmap!\n");
        // Error = FT_Err_Invalid_CharMap_Handle;
        return 0; /* Failure */
    }
 
    pLoadFont->IsTrueType = FT_IS_SFNT(Face);
    num_faces = Face->num_faces;
    SharedFace = SharedFace_Create(Face, pLoadFont->Memory);
 
    IntUnLockFreeType();
 
    if (!SharedFace)
    {
        DPRINT1("SharedFace_Create failed\n");
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return 0; /* Failure */
    }
 
    if (FontIndex == -1)
    {
        for (iFace = 1; iFace < num_faces; ++iFace)
        {
            FaceCount += IntGdiLoadFontByIndexFromMemory(pLoadFont, iFace);
        }
        FontIndex = 0;
    }
 
    FaceCount += IntGdiLoadFontsFromMemory(pLoadFont, SharedFace, FontIndex, -1);
    return FaceCount;
}

Referenced by IntGdiAddFontMemResource(), IntGdiAddFontResourceSingle(), and IntGdiLoadFontByIndexFromMemory().

IntGdiLoadFontsFromMemory()

static INT FASTCALL IntGdiLoadFontsFromMemory ( PGDI_LOAD_FONT  pLoadFont, PSHARED_FACE  SharedFace, FT_Long  FontIndex, INT  CharSetIndex  )

static

Definition at line 1611 of file freetype.c.

{
    FT_Error            Error;
    PFONT_ENTRY         Entry;
    FONT_ENTRY_MEM*     PrivateEntry = NULL;
    FONTGDI *           FontGDI;
    NTSTATUS            Status;
    FT_Face             Face;
    ANSI_STRING         AnsiString;
    FT_WinFNT_HeaderRec WinFNT;
    INT                 FaceCount = 0, CharSetCount = 0;
    PUNICODE_STRING     pFileName       = pLoadFont->pFileName;
    DWORD               Characteristics = pLoadFont->Characteristics;
    PUNICODE_STRING     pValueName = &pLoadFont->RegValueName;
    TT_OS2 *            pOS2;
    INT                 BitIndex;
    FT_UShort           os2_version;
    FT_ULong            os2_ulCodePageRange1;
    FT_UShort           os2_usWeightClass;
 
    ASSERT(SharedFace != NULL);
    ASSERT(FontIndex != -1);
 
    IntLockFreeType();
    Face = SharedFace->Face;
    SharedFace_AddRef(SharedFace);
    IntUnLockFreeType();
 
    /* allocate a FONT_ENTRY */
    Entry = ExAllocatePoolWithTag(PagedPool, sizeof(FONT_ENTRY), TAG_FONT);
    if (!Entry)
    {
        SharedFace_Release(SharedFace, TRUE);
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return 0; /* failure */
    }
 
    /* allocate a FONTGDI */
    FontGDI = EngAllocMem(FL_ZERO_MEMORY, sizeof(FONTGDI), GDITAG_RFONT);
    if (!FontGDI)
    {
        ExFreePoolWithTag(Entry, TAG_FONT);
        SharedFace_Release(SharedFace, TRUE);
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return 0; /* failure */
    }
 
    /* set file name */
    if (pFileName)
    {
        FontGDI->Filename = ExAllocatePoolWithTag(PagedPool,
                                                  pFileName->Length + sizeof(UNICODE_NULL),
                                                  GDITAG_PFF);
        if (FontGDI->Filename == NULL)
        {
            EngFreeMem(FontGDI);
            ExFreePoolWithTag(Entry, TAG_FONT);
            SharedFace_Release(SharedFace, TRUE);
            EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return 0; /* failure */
        }
 
        RtlCopyMemory(FontGDI->Filename, pFileName->Buffer, pFileName->Length);
        FontGDI->Filename[pFileName->Length / sizeof(WCHAR)] = UNICODE_NULL;
    }
    else
    {
        FontGDI->Filename = NULL;
 
        PrivateEntry = ExAllocatePoolWithTag(PagedPool, sizeof(FONT_ENTRY_MEM), TAG_FONT);
        if (!PrivateEntry)
        {
            if (FontGDI->Filename)
                ExFreePoolWithTag(FontGDI->Filename, GDITAG_PFF);
            EngFreeMem(FontGDI);
            ExFreePoolWithTag(Entry, TAG_FONT);
            SharedFace_Release(SharedFace, TRUE);
            EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return 0; /* failure */
        }
 
        PrivateEntry->Entry = Entry;
        if (pLoadFont->PrivateEntry)
        {
            InsertTailList(&pLoadFont->PrivateEntry->ListEntry, &PrivateEntry->ListEntry);
        }
        else
        {
            InitializeListHead(&PrivateEntry->ListEntry);
            pLoadFont->PrivateEntry = PrivateEntry;
        }
    }
 
    /* set face */
    FontGDI->SharedFace = SharedFace;
    FontGDI->CharSet = ANSI_CHARSET;
    FontGDI->OriginalItalic = FALSE;
    FontGDI->RequestItalic = FALSE;
    FontGDI->OriginalWeight = FW_DONTCARE;
    FontGDI->RequestWeight = FW_NORMAL;
 
    IntLockFreeType();
    pOS2 = (TT_OS2 *)FT_Get_Sfnt_Table(Face, FT_SFNT_OS2);
    if (pOS2)
    {
        FontGDI->OriginalItalic = !!(pOS2->fsSelection & 0x1);
        FontGDI->OriginalWeight = pOS2->usWeightClass;
    }
    else
    {
        Error = FT_Get_WinFNT_Header(Face, &WinFNT);
        if (!Error)
        {
            FontGDI->OriginalItalic = !!WinFNT.italic;
            FontGDI->OriginalWeight = WinFNT.weight;
        }
    }
 
    os2_version = 0;
    if (pOS2)
    {
        os2_version = pOS2->version;
        os2_ulCodePageRange1 = pOS2->ulCodePageRange1;
        os2_usWeightClass = pOS2->usWeightClass;
    }
    IntUnLockFreeType();
 
    if (pOS2 && os2_version >= 1)
    {
        /* get charset and weight from OS/2 header */
 
        /* Make sure we do not use this pointer anymore */
        pOS2 = NULL;
 
        for (BitIndex = 0; BitIndex < MAXTCIINDEX; ++BitIndex)
        {
            if (os2_ulCodePageRange1 & (1 << BitIndex))
            {
                if (g_FontTci[BitIndex].ciCharset == DEFAULT_CHARSET)
                    continue;
 
                if ((CharSetIndex == -1 && CharSetCount == 0) ||
                    CharSetIndex == CharSetCount)
                {
                    FontGDI->CharSet = g_FontTci[BitIndex].ciCharset;
                }
 
                ++CharSetCount;
            }
        }
 
        /* set actual weight */
        FontGDI->OriginalWeight = os2_usWeightClass;
    }
    else
    {
        /* get charset from WinFNT header */
        IntLockFreeType();
        Error = FT_Get_WinFNT_Header(Face, &WinFNT);
        if (!Error)
        {
            FontGDI->CharSet = WinFNT.charset;
        }
        IntUnLockFreeType();
    }
 
    /*
     * If this is the first time the font face is loaded, activate a charmap in it.
     *
     * Note from FreeType documentation:
     * https://freetype.org/freetype2/docs/reference/ft2-character_mapping.html#ft_charmap
     *
     * When a new face is created (either through FT_New_Face or
     * FT_Open_Face), the library looks for a Unicode charmap within
     * the list and automatically activates it. If there is no
     * Unicode charmap, FreeType doesn't set an 'active' charmap.
     */
    if (CharSetIndex == -1)
    {
        IntLockFreeType();
        pick_charmap(Face, FontGDI->CharSet);
        IntUnLockFreeType();
        if (!Face->charmap)
        {
            /* Fail font creation */
            ERR("Could not find desired charmap!\n");
            Error = FT_Err_Invalid_CharMap_Handle;
            goto CleanupAndFail;
        }
    }
 
    RtlInitAnsiString(&AnsiString, Face->family_name);
    Status = RtlAnsiStringToUnicodeString(&Entry->FaceName, &AnsiString, TRUE);
    if (NT_SUCCESS(Status))
    {
        if (Face->style_name && Face->style_name[0] &&
            strcmp(Face->style_name, "Regular") != 0)
        {
            RtlInitAnsiString(&AnsiString, Face->style_name);
            Status = RtlAnsiStringToUnicodeString(&Entry->StyleName, &AnsiString, TRUE);
            if (!NT_SUCCESS(Status))
                RtlFreeUnicodeString(&Entry->FaceName);
        }
        else
        {
            RtlInitUnicodeString(&Entry->StyleName, NULL);
        }
    }
    if (!NT_SUCCESS(Status))
        goto CleanupAndFail;
 
    ++FaceCount;
    DPRINT("Font loaded: %s (%s)\n",
           Face->family_name ? Face->family_name : "<NULL>",
           Face->style_name ? Face->style_name : "<NULL>");
    DPRINT("Num glyphs: %d\n", Face->num_glyphs);
    DPRINT("CharSet: %d\n", FontGDI->CharSet);
 
    /* Add this font resource to the font table */
    Entry->Font = FontGDI;
    Entry->NotEnum = (Characteristics & FR_NOT_ENUM);
 
    IntLockFreeType();
    if (Characteristics & FR_PRIVATE)
    {
        /* private font */
        PPROCESSINFO Win32Process = PsGetCurrentProcessWin32Process();
        IntLockProcessPrivateFonts(Win32Process);
        InsertTailList(&Win32Process->PrivateFontListHead, &Entry->ListEntry);
        IntUnLockProcessPrivateFonts(Win32Process);
    }
    else
    {
        /* global font */
        InsertTailList(&g_FontListHead, &Entry->ListEntry);
    }
    IntUnLockFreeType();
 
    if (CharSetIndex == -1)
    {
        INT i;
        USHORT NameLength = Entry->FaceName.Length;
 
        if (Entry->StyleName.Length)
            NameLength += Entry->StyleName.Length + sizeof(WCHAR);
 
        if (pLoadFont->RegValueName.Length == 0)
        {
            pValueName->Length = 0;
            pValueName->MaximumLength = NameLength + sizeof(WCHAR);
            pValueName->Buffer = ExAllocatePoolWithTag(PagedPool,
                                                       pValueName->MaximumLength,
                                                       TAG_USTR);
            pValueName->Buffer[0] = UNICODE_NULL;
            RtlAppendUnicodeStringToString(pValueName, &Entry->FaceName);
        }
        else
        {
            UNICODE_STRING NewString;
            USHORT Length = pValueName->Length + 3 * sizeof(WCHAR) + NameLength;
            NewString.Length = 0;
            NewString.MaximumLength = Length + sizeof(WCHAR);
            NewString.Buffer = ExAllocatePoolWithTag(PagedPool,
                                                     NewString.MaximumLength,
                                                     TAG_USTR);
            NewString.Buffer[0] = UNICODE_NULL;
 
            RtlAppendUnicodeStringToString(&NewString, pValueName);
            RtlAppendUnicodeToString(&NewString, L" & ");
            RtlAppendUnicodeStringToString(&NewString, &Entry->FaceName);
 
            RtlFreeUnicodeString(pValueName);
            *pValueName = NewString;
        }
        if (Entry->StyleName.Length)
        {
            RtlAppendUnicodeToString(pValueName, L" ");
            RtlAppendUnicodeStringToString(pValueName, &Entry->StyleName);
        }
 
        for (i = 1; i < CharSetCount; ++i)
        {
            /* Do not count charsets as loaded 'faces' */
            IntGdiLoadFontsFromMemory(pLoadFont, SharedFace, FontIndex, i);
        }
    }
 
    return FaceCount; /* Number of loaded faces */
 
CleanupAndFail:
    if (PrivateEntry)
    {
        if (pLoadFont->PrivateEntry == PrivateEntry)
            pLoadFont->PrivateEntry = NULL;
        else
            RemoveEntryList(&PrivateEntry->ListEntry);
        ExFreePoolWithTag(PrivateEntry, TAG_FONT);
    }
    if (FontGDI)
    {
        if (FontGDI->Filename)
            ExFreePoolWithTag(FontGDI->Filename, GDITAG_PFF);
        EngFreeMem(FontGDI);
    }
    ExFreePoolWithTag(Entry, TAG_FONT);
    SharedFace_Release(SharedFace, TRUE);
    return 0;
}

Referenced by IntGdiLoadFontByIndexFromMemory(), and IntGdiLoadFontsFromMemory().

IntGdiRemoveFontMemResource()

BOOL FASTCALL IntGdiRemoveFontMemResource

(

HANDLE

hMMFont

)

Definition at line 2615 of file freetype.c.

{
    PLIST_ENTRY Entry;
    PFONT_ENTRY_COLL_MEM CurrentEntry;
    PFONT_ENTRY_COLL_MEM EntryCollection = NULL;
    PPROCESSINFO Win32Process = PsGetCurrentProcessWin32Process();
 
    IntLockFreeType();
    IntLockProcessPrivateFonts(Win32Process);
    for (Entry = Win32Process->PrivateMemFontListHead.Flink;
         Entry != &Win32Process->PrivateMemFontListHead;
         Entry = Entry->Flink)
    {
        CurrentEntry = CONTAINING_RECORD(Entry, FONT_ENTRY_COLL_MEM, ListEntry);
 
        if (CurrentEntry->Handle == hMMFont)
        {
            EntryCollection = CurrentEntry;
            UnlinkFontMemCollection(CurrentEntry);
            break;
        }
    }
    IntUnLockProcessPrivateFonts(Win32Process);
    IntUnLockFreeType();
 
    if (EntryCollection)
    {
        IntGdiCleanupMemEntry(EntryCollection->Entry);
        ExFreePoolWithTag(EntryCollection, TAG_FONT);
        return TRUE;
    }
    return FALSE;
}

Referenced by NtGdiRemoveFontMemResourceEx().

IntGdiRemoveFontResource()

BOOL FASTCALL IntGdiRemoveFontResource	(	_In_ PCUNICODE_STRING	FileName,
		_In_ DWORD	cFiles,
		_In_ DWORD	dwFlags
	)

Definition at line 2341 of file freetype.c.

{
    PWSTR pchFile = FileName->Buffer;
    SIZE_T cchFile;
 
    while (cFiles--)
    {
        _SEH2_TRY
        {
            cchFile = wcslen(pchFile);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            _SEH2_YIELD(return FALSE);
        }
        _SEH2_END;
 
        UNICODE_STRING ustrPathName;
        ustrPathName.Length = (USHORT)(cchFile * sizeof(WCHAR));
        ustrPathName.MaximumLength = ustrPathName.Length + sizeof(WCHAR);
        ustrPathName.Buffer = pchFile;
 
        BOOL ret = IntGdiRemoveFontResourceSingle(&ustrPathName, dwFlags);
        if (!ret)
            return FALSE;
 
        pchFile += cchFile + 1;
    }
 
    return TRUE;
}

Referenced by NtGdiRemoveFontResourceW().

IntGdiRemoveFontResourceSingle()

static BOOL FASTCALL IntGdiRemoveFontResourceSingle ( _In_ PCUNICODE_STRING  FileName, _In_ DWORD  dwFlags  )

static

Definition at line 2272 of file freetype.c.

{
    BOOL ret = FALSE;
    UNICODE_STRING PathName;
    PLIST_ENTRY CurrentEntry, NextEntry;
    PFONT_ENTRY FontEntry;
    PFONTGDI FontGDI;
    PWSTR pszBuffer, pszFileTitle;
    SIZE_T Length;
    NTSTATUS Status;
 
    /* Build PathName */
    if (dwFlags & AFRX_DOS_DEVICE_PATH)
    {
        Length = DosPathPrefix.Length + FileName->Length + sizeof(UNICODE_NULL);
        pszBuffer = ExAllocatePoolWithTag(PagedPool, Length, TAG_USTR);
        if (!pszBuffer)
            return FALSE; /* Failure */
 
        RtlInitEmptyUnicodeString(&PathName, pszBuffer, Length);
        RtlAppendUnicodeStringToString(&PathName, &DosPathPrefix);
        RtlAppendUnicodeStringToString(&PathName, FileName);
    }
    else
    {
        Status = IntDuplicateUnicodeString(FileName, &PathName);
        if (!NT_SUCCESS(Status))
            return FALSE; /* Failure */
    }
 
    pszFileTitle = PathName.Buffer;
    if (!(dwFlags & AFRX_ALTERNATIVE_PATH))
        pszFileTitle = PathFindFileNameW(PathName.Buffer);
 
    if (!pszFileTitle || !*pszFileTitle)
    {
        RtlFreeUnicodeString(&PathName);
        return FALSE; /* Failure */
    }
 
    /* Delete font entries that matches PathName */
    IntLockFreeType();
    for (CurrentEntry = g_FontListHead.Flink;
         CurrentEntry != &g_FontListHead;
         CurrentEntry = NextEntry)
    {
        FontEntry = CONTAINING_RECORD(CurrentEntry, FONT_ENTRY, ListEntry);
        NextEntry = CurrentEntry->Flink;
 
        FontGDI = FontEntry->Font;
        ASSERT(FontGDI);
        if (FontGDI->Filename && _wcsicmp(FontGDI->Filename, pszFileTitle) == 0)
        {
            RemoveEntryList(&FontEntry->ListEntry);
            CleanupFontEntry(FontEntry);
            if (dwFlags & AFRX_WRITE_REGISTRY)
                IntDeleteRegFontEntries(pszFileTitle, dwFlags);
            ret = TRUE;
        }
    }
    IntUnLockFreeType();
 
    RtlFreeUnicodeString(&PathName);
    return ret;
}

Referenced by IntGdiRemoveFontResource().

IntGetBitmapGlyphWithCache()

static FT_BitmapGlyph IntGetBitmapGlyphWithCache ( IN OUT PFONT_CACHE_ENTRY  Cache, IN FT_GlyphSlot  GlyphSlot  )

static

Definition at line 3818 of file freetype.c.

{
    FT_Glyph GlyphCopy;
    INT error;
    PFONT_CACHE_ENTRY NewEntry;
    FT_Bitmap AlignedBitmap;
    FT_BitmapGlyph BitmapGlyph;
 
    ASSERT_FREETYPE_LOCK_HELD();
 
    error = FT_Get_Glyph(GlyphSlot, &GlyphCopy);
    if (error)
    {
        DPRINT1("Failure caching glyph.\n");
        return NULL;
    };
 
    error = FT_Glyph_To_Bitmap(&GlyphCopy, Cache->Hashed.Aspect.RenderMode, 0, 1);
    if (error)
    {
        FT_Done_Glyph(GlyphCopy);
        DPRINT1("Failure rendering glyph.\n");
        return NULL;
    };
 
    NewEntry = ExAllocatePoolWithTag(PagedPool, sizeof(FONT_CACHE_ENTRY), TAG_FONT);
    if (!NewEntry)
    {
        DPRINT1("Alloc failure caching glyph.\n");
        FT_Done_Glyph(GlyphCopy);
        return NULL;
    }
 
    BitmapGlyph = (FT_BitmapGlyph)GlyphCopy;
    FT_Bitmap_New(&AlignedBitmap);
    if (FT_Bitmap_Convert_ReactOS_Hack(GlyphSlot->library, &BitmapGlyph->bitmap,
                                       &AlignedBitmap, 4, TRUE))
    {
        DPRINT1("Conversion failed\n");
        ExFreePoolWithTag(NewEntry, TAG_FONT);
        FT_Bitmap_Done(GlyphSlot->library, &AlignedBitmap);
        FT_Done_Glyph((FT_Glyph)BitmapGlyph);
        return NULL;
    }
 
    FT_Bitmap_Done(GlyphSlot->library, &BitmapGlyph->bitmap);
    BitmapGlyph->bitmap = AlignedBitmap;
 
    NewEntry->BitmapGlyph = BitmapGlyph;
    NewEntry->dwHash = Cache->dwHash;
    NewEntry->Hashed = Cache->Hashed;
 
    InsertHeadList(&g_FontCacheListHead, &NewEntry->ListEntry);
    if (++g_FontCacheNumEntries > MAX_FONT_CACHE)
    {
        NewEntry = CONTAINING_RECORD(g_FontCacheListHead.Blink, FONT_CACHE_ENTRY, ListEntry);
        RemoveCachedEntry(NewEntry);
    }
 
    return BitmapGlyph;
}

Referenced by IntGetRealGlyph().

IntGetCharSet()

UINT FASTCALL IntGetCharSet	(	INT	nIndex,
		FT_ULong	CodePageRange1
	)

Definition at line 1504 of file freetype.c.

{
    UINT BitIndex, CharSet;
    UINT nCount = 0;
 
    if (CodePageRange1 == 0)
        return (nIndex < 0) ? 1 : DEFAULT_CHARSET;
 
    for (BitIndex = 0; BitIndex < MAXTCIINDEX; ++BitIndex)
    {
        if (CodePageRange1 & (1 << BitIndex))
        {
            CharSet = g_FontTci[BitIndex].ciCharset;
            if ((nIndex >= 0) && (nCount == (UINT)nIndex))
            {
                return CharSet;
            }
            ++nCount;
        }
    }
 
    return (nIndex < 0) ? nCount : ANSI_CHARSET;
}

IntGetFontDefaultChar()

static BOOL IntGetFontDefaultChar ( _In_ FT_Face  Face, _Out_ PWCHAR  pDefChar  )

static

Definition at line 7561 of file freetype.c.

{
    TT_OS2 *pOS2;
    FT_WinFNT_HeaderRec WinFNT;
    FT_Error error;
 
    ASSERT_FREETYPE_LOCK_NOT_HELD();
 
    if (FT_IS_SFNT(Face)) // TrueType / OpenType
    {
        IntLockFreeType();
        pOS2 = FT_Get_Sfnt_Table(Face, FT_SFNT_OS2);
        if (pOS2)
            *pDefChar = pOS2->usDefaultChar;
        IntUnLockFreeType();
        return !!pOS2;
    }
 
    if (!FT_IS_SCALABLE(Face)) // *.fon / *.fnt
    {
        IntLockFreeType();
        error = FT_Get_WinFNT_Header(Face, &WinFNT);
        IntUnLockFreeType();
        if (!error)
            *pDefChar = WinFNT.default_char;
        return !error;
    }
 
    *pDefChar = 0; // .notdef
    return TRUE;
}

Referenced by GreGetGlyphIndicesW().

IntGetFontFamilyInfo()

LONG FASTCALL IntGetFontFamilyInfo	(	HDC	Dc,
		const LOGFONTW *	SafeLogFont,
		PFONTFAMILYINFO	SafeInfo,
		LONG	InfoCount
	)

Definition at line 6442 of file freetype.c.

{
    LONG AvailCount = 0;
    PPROCESSINFO Win32Process;
 
    /* Enumerate font families in the global list */
    IntLockFreeType();
    if (!GetFontFamilyInfoForList(SafeLogFont, SafeInfo, NULL, &AvailCount,
                                  InfoCount, &g_FontListHead))
    {
        IntUnLockFreeType();
        return -1;
    }
 
    /* Enumerate font families in the process local list */
    Win32Process = PsGetCurrentProcessWin32Process();
    IntLockProcessPrivateFonts(Win32Process);
    if (!GetFontFamilyInfoForList(SafeLogFont, SafeInfo, NULL, &AvailCount, InfoCount,
                                  &Win32Process->PrivateFontListHead))
    {
        IntUnLockProcessPrivateFonts(Win32Process);
        IntUnLockFreeType();
        return -1;
    }
    IntUnLockProcessPrivateFonts(Win32Process);
    IntUnLockFreeType();
 
    /* Enumerate font families in the registry */
    if (!GetFontFamilyInfoForSubstitutes(SafeLogFont, SafeInfo, &AvailCount, InfoCount))
    {
        return -1;
    }
 
    return AvailCount;
}

Referenced by NtGdiGetFontFamilyInfo().

IntGetFontLocalizedName()

static NTSTATUS IntGetFontLocalizedName ( PUNICODE_STRING  pNameW, PSHARED_FACE  SharedFace, FT_UShort  NameID, FT_UShort  LangID  )

static

Definition at line 3300 of file freetype.c.

{
    FT_SfntName Name;
    INT i, Count, BestIndex, Score, BestScore;
    FT_Error Error;
    NTSTATUS Status = STATUS_NOT_FOUND;
    ANSI_STRING AnsiName;
    PSHARED_FACE_CACHE Cache;
    FT_Face Face = SharedFace->Face;
 
    RtlFreeUnicodeString(pNameW);
 
    /* select cache */
    if (PRIMARYLANGID(LangID) == LANG_ENGLISH)
        Cache = &SharedFace->EnglishUS;
    else
        Cache = &SharedFace->UserLanguage;
 
    /* use cache if available */
    if (NameID == TT_NAME_ID_FONT_FAMILY && Cache->FontFamily.Buffer)
        return IntDuplicateUnicodeString(&Cache->FontFamily, pNameW);
    if (NameID == TT_NAME_ID_FULL_NAME && Cache->FullName.Buffer)
        return IntDuplicateUnicodeString(&Cache->FullName, pNameW);
 
    BestIndex = -1;
    BestScore = 0;
 
    Count = FT_Get_Sfnt_Name_Count(Face);
    for (i = 0; i < Count; ++i)
    {
        Error = FT_Get_Sfnt_Name(Face, i, &Name);
        if (Error)
            continue;   /* failure */
 
        if (Name.name_id != NameID)
            continue;   /* mismatched */
 
        if (Name.platform_id != TT_PLATFORM_MICROSOFT ||
            (Name.encoding_id != TT_MS_ID_UNICODE_CS &&
             Name.encoding_id != TT_MS_ID_SYMBOL_CS))
        {
            continue;   /* not Microsoft Unicode name */
        }
 
        if (Name.string == NULL || Name.string_len == 0 ||
            (Name.string[0] == 0 && Name.string[1] == 0))
        {
            continue;   /* invalid string */
        }
 
        if (Name.language_id == LangID)
        {
            Score = 30;
            BestIndex = i;
            break;      /* best match */
        }
        else if (PRIMARYLANGID(Name.language_id) == PRIMARYLANGID(LangID))
        {
            Score = 20;
        }
        else if (PRIMARYLANGID(Name.language_id) == LANG_ENGLISH)
        {
            Score = 10;
        }
        else
        {
            Score = 0;
        }
 
        if (Score > BestScore)
        {
            BestScore = Score;
            BestIndex = i;
        }
    }
 
    if (BestIndex >= 0)
    {
        /* store the best name */
        Error = (Score == 30) ? 0 : FT_Get_Sfnt_Name(Face, BestIndex, &Name);
        if (!Error)
        {
            /* NOTE: Name.string is not null-terminated */
            UNICODE_STRING Tmp;
            Tmp.Buffer = (PWCH)Name.string;
            Tmp.Length = Tmp.MaximumLength = Name.string_len;
 
            pNameW->Length = 0;
            pNameW->MaximumLength = Name.string_len + sizeof(WCHAR);
            pNameW->Buffer = ExAllocatePoolWithTag(PagedPool, pNameW->MaximumLength, TAG_USTR);
 
            if (pNameW->Buffer)
            {
                Status = RtlAppendUnicodeStringToString(pNameW, &Tmp);
                if (Status == STATUS_SUCCESS)
                {
                    /* Convert UTF-16 big endian to little endian */
                    IntSwapEndian(pNameW->Buffer, pNameW->Length);
                }
            }
            else
            {
                Status = STATUS_INSUFFICIENT_RESOURCES;
            }
        }
    }
 
    if (!NT_SUCCESS(Status))
    {
        /* defaulted */
        if (NameID == TT_NAME_ID_FONT_SUBFAMILY)
        {
            RtlInitAnsiString(&AnsiName, Face->style_name);
            Status = RtlAnsiStringToUnicodeString(pNameW, &AnsiName, TRUE);
        }
        else
        {
            RtlInitAnsiString(&AnsiName, Face->family_name);
            Status = RtlAnsiStringToUnicodeString(pNameW, &AnsiName, TRUE);
        }
    }
 
    if (NT_SUCCESS(Status))
    {
        /* make cache */
        if (NameID == TT_NAME_ID_FONT_FAMILY)
        {
            ASSERT_FREETYPE_LOCK_HELD();
            if (!Cache->FontFamily.Buffer)
                IntDuplicateUnicodeString(pNameW, &Cache->FontFamily);
        }
        else if (NameID == TT_NAME_ID_FULL_NAME)
        {
            ASSERT_FREETYPE_LOCK_HELD();
            if (!Cache->FullName.Buffer)
                IntDuplicateUnicodeString(pNameW, &Cache->FullName);
        }
    }
 
    return Status;
}

Referenced by IntInitFontNames(), MatchFontName(), and TextIntRealizeFont().

IntGetFontRenderMode()

FT_Render_Mode FASTCALL IntGetFontRenderMode

(

LOGFONTW *

logfont

)

Definition at line 2713 of file freetype.c.

{
    switch (logfont->lfQuality)
    {
    case ANTIALIASED_QUALITY:
        break;
    case NONANTIALIASED_QUALITY:
        return FT_RENDER_MODE_MONO;
    case DRAFT_QUALITY:
        return FT_RENDER_MODE_LIGHT;
    case CLEARTYPE_QUALITY:
        if (!gspv.bFontSmoothing)
            break;
        if (!gspv.uiFontSmoothingType)
            break;
        return FT_RENDER_MODE_LCD;
    }
    return FT_RENDER_MODE_NORMAL;
}

Referenced by IntExtTextOutW(), and TextIntGetTextExtentPoint().

IntGetFullFileName()

static BOOL FASTCALL IntGetFullFileName ( POBJECT_NAME_INFORMATION  NameInfo, ULONG  Size, PUNICODE_STRING  FileName  )

static

Definition at line 5913 of file freetype.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE hFile;
    IO_STATUS_BLOCK IoStatusBlock;
    ULONG Desired;
 
    InitializeObjectAttributes(&ObjectAttributes,
                               FileName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    Status = ZwOpenFile(
                 &hFile,
                 0, // FILE_READ_ATTRIBUTES,
                 &ObjectAttributes,
                 &IoStatusBlock,
                 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                 0);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("ZwOpenFile() failed (Status = 0x%lx)\n", Status);
        return FALSE;
    }
 
    Status = ZwQueryObject(hFile, ObjectNameInformation, NameInfo, Size, &Desired);
    ZwClose(hFile);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("ZwQueryObject() failed (Status = %lx)\n", Status);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by IntGdiGetFontResourceInfo().

IntGetHash()

static DWORD IntGetHash ( IN LPCVOID  pv, IN DWORD  cdw  )

static

Definition at line 3766 of file freetype.c.

{
    DWORD dwHash = cdw;
    const DWORD *pdw = pv;
 
    while (cdw-- > 0)
    {
        dwHash *= 3;
        dwHash ^= *pdw++;
    }
 
    return dwHash;
}

Referenced by IntGetRealGlyph().

IntGetOutlineTextMetrics()

INT FASTCALL IntGetOutlineTextMetrics	(	PFONTGDI	FontGDI,
		UINT	Size,
		OUTLINETEXTMETRICW *	Otm,
		BOOL	bLocked
	)

Definition at line 3140 of file freetype.c.

{
    TT_OS2 *pOS2;
    TT_HoriHeader *pHori;
    TT_Postscript *pPost;
    FT_Fixed XScale, YScale;
    FT_WinFNT_HeaderRec WinFNT;
    FT_Error Error;
    BYTE *pb;
    FONT_NAMES FontNames;
    PSHARED_FACE SharedFace = FontGDI->SharedFace;
    PSHARED_FACE_CACHE Cache;
    FT_Face Face = SharedFace->Face;
 
    if (bLocked)
        ASSERT_FREETYPE_LOCK_HELD();
    else
        ASSERT_FREETYPE_LOCK_NOT_HELD();
 
    if (PRIMARYLANGID(gusLanguageID) == LANG_ENGLISH)
    {
        Cache = &SharedFace->EnglishUS;
    }
    else
    {
        Cache = &SharedFace->UserLanguage;
    }
 
    if (Size == 0 && Cache->OutlineRequiredSize > 0)
    {
        ASSERT(Otm == NULL);
        return Cache->OutlineRequiredSize;
    }
 
    if (!bLocked)
        IntLockFreeType();
 
    IntInitFontNames(&FontNames, SharedFace);
    Cache->OutlineRequiredSize = FontNames.OtmSize;
 
    if (Size == 0)
    {
        ASSERT(Otm == NULL);
        IntFreeFontNames(&FontNames);
        if (!bLocked)
            IntUnLockFreeType();
        return Cache->OutlineRequiredSize;
    }
 
    ASSERT(Otm != NULL);
 
    if (Size < Cache->OutlineRequiredSize)
    {
        DPRINT1("Size %u < OutlineRequiredSize %u\n", Size,
                Cache->OutlineRequiredSize);
        IntFreeFontNames(&FontNames);
        if (!bLocked)
            IntUnLockFreeType();
        return 0;   /* failure */
    }
 
    XScale = Face->size->metrics.x_scale;
    YScale = Face->size->metrics.y_scale;
 
    pOS2 = FT_Get_Sfnt_Table(Face, FT_SFNT_OS2);
    pHori = FT_Get_Sfnt_Table(Face, FT_SFNT_HHEA);
    pPost = FT_Get_Sfnt_Table(Face, FT_SFNT_POST); /* We can live with this failing */
    Error = FT_Get_WinFNT_Header(Face, &WinFNT);
 
    if (pOS2 == NULL && Error)
    {
        if (!bLocked)
            IntUnLockFreeType();
        DPRINT1("Can't find OS/2 table - not TT font?\n");
        IntFreeFontNames(&FontNames);
        return 0;
    }
 
    if (pHori == NULL && Error)
    {
        if (!bLocked)
            IntUnLockFreeType();
        DPRINT1("Can't find HHEA table - not TT font?\n");
        IntFreeFontNames(&FontNames);
        return 0;
    }
 
    Otm->otmSize = Cache->OutlineRequiredSize;
 
    FillTM(&Otm->otmTextMetrics, FontGDI, pOS2, pHori, (Error ? NULL : &WinFNT));
 
    if (!pOS2)
        goto skip_os2;
 
    Otm->otmFiller = 0;
    RtlCopyMemory(&Otm->otmPanoseNumber, pOS2->panose, PANOSE_COUNT);
    Otm->otmfsSelection = pOS2->fsSelection;
    Otm->otmfsType = pOS2->fsType;
    Otm->otmsCharSlopeRise = pHori->caret_Slope_Rise;
    Otm->otmsCharSlopeRun = pHori->caret_Slope_Run;
    Otm->otmItalicAngle = 0; /* POST table */
    Otm->otmEMSquare = Face->units_per_EM;
 
#define SCALE_X(value)  ((FT_MulFix((value), XScale) + 32) >> 6)
#define SCALE_Y(value)  ((FT_MulFix((value), YScale) + 32) >> 6)
 
    Otm->otmAscent = SCALE_Y(pOS2->sTypoAscender);
    Otm->otmDescent = SCALE_Y(pOS2->sTypoDescender);
    Otm->otmLineGap = SCALE_Y(pOS2->sTypoLineGap);
    Otm->otmsCapEmHeight = SCALE_Y(pOS2->sCapHeight);
    Otm->otmsXHeight = SCALE_Y(pOS2->sxHeight);
    Otm->otmrcFontBox.left = SCALE_X(Face->bbox.xMin);
    Otm->otmrcFontBox.right = SCALE_X(Face->bbox.xMax);
    Otm->otmrcFontBox.top = SCALE_Y(Face->bbox.yMax);
    Otm->otmrcFontBox.bottom = SCALE_Y(Face->bbox.yMin);
    Otm->otmMacAscent = Otm->otmTextMetrics.tmAscent;
    Otm->otmMacDescent = -Otm->otmTextMetrics.tmDescent;
    Otm->otmMacLineGap = Otm->otmLineGap;
    Otm->otmusMinimumPPEM = 0; /* TT Header */
    Otm->otmptSubscriptSize.x = SCALE_X(pOS2->ySubscriptXSize);
    Otm->otmptSubscriptSize.y = SCALE_Y(pOS2->ySubscriptYSize);
    Otm->otmptSubscriptOffset.x = SCALE_X(pOS2->ySubscriptXOffset);
    Otm->otmptSubscriptOffset.y = SCALE_Y(pOS2->ySubscriptYOffset);
    Otm->otmptSuperscriptSize.x = SCALE_X(pOS2->ySuperscriptXSize);
    Otm->otmptSuperscriptSize.y = SCALE_Y(pOS2->ySuperscriptYSize);
    Otm->otmptSuperscriptOffset.x = SCALE_X(pOS2->ySuperscriptXOffset);
    Otm->otmptSuperscriptOffset.y = SCALE_Y(pOS2->ySuperscriptYOffset);
    Otm->otmsStrikeoutSize = SCALE_Y(pOS2->yStrikeoutSize);
    Otm->otmsStrikeoutPosition = SCALE_Y(pOS2->yStrikeoutPosition);
 
    if (!pPost)
    {
        Otm->otmsUnderscoreSize = 0;
        Otm->otmsUnderscorePosition = 0;
    }
    else
    {
        Otm->otmsUnderscoreSize = SCALE_Y(pPost->underlineThickness);
        Otm->otmsUnderscorePosition = SCALE_Y(pPost->underlinePosition);
    }
 
#undef SCALE_X
#undef SCALE_Y
 
skip_os2:
    if (!bLocked)
        IntUnLockFreeType();
 
    pb = IntStoreFontNames(&FontNames, Otm);
    ASSERT(pb - (BYTE*)Otm == Cache->OutlineRequiredSize);
 
    IntFreeFontNames(&FontNames);
 
    return Cache->OutlineRequiredSize;
}

Referenced by FindBestFontFromList(), FontFamilyFillInfo(), ftGdiGetGlyphOutline(), and NtGdiGetOutlineTextMetricsInternalW().

IntGetRealGlyph()

static FT_BitmapGlyph IntGetRealGlyph ( IN OUT PFONT_CACHE_ENTRY  Cache )

static

Definition at line 4929 of file freetype.c.

{
    INT error;
    FT_GlyphSlot glyph;
    FT_BitmapGlyph realglyph;
 
    ASSERT_FREETYPE_LOCK_HELD();
 
    Cache->dwHash = IntGetHash(&Cache->Hashed, sizeof(Cache->Hashed) / sizeof(DWORD));
 
    realglyph = IntFindGlyphCache(Cache);
    if (realglyph)
        return realglyph;
 
    error = FT_Load_Glyph(Cache->Hashed.Face, Cache->Hashed.GlyphIndex, FT_LOAD_DEFAULT);
    if (error)
    {
        DPRINT1("WARNING: Failed to load and render glyph! [index: %d]\n", Cache->Hashed.GlyphIndex);
        return NULL;
    }
 
    glyph = Cache->Hashed.Face->glyph;
 
    if (Cache->Hashed.Aspect.Emu.Bold)
        FT_GlyphSlot_Embolden(glyph); /* Emulate Bold */
 
    if (Cache->Hashed.Aspect.Emu.Italic)
        FT_GlyphSlot_Oblique(glyph); /* Emulate Italic */
 
    realglyph = IntGetBitmapGlyphWithCache(Cache, glyph);
 
    if (!realglyph)
        DPRINT1("Failed to render glyph! [index: %d]\n", Cache->Hashed.GlyphIndex);
 
    return realglyph;
}

Referenced by IntExtTextOutW(), IntGetTextDisposition(), and TextIntGetTextExtentPoint().

IntGetTextDisposition()

static BOOL IntGetTextDisposition ( _Out_ LONGLONG *  pX64, _Out_ LONGLONG *  pY64, _In_reads_(Count) PCWCH  String, _In_ INT  Count, _In_opt_ const INT *  Dx, _Inout_ PFONT_CACHE_ENTRY  Cache, _In_ UINT  fuOptions, _In_ BOOL  bNoTransform, _Inout_ PFONTLINK_CHAIN  pChain  )

static

Definition at line 6583 of file freetype.c.

{
    LONGLONG X64 = 0, Y64 = 0;
    INT i, glyph_index;
    FT_BitmapGlyph realglyph;
    FT_Face face = Cache->Hashed.Face;
    BOOL use_kerning = FT_HAS_KERNING(face);
    ULONG previous = 0;
    FT_Vector delta, vec;
    DWORD ch0, ch1;
 
    ASSERT_FREETYPE_LOCK_HELD();
 
    for (i = 0; i < Count; ++i)
    {
        ch0 = *String++;
        if (IS_HIGH_SURROGATE(ch0))
        {
            ++i;
            if (i >= Count)
                return TRUE;
 
            ch1 = *String++;
            if (IS_LOW_SURROGATE(ch1))
                ch0 = Utf32FromSurrogatePair(ch0, ch1);
        }
 
        glyph_index = FontLink_Chain_FindGlyph(pChain, Cache, &face, ch0,
                                               (fuOptions & ETO_GLYPH_INDEX));
        Cache->Hashed.GlyphIndex = glyph_index;
 
        realglyph = IntGetRealGlyph(Cache);
        if (!realglyph)
            return FALSE;
 
        /* Retrieve kerning distance */
        if (use_kerning && previous && glyph_index)
        {
            FT_Get_Kerning(face, previous, glyph_index, 0, &delta);
            X64 += delta.x;
            Y64 -= delta.y;
        }
 
        if (NULL == Dx)
        {
            X64 += realglyph->root.advance.x >> 10;
            Y64 -= realglyph->root.advance.y >> 10;
        }
        else if (fuOptions & ETO_PDY)
        {
            vec.x = (Dx[2 * i + 0] << 6);
            vec.y = (Dx[2 * i + 1] << 6);
            if (!bNoTransform)
                FT_Vector_Transform(&vec, &Cache->Hashed.matTransform);
            X64 += vec.x;
            Y64 -= vec.y;
        }
        else
        {
            vec.x = (Dx[i] << 6);
            vec.y = 0;
            if (!bNoTransform)
                FT_Vector_Transform(&vec, &Cache->Hashed.matTransform);
            X64 += vec.x;
            Y64 -= vec.y;
        }
 
        previous = glyph_index;
    }
 
    *pX64 = X64;
    *pY64 = Y64;
    return TRUE;
}

Referenced by IntExtTextOutW().

IntInitFontNames()

static __inline void FASTCALL IntInitFontNames ( FONT_NAMES *  Names, PSHARED_FACE  SharedFace  )

static

Definition at line 3067 of file freetype.c.

{
    ULONG OtmSize;
 
    RtlInitUnicodeString(&Names->FamilyNameW, NULL);
    RtlInitUnicodeString(&Names->FaceNameW, NULL);
    RtlInitUnicodeString(&Names->StyleNameW, NULL);
    RtlInitUnicodeString(&Names->FullNameW, NULL);
 
    /* family name */
    IntGetFontLocalizedName(&Names->FamilyNameW, SharedFace, TT_NAME_ID_FONT_FAMILY, gusLanguageID);
    /* face name */
    IntGetFontLocalizedName(&Names->FaceNameW, SharedFace, TT_NAME_ID_FULL_NAME, gusLanguageID);
    /* style name */
    IntGetFontLocalizedName(&Names->StyleNameW, SharedFace, TT_NAME_ID_FONT_SUBFAMILY, gusLanguageID);
    /* unique name (full name) */
    IntGetFontLocalizedName(&Names->FullNameW, SharedFace, TT_NAME_ID_UNIQUE_ID, gusLanguageID);
 
    /* Calculate the size of OUTLINETEXTMETRICW with extra data */
    OtmSize = sizeof(OUTLINETEXTMETRICW) +
              Names->FamilyNameW.Length + sizeof(UNICODE_NULL) +
              Names->FaceNameW.Length + sizeof(UNICODE_NULL) +
              Names->StyleNameW.Length + sizeof(UNICODE_NULL) +
              Names->FullNameW.Length + sizeof(UNICODE_NULL);
    Names->OtmSize = OtmSize;
}

Referenced by IntGetOutlineTextMetrics().

IntIsFontRenderingEnabled()

BOOL FASTCALL IntIsFontRenderingEnabled

(

VOID

)

Definition at line 2701 of file freetype.c.

{
    return (gpsi->BitsPixel > 8) && g_RenderingEnabled;
}

Referenced by IntExtTextOutW(), and TextIntGetTextExtentPoint().

IntLoadFontsInRegistry()

BOOL FASTCALL IntLoadFontsInRegistry

(

VOID

)

Definition at line 2377 of file freetype.c.

{
    NTSTATUS                        Status;
    HANDLE                          KeyHandle;
    OBJECT_ATTRIBUTES               ObjectAttributes;
    KEY_FULL_INFORMATION            KeyFullInfo;
    ULONG                           i, Length;
    UNICODE_STRING                  FontTitleW, FileNameW;
    SIZE_T                          InfoSize;
    LPBYTE                          InfoBuffer;
    PKEY_VALUE_FULL_INFORMATION     pInfo;
    LPWSTR                          pchPath;
    WCHAR                           szPath[MAX_PATH];
    INT                             nFontCount = 0;
    DWORD                           dwFlags;
 
    /* open registry key */
    InitializeObjectAttributes(&ObjectAttributes, &g_FontRegPath,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL, NULL);
    Status = ZwOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ZwOpenKey failed: 0x%08X\n", Status);
        return FALSE;   /* failure */
    }
 
    /* query count of values */
    Status = ZwQueryKey(KeyHandle, KeyFullInformation,
                        &KeyFullInfo, sizeof(KeyFullInfo), &Length);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ZwQueryKey failed: 0x%08X\n", Status);
        ZwClose(KeyHandle);
        return FALSE;   /* failure */
    }
 
    /* allocate buffer */
    InfoSize = (MAX_PATH + 256) * sizeof(WCHAR);
    InfoBuffer = ExAllocatePoolWithTag(PagedPool, InfoSize, TAG_FONT);
    if (!InfoBuffer)
    {
        DPRINT1("ExAllocatePoolWithTag failed\n");
        ZwClose(KeyHandle);
        return FALSE;
    }
 
    /* for each value */
    for (i = 0; i < KeyFullInfo.Values; ++i)
    {
        /* get value name */
        Status = ZwEnumerateValueKey(KeyHandle, i, KeyValueFullInformation,
                                     InfoBuffer, InfoSize, &Length);
        if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
        {
            /* too short buffer */
            ExFreePoolWithTag(InfoBuffer, TAG_FONT);
            InfoSize *= 2;
            InfoBuffer = ExAllocatePoolWithTag(PagedPool, InfoSize, TAG_FONT);
            if (!InfoBuffer)
            {
                DPRINT1("ExAllocatePoolWithTag failed\n");
                break;
            }
            /* try again */
            Status = ZwEnumerateValueKey(KeyHandle, i, KeyValueFullInformation,
                                         InfoBuffer, InfoSize, &Length);
        }
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("ZwEnumerateValueKey failed: 0x%08X\n", Status);
            break;      /* failure */
        }
 
        /* create FontTitleW string */
        pInfo = (PKEY_VALUE_FULL_INFORMATION)InfoBuffer;
        Length = pInfo->NameLength / sizeof(WCHAR);
        pInfo->Name[Length] = UNICODE_NULL;   /* truncate */
        if (!RtlCreateUnicodeString(&FontTitleW, pInfo->Name))
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            DPRINT1("RtlCreateUnicodeString failed\n");
            break;      /* failure */
        }
 
        /* query value */
        Status = ZwQueryValueKey(KeyHandle, &FontTitleW, KeyValueFullInformation,
                                 InfoBuffer, InfoSize, &Length);
        if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
        {
            /* too short buffer */
            ExFreePoolWithTag(InfoBuffer, TAG_FONT);
            InfoSize *= 2;
            InfoBuffer = ExAllocatePoolWithTag(PagedPool, InfoSize, TAG_FONT);
            if (!InfoBuffer)
            {
                DPRINT1("ExAllocatePoolWithTag failed\n");
                break;
            }
            /* try again */
            Status = ZwQueryValueKey(KeyHandle, &FontTitleW, KeyValueFullInformation,
                                     InfoBuffer, InfoSize, &Length);
        }
        pInfo = (PKEY_VALUE_FULL_INFORMATION)InfoBuffer;
        if (!NT_SUCCESS(Status) || !pInfo->DataLength)
        {
            DPRINT1("ZwQueryValueKey failed: 0x%08X\n", Status);
            RtlFreeUnicodeString(&FontTitleW);
            break;      /* failure */
        }
 
        /* Build pchPath */
        pchPath = (LPWSTR)((PUCHAR)pInfo + pInfo->DataOffset);
        Length = pInfo->DataLength / sizeof(WCHAR);
        pchPath[Length] = UNICODE_NULL; /* truncate */
 
        /* Load font(s) without writing registry */
        if (PathIsRelativeW(pchPath))
        {
            dwFlags = 0;
            Status = RtlStringCbPrintfW(szPath, sizeof(szPath),
                                        L"\\SystemRoot\\Fonts\\%s", pchPath);
        }
        else
        {
            dwFlags = AFRX_ALTERNATIVE_PATH | AFRX_DOS_DEVICE_PATH;
            Status = RtlStringCbCopyW(szPath, sizeof(szPath), pchPath);
        }
 
        if (NT_SUCCESS(Status))
        {
            RtlCreateUnicodeString(&FileNameW, szPath);
            nFontCount += IntGdiAddFontResourceEx(&FileNameW, 1, 0, dwFlags);
            RtlFreeUnicodeString(&FileNameW);
        }
 
        RtlFreeUnicodeString(&FontTitleW);
    }
 
    /* close now */
    ZwClose(KeyHandle);
 
    /* free memory block */
    if (InfoBuffer)
    {
        ExFreePoolWithTag(InfoBuffer, TAG_FONT);
    }
 
    return (KeyFullInfo.Values != 0 && nFontCount != 0);
}

Referenced by InitFontSupport().

IntLoadFontSubstList()

BOOL FASTCALL IntLoadFontSubstList

(

PLIST_ENTRY

pHead

)

Definition at line 729 of file freetype.c.

{
    NTSTATUS                        Status;
    HANDLE                          KeyHandle;
    OBJECT_ATTRIBUTES               ObjectAttributes;
    KEY_FULL_INFORMATION            KeyFullInfo;
    ULONG                           i, Length;
    UNICODE_STRING                  FromW, ToW;
    BYTE                            InfoBuffer[128];
    PKEY_VALUE_FULL_INFORMATION     pInfo;
    BYTE                            CharSets[FONTSUBST_FROM_AND_TO];
    LPWSTR                          pch;
    PFONTSUBST_ENTRY                pEntry;
 
    /* the FontSubstitutes registry key */
    static UNICODE_STRING FontSubstKey =
        RTL_CONSTANT_STRING(L"\\Registry\\Machine\\Software\\"
                            L"Microsoft\\Windows NT\\CurrentVersion\\"
                            L"FontSubstitutes");
 
    /* open registry key */
    InitializeObjectAttributes(&ObjectAttributes, &FontSubstKey,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL, NULL);
    Status = ZwOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("ZwOpenKey failed: 0x%08X\n", Status);
        return FALSE;   /* failure */
    }
 
    /* query count of values */
    Status = ZwQueryKey(KeyHandle, KeyFullInformation,
                        &KeyFullInfo, sizeof(KeyFullInfo), &Length);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("ZwQueryKey failed: 0x%08X\n", Status);
        ZwClose(KeyHandle);
        return FALSE;   /* failure */
    }
 
    /* for each value */
    for (i = 0; i < KeyFullInfo.Values; ++i)
    {
        /* get value name */
        Status = ZwEnumerateValueKey(KeyHandle, i, KeyValueFullInformation,
                                     InfoBuffer, sizeof(InfoBuffer), &Length);
        if (!NT_SUCCESS(Status))
        {
            DPRINT("ZwEnumerateValueKey failed: 0x%08X\n", Status);
            break;      /* failure */
        }
 
        /* create FromW string */
        pInfo = (PKEY_VALUE_FULL_INFORMATION)InfoBuffer;
        Length = pInfo->NameLength / sizeof(WCHAR);
        pInfo->Name[Length] = UNICODE_NULL;   /* truncate */
        if (!RtlCreateUnicodeString(&FromW, pInfo->Name))
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            DPRINT("RtlCreateUnicodeString failed\n");
            break;      /* failure */
        }
 
        /* query value */
        Status = ZwQueryValueKey(KeyHandle, &FromW, KeyValueFullInformation,
                                 InfoBuffer, sizeof(InfoBuffer), &Length);
        pInfo = (PKEY_VALUE_FULL_INFORMATION)InfoBuffer;
        if (!NT_SUCCESS(Status) || !pInfo->DataLength)
        {
            DPRINT("ZwQueryValueKey failed: 0x%08X\n", Status);
            RtlFreeUnicodeString(&FromW);
            break;      /* failure */
        }
 
        /* create ToW string */
        pch = (LPWSTR)((PUCHAR)pInfo + pInfo->DataOffset);
        Length = pInfo->DataLength / sizeof(WCHAR);
        pch[Length] = UNICODE_NULL; /* truncate */
        if (!RtlCreateUnicodeString(&ToW, pch))
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            DPRINT("RtlCreateUnicodeString failed\n");
            RtlFreeUnicodeString(&FromW);
            break;      /* failure */
        }
 
        /* does charset exist? (from) */
        CharSets[FONTSUBST_FROM] = DEFAULT_CHARSET;
        pch = wcsrchr(FromW.Buffer, L',');
        if (pch)
        {
            /* truncate */
            *pch = UNICODE_NULL;
            FromW.Length = (pch - FromW.Buffer) * sizeof(WCHAR);
            /* parse charset number */
            CharSets[FONTSUBST_FROM] = (BYTE)_wtoi(pch + 1);
        }
 
        /* does charset exist? (to) */
        CharSets[FONTSUBST_TO] = DEFAULT_CHARSET;
        pch = wcsrchr(ToW.Buffer, L',');
        if (pch)
        {
            /* truncate */
            *pch = UNICODE_NULL;
            ToW.Length = (pch - ToW.Buffer) * sizeof(WCHAR);
            /* parse charset number */
            CharSets[FONTSUBST_TO] = (BYTE)_wtoi(pch + 1);
        }
 
        /* is it identical? */
        if (RtlEqualUnicodeString(&FromW, &ToW, TRUE) &&
            CharSets[FONTSUBST_FROM] == CharSets[FONTSUBST_TO])
        {
            RtlFreeUnicodeString(&FromW);
            RtlFreeUnicodeString(&ToW);
            continue;
        }
 
        /* allocate an entry */
        pEntry = ExAllocatePoolWithTag(PagedPool, sizeof(FONTSUBST_ENTRY), TAG_FONT);
        if (pEntry == NULL)
        {
            DPRINT("ExAllocatePoolWithTag failed\n");
            RtlFreeUnicodeString(&FromW);
            RtlFreeUnicodeString(&ToW);
            break;      /* failure */
        }
 
        /* store to *pEntry */
        pEntry->FontNames[FONTSUBST_FROM] = FromW;
        pEntry->FontNames[FONTSUBST_TO] = ToW;
        pEntry->CharSets[FONTSUBST_FROM] = CharSets[FONTSUBST_FROM];
        pEntry->CharSets[FONTSUBST_TO] = CharSets[FONTSUBST_TO];
 
        /* insert pEntry to *pHead */
        InsertTailList(pHead, &pEntry->ListEntry);
    }
 
    /* close now */
    ZwClose(KeyHandle);
 
    return NT_SUCCESS(Status);
}

Referenced by InitFontSupport().

IntLoadSystemFonts()

VOID FASTCALL IntLoadSystemFonts

(

VOID

)

Definition at line 1378 of file freetype.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING Directory, FileName, TempString;
    IO_STATUS_BLOCK Iosb;
    HANDLE hDirectory;
    BYTE *DirInfoBuffer;
    PFILE_DIRECTORY_INFORMATION DirInfo;
    BOOLEAN bRestartScan = TRUE;
    NTSTATUS Status;
    INT i;
    static UNICODE_STRING SearchPatterns[] =
    {
        RTL_CONSTANT_STRING(L"*.ttf"),
        RTL_CONSTANT_STRING(L"*.ttc"),
        RTL_CONSTANT_STRING(L"*.otf"),
        RTL_CONSTANT_STRING(L"*.otc"),
        RTL_CONSTANT_STRING(L"*.fon"),
        RTL_CONSTANT_STRING(L"*.fnt")
    };
    static UNICODE_STRING IgnoreFiles[] =
    {
        RTL_CONSTANT_STRING(L"."),
        RTL_CONSTANT_STRING(L".."),
    };
 
    RtlInitUnicodeString(&Directory, L"\\SystemRoot\\Fonts\\");
 
    InitializeObjectAttributes(
        &ObjectAttributes,
        &Directory,
        OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
        NULL,
        NULL);
 
    Status = ZwOpenFile(
                 &hDirectory,
                 SYNCHRONIZE | FILE_LIST_DIRECTORY,
                 &ObjectAttributes,
                 &Iosb,
                 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                 FILE_SYNCHRONOUS_IO_NONALERT | FILE_DIRECTORY_FILE);
 
    if (NT_SUCCESS(Status))
    {
        for (i = 0; i < _countof(SearchPatterns); ++i)
        {
            DirInfoBuffer = ExAllocatePoolWithTag(PagedPool, 0x4000, TAG_FONT);
            if (DirInfoBuffer == NULL)
            {
                ZwClose(hDirectory);
                return;
            }
 
            FileName.Buffer = ExAllocatePoolWithTag(PagedPool, MAX_PATH * sizeof(WCHAR), TAG_FONT);
            if (FileName.Buffer == NULL)
            {
                ExFreePoolWithTag(DirInfoBuffer, TAG_FONT);
                ZwClose(hDirectory);
                return;
            }
            FileName.Length = 0;
            FileName.MaximumLength = MAX_PATH * sizeof(WCHAR);
 
            while (1)
            {
                Status = ZwQueryDirectoryFile(
                             hDirectory,
                             NULL,
                             NULL,
                             NULL,
                             &Iosb,
                             DirInfoBuffer,
                             0x4000,
                             FileDirectoryInformation,
                             FALSE,
                             &SearchPatterns[i],
                             bRestartScan);
 
                if (!NT_SUCCESS(Status) || Status == STATUS_NO_MORE_FILES)
                {
                    break;
                }
 
                DirInfo = (PFILE_DIRECTORY_INFORMATION)DirInfoBuffer;
                while (1)
                {
                    SIZE_T ign;
 
                    TempString.Buffer = DirInfo->FileName;
                    TempString.Length = TempString.MaximumLength = DirInfo->FileNameLength;
 
                    /* Should we ignore this file? */
                    for (ign = 0; ign < _countof(IgnoreFiles); ++ign)
                    {
                        /* Yes.. */
                        if (RtlEqualUnicodeString(IgnoreFiles + ign, &TempString, FALSE))
                            break;
                    }
 
                    /* If we tried all Ignore patterns and there was no match, try to create a font */
                    if (ign == _countof(IgnoreFiles))
                    {
                        RtlCopyUnicodeString(&FileName, &Directory);
                        RtlAppendUnicodeStringToString(&FileName, &TempString);
                        if (!IntGdiAddFontResourceEx(&FileName, 1, 0, AFRX_WRITE_REGISTRY))
                            DPRINT1("ERR: Failed to load %wZ\n", &FileName);
                    }
 
                    if (DirInfo->NextEntryOffset == 0)
                        break;
 
                    DirInfo = (PFILE_DIRECTORY_INFORMATION)((ULONG_PTR)DirInfo + DirInfo->NextEntryOffset);
                }
 
                bRestartScan = FALSE;
            }
 
            ExFreePoolWithTag(FileName.Buffer, TAG_FONT);
            ExFreePoolWithTag(DirInfoBuffer, TAG_FONT);
        }
        ZwClose(hDirectory);
    }
}

Referenced by InitFontSupport().

IntMatrixFromMx()

static VOID FASTCALL IntMatrixFromMx ( FT_Matrix *  pmat, const MATRIX *  pmx  )

static

Definition at line 1050 of file freetype.c.

{
    FLOATOBJ ef;
 
    /* Create a freetype matrix, by converting to 16.16 fixpoint format */
    ef = pmx->efM11;
    FLOATOBJ_MulLong(&ef, 0x00010000);
    pmat->xx = FLOATOBJ_GetLong(&ef);
 
    ef = pmx->efM21;
    FLOATOBJ_MulLong(&ef, 0x00010000);
    pmat->xy = -FLOATOBJ_GetLong(&ef); /* (*1) See below */
 
    ef = pmx->efM12;
    FLOATOBJ_MulLong(&ef, 0x00010000);
    pmat->yx = -FLOATOBJ_GetLong(&ef); /* (*1) See below */
 
    ef = pmx->efM22;
    FLOATOBJ_MulLong(&ef, 0x00010000);
    pmat->yy = FLOATOBJ_GetLong(&ef);
 
    // (*1): Y direction is mirrored as follows:
    //
    // [  M11  -M12 ]   [  X ]    [   M11*X + M12*Y  ]
    // [            ] * [    ] == [                  ]
    // [ -M21   M22 ]   [ -Y ]    [ -(M21*X + M22*Y) ].
}

Referenced by ftGdiGetGlyphOutline(), and IntExtTextOutW().

IntNeedRequestFontSize()

static BOOL IntNeedRequestFontSize ( PFONTLINK_CHAIN  pChain, FT_Face  face, PLIST_ENTRY  TargetEntry  )

static

Definition at line 4346 of file freetype.c.

{
    PLIST_ENTRY Entry, Head = &pChain->FontLinkList;
    PFONTLINK pFontLink;
 
    for (Entry = Head->Flink; Entry != Head; Entry = Entry->Flink)
    {
        pFontLink = CONTAINING_RECORD(Entry, FONTLINK, ListEntry);
        if (!FontLink_PrepareFontInfo(pFontLink))
            continue; // This link is not useful, check the next one
 
        if (pFontLink->SharedFace->Face == face || Entry == TargetEntry)
            return FALSE;
    }
 
    return TRUE;
}

Referenced by FontLink_Chain_FindGlyph().

IntRequestFontSize()

static FT_Error IntRequestFontSize ( _Inout_ PFONTGDI  FontGDI, _In_ LONG  lfWidth, _In_ LONG  lfHeight  )

static

Definition at line 4244 of file freetype.c.

{
    FT_Error Error;
    Error = IntRequestFontSizeEx(FontGDI->SharedFace->Face, lfWidth, lfHeight,
                                 &FontGDI->tmHeight, &FontGDI->tmAscent,
                                 &FontGDI->tmDescent, &FontGDI->tmInternalLeading,
                                 &FontGDI->lfHeight, &FontGDI->lfWidth);
    if (Error == FT_Err_Ok)
        FontGDI->Magic = FONTGDI_MAGIC;
    return Error;
}

Referenced by FindBestFontFromList(), and TextIntUpdateSize().

IntRequestFontSizeEx()

static FT_Error IntRequestFontSizeEx ( _In_ FT_Face  face, _In_ LONG  lfWidth, _In_ LONG  lfHeight, _Out_opt_ PLONG  ptmHeight, _Out_opt_ PLONG  ptmAscent, _Out_opt_ PLONG  ptmDescent, _Out_opt_ PLONG  ptmInternalLeading, _Out_opt_ PLONG  plfHeight, _Out_opt_ PLONG  plfWidth  )

static

Definition at line 4081 of file freetype.c.

{
    FT_Error error;
    FT_Size_RequestRec req;
    TT_OS2 *pOS2;
    TT_HoriHeader *pHori;
    FT_WinFNT_HeaderRec WinFNT;
    LONG Ascent, Descent, Sum, EmHeight;
    LONG tmHeight, tmAscent, tmDescent, tmInternalLeading;
 
    lfWidth = abs(lfWidth);
    if (lfHeight == 0)
    {
        if (lfWidth == 0)
        {
            DPRINT("lfHeight and lfWidth are zero.\n");
            lfHeight = -16;
        }
        else
        {
            lfHeight = lfWidth;
        }
    }
 
    if (lfHeight == -1)
        lfHeight = -2;
 
    ASSERT_FREETYPE_LOCK_HELD();
    pOS2 = (TT_OS2 *)FT_Get_Sfnt_Table(face, FT_SFNT_OS2);
    pHori = (TT_HoriHeader *)FT_Get_Sfnt_Table(face, FT_SFNT_HHEA);
 
    if (!pOS2 || !pHori)
    {
        error = FT_Get_WinFNT_Header(face, &WinFNT);
        if (error)
        {
            ERR("%s: Failed to request font size.\n", face->family_name);
            return error;
        }
 
        tmHeight = WinFNT.pixel_height;
        tmAscent = WinFNT.ascent;
        if (ptmHeight)
            *ptmHeight = tmHeight;
        if (ptmAscent)
            *ptmAscent = tmAscent;
        if (ptmDescent)
            *ptmDescent = tmHeight - tmAscent;
        if (ptmInternalLeading)
            *ptmInternalLeading = WinFNT.internal_leading;
        if (plfHeight)
            *plfHeight = lfHeight;
        if (plfWidth)
            *plfWidth = lfWidth;
        return FT_Err_Ok;
    }
 
    /*
     * NOTE: We cast TT_OS2.usWinAscent and TT_OS2.usWinDescent to signed FT_Short.
     * Why? See: https://learn.microsoft.com/en-us/typography/opentype/spec/os2#uswindescent
     *
     * > usWinDescent is "usually" a positive value ...
     *
     * We can read it as "not always". See CORE-14994.
     * See also: https://learn.microsoft.com/en-us/typography/opentype/spec/os2#fsselection
     */
#define FM_SEL_USE_TYPO_METRICS 0x80
    if (lfHeight > 0)
    {
        /* case (A): lfHeight is positive */
        Sum = (FT_Short)pOS2->usWinAscent + (FT_Short)pOS2->usWinDescent;
        if (Sum == 0 || (pOS2->fsSelection & FM_SEL_USE_TYPO_METRICS))
        {
            Ascent = pHori->Ascender;
            Descent = -pHori->Descender;
            Sum = Ascent + Descent;
        }
        else
        {
            Ascent = (FT_Short)pOS2->usWinAscent;
            Descent = (FT_Short)pOS2->usWinDescent;
        }
 
        tmAscent = FT_MulDiv(lfHeight, Ascent, Sum);
        tmDescent = FT_MulDiv(lfHeight, Descent, Sum);
        tmHeight = tmAscent + tmDescent;
        tmInternalLeading = tmHeight - FT_MulDiv(lfHeight, face->units_per_EM, Sum);
    }
    else if (lfHeight < 0)
    {
        /* case (B): lfHeight is negative */
        if (pOS2->fsSelection & FM_SEL_USE_TYPO_METRICS)
        {
            tmAscent = FT_MulDiv(-lfHeight, pHori->Ascender, face->units_per_EM);
            tmDescent = FT_MulDiv(-lfHeight, -pHori->Descender, face->units_per_EM);
        }
        else
        {
            tmAscent = FT_MulDiv(-lfHeight, (FT_Short)pOS2->usWinAscent, face->units_per_EM);
            tmDescent = FT_MulDiv(-lfHeight, (FT_Short)pOS2->usWinDescent, face->units_per_EM);
        }
        tmHeight = tmAscent + tmDescent;
        tmInternalLeading = tmHeight + lfHeight;
    }
#undef FM_SEL_USE_TYPO_METRICS
 
    EmHeight = tmHeight - tmInternalLeading;
    EmHeight = max(EmHeight, 1);
    EmHeight = min(EmHeight, USHORT_MAX);
 
#if 1
    /* I think this is wrong implementation but its test result is better. */
    if (lfWidth != 0)
        req.width = FT_MulDiv(lfWidth, face->units_per_EM, pOS2->xAvgCharWidth) << 6;
#else
    /* I think this is correct implementation but it is mismatching
     * to the other metric functions. The test result is bad. */
    if (lfWidth != 0)
        req.width = (FT_MulDiv(lfWidth, 96 * 5, 72 * 3) << 6); /* ??? FIXME */
#endif
    else
        req.width = 0;
 
    /* HACK: We do not handle small widths well, so just use zero for these. See CORE-19870. */
    if (lfWidth < 10)
        req.width = 0;
 
    req.type           = FT_SIZE_REQUEST_TYPE_NOMINAL;
    req.height         = (EmHeight << 6);
    req.horiResolution = 0;
    req.vertResolution = 0;
    error = FT_Request_Size(face, &req);
    if (error)
    {
        ERR("%s: Failed to request font size.\n", face->family_name);
        return error;
    }
 
    if (ptmHeight)
        *ptmHeight = tmHeight;
    if (ptmAscent)
        *ptmAscent = tmAscent;
    if (ptmDescent)
        *ptmDescent = tmDescent;
    if (ptmInternalLeading)
        *ptmInternalLeading = tmInternalLeading;
    if (plfHeight)
        *plfHeight = lfHeight;
    if (plfWidth)
        *plfWidth = lfWidth;
    return FT_Err_Ok;
}

Referenced by FontLink_Chain_FindGlyph(), and IntRequestFontSize().

IntStoreFontNames()

PBYTE FASTCALL IntStoreFontNames	(	_In_ const FONT_NAMES *	Names,
		_Out_ OUTLINETEXTMETRICW *	Otm
	)

Definition at line 3103 of file freetype.c.

{
    PBYTE pb = (PBYTE)Otm + sizeof(OUTLINETEXTMETRICW);
 
    /* family name */
    Otm->otmpFamilyName = (LPSTR)(pb - (BYTE*) Otm);
    pb += IntStoreName(&Names->FamilyNameW, pb);
 
    /* face name */
    Otm->otmpFaceName = (LPSTR)(pb - (BYTE*) Otm);
    pb += IntStoreName(&Names->FaceNameW, pb);
 
    /* style name */
    Otm->otmpStyleName = (LPSTR)(pb - (BYTE*) Otm);
    pb += IntStoreName(&Names->StyleNameW, pb);
 
    /* unique name (full name) */
    Otm->otmpFullName = (LPSTR)(pb - (BYTE*) Otm);
    pb += IntStoreName(&Names->FullNameW, pb);
 
    return pb;
}

Referenced by IntGetOutlineTextMetrics().

IntStoreName()

static SIZE_T FASTCALL IntStoreName ( _In_ const UNICODE_STRING *  pName, _Out_ PBYTE  pb  )

inlinestatic

Definition at line 3095 of file freetype.c.

{
    RtlCopyMemory(pb, pName->Buffer, pName->Length);
    *(WCHAR*)&pb[pName->Length] = UNICODE_NULL;
    return pName->Length + sizeof(UNICODE_NULL);
}

Referenced by IntStoreFontNames().

IntTranslateCharsetInfo()

static BOOLEAN IntTranslateCharsetInfo ( PDWORD  Src, LPCHARSETINFO  Cs, DWORD  Flags  )

static

Definition at line 2776 of file freetype.c.

{
    int Index = 0;
 
    switch (Flags)
    {
    case TCI_SRCFONTSIG:
        while (Index < MAXTCIINDEX && 0 == (*Src >> Index & 0x0001))
        {
            Index++;
        }
        break;
    case TCI_SRCCODEPAGE:
        while (Index < MAXTCIINDEX && *Src != g_FontTci[Index].ciACP)
        {
            Index++;
        }
        break;
    case TCI_SRCCHARSET:
        while (Index < MAXTCIINDEX && *Src != g_FontTci[Index].ciCharset)
        {
            Index++;
        }
        break;
    case TCI_SRCLOCALE:
        UNIMPLEMENTED;
        return FALSE;
    default:
        return FALSE;
    }
 
    if (Index >= MAXTCIINDEX || DEFAULT_CHARSET == g_FontTci[Index].ciCharset)
    {
        return FALSE;
    }
 
    RtlCopyMemory(Cs, &g_FontTci[Index], sizeof(CHARSETINFO));
 
    return TRUE;
}

Referenced by FontFamilyFillInfo(), and ftGdiGetTextCharsetInfo().

MatchFontName()

static BOOL MatchFontName ( PSHARED_FACE  SharedFace, PUNICODE_STRING  Name1, FT_UShort  NameID, FT_UShort  LangID  )

static

Definition at line 5862 of file freetype.c.

{
    NTSTATUS Status;
    UNICODE_STRING Name2;
 
    RtlInitUnicodeString(&Name2, NULL);
    Status = IntGetFontLocalizedName(&Name2, SharedFace, NameID, LangID);
 
    if (NT_SUCCESS(Status))
    {
        if (RtlCompareUnicodeString(Name1, &Name2, TRUE) == 0)
        {
            RtlFreeUnicodeString(&Name2);
            return TRUE;
        }
 
        RtlFreeUnicodeString(&Name2);
    }
 
    return FALSE;
}

Referenced by FontLink_PrepareFontInfo(), and MatchFontNames().

MatchFontNames()

static BOOL MatchFontNames ( PSHARED_FACE  SharedFace, LPCWSTR  lfFaceName  )

static

Definition at line 5885 of file freetype.c.

{
    UNICODE_STRING Name1;
 
    if (lfFaceName[0] == UNICODE_NULL)
        return FALSE;
 
    RtlInitUnicodeString(&Name1, lfFaceName);
 
    if (MatchFontName(SharedFace, &Name1, TT_NAME_ID_FONT_FAMILY, LANG_ENGLISH) ||
        MatchFontName(SharedFace, &Name1, TT_NAME_ID_FULL_NAME, LANG_ENGLISH))
    {
        return TRUE;
    }
    if (PRIMARYLANGID(gusLanguageID) != LANG_ENGLISH)
    {
        if (MatchFontName(SharedFace, &Name1, TT_NAME_ID_FONT_FAMILY, gusLanguageID) ||
            MatchFontName(SharedFace, &Name1, TT_NAME_ID_FULL_NAME, gusLanguageID))
        {
            return TRUE;
        }
    }
    return FALSE;
}

Referenced by TextIntRealizeFont().

NtGdiExtTextOutW()

BOOL APIENTRY NtGdiExtTextOutW	(	_In_ HDC	hDC,
		_In_ INT	XStart,
		_In_ INT	YStart,
		_In_ UINT	fuOptions,
		_In_opt_ LPCRECT	UnsafeRect,
		_In_reads_opt_(Count) PCWCH	UnsafeString,
		_In_range_(0, 0xFFFF) UINT	Count,
		_In_reads_opt_(_Inexpressible_(cwc)) const INT *	UnsafeDx,
		_In_ DWORD	dwCodePage
	)

Definition at line 7257 of file freetype.c.

{
    BOOL Result = FALSE;
    NTSTATUS Status = STATUS_SUCCESS;
    RECTL SafeRect;
    BYTE LocalBuffer[STACK_TEXT_BUFFER_SIZE];
    PVOID Buffer = LocalBuffer;
    LPCWSTR SafeString = NULL;
    PINT SafeDx = NULL;
    ULONG BufSize, StringSize, DxSize = 0;
 
    /* Check if String is valid */
    if ((Count > 0xFFFF) || (Count > 0 && UnsafeString == NULL))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (Count > 0)
    {
        /* Calculate buffer size for string and Dx values */
        BufSize = StringSize = Count * sizeof(WCHAR);
        if (UnsafeDx)
        {
            /* If ETO_PDY is specified, we have pairs of INTs */
            DxSize = (Count * sizeof(INT)) * ((fuOptions & ETO_PDY) ? 2 : 1);
            BufSize += DxSize;
        }
 
        /* Check if our local buffer is large enough */
        if (BufSize > sizeof(LocalBuffer))
        {
            /* It's not, allocate a temp buffer */
            Buffer = ExAllocatePoolWithTag(PagedPool, BufSize, GDITAG_TEXT);
            if (!Buffer)
            {
                return FALSE;
            }
        }
 
        /* Probe and copy user mode data to the buffer */
        _SEH2_TRY
        {
            /* Put the Dx before the String to assure alignment of 4 */
            SafeString = (LPCWSTR)(((ULONG_PTR)Buffer) + DxSize);
 
            /* Probe and copy the string */
            ProbeForRead(UnsafeString, StringSize, 1);
            RtlCopyMemory((PVOID)SafeString, UnsafeString, StringSize);
 
            /* If we have Dx values... */
            if (UnsafeDx)
            {
                /* ... probe and copy them */
                SafeDx = Buffer;
                ProbeForRead(UnsafeDx, DxSize, 1);
                RtlCopyMemory(SafeDx, UnsafeDx, DxSize);
            }
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END
        if (!NT_SUCCESS(Status))
        {
            goto cleanup;
        }
    }
 
    /* If we have a rect, copy it */
    if (UnsafeRect)
    {
        _SEH2_TRY
        {
            ProbeForRead(UnsafeRect, sizeof(RECT), 1);
            SafeRect = *UnsafeRect;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END
        if (!NT_SUCCESS(Status))
        {
            goto cleanup;
        }
    }
 
    /* Finally call the internal routine */
    Result = GreExtTextOutW(hDC,
                            XStart,
                            YStart,
                            fuOptions,
                            &SafeRect,
                            SafeString,
                            Count,
                            SafeDx,
                            dwCodePage);
 
cleanup:
    /* If we allocated a buffer, free it */
    if (Buffer != LocalBuffer)
    {
        ExFreePoolWithTag(Buffer, GDITAG_TEXT);
    }
 
    return Result;
}

NtGdiGetFontFamilyInfo()

LONG NTAPI NtGdiGetFontFamilyInfo	(	_In_ HDC	Dc,
		_In_ const LOGFONTW *	UnsafeLogFont,
		_Out_ PFONTFAMILYINFO	UnsafeInfo,
		_Inout_ PLONG	UnsafeInfoCount
	)

Definition at line 6482 of file freetype.c.

{
    NTSTATUS Status;
    LOGFONTW LogFont;
    PFONTFAMILYINFO Info;
    LONG GotCount, AvailCount, SafeInfoCount;
    ULONG DataSize;
 
    if (UnsafeLogFont == NULL || UnsafeInfo == NULL || UnsafeInfoCount == NULL)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return -1;
    }
 
    Status = MmCopyFromCaller(&SafeInfoCount, UnsafeInfoCount, sizeof(SafeInfoCount));
    if (!NT_SUCCESS(Status))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return -1;
    }
    GotCount = 0;
    Status = MmCopyToCaller(UnsafeInfoCount, &GotCount, sizeof(*UnsafeInfoCount));
    if (!NT_SUCCESS(Status))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return -1;
    }
    Status = MmCopyFromCaller(&LogFont, UnsafeLogFont, sizeof(LOGFONTW));
    if (!NT_SUCCESS(Status))
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return -1;
    }
    if (SafeInfoCount <= 0)
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return -1;
    }
 
    /* Allocate space for a safe copy */
    Status = RtlULongMult(SafeInfoCount, sizeof(FONTFAMILYINFO), &DataSize);
    if (!NT_SUCCESS(Status) || DataSize > LONG_MAX)
    {
        DPRINT1("Overflowed.\n");
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return -1;
    }
    Info = ExAllocatePoolWithTag(PagedPool, DataSize, GDITAG_TEXT);
    if (Info == NULL)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return -1;
    }
 
    /* Retrieve the information */
    AvailCount = IntGetFontFamilyInfo(Dc, &LogFont, Info, SafeInfoCount);
    GotCount = min(AvailCount, SafeInfoCount);
    SafeInfoCount = AvailCount;
 
    /* Return data to caller */
    if (GotCount > 0)
    {
        Status = RtlULongMult(GotCount, sizeof(FONTFAMILYINFO), &DataSize);
        if (!NT_SUCCESS(Status) || DataSize > LONG_MAX)
        {
            DPRINT1("Overflowed.\n");
            ExFreePoolWithTag(Info, GDITAG_TEXT);
            EngSetLastError(ERROR_INVALID_PARAMETER);
            return -1;
        }
        Status = MmCopyToCaller(UnsafeInfo, Info, DataSize);
        if (!NT_SUCCESS(Status))
        {
            ExFreePoolWithTag(Info, GDITAG_TEXT);
            EngSetLastError(ERROR_INVALID_PARAMETER);
            return -1;
        }
        Status = MmCopyToCaller(UnsafeInfoCount, &SafeInfoCount, sizeof(*UnsafeInfoCount));
        if (!NT_SUCCESS(Status))
        {
            ExFreePoolWithTag(Info, GDITAG_TEXT);
            EngSetLastError(ERROR_INVALID_PARAMETER);
            return -1;
        }
    }
 
    ExFreePoolWithTag(Info, GDITAG_TEXT);
 
    return GotCount;
}

Referenced by IntEnumFontFamilies().

pick_charmap()

static FT_Encoding pick_charmap ( FT_Face  face, int  charset  )

static

Definition at line 1587 of file freetype.c.

{
    static const FT_Encoding regular_order[] = { FT_ENCODING_UNICODE, FT_ENCODING_APPLE_ROMAN, FT_ENCODING_MS_SYMBOL, 0 };
    static const FT_Encoding symbol_order[]  = { FT_ENCODING_MS_SYMBOL, FT_ENCODING_UNICODE, FT_ENCODING_APPLE_ROMAN, 0 };
    const FT_Encoding *encs = regular_order;
 
    if (charset == SYMBOL_CHARSET) encs = symbol_order;
 
    while (*encs != 0)
    {
        if (select_charmap( face, *encs )) break;
        encs++;
    }
 
    if (!face->charmap && face->num_charmaps)
    {
        if (!FT_Set_Charmap(face, face->charmaps[0]))
            return face->charmap->encoding;
    }
 
    return *encs;
}

Referenced by IntGdiLoadFontByIndexFromMemory(), and IntGdiLoadFontsFromMemory().

RemoveCachedEntry()

static void RemoveCachedEntry ( PFONT_CACHE_ENTRY  Entry )

static

Definition at line 462 of file freetype.c.

{
    ASSERT_FREETYPE_LOCK_HELD();
 
    FT_Done_Glyph((FT_Glyph)Entry->BitmapGlyph);
    RemoveEntryList(&Entry->ListEntry);
    ExFreePoolWithTag(Entry, TAG_FONT);
    g_FontCacheNumEntries--;
    ASSERT(g_FontCacheNumEntries <= MAX_FONT_CACHE);
}

Referenced by FreeFontSupport(), IntGetBitmapGlyphWithCache(), and RemoveCacheEntries().

RemoveCacheEntries()

static void RemoveCacheEntries ( FT_Face  Face )

static

Definition at line 474 of file freetype.c.

{
    PLIST_ENTRY CurrentEntry, NextEntry;
    PFONT_CACHE_ENTRY FontEntry;
 
    ASSERT_FREETYPE_LOCK_HELD();
 
    for (CurrentEntry = g_FontCacheListHead.Flink;
         CurrentEntry != &g_FontCacheListHead;
         CurrentEntry = NextEntry)
    {
        FontEntry = CONTAINING_RECORD(CurrentEntry, FONT_CACHE_ENTRY, ListEntry);
        NextEntry = CurrentEntry->Flink;
 
        if (FontEntry->Hashed.Face == Face)
        {
            RemoveCachedEntry(FontEntry);
        }
    }
}

Referenced by SharedFace_Release().

RTL_STATIC_LIST_HEAD() [1/4]

static RTL_STATIC_LIST_HEAD ( g_FontCacheListHead  )

static

RTL_STATIC_LIST_HEAD() [2/4]

static RTL_STATIC_LIST_HEAD ( g_FontLinkEntries  )

static

RTL_STATIC_LIST_HEAD() [3/4]

static RTL_STATIC_LIST_HEAD ( g_FontListHead  )

static

RTL_STATIC_LIST_HEAD() [4/4]

static RTL_STATIC_LIST_HEAD ( g_FontSubstListHead  )

static

select_charmap()

static BOOL select_charmap ( FT_Face  ft_face, FT_Encoding  encoding  )

static

Definition at line 1529 of file freetype.c.

{
    FT_Error ft_err = FT_Err_Invalid_CharMap_Handle;
    FT_CharMap cmap0, cmap1, cmap2, cmap3, cmap_def;
    FT_Int i;
 
    cmap0 = cmap1 = cmap2 = cmap3 = cmap_def = NULL;
 
    for (i = 0; i < ft_face->num_charmaps; i++)
    {
        if (ft_face->charmaps[i]->encoding == encoding)
        {
            TRACE("found cmap with platform_id %u, encoding_id %u\n",
                   ft_face->charmaps[i]->platform_id, ft_face->charmaps[i]->encoding_id);
 
            switch (ft_face->charmaps[i]->platform_id)
            {
                default:
                    cmap_def = ft_face->charmaps[i];
                    break;
                case TT_PLATFORM_APPLE_UNICODE: // 0: /* Apple Unicode */
                    cmap0 = ft_face->charmaps[i];
                    break;
                case TT_PLATFORM_MACINTOSH:     // 1: /* Macintosh */
                    cmap1 = ft_face->charmaps[i];
                    break;
                case TT_PLATFORM_ISO:           // 2: /* ISO */
                    cmap2 = ft_face->charmaps[i];
                    break;
                case TT_PLATFORM_MICROSOFT:     // 3: /* Microsoft */
                    cmap3 = ft_face->charmaps[i];
                    break;
            }
        }
#ifdef __REACTOS__
// Wine bug: for each loop iteration, a FT_Set_Charmap() call is made.
// ReactOS fix: Instead, loop until we retrieve all the cmap pointers
// of interest, then do one single FT_Set_Charmap() call using the
// preferred cmap.
    }{
#endif
 
        if (cmap3) /* prefer Microsoft cmap table */
            ft_err = FT_Set_Charmap(ft_face, cmap3);
        else if (cmap1)
            ft_err = FT_Set_Charmap(ft_face, cmap1);
        else if (cmap2)
            ft_err = FT_Set_Charmap(ft_face, cmap2);
        else if (cmap0)
            ft_err = FT_Set_Charmap(ft_face, cmap0);
        else if (cmap_def)
            ft_err = FT_Set_Charmap(ft_face, cmap_def);
    }
 
    return ft_err == FT_Err_Ok;
}

Referenced by pick_charmap().

SharedFace_AddRef()

static void SharedFace_AddRef ( PSHARED_FACE  Ptr )

static

Definition at line 454 of file freetype.c.

{
    ASSERT_FREETYPE_LOCK_HELD();
 
    ++Ptr->RefCount;
}

Referenced by IntGdiLoadFontsFromMemory().

SharedFace_Create()

static PSHARED_FACE SharedFace_Create ( FT_Face  Face, PSHARED_MEM  Memory  )

static

Definition at line 419 of file freetype.c.

{
    PSHARED_FACE Ptr;
    Ptr = ExAllocatePoolWithTag(PagedPool, sizeof(SHARED_FACE), TAG_FONT);
    if (Ptr)
    {
        Ptr->Face = Face;
        Ptr->RefCount = 1;
        Ptr->Memory = Memory;
        SharedFaceCache_Init(&Ptr->EnglishUS);
        SharedFaceCache_Init(&Ptr->UserLanguage);
 
        SharedMem_AddRef(Memory);
        DPRINT("Creating SharedFace for %s\n", Face->family_name ? Face->family_name : "<NULL>");
    }
    return Ptr;
}

Referenced by IntGdiLoadFontByIndexFromMemory().

SharedFace_Release()

static void SharedFace_Release ( PSHARED_FACE  Ptr, BOOL  bDoLock  )

static

Definition at line 523 of file freetype.c.

{
    if (bDoLock)
        IntLockFreeType();
    else
        ASSERT_FREETYPE_LOCK_HELD();
 
    ASSERT(Ptr->RefCount > 0);
 
    if (Ptr->RefCount <= 0)
        return;
 
    --Ptr->RefCount;
    if (Ptr->RefCount == 0)
    {
        DPRINT("Releasing SharedFace for %s\n", Ptr->Face->family_name ? Ptr->Face->family_name : "<NULL>");
        RemoveCacheEntries(Ptr->Face);
        FT_Done_Face(Ptr->Face);
        SharedMem_Release(Ptr->Memory);
        SharedFaceCache_Release(&Ptr->EnglishUS);
        SharedFaceCache_Release(&Ptr->UserLanguage);
        ExFreePoolWithTag(Ptr, TAG_FONT);
    }
 
    if (bDoLock)
        IntUnLockFreeType();
}

Referenced by CleanupFontEntryEx(), and IntGdiLoadFontsFromMemory().

SharedFaceCache_Init()

static void SharedFaceCache_Init ( PSHARED_FACE_CACHE  Cache )

static

Definition at line 411 of file freetype.c.

{
    Cache->OutlineRequiredSize = 0;
    RtlInitUnicodeString(&Cache->FontFamily, NULL);
    RtlInitUnicodeString(&Cache->FullName, NULL);
}

Referenced by SharedFace_Create().

SharedFaceCache_Release()

static void SharedFaceCache_Release ( PSHARED_FACE_CACHE  Cache )

static

Definition at line 516 of file freetype.c.

{
    RtlFreeUnicodeString(&Cache->FontFamily);
    RtlFreeUnicodeString(&Cache->FullName);
}

Referenced by SharedFace_Release().

SharedMem_AddRef()

static void SharedMem_AddRef ( PSHARED_MEM  Ptr )

static

Definition at line 403 of file freetype.c.

{
    ASSERT_FREETYPE_LOCK_HELD();
 
    ++Ptr->RefCount;
}

Referenced by SharedFace_Create().

SharedMem_Create()

static PSHARED_MEM SharedMem_Create ( PBYTE  Buffer, ULONG  BufferSize, BOOL  IsMapping  )

static

Definition at line 438 of file freetype.c.

{
    PSHARED_MEM Ptr;
    Ptr = ExAllocatePoolWithTag(PagedPool, sizeof(SHARED_MEM), TAG_FONT);
    if (Ptr)
    {
        Ptr->Buffer = Buffer;
        Ptr->BufferSize = BufferSize;
        Ptr->RefCount = 1;
        Ptr->IsMapping = IsMapping;
        DPRINT("Creating SharedMem for %p (%i, %p)\n", Buffer, IsMapping, Ptr);
    }
    return Ptr;
}

Referenced by IntGdiAddFontMemResource(), and IntGdiAddFontResourceSingle().

SharedMem_Release()

static void SharedMem_Release ( PSHARED_MEM  Ptr )

static

Definition at line 495 of file freetype.c.

{
    ASSERT_FREETYPE_LOCK_HELD();
    ASSERT(Ptr->RefCount > 0);
 
    if (Ptr->RefCount <= 0)
        return;
 
    --Ptr->RefCount;
    if (Ptr->RefCount == 0)
    {
        DPRINT("Releasing SharedMem for %p (%i, %p)\n", Ptr->Buffer, Ptr->IsMapping, Ptr);
        if (Ptr->IsMapping)
            MmUnmapViewInSystemSpace(Ptr->Buffer);
        else
            ExFreePoolWithTag(Ptr->Buffer, TAG_FONT);
        ExFreePoolWithTag(Ptr, TAG_FONT);
    }
}

Referenced by IntGdiAddFontMemResource(), IntGdiAddFontResourceSingle(), and SharedFace_Release().

SubstituteFontByList()

static BOOL SubstituteFontByList ( PLIST_ENTRY  pHead, PUNICODE_STRING  pOutputName, PUNICODE_STRING  pInputName, BYTE  RequestedCharSet, BYTE  CharSetMap[FONTSUBST_FROM_AND_TO]  )

static

Definition at line 1079 of file freetype.c.

{
    PLIST_ENTRY         pListEntry;
    PFONTSUBST_ENTRY    pSubstEntry;
    BYTE                CharSets[FONTSUBST_FROM_AND_TO];
 
    CharSetMap[FONTSUBST_FROM] = DEFAULT_CHARSET;
    CharSetMap[FONTSUBST_TO] = RequestedCharSet;
 
    /* for each list entry */
    for (pListEntry = pHead->Flink;
         pListEntry != pHead;
         pListEntry = pListEntry->Flink)
    {
        pSubstEntry = CONTAINING_RECORD(pListEntry, FONTSUBST_ENTRY, ListEntry);
 
        CharSets[FONTSUBST_FROM] = pSubstEntry->CharSets[FONTSUBST_FROM];
 
        if (CharSets[FONTSUBST_FROM] != DEFAULT_CHARSET &&
            CharSets[FONTSUBST_FROM] != RequestedCharSet)
        {
            continue;   /* not matched */
        }
 
        /* does charset number exist? (to) */
        if (pSubstEntry->CharSets[FONTSUBST_TO] != DEFAULT_CHARSET)
        {
            CharSets[FONTSUBST_TO] = pSubstEntry->CharSets[FONTSUBST_TO];
        }
        else
        {
            CharSets[FONTSUBST_TO] = RequestedCharSet;
        }
 
        /* does font name match? */
        if (!RtlEqualUnicodeString(&pSubstEntry->FontNames[FONTSUBST_FROM],
                                   pInputName, TRUE))
        {
            continue;   /* not matched */
        }
 
        /* update *pOutputName */
        *pOutputName = pSubstEntry->FontNames[FONTSUBST_TO];
 
        if (CharSetMap[FONTSUBST_FROM] == DEFAULT_CHARSET)
        {
            /* update CharSetMap */
            CharSetMap[FONTSUBST_FROM]  = CharSets[FONTSUBST_FROM];
            CharSetMap[FONTSUBST_TO]    = CharSets[FONTSUBST_TO];
        }
        return TRUE;   /* success */
    }
 
    return FALSE;
}

Referenced by SubstituteFontRecurse().

SubstituteFontRecurse()

static BOOL SubstituteFontRecurse ( PLOGFONTW  pLogFont )

static

Definition at line 1140 of file freetype.c.

{
    UINT            RecurseCount = 5;
    UNICODE_STRING  OutputNameW = { 0 };
    BYTE            CharSetMap[FONTSUBST_FROM_AND_TO];
    BOOL            Found;
    UNICODE_STRING  InputNameW;
 
    if (pLogFont->lfFaceName[0] == UNICODE_NULL)
        return FALSE;
 
    RtlInitUnicodeString(&InputNameW, pLogFont->lfFaceName);
 
    while (RecurseCount-- > 0)
    {
        Found = SubstituteFontByList(&g_FontSubstListHead,
                                     &OutputNameW, &InputNameW,
                                     pLogFont->lfCharSet, CharSetMap);
        if (!Found)
            break;
 
        IntUnicodeStringToBuffer(pLogFont->lfFaceName, sizeof(pLogFont->lfFaceName), &OutputNameW);
        RtlInitUnicodeString(&InputNameW, pLogFont->lfFaceName);
 
        if (CharSetMap[FONTSUBST_FROM] == DEFAULT_CHARSET ||
            CharSetMap[FONTSUBST_FROM] == pLogFont->lfCharSet)
        {
            pLogFont->lfCharSet = CharSetMap[FONTSUBST_TO];
        }
    }
 
    return TRUE;    /* success */
}

Referenced by FontLink_Create(), FontLink_FindEntry(), GetFontFamilyInfoForSubstitutes(), and TextIntRealizeFont().

TextIntCreateFontIndirect()

NTSTATUS FASTCALL TextIntCreateFontIndirect	(	CONST LPLOGFONTW	lf,
		HFONT *	NewFont
	)

Definition at line 2734 of file freetype.c.

{
    PLFONT plfont;
    LOGFONTW *plf;
 
    ASSERT(lf);
    plfont = LFONT_AllocFontWithHandle();
    if (!plfont)
    {
        return STATUS_NO_MEMORY;
    }
 
    ExInitializePushLock(&plfont->lock);
    *NewFont = plfont->BaseObject.hHmgr;
    plf = &plfont->logfont.elfEnumLogfontEx.elfLogFont;
    RtlCopyMemory(plf, lf, sizeof(LOGFONTW));
    if (lf->lfEscapement != lf->lfOrientation)
    {
        /* This should really depend on whether GM_ADVANCED is set */
        plf->lfOrientation = plf->lfEscapement;
    }
    LFONT_UnlockFont(plfont);
 
    return STATUS_SUCCESS;
}

Referenced by CreateStockFonts(), and UserDrawCaptionText().

TextIntGetTextExtentPoint()

BOOL FASTCALL TextIntGetTextExtentPoint	(	_In_ PDC	dc,
		_In_ PTEXTOBJ	TextObj,
		_In_reads_(Count) PCWCH	String,
		_In_ INT	Count,
		_In_ ULONG	MaxExtent,
		_Out_ PINT	Fit,
		_Out_writes_to_opt_(Count, *Fit) PINT	Dx,
		_Out_ PSIZE	Size,
		_In_ FLONG	fl
	)

Definition at line 4969 of file freetype.c.

{
    PFONTGDI FontGDI;
    FT_BitmapGlyph realglyph;
    INT glyph_index, i, previous, nTenthsOfDegrees;
    ULONGLONG TotalWidth64 = 0;
    LOGFONTW *plf;
    BOOL use_kerning, bVerticalWriting;
    LONG ascender, descender;
    FONT_CACHE_ENTRY Cache;
    DWORD ch0, ch1;
    FONTLINK_CHAIN Chain;
 
    FontGDI = ObjToGDI(TextObj->Font, FONT);
 
    Cache.Hashed.Face = FontGDI->SharedFace->Face;
    if (NULL != Fit)
    {
        *Fit = 0;
    }
 
    plf = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
    Cache.Hashed.lfHeight = plf->lfHeight;
    Cache.Hashed.lfWidth = plf->lfWidth;
    Cache.Hashed.Aspect.Emu.Bold = EMUBOLD_NEEDED(FontGDI->OriginalWeight, plf->lfWeight);
    Cache.Hashed.Aspect.Emu.Italic = (plf->lfItalic && !FontGDI->OriginalItalic);
 
    // Check vertical writing (tategaki)
    nTenthsOfDegrees = IntNormalizeAngle(plf->lfEscapement - plf->lfOrientation);
    bVerticalWriting = ((nTenthsOfDegrees == 90 * 10) || (nTenthsOfDegrees == 270 * 10));
 
    if (IntIsFontRenderingEnabled())
        Cache.Hashed.Aspect.RenderMode = (BYTE)IntGetFontRenderMode(plf);
    else
        Cache.Hashed.Aspect.RenderMode = (BYTE)FT_RENDER_MODE_MONO;
 
    // NOTE: GetTextExtentPoint32 simply ignores lfEscapement and XFORM.
    IntLockFreeType();
    if (!TextIntUpdateSize(TextObj, FontGDI, FALSE))
    {
        IntUnLockFreeType();
        return FALSE;
    }
    Cache.Hashed.matTransform = identityMat;
    FT_Set_Transform(Cache.Hashed.Face, NULL, NULL);
 
    FontLink_Chain_Init(&Chain, TextObj, Cache.Hashed.Face);
 
    use_kerning = FT_HAS_KERNING(Cache.Hashed.Face);
    previous = 0;
 
    for (i = 0; i < Count; i++)
    {
        ch0 = *String++;
        if (IS_HIGH_SURROGATE(ch0))
        {
            ++i;
            if (i >= Count)
                break;
 
            ch1 = *String++;
            if (IS_LOW_SURROGATE(ch1))
                ch0 = Utf32FromSurrogatePair(ch0, ch1);
        }
 
        glyph_index = FontLink_Chain_FindGlyph(&Chain, &Cache, &Cache.Hashed.Face, ch0,
                                               (fl & GTEF_INDICES));
        Cache.Hashed.GlyphIndex = glyph_index;
 
        realglyph = IntGetRealGlyph(&Cache);
        if (!realglyph)
            break;
 
        /* Retrieve kerning distance */
        if (use_kerning && previous && glyph_index)
        {
            FT_Vector delta;
            FT_Get_Kerning(Cache.Hashed.Face, previous, glyph_index, 0, &delta);
            TotalWidth64 += delta.x;
        }
 
        TotalWidth64 += realglyph->root.advance.x >> 10;
 
        if (((TotalWidth64 + 32) >> 6) <= MaxExtent && NULL != Fit)
        {
            *Fit = i + 1;
        }
        if (NULL != Dx)
        {
            Dx[i] = (TotalWidth64 + 32) >> 6;
        }
 
        previous = glyph_index;
    }
    ASSERT(FontGDI->Magic == FONTGDI_MAGIC);
    ascender = FontGDI->tmAscent; /* Units above baseline */
    descender = FontGDI->tmDescent; /* Units below baseline */
    IntUnLockFreeType();
 
    if (bVerticalWriting)
    {
        Size->cx = ascender + descender;
        Size->cy = (TotalWidth64 + 32) >> 6;
    }
    else
    {
        Size->cx = (TotalWidth64 + 32) >> 6;
        Size->cy = ascender + descender;
    }
 
    return TRUE;
}

Referenced by GreGetTextExtentExW(), GreGetTextExtentW(), IntExtTextOutW(), IntGetCharDimensions(), and NtGdiGetTextExtentExW().

TextIntRealizeFont()

NTSTATUS FASTCALL TextIntRealizeFont	(	HFONT	FontHandle,
		PTEXTOBJ	pTextObj
	)

Definition at line 5990 of file freetype.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PTEXTOBJ TextObj;
    PPROCESSINFO Win32Process;
    ULONG MatchPenalty;
    LOGFONTW *pLogFont;
    LOGFONTW SubstitutedLogFont;
 
    ASSERT_FREETYPE_LOCK_NOT_HELD();
 
    if (!pTextObj)
    {
        TextObj = TEXTOBJ_LockText(FontHandle);
        if (NULL == TextObj)
        {
            return STATUS_INVALID_HANDLE;
        }
 
        if (TextObj->fl & TEXTOBJECT_INIT)
        {
            TEXTOBJ_UnlockText(TextObj);
            return STATUS_SUCCESS;
        }
    }
    else
    {
        TextObj = pTextObj;
    }
 
    pLogFont = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
 
    /* substitute */
    SubstitutedLogFont = *pLogFont;
    SubstituteFontRecurse(&SubstitutedLogFont);
    DPRINT("Font '%S,%u' is substituted by '%S,%u'.\n",
           pLogFont->lfFaceName, pLogFont->lfCharSet,
           SubstitutedLogFont.lfFaceName, SubstitutedLogFont.lfCharSet);
 
    MatchPenalty = 0xFFFFFFFF;
    TextObj->Font = NULL;
 
    Win32Process = PsGetCurrentProcessWin32Process();
 
    /* Search private fonts */
    IntLockFreeType();
    IntLockProcessPrivateFonts(Win32Process);
    FindBestFontFromList(&TextObj->Font, &MatchPenalty, &SubstitutedLogFont,
                         &Win32Process->PrivateFontListHead);
    IntUnLockProcessPrivateFonts(Win32Process);
 
    /* Search system fonts */
    FindBestFontFromList(&TextObj->Font, &MatchPenalty, &SubstitutedLogFont,
                         &g_FontListHead);
    IntUnLockFreeType();
 
    if (NULL == TextObj->Font)
    {
        DPRINT1("Request font %S not found, no fonts loaded at all\n",
                pLogFont->lfFaceName);
        Status = STATUS_NOT_FOUND;
    }
    else
    {
        UNICODE_STRING Name;
        PFONTGDI FontGdi = ObjToGDI(TextObj->Font, FONT);
        PSHARED_FACE SharedFace = FontGdi->SharedFace;
 
        TextObj->TextFace[0] = UNICODE_NULL;
        IntLockFreeType();
        if (MatchFontNames(SharedFace, SubstitutedLogFont.lfFaceName))
        {
            IntUnLockFreeType();
            RtlStringCchCopyW(TextObj->TextFace, _countof(TextObj->TextFace), pLogFont->lfFaceName);
        }
        else
        {
            RtlInitUnicodeString(&Name, NULL);
            Status = IntGetFontLocalizedName(&Name, SharedFace, TT_NAME_ID_FONT_FAMILY, gusLanguageID);
            IntUnLockFreeType();
            if (NT_SUCCESS(Status))
            {
                /* truncated copy */
                IntUnicodeStringToBuffer(TextObj->TextFace, sizeof(TextObj->TextFace), &Name);
                RtlFreeUnicodeString(&Name);
            }
        }
 
        // Need hdev, when freetype is loaded need to create DEVOBJ for
        // Consumer and Producer.
        TextObj->Font->iUniq = 1; // Now it can be cached.
        IntFontType(FontGdi);
        FontGdi->flType = TextObj->Font->flFontType;
        FontGdi->RequestUnderline = pLogFont->lfUnderline ? 0xFF : 0;
        FontGdi->RequestStrikeOut = pLogFont->lfStrikeOut ? 0xFF : 0;
        FontGdi->RequestItalic = pLogFont->lfItalic ? 0xFF : 0;
        if (pLogFont->lfWeight != FW_DONTCARE)
            FontGdi->RequestWeight = pLogFont->lfWeight;
        else
            FontGdi->RequestWeight = FW_NORMAL;
 
        TextObj->fl |= TEXTOBJECT_INIT;
        Status = STATUS_SUCCESS;
    }
 
    if (!pTextObj) TEXTOBJ_UnlockText(TextObj);
 
    ASSERT((NT_SUCCESS(Status) ^ (NULL == TextObj->Font)) != 0);
 
    return Status;
}

Referenced by DC_hSelectFont(), DC_InitHack(), FontGetObject(), and RealizeFontInit().

TextIntUpdateSize()

BOOL FASTCALL TextIntUpdateSize	(	_In_ PTEXTOBJ	TextObj,
		_In_ PFONTGDI	FontGDI,
		_In_ BOOL	bDoLock
	)

Definition at line 4261 of file freetype.c.

{
    PLOGFONTW plf = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
    FT_Face face = FontGDI->SharedFace->Face;
    FT_Error error;
 
    ASSERT(face->charmap);
 
    if (bDoLock)
        IntLockFreeType();
    else
        ASSERT_FREETYPE_LOCK_HELD();
 
    error = IntRequestFontSize(FontGDI, plf->lfWidth, plf->lfHeight);
 
    if (bDoLock)
        IntUnLockFreeType();
 
    if (error != FT_Err_Ok)
        DPRINT1("Error in setting pixel sizes: %d\n", error);
    return (error == FT_Err_Ok);
}

Referenced by ftGdiGetGlyphOutline(), ftGdiGetTextMetricsW(), GreGetCharABCWidthsW(), GreGetCharWidthW(), IntExtTextOutW(), NtGdiGetOutlineTextMetricsInternalW(), and TextIntGetTextExtentPoint().

UnlinkFontMemCollection()

static VOID FASTCALL UnlinkFontMemCollection ( PFONT_ENTRY_COLL_MEM  Collection )

static

Definition at line 2598 of file freetype.c.

{
    PFONT_ENTRY_MEM FontMemEntry = Collection->Entry;
    PLIST_ENTRY ListEntry;
    RemoveEntryList(&Collection->ListEntry);
 
    do {
        /* Also unlink the FONT_ENTRY stuff from the PrivateFontListHead */
        RemoveEntryList(&FontMemEntry->Entry->ListEntry);
 
        ListEntry = FontMemEntry->ListEntry.Flink;
        FontMemEntry = CONTAINING_RECORD(ListEntry, FONT_ENTRY_MEM, ListEntry);
 
    } while (FontMemEntry != Collection->Entry);
}

Referenced by IntGdiCleanupPrivateFontsForProcess(), and IntGdiRemoveFontMemResource().

Variable Documentation

DosPathPrefix

const UNICODE_STRING DosPathPrefix = RTL_CONSTANT_STRING(L"\\??\\")

static

Definition at line 1995 of file freetype.c.

Referenced by IntGdiAddFontResourceSingle(), and IntGdiRemoveFontResourceSingle().

g_ElfScripts

PWCHAR g_ElfScripts[32]

static

Initial value:

=   
{
    L"Western", 
    L"Central_European",
    L"Cyrillic",
    L"Greek",
    L"Turkish",
    L"Hebrew",
    L"Arabic",
    L"Baltic",
    L"Vietnamese", 
    NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
    L"Thai",
    L"Japanese",
    L"CHINESE_GB2312",
    L"Hangul",
    L"CHINESE_BIG5",
    L"Hangul(Johab)",
    NULL, NULL, 
    NULL, NULL, NULL, NULL, NULL, NULL, NULL,
    L"Symbol" 
}

Definition at line 242 of file freetype.c.

Referenced by FontFamilyFillInfo().

g_FontCacheNumEntries

UINT g_FontCacheNumEntries

static

Definition at line 240 of file freetype.c.

Referenced by InitFontSupport(), IntGetBitmapGlyphWithCache(), and RemoveCachedEntry().

g_FontRegPath

UNICODE_STRING g_FontRegPath

Initial value:

=
    RTL_CONSTANT_STRING(L"\\REGISTRY\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts")

Definition at line 209 of file freetype.c.

Referenced by IntDeleteRegFontEntries(), IntGdiAddFontResourceSingle(), and IntLoadFontsInRegistry().

g_FontTci

const CHARSETINFO g_FontTci[MAXTCIINDEX]

static

Definition at line 270 of file freetype.c.

Referenced by IntCharSetFromCodePage(), IntGdiLoadFontsFromMemory(), IntGetCharSet(), and IntTranslateCharsetInfo().

g_FreeTypeLibrary

FT_Library g_FreeTypeLibrary

Definition at line 206 of file freetype.c.

Referenced by FreeFontSupport(), ftGdiGetGlyphOutline(), InitFontSupport(), and IntGdiLoadFontByIndexFromMemory().

g_FreeTypeLock

PFAST_MUTEX g_FreeTypeLock

static

Definition at line 214 of file freetype.c.

Referenced by FreeFontSupport(), and InitFontSupport().

g_RenderingEnabled

BOOL g_RenderingEnabled = TRUE

static

Definition at line 217 of file freetype.c.

Referenced by IntEnableFontRendering(), and IntIsFontRenderingEnabled().

gmxWorldToDeviceDefault

const MATRIX gmxWorldToDeviceDefault

extern

Definition at line 20 of file dclife.c.

gmxWorldToPageDefault

const MATRIX gmxWorldToPageDefault

extern

Definition at line 36 of file dclife.c.

Referenced by DC_vInitDc().

identityMat

const FT_Matrix identityMat = {(1 << 16), 0, 0, (1 << 16)}

static

Definition at line 201 of file freetype.c.

Referenced by ftGdiGetGlyphOutline(), IntExtTextOutW(), and TextIntGetTextExtentPoint().

s_chFontLinkDefaultChar

DWORD s_chFontLinkDefaultChar = FONTLINK_DEFAULT_CHAR

static

Definition at line 61 of file freetype.c.

Referenced by FontLink_Chain_FindGlyph(), and FontLink_LoadSettings().

s_fFontLinkUseAnsi

BOOL s_fFontLinkUseAnsi = FALSE

static

Definition at line 64 of file freetype.c.

Referenced by FontLink_Chain_Populate(), and FontLink_LoadDefaultCharset().

s_fFontLinkUseOem

BOOL s_fFontLinkUseOem = FALSE

static

Definition at line 65 of file freetype.c.

Referenced by FontLink_Chain_Populate(), and FontLink_LoadDefaultCharset().

s_fFontLinkUseSymbol

BOOL s_fFontLinkUseSymbol = FALSE

static

Definition at line 66 of file freetype.c.

Referenced by FontLink_Chain_Populate(), and FontLink_LoadDefaultCharset().

s_szDefFontLinkFileName

WCHAR s_szDefFontLinkFileName[MAX_PATH] = L""

static

Definition at line 62 of file freetype.c.

Referenced by FontLink_Chain_Populate(), and FontLink_LoadDefaultFonts().

s_szDefFontLinkFontName

WCHAR s_szDefFontLinkFontName[MAX_PATH] = L""

static

Definition at line 63 of file freetype.c.

Referenced by FontLink_Chain_Populate(), and FontLink_LoadDefaultFonts().

s_szzDefFixedFontLink

const WCHAR s_szzDefFixedFontLink[]

static

Initial value:

=
    L"cour.ttf,Courier New\0"
    L"msgothic.ttc,MS Gothic\0"
    L"mingliu.ttc,MingLiU\0"
    L"simsun.ttc,NSimSun\0"
    L"gulim.ttc,GulimChe\0"
    L"\0"

Definition at line 1196 of file freetype.c.

Referenced by FontLink_Chain_FindEntry().

s_szzDefFontLink

const WCHAR s_szzDefFontLink[]

static

Initial value:

=
    L"tahoma.ttf,Tahoma\0"
    L"msgothic.ttc,MS UI Gothic\0"
    L"mingliu.ttc,PMingLiU\0"
    L"simsun.ttc,SimSun\0"
    L"gulim.ttc,Gulim\0"
    L"\0"

Definition at line 1188 of file freetype.c.

Referenced by FontLink_Chain_FindEntry().