text.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_STRGDI
struct	_LFONT

Macros
#define	TAG_FINF   'FNIF'
#define	TO_MEM_ALLOCATED   0x0001
#define	TO_ALL_PTRS_VALID   0x0002
#define	TO_VALID   0x0004
#define	TO_ESC_NOT_ORIENT   0x0008
#define	TO_PWSZ_ALLOCATED   0x0010
#define	TSIM_UNDERLINE1   0x0020
#define	TSIM_UNDERLINE2   0x0040
#define	TSIM_STRIKEOUT   0x0080
#define	TO_HIGHRESTEXT   0x0100
#define	TO_BITMAPS   0x0200
#define	TO_PARTITION_INIT   0x0400
#define	TO_ALLOC_FACENAME   0x0800
#define	TO_SYS_PARTITION   0x1000
#define	TEXTOBJECT_INIT   0x00010000
#define	LFONT_AllocFontWithHandle()   ((PLFONT)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_FONT, sizeof(TEXTOBJ)))
#define	LFONT_ShareLockFont(hfont)   (PLFONT)GDIOBJ_ReferenceObjectByHandle(hfont, GDIObjType_LFONT_TYPE)
#define	LFONT_ShareUnlockFont(plfnt)   GDIOBJ_vDereferenceObject((POBJ)plfnt)
#define	LFONT_UnlockFont(plfnt)   GDIOBJ_vUnlockObject((POBJ)plfnt)
#define	AFRX_WRITE_REGISTRY   0x1
#define	AFRX_ALTERNATIVE_PATH   0x2
#define	AFRX_DOS_DEVICE_PATH   0x4
#define	IntLockProcessPrivateFonts(W32Process)    ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&W32Process->PrivateFontListLock)
#define	IntUnLockProcessPrivateFonts(W32Process)    ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&W32Process->PrivateFontListLock)

Typedefs
typedef struct _STRGDI	STRGDI
typedef struct _STRGDI *	PSTRGDI
typedef struct _LFONT	TEXTOBJ
typedef struct _LFONT *	PTEXTOBJ
typedef struct _LFONT	LFONT
typedef struct _LFONT *	PLFONT

Functions
FORCEINLINE PTEXTOBJ	TEXTOBJ_LockText (HFONT hfont)
FORCEINLINE VOID	TEXTOBJ_UnlockText (PLFONT plfnt)
PTEXTOBJ FASTCALL	RealizeFontInit (HFONT)
NTSTATUS FASTCALL	TextIntRealizeFont (HFONT, PTEXTOBJ)
NTSTATUS FASTCALL	TextIntCreateFontIndirect (CONST LPLOGFONTW lf, HFONT *NewFont)
BYTE FASTCALL	IntCharSetFromCodePage (UINT uCodePage)
BOOL FASTCALL	InitFontSupport (VOID)
BOOL FASTCALL	IntIsFontRenderingEnabled (VOID)
VOID FASTCALL	IntEnableFontRendering (BOOL Enable)
ULONG FASTCALL	FontGetObject (PTEXTOBJ TextObj, ULONG Count, PVOID Buffer)
VOID FASTCALL	IntLoadSystemFonts (VOID)
BOOL FASTCALL	IntLoadFontsInRegistry (VOID)
VOID FASTCALL	IntGdiCleanupPrivateFontsForProcess (VOID)
INT FASTCALL	IntGdiAddFontResource (PUNICODE_STRING FileName, DWORD Characteristics)
INT FASTCALL	IntGdiAddFontResourceEx (PUNICODE_STRING FileName, DWORD Characteristics, DWORD dwFlags)
HANDLE FASTCALL	IntGdiAddFontMemResource (PVOID Buffer, DWORD dwSize, PDWORD pNumAdded)
BOOL FASTCALL	IntGdiRemoveFontMemResource (HANDLE hMMFont)
ULONG FASTCALL	ftGdiGetGlyphOutline (PDC, WCHAR, UINT, LPGLYPHMETRICS, ULONG, PVOID, LPMAT2, BOOL)
INT FASTCALL	IntGetOutlineTextMetrics (PFONTGDI, UINT, OUTLINETEXTMETRICW *)
BOOL FASTCALL	TextIntUpdateSize (PDC, PTEXTOBJ, PFONTGDI, BOOL)
BOOL FASTCALL	ftGdiGetRasterizerCaps (LPRASTERIZER_STATUS)
BOOL FASTCALL	TextIntGetTextExtentPoint (PDC, PTEXTOBJ, LPCWSTR, INT, ULONG, LPINT, LPINT, LPSIZE, FLONG)
BOOL FASTCALL	ftGdiGetTextMetricsW (HDC, PTMW_INTERNAL)
DWORD FASTCALL	IntGetFontLanguageInfo (PDC)
INT FASTCALL	ftGdiGetTextCharsetInfo (PDC, PFONTSIGNATURE, DWORD)
DWORD FASTCALL	ftGetFontUnicodeRanges (PFONTGDI, PGLYPHSET)
DWORD FASTCALL	ftGdiGetFontData (PFONTGDI, DWORD, DWORD, PVOID, DWORD)
BOOL FASTCALL	IntGdiGetFontResourceInfo (PUNICODE_STRING, PVOID, DWORD *, DWORD)
BOOL FASTCALL	ftGdiRealizationInfo (PFONTGDI, PREALIZATION_INFO)
DWORD FASTCALL	ftGdiGetKerningPairs (PFONTGDI, DWORD, LPKERNINGPAIR)
BOOL NTAPI	GreExtTextOutW (IN HDC, IN INT, IN INT, IN UINT, IN OPTIONAL RECTL *, IN LPCWSTR, IN INT, IN OPTIONAL LPINT, IN DWORD)
DWORD FASTCALL	IntGetCharDimensions (HDC, PTEXTMETRICW, PDWORD)
BOOL FASTCALL	GreGetTextExtentW (HDC, LPCWSTR, INT, LPSIZE, UINT)
BOOL FASTCALL	GreGetTextExtentExW (HDC, LPCWSTR, ULONG, ULONG, PULONG, PULONG, LPSIZE, FLONG)
BOOL FASTCALL	GreTextOutW (HDC, int, int, LPCWSTR, int)
HFONT FASTCALL	GreCreateFontIndirectW (LOGFONTW *)
BOOL WINAPI	GreGetTextMetricsW (_In_ HDC hdc, _Out_ LPTEXTMETRICW lptm)

Macro Definition Documentation

AFRX_ALTERNATIVE_PATH

#define AFRX_ALTERNATIVE_PATH   0x2

Definition at line 105 of file text.h.

AFRX_DOS_DEVICE_PATH

#define AFRX_DOS_DEVICE_PATH   0x4

Definition at line 106 of file text.h.

AFRX_WRITE_REGISTRY

#define AFRX_WRITE_REGISTRY   0x1

Definition at line 104 of file text.h.

IntLockProcessPrivateFonts

#define IntLockProcessPrivateFonts

(

W32Process

)

ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&W32Process->PrivateFontListLock)

Definition at line 147 of file text.h.

IntUnLockProcessPrivateFonts

#define IntUnLockProcessPrivateFonts

(

W32Process

)

ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(&W32Process->PrivateFontListLock)

Definition at line 150 of file text.h.

LFONT_AllocFontWithHandle

#define LFONT_AllocFontWithHandle

(

)

((PLFONT)GDIOBJ_AllocObjWithHandle(GDI_OBJECT_TYPE_FONT, sizeof(TEXTOBJ)))

Definition at line 76 of file text.h.

LFONT_ShareLockFont

#define LFONT_ShareLockFont

(

hfont

)

(PLFONT)GDIOBJ_ReferenceObjectByHandle(hfont, GDIObjType_LFONT_TYPE)

Definition at line 77 of file text.h.

LFONT_ShareUnlockFont

#define LFONT_ShareUnlockFont

(

plfnt

)

GDIOBJ_vDereferenceObject((POBJ)plfnt)

Definition at line 78 of file text.h.

LFONT_UnlockFont

#define LFONT_UnlockFont

(

plfnt

)

GDIOBJ_vUnlockObject((POBJ)plfnt)

Definition at line 79 of file text.h.

TAG_FINF

#define TAG_FINF   'FNIF'

Definition at line 3 of file text.h.

TEXTOBJECT_INIT

#define TEXTOBJECT_INIT   0x00010000

Definition at line 56 of file text.h.

TO_ALL_PTRS_VALID

#define TO_ALL_PTRS_VALID   0x0002

Definition at line 8 of file text.h.

TO_ALLOC_FACENAME

#define TO_ALLOC_FACENAME   0x0800

Definition at line 18 of file text.h.

TO_BITMAPS

#define TO_BITMAPS   0x0200

Definition at line 16 of file text.h.

TO_ESC_NOT_ORIENT

#define TO_ESC_NOT_ORIENT   0x0008

Definition at line 10 of file text.h.

TO_HIGHRESTEXT

#define TO_HIGHRESTEXT   0x0100

Definition at line 15 of file text.h.

TO_MEM_ALLOCATED

#define TO_MEM_ALLOCATED   0x0001

Definition at line 7 of file text.h.

TO_PARTITION_INIT

#define TO_PARTITION_INIT   0x0400

Definition at line 17 of file text.h.

TO_PWSZ_ALLOCATED

#define TO_PWSZ_ALLOCATED   0x0010

Definition at line 11 of file text.h.

TO_SYS_PARTITION

#define TO_SYS_PARTITION   0x1000

Definition at line 19 of file text.h.

TO_VALID

#define TO_VALID   0x0004

Definition at line 9 of file text.h.

TSIM_STRIKEOUT

#define TSIM_STRIKEOUT   0x0080

Definition at line 14 of file text.h.

TSIM_UNDERLINE1

#define TSIM_UNDERLINE1   0x0020

Definition at line 12 of file text.h.

TSIM_UNDERLINE2

#define TSIM_UNDERLINE2   0x0040

Definition at line 13 of file text.h.

Typedef Documentation

LFONT

typedef struct _LFONT LFONT

PLFONT

typedef struct _LFONT * PLFONT

PSTRGDI

typedef struct _STRGDI * PSTRGDI

PTEXTOBJ

typedef struct _LFONT * PTEXTOBJ

STRGDI

typedef struct _STRGDI STRGDI

TEXTOBJ

typedef struct _LFONT TEXTOBJ

Function Documentation

FontGetObject()

ULONG FASTCALL FontGetObject	(	PTEXTOBJ	TextObj,
		ULONG	Count,
		PVOID	Buffer
	)

Definition at line 293 of file font.c.

{
    ULONG cjMaxSize;
    ENUMLOGFONTEXDVW *plf;
 
    ASSERT(plfont);
    plf = &plfont->logfont;
 
    if (!(plfont->fl & TEXTOBJECT_INIT))
    {
        NTSTATUS Status;
        DPRINT("FontGetObject font not initialized!\n");
 
        Status = TextIntRealizeFont(plfont->BaseObject.hHmgr, plfont);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("FontGetObject(TextIntRealizeFont) Status = 0x%lx\n", Status);
        }
    }
 
    /* If buffer is NULL, only the size is requested */
    if (pvBuffer == NULL) return sizeof(LOGFONTW);
 
    /* Calculate the maximum size according to number of axes */
    cjMaxSize = FIELD_OFFSET(ENUMLOGFONTEXDVW,
                    elfDesignVector.dvValues[plf->elfDesignVector.dvNumAxes]);
 
    if (cjBuffer > cjMaxSize) cjBuffer = cjMaxSize;
 
    RtlCopyMemory(pvBuffer, plf, cjBuffer);
 
    return cjBuffer;
}

Referenced by GreGetObject().

ftGdiGetFontData()

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

Definition at line 4658 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,
		LPMAT2	pmat2,
		BOOL	bIgnoreRotation
	)

Definition at line 3729 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;
 
    Size = IntGetOutlineTextMetrics(FontGDI, 0, NULL);
    potm = ExAllocatePoolWithTag(PagedPool, Size, GDITAG_TEXT);
    if (!potm)
    {
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
        TEXTOBJ_UnlockText(TextObj);
        return GDI_ERROR;
    }
    Size = IntGetOutlineTextMetrics(FontGDI, Size, potm);
    if (!Size)
    {
        /* FIXME: last error? */
        ExFreePoolWithTag(potm, GDITAG_TEXT);
        TEXTOBJ_UnlockText(TextObj);
        return GDI_ERROR;
    }
 
    IntLockFreeType();
    TextIntUpdateSize(dc, TextObj, FontGDI, FALSE);
    IntMatrixFromMx(&mat, DC_pmxWorldToDevice(dc));
    FT_Set_Transform(ft_face, &mat, NULL);
 
    TEXTOBJ_UnlockText(TextObj);
 
    glyph_index = get_glyph_index_flagged(ft_face, wch, GGO_GLYPH_INDEX, iFormat);
    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);
    if (error)
    {
        DPRINT1("WARNING: Failed to load and render glyph! [index: %u]\n", glyph_index);
        IntUnLockFreeType();
        if (potm) ExFreePoolWithTag(potm, GDITAG_TEXT);
        return GDI_ERROR;
    }
    IntUnLockFreeType();
 
    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 5673 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 3079 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,
		PFONTSIGNATURE	lpSig,
		DWORD	dwFlags
	)

Definition at line 4374 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 4561 of file freetype.c.

{
    PDC dc;
    PDC_ATTR pdcattr;
    PTEXTOBJ TextObj;
    PFONTGDI FontGDI;
    FT_Face Face;
    TT_OS2 *pOS2;
    TT_HoriHeader *pHori;
    FT_WinFNT_HeaderRec Win;
    ULONG Error;
    NTSTATUS Status = STATUS_SUCCESS;
    LOGFONTW *plf;
 
    if (!ptmwi)
    {
        EngSetLastError(STATUS_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)
    {
        plf = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
        FontGDI = ObjToGDI(TextObj->Font, FONT);
 
        Face = FontGDI->SharedFace->Face;
 
        // NOTE: GetTextMetrics simply ignores lfEscapement and XFORM.
        IntLockFreeType();
        Error = IntRequestFontSize(dc, FontGDI, plf->lfWidth, plf->lfHeight);
        FT_Set_Transform(Face, NULL, NULL);
 
        IntUnLockFreeType();
 
        if (0 != Error)
        {
            DPRINT1("Error in setting pixel sizes: %u\n", Error);
            Status = STATUS_UNSUCCESSFUL;
        }
        else
        {
            Status = STATUS_SUCCESS;
 
            IntLockFreeType();
            pOS2 = FT_Get_Sfnt_Table(Face, ft_sfnt_os2);
            if (NULL == pOS2)
            {
                DPRINT1("Can't find OS/2 table - not TT font?\n");
                Status = STATUS_INTERNAL_ERROR;
            }
 
            pHori = FT_Get_Sfnt_Table(Face, ft_sfnt_hhea);
            if (NULL == pHori)
            {
                DPRINT1("Can't find HHEA table - not TT font?\n");
                Status = STATUS_INTERNAL_ERROR;
            }
 
            Error = FT_Get_WinFNT_Header(Face, &Win);
 
            if (NT_SUCCESS(Status) || !Error)
            {
                FillTM(&ptmwi->TextMetric, FontGDI, pOS2, pHori, !Error ? &Win : 0);
 
                /* 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 5654 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 4487 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;
    }
 
    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) return 0;
 
        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");
                return 0;
            }
            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;
    }
    return size;
}

Referenced by NtGdiGetFontUnicodeRanges().

GreCreateFontIndirectW()

HFONT FASTCALL GreCreateFontIndirectW

(

LOGFONTW *

lplf

)

Internal

Definition at line 23 of file font.c.

{
    if (lplf)
    {
        ENUMLOGFONTEXDVW Logfont;
 
        RtlCopyMemory( &Logfont.elfEnumLogfontEx.elfLogFont, lplf, sizeof(LOGFONTW));
        RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfFullName,
                       sizeof(Logfont.elfEnumLogfontEx.elfFullName));
        RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfStyle,
                       sizeof(Logfont.elfEnumLogfontEx.elfStyle));
        RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfScript,
                       sizeof(Logfont.elfEnumLogfontEx.elfScript));
 
        Logfont.elfDesignVector.dvNumAxes = 0;
 
        RtlZeroMemory( &Logfont.elfDesignVector, sizeof(DESIGNVECTOR));
 
        return HfontCreate((PENUMLOGFONTEXDVW)&Logfont, 0, 0, 0, NULL );
    }
    else return NULL;
}

Referenced by IntPaintDesktop(), MENU_DrawPopupGlyph(), MenuInit(), UITOOLS95_DFC_ButtonCheckRadio(), UITOOLS95_DrawFrameCaption(), UITOOLS95_DrawFrameMenu(), and UITOOLS95_DrawFrameScroll().

GreExtTextOutW()

BOOL NTAPI GreExtTextOutW	(	IN	HDC,
		IN	INT,
		IN	INT,
		IN	UINT,
		IN OPTIONAL RECTL *	,
		IN	LPCWSTR,
		IN	INT,
		IN OPTIONAL	LPINT,
		IN	DWORD
	)

GreGetTextExtentExW()

BOOL FASTCALL GreGetTextExtentExW	(	HDC	hDC,
		LPCWSTR	String,
		ULONG	Count,
		ULONG	MaxExtent,
		PULONG	Fit,
		PULONG	Dx,
		LPSIZE	pSize,
		FLONG	fl
	)

Definition at line 135 of file text.c.

{
    PDC pdc;
    PDC_ATTR pdcattr;
    BOOL Result;
    PTEXTOBJ TextObj;
 
    if ( (!String && Count ) || !pSize )
    {
        EngSetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if ( !Count )
    {
        if ( Fit ) Fit = 0;
        return TRUE;
    }
 
    pdc = DC_LockDc(hDC);
    if (NULL == pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    pdcattr = pdc->pdcattr;
 
    TextObj = RealizeFontInit(pdcattr->hlfntNew);
    if ( TextObj )
    {
        Result = TextIntGetTextExtentPoint( pdc,
                                            TextObj,
                                            String,
                                            Count,
                                            MaxExtent,
                                            (LPINT)Fit,
                                            (LPINT)Dx,
                                            pSize,
                                            fl);
        TEXTOBJ_UnlockText(TextObj);
    }
    else
        Result = FALSE;
 
    DC_UnlockDc(pdc);
    return Result;
}

Referenced by TEXT_Ellipsify(), TEXT_NextLineW(), TEXT_PathEllipsify(), TEXT_WordBreak(), and UserDrawCaptionText().

GreGetTextExtentW()

BOOL FASTCALL GreGetTextExtentW	(	HDC	hDC,
		LPCWSTR	lpwsz,
		INT	cwc,
		LPSIZE	psize,
		UINT	flOpts
	)

Definition at line 78 of file text.c.

{
    PDC pdc;
    PDC_ATTR pdcattr;
    BOOL Result;
    PTEXTOBJ TextObj;
 
    if (!cwc)
    {
        psize->cx = 0;
        psize->cy = 0;
        return TRUE;
    }
 
    pdc = DC_LockDc(hDC);
    if (!pdc)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    pdcattr = pdc->pdcattr;
 
    TextObj = RealizeFontInit(pdcattr->hlfntNew);
    if ( TextObj )
    {
        Result = TextIntGetTextExtentPoint( pdc,
                                            TextObj,
                                            lpwsz,
                                            cwc,
                                            0,
                                            NULL,
                                            0,
                                            psize,
                                            flOpts);
        TEXTOBJ_UnlockText(TextObj);
    }
    else
        Result = FALSE;
 
    DC_UnlockDc(pdc);
    return Result;
}

Referenced by DrawTextExWorker(), IntPaintDesktop(), and TEXT_DrawUnderscore().

GreGetTextMetricsW()

BOOL WINAPI GreGetTextMetricsW	(	_In_ HDC	hdc,
		_Out_ LPTEXTMETRICW	lptm
	)

Definition at line 193 of file text.c.

{
   TMW_INTERNAL tmwi;
   if (!ftGdiGetTextMetricsW(hdc, &tmwi)) return FALSE;
   IntTMWFixUp(hdc, &tmwi);
   *lptm = tmwi.TextMetric;
   return TRUE;
}

Referenced by DrawTextExWorker().

GreTextOutW()

BOOL FASTCALL GreTextOutW	(	HDC	hdc,
		int	nXStart,
		int	nYStart,
		LPCWSTR	lpString,
		int	cchString
	)

Functions

Definition at line 61 of file text.c.

{
    return GreExtTextOutW(hdc, nXStart, nYStart, 0, NULL, lpString, cchString, NULL, 0);
}

Referenced by MENU_DrawPopupGlyph(), UITOOLS95_DFC_ButtonCheckRadio(), UITOOLS95_DrawFrameCaption(), UITOOLS95_DrawFrameMenu(), and UITOOLS95_DrawFrameScroll().

InitFontSupport()

BOOL FASTCALL InitFontSupport

(

VOID

)

Definition at line 661 of file freetype.c.

{
    ULONG ulError;
 
    InitializeListHead(&g_FontListHead);
    InitializeListHead(&g_FontCacheListHead);
    g_FontCacheNumEntries = 0;
    /* Fast Mutexes must be allocated from non paged pool */
    g_FontListLock = ExAllocatePoolWithTag(NonPagedPool, sizeof(FAST_MUTEX), TAG_INTERNAL_SYNC);
    if (g_FontListLock == NULL)
    {
        return FALSE;
    }
 
    ExInitializeFastMutex(g_FontListLock);
    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 DBG
    DumpFontInfo(TRUE);
#endif
 
    return TRUE;
}

Referenced by DriverEntry().

IntCharSetFromCodePage()

BYTE FASTCALL IntCharSetFromCodePage

(

UINT

uCodePage

)

Definition at line 173 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().

IntEnableFontRendering()

VOID FASTCALL IntEnableFontRendering

(

BOOL

Enable

)

Definition at line 1969 of file freetype.c.

{
    g_RenderingEnabled = Enable;
}

IntGdiAddFontMemResource()

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

Definition at line 1795 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);
 
    LoadFont.pFileName          = NULL;
    LoadFont.Memory             = SharedMem_Create(BufferCopy, dwSize, FALSE);
    LoadFont.Characteristics    = FR_PRIVATE | FR_NOT_ENUM;
    RtlInitUnicodeString(&LoadFont.RegValueName, NULL);
    LoadFont.IsTrueType         = FALSE;
    LoadFont.PrivateEntry       = NULL;
    FaceCount = IntGdiLoadFontsFromMemory(&LoadFont, NULL, -1, -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;
            IntLockProcessPrivateFonts(Win32Process);
            EntryCollection->Handle = ULongToHandle(++Win32Process->PrivateMemFontHandleCount);
            InsertTailList(&Win32Process->PrivateMemFontListHead, &EntryCollection->ListEntry);
            IntUnLockProcessPrivateFonts(Win32Process);
            Ret = EntryCollection->Handle;
        }
    }
    *pNumAdded = FaceCount;
 
    return Ret;
}

Referenced by NtGdiAddFontMemResourceEx().

IntGdiAddFontResource()

INT FASTCALL IntGdiAddFontResource	(	PUNICODE_STRING	FileName,
		DWORD	Characteristics
	)

Definition at line 1625 of file freetype.c.

{
    return IntGdiAddFontResourceEx(FileName, Characteristics, 0);
}

Referenced by NtGdiAddFontResourceW().

IntGdiAddFontResourceEx()

INT FASTCALL IntGdiAddFontResourceEx	(	PUNICODE_STRING	FileName,
		DWORD	Characteristics,
		DWORD	dwFlags
	)

Definition at line 1426 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)");
    static const UNICODE_STRING DosPathPrefix = RTL_CONSTANT_STRING(L"\\??\\");
 
    /* 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 = DuplicateUnicodeString(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;
    }
 
    LoadFont.pFileName          = &PathName;
    LoadFont.Memory             = SharedMem_Create(Buffer, ViewSize, TRUE);
    LoadFont.Characteristics    = Characteristics;
    RtlInitUnicodeString(&LoadFont.RegValueName, NULL);
    LoadFont.IsTrueType         = FALSE;
    LoadFont.CharSet            = DEFAULT_CHARSET;
    LoadFont.PrivateEntry       = NULL;
    FontCount = IntGdiLoadFontsFromMemory(&LoadFont, NULL, -1, -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 = NameFromCharSet(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 IntGdiAddFontResource(), IntLoadFontsInRegistry(), and IntLoadSystemFonts().

IntGdiCleanupPrivateFontsForProcess()

VOID FASTCALL IntGdiCleanupPrivateFontsForProcess

(

VOID

)

Definition at line 1917 of file freetype.c.

{
    PPROCESSINFO Win32Process = PsGetCurrentProcessWin32Process();
    PLIST_ENTRY Entry;
    PFONT_ENTRY_COLL_MEM EntryCollection;
 
    DPRINT("IntGdiCleanupPrivateFontsForProcess()\n");
    do {
        Entry = NULL;
        EntryCollection = NULL;
 
        IntLockProcessPrivateFonts(Win32Process);
        if (!IsListEmpty(&Win32Process->PrivateMemFontListHead))
        {
            Entry = Win32Process->PrivateMemFontListHead.Flink;
            EntryCollection = CONTAINING_RECORD(Entry, FONT_ENTRY_COLL_MEM, ListEntry);
            UnlinkFontMemCollection(EntryCollection);
        }
        IntUnLockProcessPrivateFonts(Win32Process);
 
        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;
            IntLockProcessPrivateFonts(Win32Process);
            if (!IsListEmpty(&Win32Process->PrivateFontListHead))
            {
                Entry = RemoveHeadList(&Win32Process->PrivateFontListHead);
            }
            IntUnLockProcessPrivateFonts(Win32Process);
 
            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 5386 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 */
    IntLockGlobalFonts();
    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;
        }
    }
    IntUnLockGlobalFonts();
 
    /* 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().

IntGdiRemoveFontMemResource()

BOOL FASTCALL IntGdiRemoveFontMemResource

(

HANDLE

hMMFont

)

Definition at line 1883 of file freetype.c.

{
    PLIST_ENTRY Entry;
    PFONT_ENTRY_COLL_MEM CurrentEntry;
    PFONT_ENTRY_COLL_MEM EntryCollection = NULL;
    PPROCESSINFO Win32Process = PsGetCurrentProcessWin32Process();
 
    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);
 
    if (EntryCollection)
    {
        IntGdiCleanupMemEntry(EntryCollection->Entry);
        ExFreePoolWithTag(EntryCollection, TAG_FONT);
        return TRUE;
    }
    return FALSE;
}

Referenced by NtGdiRemoveFontMemResourceEx().

IntGetCharDimensions()

DWORD FASTCALL IntGetCharDimensions	(	HDC	hdc,
		PTEXTMETRICW	ptm,
		PDWORD	height
	)

Definition at line 329 of file font.c.

{
  PDC pdc;
  PDC_ATTR pdcattr;
  PTEXTOBJ TextObj;
  SIZE sz;
  TMW_INTERNAL tmwi;
  BOOL Good;
 
  static const WCHAR alphabet[] = {
        'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
        'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
        'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
 
  if(!ftGdiGetTextMetricsW(hdc, &tmwi)) return 0;
 
  pdc = DC_LockDc(hdc);
 
  if (!pdc) return 0;
 
  pdcattr = pdc->pdcattr;
 
  TextObj = RealizeFontInit(pdcattr->hlfntNew);
  if ( !TextObj )
  {
     DC_UnlockDc(pdc);
     return 0;
  }
  Good = TextIntGetTextExtentPoint(pdc, TextObj, alphabet, 52, 0, NULL, 0, &sz, 0);
  TEXTOBJ_UnlockText(TextObj);
  DC_UnlockDc(pdc);
 
  if (!Good) return 0;
  if (ptm) *ptm = tmwi.TextMetric;
  if (height) *height = tmwi.TextMetric.tmHeight;
 
  return (sz.cx / 26 + 1) / 2;
}

Referenced by co_IntInitializeDesktopGraphics(), IntGetDialogBaseUnits(), MENU_CalcItemSize(), and UserChangeDisplaySettings().

IntGetFontLanguageInfo()

DWORD FASTCALL IntGetFontLanguageInfo

(

PDC

Dc

)

Definition at line 371 of file font.c.

{
  PDC_ATTR pdcattr;
  FONTSIGNATURE fontsig;
  static const DWORD GCP_DBCS_MASK=0x003F0000,
        GCP_DIACRITIC_MASK=0x00000000,
        FLI_GLYPHS_MASK=0x00000000,
        GCP_GLYPHSHAPE_MASK=0x00000040,
        GCP_KASHIDA_MASK=0x00000000,
        GCP_LIGATE_MASK=0x00000000,
        GCP_USEKERNING_MASK=0x00000000,
        GCP_REORDER_MASK=0x00000060;
 
  DWORD result=0;
 
  ftGdiGetTextCharsetInfo( Dc, &fontsig, 0 );
 
 /* We detect each flag we return using a bitmask on the Codepage Bitfields */
  if( (fontsig.fsCsb[0]&GCP_DBCS_MASK)!=0 )
        result|=GCP_DBCS;
 
  if( (fontsig.fsCsb[0]&GCP_DIACRITIC_MASK)!=0 )
        result|=GCP_DIACRITIC;
 
  if( (fontsig.fsCsb[0]&FLI_GLYPHS_MASK)!=0 )
        result|=FLI_GLYPHS;
 
  if( (fontsig.fsCsb[0]&GCP_GLYPHSHAPE_MASK)!=0 )
        result|=GCP_GLYPHSHAPE;
 
  if( (fontsig.fsCsb[0]&GCP_KASHIDA_MASK)!=0 )
        result|=GCP_KASHIDA;
 
  if( (fontsig.fsCsb[0]&GCP_LIGATE_MASK)!=0 )
        result|=GCP_LIGATE;
 
  if( (fontsig.fsCsb[0]&GCP_USEKERNING_MASK)!=0 )
        result|=GCP_USEKERNING;
 
  pdcattr = Dc->pdcattr;
 
  /* This might need a test for a HEBREW- or ARABIC_CHARSET as well */
  if ( pdcattr->flTextAlign & TA_RTLREADING )
     if( (fontsig.fsCsb[0]&GCP_REORDER_MASK)!=0 )
                    result|=GCP_REORDER;
 
  return result;
}

Referenced by NtGdiGetDCDword().

IntGetOutlineTextMetrics()

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

Definition at line 2404 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 (PRIMARYLANGID(gusLanguageID) == LANG_ENGLISH)
    {
        Cache = &SharedFace->EnglishUS;
    }
    else
    {
        Cache = &SharedFace->UserLanguage;
    }
 
    if (Size == 0 && Cache->OutlineRequiredSize > 0)
    {
        ASSERT(Otm == NULL);
        return Cache->OutlineRequiredSize;
    }
 
    IntInitFontNames(&FontNames, SharedFace);
    Cache->OutlineRequiredSize = FontNames.OtmSize;
 
    if (Size == 0)
    {
        ASSERT(Otm == NULL);
        IntFreeFontNames(&FontNames);
        return Cache->OutlineRequiredSize;
    }
 
    ASSERT(Otm != NULL);
 
    if (Size < Cache->OutlineRequiredSize)
    {
        DPRINT1("Size %u < OutlineRequiredSize %u\n", Size,
                Cache->OutlineRequiredSize);
        IntFreeFontNames(&FontNames);
        return 0;   /* failure */
    }
 
    XScale = Face->size->metrics.x_scale;
    YScale = Face->size->metrics.y_scale;
 
    IntLockFreeType();
 
    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)
    {
        IntUnLockFreeType();
        DPRINT1("Can't find OS/2 table - not TT font?\n");
        IntFreeFontNames(&FontNames);
        return 0;
    }
 
    if (pHori == NULL && Error)
    {
        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 ? &WinFNT : 0);
 
    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:
    IntUnLockFreeType();
 
    pb = IntStoreFontNames(&FontNames, Otm);
    ASSERT(pb - (BYTE*)Otm == Cache->OutlineRequiredSize);
 
    IntFreeFontNames(&FontNames);
 
    return Cache->OutlineRequiredSize;
}

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

IntIsFontRenderingEnabled()

BOOL FASTCALL IntIsFontRenderingEnabled

(

VOID

)

Definition at line 1963 of file freetype.c.

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

Referenced by IntExtTextOutW(), and TextIntGetTextExtentPoint().

IntLoadFontsInRegistry()

BOOL FASTCALL IntLoadFontsInRegistry

(

VOID

)

Definition at line 1641 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;
    BOOLEAN                         Success;
    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 */
        Success = RtlCreateUnicodeString(&FontTitleW, pInfo->Name);
        if (!Success)
        {
            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, 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().

IntLoadSystemFonts()

VOID FASTCALL IntLoadSystemFonts

(

VOID

)

Definition at line 896 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, 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().

RealizeFontInit()

PTEXTOBJ FASTCALL RealizeFontInit

(

HFONT

hFont

)

Definition at line 422 of file font.c.

{
  NTSTATUS Status = STATUS_SUCCESS;
  PTEXTOBJ pTextObj;
 
  pTextObj = TEXTOBJ_LockText(hFont);
 
  if ( pTextObj && !(pTextObj->fl & TEXTOBJECT_INIT))
  {
     Status = TextIntRealizeFont(hFont, pTextObj);
     if (!NT_SUCCESS(Status))
     {
        TEXTOBJ_UnlockText(pTextObj);
        return NULL;
     }
  }
  return pTextObj;
}

Referenced by ftGdiGetGlyphOutline(), ftGdiGetTextCharsetInfo(), ftGdiGetTextMetricsW(), GreGetKerningPairs(), GreGetTextExtentExW(), GreGetTextExtentW(), IntExtTextOutW(), IntGetCharDimensions(), NtGdiGetCharABCWidthsW(), NtGdiGetCharWidthW(), NtGdiGetFontData(), NtGdiGetFontUnicodeRanges(), NtGdiGetGlyphIndicesW(), NtGdiGetKerningPairs(), NtGdiGetOutlineTextMetricsInternalW(), NtGdiGetRealizationInfo(), NtGdiGetTextExtentExW(), and NtGdiGetTextFaceW().

TextIntCreateFontIndirect()

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

Definition at line 1997 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	(	PDC	dc,
		PTEXTOBJ	TextObj,
		LPCWSTR	String,
		INT	Count,
		ULONG	MaxExtent,
		LPINT	Fit,
		LPINT	Dx,
		LPSIZE	Size,
		FLONG	fl
	)

Definition at line 4264 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;
 
    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();
    TextIntUpdateSize(dc, TextObj, FontGDI, FALSE);
    Cache.Hashed.matTransform = identityMat;
    FT_Set_Transform(Cache.Hashed.Face, NULL, NULL);
 
    use_kerning = FT_HAS_KERNING(Cache.Hashed.Face);
    previous = 0;
 
    for (i = 0; i < Count; i++)
    {
        glyph_index = get_glyph_index_flagged(Cache.Hashed.Face, *String, GTEF_INDICES, fl);
        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;
        }
 
        /* Bold and italic do not use the cache */
        if (Cache.Hashed.Aspect.EmuBoldItalic)
        {
            FT_Done_Glyph((FT_Glyph)realglyph);
        }
 
        previous = glyph_index;
        String++;
    }
    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(), IntGetCharDimensions(), and NtGdiGetTextExtentExW().

TextIntRealizeFont()

NTSTATUS FASTCALL TextIntRealizeFont	(	HFONT	FontHandle,
		PTEXTOBJ	pTextObj
	)

Definition at line 5199 of file freetype.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PTEXTOBJ TextObj;
    PPROCESSINFO Win32Process;
    ULONG MatchPenalty;
    LOGFONTW *pLogFont;
    LOGFONTW SubstitutedLogFont;
 
    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;
    DPRINT("Font '%S,%u' is substituted by: ", pLogFont->lfFaceName, pLogFont->lfCharSet);
    SubstituteFontRecurse(&SubstitutedLogFont);
    DPRINT("'%S,%u'.\n", SubstitutedLogFont.lfFaceName, SubstitutedLogFont.lfCharSet);
 
    MatchPenalty = 0xFFFFFFFF;
    TextObj->Font = NULL;
 
    Win32Process = PsGetCurrentProcessWin32Process();
 
    /* Search private fonts */
    IntLockProcessPrivateFonts(Win32Process);
    FindBestFontFromList(&TextObj->Font, &MatchPenalty, &SubstitutedLogFont,
                         &Win32Process->PrivateFontListHead);
    IntUnLockProcessPrivateFonts(Win32Process);
 
    /* Search system fonts */
    IntLockGlobalFonts();
    FindBestFontFromList(&TextObj->Font, &MatchPenalty, &SubstitutedLogFont,
                         &g_FontListHead);
    IntUnLockGlobalFonts();
 
    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;
        if (MatchFontNames(SharedFace, SubstitutedLogFont.lfFaceName))
        {
            RtlStringCchCopyW(TextObj->TextFace, _countof(TextObj->TextFace), pLogFont->lfFaceName);
        }
        else
        {
            RtlInitUnicodeString(&Name, NULL);
            Status = IntGetFontLocalizedName(&Name, SharedFace, TT_NAME_ID_FONT_FAMILY, gusLanguageID);
            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	(	PDC	dc,
		PTEXTOBJ	TextObj,
		PFONTGDI	FontGDI,
		BOOL	bDoLock
	)

Definition at line 3591 of file freetype.c.

{
    FT_Face face;
    INT error, n;
    FT_CharMap charmap, found;
    LOGFONTW *plf;
 
    if (bDoLock)
        IntLockFreeType();
 
    face = FontGDI->SharedFace->Face;
    if (face->charmap == NULL)
    {
        DPRINT("WARNING: No charmap selected!\n");
        DPRINT("This font face has %d charmaps\n", face->num_charmaps);
 
        found = NULL;
        for (n = 0; n < face->num_charmaps; n++)
        {
            charmap = face->charmaps[n];
            if (charmap->encoding == FT_ENCODING_UNICODE)
            {
                found = charmap;
                break;
            }
        }
        if (!found)
        {
            for (n = 0; n < face->num_charmaps; n++)
            {
                charmap = face->charmaps[n];
                if (charmap->platform_id == TT_PLATFORM_APPLE_UNICODE)
                {
                    found = charmap;
                    break;
                }
            }
        }
        if (!found)
        {
            for (n = 0; n < face->num_charmaps; n++)
            {
                charmap = face->charmaps[n];
                if (charmap->encoding == FT_ENCODING_MS_SYMBOL)
                {
                    found = charmap;
                    break;
                }
            }
        }
        if (!found && face->num_charmaps > 0)
        {
            found = face->charmaps[0];
        }
        if (!found)
        {
            DPRINT1("WARNING: Could not find desired charmap!\n");
        }
        else
        {
            DPRINT("Found charmap encoding: %i\n", found->encoding);
            error = FT_Set_Charmap(face, found);
            if (error)
            {
                DPRINT1("WARNING: Could not set the charmap!\n");
            }
        }
    }
 
    plf = &TextObj->logfont.elfEnumLogfontEx.elfLogFont;
 
    error = IntRequestFontSize(dc, FontGDI, plf->lfWidth, plf->lfHeight);
 
    if (bDoLock)
        IntUnLockFreeType();
 
    if (error)
    {
        DPRINT1("Error in setting pixel sizes: %d\n", error);
        return FALSE;
    }
 
    return TRUE;
}

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

TEXTOBJ_LockText()

FORCEINLINE PTEXTOBJ TEXTOBJ_LockText

(

HFONT

hfont

)

Definition at line 83 of file text.h.

{
    PLFONT plfnt = LFONT_ShareLockFont(hfont);
    if (plfnt != 0)
    {
        KeEnterCriticalRegion();
        ExAcquirePushLockExclusive(&plfnt->lock);
    }
    return plfnt;
}

Referenced by RealizeFontInit(), and TextIntRealizeFont().

TEXTOBJ_UnlockText()

FORCEINLINE VOID TEXTOBJ_UnlockText

(

PLFONT

plfnt

)

Definition at line 96 of file text.h.

{
    ExReleasePushLockExclusive(&plfnt->lock);
    KeLeaveCriticalRegion();
    LFONT_ShareUnlockFont(plfnt);
}

Referenced by ftGdiGetGlyphOutline(), ftGdiGetTextCharsetInfo(), ftGdiGetTextMetricsW(), GreGetKerningPairs(), GreGetTextExtentExW(), GreGetTextExtentW(), IntExtTextOutW(), IntGetCharDimensions(), NtGdiGetCharABCWidthsW(), NtGdiGetCharWidthW(), NtGdiGetFontData(), NtGdiGetFontUnicodeRanges(), NtGdiGetGlyphIndicesW(), NtGdiGetKerningPairs(), NtGdiGetOutlineTextMetricsInternalW(), NtGdiGetRealizationInfo(), NtGdiGetTextExtentExW(), NtGdiGetTextFaceW(), RealizeFontInit(), and TextIntRealizeFont().