bmfd.h File Reference

#include <stdarg.h>
#include <windef.h>
#include <wingdi.h>
#include <winddi.h>
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for bmfd.h:

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

Go to the source code of this file.

Classes
struct	NE_NAMEINFO
struct	NE_TYPEINFO
struct	NE_RESTABLE
struct	_FONTDIRENTRY
struct	_DIRENTRY
struct	_FONTGROUPHDR
struct	FONTINFO16
struct	GLYPHENTRY20
struct	GLYPHENTRY30
union	GLYPHENTRY
struct	BMFD_FACE
struct	BMFD_FILE
struct	BMFD_FONT
struct	BMFD_IFIMETRICS

Macros
#define	GETVAL(x)
#define	FDM_MASK
#define	FM_INFO_MASK
#define	FLOATL_1   0x3f800000
#define	TAG_PDEV   'veDP'
#define	TAG_GLYPHSET   'GlSt'
#define	TAG_IFIMETRICS   'Ifim'
#define	TAG_FONTINFO   'Font'
#define	IMAGE_DOS_MAGIC   0x594D
#define	NE_RSCTYPE_FONT   0x8008
#define	NE_RSCTYPE_FONTDIR   0x8007
#define	DFF_FIXED   0x0001
#define	DFF_PROPORTIONAL   0x0002
#define	DFF_ABCFIXED   0x0004
#define	DFF_ABCPROPORTIONAL   0x0008
#define	DFF_1COLOR   0x0010
#define	DFF_16COLOR   0x0020
#define	DFF_256COLOR   0x0040
#define	DFF_RGBCOLOR   0x0080
#define	MAX_STYLESIZE   35

Typedefs
typedef struct NE_NAMEINFO *	PNE_NAMEINFO
typedef struct NE_TYPEINFO *	PNE_TYPEINFO
typedef struct NE_RESTABLE *	PNE_RESTABLE
typedef struct _FONTDIRENTRY	FONTDIRENTRY
typedef struct _FONTDIRENTRY *	PFONTDIRENTRY
typedef struct _DIRENTRY	DIRENTRY
typedef struct _DIRENTRY *	PDIRENTRY
typedef struct _FONTGROUPHDR	FONTGROUPHDR
typedef struct _FONTGROUPHDR *	PFONTGROUPHDR
typedef struct FONTINFO16 *	LPFONTINFO16
typedef struct FONTINFO16 *	PFONTINFO16
typedef struct GLYPHENTRY20 *	PGLYPHENTRY20
typedef struct GLYPHENTRY30 *	PGLYPHENTRY30
typedef union GLYPHENTRY *	PGLYPHENTRY
typedef struct BMFD_FACE *	PBMFD_FACE
typedef struct BMFD_FILE *	PBMFD_FILE
typedef struct BMFD_FONT *	PBMFD_FONT
typedef struct BMFD_IFIMETRICS *	PBMFD_IFIMETRICS

Enumerations
enum	FONTTYPE { FONTTYPE_FON, FONTTYPE_FNT }

Functions
ULONG	DbgPrint (IN PCHAR Format, IN ...)
DHPDEV APIENTRY	BmfdEnablePDEV (IN DEVMODEW *pdm, IN LPWSTR pwszLogAddress, IN ULONG cPat, OUT HSURF *phsurfPatterns, IN ULONG cjCaps, OUT ULONG *pdevcaps, IN ULONG cjDevInfo, OUT DEVINFO *pdi, IN HDEV hdev, IN LPWSTR pwszDeviceName, IN HANDLE hDriver)
VOID APIENTRY	BmfdCompletePDEV (IN DHPDEV dhpdev, IN HDEV hdev)
VOID APIENTRY	BmfdDisablePDEV (IN DHPDEV dhpdev)
ULONG_PTR APIENTRY	BmfdLoadFontFile (ULONG cFiles, ULONG_PTR *piFile, PVOID *ppvView, ULONG *pcjView, DESIGNVECTOR *pdv, ULONG ulLangID, ULONG ulFastCheckSum)
BOOL APIENTRY	BmfdUnloadFontFile (IN ULONG_PTR iFile)
LONG APIENTRY	BmfdQueryFontFile (ULONG_PTR iFile, ULONG ulMode, ULONG cjBuf, ULONG *pulBuf)
LONG APIENTRY	BmfdQueryFontCaps (ULONG culCaps, ULONG *pulCaps)
PVOID APIENTRY	BmfdQueryFontTree (DHPDEV dhpdev, ULONG_PTR iFile, ULONG iFace, ULONG iMode, ULONG_PTR *pid)
PIFIMETRICS APIENTRY	BmfdQueryFont (IN DHPDEV dhpdev, IN ULONG_PTR iFile, IN ULONG iFace, IN ULONG_PTR *pid)
VOID APIENTRY	BmfdFree (PVOID pv, ULONG_PTR id)
PFD_GLYPHATTR APIENTRY	BmfdQueryGlyphAttrs (FONTOBJ *pfo, ULONG iMode)
LONG APIENTRY	BmfdQueryFontData (DHPDEV dhpdev, FONTOBJ *pfo, ULONG iMode, HGLYPH hg, OUT GLYPHDATA *pgd, PVOID pv, ULONG cjSize)
VOID APIENTRY	BmfdDestroyFont (IN FONTOBJ *pfo)

Macro Definition Documentation

DFF_16COLOR

#define DFF_16COLOR   0x0020

Definition at line 84 of file bmfd.h.

DFF_1COLOR

#define DFF_1COLOR   0x0010

Definition at line 83 of file bmfd.h.

DFF_256COLOR

#define DFF_256COLOR   0x0040

Definition at line 85 of file bmfd.h.

DFF_ABCFIXED

#define DFF_ABCFIXED   0x0004

Definition at line 81 of file bmfd.h.

DFF_ABCPROPORTIONAL

#define DFF_ABCPROPORTIONAL   0x0008

Definition at line 82 of file bmfd.h.

DFF_FIXED

#define DFF_FIXED   0x0001

Definition at line 79 of file bmfd.h.

DFF_PROPORTIONAL

#define DFF_PROPORTIONAL   0x0002

Definition at line 80 of file bmfd.h.

DFF_RGBCOLOR

#define DFF_RGBCOLOR   0x0080

Definition at line 86 of file bmfd.h.

FDM_MASK

#define FDM_MASK

Value:

FDM_TYPE_CONST_BEARINGS | FDM_TYPE_ZERO_BEARINGS | \
    FDM_TYPE_CHAR_INC_EQUAL_BM_BASE | FDM_TYPE_MAXEXT_EQUAL_BM_SIDE | \
    FDM_TYPE_BM_SIDE_CONST

Definition at line 29 of file bmfd.h.

FLOATL_1

#define FLOATL_1   0x3f800000

Definition at line 39 of file bmfd.h.

FM_INFO_MASK

#define FM_INFO_MASK

Value:

FM_INFO_TECH_BITMAP | FM_INFO_1BPP | FM_INFO_INTEGER_WIDTH | \
    FM_INFO_RETURNS_BITMAPS | FM_INFO_RIGHT_HANDED | FM_INFO_INTEGRAL_SCALING |\
    FM_INFO_90DEGREE_ROTATIONS | FM_INFO_OPTICALLY_FIXED_PITCH | FM_INFO_NONNEGATIVE_AC

Definition at line 34 of file bmfd.h.

GETVAL

#define GETVAL

(

x

)

Value:

(sizeof(x) == 1) ? (x) : \
    (sizeof(x) == 2) ? (((PCHAR)&(x))[0] + (((PCHAR)&(x))[1] << 8)) : \
    (((PCHAR)&(x))[0] + (((PCHAR)&(x))[1] << 8) + (((PCHAR)&(x))[2] << 16) + \
     (((PCHAR)&(x))[3] << 24))

Definition at line 21 of file bmfd.h.

IMAGE_DOS_MAGIC

#define IMAGE_DOS_MAGIC   0x594D

FON / FNT specific types

Definition at line 49 of file bmfd.h.

MAX_STYLESIZE

#define MAX_STYLESIZE   35

Definition at line 253 of file bmfd.h.

NE_RSCTYPE_FONT

#define NE_RSCTYPE_FONT   0x8008

Definition at line 62 of file bmfd.h.

NE_RSCTYPE_FONTDIR

#define NE_RSCTYPE_FONTDIR   0x8007

Definition at line 63 of file bmfd.h.

TAG_FONTINFO

#define TAG_FONTINFO   'Font'

Definition at line 44 of file bmfd.h.

TAG_GLYPHSET

#define TAG_GLYPHSET   'GlSt'

Definition at line 42 of file bmfd.h.

TAG_IFIMETRICS

#define TAG_IFIMETRICS   'Ifim'

Definition at line 43 of file bmfd.h.

TAG_PDEV

#define TAG_PDEV   'veDP'

Definition at line 41 of file bmfd.h.

Typedef Documentation

DIRENTRY

typedef struct _DIRENTRY DIRENTRY

FONTDIRENTRY

typedef struct _FONTDIRENTRY FONTDIRENTRY

FONTGROUPHDR

typedef struct _FONTGROUPHDR FONTGROUPHDR

LPFONTINFO16

typedef struct FONTINFO16 * LPFONTINFO16

PBMFD_FACE

typedef struct BMFD_FACE * PBMFD_FACE

PBMFD_FILE

typedef struct BMFD_FILE * PBMFD_FILE

PBMFD_FONT

typedef struct BMFD_FONT * PBMFD_FONT

PBMFD_IFIMETRICS

typedef struct BMFD_IFIMETRICS * PBMFD_IFIMETRICS

PDIRENTRY

typedef struct _DIRENTRY * PDIRENTRY

PFONTDIRENTRY

typedef struct _FONTDIRENTRY * PFONTDIRENTRY

PFONTGROUPHDR

typedef struct _FONTGROUPHDR * PFONTGROUPHDR

PFONTINFO16

typedef struct FONTINFO16 * PFONTINFO16

PGLYPHENTRY

typedef union GLYPHENTRY * PGLYPHENTRY

PGLYPHENTRY20

typedef struct GLYPHENTRY20 * PGLYPHENTRY20

PGLYPHENTRY30

typedef struct GLYPHENTRY30 * PGLYPHENTRY30

PNE_NAMEINFO

typedef struct NE_NAMEINFO * PNE_NAMEINFO

PNE_RESTABLE

typedef struct NE_RESTABLE * PNE_RESTABLE

PNE_TYPEINFO

typedef struct NE_TYPEINFO * PNE_TYPEINFO

Enumeration Type Documentation

FONTTYPE

enum FONTTYPE

Driver specific types

Enumerator
FONTTYPE_FON
FONTTYPE_FNT

Definition at line 200 of file bmfd.h.

{
    FONTTYPE_FON,
    FONTTYPE_FNT,
} FONTTYPE;

Function Documentation

BmfdCompletePDEV()

VOID APIENTRY BmfdCompletePDEV	(	IN DHPDEV	dhpdev,
		IN HDEV	hdev
	)

Definition at line 89 of file enable.c.

{
    DbgPrint("BmfdCompletePDEV()\n");
    /* Nothing to do */
}

BmfdDestroyFont()

VOID APIENTRY BmfdDestroyFont

(

IN FONTOBJ *

pfo

)

Definition at line 683 of file font.c.

{
    /* Free the font realization info */
    EngFreeMem(pfo->pvProducer);
    pfo->pvProducer = NULL;
}

BmfdDisablePDEV()

VOID APIENTRY BmfdDisablePDEV

(

IN DHPDEV

dhpdev

)

Definition at line 100 of file enable.c.

{
    DbgPrint("BmfdDisablePDEV()\n");
    /* Nothing to do */
}

BmfdEnablePDEV()

DHPDEV APIENTRY BmfdEnablePDEV	(	IN DEVMODEW *	pdm,
		IN LPWSTR	pwszLogAddress,
		IN ULONG	cPat,
		OUT HSURF *	phsurfPatterns,
		IN ULONG	cjCaps,
		OUT ULONG *	pdevcaps,
		IN ULONG	cjDevInfo,
		OUT DEVINFO *	pdi,
		IN HDEV	hdev,
		IN LPWSTR	pwszDeviceName,
		IN HANDLE	hDriver
	)

Definition at line 67 of file enable.c.

{
    DbgPrint("BmfdEnablePDEV(hdev=%p)\n", hdev);

    /* Return a dummy DHPDEV */
    return (PVOID)1;
}

BmfdFree()

VOID APIENTRY BmfdFree	(	PVOID	pv,
		ULONG_PTR	id
	)

Definition at line 669 of file font.c.

{
    DbgPrint("BmfdFree()\n");
    if (id)
    {
        EngFreeMem((PVOID)id);
    }
}

BmfdLoadFontFile()

ULONG_PTR APIENTRY BmfdLoadFontFile	(	ULONG	cFiles,
		ULONG_PTR *	piFile,
		PVOID *	ppvView,
		ULONG *	pcjView,
		DESIGNVECTOR *	pdv,
		ULONG	ulLangID,
		ULONG	ulFastCheckSum
	)

Public Interface

Definition at line 236 of file font.c.

{
    PBMFD_FILE pfile = NULL;
    PVOID pvView;
    ULONG cjView;

    DbgPrint("BmfdLoadFontFile()\n");
    __debugbreak();

    /* Check parameters */
    if (cFiles != 1)
    {
        DbgPrint("Only 1 File is allowed, got %ld!\n", cFiles);
        return HFF_INVALID;
    }

    /* Map the font file */
    if (!EngMapFontFileFD(*piFile, (PULONG*)&pvView, &cjView))
    {
        DbgPrint("Could not map font file!\n", cFiles);
        return HFF_INVALID;
    }

    DbgPrint("mapped font file to %p, site if %ld\n", pvView, cjView);

    /* Try to parse a .fon file */
    pfile = ParseFonFile(pvView, cjView);

    if (!pfile)
    {
        /* Could be a .fnt file */
        pfile = ParseFntFile(pvView, cjView);
    }

    /* Check whether we succeeded finding a font */
    if (!pfile)
    {
        DbgPrint("No font data found\n");

        /* Unmap the file */
        EngUnmapFontFileFD(*piFile);

        /* Failure! */
        return HFF_INVALID;
    }

    pfile->iFile = *piFile;
    pfile->pvView = pvView;

    /* Success, return the pointer to font info structure */
    return (ULONG_PTR)pfile;
}

BmfdQueryFont()

PIFIMETRICS APIENTRY BmfdQueryFont	(	IN DHPDEV	dhpdev,
		IN ULONG_PTR	iFile,
		IN ULONG	iFace,
		IN ULONG_PTR *	pid
	)

Definition at line 510 of file font.c.

{
    PBMFD_FILE pfile = (PBMFD_FILE)iFile;
    PBMFD_FACE pface;
    PFONTINFO16 pFontInfo;
    PIFIMETRICS pifi;
    PBMFD_IFIMETRICS pifiX;
    PANOSE panose = {0};

    DbgPrint("BmfdQueryFont()\n");
//    __debugbreak();

    /* Validate parameters */
    if (iFace > pfile->cNumFaces || !pid)
    {
        return NULL;
    }

    pface = &pfile->aface[iFace - 1];
    pFontInfo = pface->pFontInfo;

    /* Allocate the structure */
    pifiX = EngAllocMem(FL_ZERO_MEMORY, sizeof(BMFD_IFIMETRICS), TAG_IFIMETRICS);
    if (!pifiX)
    {
        return NULL;
    }

    /* Return a pointer to free it later */
    *pid = (ULONG_PTR)pifiX;

    /* Fill IFIMETRICS */
    pifi = &pifiX->ifim;
    pifi->cjThis = sizeof(BMFD_IFIMETRICS);
    pifi->cjIfiExtra = 0;
    pifi->dpwszFamilyName = FIELD_OFFSET(BMFD_IFIMETRICS, wszFamilyName);
    pifi->dpwszStyleName = FIELD_OFFSET(BMFD_IFIMETRICS, wszFamilyName);
    pifi->dpwszFaceName = FIELD_OFFSET(BMFD_IFIMETRICS, wszFaceName);
    pifi->dpwszUniqueName = FIELD_OFFSET(BMFD_IFIMETRICS, wszFaceName);
    pifi->dpFontSim = 0;
    pifi->lEmbedId = 0;
    pifi->lItalicAngle = 0;
    pifi->lCharBias = 0;
    pifi->dpCharSets = 0;
    pifi->jWinCharSet = pFontInfo->dfCharSet;
    pifi->jWinPitchAndFamily = pFontInfo->dfPitchAndFamily;
    pifi->usWinWeight = GETVAL(pFontInfo->dfWeight);
    pifi->flInfo = pface->flInfo;
    pifi->fsSelection = 0;
    pifi->fsType = 0;
    pifi->fwdUnitsPerEm = GETVAL(pFontInfo->dfPixHeight);
    pifi->fwdLowestPPEm = 0;
    pifi->fwdWinAscender = GETVAL(pFontInfo->dfAscent);
    pifi->fwdWinDescender = pifi->fwdUnitsPerEm - pifi->fwdWinAscender;
    pifi->fwdMacAscender = pifi->fwdWinAscender;
    pifi->fwdMacDescender = - pifi->fwdWinDescender;
    pifi->fwdMacLineGap = 0;
    pifi->fwdTypoAscender = pifi->fwdWinAscender;
    pifi->fwdTypoDescender = - pifi->fwdWinDescender;
    pifi->fwdTypoLineGap = 0;
    pifi->fwdAveCharWidth = GETVAL(pFontInfo->dfAvgWidth);
    pifi->fwdMaxCharInc =  GETVAL(pFontInfo->dfMaxWidth);
    pifi->fwdCapHeight = pifi->fwdUnitsPerEm / 2;
    pifi->fwdXHeight = pifi->fwdUnitsPerEm / 4;
    pifi->fwdSubscriptXSize = 0;
    pifi->fwdSubscriptYSize = 0;
    pifi->fwdSubscriptXOffset = 0;
    pifi->fwdSubscriptYOffset = 0;
    pifi->fwdSuperscriptXSize = 0;
    pifi->fwdSuperscriptYSize = 0;
    pifi->fwdSuperscriptXOffset = 0;
    pifi->fwdSuperscriptYOffset = 0;
    pifi->fwdUnderscoreSize = 01;
    pifi->fwdUnderscorePosition = -1;
    pifi->fwdStrikeoutSize = 1;
    pifi->fwdStrikeoutPosition = pifi->fwdXHeight + 1;
    pifi->chFirstChar = pFontInfo->dfFirstChar;
    pifi->chLastChar = pFontInfo->dfLastChar;
    pifi->chDefaultChar = pFontInfo->dfFirstChar + pFontInfo->dfDefaultChar;
    pifi->chBreakChar = pFontInfo->dfFirstChar + pFontInfo->dfBreakChar;
    pifi->wcFirstChar = pface->wcFirstChar;
    pifi->wcLastChar = pface->wcLastChar;
    pifi->wcDefaultChar = pface->wcDefaultChar;
    pifi->wcBreakChar = pface->wcBreakChar;
    pifi->ptlBaseline.x = 1;
    pifi->ptlBaseline.y = 0;
    pifi->ptlAspect.x = pFontInfo->dfVertRes; // CHECKME
    pifi->ptlAspect.y = pFontInfo->dfHorizRes;
    pifi->ptlCaret.x = 0;
    pifi->ptlCaret.y = 1;
    pifi->rclFontBox.left = 0;
    pifi->rclFontBox.right = pifi->fwdAveCharWidth;
    pifi->rclFontBox.top = pifi->fwdWinAscender;
    pifi->rclFontBox.bottom = - pifi->fwdWinDescender;
    *(DWORD*)&pifi->achVendId = 0x30303030; // FIXME
    pifi->cKerningPairs = 0;
    pifi->ulPanoseCulture = FM_PANOSE_CULTURE_LATIN;
    pifi->panose = panose;

    /* Set char sets */
    pifiX->ajCharSet[0] = pifi->jWinCharSet;
    pifiX->ajCharSet[1] = DEFAULT_CHARSET;

    if (pface->flInfo & FM_INFO_CONSTANT_WIDTH)
        pifi->jWinPitchAndFamily |= FIXED_PITCH;

#if 0
    EngMultiByteToUnicodeN(pifiX->wszFaceName,
                           LF_FACESIZE * sizeof(WCHAR),
                           NULL,
                           pFontInfo->,
                           strnlen(pDesc, LF_FACESIZE));
#endif
    wcscpy(pifiX->wszFaceName, L"Courier-X");
    wcscpy(pifiX->wszFamilyName, L"Courier-X");

    /* Initialize font weight style flags and string */
    if (pifi->usWinWeight == FW_REGULAR)
    {
   //     pifi->fsSelection |= FM_SEL_REGULAR;
    }
    else if (pifi->usWinWeight > FW_SEMIBOLD)
    {
        pifi->fsSelection |= FM_SEL_BOLD;
        wcscat(pifiX->wszStyleName, L"Bold ");
    }
    else if (pifi->usWinWeight <= FW_LIGHT)
    {
        wcscat(pifiX->wszStyleName, L"Light ");
    }

    if (pFontInfo->dfItalic)
    {
        pifi->fsSelection |= FM_SEL_ITALIC;
        wcscat(pifiX->wszStyleName, L"Italic ");
    }

    if (pFontInfo->dfUnderline)
    {
        pifi->fsSelection |= FM_SEL_UNDERSCORE;
        wcscat(pifiX->wszStyleName, L"Underscore ");
    }

    if (pFontInfo->dfStrikeOut)
    {
        pifi->fsSelection |= FM_SEL_STRIKEOUT;
        wcscat(pifiX->wszStyleName, L"Strikeout ");
    }

    return pifi;
}

BmfdQueryFontCaps()

LONG APIENTRY BmfdQueryFontCaps	(	ULONG	culCaps,
		ULONG *	pulCaps
	)

Definition at line 361 of file font.c.

{
    DbgPrint("BmfdQueryFontCaps()\n");

    /* We need room for 2 ULONGs */
    if (culCaps < 2)
    {
        return FD_ERROR;
    }

    /* We only support 1 bpp */
    pulCaps[0] = 2;
    pulCaps[1] = QC_1BIT;

    return 2;
}

BmfdQueryFontData()

LONG APIENTRY BmfdQueryFontData	(	DHPDEV	dhpdev,
		FONTOBJ *	pfo,
		ULONG	iMode,
		HGLYPH	hg,
		OUT GLYPHDATA *	pgd,
		PVOID	pv,
		ULONG	cjSize
	)

Definition at line 316 of file glyph.c.

{
    PBMFD_FILE pfile = (PBMFD_FILE)pfo->iFile;
    PBMFD_FACE pface = &pfile->aface[pfo->iFace - 1];
    PBMFD_FONT pfont= BmfdGetFontInstance(pfo, pface);

    DbgPrint("BmfdQueryFontData(pfo=%p, iMode=%ld, hg=%p, pgd=%p, pv=%p, cjSize=%ld)\n",
             pfo, iMode, hg, pgd, pv, cjSize);
//    __debugbreak();

    switch (iMode)
    {
        case QFD_GLYPHANDBITMAP: /* 1 */
            return BmfdQueryGlyphAndBitmap(pfont, hg, pgd, pv, cjSize);

        case QFD_MAXEXTENTS: /* 3 */
            return BmfdQueryMaxExtents(pfont, pv, cjSize);

            /* we support nothing else */
        default:
            return FD_ERROR;

    }

    return FD_ERROR;
}

BmfdQueryFontFile()

LONG APIENTRY BmfdQueryFontFile	(	ULONG_PTR	iFile,
		ULONG	ulMode,
		ULONG	cjBuf,
		ULONG *	pulBuf
	)

Definition at line 317 of file font.c.

{
    PBMFD_FILE pfile = (PBMFD_FILE)iFile;

    DbgPrint("BmfdQueryFontFile()\n");
//    __debugbreak();

    switch (ulMode)
    {
        case QFF_DESCRIPTION:
        {
            /* We copy the face name of the 1st face */
            PCHAR pDesc = pfile->aface[0].pszFaceName;
            ULONG cOutSize;
            if (pulBuf)
            {
                EngMultiByteToUnicodeN((LPWSTR)pulBuf,
                                       cjBuf,
                                       &cOutSize,
                                       pDesc,
                                       strnlen(pDesc, LF_FACESIZE));
            }
            else
            {
                cOutSize = (strnlen(pDesc, LF_FACESIZE) + 1) * sizeof(WCHAR);
            }
            return cOutSize;
        }

        case QFF_NUMFACES:
            /* return the number of faces in the file */
            return pfile->cNumFaces;

        default:
            return FD_ERROR;
    }
}

BmfdQueryFontTree()

PVOID APIENTRY BmfdQueryFontTree	(	DHPDEV	dhpdev,
		ULONG_PTR	iFile,
		ULONG	iFace,
		ULONG	iMode,
		ULONG_PTR *	pid
	)

Definition at line 383 of file font.c.

{
    PBMFD_FILE pfile = (PBMFD_FILE)iFile;
    PBMFD_FACE pface;
    ULONG i, j, cjSize, cGlyphs, cRuns;
    CHAR ch, chFirst, ach[256];
    WCHAR wc, awc[256];
    PFD_GLYPHSET pGlyphSet;
    WCRUN *pwcrun;
    HGLYPH * phglyphs;

    DbgPrint("DrvQueryFontTree(iMode=%ld)\n", iMode);
//    __debugbreak();

    /* Check parameters, we only support QFT_GLYPHSET */
    if (!iFace || iFace > pfile->cNumFaces || iMode != QFT_GLYPHSET)
    {
        DbgPrint("iFace = %ld, cNumFaces = %ld\n", iFace, pfile->cNumFaces);
        return NULL;
    }

    /* Get a pointer to the face data */
    pface = &pfile->aface[iFace - 1];

    /* Get the number of characters in the face */
    cGlyphs = pface->cGlyphs;

    chFirst = pface->pFontInfo->dfFirstChar;

    /* Build array of supported chars */
    for (i = 0; i < cGlyphs; i++)
    {
        ach[i] = chFirst + i;
    }

    /* Convert the chars to unicode */
    EngMultiByteToUnicodeN(awc, sizeof(awc), NULL, ach, cGlyphs);

    /* Sort both arrays in wchar order */
    for (i = 0; i < cGlyphs - 1; i++)
    {
        wc = awc[i];
        for (j = i + 1; j < cGlyphs; j++)
        {
            if (awc[j] < wc)
            {
                awc[i] = awc[j];
                awc[j] = wc;
                wc = awc[i];
                ch = ach[i];
                ach[i] = ach[j];
                ach[j] = ch;
            }
        }
    }

    /* Find number of WCRUNs */
    cRuns = 1;
    for (i = 1; i < cGlyphs; i++)
    {
        if (awc[i] != awc[i - 1] + 1)
        {
            cRuns++;
        }
    }

    /* Calculate FD_GLYPHSET size */
    cjSize = sizeof(FD_GLYPHSET)
             + (cRuns - 1) * sizeof(WCRUN)
             + cGlyphs * sizeof(HGLYPH);

    /* Allocate the FD_GLYPHSET structure */
    pGlyphSet = EngAllocMem(0, cjSize, TAG_GLYPHSET);
    if (!pGlyphSet)
    {
        return NULL;
    }

    /* Initialize FD_GLYPHSET */
    pGlyphSet->cjThis = cjSize;
    pGlyphSet->flAccel = 0;
    pGlyphSet->cGlyphsSupported = cGlyphs;
    pGlyphSet->cRuns = cRuns;

    /* Initialize 1st WCRUN */
    pwcrun = pGlyphSet->awcrun;
    phglyphs = (PHGLYPH)&pGlyphSet->awcrun[cRuns];
    pwcrun[0].wcLow = awc[0];
    pwcrun[0].cGlyphs = 1;
    pwcrun[0].phg = phglyphs;
    phglyphs[0] = 0;

    /* Walk through all supported chars */
    for (i = 1, j = 0; i < cGlyphs; i++)
    {
        /* Use offset to glyph entry as hglyph */
        phglyphs[i] = (ach[i] - chFirst) * pface->cjEntrySize;

        /* Check whether we can append the wchar to a run */
        if (awc[i] == awc[i - 1] + 1)
        {
            /* Append to current WCRUN */
            pwcrun[j].cGlyphs++;
        }
        else
        {
            /* Add a new WCRUN */
            j++;
            pwcrun[j].wcLow = awc[i];
            pwcrun[j].cGlyphs = 1;
            pwcrun[j].phg = &phglyphs[i];
        }
    }

    /* Set *pid to the allocated structure for use in BmfdFree */
    *pid = (ULONG_PTR)pGlyphSet;

    return pGlyphSet;
}

BmfdQueryGlyphAttrs()

PFD_GLYPHATTR APIENTRY BmfdQueryGlyphAttrs	(	FONTOBJ *	pfo,
		ULONG	iMode
	)

Public Interface

Definition at line 305 of file glyph.c.

{
    DbgPrint("BmfdQueryGlyphAttrs()\n");
    /* We don't support FO_ATTR_MODE_ROTATE */
    return NULL;
}

BmfdUnloadFontFile()

BOOL APIENTRY BmfdUnloadFontFile

(

IN ULONG_PTR

iFile

)

Definition at line 298 of file font.c.

{
    PBMFD_FILE pfile = (PBMFD_FILE)iFile;

    DbgPrint("BmfdUnloadFontFile()\n");

    /* Unmap the font file */
    EngUnmapFontFileFD(pfile->iFile);

    /* Free the memory that was allocated for the font */
    EngFreeMem(pfile);

    return TRUE;
}

DbgPrint()

ULONG DbgPrint	(	IN PCHAR	Format,
		IN ...
	)

Function prototypes

Definition at line 29 of file enable.c.

{
    va_list args;

    va_start(args, Format);
    EngDebugPrint("Bmfd: ", Format, args);
    va_end(args);
    return 0;
}