windows-xp/Source/XPSP1/NT/shell/shell32/piffnt.c

/*
 *  Microsoft Confidential
 *  Copyright (C) Microsoft Corporation 1991
 *  All Rights Reserved.
 *
 *
 *  PIFFNT.C
 *  User interface dialogs for GROUP_FNT
 *
 *  History:
 *  Created 04-Jan-1993 1:10pm by Jeff Parsons
 *  Changed 05-May-1993 5:10pm by Raymond Chen -- New Chicago-look preview
 *  Changed 12-Aug-1993 4:14pm by Raymond Chen -- Remove font inc and dec
 *
 *  All font dialog code taken from font*.c in vmdosapp, 01-Apr-93
 */

#include "shellprv.h"
#pragma hdrstop

#define REGSTR_MSDOSEMU_DISPLAYPARAMS TEXT("DisplayParams")

#define REGSTR_PATH_MSDOSEMU "Software\\Microsoft\\Windows\\CurrentVersion\\MS-DOS Emulation"

const TCHAR szWndPreviewClass[] = TEXT("WOAWinPreview");
const TCHAR szFontPreviewClass[] = TEXT("WOAFontPreview");

// The preview strings for bilingual dosbox. 
// We'll load this from our resource that will be properly
// localized. We'll give up if it fails and use above sample
// instead.

UINT cxScreen, cyScreen, dyChar, dyItem;

// Macro definitions that handle codepages 
//
#define OEMCharsetFromCP(cp) \
    ((cp)==CP_JPN? SHIFTJIS_CHARSET : ((cp)==CP_WANSUNG? HANGEUL_CHARSET : OEM_CHARSET))
/*
 * Font cache information.  Note that this cache, being in PIFMGR,
 * is now global, which will make support for per-VM font files/faces
 * more problematic, if we even decide that's an interesting feature.
 *
 */
DWORD   bpfdiStart[2] =  {  0  };    /* strage for the offset to cache */
UINT    cfdiCache[2];                   /* # used entries in fdi cache */
UINT    cfdiCacheActual[2];             /* Total # entries in fdi cache */
LPVOID lpCache = NULL;


/*
 * Owner-draw list box information.
 *
 */
HBITMAP hbmFont;                        /* Handle to "TrueType" logo */
DWORD   dwTimeCheck;
COLORREF clrChecksum;

HCURSOR hcursorWait;

#define MAXDIMENSTRING 80

/*
 * Initial font heights for TT fonts
 *
 * This is read from an INI file, so it must remain writeable.
 *
 * We don't try generating TT fonts below 12pt by default because
 * they just look crappy.  Frosting setup will put a different
 * table into place because Lucida Console looks good down to 4pt.
 *
 * On NT, Lucida Console is installed be default, though.
 *
 * The Frosting table is
 *      4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 22
 */
WORD rgwInitialTtHeights[] = { 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 22 };



/*
 * rgpnlPenalties -- Initialize penalty array to default values
 */
INT rgpnlPenalties[] =
        { 5000, 1000, 0, 1000, 5000, 1000, 0, 1000, 1 };


POINT ptNonAspectMin = { -1, -1 };

// Context-sensitive help ids

const static DWORD rgdwHelp[] = {
    IDC_FONTGRP,            IDH_COMM_GROUPBOX,
    IDC_RASTERFONTS,        IDH_DOS_AVAIL_FONTS,
    IDC_TTFONTS,            IDH_DOS_AVAIL_FONTS,
    IDC_BOTHFONTS,          IDH_DOS_AVAIL_FONTS,
    IDC_FONTSIZELBL,        IDH_DOS_FONT_SIZE,
    IDC_FONTSIZE,           IDH_DOS_FONT_SIZE,
    IDC_WNDPREVIEWLBL,      IDH_DOS_FONT_WINDOW_PREVIEW,
    IDC_FONTPREVIEWLBL,     IDH_DOS_FONT_FONT_PREVIEW,
    IDC_WNDPREVIEW,         IDH_DOS_FONT_WINDOW_PREVIEW,
    IDC_FONTPREVIEW,        IDH_DOS_FONT_FONT_PREVIEW,
    IDC_REALMODEDISABLE,    IDH_DOS_REALMODEPROPS,
    0, 0
};


BOOL_PTR CALLBACK DlgFntProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    PFNTINFO pfi = (PFNTINFO)GetWindowLongPtr(hDlg, DWLP_USER);

    switch (uMsg) 
    {
    case WM_INITDIALOG:
        // allocate dialog instance data
        if (NULL != (pfi = (PFNTINFO)LocalAlloc(LPTR, sizeof(FNTINFO)))) 
        {
            pfi->ppl = (PPROPLINK)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtr(hDlg, DWLP_USER, (LPARAM)pfi);
            InitFntDlg(hDlg, pfi);
            break;
        }
        else
        {
            EndDialog(hDlg, FALSE);     // fail the dialog create
        }
        break;

    case WM_DESTROY:
        // free any allocations/resources inside the pfi first!
        if (pfi) 
        {
            if (pfi->hFontPreview)
            {
                DeleteObject(pfi->hFontPreview);
                pfi->hFontPreview = NULL;
            }
            // ok, NOW we can free the pfi
            EVAL(LocalFree(pfi) == NULL);
            SetWindowLongPtr(hDlg, DWLP_USER, 0);
        }
        break;

    HELP_CASES(rgdwHelp)                // Handle help messages

    case WM_COMMAND:
        if (LOWORD(lParam) == 0)
            break;                      // message not from a control

        switch (LOWORD(wParam))
        {
        case IDC_RASTERFONTS:
        case IDC_TTFONTS:
        case IDC_BOTHFONTS:

            /*
             * Rebuild the font list based on the user's selection of
             * which fonts to include/exclude.
             */
            pfi->fntProposed.flFnt &= ~FNT_BOTHFONTS;
            pfi->fntProposed.flFnt |= FNTFLAGSFROMID(wParam);
            CreateFontList(GetDlgItem(hDlg, IDC_FONTSIZE), TRUE, &pfi->fntProposed);
            PreviewUpdate(GetDlgItem(hDlg, IDC_FONTSIZE), pfi);

            if (HIWORD(wParam) == BN_CLICKED)
                SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0L);

            return FALSE;

        case IDC_FONTSIZE:

            if (HIWORD(wParam) == LBN_SELCHANGE)
            {
                PreviewUpdate(GetDlgItem(hDlg, IDC_FONTSIZE), pfi);
                SendMessage(GetParent(hDlg), PSM_CHANGED, (WPARAM)hDlg, 0L);
                return TRUE;
            }
            if (HIWORD(wParam) == LBN_DBLCLK)
                ApplyFntDlg(hDlg, pfi);

            return FALSE;
        }
        break;

    case WM_NOTIFY:
        switch (((NMHDR *)lParam)->code) {
        case PSN_SETACTIVE:
            AdjustRealModeControls(pfi->ppl, hDlg);
            break;

        case PSN_KILLACTIVE:
            // This gives the current page a chance to validate itself
            // SetWindowLong(hDlg, DWL_MSGRESULT, ValidFntDlg(hDlg, pfi));
            break;

        case PSN_APPLY:
            // This happens on OK....
            ApplyFntDlg(hDlg, pfi);
            break;

        case PSN_RESET:
            // This happens on Cancel....
            break;
        }
        break;

    /*
     *  For WM_MEASUREITEM and WM_DRAWITEM, since there is only one
     *  owner-draw list box in the entire dialog box, we don't have
     *  to do a GetDlgItem to figure out who he is.
     */

    case WM_MEASUREITEM:
        // measure the owner draw listbox
        MeasureItemFontList((LPMEASUREITEMSTRUCT)lParam);
        break;

    case WM_DRAWITEM:
        DrawItemFontList(TRUE, (LPDRAWITEMSTRUCT)lParam);
        break;

    case WM_SYSCOLORCHANGE:
        UpdateTTBitmap();
        break;

    default:
        return FALSE;                   // return 0 when not processing
    }
    return TRUE;
}


/** InitFntDlg
 *
 *  Create the list of appropriate fonts.
 *
 *  This routine is broken out of FontDlgProc because it chew
 *  up lots of stack for the message buffer, and we don't want to
 *  eat that much stack on every entry to FontDlgProc.
 *
 *  Note that we must defer CreateFontList until WM_INITDIALOG
 *  time because it is not until then that we have a list box that
 *  we can shove the data into.
 */

void InitFntDlg(HWND hDlg, register PFNTINFO pfi)
{
    HWND hwndList;              /* The listbox of fonts */
    PPROPLINK ppl = pfi->ppl;
    WINDOWPLACEMENT wp;

    ASSERTTRUE(ppl->iSig == PROP_SIG);

    if (!PifMgr_GetProperties(ppl, MAKELP(0,GROUP_FNT),
                        &pfi->fntProposed, sizeof(pfi->fntProposed), GETPROPS_NONE)
        ||
        !PifMgr_GetProperties(ppl, MAKELP(0,GROUP_WIN),
                        &pfi->winOriginal, sizeof(pfi->winOriginal), GETPROPS_NONE)) {
        Warning(hDlg, IDS_QUERY_ERROR, MB_ICONEXCLAMATION | MB_OK);
        return;
    }

    /*
     * Set up instance variables for the window preview window.
     */
     
    /* Show preview maximized if window is maximized or restores to max'd.
     * Also if it is open restored and has no scrollbars.
     * (Determined by comparing the client window size against the cell
     * size and font size.)
     */

    pfi->fMax = FALSE;

    /*
     * Preload winOriginal with up-to-the-minute goodies, if we have
     * them.
     */

#define HasScrollbars(z) \
    (pfi->winOriginal.c##z##Cells * pfi->fntProposed.c##z##FontActual > \
     pfi->winOriginal.c##z##Client)

    if (ppl->hwndTty) {
        wp.length = sizeof(WINDOWPLACEMENT);
        VERIFYTRUE(GetWindowPlacement(ppl->hwndTty, &wp));

        // Convert/Copy to 16-bit structure
        pfi->winOriginal.wLength          = (WORD)wp.length;
        pfi->winOriginal.wShowFlags       = (WORD)wp.flags;
        pfi->winOriginal.wShowCmd         = (WORD)wp.showCmd;
        pfi->winOriginal.xMinimize        = (WORD)wp.ptMinPosition.x;
        pfi->winOriginal.yMinimize        = (WORD)wp.ptMinPosition.y;
        pfi->winOriginal.xMaximize        = (WORD)wp.ptMaxPosition.x;
        pfi->winOriginal.yMaximize        = (WORD)wp.ptMaxPosition.y;
        pfi->winOriginal.rcNormal.left    = (WORD)wp.rcNormalPosition.left;
        pfi->winOriginal.rcNormal.top     = (WORD)wp.rcNormalPosition.top;
        pfi->winOriginal.rcNormal.right   = (WORD)wp.rcNormalPosition.right;
        pfi->winOriginal.rcNormal.bottom  = (WORD)wp.rcNormalPosition.bottom;

        if (!IsIconic(ppl->hwndTty) &&
                !HasScrollbars(x) && !HasScrollbars(y)) {
            pfi->fMax = TRUE;
        }
    }

    if ((pfi->winOriginal.wShowCmd == SW_SHOWMAXIMIZED) ||
        (pfi->winOriginal.wShowFlags & WPF_RESTORETOMAXIMIZED)) {
        pfi->fMax = TRUE;
    }

    if (pfi->winOriginal.wShowCmd == SW_SHOWMAXIMIZED) {
        pfi->ptCorner.x = (LONG)pfi->winOriginal.xMaximize;
        pfi->ptCorner.y = (LONG)pfi->winOriginal.yMaximize;
    } else {
        if (pfi->winOriginal.rcNormal.left==0)
        {
            pfi->ptCorner.x = -1;
        }
        else
        {
            pfi->ptCorner.x = (LONG)pfi->winOriginal.rcNormal.left;
        }
        pfi->ptCorner.y = (LONG)pfi->winOriginal.rcNormal.top;
    }

    /*
     * First, check which fonts the user wants to see.
     *
     */
    CheckDlgButton(hDlg, IDFROMFNTFLAGS(pfi->fntProposed.flFnt), TRUE);

    hwndList = GetDlgItem(hDlg, IDC_FONTSIZE);
    // SendMessage(hwndList, WM_SETFONT, (WPARAM)GetStockObject(SYSTEM_FIXED_FONT), FALSE);

    if (CreateFontList(hwndList, TRUE, &pfi->fntProposed) == LB_ERR) {
        MemoryWarning(hDlg);
        EndDialog(hDlg, PtrToLong(BPFDI_CANCEL));    /* Get out of the dialog */
        return;
    }

    /* Initialize the preview windows */
    PreviewInit(hDlg, pfi);
    PreviewUpdate(GetDlgItem(hDlg, IDC_FONTSIZE), pfi);
}


void ApplyFntDlg(HWND hDlg, register PFNTINFO pfi)
{
    PPROPLINK ppl = pfi->ppl;

    ASSERTTRUE(ppl->iSig == PROP_SIG);

    if (!PifMgr_SetProperties(ppl, MAKELP(0,GROUP_FNT),
                        &pfi->fntProposed, sizeof(pfi->fntProposed), SETPROPS_NONE))
        Warning(hDlg, IDS_UPDATE_ERROR, MB_ICONEXCLAMATION | MB_OK);
    else
    if (ppl->hwndNotify) {
        ppl->flProp |= PROP_NOTIFY;
        PostMessage(ppl->hwndNotify, ppl->uMsgNotify, sizeof(pfi->fntProposed), (LPARAM)MAKELP(0,GROUP_FNT));
    }
}

/*
 * Retrieves the name of the font to use for true-type DOS box
 * in a window given a registry tree root.
 *
 * Entry:
 *
 * hkRoot      -> registry tree root to search
 * pszFaceSbcs -> LF_FACESIZE buffer for SBCS font
 * pszFaceDbcs -> LF_FACESIZE buffer for DBCS font (may be null)
 *
 * Exit:
 *
 * Buffers filled with new font names, or left unchanged if nothing
 * found in registry.
 *
 */

#define REGSTR_MSDOSEMU_FONT "Font"
#define REGSTR_MSDOSEMU_FONTDBCS "FontDBCS"

void GetDosBoxTtFontsHkA(HKEY hkRoot, LPSTR pszFaceSbcs, LPSTR pszFaceDbcs)
{
    static CHAR const szMsdosemu[] = REGSTR_PATH_MSDOSEMU;
    HKEY hk;
    DWORD cb;

    if (RegOpenKeyExA(hkRoot, szMsdosemu, 0, KEY_READ, &hk) == ERROR_SUCCESS)
    {
        static CHAR const szFont[] = REGSTR_MSDOSEMU_FONT;
        cb = LF_FACESIZE;
        RegQueryValueExA(hk, szFont, 0, 0, (LPBYTE)pszFaceSbcs, &cb);

        if (pszFaceDbcs)
        {
            static CHAR const szDbcsFont[] = REGSTR_MSDOSEMU_FONTDBCS;
            cb = LF_FACESIZE;
            RegQueryValueExA(hk, szDbcsFont, 0, 0, (LPBYTE)pszFaceDbcs, &cb);
        }
        RegCloseKey(hk);
    }
}

/*
 * Retrieves the name of the font to use for true-type DOS box
 * in a window.
 *
 * This routine consults the appropriate registry keys.
 *
 * The DOS box font comes first from HKLM, to establish  a
 * machine-wide default, but can in turn be overridden by
 * HKCU for each user to override.
 *
 * Entry:
 *
 * pszFaceSbcs -> LF_FACESIZE buffer for SBCS font
 * pszFaceDbcs -> LF_FACESIZE buffer for DBCS font (may be null)
 *
 * Exit:
 *
 * Buffers filled with new font names, or left unchange if nothing
 * found in registry.
 *
 */

void CoolGetDosBoxTtFontsA(LPSTR pszFaceSbcs, LPSTR pszFaceDbcs)
{
    GetDosBoxTtFontsHkA(HKEY_LOCAL_MACHINE, pszFaceSbcs, pszFaceDbcs);
    GetDosBoxTtFontsHkA(HKEY_CURRENT_USER, pszFaceSbcs, pszFaceDbcs);
}

/** BroadcastFontChange
 *
 *  HACK! for MS PowerPoint 4.0.  These wallys, for some reason, will go
 *  off and eat up reams of CPU time if they receive a WM_FONTCHANGE
 *  message that was *posted*.  But if the message is *sent*, they do
 *  the right thing.  The puzzling thing is that they never call
 *  InSendMessage(), so how do they know?  What's more, why do they care?
 *  This was true in 3.1 also.  What's their problem?
 *
 *  The problem is that sending a broadcast risks deadlock city; see the
 *  various hacks in winoldap for places where DDE broadcasting is bypassed.
 *  In addition, since BroadcastFontChange is also called during the WEP,
 *  multi-threaded apps will deadlock if we SendMessage back to a window
 *  on a different thread in the app, because Kernel takes a process
 *  critical section during DLL unload.
 *
 *  So if PowerPig is running, we just don't tell anybody that we dorked
 *  with the fonts.
 *
 *  Returns:
 *
 *      None.
 *
 */

void BroadcastFontChange(void)
{
    if (!GetModuleHandle(szPP4)) {
        PostMessage(HWND_BROADCAST, WM_FONTCHANGE, 0, 0L);
    }
}

/** LoadGlobalFontData
 *
 *  Get the name of the DOS box raster font and load it.
 *
 *  Get the name of the TT font.  (CheckDisplayParameters needs this.)
 *
 *  Check the display parameters.
 *
 *  Initialize the fdi cache.  The cache remains in GlobalLock'd
 *  memory throughout its lifetime.  This is not a problem because
 *  we are guaranteed to be in protected mode.
 *
 *  We also load things necessary for the font combo/list boxes.
 *
 *  And compute the height of the owner-draw list box item.
 *
 *  Returns:
 *
 *      TRUE on success.  In which case the FDI cache and hbmFont
 *      are ready to use.
 *
 *      FALSE on failure.  In which case there is insufficient memory
 *      to complete the operation.
 */

typedef void (WINAPI *LPFNGDBTF)(LPTSTR, LPTSTR); /* GetDosBoxTtFonts */

BOOL LoadGlobalFontData(void)
{
    HDC hDC;
    TEXTMETRIC tm;
    TCHAR szBuffer[MAXPATHNAME];

    cxScreen = GetSystemMetrics(SM_CXSCREEN);
    cyScreen = GetSystemMetrics(SM_CYSCREEN);

    /*
     * Get the system char size and save it away for later use.
     */
    hDC = GetDC(NULL);
    SelectObject(hDC, GetStockObject(SYSTEM_FONT));
    GetTextMetrics(hDC, &tm);
    ReleaseDC(NULL, hDC);

    dyChar = tm.tmHeight + tm.tmExternalLeading;
    dyItem = max(tm.tmHeight, DY_TTBITMAP);

    /*
     * Chicago's AddFontResource looks in the FONTS directory first, which
     * is great because it saves us the trouble of doing goofy disk access
     * optimizations.
     */
    GetPrivateProfileString(sz386EnhSection, szWOAFontKey,
                            c_szNULL, szBuffer, ARRAYSIZE(szBuffer), szSystemINI);
    if (szBuffer[0] && AddFontResource(szBuffer)) {
        BroadcastFontChange();
    }

    /*
     * Add DBCS native font if it is present.
     */
    GetPrivateProfileString(sz386EnhSection, szWOADBCSFontKey,
                            c_szNULL, szBuffer, ARRAYSIZE(szBuffer), szSystemINI);
    if (szBuffer[0] && AddFontResource(szBuffer)) {
        BroadcastFontChange();
    }

    /*
     * Load default TT font name(s) and TT cache section names from resource
     */
    LoadStringA(g_hinst, IDS_TTFACENAME_SBCS, szTTFaceName[0], ARRAYSIZE(szTTFaceName[0]));
    LoadString(g_hinst,IDS_TTCACHESEC_SBCS, szTTCacheSection[0], ARRAYSIZE(szTTCacheSection[0]));

    if (IsBilingualCP(g_uCodePage))
    {
        LoadStringA(g_hinst, IDS_TTFACENAME_DBCS, szTTFaceName[1], ARRAYSIZE(szTTFaceName[1]));
        LoadString(g_hinst, IDS_TTCACHESEC_DBCS, szTTCacheSection[1], ARRAYSIZE(szTTCacheSection[1]));
    }        

    CoolGetDosBoxTtFontsA(szTTFaceName[0], szTTFaceName[1]);

    CheckDisplayParameters();

    // alloc needed # of cache
    //
    lpCache = (LPVOID)LocalAlloc(LPTR,
                    FDI_TABLE_START * sizeof(FONTDIMENINFO) * (IsBilingualCP(g_uCodePage)? 2:1));
                         
    if (!lpCache)
        return FALSE;

    hcursorWait = LoadCursor(NULL, IDC_WAIT);

    UpdateTTBitmap();
    if (!hbmFont)
        goto E0;

    // set initial value of # of cache entries which depends on whether we have
    // two codepage to handle
    //
    cfdiCacheActual[0] = FDI_TABLE_START;

    if (IsBilingualCP(g_uCodePage))
    {
        cfdiCacheActual[1] = FDI_TABLE_START;
        bpfdiStart[1] += FDI_TABLE_START;
    }

    FontSelInit();

    return TRUE;

E0: 
    EVAL(LocalFree(lpCache) == NULL);

    return FALSE;
}



void FreeGlobalFontData()
{
    TCHAR szBuffer[MAXPATHNAME] = {0};

    if (hbmFont)
        DeleteObject(hbmFont);

    EVAL(LocalFree(lpCache) == NULL);



    GetPrivateProfileString(sz386EnhSection, szWOAFontKey,
                            c_szNULL, szBuffer, ARRAYSIZE(szBuffer), szSystemINI);
    if (*szBuffer) {
        if (RemoveFontResource(szBuffer)) {
            BroadcastFontChange();
        }
    }
    GetPrivateProfileString(sz386EnhSection, szWOADBCSFontKey,
                            c_szNULL, szBuffer, ARRAYSIZE(szBuffer), szSystemINI);
    if (*szBuffer) {
        if (RemoveFontResource(szBuffer)) {
            BroadcastFontChange();
        }
    }
}


BOOL LoadGlobalFontEditData()
{
    WNDCLASS wc;

    // Set up the window preview class for piffnt.c

    wc.style         = 0L;
    wc.lpfnWndProc   = WndPreviewWndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = sizeof(PFNTINFO);
    wc.hInstance     = g_hinst;
    wc.hIcon         = NULL;
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = szWndPreviewClass;

    // Don't go through RegisterClassD because we manually unregister
    // this class ourselves.
    if (!RealRegisterClass(&wc))
        return FALSE;

    // Set up the font preview class for piffnt.c

    wc.style         = 0L;
    wc.lpfnWndProc   = FontPreviewWndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = sizeof(PFNTINFO);
    wc.hInstance     = g_hinst;
    wc.hIcon         = NULL;
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = GetStockObject(BLACK_BRUSH);
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = szFontPreviewClass;

    // Don't go through RegisterClassD because we manually unregister
    // this class ourselves.
    if (!RealRegisterClass(&wc))
        return FALSE;

    return TRUE;
}


void FreeGlobalFontEditData()
{
    UnregisterClass(szWndPreviewClass, g_hinst);
    UnregisterClass(szFontPreviewClass, g_hinst);
}


/*
 *  Make sure that the display parameters have not changed, including
 *  the name of the TT font(s).
 *
 *  If they have, we BLAST OUR CACHE since it is no longer any good.
 *
 *  Entry:
 *      szTTFaceName contains the name of the TrueType font to use.
 *
 *  Returns:
 *      None.
 */

void CheckDisplayParameters(void)
{
    HDC         hIC;
    HKEY        hk;
    DISPLAYPARAMETERS dpTrue, dpStored;

    hIC = CreateIC(szDisplay, 0, 0, 0);

    if (!hIC) {
        /*
         * If things are really screwy, stay conservative and assume
         * that all is well.
         */
        return;
    }

    dpTrue.dpHorzSize   = GetDeviceCaps(hIC, HORZSIZE);
    dpTrue.dpVertSize   = GetDeviceCaps(hIC, VERTSIZE);
    dpTrue.dpHorzRes    = GetDeviceCaps(hIC, HORZRES);
    dpTrue.dpVertRes    = GetDeviceCaps(hIC, VERTRES);
    dpTrue.dpLogPixelsX = GetDeviceCaps(hIC, LOGPIXELSX);
    dpTrue.dpLogPixelsY = GetDeviceCaps(hIC, LOGPIXELSY);
    dpTrue.dpAspectX    = GetDeviceCaps(hIC, ASPECTX);
    dpTrue.dpAspectY    = GetDeviceCaps(hIC, ASPECTY);
    dpTrue.dpBitsPerPixel = GetDeviceCaps(hIC, BITSPIXEL);
    DeleteDC(hIC);

    /*
     *  Since szTTFaceName is pre-initialized to "Courier New" padded
     *  with nulls, we can rely on the garbage after the end of the
     *  string always to be the same, so that a pure memory comparison
     *  will work.
     */
    MultiByteToWideChar(CP_ACP, 0, szTTFaceName[0], -1, dpTrue.szTTFace[0], ARRAYSIZE(dpTrue.szTTFace[0]));
    if (IsBilingualCP(g_uCodePage))
        MultiByteToWideChar(CP_ACP, 0, szTTFaceName[1], -1, dpTrue.szTTFace[1], ARRAYSIZE(dpTrue.szTTFace[1]));

    /*
     *  We must store the dimension information in the registry because
     *  the install program for Omar Sharif Bridge will ERASE! your
     *  SYSTEM.INI if it contains a line greater than 78 characters.
     *  (I am not making this up.  How could I?)
     */

    if (RegCreateKey(HKEY_LOCAL_MACHINE, TEXT(REGSTR_PATH_MSDOSEMU), &hk) == 0) {
        DWORD cb = sizeof(DISPLAYPARAMETERS);
        if (SHQueryValueEx(hk, REGSTR_MSDOSEMU_DISPLAYPARAMS, 0, 0, (LPVOID)&dpStored, &cb) != 0 || cb != sizeof(DISPLAYPARAMETERS) || IsBufferDifferent(&dpTrue, &dpStored, sizeof(DISPLAYPARAMETERS))) {
            /*
             * Not much we can do if the write fails, so don't check.
             */
            VERIFYTRUE(RegSetValueEx(hk, REGSTR_MSDOSEMU_DISPLAYPARAMS, 0, REG_BINARY, (LPVOID)&dpTrue, cb) == 0);

            /* Blast the font dimension cache */
            WritePrivateProfileString(szTTCacheSection[1], NULL, NULL, szSystemINI);
            if (IsBilingualCP(g_uCodePage))
                WritePrivateProfileString(szTTCacheSection[0], NULL, NULL, szSystemINI);
        }
        VERIFYTRUE(RegCloseKey(hk) == 0);
    } else {
        /*
         *  Couldn't access registry.  Oh well.
         */
    }

}

/*
 *  When the dialog box is created, we create the Window
 *  Preview child window, as well as the Font Preview window.
 *
 *  The creation is deferred until the actual dialog box creation
 *  because the size and shape of the Window Preview window depends
 *  on the current video driver.
 */

void PreviewInit(HWND hDlg, PFNTINFO pfi)
{
    HWND hwnd;
    RECT rectLabel, rcPreview;

    /*
     * Compute the size of our preview window.
     *
     *  The top is aligned with the top of IDC_WNDPREVIEWLBL,
     *          minus a top margin of 3/2 dyChar.
     *  The left edge is aligned with the left edge of IDC_WNDPREVIEWLBL.
     *  The maximum width is the width of IDC_WNDPREVIEWLBL.
     *  The bottom edge can go as far down as the bottom of the dialog,
     *          minus a bottom margin of 3/2 dyChar.
     *  And the shape of the preview window is determined by the screen
     *          dimensions.
     *
     * We make the preview window as large as possible, given these
     * constraints.
     *
     */
    GetWindowRect(GetDlgItem(hDlg, IDC_WNDPREVIEWLBL), &rectLabel);
    ScreenToClient(hDlg, (LPPOINT)&rectLabel);
    ScreenToClient(hDlg, (LPPOINT)&rectLabel.right);

    /*
     * This GetWindowRect/ScreenToClient sets rcPreview.top.
     */
    GetWindowRect(GetDlgItem(hDlg, IDC_WNDPREVIEWLBL), &rcPreview);
    ScreenToClient(hDlg, (LPPOINT)&rcPreview);

    /*
     * Compute height based on width.
     */
    rcPreview.top += 3 * dyChar / 2;
    rcPreview.left = rectLabel.left;
    rcPreview.right = rectLabel.right - rectLabel.left;
    rcPreview.bottom = AspectScale(cyScreen, cxScreen, rcPreview.right);

    /*
     * Phew.  Now we can create the preview window.
     */
    hwnd = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        szWndPreviewClass, NULL,
        WS_CHILD | WS_VISIBLE,
        rcPreview.left, rcPreview.top,
        rcPreview.right, rcPreview.bottom,
        hDlg, (HMENU)IDC_WNDPREVIEW, g_hinst, NULL);

    if (hwnd)
        SetWindowLongPtr(hwnd, 0, (LONG_PTR)pfi);

    /*
     * Compute the size of the font preview.  This is easier.
     */
    GetWindowRect(GetDlgItem(hDlg, IDC_FONTPREVIEWLBL), &rectLabel);
    ScreenToClient(hDlg, (LPPOINT)&rectLabel.left);
    ScreenToClient(hDlg, (LPPOINT)&rectLabel.right);

    hwnd = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        szFontPreviewClass, NULL,
        WS_CHILD | WS_VISIBLE,
        rectLabel.left,
        rectLabel.top + 3 * dyChar / 2,
        rectLabel.right - rectLabel.left,
        rcPreview.bottom,
        hDlg, (HMENU)IDC_FONTPREVIEW, g_hinst, NULL);

    if (hwnd)
        SetWindowLongPtr(hwnd, 0, (LONG_PTR)pfi);
}


/*  PreviewUpdate
 *
 *  Does the preview of the selected font.
 */

void PreviewUpdate(HWND hwndList, PFNTINFO pfi)
{
    HWND hDlg;
    BPFDI bpfdi;

    /* Delete the old font if necessary */
    if (pfi->hFontPreview)
    {
        DeleteObject(pfi->hFontPreview);
        pfi->hFontPreview = NULL;
    }

    /* When we select a font, we do the font preview by setting it
     * into the appropriate list box
     */
    bpfdi = (BPFDI)GetFont(hwndList, TRUE, pfi);
    if (IsSpecialBpfdi(bpfdi))
        return;

    /* Update our internal font structure so that preview window
     * will actually change
     */
    pfi->bpfdi = bpfdi;
    SetFont(&pfi->fntProposed, bpfdi);

    /* Make the new font */
    pfi->hFontPreview = CreateFontFromBpfdi(bpfdi, pfi);

    /* Force the preview windows to repaint */
    hDlg = GetParent(hwndList);
    InvalidateRect(GetDlgItem(hDlg, IDC_WNDPREVIEW), NULL, TRUE);
    InvalidateRect(GetDlgItem(hDlg, IDC_FONTPREVIEW), NULL, TRUE);
}


/*  WndPreviewWndProc
 *
 *  Handles the window preview window.
 */

LRESULT WndPreviewWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case WM_PAINT:
        WndPreviewPaint(GetParent(hwnd), hwnd);
        break;

    case WM_HELP:       // Handles title bar help button message
        WinHelp(hwnd, NULL, HELP_CONTEXTPOPUP, IDH_DOS_FONT_WINDOW_PREVIEW);
        break;

    case WM_RBUTTONUP:
    case WM_NCRBUTTONUP: // Equivalent of WM_CONTEXTMENU
        OnWmContextMenu((WPARAM)hwnd, &rgdwHelp[0]);
        break;

    default:
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }

    return 0;
}

/*  Swiped from Control Panel / Metrics.
 *
 *  Draws the frame *and* modifies the rectangle to contain the
 *  shrunk coordinates.
 */
void _DrawFrame(HDC hdc, int clr, LPRECT lprc, int cx, int cy)
{
    HBRUSH hbr;
    RECT rcT;

    CopyRect(&rcT, lprc);
    hbr = SelectObject(hdc, GetSysColorBrush(clr));

    /* Left */
    PatBlt(hdc, rcT.left, rcT.top, cx, rcT.bottom-rcT.top, PATCOPY);
    rcT.left += cx;

    /* Top */
    PatBlt(hdc, rcT.left, rcT.top, rcT.right-rcT.left, cy, PATCOPY);
    rcT.top += cy;

    /* Right */
    rcT.right -= cx;
    PatBlt(hdc, rcT.right, rcT.top, cx, rcT.bottom-rcT.top, PATCOPY);

    /* Bottom */
    rcT.bottom -= cy;
    PatBlt(hdc, rcT.left, rcT.bottom, rcT.right-rcT.left, cy, PATCOPY);

    SelectObject(hdc, hbr);
    CopyRect(lprc, &rcT);
}


/*  WndPreviewPaint
 *
 *  Paints the window preview window.  This is called from its
 *  paint message handler.
 *
 */

void WndPreviewPaint(HWND hDlg, HWND hwnd)
{
    PPROPLINK ppl;
    PFNTINFO pfi;
    RECT rcPreview;
    RECT rcWin;
    RECT rcClient;
    RECT rcT;
    POINT ptButton;
#define cxButton    ptButton.x
#define cyButton    ptButton.y
    POINT ptCorner;
    POINT ptFrame;
#define cxFrame    ptFrame.x
#define cyFrame    ptFrame.y
    BPFDI bpfdi;
    int cxBorder, cyBorder;
    int dyToolbar;
    PAINTSTRUCT ps;
    BOOL bCenter;

    BeginPaint(hwnd, &ps);

    pfi = (PFNTINFO)GetWindowLongPtr(hwnd, 0);

    ppl = pfi->ppl;
    ASSERTTRUE(ppl->iSig == PROP_SIG);

    bpfdi = pfi->bpfdi;

    /* If we don't have a font, get out */
    if (!pfi->hFontPreview)
        return;

    /* Get the width of the preview "screen" */
    GetClientRect(hwnd, &rcPreview);

    /* Figure out how large we would be as a result of the change.
     * This isn't perfect, but it'll probably be close enough.
     * (Imperfection if we chose AUTO as the font.)
     */

    /* Assume maximized */
    rcClient.left = rcClient.top = 0;
    if (pfi->winOriginal.cxCells) {
        rcClient.right = pfi->winOriginal.cxCells * bpfdi->fdiWidthActual;
    } else {
        rcClient.right = 80 * bpfdi->fdiWidthActual;
    }

    if (pfi->winOriginal.cyCells) {
        rcClient.bottom = pfi->winOriginal.cyCells * bpfdi->fdiHeightActual;
    } else {
        PROPVID vid;

        // set default value
        rcClient.bottom = 25 * bpfdi->fdiHeightActual;

        // now see if there is a value in the pif file for size of window...
        if (PifMgr_GetProperties(ppl, MAKELP(0,GROUP_VID),
                        &vid, sizeof(vid), GETPROPS_NONE))
        {
            if (vid.cScreenLines > 0)
                rcClient.bottom = vid.cScreenLines * bpfdi->fdiHeightActual;

        }
    }
    if (!pfi->fMax && pfi->winOriginal.cxClient && pfi->winOriginal.cyClient) {
        /* Shrink down to window actual */
        if (rcClient.right > (int)pfi->winOriginal.cxClient)
            rcClient.right = (int)pfi->winOriginal.cxClient;
        if (rcClient.bottom > (int)pfi->winOriginal.cyClient)
            rcClient.bottom = (int)pfi->winOriginal.cyClient;
    }

    /* Get some more metrics */
    cxBorder = GetSystemMetrics(SM_CXBORDER);
    cyBorder = GetSystemMetrics(SM_CYBORDER);

    cxButton = GetSystemMetrics(SM_CXSIZE);
    cyButton = GetSystemMetrics(SM_CYSIZE);
//  cyButton *= 2;                      /* Double the height for "looks" */

    cxFrame = GetSystemMetrics(SM_CXFRAME);
    cyFrame = GetSystemMetrics(SM_CYFRAME);

    /* FLAG DAY!  Convert everything from desktop coordinates to
     * aspect ratio-scaled preview coordinates
     *
     * Do **not** convert cxBorder and cyBorder!
     *
     * ptCorner must not be modified in-place since its value is used at
     * the next go-round.
     *
     * After translation, cxFrame and cyFrame are adjusted so that the
     * cxBorder counts against them.  This allows for users who set
     * really wide frames, but doesn't penalize the users who have
     * narrow frames.
     */

    ptCorner = pfi->ptCorner;
    bCenter = (ptCorner.x == -1);
    AspectPoint(&rcPreview, &ptCorner);
    AspectPoint(&rcPreview, &ptFrame);
    AspectRect(&rcPreview, &rcClient);
    AspectPoint(&rcPreview, &ptButton);

    /*
     * The height of a toolbar is hard-coded at 30 pixels.
     */
    if (pfi->winOriginal.flWin & WIN_TOOLBAR) {
        dyToolbar = (int)AspectScale(rcPreview.bottom, cyScreen, 30);
    } else {
        dyToolbar = 0;
    }

    /* Make sure the buttons are nonzero in dimension */
    if (cxButton == 0) cxButton = 1;
    if (cyButton == 0) cyButton = 1;

    /*
     * Don't penalize people who have thin frames.
     */
    if (cxFrame < cxBorder) cxFrame = cxBorder;
    if (cyFrame < cyBorder) cyFrame = cyBorder;

    /*
     * Convert from client rectangle back to window rectangle.
     *
     * We must do this *AFTER* the flag day, because we need to use the
     * post-flag day cxBorder and cyBorder.
     */

    /* Put a (scaled-down) toolbar into place.  We'll expand the client
     * region to accomodate it.  (We'll subtract the toolbar off before
     * painting the client region.)
     */
    rcClient.bottom += dyToolbar;

    /* Shove the client region down to make room for the caption. */
    OffsetRect(&rcClient, 0, cyButton);

    rcWin = rcClient;
    rcWin.top = 0;
    InflateRect(&rcWin, cxFrame, cyFrame);

    /*
     * Now put it in the proper position on the (shrunk-down) desktop.
     * We cannot do this until rcWin's value is finalized.
     */
    if (bCenter)
    {
        ptCorner.x = ((rcPreview.right - rcPreview.left) -
                       (rcWin.right  - rcWin.left)
                     ) / 2;
        if (ptCorner.x < 0)
            ptCorner.x = 0;

        ptCorner.y = ((rcPreview.bottom - rcPreview.top) -
                       (rcWin.bottom  - rcWin.top)
                     ) / 5;
        if (ptCorner.y < 0)
            ptCorner.y = 0;

    }
    OffsetRect(&rcWin, ptCorner.x, ptCorner.y);
    OffsetRect(&rcClient, ptCorner.x, ptCorner.y);

    /* It's party time! */

    /* The outer border */
    DrawEdge(ps.hdc, &rcWin, BDR_RAISEDINNER, BF_RECT | BF_ADJUST);

    /* The sizing frame */
    _DrawFrame(ps.hdc, COLOR_ACTIVEBORDER,
                    &rcWin, cxFrame - cxBorder, cyFrame - cyBorder);

    /* rcWin has now shrunk to its inner edge */

    /* Move its bottom edge upwards to meet the top of the client region.
     * This turns rcWin into the caption area.
     */
    rcWin.bottom = rcClient.top;
    FillRect(ps.hdc, &rcWin, (HBRUSH)(COLOR_ACTIVECAPTION+1));

    /* Next comes the toolbar */
    rcT= rcClient;
    rcT.bottom = rcT.top + dyToolbar;
    FillRect(ps.hdc, &rcT, (HBRUSH)(COLOR_BTNFACE+1));

    /* Next, draw the client region */
    rcClient.top += dyToolbar;
    DrawEdge(ps.hdc, &rcClient, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
    FillRect(ps.hdc, &rcClient, (HBRUSH)GetStockObject(BLACK_BRUSH));

    /*
     * Now draw the three caption buttons.
     */

    /*
     * The system menu.
     */
    rcT = rcWin;
    rcT.right = rcT.left + cxButton;
  //DrawFrameControl(ps.hdc, &rcT, DFC_SYSMENU, DFCS_SYSMENUMAIN);
    DrawFrameControl(ps.hdc, &rcT, DFC_CAPTION, DFCS_CAPTIONCLOSE);

    /*
     * The maximize menu.
     */
    rcWin.left = rcWin.right - cxButton;
  //DrawFrameControl(ps.hdc, &rcWin, DFC_SIZE, DFCS_SIZEMAX);
    DrawFrameControl(ps.hdc, &rcWin, DFC_CAPTION, DFCS_CAPTIONMAX);

    /*
     * The minimize menu.
     */
    rcWin.left -= cxButton;
    rcWin.right -= cxButton;
  //DrawFrameControl(ps.hdc, &rcWin, DFC_SIZE, DFCS_SIZEMIN);
    DrawFrameControl(ps.hdc, &rcWin, DFC_CAPTION, DFCS_CAPTIONMIN);

    EndPaint(hwnd, &ps);
}
#undef cxButton
#undef cyButton

#undef cxFrame
#undef cyFrame

LRESULT FontPreviewWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    RECT rect;
    PFNTINFO pfi;
    PAINTSTRUCT ps;

    switch (uMsg)
    {
    case WM_PAINT:
        BeginPaint(hwnd, &ps);

        pfi = (PFNTINFO)GetWindowLongPtr(hwnd, 0);

        /* Draw the font sample */
        SelectObject(ps.hdc, pfi->hFontPreview);
        SetTextColor(ps.hdc, RGB(192, 192, 192));
        SetBkColor(ps.hdc, RGB(0, 0, 0));
        GetClientRect(hwnd, &rect);
        InflateRect(&rect, -2, -2);

        {
            TCHAR szPreviewText[300];
            LoadString(g_hinst, IsBilingualCP(pfi->fntProposed.wCurrentCP) ? IDS_PREVIEWTEXT_BILNG : IDS_PREVIEWTEXT, szPreviewText, ARRAYSIZE(szPreviewText));
            // load a sample for their native codepage
            DrawText(ps.hdc, szPreviewText, -1, &rect, 0);
        }

        EndPaint(hwnd, &ps);
        break;

    case WM_HELP:       // Handles title bar help button message
        WinHelp(hwnd, NULL, HELP_CONTEXTPOPUP, IDH_DOS_FONT_FONT_PREVIEW);
        break;

    case WM_RBUTTONUP:
    case WM_NCRBUTTONUP: // Equivalent of WM_CONTEXTMENU
        OnWmContextMenu((WPARAM)hwnd, &rgdwHelp[0]);
        break;

    default:
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }

    return 0;
}


/*
 *  Loads the dialog control hwndList with all available font
 *  dimensions for raster fonts, and a selected collection of
 *  dimensions for TrueType fonts.
 *
 *  The reference data for each control is an index into lpfniCache.
 *
 *  The hourglass cursor is displayed during the font list build.
 *
 *  Entry:
 *      hwndList == handle to listbox or combo box to fill
 *      fListBox == TRUE if hwndList is a listbox, FALSE if a combo box
 *      lpFnt    -> PROPFNT structure
 *
 *      If HIWORD(lpFnt) is NULL, then LOWORD(lpFnt) is used as an hProps
 *      to get obtain property info for that handle.
 *
 *  Returns:
 *      >= 0 on success, indicating the current selection.
 *      In which case the FDI cache is valid and hwndList has been filled
 *      with font information, and the currently-selected font has been
 *      made the current selection.
 *
 *      LB_ERR/CB_ERR on failure.  The list box hwndList is left in an
 *      indeterminate state.
 */

int WINAPI CreateFontList(HWND hwndList, BOOL fListBox, LPPROPFNT lpFnt)
{
    DWORD   dwIndex;
    HCURSOR hcursor;
    PROPFNT fntTemp;
    int     iReturn = LB_ERR;
    TCHAR   szBuf[MAXDIMENSTRING];

    if (IS_INTRESOURCE(lpFnt))
    {
        if (!PifMgr_GetProperties(lpFnt, MAKELP(0,GROUP_FNT),
                           &fntTemp, sizeof(fntTemp), GETPROPS_NONE))
            goto Exit2;

        lpFnt = &fntTemp;
    }

    /*
     * Put up an hourglass while the font list build is taking place,
     * since it might take a long time if we have to re-rasterize
     * TrueType fonts.
     *
     * NOTE!  That we do not do a ShowCursor.  Why?
     *
     *  If the user is on a mouseless system, then he can't access his
     *  toolbar, and hence the only time this code can get called is
     *  during the creation of the font selection dialog box.  In which
     *  case, DialogBox has already done a ShowCursor for us.
     *
     */
    hcursor = SetCursor(hcursorWait);

    /*
     * Initialize the list box.
     */
    if (hwndList) {
        SendMessage(hwndList, WM_SETREDRAW, FALSE, 0L);
        SendMessage(hwndList, fListBox ? LB_RESETCONTENT : CB_RESETCONTENT, 0, 0L);
    }

    /*
     * Add the fonts.
     */
    if ((lpFnt->flFnt & FNT_RASTERFONTS) &&
        !AddRasterFontsToFontListA(hwndList, fListBox,
                                  lpFnt->achRasterFaceName, lpFnt->wCurrentCP))
        goto Exit;

    if ((lpFnt->flFnt & FNT_TTFONTS) &&
        !AddTrueTypeFontsToFontListA(hwndList, fListBox,
                                  lpFnt->achTTFaceName, lpFnt->wCurrentCP))
        goto Exit;

    /*
     * And the magical "Auto" font size.
     */

    /*
     * Beyond this point, success is assured, so at the very least,
     * DON'T return LB_ERR;  we may optionally set the return code to
     * the current selection, below, too...
     */
    iReturn = 0;

    if (hwndList) {
        /*
         * No error checking here because if anything fails, then the
         * end result will be merely that the "Auto" option either
         * (1) exists but is invisible, or (2) doesn't appear at all.
         */
        LoadString(g_hinst, IDS_AUTO, szBuf, ARRAYSIZE(szBuf));
        dwIndex = lcbInsertString(hwndList, fListBox, szBuf, 0);
        lcbSetItemDataPair(hwndList, fListBox, dwIndex, BPFDI_AUTO, 0);

        /*
         * Make yet another pass through the list to find the current
         * font and select it.  Thanks to an intentional flakiness
         * in USER, we can't do this check at the point that the
         * font is added, because the selection does not move with the
         * item when a new item is inserted above the selection.
         *
         * Bleah.
         */
        if (!MatchCurrentFont(hwndList, fListBox, lpFnt)) {
            /*
             * If no font matched the current font, and we are a list box,
             * then make the first font the current selection.
             *
             * We don't want to make any default selection if we are a
             * combo box, because that would make the user think that the
             * current font was something it wasn't.
             */
            if (fListBox) {
                /*
                 * SORTING-SENSITIVE!  This assumes that "Auto" is at the top
                 * of the list.
                 */
                lcbSetCurSel(hwndList, TRUE, 0);
                lpFnt->flFnt |= FNT_AUTOSIZE;
            }
        }
        SendMessage(hwndList, WM_SETREDRAW, TRUE, 0L);

        iReturn = lcbGetCurSel(hwndList, fListBox);
    }
Exit:
    /*
     * Reset the mouse cursor.
     */
    SetCursor(hcursor);

Exit2:
    return iReturn;
}


/** UpdateTTBitmap
 *
 *  Recompute the colors for the TrueType bitmap hbmFont.
 *
 *  Since we may receive this several times for a single WM_SYSCOLORCHANGE,
 *  we update our colors under the following conditions:
 *
 *      1. More than one second has elapsed since the previous call, or
 *      2. A crude checksum fails.
 *
 *  Entry:
 *      None.
 *
 *  Returns:
 *      hbmFont recomputed.
 */

VOID WINAPI UpdateTTBitmap(void)
{
    COLORREF clr;

    /*
     *  Note that the checksum should not be a symmetric function,
     *  because a common color alteration is to exchange or permute
     *  the colors.
     */
    clr = +  GetSysColor(COLOR_BTNTEXT)
          -  GetSysColor(COLOR_BTNSHADOW)
          + (GetSysColor(COLOR_BTNFACE) ^ 1)
          - (GetSysColor(COLOR_BTNHIGHLIGHT) ^ 2)
          ^  GetSysColor(COLOR_WINDOW);

    if (!hbmFont || clr != clrChecksum || GetTickCount() - dwTimeCheck < 1000) {
        clrChecksum = clr;
        dwTimeCheck = GetTickCount();
        if (hbmFont) DeleteObject(hbmFont);
        hbmFont = CreateMappedBitmap(g_hinst, IDB_TTBITMAP, 0, NULL, 0);
    }
}


/** DrawItemFontList
 *
 *  Answer the WM_DRAWITEM message sent from the font list box or
 *  font combo box.
 *
 *  This code was originally lifted from FONT.C in sdk\commdlg.
 *
 *  See fontutil.h for an explanation of the \1 hack.
 *
 *  Entry:
 *      fListBox    =  TRUE if the item is a list box, FALSE if a combo box
 *      lpdis       -> DRAWITEMSTRUCT describing object to be drawn
 *
 *  Returns:
 *      None.
 *
 *      The object is drawn.
 */

#define cTabsList 3

typedef struct DIFLINFO {
    LPTSTR       di_lpsz;
    PINT        di_pTabs;
} DIFLINFO, *LPDIFLINFO;

#define lpdi ((LPDIFLINFO)lp)
BOOL CALLBACK diflGrayStringProc(HDC hdc, LPARAM lp, int cch)
{
    return (BOOL)TabbedTextOut(hdc, 0, 0,
                  lpdi->di_lpsz, lstrlen(lpdi->di_lpsz),
                  cTabsList, lpdi->di_pTabs, 0);

}
#undef lpdi

VOID WINAPI DrawItemFontList(BOOL fListBox, const LPDRAWITEMSTRUCT lpdis)
{
    HDC     hDC, hdcMem;
    DWORD   rgbBack, rgbText;
    int     iColorBack;
    COLORREF clrText;
    COLORREF clrBack;
    TCHAR    szDimen[MAXDIMENSTRING];
    HBITMAP hOld;
    int     dy;
    DIFLINFO di;
    static int rgTabsList[cTabsList] = {0, 0, 0};
    static int rgTabsCombo[cTabsList] = {0, 0, 0};
#define lpsz di.di_lpsz
#define pTabs di.di_pTabs

    if ((int)lpdis->itemID < 0)
        return;

    hDC = lpdis->hDC;

    if (lpdis->itemAction & ODA_FOCUS) {
        if (lpdis->itemState & ODS_SELECTED) {
            DrawFocusRect(hDC, &lpdis->rcItem);
        }
    } else {
        if (lpdis->itemState & ODS_SELECTED) {
            clrBack = GetSysColor(iColorBack = COLOR_HIGHLIGHT);
            clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
        } else {
            clrBack = GetSysColor(iColorBack = COLOR_WINDOW);
            clrText = GetSysColor(IsWindowEnabled(lpdis->hwndItem) ?
                                        COLOR_WINDOWTEXT : COLOR_GRAYTEXT);
        }
        rgbText = SetTextColor(hDC, clrText);
        rgbBack = SetBkColor(hDC, clrBack);

        // draw selection background
        FillRect(hDC, &lpdis->rcItem, (HBRUSH)UIntToPtr((iColorBack + 1)));

        // get the string
        SendMessage(lpdis->hwndItem, fListBox ? LB_GETTEXT : CB_GETLBTEXT, lpdis->itemID, (LPARAM)(LPTSTR)szDimen);

        lpsz = szDimen;
        if (szDimen[0] == TEXT('\1'))   // hack for "Auto" string
            lpsz++;

        if (fListBox)
            pTabs = rgTabsList;
        else
            pTabs = rgTabsCombo;

        if (pTabs[0] == 0) {            /* Never seen this font before */
            /* Assumes GetTextExtent(hDC, ANSI_TIMES, 1) < 2 * dxChar */
            SIZE sSize;
            GetTextExtentPoint32(hDC, szZero, 1, &sSize); // size of '0'
            /* A negative # for tab stop right aligns the tabs... */
            pTabs[0] = -sSize.cx * 3;
            pTabs[1] = -sSize.cx * 5;
            pTabs[2] = -sSize.cx * 8;
        }

        // draw the text
        //
        // Note that the SDK dox for GrayString says that you can detect
        // whether GrayString is needed by saying
        //
        //      if (GetSysColor(COLOR_GRAYTEXT) == 0) {
        //          GrayString(...);
        //      } else {
        //          TextOut(...);
        //      }
        //
        // This is incorrect.  The correct test is the one below, which
        // also catches bad color combinations on color devices.
        //
        if (clrText == clrBack) {
            SetTextColor(hDC, GetSysColor(COLOR_WINDOWTEXT));
            GrayString(hDC, GetStockObject(GRAY_BRUSH), diflGrayStringProc ,
                       (LPARAM)(LPVOID)&di, 0,
                        lpdis->rcItem.left + DX_TTBITMAP,
                        lpdis->rcItem.top,
                        lpdis->rcItem.right - lpdis->rcItem.left - DX_TTBITMAP,
                        lpdis->rcItem.bottom - lpdis->rcItem.top);
        } else {
            TabbedTextOut(hDC, lpdis->rcItem.left + DX_TTBITMAP, lpdis->rcItem.top, lpsz, lstrlen(lpsz), cTabsList, pTabs, DX_TTBITMAP);
        }

        // and the bitmap if needed
        if (!IsSpecialBpfdi((BPFDI)lpdis->itemData))
        {
            if (((BPFDI)(lpdis->itemData))->bTT) {
                hdcMem = CreateCompatibleDC(hDC);
                if (hdcMem) {
                    hOld = SelectObject(hdcMem, hbmFont);

                    dy = ((lpdis->rcItem.bottom - lpdis->rcItem.top) - DY_TTBITMAP) / 2;

                    BitBlt(hDC, lpdis->rcItem.left, lpdis->rcItem.top + dy,
                        DX_TTBITMAP, DY_TTBITMAP, hdcMem, 0,
                        lpdis->itemState & ODS_SELECTED ? 0 : DY_TTBITMAP, SRCCOPY);

                    if (hOld)
                        SelectObject(hdcMem, hOld);
                    DeleteDC(hdcMem);
                }
            }
        }

        SetTextColor(hDC, rgbText);
        SetBkColor(hDC, rgbBack);

        if (lpdis->itemState & ODS_FOCUS) {
            DrawFocusRect(hDC, &lpdis->rcItem);
        }
    }
}
#undef lpsz
#undef pTabs


/** MeasureItemFontList
 *
 *  Answer the WM_MEASUREITEM message sent from the font list box or
 *  font combo box. shared between the toolbar combo box code and
 *  the font preview property sheet
 *
 *  Entry:
 *      lpmi -> LPMEASUREITEMSTRUCT describing object to be measured
 *
 *  Returns:
 *      TRUE.
 *
 *      lpmi->itemHeight filled with actual item height.
 */

LONG WINAPI MeasureItemFontList(LPMEASUREITEMSTRUCT lpmi)
{
    lpmi->itemHeight = dyItem;
    return TRUE;
}


/** GetItemFontInfo
 *
 *  Returns font information for the current selection in the given
 *  listbox/combobox.
 *
 *  Entry:
 *      hwndList == handle to listbox or combo box to fill
 *                  if NULL, then AUTO is assumed
 *      fListBox == TRUE if hwndList is a listbox, FALSE if a combo box
 *      hProps   == property handle
 *      lpFnt    -> PROPFNT structure (filled in upon return)
 *
 *  Returns:
 *      LB_ERR/CB_ERR on error, index of current selection otherwise
 */

int WINAPI GetItemFontInfo(HWND hwndList, BOOL fListBox, HANDLE hProps, LPPROPFNT lpFnt)
{
    DWORD_PTR dw;
    int index;

    /*
     * Get font defaults;  the nice thing about this call is that
     * it also takes care of calling ChooseBestFont if AUTOSIZE is set,
     * which means we can tell GetFont() to not bother.
     */
    PifMgr_GetProperties(hProps, MAKELP(0,GROUP_FNT),
                  lpFnt, sizeof(PROPFNT), GETPROPS_NONE);

    dw = GetFont(hwndList, fListBox, NULL);
    if (IsSpecialBpfdi((BPFDI)dw))
    {
        return 0;
    }

    index = ((BPFDI)dw)->Index;
    if (index == 0)
        lpFnt->flFnt |= FNT_AUTOSIZE;
    else if (index > 0)
        lpFnt->flFnt &= ~FNT_AUTOSIZE;

    /*
     * Fill the caller's PROPFNT structure with all the font goodies (if any)
     *
     * Note that this does nothing if we ended up picking the AUTO font.
     */
    SetFont(lpFnt, (BPFDI)dw);

    return index;
}


/** MatchCurrentFont
 *
 *  Locates the current font in the indicated list box and
 *  makes him the current selection.
 *
 *  If we are in auto-mode, then "Auto" is selected.
 *
 *  Entry:
 *      hwndList == handle to listbox or combo box
 *      fListBox == TRUE if hwndList is a listbox, FALSE if a combo box
 *      lpFnt    -> PROPFNT structure
 *
 *  Returns:
 *      TRUE if the current font was found and selected.
 */
BOOL WINAPI MatchCurrentFont(HWND hwndList, BOOL fListBox, LPPROPFNT lpFnt)
{
    BPFDI bpfdi;
    DWORD dwCount, dwIndex;
    BOOL  fCurFontIsTt = !!(lpFnt->flFnt & FNT_TT);

    if (lpFnt->flFnt & FNT_AUTOSIZE) {
        /*
         * SORTING-SENSITIVE!  This assumes that "Auto" is at the top
         * of the list.
         */
        lcbSetCurSel(hwndList, fListBox, 0);
        return TRUE;
    }
    dwCount = lcbGetCount(hwndList, fListBox);
    for (dwIndex = 0; dwIndex < dwCount; dwIndex++) {

        bpfdi = lcbGetBpfdi(hwndList, fListBox, dwIndex);

        if (!IsSpecialBpfdi(bpfdi)) {
            // bpfdi = (BPFDI)((DWORD)bpfdi + (DWORD)lpCache);
            if (bpfdi->fdiWidthActual  == lpFnt->cxFontActual &&
                bpfdi->fdiHeightActual == lpFnt->cyFontActual &&
                fCurFontIsTt == (bpfdi->fdiHeightReq != 0)) {

                    lcbSetCurSel(hwndList, fListBox, dwIndex);
                    return TRUE;
            }
        }
    }
    return FALSE;
}

/** AddRasterFontsToFontList
 *
 *  Enumerate the available dimensions for our OEM raster font
 *  and add them to the list or combo box.
 *
 *  Entry:
 *      hwndList        =  List box or combo box to fill with info
 *      fListBox        =  TRUE if hwndList is a listbox, FALSE if a combo box
 *      lpszRasterFaceName
 *
 *  Returns:
 *      TRUE if fonts were enumerated to completion.
 *      FALSE if enumeration failed.  (Out of memory.)
 *
 */
BOOL AddRasterFontsToFontListA(HWND hwndList, BOOL fListBox,
                                       LPCSTR lpszRasterFaceName, INT CodePage)
{
    HDC     hDC;
    BOOL    fSuccess;
    FNTENUMINFO FntEnum;

    hDC = GetDC(hwndList);
    if (!hDC) return FALSE;

    FntEnum.hwndList = hwndList;
    FntEnum.fListBox = fListBox;
    FntEnum.CodePage = CodePage;
    fSuccess = EnumFontFamiliesA(hDC,
                                lpszRasterFaceName,
                                (FONTENUMPROCA)RasterFontEnum,
                                (LPARAM)&FntEnum);
    ReleaseDC(hwndList, hDC);
    return TRUE;
}


/** RasterFontEnum
 *
 *  FONTENUMPROC for enumerating all available dimensions of the OEM
 *  raster font.
 *
 *  This routine is used to load the logical and physical font
 *  dimensions cache with information about raster fonts.
 *
 *  Entry:
 *      lpelf           \
 *      lpntm            > from EnumFonts (see SDK)
 *      nFontType       /
 *      hwndList        =  List box or combo box to fill with info
 *      fListBox        =  TRUE if hwndList is a listbox, FALSE if a combo box
 *
 *  Returns:
 *      TRUE to continue enumeration.
 *      FALSE to stop enumeration.  (Out of memory.)
 */

int CALLBACK RasterFontEnum(ENUMLOGFONTA *lpelf, NEWTEXTMETRICA *lpntm, int nFontType, LPARAM lParam)
{
#define fListBox  (((LPFNTENUMINFO)lParam)->fListBox)
#define hwndList  (((LPFNTENUMINFO)lParam)->hwndList)
#define CodePage (((LPFNTENUMINFO)lParam)->CodePage)
#define lpLogFont (&(lpelf->elfLogFont))

    /*
     * We only care about OEM fixed-pitch fonts.
     */
    if (lpLogFont->lfCharSet != OEMCharsetFromCP(CodePage)
        || (lpLogFont->lfPitchAndFamily & (TMPF_TRUETYPE | TMPF_FIXED_PITCH))
            != TMPF_FIXED_PITCH)
        return TRUE;

    return AddToFontListCache(hwndList,
                              fListBox,
                              0, 0,
                              lpLogFont->lfHeight,
                              lpLogFont->lfWidth,
                              CodePage) != BPFDI_CANCEL;
#undef lpLogFont
#undef fListBox
#undef hwndList
#undef CodePage
}

/** AddToFontListCache
 *
 *  Adds an entry to the font dimension information cache,
 *  growing the cache if necessary.
 *
 *  It also adds the entry to the indicated list box, provided
 *  the entry is not a duplicate.
 *
 *  Returns:
 *      BPFDI of the recently-added font, or BPFDI_CANCEL if out of memory.
 *
 *  Overview:
 *      (1) Grow the cache if necessary.
 *      (2) Add the information to the list/combo box.
 *      (3) Add the information to the cache.
 */
BPFDI AddToFontListCache(HWND hwndList,
                         BOOL fListBox,
                         UINT uHeightReq,
                         UINT uWidthReq,
                         UINT uHeightActual,
                         UINT uWidthActual,
                         UINT uCodePage)
{
    LPVOID  hCache;
    LONG_PTR lCacheSave;
    DWORD   dwIndex, ifdi;
    BPFDI   bpfdi;
    TCHAR   szBuf[MAXDIMENSTRING];
    int     idx;
    
    ASSERT(!((uHeightReq==0) && (uWidthReq==0) && (uHeightActual==0) && (uWidthActual==0)));
    /* Reject too-large fonts out of hand. */
    if (uHeightActual > MAX_FONT_HEIGHT) {
        return BPFDI_IGNORE;
    }

    /*
     * FIRST, determine whether this font entry has already been cached
     */

    // we maintain two set of cache entries in case we have two code page
    // to support
    // 
    idx = IsBilingualCP(uCodePage) ? 1 : 0; 
    
    for (ifdi = 0, bpfdi = (BPFDI)((DWORD_PTR)lpCache + bpfdiStart[idx]); ifdi < cfdiCache[idx]; ++ifdi, ++bpfdi)
    {
        if (bpfdi->fdiWidthReq == uWidthReq &&
            bpfdi->fdiHeightReq == uHeightReq &&
            bpfdi->fdiWidthActual == uWidthActual &&
            bpfdi->fdiHeightActual == uHeightActual)
                goto UpdateListCombo;
    }

    /*
     * Grow the cache if necessary.
     */
    if (cfdiCache[idx] >= cfdiCacheActual[idx]) {

        /*
         * save offset from beginning of cache
         */
        bpfdi = (BPFDI)((DWORD_PTR)bpfdi - (DWORD_PTR)lpCache);

        /*
         * save current lpCache value so can adjust entries in listbox
         * when we're done...
         */
        lCacheSave = (LONG_PTR)lpCache;
        hCache = LocalReAlloc(lpCache,
        (cfdiCacheActual[0] + cfdiCacheActual[1] + FDI_TABLE_INC) *
        sizeof(FONTDIMENINFO), LMEM_ZEROINIT|LMEM_MOVEABLE);
        if (!hCache)
            return BPFDI_CANCEL;
        lpCache = hCache;
        
        if (!idx && IsBilingualCP(g_uCodePage)) {
            /*
             * We need to shift 2nd cache before using expanded 1st chache
             */
            BPFDI bpfdi2;
            for (ifdi = cfdiCache[1],
                              bpfdi2 = (BPFDI)((DWORD_PTR)lpCache + bpfdiStart[1]) + ifdi - 1 + FDI_TABLE_INC ;
                                                  ifdi ; ifdi--, bpfdi2--) {
                *bpfdi2 = *(bpfdi2 - FDI_TABLE_INC);
            }
            bpfdiStart[1] += FDI_TABLE_INC;
        }
        /* restore bpfdi from saved offset */
        bpfdi = (BPFDI)((DWORD_PTR)lpCache + (DWORD_PTR)bpfdi);
        cfdiCacheActual[idx] += FDI_TABLE_INC;

        /*
         * Convert lCacheSave to an offset...
         */
        lCacheSave = (LONG_PTR)lpCache - lCacheSave;

        if (lCacheSave)
        {
            /*
             * Now, adjust each entry in the listbox to account for the new
             * relocated cache position..
             */

            dwIndex = lcbGetCount(hwndList, fListBox);
            for(ifdi = 0; ifdi < dwIndex; ifdi++)
            {
                LONG_PTR lBpfdi;

                lBpfdi = (LONG_PTR)lcbGetItemDataPair(hwndList, fListBox, ifdi);
                if (!IsSpecialBpfdi((BPFDI)lBpfdi))
                {
                    lBpfdi += lCacheSave;
                    lcbSetItemDataPair(hwndList, fListBox, ifdi, lBpfdi, ((BPFDI)lBpfdi)->bTT);
                }
            }
        }
    }

    /*
     * Now add the information to the cache.  All the casting on bpfdiCache
     * is just to inhibit a bogus compiler complaint.
     */
    bpfdi->fdiWidthReq  = uWidthReq;
    bpfdi->fdiHeightReq = uHeightReq;

    bpfdi->fdiWidthActual  = uWidthActual;
    bpfdi->fdiHeightActual = uHeightActual;

    cfdiCache[idx]++;

  UpdateListCombo:

    if (hwndList) {
        /*
         * Add the string to the list/combo box if it isn't there already.
         */
        wsprintf(szBuf, TEXT("\t%2d\tx\t%2d"), uWidthActual, uHeightActual);

        dwIndex = lcbFindStringExact(hwndList, fListBox, szBuf);

        if (IsDlgError(dwIndex)) {
            /*
             * Not already on the list.  Add it.
             */
            dwIndex = lcbAddString(hwndList, fListBox, szBuf);

            if (IsDlgError(dwIndex)) {
                return BPFDI_CANCEL;
            }
            lcbSetItemDataPair(hwndList, fListBox, dwIndex,
                               bpfdi, uHeightReq);
        }
    }
    return bpfdi;
}


/** AddTrueTypeFontsToFontListA
 *
 *  To avoid rasterizing all the fonts unnecessarily, we load the
 *  information from the szTTCacheSection font cache.
 *
 *  Note that the cache information is not validated!  We just
 *  assume that if the value is in the cache, it is valid.
 *
 *  Entry:
 *      hwndList        =  List box or combo box to fill with info
 *      fListBox        =  TRUE if hwndList is a listbox, FALSE if a combo box
 *      lpszTTFaceName
 *
 *  Returns:
 *      TRUE if fonts were enumerated to completion.
 *      FALSE if enumeration failed.  (Out of memory.)
 *
 *  Caveats:
 *      The ParseIniWords call assumes that the values were written
 *      by AddOneNewTrueTypeFontToFontList, who wrote them out so
 *      that a single call to ParseIniWords will read the height and
 *      width directly into a dwHeightWidth.
 *
 *      Similarly, the second ParseIniWords reads the item directly into
 *      a dwHeightWidth.
 */

BOOL AddTrueTypeFontsToFontListA(HWND hwndList, BOOL fListBox,
                                        LPSTR lpszTTFaceName, INT CodePage)
{
    LPTSTR  pszBuf;
    LPTSTR  pszBufNew;
    LPTSTR  psz;
    LPTSTR  lpszNext;
    DWORD   dwHWReq;
    DWORD   dwHWActual;
    BOOL    fSuccess;
    DWORD   cchBuf;
    DWORD   cchActual;
    int     i;
    int     idx = IsBilingualCP(CodePage) ? 1 : 0;
    
    /*
     * See if we can load everything out of the szTTCacheSection.
     *
     * There is no API to get the size of a profile string, so we
     * have to fake it by reading, reallocing, and reading again
     * until it all fits.
     *
     * The initial value of 1024 characters means that we can handle
     * up to 128 font sizes.  A comfortable number, we hope.
     */

    cchBuf = 1024;
    cchActual = 0;
    pszBufNew = (LPTSTR)LocalAlloc(LPTR, cchBuf*sizeof(TCHAR));

    while (pszBufNew) {
        pszBuf = pszBufNew;
        cchActual = GetPrivateProfileString(szTTCacheSection[idx], NULL,
                                         c_szNULL, pszBuf, cchBuf, szSystemINI);
        if (cchActual < cchBuf - 5) goto Okay;

        cchBuf += 512;
        pszBufNew = (LPTSTR)LocalReAlloc(pszBuf, cchBuf*sizeof(TCHAR), LMEM_MOVEABLE|LMEM_ZEROINIT);
    }

    /* Bleargh.  Too much stuff in the cache.  Punt it and start anew. */
    goto FreshStart;

Okay:

    fSuccess = FALSE;

    /*
     *  In the time between flushing the cache and reloading it here,
     *  a handful of fonts may have gotten added to the cache due to
     *  WinOldAp trying to realize the font it got back.  So consider the
     *  font cache decent if there are at least ten fonts in it.
     */
    if (cchActual >= 4 * 10) {

        /*
         * We found cache information.  Party away.
         */

        psz = pszBuf;
        while (*psz) {

            if (ParseIniWords(psz, (PWORD)&dwHWReq, 2, &lpszNext) != 2 ||
                GetIniWords(szTTCacheSection[idx], psz,
                            (PWORD)&dwHWActual, 2, szSystemINI) != 2) {
                /* Font cache looks bogus.  Start with a new one. */
                goto FreshStart;
            }

            if (AddToFontListCache(hwndList, fListBox,
                                   (UINT)HIWORD(dwHWReq),
                                   (UINT)LOWORD(dwHWReq),
                                   (UINT)HIWORD(dwHWActual),
                                   (UINT)LOWORD(dwHWActual),
                                   CodePage) == BPFDI_CANCEL)
                goto E0;
                
            psz = (LPTSTR)(lpszNext + 1);       /* Skip past the NUL */
        }

    }
    else
    {
FreshStart:
        /* Blast the old cache, just make sure we have a clean slate */
        WritePrivateProfileString(szTTCacheSection[idx], NULL, NULL, szSystemINI);

        /* No cache available.  Need to build one. */
        for (i = 0; i < NUMINITIALTTHEIGHTS; i++) 
        {
            if (rgwInitialTtHeights[i]) 
            {
                AddOneNewTrueTypeFontToFontListA(hwndList, fListBox,
                                                0, (UINT)rgwInitialTtHeights[i],
                                                lpszTTFaceName, CodePage);
            }
        }
    }

    fSuccess = TRUE;
E0:
    EVAL(LocalFree(pszBuf) == NULL);
    return fSuccess;
}


/*  Given height and width, synthesize a TrueType font with those
 *  dimensions and record the actual font height and width in
 *  the persistent font cache, as well as a FDI.
 *
 *  Entry:
 *      hwndList        =  List box or combo box to fill with info
 *      fListBox        =  TRUE if hwndList is a listbox, FALSE if a combo box
 *      wHeight         =  Desired font height
 *      wWidth          =  Desired font width (can be zero for "default")
 *      lpszTTFaceName
 *
 *  Returns:
 *      BPFDI of font dimension info, or BPFDI_CANCEL on failure.
 *
 *  Caveats:
 *      The wsprintf assumes that the fdiWidthReq and
 *      fdiHeightReq fields appear in the indicated order,
 *      because the values will be read into a dwHeightWidth later.
 *
 *      Similarly for the WriteIniWords.
 */

BPFDI AddOneNewTrueTypeFontToFontListA(HWND hwndList,
                                      BOOL fListBox,
                                      UINT uWidth, UINT uHeight,
                                      LPSTR lpszTTFaceName, INT CodePage)
{
    BPFDI   bpfdi;
    HDC     hDC;
    HFONT   hFont;
    SIZE    sSize;
    HFONT   hFontPrev;
    DWORD   dwHeightWidth;
    TCHAR   szBuf[MAXDIMENSTRING];

    int     idx;
    BYTE    bCharset;
    DWORD   fdwClipPrecision;

    bpfdi = BPFDI_CANCEL;

    hDC = GetDC(NULL);          /* Get a screen DC */
    if (!hDC) goto E0;
    
    // choose charset, clip precision based on codepage
    // 0xFE is a hack for japanese platform
    //
    bCharset = (CodePage == CP_JPN? 0xFE: OEMCharsetFromCP(CodePage));
    
    if (CodePage == CP_US)
        fdwClipPrecision = CLIP_DEFAULT_PRECIS|(g_uCodePage == CP_WANSUNG? CLIP_DFA_OVERRIDE: 0);
    else
        fdwClipPrecision = CLIP_DEFAULT_PRECIS;

    hFont = CreateFontA((INT)uHeight, (INT)uWidth, 0, 0, 0, 0, 0, 0,
               bCharset, OUT_TT_PRECIS,
               fdwClipPrecision, 0, FIXED_PITCH | FF_DONTCARE, lpszTTFaceName);
               
    if (!hFont) goto E1;

    hFontPrev = SelectObject(hDC, hFont);
    if (!hFontPrev) goto E2;

    if (GetTextExtentPoint32(hDC, szZero, 1, &sSize))
    {
        dwHeightWidth = (sSize.cy << 16) | (sSize.cx & 0x00FF);
    }
    else
    {
        dwHeightWidth = 0;
    }

    if (!dwHeightWidth) goto E3;

    if (IsBilingualCP(CodePage) && (HIWORD(dwHeightWidth)%2))
        goto E3;

    wsprintf(szBuf, TEXT("%d %d"), uWidth, uHeight);

    idx = IsBilingualCP(CodePage) ? 0 : 1;
    
    WriteIniWords(szTTCacheSection[idx], szBuf, (PWORD)&dwHeightWidth, 2, szSystemINI);

    bpfdi = AddToFontListCache(hwndList, fListBox, uHeight, uWidth,
                               (UINT)sSize.cy, (UINT)sSize.cx,
                               CodePage);

E3: SelectObject(hDC, hFontPrev);
E2: DeleteObject(hFont);
E1: ReleaseDC(0, hDC);
E0: return bpfdi;

}


/*  Returns the BPFDI corresponding to the currently selected font in
 *  the indicated list or combo box, or BPFDI_CANCEL on error.
 *
 *  Entry:
 *      hwndList == handle to listbox or combo box to fill
 *                  if NULL, then AUTO font calculation is assumed
 *      fListBox == TRUE if hwndList is a listbox, FALSE if a combo box
 *      pfi      -> FNTINFO structure
 *                  if pfi is NULL, then AUTO font calculation is ignored
 *  Returns:
 *      BPFDI of the current selection, or BPFDI_CANCEL on error.
 */
DWORD_PTR GetFont(HWND hwndList, BOOL fListBox, PFNTINFO pfi)
{
    DWORD dwIndex = 0;
    BPFDI bpfdi = BPFDI_CANCEL;

    if (!hwndList) {            // just do AUTO calculations
        if (!pfi)
            goto Exit;          // whoops, can't even do those
        goto ChooseBest;
    }
    dwIndex = lcbGetCurSel(hwndList, fListBox);
    if (!IsDlgError(dwIndex)) {

        if (pfi)
            pfi->fntProposed.flFnt &= ~FNT_AUTOSIZE;

        bpfdi = lcbGetBpfdi(hwndList, fListBox, dwIndex);

        if (bpfdi == BPFDI_AUTO && pfi) {
            pfi->fntProposed.flFnt |= FNT_AUTOSIZE;

ChooseBest:
            bpfdi = ChooseBestFont((UINT)pfi->winOriginal.cxCells,
                                   (UINT)pfi->winOriginal.cyCells,
                                   (UINT)pfi->winOriginal.cxClient,
                                   (UINT)pfi->winOriginal.cyClient,
                                   (UINT)pfi->fntProposed.flFnt,
                                    (INT)pfi->fntProposed.wCurrentCP);
        }
        // Set the index of the current selection (HIWORD
        // of the return code) to LB_ERR if there's an error

        if (bpfdi == BPFDI_CANCEL)
            dwIndex = (DWORD)LB_ERR;
    }
  Exit:
    if (!IsSpecialBpfdi(bpfdi))
    {
        bpfdi->Index = dwIndex;
    }

    return (DWORD_PTR)bpfdi;
}


/*  Copies data from the given BPFDI to the given PROPFNT structure.
 *
 *  Entry:
 *      lpFnt = pointer to PROPFNT structure
 *      bpfdi = based pointer to a FONTDIMENINFO structure;
 *              if a special BPFDI_* constant, no font info is changed
 *  Returns:
 *      Nothing
 */
void SetFont(LPPROPFNT lpFnt, BPFDI bpfdi)
{
    if (!IsSpecialBpfdi(bpfdi)) 
    {
        lpFnt->flFnt &= ~(FNT_RASTER | FNT_TT);

        if (bpfdi->fdiHeightReq == 0) 
        {
            /* Raster font */
            lpFnt->flFnt |= FNT_RASTER;
            lpFnt->cxFont = lpFnt->cxFontActual = (WORD) bpfdi->fdiWidthActual;
            lpFnt->cyFont = lpFnt->cyFontActual = (WORD) bpfdi->fdiHeightActual;
        }
        else 
        {
            /* TrueType font */
            lpFnt->flFnt |= FNT_TT;
            lpFnt->cxFont = (WORD) bpfdi->fdiWidthReq;
            lpFnt->cyFont = (WORD) bpfdi->fdiHeightReq;
            lpFnt->cxFontActual = (WORD) bpfdi->fdiWidthActual;
            lpFnt->cyFontActual = (WORD) bpfdi->fdiHeightActual;
        }
    }
}


/*  Performs the following calculation in LONG arithmetic to avoid
 *  overflow:
 *      return = n1 * m / n2
 *  This can be used to make an aspect ration calculation where n1/n2
 *  is the aspect ratio and m is a known value.  The return value will
 *  be the value that corresponds to m with the correct apsect ratio.
 */

//
// <This is defined as a macro for Win32 >
//

/*  Scales a point to be preview-sized instead of screen-sized.
 *  Depends on the global vars cxScreen and cyScreen established at init.
 */

void AspectPoint(LPRECT lprcPreview, LPPOINT lppt)
{
    lppt->x = AspectScale(lprcPreview->right, cxScreen, lppt->x);
    lppt->y = AspectScale(lprcPreview->bottom, cyScreen, lppt->y);
}

/*  AspectRect
 *
 *  Scales a rectangle to be preview-sized instead of screen-sized.
 *  Depends on the global vars cxScreen and cyScreen established at init.
 */

void AspectRect(LPRECT lprcPreview, LPRECT lprc)
{
    AspectPoint(lprcPreview, &((LPPOINT)lprc)[0]); /* Upper left corner */
    AspectPoint(lprcPreview, &((LPPOINT)lprc)[1]); /* Lower right corner */
}

/*  Given a BPFDI, create a font that corresponds to it.
 *
 *  Entry:
 *      bpfdi       -> FDI describing the font we want to create
 *      pfi         -> proposed font info structure
 *
 *  Returns:
 *      HFONT that was created.
 */
HFONT CreateFontFromBpfdi(BPFDI bpfdi, PFNTINFO pfi)
{
    HFONT hf;
    int   fdwClipPrecision;
    BYTE  bT2Charset;

    // a hack for japanese charset
    bT2Charset = (pfi->fntProposed.wCurrentCP == CP_JPN? 
                  0xFE: OEMCharsetFromCP(pfi->fntProposed.wCurrentCP));
    
    if (pfi->fntProposed.wCurrentCP == CP_US)
        fdwClipPrecision = CLIP_DEFAULT_PRECIS|(g_uCodePage == CP_WANSUNG? CLIP_DFA_OVERRIDE: 0);
    else
        fdwClipPrecision = CLIP_DEFAULT_PRECIS;
        
    if (bpfdi->fdiHeightReq == 0) {
        /* Raster font */
        hf = CreateFontA(bpfdi->fdiHeightActual, bpfdi->fdiWidthActual,
            0, 0, 0, 0, 0, 0, (BYTE)OEMCharsetFromCP(pfi->fntProposed.wCurrentCP), 
            OUT_RASTER_PRECIS, fdwClipPrecision,
            0, FIXED_PITCH | FF_DONTCARE, pfi->fntProposed.achRasterFaceName);
    } else {
        /* a TrueType font */
        hf = CreateFontA(bpfdi->fdiHeightReq, bpfdi->fdiWidthReq,
            0, 0, 0, 0, 0, 0, (BYTE)bT2Charset, OUT_TT_PRECIS, fdwClipPrecision,
            0, FIXED_PITCH | FF_DONTCARE, pfi->fntProposed.achTTFaceName);
    }

    return hf;
}


/** FontSelInit
 *
 *  Obtain the various font selection penalties from SYSTEM.INI
 *  and force the values into range.
 *
 *  Entry:
 *      rgwInitialTtHeights contains default values for sizes.
 *
 *  Exit:
 *      rgwInitialTtHeights contains actual values for sizes.
 */

void FontSelInit(void)
{
    GetIniWords(szNonWinSection, szTTInitialSizes,
                rgwInitialTtHeights, sizeof(rgwInitialTtHeights)/sizeof(WORD), szSystemINI);
}


/*  Convert logical dimensions for a TrueType font into physical
 *  dimensions.  If possible, we get this information from the
 *  font dimension cache, but in the case where this is not possible,
 *  we synthesize the font and measure him directly.
 *
 *  Entry:
 *      dxWidth  = logical font width
 *      dyHeight = logical font height
 *
 *  Returns:
 *      BPFDI pointing to dimension information, or BPFDI_CANCEL on failure.
 */

BPFDI GetTrueTypeFontTrueDimensions(UINT dxWidth, UINT dyHeight, INT CodePage)
{
    IFDI    ifdi;
    BPFDI   bpfdi;
    int     idx = IsBilingualCP(CodePage)? 1 : 0;
    for (ifdi = 0, bpfdi = (BPFDI)((DWORD_PTR)lpCache + bpfdiStart[idx]);  
                    ifdi < cfdiCache[idx];  ifdi++, bpfdi++)
    {
        if (bpfdi->fdiWidthReq  == dxWidth &&
            bpfdi->fdiHeightReq == dyHeight) {
            return bpfdi;
        }
    }

    /*
     * The font dimensions have not been cached.  We have to create it.
     */
    return (BPFDI)AddOneNewTrueTypeFontToFontListA(0, 0, dxWidth, dyHeight,
                                                 szTTFaceName[idx], CodePage);
}


/*  Look for a font that matches the indicated dimensions, creating
 *  one if necessary.
 *
 *  But we never create a font which is too narrow or too short.
 *  The limits are controlled by the ptNonAspectMin variable.
 *
 *  Entry:
 *      dxWidth  = desired font width
 *      dyHeight = desired font height
 *      fPerfect = see below
 *
 *          If fPerfect is TRUE, then a perfect match is requested
 *          from the font cache (we should not try to synthesize a font).
 *          In which case, the sign of dyHeight determines whether a
 *          raster font (positive) or TrueType font (negative) is
 *          desired.  If a perfect match cannot be found, then we
 *          return BPFDI_CANCEL.
 *
 *  Returns:
 *      BPFDI of of the font that matches the best.
 *      BPFDI_CANCEL if no font could be found.
 */
BPFDI FindFontMatch(UINT dxWidth, UINT dyHeight, LPINT lpfl, INT CodePage)
{
    IFDI    ifdi;
    BPFDI   bpfdi;
    BPFDI   bpfdiBest = BPFDI_CANCEL;
    PENALTY pnlBest = SENTINELPENALTY;
    int     idx;

    int fl = *lpfl;
    /*
     * First, see if a perfect match already exists.
     */
    idx = IsBilingualCP(CodePage) ? 1 : 0;
    for (ifdi = 0, bpfdi = (BPFDI)((DWORD_PTR)lpCache+bpfdiStart[idx]);  
                    ifdi < cfdiCache[idx];  ifdi++, bpfdi++)
    {

        if (fl & FFM_RESTRICTED) {
            /* Deal with the restrictions.
             * Reject the font if it is raster but we want TTONLY, or v.v.
             *
             * The condition below reads as
             *
             *      If (is a raster font != want a raster font)
             */
            if (!bpfdi->fdiHeightReq != (fl == FFM_RASTERFONTS)) {
                continue;
            }
        }
        if (bpfdi->fdiHeightActual == dyHeight && bpfdi->fdiWidthActual == dxWidth) {
            *lpfl = FFM_PERFECT;
            return bpfdi;
    }   }

    if (fl != FFM_TTFONTS)
        return BPFDI_CANCEL;
    /*
     * We got here if we couldn't find a perfect match.
     *
     * Adjust the requested height and width for aspect ratio
     * constraints.  If adjustments are necessary, trust the height.
     *
     * Comparisons are as WORDs (unsigned) so that a setting of "-1 -1"
     * lets the user forbid all non-aspect ratio fonts.
     */
    if (dyHeight < (UINT)ptNonAspectMin.y || dxWidth < (UINT)ptNonAspectMin.x) {
        dxWidth = 0;
    }
    return GetTrueTypeFontTrueDimensions(dxWidth, dyHeight, CodePage);
}

/*  We have decided whether the desired size is larger or smaller.
 *  Compute the penalty corresponding to the Initial and Scale.
 *
 *  Entry:
 *      ppnlp   -> PENALTYPAIR to apply
 *      dSmaller = the smaller dimension
 *      dLarger  = the larger dimension
 *
 *  Exit:
 *      Returns penalty to apply to the difference in dimensions.
 */
PENALTY ComputePenaltyFromPair(PPENALTYPAIR ppnlp,
                               UINT dSmaller, UINT dLarger)
{
    return (ppnlp->pnlInitial +
            ppnlp->pnlScale - MulDiv(ppnlp->pnlScale, dSmaller, dLarger));
}


/*  Compute the penalty depending on whether the desired size
 *  is smaller, equal to, or larger than the actual size.
 *
 *  Entry:
 *      ppnll   -> PENALTYLIST to apply
 *      dActual  = the actual dimension
 *      dDesired = the desired dimension
 *
 *  Exit:
 *      Returns penalty to apply to the difference in dimensions,
 *      choosing between the Overshoot and Shortfall PENALTYPAIRS,
 *      accordingly.
 */
PENALTY ComputePenaltyFromList(PPENALTYLIST ppnll,
                               UINT dActual, UINT dDesired)
{
    if (dActual == dDesired)
        return 0;

    if (dActual < dDesired)
        return ComputePenaltyFromPair(&ppnll->pnlpOvershoot, dActual, dDesired);

    return ComputePenaltyFromPair(&ppnll->pnlpShortfall, dDesired, dActual);
}


/** ComputePenalty
 *
 *  Compute the total penalty associated to a window size.
 *
 *  Entry:
 *      dxCells  = width of window in cells
 *      dyCells  = height of window in cells
 *      dxClient = actual horizontal size of window
 *      dyClient = actual vertical   size of window
 *      dxFont   = width of one character in the font
 *      dyFont   = height of one character in the font
 *
 *  Exit:
 *      Returns total penalty associated to a window of the indicated
 *      size with a font of the indicated dimensions.
 */
PENALTY ComputePenalty(UINT cxCells,  UINT cyCells,
                       UINT dxClient, UINT dyClient,
                       UINT dxFont,   UINT dyFont)
{
    return
        (ComputePenaltyFromList(&pnllX, dxClient, dxFont * cxCells) +
         ComputePenaltyFromList(&pnllY, dyClient, dyFont * cyCells));
}


/** ChooseBestFont
 *
 *  Determine which font looks best for the specified window size
 *  by picking the one which has the smallest penalty.
 *
 *  Entry:
 *      dxCells = width of window in cells
 *      dyCells = height of window in cells
 *      dxClient= width of window we want to fit into
 *      dyClient= height of window we want to fit into
 *      fl      = font pool flags
 *
 *  Returns:
 *      Word offset from lpFontTable of the font we've decided to use.
 *      BPFDI_CANCEL if no font could be found.  (Should never happen.)
 *
 *  NOTE!
 *      We do *not* FontEnum through all the fonts because that would be
 *      too slow.  Instead, we inspect the cache of available font
 *      dimensions, and only after we've chosen the best font do we
 *      load all his other info.
 *
 *      This means that if the user installs new fonts, we won't see
 *      them until the cache is updated on receipt of a WM_FONTCHANGEff
 *      message, or the user either (1) pulls down the font list box,
 *      or (2) calls up the font selection dialog box.
 */

BPFDI ChooseBestFont(UINT cxCells, UINT cyCells, UINT dxClient, UINT dyClient,
                                                         INT fl, INT CodePage)
{
    int     flTemp;
    DWORD    ifdi;
    BPFDI   bpfdi;
    PENALTY pnl;
    UINT    dxWidth, dyHeight;
    BPFDI   bpfdiBest = BPFDI_CANCEL;
    PENALTY pnlBest = SENTINELPENALTY;
    int     idx;
    static int prev_CodePage;  // Only Japan is interested in prev_CodePage.

    /*
     * First, synthesize the theoretical best match.
     */
    if (!cxCells)
        cxCells = 80;           // if we get called with no real data,
    if (!cyCells)               // at least try to do something reasonable
        cyCells = 25;

    //
    // In the case where the values passed in don't make sense,
    // we default to raster 8x12.
    //
    dxWidth = (dxClient >= cxCells)? dxClient / cxCells : 8;
    dyHeight = (dyClient >= cyCells)? dyClient / cyCells : 12;

    //
    // Now, if we bad values, make some sense out of bad values for
    // dxClient & dyClient
    //

    if ((dxClient==0) || (dyClient==0))
    {
        dxClient = dxWidth * 80;
        dyClient = dyHeight * 25;
    }

    flTemp = 0;
    if ((fl & FNT_BOTHFONTS) != FNT_BOTHFONTS) {
        flTemp = FFM_RASTERFONTS;
        if (fl & FNT_TTFONTS)
            flTemp = FFM_TTFONTS;
    }
    bpfdi = FindFontMatch(dxWidth, dyHeight, &flTemp, CodePage);
    if (flTemp == FFM_PERFECT)
    {
        prev_CodePage = CodePage;
        return bpfdi;
    }

    idx = IsBilingualCP(CodePage)? 1 : 0;
    for (ifdi = 0, bpfdi = (BPFDI)((DWORD_PTR)lpCache+bpfdiStart[idx]);  
                    ifdi < cfdiCache[idx];  ifdi++, bpfdi++)
    {
        // If the font pool is restricted, then only look at like fonts

        if (flTemp)
            if (!bpfdi->fdiHeightReq != (flTemp == FFM_RASTERFONTS))
                continue;

// was ifdef JAPAN (hack)
// to prevent DOS_BOX shrinking which occurs toggling CP437 & CP932,
// just select one size bigger font when change CP437 to CP932
        if (CodePage == 932 && prev_CodePage == 437) {
           if (dxWidth < bpfdi->fdiWidthActual) {
              if (bpfdiBest->fdiWidthActual > bpfdi->fdiWidthActual)
                 bpfdiBest = bpfdi;
              else if (bpfdiBest->fdiWidthActual == bpfdi->fdiWidthActual &&
                       bpfdiBest->fdiHeightActual > bpfdi->fdiHeightActual)
                 bpfdiBest = bpfdi;
           }
           else {
              if (dxWidth == bpfdi->fdiWidthActual) {
                 if (bpfdi->fdiHeightActual > dyHeight &&
                     bpfdiBest->fdiHeightActual > bpfdi->fdiHeightActual)
                    bpfdiBest = bpfdi;
              }
           }
        }
        else 
// was the end of ifdef JAPAN
        {
        pnl = 0;
        if (bpfdi->fdiHeightReq)
            pnl = pnlTrueType;

        pnl += ComputePenalty(cxCells, cyCells,
                              dxClient, dyClient,
                              bpfdi->fdiWidthActual,
                              bpfdi->fdiHeightActual);

        if (pnl <= pnlBest) {
            pnlBest = pnl;
            bpfdiBest = bpfdi;
        }
        }
    }
// was ifdef JAPAN
    prev_CodePage = CodePage;
// was end of ifdef JAPAN
    return bpfdiBest;
}