font.c File Reference

#include "precomp.h"
#include <winuser.h>
#include "settings.h"
#include "font.h"
#include <debug.h>

Include dependency graph for font.c:

Go to the source code of this file.

Classes
struct	_FIND_SUITABLE_FONT_PROC_PARAM
struct	_IS_VALID_CONSOLE_FONT_PARAM

Macros
#define	NDEBUG
#define	DBGFNT   DPRINT
#define	DBGFNT1   DPRINT1
#define	TERMINAL_FACENAME   L"Terminal"
#define	DEFAULT_NON_DBCS_FONTFACE   L"Lucida Console"
#define	DEFAULT_TT_FONT_FACENAME   L"__DefaultTTFont__"
#define	TM_IS_TT_FONT(x)   (((x) & TMPF_TRUETYPE) == TMPF_TRUETYPE)
#define	SIZE_EQUAL(s1, s2)   (((s1).X == (s2).X) && ((s1).Y == (s2).Y))

Typedefs
typedef struct _FIND_SUITABLE_FONT_PROC_PARAM	FIND_SUITABLE_FONT_PROC_PARAM
typedef struct _FIND_SUITABLE_FONT_PROC_PARAM *	PFIND_SUITABLE_FONT_PROC_PARAM
typedef struct _IS_VALID_CONSOLE_FONT_PARAM	IS_VALID_CONSOLE_FONT_PARAM
typedef struct _IS_VALID_CONSOLE_FONT_PARAM *	PIS_VALID_CONSOLE_FONT_PARAM

Functions
BYTE	CodePageToCharSet (_In_ UINT CodePage)
	Retrieves the character set associated with a given code page.
static BOOL CALLBACK	FindSuitableFontProc (_In_ PLOGFONTW lplf, _In_ PNEWTEXTMETRICW lpntm, _In_ DWORD FontType, _In_ LPARAM lParam)
	EnumFontFamiliesEx() callback helper for FindSuitableFont().
static BOOL	FindSuitableFont (_Inout_ PFONT_DATA FontData, _In_ UINT CodePage)
	Finds a font suitable for the given code page, based on the current font and its characteristics provided in input.
static HFONT	CreateConsoleFontWorker (_In_ PFONT_DATA FontData, _In_ UINT CodePage)
	Validates and creates a suitable console font based on the font characteristics given in input.
HFONT	CreateConsoleFontEx (_In_ LONG Height, _In_opt_ LONG Width, _Inout_updates_z_(LF_FACESIZE) PWSTR FaceName, _In_ ULONG FontWeight, _In_ ULONG FontFamily, _In_ UINT CodePage, _In_ BOOL UseDefaultFallback, _Out_ PFONT_DATA FontData)
	Validates and creates a suitable console font based on the font characteristics given in input.
HFONT	CreateConsoleFont2 (_In_ LONG Height, _In_opt_ LONG Width, _Inout_ PCONSOLE_STATE_INFO ConsoleInfo)
	A wrapper for CreateConsoleFontEx().
HFONT	CreateConsoleFont (_Inout_ PCONSOLE_STATE_INFO ConsoleInfo)
	A wrapper for CreateConsoleFontEx().
	_Success_ (return)
	Retrieves the cell size for a console font.
BOOL	IsValidConsoleFont2 (_In_ PLOGFONTW lplf, _In_ PNEWTEXTMETRICW lpntm, _In_ DWORD FontType, _In_ UINT CodePage)
	Validates whether a given font can be supported in the console, under the specified code page.
static BOOL CALLBACK	IsValidConsoleFontProc (_In_ PLOGFONTW lplf, _In_ PNEWTEXTMETRICW lpntm, _In_ DWORD FontType, _In_ LPARAM lParam)
	EnumFontFamiliesEx() callback helper for IsValidConsoleFont().
BOOL	IsValidConsoleFont (_In_ PCWSTR FaceName, _In_ UINT CodePage)
	Validates whether a given font can be supported in the console, under the specified code page.
VOID	InitTTFontCache (VOID)
	Initializes the console TrueType font cache.
VOID	ClearTTFontCache (VOID)
	Clears the console TrueType font cache.
VOID	RefreshTTFontCache (VOID)
	Refreshes the console TrueType font cache, by clearing and re-initializing it.
PTT_FONT_ENTRY	FindCachedTTFont (_In_reads_or_z_opt_(LF_FACESIZE) PCWSTR FaceName, _In_ UINT CodePage)
	Searches for a font in the console TrueType font cache, with the specified code page.

Variables
SINGLE_LIST_ENTRY	TTFontCache = { NULL }

Macro Definition Documentation

DBGFNT

#define DBGFNT   DPRINT

Definition at line 21 of file font.c.

DBGFNT1

#define DBGFNT1   DPRINT1

Definition at line 22 of file font.c.

DEFAULT_NON_DBCS_FONTFACE

#define DEFAULT_NON_DBCS_FONTFACE   L"Lucida Console"

Definition at line 28 of file font.c.

DEFAULT_TT_FONT_FACENAME

#define DEFAULT_TT_FONT_FACENAME   L"__DefaultTTFont__"

Definition at line 29 of file font.c.

NDEBUG

#define NDEBUG

Definition at line 18 of file font.c.

SIZE_EQUAL

#define SIZE_EQUAL	(		s1,
			s2
	)		(((s1).X == (s2).X) && ((s1).Y == (s2).Y))

Definition at line 78 of file font.c.

TERMINAL_FACENAME

#define TERMINAL_FACENAME   L"Terminal"

Definition at line 27 of file font.c.

TM_IS_TT_FONT

#define TM_IS_TT_FONT

(

x

)

(((x) & TMPF_TRUETYPE) == TMPF_TRUETYPE)

Definition at line 77 of file font.c.

Typedef Documentation

FIND_SUITABLE_FONT_PROC_PARAM

typedef struct _FIND_SUITABLE_FONT_PROC_PARAM FIND_SUITABLE_FONT_PROC_PARAM

IS_VALID_CONSOLE_FONT_PARAM

typedef struct _IS_VALID_CONSOLE_FONT_PARAM IS_VALID_CONSOLE_FONT_PARAM

PFIND_SUITABLE_FONT_PROC_PARAM

typedef struct _FIND_SUITABLE_FONT_PROC_PARAM * PFIND_SUITABLE_FONT_PROC_PARAM

PIS_VALID_CONSOLE_FONT_PARAM

typedef struct _IS_VALID_CONSOLE_FONT_PARAM * PIS_VALID_CONSOLE_FONT_PARAM

Function Documentation

_Success_()

_Success_

(

return

)

Retrieves the cell size for a console font.

Parameters

	[in,opt]	hDC An optional GDI device context handle.
[in]	hFont	The GDI handle to the font.
[out]	Height	In case of success, receives the cell height size (in pixels).
[out]	Width	In case of success, receives the cell height size (in pixels).

Returns

TRUE if success, FALSE in case of failure.

Definition at line 686 of file font.c.

{
    BOOL Success = FALSE;
    HDC hOrgDC = hDC;
    HFONT hOldFont;
    // LONG LogSize, PointSize;
    LONG CharWidth, CharHeight;
    TEXTMETRICW tm;
    // SIZE CharSize;
 
    if (!hDC)
        hDC = GetDC(NULL);
 
    hOldFont = SelectObject(hDC, hFont);
    if (hOldFont == NULL)
    {
        DBGFNT1("GetFontCellSize: SelectObject failed\n");
        goto Quit;
    }
 
/*
 * See also: Display_SetTypeFace in applications/fontview/display.c
 */
 
    /*
     * Note that the method with GetObjectW just returns
     * the original parameters with which the font was created.
     */
    if (!GetTextMetricsW(hDC, &tm))
    {
        DBGFNT1("GetFontCellSize: GetTextMetrics failed\n");
        goto Cleanup;
    }
 
    CharHeight = tm.tmHeight + tm.tmExternalLeading;
 
#if 0
    /* Measure real char width more precisely if possible */
    if (GetTextExtentPoint32W(hDC, L"R", 1, &CharSize))
        CharWidth = CharSize.cx;
#else
    CharWidth = tm.tmAveCharWidth; // tm.tmMaxCharWidth;
#endif
 
#if 0
    /*** Logical to Point size ***/
    LogSize   = tm.tmHeight - tm.tmInternalLeading;
    PointSize = MulDiv(LogSize, 72, GetDeviceCaps(hDC, LOGPIXELSY));
    /*****************************/
#endif
 
    *Height = (UINT)CharHeight;
    *Width  = (UINT)CharWidth;
    Success = TRUE;
 
Cleanup:
    SelectObject(hDC, hOldFont);
Quit:
    if (!hOrgDC)
        ReleaseDC(NULL, hDC);
 
    return Success;
}

ClearTTFontCache()

VOID ClearTTFontCache

(

VOID

)

Clears the console TrueType font cache.

Returns

None.

Definition at line 1131 of file font.c.

{
    PSINGLE_LIST_ENTRY Entry;
    PTT_FONT_ENTRY FontEntry;
 
    while (TTFontCache.Next != NULL)
    {
        Entry = PopEntryList(&TTFontCache);
        FontEntry = CONTAINING_RECORD(Entry, TT_FONT_ENTRY, Entry);
        RtlFreeHeap(RtlGetProcessHeap(), 0, FontEntry);
    }
    TTFontCache.Next = NULL;
}

Referenced by InitApplet(), and RefreshTTFontCache().

CodePageToCharSet()

BYTE CodePageToCharSet

(

_In_ UINT

CodePage

)

Retrieves the character set associated with a given code page.

Parameters

[in]

CodePage

The code page to convert.

Returns

The character set corresponding to the code page, or DEFAULT_CHARSET.

Definition at line 51 of file font.c.

{
    CHARSETINFO CharInfo;
    if (TranslateCharsetInfo(UlongToPtr(CodePage), &CharInfo, TCI_SRCCODEPAGE))
        return (BYTE)CharInfo.ciCharset;
    else
        return DEFAULT_CHARSET;
}

Referenced by CON_API(), CreateConsoleFontWorker(), FindSuitableFont(), and IsValidConsoleFont().

CreateConsoleFont()

HFONT CreateConsoleFont

(

_Inout_ PCONSOLE_STATE_INFO

ConsoleInfo

)

A wrapper for CreateConsoleFontEx().

Parameters

[in,out]

ConsoleInfo

A pointer to console settings information, containing in particular (in input) the face name and characteristics of the font to create with the current console code page. In output, the font information gets updated. Note that a default fallback font is always being used in case neither the specified font nor any substitute font could be found and created for the specified code page.

Returns

A GDI handle to the created font, or NULL in case of failure.

See also

CreateConsoleFontEx(), CreateConsoleFont2()

Definition at line 653 of file font.c.

{
    /*
     * Format:
     * Width  = FontSize.X = LOWORD(FontSize);
     * Height = FontSize.Y = HIWORD(FontSize);
     */
    /* NOTE: FontSize is always in cell height/width units (pixels) */
    return CreateConsoleFont2((LONG)(ULONG)ConsoleInfo->FontSize.Y,
                              (LONG)(ULONG)ConsoleInfo->FontSize.X,
                              ConsoleInfo);
}

Referenced by RefreshFontPreview().

CreateConsoleFont2()

HFONT CreateConsoleFont2	(	_In_ LONG	Height,
		_In_opt_ LONG	Width,
		_Inout_ PCONSOLE_STATE_INFO	ConsoleInfo
	)

A wrapper for CreateConsoleFontEx().

Parameters

[in]	Height	The font height in cell units (pixels).
	[in,opt]	Width The font width in cell units (pixels).
[in,out]	ConsoleInfo	A pointer to console settings information, containing in particular (in input) the face name and characteristics of the font to create with the current console code page. In output, the font information gets updated. Note that a default fallback font is always being used in case neither the specified font nor any substitute font could be found and created for the specified code page.

Returns

A GDI handle to the created font, or NULL in case of failure.

See also

CreateConsoleFontEx(), CreateConsoleFont()

Definition at line 609 of file font.c.

{
    FONT_DATA FontData;
    HFONT hFont;
 
    hFont = CreateConsoleFontEx(Height,
                                Width,
                                ConsoleInfo->FaceName,
                                ConsoleInfo->FontWeight,
                                ConsoleInfo->FontFamily,
                                ConsoleInfo->CodePage,
                                TRUE, // UseDefaultFallback
                                &FontData);
    if (hFont)
    {
        ConsoleInfo->FontWeight = FontData.Weight;
        ConsoleInfo->FontFamily = FontData.Family;
    }
 
    return hFont;
}

Referenced by CreateConsoleFont(), and FontSizeChange().

CreateConsoleFontEx()

HFONT CreateConsoleFontEx	(	_In_ LONG	Height,
		_In_opt_ LONG	Width,
		_Inout_updates_z_(LF_FACESIZE) PWSTR	FaceName,
		_In_ ULONG	FontWeight,
		_In_ ULONG	FontFamily,
		_In_ UINT	CodePage,
		_In_ BOOL	UseDefaultFallback,
		_Out_ PFONT_DATA	FontData
	)

Validates and creates a suitable console font based on the font characteristics given in input.

Parameters

[in]	Height	The font height in cell units (pixels).
	[in,opt]	Width The font width in cell units (pixels).
[in,out]	FaceName	A pointer to a maximally LF_FACESIZE-sized buffer. In input: The buffer contains the face name of the font to try to create. In output: The buffer receives the face name of the font that has been created, in case of success. It may, or may not be, identical to the face name provided in input, in case a substitute font has been chosen.
[in]	FontWeight	The font weight.
[in]	FontFamily	The font family.
[in]	CodePage	The code page the font has to support.
[in]	UseDefaultFallback	Whether (TRUE) or not (FALSE) to use a default fallback font in case neither the specified font nor any substitute font could be found and created for the specified code page.
[out]	FontData	The face name and characteristics of the created font.

Returns

A GDI handle to the created font, or NULL in case of failure.

Remarks

Similar to FindCreateFont() https://github.com/microsoft/terminal/blob/main/src/propsheet/fontdlg.cpp#L1113 but:

• does not support an internal font cache for now;
• returns a font handle (and not a font index to the cache).

Definition at line 505 of file font.c.

{
    HFONT hFont;
 
    FontData->FaceName = FaceName;
    FontData->Weight = FontWeight;
    FontData->Family = FontFamily;
    /* NOTE: FontSize is always in cell height/width units (pixels) */
    FontData->Size.X = Width;
    FontData->Size.Y = Height;
    FontData->CharSet = 0; // CodePageToCharSet(CodePage);
 
    if (/* !FaceName || */ !*FaceName || wcscmp(FaceName, DEFAULT_TT_FONT_FACENAME) == 0)
    {
        /* We do not have an actual font face name yet and should find one.
         * Call FindSuitableFont() to determine the default font to use. */
    }
    else
    {
        hFont = CreateConsoleFontWorker(FontData, CodePage);
        if (hFont)
            return hFont;
 
        DBGFNT1("CreateConsoleFont('%S') failed - Try to find a suitable font...\n",
                FaceName);
    }
 
    /*
     * We could not create a font with the default settings.
     * Try to find a suitable font and retry.
     */
    if (!FindSuitableFont(FontData, CodePage))
    {
        /* We could not find any suitable font, fall back
         * to some default one if required to do so. */
        DBGFNT1("FindSuitableFont could not find anything - %s\n",
                UseDefaultFallback ? "Falling back to 'Terminal'"
                                   : "Bailing out");
 
        /* No fallback: no font! */
        if (!UseDefaultFallback)
            return NULL;
 
        //
        // FIXME: See also !*FaceName case in FindSuitableFont().
        //
        /* Use "Terminal" as the fallback */
        StringCchCopyW(FaceName, LF_FACESIZE, TERMINAL_FACENAME);
#if 0
        // FIXME: CJK font choose workaround: Don't choose Asian
        // charset font if there is no preferred font for CJK.
        if (IsCJKCodePage(CodePage))
            FontData->CharSet = ANSI_CHARSET;
#endif
        FontData->Family &= ~TMPF_TRUETYPE;
    }
    else
    {
        DBGFNT1("FindSuitableFont found: '%S', size (%d x %d)\n",
                FaceName, FontData->Size.X, FontData->Size.Y);
    }
 
    /* Retry creating the font */
    hFont = CreateConsoleFontWorker(FontData, CodePage);
    if (!hFont)
        DBGFNT1("CreateConsoleFont('%S') failed\n", FaceName);
 
    return hFont;
}

Referenced by CreateConsoleFont2(), and InitFonts().

CreateConsoleFontWorker()

static HFONT CreateConsoleFontWorker ( _In_ PFONT_DATA  FontData, _In_ UINT  CodePage  )

static

Validates and creates a suitable console font based on the font characteristics given in input.

Parameters

[in]	FontData	The face name and characteristics of the font to create.
[in]	CodePage	The code page the font has to support.

Returns

A GDI handle to the created font, or NULL in case of failure.

Definition at line 424 of file font.c.

{
    LOGFONTW lf;
 
    RtlZeroMemory(&lf, sizeof(lf));
 
    lf.lfHeight = (LONG)(ULONG)FontData->Size.Y;
    lf.lfWidth  = (LONG)(ULONG)FontData->Size.X;
 
    lf.lfEscapement  = 0;
    lf.lfOrientation = 0; // TA_BASELINE; // TA_RTLREADING; when the console supports RTL?
    // lf.lfItalic = lf.lfUnderline = lf.lfStrikeOut = FALSE;
    lf.lfWeight  = FontData->Weight;
    lf.lfCharSet = CodePageToCharSet(CodePage);
    lf.lfOutPrecision  = OUT_DEFAULT_PRECIS;
    lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
    lf.lfQuality = DEFAULT_QUALITY;
 
    /* Set the mandatory flags and remove those that we do not support */
    lf.lfPitchAndFamily = (BYTE)( (FIXED_PITCH | FF_MODERN | FontData->Family) &
                                 ~(VARIABLE_PITCH | FF_DECORATIVE | FF_ROMAN | FF_SCRIPT | FF_SWISS));
 
    if (!IsValidConsoleFont(FontData->FaceName, CodePage))
        return NULL;
 
    StringCchCopyNW(lf.lfFaceName, ARRAYSIZE(lf.lfFaceName),
                    FontData->FaceName, LF_FACESIZE);
 
    return CreateFontIndirectW(&lf);
}

Referenced by CreateConsoleFontEx().

FindCachedTTFont()

PTT_FONT_ENTRY FindCachedTTFont	(	_In_reads_or_z_opt_(LF_FACESIZE) PCWSTR	FaceName,
		_In_ UINT	CodePage
	)

Searches for a font in the console TrueType font cache, with the specified code page.

Parameters

[in,opt]

FaceName An optional pointer to a maximally LF_FACESIZE-sized buffer. The buffer contains the face name of the font to search for.

• If FaceName != NULL, search for the named font that should match the provided code page (when CodePage != INVALID_CP).
• If FaceName == NULL, search for a font with the provided code page. In this case, CodePage cannot be == INVALID_CP, otherwise the search fails.

Parameters

[in]

CodePage

The code page the font has to support, or INVALID_CP when searching a font by face name only.

Returns

A pointer to the cache entry for the font, or NULL if not found.

Definition at line 1183 of file font.c.

{
    PSINGLE_LIST_ENTRY Entry;
    PTT_FONT_ENTRY FontEntry;
 
    if (FaceName)
    {
        /* Search for the named font */
        for (Entry = TTFontCache.Next;
             Entry != NULL;
             Entry = Entry->Next)
        {
            FontEntry = CONTAINING_RECORD(Entry, TT_FONT_ENTRY, Entry);
 
            /* NOTE: The font face names are case-sensitive */
            if ((wcscmp(FontEntry->FaceName   , FaceName) == 0) ||
                (wcscmp(FontEntry->FaceNameAlt, FaceName) == 0))
            {
                /* Return the font if we don't search by code page, or when they match */
                if ((CodePage == INVALID_CP) || (CodePage == FontEntry->CodePage))
                {
                    return FontEntry;
                }
            }
        }
    }
    else if (CodePage != INVALID_CP)
    {
        /* Search for a font with the specified code page */
        for (Entry = TTFontCache.Next;
             Entry != NULL;
             Entry = Entry->Next)
        {
            FontEntry = CONTAINING_RECORD(Entry, TT_FONT_ENTRY, Entry);
 
            /* Return the font if the code pages match */
            if (CodePage == FontEntry->CodePage)
                return FontEntry;
        }
    }
 
    return NULL;
}

Referenced by FindSuitableFont().

FindSuitableFont()

static BOOL FindSuitableFont ( _Inout_ PFONT_DATA  FontData, _In_ UINT  CodePage  )

static

Finds a font suitable for the given code page, based on the current font and its characteristics provided in input.

Parameters

[in,out]	FontData	In input: The face name and characteristics of the font to search for, possibly getting a best match. In output: The face name and characteristics of the suitable font, in case of success.
[in]	CodePage	The code page the font has to support.

Returns

TRUE in case a suitable font has been found. Its name and characteristics are returned in FontData. FALSE if no suitable font has been found.

Definition at line 307 of file font.c.

{
    FIND_SUITABLE_FONT_PROC_PARAM Param;
    _Inout_updates_z_(LF_FACESIZE) PWSTR FaceName;
    HDC hDC;
    LOGFONTW lf;
    PTT_FONT_ENTRY FontEntry;
 
    /* Save the original FaceName pointer */
    FaceName = FontData->FaceName;
 
    /* Save our current search criteria */
    RtlZeroMemory(&Param, sizeof(Param));
    Param.SearchFont = *FontData;
 
    Param.SearchFont.CharSet = CodePageToCharSet(CodePage);
    Param.CodePage = CodePage;
 
    if (/* !FaceName || */ !*FaceName)
    {
        /* Find and use a default Raster font */
 
        /* Use "Terminal" as the fallback */
        StringCchCopyW(FaceName, LF_FACESIZE, TERMINAL_FACENAME);
#if 0
        // FIXME: CJK font choose workaround: Don't choose Asian
        // charset font if there is no preferred font for CJK.
        if (IsCJKCodePage(CodePage))
            FontData->CharSet = ANSI_CHARSET;
#endif
        FontData->Family &= ~TMPF_TRUETYPE;
    }
    else if (wcscmp(FaceName, DEFAULT_TT_FONT_FACENAME) == 0)
    {
        /* Find and use a default TrueType font */
        FontEntry = FindCachedTTFont(NULL, CodePage);
        if (FontEntry)
        {
            StringCchCopyW(FaceName, LF_FACESIZE, FontEntry->FaceName);
        }
        else
        {
            StringCchCopyW(FaceName, LF_FACESIZE, DEFAULT_NON_DBCS_FONTFACE);
        }
        FontData->Family |= TMPF_TRUETYPE;
    }
 
    /* Search for a TrueType alternative face name */
    FontEntry = FindCachedTTFont(FaceName, CodePage);
    if (FontEntry)
    {
        /* NOTE: The font face names are case-sensitive */
        if (wcscmp(FontEntry->FaceName, FaceName) == 0)
            Param.AltFaceName = FontEntry->FaceNameAlt;
        else if (wcscmp(FontEntry->FaceNameAlt, FaceName) == 0)
            Param.AltFaceName = FontEntry->FaceName;
    }
    else
    {
        Param.AltFaceName = FaceName;
    }
 
    /* Initialize the search: start with a strict search, then a relaxed one */
    Param.FontFound = FALSE;
 
    Param.StrictSearch = TRUE;
SearchAgain:
    /*
     * Enumerate all fonts with the given character set.
     * We will match them with the search criteria.
     */
    RtlZeroMemory(&lf, sizeof(lf));
    lf.lfCharSet = Param.SearchFont.CharSet;
    // lf.lfPitchAndFamily = FIXED_PITCH | FF_MODERN;
 
    hDC = GetDC(NULL);
    EnumFontFamiliesExW(hDC, &lf, (FONTENUMPROCW)FindSuitableFontProc, (LPARAM)&Param, 0);
    ReleaseDC(NULL, hDC);
 
    /* If we failed to find any font, search again with relaxed criteria */
    if (Param.StrictSearch && !Param.FontFound)
    {
        Param.StrictSearch = FALSE;
        goto SearchAgain;
    }
 
    /* If no font was found again, return failure */
    if (!Param.FontFound)
        return FALSE;
 
    /* Return the font details */
    *FontData = Param.CandidateFont;
    FontData->FaceName = FaceName; // Restore the original FaceName pointer.
    StringCchCopyNW(FaceName, LF_FACESIZE,
                    Param.CandidateFaceName,
                    ARRAYSIZE(Param.CandidateFaceName));
 
    return TRUE;
}

Referenced by CreateConsoleFontEx().

FindSuitableFontProc()

static BOOL CALLBACK FindSuitableFontProc ( _In_ PLOGFONTW  lplf, _In_ PNEWTEXTMETRICW  lpntm, _In_ DWORD  FontType, _In_ LPARAM  lParam  )

static

EnumFontFamiliesEx() callback helper for FindSuitableFont().

Remarks

It implements a nearly-identical console-suitable font search algorithm based on the one from FindCreateFont() https://github.com/microsoft/terminal/blob/main/src/propsheet/fontdlg.cpp#L1113 excepting that for now, it does not support an internal font cache.

Definition at line 90 of file font.c.

{
    PFIND_SUITABLE_FONT_PROC_PARAM Param = (PFIND_SUITABLE_FONT_PROC_PARAM)lParam;
    PFONT_DATA SearchFont = &Param->SearchFont;
 
    if (!IsValidConsoleFont2(lplf, lpntm, FontType, Param->CodePage))
    {
        /* This font does not suit us; continue enumeration */
        return TRUE;
    }
 
#ifndef FONT_CACHE_PRESENT
    /*
     * Since we don't cache all the possible font sizes for TrueType fonts,
     * we cannot check our requested size (and weight) against the enumerated
     * one; therefore reset the enumerated values to the requested ones.
     * On the contrary, Raster fonts get their specific font sizes (and weights)
     * enumerated separately, so for them we can keep the enumerated values.
     */
    if (FontType == TRUETYPE_FONTTYPE)
    {
        lplf->lfHeight = SearchFont->Size.Y;
        lplf->lfWidth  = 0; // SearchFont->Size.X;
        lplf->lfWeight = FW_NORMAL;
    }
#endif
 
    if (Param->StrictSearch)
    {
        /*
         * Find whether this is an exact match.
         */
 
        /* If looking for a particular family, skip non-matches */
        if ((SearchFont->Family != 0) &&
            ((BYTE)SearchFont->Family != (lplf->lfPitchAndFamily & 0xF0)))
        {
            /* Continue enumeration */
            return TRUE;
        }
 
        /* Skip non-matching sizes */
#if 0
        if ((FontInfo[i].SizeWant.Y != Size.Y) &&
            !SIZE_EQUAL(FontInfo[i].Size, Size))
#endif
        if ((lplf->lfHeight != SearchFont->Size.Y) &&
            !(lplf->lfWidth == SearchFont->Size.X &&
              lplf->lfHeight == SearchFont->Size.Y))
        {
            /* Continue enumeration */
            return TRUE;
        }
 
        /* Skip non-matching weights */
        if ((SearchFont->Weight != 0) &&
            (SearchFont->Weight != lplf->lfWeight))
        {
            /* Continue enumeration */
            return TRUE;
        }
 
        /* NOTE: We are making the font enumeration at fixed CharSet,
         * with the one specified in the parameter block. */
        ASSERT(lplf->lfCharSet == SearchFont->CharSet);
 
        if ((FontType != TRUETYPE_FONTTYPE) && // !TM_IS_TT_FONT(lpntm->tmPitchAndFamily)
            (lplf->lfCharSet != SearchFont->CharSet) &&
            !(lplf->lfCharSet == OEM_CHARSET && IsCJKCodePage(Param->CodePage))) // g_fEastAsianSystem
        {
            /* Continue enumeration */
            return TRUE;
        }
 
        /*
         * Size (and maybe family) match. If we don't care about the name or
         * if it matches, use this font. Otherwise, if name doesn't match and
         * it is a raster font, consider it.
         *
         * NOTE: The font face names are case-sensitive.
         */
        if (!SearchFont->FaceName || !*(SearchFont->FaceName) ||
            (wcscmp(lplf->lfFaceName, SearchFont->FaceName) == 0) ||
            (wcscmp(lplf->lfFaceName, Param->AltFaceName) == 0))
        {
            // FontIndex = i;
 
            PFONT_DATA CandidateFont = &Param->CandidateFont;
 
            CandidateFont->FaceName = Param->CandidateFaceName;
            StringCchCopyNW(Param->CandidateFaceName,
                            ARRAYSIZE(Param->CandidateFaceName),
                            lplf->lfFaceName, ARRAYSIZE(lplf->lfFaceName));
 
            CandidateFont->Weight = lplf->lfWeight;
            CandidateFont->Family = (lplf->lfPitchAndFamily & 0xF0);
 
            CandidateFont->Size.X = lplf->lfWidth;
            CandidateFont->Size.Y = lplf->lfHeight;
 
            CandidateFont->CharSet = lplf->lfCharSet;
 
            /* The font is found, stop enumeration */
            Param->FontFound = TRUE;
            return FALSE;
        }
        else if (FontType != TRUETYPE_FONTTYPE) // !TM_IS_TT_FONT(lpntm->tmPitchAndFamily)
        {
            // FontIndex = i;
 
            PFONT_DATA CandidateFont = &Param->CandidateFont;
 
            CandidateFont->FaceName = Param->CandidateFaceName;
            StringCchCopyNW(Param->CandidateFaceName,
                            ARRAYSIZE(Param->CandidateFaceName),
                            lplf->lfFaceName, ARRAYSIZE(lplf->lfFaceName));
 
            CandidateFont->Weight = lplf->lfWeight;
            CandidateFont->Family = (lplf->lfPitchAndFamily & 0xF0);
 
            CandidateFont->Size.X = lplf->lfWidth;
            CandidateFont->Size.Y = lplf->lfHeight;
 
            CandidateFont->CharSet = lplf->lfCharSet;
 
            /* A close Raster Font fit was found; only the name doesn't match.
             * Continue enumeration to see whether we can find better. */
            Param->FontFound = TRUE;
        }
    }
    else // !Param->StrictSearch
    {
        /*
         * Failed to find exact match, even after enumeration, so now
         * try to find a font of same family and same size or bigger.
         */
 
        if (IsCJKCodePage(Param->CodePage)) // g_fEastAsianSystem
        {
            if ((SearchFont->Family != 0) &&
                ((BYTE)SearchFont->Family != (lplf->lfPitchAndFamily & 0xF0)))
            {
                /* Continue enumeration */
                return TRUE;
            }
 
            if ((FontType != TRUETYPE_FONTTYPE) && // !TM_IS_TT_FONT(lpntm->tmPitchAndFamily)
                (lplf->lfCharSet != SearchFont->CharSet))
            {
                /* Continue enumeration */
                return TRUE;
            }
        }
        else
        {
            if (// (SearchFont->Family != 0) &&
                ((BYTE)SearchFont->Family != (lplf->lfPitchAndFamily & 0xF0)))
            {
                /* Continue enumeration */
                return TRUE;
            }
        }
 
        if ((lplf->lfHeight >= SearchFont->Size.Y) &&
            (lplf->lfWidth  >= SearchFont->Size.X))
        {
            /* Same family, size >= desired */
            // FontIndex = i;
 
            PFONT_DATA CandidateFont = &Param->CandidateFont;
 
            CandidateFont->FaceName = Param->CandidateFaceName;
            StringCchCopyNW(Param->CandidateFaceName,
                            ARRAYSIZE(Param->CandidateFaceName),
                            lplf->lfFaceName, ARRAYSIZE(lplf->lfFaceName));
 
            CandidateFont->Weight = lplf->lfWeight;
            CandidateFont->Family = (lplf->lfPitchAndFamily & 0xF0);
 
            CandidateFont->Size.X = lplf->lfWidth;
            CandidateFont->Size.Y = lplf->lfHeight;
 
            CandidateFont->CharSet = lplf->lfCharSet;
 
            /* The font is found, stop enumeration */
            Param->FontFound = TRUE;
            return FALSE;
        }
    }
 
    /* Continue enumeration */
    return TRUE;
}

Referenced by FindSuitableFont().

InitTTFontCache()

VOID InitTTFontCache

(

VOID

)

Initializes the console TrueType font cache.

Remarks

To install additional TrueType fonts to be available for the console, add entries of type REG_SZ named "0", "00" etc... in: HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Console\TrueTypeFont The names of the fonts listed there should match those in: HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Fonts

Returns

None.

Definition at line 1013 of file font.c.

{
    LRESULT lResult;
    HKEY hKey;
    DWORD dwIndex, dwType;
    WCHAR szValueName[MAX_PATH];
    DWORD cchValueName;
    WCHAR szValue[LF_FACESIZE] = L"";
    DWORD cbValue;
    UINT CodePage;
    PTT_FONT_ENTRY FontEntry;
    PWCHAR pszNext;
 
    if (TTFontCache.Next != NULL)
        return;
    // TTFontCache.Next = NULL;
 
    /* Open the Console\TrueTypeFont key */
    // "\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Console\\TrueTypeFont"
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                      L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Console\\TrueTypeFont",
                      0,
                      KEY_QUERY_VALUE,
                      &hKey) != ERROR_SUCCESS)
    {
        return;
    }
 
    /* Enumerate all the available TrueType console fonts */
    for (dwIndex = 0, cchValueName = ARRAYSIZE(szValueName),
                      cbValue = sizeof(szValue);
         (lResult = RegEnumValueW(hKey, dwIndex,
                                  szValueName, &cchValueName,
                                  NULL, &dwType,
                                  (PBYTE)szValue, &cbValue)) != ERROR_NO_MORE_ITEMS;
         ++dwIndex, cchValueName = ARRAYSIZE(szValueName),
                    cbValue = sizeof(szValue))
    {
        /* Ignore if we failed for another reason, e.g. because
         * the value name is too long (and thus, invalid). */
        if (lResult != ERROR_SUCCESS)
            continue;
 
        /* Validate the value name (exclude the unnamed value) */
        if (!cchValueName || (*szValueName == UNICODE_NULL))
            continue;
        /* Too large value names have already been handled with ERROR_MORE_DATA */
        ASSERT((cchValueName < ARRAYSIZE(szValueName)) &&
               (szValueName[cchValueName] == UNICODE_NULL));
 
        /* Only (multi-)string values are supported */
        if ((dwType != REG_SZ) && (dwType != REG_MULTI_SZ))
            continue;
 
        /* The value name is a code page (in decimal), validate it */
        CodePage = wcstoul(szValueName, &pszNext, 10);
        if (*pszNext)
            continue; // Non-numerical garbage followed...
        // IsValidCodePage(CodePage);
 
        FontEntry = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*FontEntry));
        if (!FontEntry)
        {
            DBGFNT1("InitTTFontCache: Failed to allocate memory, continuing...\n");
            continue;
        }
 
        FontEntry->CodePage = CodePage;
 
        pszNext = szValue;
 
        /* Check whether bold is disabled for this font */
        if (*pszNext == BOLD_MARK)
        {
            FontEntry->DisableBold = TRUE;
            ++pszNext;
        }
        else
        {
            FontEntry->DisableBold = FALSE;
        }
 
        /* Copy the font name */
        StringCchCopyNW(FontEntry->FaceName, ARRAYSIZE(FontEntry->FaceName),
                        pszNext, wcslen(pszNext));
 
        if (dwType == REG_MULTI_SZ)
        {
            /* There may be an alternate face name as the second string */
            pszNext += wcslen(pszNext) + 1;
 
            /* Check whether bold is disabled for this font */
            if (*pszNext == BOLD_MARK)
            {
                FontEntry->DisableBold = TRUE;
                ++pszNext;
            }
            // else, keep the original setting.
 
            /* Copy the alternate font name */
            StringCchCopyNW(FontEntry->FaceNameAlt, ARRAYSIZE(FontEntry->FaceNameAlt),
                            pszNext, wcslen(pszNext));
        }
 
        PushEntryList(&TTFontCache, &FontEntry->Entry);
    }
 
    /* Close the key and quit */
    RegCloseKey(hKey);
}

Referenced by GuiInit(), InitApplet(), and RefreshTTFontCache().

IsValidConsoleFont()

BOOL IsValidConsoleFont	(	_In_ PCWSTR	FaceName,
		_In_ UINT	CodePage
	)

Validates whether a given font can be supported in the console, under the specified code page.

Parameters

[in]	FaceName	The face name of the font to validate.
[in]	CodePage	The code page the font has to support.

Returns

TRUE if the font is valid and supported in the console, FALSE if not.

See also

IsValidConsoleFont2()

Definition at line 974 of file font.c.

{
    IS_VALID_CONSOLE_FONT_PARAM Param;
    HDC hDC;
    LOGFONTW lf;
 
    Param.IsValidFont = FALSE;
    Param.CodePage = CodePage;
 
    RtlZeroMemory(&lf, sizeof(lf));
    lf.lfCharSet = CodePageToCharSet(CodePage);
    // lf.lfPitchAndFamily = FIXED_PITCH | FF_MODERN;
    StringCchCopyW(lf.lfFaceName, ARRAYSIZE(lf.lfFaceName), FaceName);
 
    hDC = GetDC(NULL);
    EnumFontFamiliesExW(hDC, &lf, (FONTENUMPROCW)IsValidConsoleFontProc, (LPARAM)&Param, 0);
    ReleaseDC(NULL, hDC);
 
    return Param.IsValidFont;
}

Referenced by CreateConsoleFontWorker().

IsValidConsoleFont2()

BOOL IsValidConsoleFont2	(	_In_ PLOGFONTW	lplf,
		_In_ PNEWTEXTMETRICW	lpntm,
		_In_ DWORD	FontType,
		_In_ UINT	CodePage
	)

Validates whether a given font can be supported in the console, under the specified code page.

Parameters

[in]	lplf
[in]	lpntm
[in]	FontType	The GDI font characteristics of the font to validate.
[in]	CodePage	The code page the font has to support.

Returns

TRUE if the font is valid and supported in the console, FALSE if not.

Remarks

Equivalent of the font validation tests in FontEnumForV2Console() (or the more restrictive ones in FontEnum()) https://github.com/microsoft/terminal/blob/main/src/propsheet/misc.cpp#L465 https://github.com/microsoft/terminal/blob/main/src/propsheet/misc.cpp#L607

See also

IsValidConsoleFont()

Definition at line 782 of file font.c.

{
    LPCWSTR FaceName = lplf->lfFaceName;
 
    /*
     * According to: https://web.archive.org/web/20140901124501/http://support.microsoft.com/kb/247815
     * "Necessary criteria for fonts to be available in a command window",
     * the criteria for console-eligible fonts are as follows:
     * - The font must be a fixed-pitch font.
     * - The font cannot be an italic font.
     * - The font cannot have a negative A or C space.
     * - If it is a TrueType font, it must be FF_MODERN.
     * - If it is not a TrueType font, it must be OEM_CHARSET.
     *
     * Non documented: vertical fonts are forbidden (their name start with a '@').
     *
     * Additional criteria for Asian installations:
     * - If it is not a TrueType font, the face name must be "Terminal".
     * - If it is an Asian TrueType font, it must also be an Asian character set.
     *
     * See also Raymond Chen's blog: https://devblogs.microsoft.com/oldnewthing/?p=26843
     * and MIT-licensed Microsoft Terminal source code: https://github.com/microsoft/terminal/blob/main/src/propsheet/misc.cpp
     * for other details.
     *
     * To install additional TrueType fonts to be available for the console,
     * add entries of type REG_SZ named "0", "00" etc... in:
     * HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Console\TrueTypeFont
     * The names of the fonts listed there should match those in:
     * HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Fonts
     */
 
    /*
     * In ReactOS we relax some of the criteria:
     * - We allow fixed-pitch FF_MODERN (Monospace) TrueType fonts
     *   that can be italic or have negative A or C space.
     * - If it is not a TrueType font, it can be from another character set
     *   than OEM_CHARSET. When an Asian codepage is active however, we require
     *   that this non-TrueType font has an Asian character set.
     */
 
    /* Reject variable-width fonts ... */
    if ( ( ((lplf->lfPitchAndFamily & 0x03) != FIXED_PITCH)
#if 0 /* Reject italic and TrueType fonts with negative A or C space ... */
           || (lplf->lfItalic)
           || !(lpntm->ntmFlags & NTM_NONNEGATIVE_AC)
#endif
         ) &&
        /* ... if they are not in the list of additional TrueType fonts to include */
         !IsAdditionalTTFont(FaceName) )
    {
        DBGFNT("Font '%S' rejected because it%s (lfPitchAndFamily = %d)\n",
               FaceName,
               !(lplf->lfPitchAndFamily & FIXED_PITCH) ? "'s not FIXED_PITCH"
                   : (!(lpntm->ntmFlags & NTM_NONNEGATIVE_AC) ? " has negative A or C space"
                                                              : " is broken"),
               lplf->lfPitchAndFamily);
        return FALSE;
    }
 
    /* Reject TrueType fonts that are not FF_MODERN */
    if ((FontType == TRUETYPE_FONTTYPE) && ((lplf->lfPitchAndFamily & 0xF0) != FF_MODERN))
    {
        DBGFNT("TrueType font '%S' rejected because it's not FF_MODERN (lfPitchAndFamily = %d)\n",
               FaceName, lplf->lfPitchAndFamily);
        return FALSE;
    }
 
    /* Reject vertical fonts (tategaki) */
    if (FaceName[0] == L'@')
    {
        DBGFNT("Font '%S' rejected because it's vertical\n", FaceName);
        return FALSE;
    }
 
    /* Is the current code page Chinese, Japanese or Korean? */
    if (IsCJKCodePage(CodePage))
    {
        /* It's CJK */
 
        if (FontType == TRUETYPE_FONTTYPE)
        {
            /*
             * Here we are inclusive and check for any CJK character set,
             * instead of looking just at the current one via CodePageToCharSet().
             */
            if (!IsCJKCharSet(lplf->lfCharSet))
            {
                DBGFNT("TrueType font '%S' rejected because it's not Asian charset (lfCharSet = %d)\n",
                       FaceName, lplf->lfCharSet);
                return FALSE;
            }
 
            /*
             * If this is a cached TrueType font that is used only for certain
             * code pages, verify that the charset it claims is the correct one.
             *
             * Since there may be multiple entries for a cached TrueType font,
             * a general one (code page == 0) and one or more for explicit
             * code pages, we need to perform two search queries instead of
             * just one and retrieving the code page for this entry.
             */
            if (IsAdditionalTTFont(FaceName) && !IsAdditionalTTFontCP(FaceName, 0) &&
                !IsCJKCharSet(lplf->lfCharSet))
            {
                DBGFNT("Cached TrueType font '%S' rejected because it claims a code page that is not Asian charset (lfCharSet = %d)\n",
                       FaceName, lplf->lfCharSet);
                return FALSE;
            }
        }
        else
        {
            /* Reject non-TrueType fonts that do not have an Asian character set */
            if (!IsCJKCharSet(lplf->lfCharSet) && (lplf->lfCharSet != OEM_CHARSET))
            {
                DBGFNT("Non-TrueType font '%S' rejected because it's not Asian charset or OEM_CHARSET (lfCharSet = %d)\n",
                       FaceName, lplf->lfCharSet);
                return FALSE;
            }
 
            /* Reject non-TrueType fonts that are not Terminal */
            if (wcscmp(FaceName, TERMINAL_FACENAME) != 0)
            {
                DBGFNT("Non-TrueType font '%S' rejected because it's not 'Terminal'\n", FaceName);
                return FALSE;
            }
        }
    }
    else
    {
        /* Not CJK */
 
        /* Reject non-TrueType fonts that are not OEM or similar */
        if ((FontType != TRUETYPE_FONTTYPE) &&
            (lplf->lfCharSet != ANSI_CHARSET) &&
            (lplf->lfCharSet != DEFAULT_CHARSET) &&
            (lplf->lfCharSet != OEM_CHARSET))
        {
            DBGFNT("Non-TrueType font '%S' rejected because it's not ANSI_CHARSET or DEFAULT_CHARSET or OEM_CHARSET (lfCharSet = %d)\n",
                   FaceName, lplf->lfCharSet);
            return FALSE;
        }
    }
 
    /* All good */
    return TRUE;
}

Referenced by EnumFaceNamesProc(), FindSuitableFontProc(), and IsValidConsoleFontProc().

IsValidConsoleFontProc()

static BOOL CALLBACK IsValidConsoleFontProc ( _In_ PLOGFONTW  lplf, _In_ PNEWTEXTMETRICW  lpntm, _In_ DWORD  FontType, _In_ LPARAM  lParam  )

static

EnumFontFamiliesEx() callback helper for IsValidConsoleFont().

Definition at line 943 of file font.c.

{
    PIS_VALID_CONSOLE_FONT_PARAM Param = (PIS_VALID_CONSOLE_FONT_PARAM)lParam;
    Param->IsValidFont = IsValidConsoleFont2(lplf, lpntm, FontType, Param->CodePage);
 
    /* Stop the enumeration now */
    return FALSE;
}

Referenced by IsValidConsoleFont().

RefreshTTFontCache()

VOID RefreshTTFontCache

(

VOID

)

Refreshes the console TrueType font cache, by clearing and re-initializing it.

Returns

None.

Definition at line 1153 of file font.c.

{
    ClearTTFontCache();
    InitTTFontCache();
}

Referenced by GuiApplyUserSettings().

Variable Documentation

TTFontCache

SINGLE_LIST_ENTRY TTFontCache = { NULL }

Definition at line 32 of file font.c.

Referenced by ClearTTFontCache(), FindCachedTTFont(), and InitTTFontCache().