windows-server-2003/windows/core/ntgdi/gre/pftobj.cxx

/******************************Module*Header*******************************\
* Module Name: pftobj.cxx                                                  *
*                                                                          *
* Non-inline methods for physical font table objects.                      *
*                                                                          *
* Created: 30-Oct-1990 09:32:48                                            *
* Author: Gilman Wong [gilmanw]                                            *
*                                                                          *
*  Tue 09-Aug-1994 10:04:09 by Kirk Olynyk [kirko]                         *
* Prior to build ### there was only a single font table on which all       *
* fonts, be they public (engine) or device, where attached. I have         *
* changed the font architecture so that there will be two font tables.     *
* One for public fonts and the other font device fonts. The public font    *
* table will be string based. That is, the fonts were added to this        *
* using GreAddFontResourceW() with the name of the associated font file.   *
* The name of the font file and path will be hashed and the font files     *
* will hang off of the collision list. The number of hash buckets is       *
* set at boot time.                                                        *
*                                                                          *
* The device font table will be for device fonts (suprise).                *
* In this case the fonts will be placed in hash collisions                 *
* lists depending upon the value of their hdev.                            *
*                                                                          *
* Copyright (c) 1994-1999 Microsoft Corporation                            *
*                                                                          *
\**************************************************************************/

#include "precomp.hxx"

extern "C" BOOL bInitFontTables();
extern "C" void vQueryRegistryForNumberOfBuckets(unsigned *, unsigned *);

#pragma alloc_text(INIT, bInitFontTables)
#pragma alloc_text(INIT, vQueryRegistryForNumberOfBuckets)

#define  CPRIVATEBUCKETS     20

PFT *gpPFTPublic;       // global public font table (for font drivers)
PFT *gpPFTDevice;       // global device font table (for printers)
PFT *gpPFTPrivate = PPFTNULL;   // global public talbe for private fonts, init as NULL

#ifdef LANGPACK
UINT PFFOBJ::uGlobalUniqueness = 0;
#endif

LARGE_INTEGER PFTOBJ::FontChangeTime;    // time of most recent addition or
                                         // removal of a font file
// Definitions for local functions used to remove font files from system.

static RFONT*      prfntKillList(PFFOBJ &);
static BOOL        bKillRFONTList(PFFOBJ &, RFONT *);
static UINT        iHash(const WCHAR *, UINT);


/******************************Public*Routine******************************\
* pAllocateAndInitializePFT                                                *
*                                                                          *
*   Allocates and initializes a font table with cBuckets                   *
*   This allows the public (engine) font table and the device              *
*   font table to share the same code.                                     *
*                                                                          *
*   input:  cBuckets = number of members in allocated PFF* table           *
*   output: address of new PFT                                             *
*                                                                          *
*   Notes:                                                                 *
*                                                                          *
*   it is not necessary to check for error in the creation                 *
*   of the hash tables because the system will still work                  *
*                                                                          *
*   error:  return 0                                                       *
*                                                                          *
* History:                                                                 *
*  Fri 05-Aug-1994 07:41:50 by Kirk Olynyk [kirko]                         *
* Wrote it.                                                                *
\**************************************************************************/

PFT *pAllocateAndInitializePFT(unsigned cBuckets)
{
    PFT *pPFT;

    register ULONGSIZE_T size = offsetof(PFT, apPFF) + cBuckets * sizeof(PFF*);
    if (pPFT = (PFT*) PALLOCMEM(size, 'tfpG'))
    {
        pPFT->cBuckets       = cBuckets;
        pPFT->cFiles         = 0;
    }
    return(pPFT);
}

// strings used to identify values stored in the registry

static CONST PWSZ pwszP0 =  L"NumberOfPublicFontFilesAtLastLogOff";
static CONST PWSZ pwszP1 =  L"NumberOfPublicFontFilesSetByUser";
static CONST PWSZ pwszD0 =  L"NumberOfDeviceFontFilesAtLastLogOff";
static CONST PWSZ pwszD1 =  L"NumberOfDeviceFontFilesSetByUser";
static CONST PWSZ pwszFC =
          L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\FontCache";

// Define some default values in case the registry numbers are bogus

#define MIN_PUBLIC_BUCKETS 100
#define MAX_PUBLIC_BUCKETS 10000
#define MIN_DRIVER_BUCKETS 5
#define MAX_DRIVER_BUCKETS 100

// PIR :== Put In Range

#define PIR(x,a,b) ((x)<(a)?(a):((x)>(b)?(b):(x)))



/******************************Public*Routine******************************\
* vQueryRegistryForNumberOfBuckets
*
* Gets from the registry the number of buckets needed for the public
* and driver font tables.
*
* History:
*  Mon 26-Sep-1994 09:59:52 by Kirk Olynyk [kirko]
* Wrote it.
\**************************************************************************/

extern "C" void vQueryRegistryForNumberOfBuckets(
    unsigned *puPublic      // recieves # buckets for Public fonts
  , unsigned *puDevice      // recieves # buckets for Device fonts
  )
{

    RTL_QUERY_REGISTRY_TABLE QueryTable[5];
    HANDLE hDevMode;
    DWORD Status;

    ULONG cPublicBucketsSys  = 0;
    ULONG cPublicBucketsUser = 0;
    ULONG cDeviceBucketsSys  = 0;
    ULONG cDeviceBucketsUser = 0;

    //
    // Initialize registry query table.
    //

    QueryTable[0].QueryRoutine = NULL;
    QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
    QueryTable[0].Name = L"NumberOfPublicFontFilesAtLastLogOff";
    QueryTable[0].EntryContext = &cPublicBucketsSys;
    QueryTable[0].DefaultType = REG_NONE;
    QueryTable[0].DefaultData = NULL;
    QueryTable[0].DefaultLength = 0;

    QueryTable[1].QueryRoutine = NULL;
    QueryTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
    QueryTable[1].Name = L"NumberOfPublicFontFilesSetByUser";
    QueryTable[1].EntryContext = &cPublicBucketsUser;
    QueryTable[1].DefaultType = REG_NONE;
    QueryTable[1].DefaultData = NULL;
    QueryTable[1].DefaultLength = 0;

    QueryTable[2].QueryRoutine = NULL;
    QueryTable[2].Flags = RTL_QUERY_REGISTRY_DIRECT;
    QueryTable[2].Name = L"NumberOfDeviceFontFilesAtLastLogOff";
    QueryTable[2].EntryContext = &cDeviceBucketsSys;
    QueryTable[2].DefaultType = REG_NONE;
    QueryTable[2].DefaultData = NULL;
    QueryTable[2].DefaultLength = 0;

    QueryTable[3].QueryRoutine = NULL;
    QueryTable[3].Flags = RTL_QUERY_REGISTRY_DIRECT;
    QueryTable[3].Name = L"NumberOfDeviceFontFilesSetByUser";
    QueryTable[3].EntryContext = &cDeviceBucketsUser;
    QueryTable[3].DefaultType = REG_NONE;
    QueryTable[3].DefaultData = NULL;
    QueryTable[3].DefaultLength = 0;

    QueryTable[4].QueryRoutine = NULL;
    QueryTable[4].Flags = 0;
    QueryTable[4].Name = NULL;

    //
    // If the open was succesdsful, then query the registry for the
    // specified printer.
    //

    Status = RtlQueryRegistryValues(RTL_REGISTRY_WINDOWS_NT,
                                    L"FontCache",
                                    &QueryTable[0],
                                    NULL,
                                    NULL);

    if (!NT_SUCCESS(Status))
    {
        WARNING1("vQueryRegistryForNumberOfBuckets failure\n");
    }
    else
    {
        if (!cPublicBucketsUser)
        {
            cPublicBucketsUser = cPublicBucketsSys;
        }
        if (!cDeviceBucketsUser)
        {
            cDeviceBucketsUser = cDeviceBucketsSys;
        }
    }
    *puPublic = PIR(cPublicBucketsUser, MIN_PUBLIC_BUCKETS, MAX_PUBLIC_BUCKETS);
    *puDevice = PIR(cDeviceBucketsUser, MIN_DRIVER_BUCKETS, MAX_DRIVER_BUCKETS);
}


/******************************Public*Routine******************************\
* BOOL bInitFontTables                                                    *
*                                                                          *
* Create the global public PFT and driver PFT                              *
*                                                                          *
* Create the public PFT semaphore to serialize access to both the          *
* public and driver font tables and their releated PFF's and PFE's         *
* Access to the RFONT's (realized font instances) are regulated            *
* by a separate semaphore.                                                 *
*                                                                          *
* History:                                                                 *
*  Fri 05-Aug-1994 07:07:27 by Kirk Olynyk [kirko]                         *
* Made it allocate both the public and driver font tables. Both            *
* allocations and initializations are done by a common routine.            *
*  21-Jan-1991 -by- Gilman Wong [gilmanw]                                  *
* Wrote it.                                                                *
\**************************************************************************/

extern "C" BOOL bInitFontTables()
{
    unsigned cPublicBuckets;
    unsigned cDeviceBuckets;
    register BOOL bRet = FALSE;

    vQueryRegistryForNumberOfBuckets(&cPublicBuckets, &cDeviceBuckets);
    if (
    bRet = (
        (gpPFTPublic    = pAllocateAndInitializePFT(cPublicBuckets))
     && (gpPFTDevice    = pAllocateAndInitializePFT(cDeviceBuckets))
     && (ghsemPublicPFT = GreCreateSemaphore())
     && (ghsemGlyphSet = GreCreateSemaphore())
     && (ghsemPrintKView = GreCreateSemaphore()))
    )
    {
       FHMEMOBJ fhmo1(&gpPFTPublic->pfhFace  , FHT_FACE  , cPublicBuckets);
       FHMEMOBJ fhmo2(&gpPFTPublic->pfhFamily, FHT_FAMILY, cPublicBuckets);
       FHMEMOBJ fhmo3(&gpPFTPublic->pfhUFI, FHT_UFI, cPublicBuckets);
    }

    #if DBG
        if (!bRet)
        {
            if (!gpPFTPublic)       WARNING("gpPFTPublic == 0\n");
            if (!gpPFTDevice)       WARNING("gpPFTDevice == 0\n");
            if (!ghsemPublicPFT)    WARNING("ghsemPublicPFT == 0\n");
        }
    #endif

    return(bRet);
}


/******************************Public*Routine******************************\
* BOOL bInitPrivatePFT                                                     *
*                                                                          *
* Create the global private PFT                                            *
*                                                                          *
* Create the semaphore for the private PFT to serialize access             *
* to the private PFT and its releated PFF's and PFE's                      *
* Access to the RFONT's (realized font instances) are regulated            *
* by a separate semaphore.                                                 *
*                                                                          *
* History:                                                                 *
*  10-Aug-1996 -by- Xudong Wu [TessieW]                                    *
* Wrote it.                                                                *
\**************************************************************************/

BOOL bInitPrivatePFT()
{
    register BOOL bRet = FALSE;

    SEMOBJ sem(ghsemPublicPFT);

    if (gpPFTPrivate)
        return TRUE;


    if ( bRet = ((gpPFTPrivate = pAllocateAndInitializePFT(CPRIVATEBUCKETS)) != PPFTNULL )  )
    {
       FHMEMOBJ fhmo1(&gpPFTPrivate->pfhFace  , FHT_FACE  , CPRIVATEBUCKETS);
       FHMEMOBJ fhmo2(&gpPFTPrivate->pfhFamily, FHT_FAMILY, CPRIVATEBUCKETS);
       FHMEMOBJ fhmo3(&gpPFTPrivate->pfhUFI, FHT_UFI, CPRIVATEBUCKETS);
    }

#if DBG
    if (!bRet)
    {
        if (!gpPFTPrivate)      WARNING("gpPFTPrivate== 0\n");
    }
#endif

    return(bRet);
}


/******************************Public*Routine******************************\
* VOID  vCleanupPrivateFonts()                                             *
*                                                                          *
* Clean up the PFF for the dying process pid                               *
*                                                                          *
* History:                                                                 *
*  01-Oct-1996 -by- Xudong Wu [TessieW]                                    *
* Wrote it.                                                                *
\**************************************************************************/

VOID vCleanupPrivateFonts()
{
    ULONG i;
    PFF  *pPFF, **ppPFF, **ppPFFHead;

    // We have seen some stress failures on the Hydra system
    // that ghsemPublicPFT was not even initialized

    if (ghsemPublicPFT)
    {
        GreAcquireSemaphoreEx(ghsemPublicPFT, SEMORDER_PUBLICPFT, NULL);

        PUBLIC_PFTOBJ  pftop(gpPFTPrivate);

        if (pftop.bValid())
        {
            //fonts loaded as private

            ppPFFHead = gpPFTPrivate->apPFF;

            for (i=0; i < CPRIVATEBUCKETS; i++)
            {
                ppPFF = ppPFFHead;
                pPFF = *ppPFFHead;

                while ( pPFF )
                {
                    PFF *pPFFNextVictim = pPFF->pPFFNext;

                    // bUnloadWorkhorse should release ghsemPublicPFT

                    if ( pftop.bUnloadWorkhorse(pPFF, ppPFF, ghsemPublicPFT, FRW_PVT_CLEANUP) )
                    {
                        GreQuerySystemTime( &PFTOBJ::FontChangeTime );
                    }

                    pPFF = pPFFNextVictim;

                    GreAcquireSemaphoreEx(ghsemPublicPFT, SEMORDER_PUBLICPFT, NULL);
                }

                ppPFFHead++;
            }
        }

        GreReleaseSemaphoreEx(ghsemPublicPFT);
    }
}

/******************************Public*Routine******************************\
* BOOL PFTOBJ::bDelete()                                                  *
*                                                                          *
* Destroy the PFT physical font table object.                              *
*                                                                          *
*   If this method succeeds the pointer to the public font table is        *
* set to 0 and then this method returns TRUE. If the table contains        *
* any files, then this method will fail and return FALSE.                  *
*                                                                          *
* History:                                                                 *
*  30-Oct-1990 -by- Gilman Wong [gilmanw]                                  *
* Wrote it.                                                                *
\**************************************************************************/

BOOL PFTOBJ::bDelete()
{
    if (pPFT->cFiles == 0)
    {
        VFREEMEM(pPFT);
        pPFT = 0;
    }
    else
    {
        WARNING("gdisrv!bDeletePFTOBJ(): cFiles != 0");
    }
    return(!pPFT);
}

/******************************Public*Routine******************************\
* PFTOBJ::chpfeIncrPFF                                                     *
*                                                                          *
* If this was an attempt to load a font that was embeded and the           *
* client ID didn't match that in the *.fot file FALSE will be              *
* return via pbEmbedStatus ortherwise TRUE is returned.                    *
*                                                                          *
* If found, the load count of the PFF is incremented.                      *
*                                                                          *
* Note:                                                                    *
*   Caller should be holding the ghsemPublicPFT                            *
*   semaphore when calling this routine in order                           *
*   to access the table and load count.                                    *
*                                                                          *
* Returns:                                                                 *
*   Number of PFEs in the PFF, 0 if PFF not found.                         *
*                                                                          *
* History:                                                                 *
*  Fri 05-Aug-1994 13:37:11 by Kirk Olynyk [kirko]                         *
* The PFF has been found up front and is guaranteed to exist.              *
* I have removed the check to see if it is a device font. This check       *
* is now redundant because you can tell if it is a device font by the      *
* table that you are on. If device fonts cannot be loaded via              *
* AddFontResouce, then this function should not be called for a            *
* device font.                                                             *
*  28-Jun-1991 -by- Gilman Wong [gilmanw]                                  *
* Wrote it.                                                                *
\**************************************************************************/

COUNT PFTOBJ::chpfeIncrPFF(
   PFF    *pPFF,               // address of PFF to be, incremented
   BOOL   *pbEmbedStatus,      // tried to load an embeded font illegally
   ULONG  flEmbed,
   PEUDCLOAD pEudcLoadData   // PFE's in file if EUDC
    )
{
    // Caller should be holding ghsemPublicPFT semaphore!

    BOOL bEUDC = ( pEudcLoadData != NULL );

    COUNT cRet = 0;
    PFFOBJ pffo(pPFF);
    if (!pffo.bValid())
    {
        RIP("Invalid PFFOBJ\n");
    }
    else
    {
        if ((bEUDC && pffo.bEUDC()) || (!bEUDC && !pffo.bEUDC()) )
        {
            *pbEmbedStatus = !bIsPrivatePFT() || pffo.bAddPvtData(flEmbed);

            if(*pbEmbedStatus)
            {
                    if(bEUDC)
                    {
                        if((pEudcLoadData->LinkedFace == NULL) &&
                           (pffo.cFonts() > 2))
                        {
                            // EUDC font file can have at most two fonts (one regular
                            // and one @) unless the user specifies a face name.
                            // we return failure by setting embed status to false

                            *pbEmbedStatus = FALSE;

                            // return non-zero so calling function returns right away

                            return(1);
                        }
                        pffo.vGetEUDC(pEudcLoadData);
                    }

                    if (!bIsPrivatePFT())
                    {
                        pffo.vLoadIncr(flEmbed);
                    }

                    cRet = pffo.cFonts();
            }
            else
            {
                cRet = ~cRet;
                ASSERTGDI(cRet,
                    "cRet should be non zero so calling function"
                    " will return right away\n");
            }
        }
    }
    return(cRet);
}

/******************************Public*Routine******************************\
* PFTOBJ::pPFFGet                                                          *
*                                                                          *
* Note:                                                                    *
*   Caller should be holding the ghsemPublicPFT semaphore when             *
*   this method calling this in order to guarantee a stable font           *
*   table.                                                                 *
*   Note that since all the strings in the table are in upper case         *
*   and the input string must be upper case, we are allowed to             *
*   compare strings with the faster case sensitive compare                 *
*   wcscmp().                                                              *
*                                                                          *
* Returns:                                                                 *
*   PPFF of the PFF if found, (PPFF) NULL if the PFF not found.            *
*                                                                          *
* History:                                                                 *
*  Thu 04-Aug-1994 08:18:27 by Kirk Olynyk [kirko]                         *
* Modified to make the public font table hash based                        *
*  06-May-1992 -by- Gilman Wong [gilmanw]                                  *
* Wrote it.                                                                *
\**************************************************************************/

PPFF PUBLIC_PFTOBJ::pPFFGet (
    PWSZ pwszPathname   // address of upper case string
  , ULONG cwc
  , ULONG cFiles
  , DESIGNVECTOR *pdv
  , ULONG         cjDV
  , PFF ***pppPFF       // write address of bucket here
  , BOOL bEUDC          // be true if EUDC
  )
{
    PFF *pPFF, **ppPFF;

// it is enough to hash on the first file only, no need to include the
// second and or third file to the hashing routine [bodind]

    ppPFF = pPFT->apPFF + iHash(pwszPathname,pPFT->cBuckets);
    if (pppPFF)
    {
        *pppPFF = ppPFF;
    }

    pPFF = *ppPFF;

    while(pPFF)
    {
        if
        ((bEUDC == ((pPFF->flState & PFF_STATE_EUDC_FONT) != 0)) &&
        (cwc == pPFF->cwc) && (cFiles == pPFF->cFiles) &&
        !memcmp(pPFF->pwszPathname_, pwszPathname, cwc * sizeof(WCHAR)) &&
        (cjDV == pPFF->cjDV_) &&
        (!cjDV || !memcmp(pdv, pPFF->pdv_, pPFF->cjDV_))
        )
        {
            break;
        }
        pPFF = pPFF->pPFFNext;
    }

    return(pPFF);
}


/**********************Public*Routine***************************\
* PFTOBJ::pPFFGetMM                                             *
*                                                               *
* Note:                                                         *
*   Caller should be holding the ghsemPublicPFT semaphore       *
*   when this method calling this in order to guarantee         *
*   a stable font table. Also this should only be called        *
*   when we remove the memory fonts.                            *
*                                                               *
*   We check the PFF_STATE_MEMORY_FONT flag, the ulCheckSum     *
*   and the process ID                                          *
*                                                               *
* Returns:                                                      *
*   PPFF of the PFF if found, (PPFF) NULL if not found.         *
*                                                               *
* History:                                                      *
*  12-Jun-1997  -by-    Xudong Wu [TessieW]                     *
* Wrote it.                                                     *
\***************************************************************/
PPFF PUBLIC_PFTOBJ::pPFFGetMM
(
    ULONG   ulCheckSum,
    PFF     ***pppPFF
)
{
    BOOL    bFind = FALSE;
    PFF     *pPFF, **ppPFFHead;
    int     i;

    ASSERTGDI(pPFT == gpPFTPrivate, "pPFFGetMM(): it is not private PFT table\n");

    ppPFFHead = gpPFTPrivate->apPFF;

    for (i=0; i < CPRIVATEBUCKETS; i++)
    {
        pPFF = *ppPFFHead;

        while (pPFF)
        {
            if ((pPFF->flState & PFF_STATE_MEMORY_FONT) && (pPFF->ulCheckSum == ulCheckSum))
            {
                PFFOBJ  pffo(pPFF);

                if (pffo.pPvtDataMatch())
                {
                    bFind = TRUE;
                    break;
                }
            }

            pPFF = pPFF->pPFFNext;
        }

        if (bFind)
        {
            break;
        }

        ppPFFHead++;
    }

    if (bFind && pppPFF)
    {
        *pppPFF = ppPFFHead;
    }

    return(pPFF);
}



/******************************Public*Routine******************************\
* PFTOBJ::pPFFGet                                                          *
*                                                                          *
* This function searches for the PFF that contains the device fonts for    *
* the PDEV specified by the HPDEV passed in.                               *
*                                                                          *
* Note:                                                                    *
*   Caller should be holding the ghsemPublicPFT semaphore                  *
*   when calling this in order to have access to the font tables.          *
*                                                                          *
* Returns:                                                                 *
*   pointer to the PFF if found. 0 returned on error.                      *
*                                                                          *
* History:                                                                 *
*  Fri 05-Aug-1994 13:39:04 by Kirk Olynyk [kirko]                         *
* Changed this to a hash based search.                                     *
*  06-May-1992 -by- Gilman Wong [gilmanw]                                  *
* Wrote it.                                                                *
\**************************************************************************/

#define iHashHPDEV(hdev, c)    (((ULONG_PTR) hdev >> 4) % c)

PPFF DEVICE_PFTOBJ::pPFFGet(
    HDEV hdev
  , PFF ***pppPFF     // write address of bucket here
)
{
    PFF *pPFF, **ppPFF;

    ppPFF = pPFT->apPFF + iHashHPDEV(hdev, pPFT->cBuckets);
    pPFF = *ppPFF;
    if (pppPFF)
    {
        *pppPFF = ppPFF;
    }
    while (pPFF)
    {
        PFFOBJ pffo(pPFF);
        if (!pffo.bValid())
        {
            RIP("PFTOBJ::PPFFGet(HPDEV) encountered invalid PFFOBJ\n");
        }
        else if (hdev == pffo.hdev())
        {
            break;
        }
        pPFF = pPFF->pPFFNext;
    }
    return(pPFF);
}

/******************************Public*Routine******************************\
*
* bLoadAFont, wrapper for one file only
*
*
* History:
*  28-Mar-1996 -by- Bodin Dresevic [BodinD]
* Wrote it.
\**************************************************************************/

BOOL PUBLIC_PFTOBJ::bLoadAFont(
    PWSZ   pwszPathname,             // font file pathname
    PULONG pcFonts,                  // number of fonts faces loaded
    FLONG  fl,                       // permanent
    PPFF    *pPPFF,
    PEUDCLOAD pEudcLoadData
  )
{

    WCHAR awcUcPathName[MAX_PATH + 1];
    ULONG cwc = wcslen(pwszPathname) + 1;
    cCapString(awcUcPathName, pwszPathname, cwc);

    return bLoadFonts(awcUcPathName, cwc, 1, // pwsz, cwc, cFiles
                      NULL, 0,               // pdv, cjDV
                      pcFonts,fl, pPPFF
                      , 0
                      , FALSE
                      , pEudcLoadData
                      );
}

/************************Public*Routine*******************************\
*
* VOID    vLoadFontFileView()
*
* Note: we need to grab semaphore ghsemDriverMgmt before the function
*       call and release the semaphore afterwards.
*
* History:
*   03-June-1997 -by- Xudong Wu [Tessiew]
*  Wrote it.
\*********************************************************************/
VOID  vLoadFontFileView
(
    PWSZ            pwszPathname,             // font file pathname
    ULONG           cwc,                      // cwc in PathName
    FONTFILEVIEW    **apfv,
    ULONG           cFiles,
    PVOID           *apvView,
    ULONG           *acjView,
    DESIGNVECTOR    *pdv,
    ULONG           cjDV,
    HFF             *phffNew,
    PPDEV           *pppDevList,
    PFNTCHECKSUM    pFntCheckSum
)
{
    GDIFunctionID(vLoadFontFileView);

    HFF     hffNew = HFF_INVALID;
    PPDEV   ppDevList = gppdevList, ppDevTmp;
    ULONG   lflag;
    PPDEV   ppDevCache = NULL;
    BOOL    bCached = FALSE;

    pFntCheckSum->ulCheckSum = 0;
    pFntCheckSum->ulFastCheckSum = 0;

    pFntCheckSum->ulCheckSum = LookUpFNTCacheTable( cwc, pwszPathname, &pFntCheckSum->ulFastCheckSum,
                                                    apfv, cFiles, &ppDevList, pdv, cjDV);

    if (pFntCheckSum->ulCheckSum && ppDevList)
    {
        PDEVOBJ pdo((HDEV)ppDevList);

        ASSERTGDI (pdo.bFontDriver(), " Something wrong in font ppDev cache \n" );

        // In case something wrong in font driver.

        if (pdo.bFontDriver())
        {
            // make a reference to the font driver under the protection
            // of the semaphore. This will guarantee that the font
            // driver will not be unloaded unexpectedly. After that

            pdo.vReferencePdev();

            GreReleaseSemaphoreEx(ghsemDriverMgmt);


            // Attempt to load the font file.
            // It is acceptable to release the lock at this point because
            // we know this font driver has at least one reference to it.
            // We also do not care if other font drivers are added or removed
            // from the list while we are scanning it ...

            // We are assuming that DrvLoadFontFile will call EngMapFontFile
            // and EngUnmapFontFile in balanced pairs upon the view.

            // we are trying to add the font using the cached info. If this failed
            // we will try to add it later without using the cached info, in case there
            // is a problem with boot cache. (Defensive programming).

            hffNew = pdo.LoadFontFile( cFiles,
                                       (ULONG_PTR *) apfv,
                                       apvView,
                                       acjView,
                                       pdv,
                                       (ULONG) gusLanguageID,
                                       pFntCheckSum->ulFastCheckSum
                                      );


            if (hffNew == HFF_INVALID)
            {
                hffNew = pdo.LoadFontFile( cFiles,
                                       (ULONG_PTR *) apfv,
                                       apvView,
                                       acjView,
                                       pdv,
                                       (ULONG) gusLanguageID,
                                       0
                                      );

            }

            if (hffNew != HFF_INVALID)
            {
               bCached = TRUE;
            }
            else
            {
                // We did not load the font file properly
                // Release the reference and go on.
                pdo.vUnreferencePdev();
            }

            // Grab the lock again here (so we exit the loop properly)
            GreAcquireSemaphoreEx(ghsemDriverMgmt, SEMORDER_DRIVERMGMT, NULL);
        }
    }

    if (!bCached)
    {
        ppDevList = gppdevList;

        do
        {
            PDEVOBJ pdo((HDEV)ppDevList);

            ppDevTmp = NULL;
            if ( pdo.bFontDriver() )
            {
            // make a reference to the font driver under the protection
            // of the semaphore. This will guarantee that the font
            // driver will not be unloaded unexpectedly. After that

                pdo.vReferencePdev();

                GreReleaseSemaphoreEx(ghsemDriverMgmt);

            // Attempt to load the font file.
            // It is acceptable to release the lock at this point because
            // we know this font driver has at least one reference to it.
            // We also do not care if other font drivers are added or removed
            // from the list while we are scanning it ...

            // We are assuming that DrvLoadFontFile will call EngMapFontFile
            // and EngUnmapFontFile in balanced pairs upon the view.

                hffNew = pdo.LoadFontFile( cFiles,
                                       (ULONG_PTR *) apfv,
                                       apvView,
                                       acjView,
                                       pdv,
                                       (ULONG) gusLanguageID,
                                       pFntCheckSum->ulFastCheckSum
                                      );


            // Grab the lock again here (so we exit the loop properly)

                GreAcquireSemaphoreEx(ghsemDriverMgmt, SEMORDER_DRIVERMGMT, NULL);

                if (hffNew != HFF_INVALID)
                {
                    PutFntCacheDrv(pFntCheckSum->ulFastCheckSum, ppDevList);
                    break;
                }
                else
                {
                // We did not load the font file properly
                // Release the reference and go on.

                    ppDevTmp = ppDevList->ppdevNext;
                    pdo.vUnreferencePdev();
                }
            }
            ppDevList = ppDevTmp ? ppDevTmp : ppDevList->ppdevNext;

        } while (ppDevList);
    }

    *pppDevList = ppDevList;
    *phffNew = hffNew;
}



/******************************Public*Routine******************************\
* BOOL PUBLIC_PFTOBJ::bLoadFonts                                          *
*                                                                          *
* The bLoadFont function searches for an IFI font driver which can load    *
* the requested font file.  If a driver is found, a new Pysical Font       *
* File object is created and is used to load the font file.                *
*                                                                          *
* Note that if the font file has already been loaded (i.e., a PFF object   *
* already exists for it), the ref count in the PFF is incremented without  *
* reloading the file.                                                      *
*                                                                          *
* If pppfeEUDC != NULL then we are loading an EUDC font file.  This has    *
* the restriction the font file has only one face or two if the other is   *
* an @face. If either of these aren't true the call fails.  Also, an EUDC  *
* font wont be enumerated.  Finally the PFE will be returned for the one   *
* font in the EUDC font file via pppfeEUDC.                                *
*                                                                          *
* Returns FALSE on failure.                                                *
*                                                                          *
* History:                                                                 *
*  Thu 28-Mar-1996 -by- Bodin Dresevic [BodinD]
* update: added multiple file support
*  Thu 04-Aug-1994 08:04:03 by Kirk Olynyk [kirko]                         *
* Made the font table hash based.                                          *
*  06-Nov-1990 -by- Gilman Wong [gilmanw]                                  *
* Wrote it.                                                                *
\**************************************************************************/

BOOL PUBLIC_PFTOBJ::bLoadFonts(
    PWSZ   pwszPathname,             // font file pathname
    ULONG  cwc,                      // cwc in PathName
    ULONG  cFiles,                   // number of distinct files in path
    DESIGNVECTOR *pdv,
    ULONG         cjDV,
    PULONG pcFonts,                  // number of fonts faces loaded
    FLONG  fl,                       // permanent
    PPFF    *pPPFF,
    FLONG  flEmbed,
    BOOL   bSkip,               // skip the check if the font is already loaded
    PEUDCLOAD pEudcLoadData     // returns PFE for EUDC font file
    )
{
    GDIFunctionID(PUBLIC_PFTOBJ::bLoadFonts);

    COUNT   cFonts;                   // count of fonts in font file
    BOOL    bRet = FALSE;             // assume failuer
    PFF     *pPFF;                    // convenient pointer2
    PFF     **ppPFF;                    // address of bucket
    BOOL    bEUDC = ( pEudcLoadData != NULL );
    PPFE    *pppfeEUDC = ((bEUDC) ? pEudcLoadData->pppfeData : NULL);
    FNTCHECKSUM fntCheckSum;
    PFF     *pPFFTemp = NULL;
    BOOL    bClone = FALSE;

    if (!pwszPathname)
    {
        RIP("pwszPathname != 0\n");
        return(bRet);
    }

    // we have seen AV caused by uninitialized gpsemPublicPFT
    // on Hydra systems
    // hydra -- we might remove this in Beta3

    //if (!ghsemPublicPFT)
    //{
    //    return bRet;
    //}

    // if (already_loaded) increment_ref_count_then_exit_immediately

    if (!bSkip)
    {
        SEMOBJ so(ghsemPublicPFT);

        *pcFonts = 0;

        if ((*pPPFF = pPFFGet((PWSZ) pwszPathname, cwc, cFiles, pdv, cjDV, &ppPFF, bEUDC)) &&
            (*pcFonts = chpfeIncrPFF(*pPPFF, &bRet, flEmbed, pEudcLoadData)))
        {
            return(bRet);
        }
        else if (pPFFTemp = pPFFGet((PWSZ) pwszPathname, cwc, cFiles, pdv, cjDV, &ppPFF, !bEUDC))
        {
            if (pPFFTemp->pPFFClone == (PFF *) NULL)
                bClone = TRUE;
        }
    }

    // Grab the head of the font driver list under semaphore and find
    // the first font driver in the list that loads the font
    //
    // Release the semaphore so we can go and see if the
    // driver supports the font.  If it does, then keep
    // the reference count and exit.  Otherwise, grab the
    // semaphore again, release the reference count and
    // find the next driver in the list.


// alloc temp memory, this could be done on the stack if it were not
// for the fact that we do not know ahead the upper bound on cFiles

    if (!bClone)
    {
        HFF hffNew = HFF_INVALID;             // IFI handle to font file

        MALLOCOBJ moViews(cFiles * (sizeof(PVOID) + sizeof(ULONG)));
        if (!moViews.bValid())
            return FALSE;

        PVOID *apvView      = (PVOID *)moViews.pv();
        ULONG *acjView      = (ULONG *)&apvView[cFiles];


        FONTFILEVIEW **apfv;

    // apfv - pointer to a block of memory that begins with an array
    //    of cFiles pointers to FONTFILEVIEW structures followed
    //    by a corretly aligned FONTFILEVIEW structure

        unsigned offset;

    // offset - offset of FONTFILEVIEW structure from the beginning
    //     of the block of memory pointed to by apfv. This is equal to the
    //     offset of the nearest double following the array of pointers.
    //     In C, a double is maximally aligned.

        offset = ALIGN8(cFiles * sizeof(void*));

        apfv = (FONTFILEVIEW**) PALLOCMEM(offset + cFiles*sizeof(FONTFILEVIEW),'vffG');

        if (apfv == NULL)
        {
            WARNING("Out of memory\n");
            return(FALSE);
        }

    // pfv - pointer to FONTFILEVIEW structure following the array of
    //     cFiles pointers.

        FONTFILEVIEW *pfv = (FONTFILEVIEW*)(((char*) apfv) + offset);

    // init the data for all files;

        PWSZ   pwszTmp = pwszPathname;
        ULONG  iFile;

        for (iFile = 0; iFile < cFiles; iFile++)
        {
            apfv[iFile] = &pfv[iFile];

            apfv[iFile]->pwszPath = pwszTmp;

            if (!EngMapFontFileFDInternal((ULONG_PTR)apfv[iFile], (PULONG*)&apvView[iFile], &acjView[iFile], FALSE))
            {
                WARNING("EngMapFontFile failed\n");

            // clean up, unmap all of those mapped so far

                for (ULONG jFile = 0; jFile < iFile; jFile++)
                    EngUnmapFontFileFD((ULONG_PTR)apfv[jFile]);

                VFREEMEM(apfv);
                return(FALSE);
            }

            // get to the next file in the multiple path

            while (*pwszTmp++)
                ;
        }

        PPDEV   ppDevList;

        // order of grabbing semaphores important

        GreAcquireSemaphoreEx(ghsemDriverMgmt, SEMORDER_DRIVERMGMT, NULL);
        vLoadFontFileView(pwszPathname, cwc, apfv, cFiles, apvView, acjView, pdv, cjDV, &hffNew, &ppDevList, &fntCheckSum);
        PDEVOBJ pdo((HDEV)ppDevList);
        GreReleaseSemaphoreEx(ghsemDriverMgmt);

        ASSERTGDI(bRet==FALSE,"bRet != FALSE\n");

        if (hffNew != HFF_INVALID)
        {
        // cFonts = number of faces in the file

            cFonts = pdo.QueryFontFile( hffNew,
                                        QFF_NUMFACES,
                                        0,
                                        NULL);

            if (cFonts && cFonts != FD_ERROR)
            {
            // EUDC font file can have at most two fonts. If it
            // has two fonts then one of the face names must begin
            // with the '@' character. We check the number of fonts
            // here but we do not check the characters of the
            // face names.

                if (bEUDC && (pEudcLoadData->LinkedFace == NULL) && (cFonts > 2))
                {
                    WARNING("EUDC font file has more than two faces.");
                    return(bRet);
                }

                *pcFonts = cFonts;

            // Create new PFF with table big enough to accomodate
            // the new fonts and pathname.

                PFFCLEANUP *pPFFC = 0;

                PFFMEMOBJ pffmo(cFonts,
                                pwszPathname,cwc, cFiles, pdv, cjDV,
                                hffNew,pdo.hdev(),0,pPFT,fl,flEmbed,&fntCheckSum, apfv, NULL
                               );

                if (pffmo.bValid())
                {
                // Tell the PFF user object to load its table of
                // HPFE's for each font in file.

                    if (!pffmo.bLoadFontFileTable(pwszPathname,
                                                  cFonts,
                                                  (HANDLE) 0,
                                                  NULL,  //PFE_UFIMATCH bit for remote printing
                                                  pEudcLoadData
                                                  ))
                    {
                        *pcFonts = 0;
                    }
                    else
                    {
                    // Font load has succeeded.  If some other process hasn't
                    // already snuck in and added it while the ghsemPublicPFT
                    // semaphore was released, add the new PFF to the PFT.
                    // Stabilize font table before searching or modifying it.

                        SEMOBJ so2(ghsemPublicPFT);

                    // Is PFF already in table?  We check this by
                    // assuming that it already is and attempt to
                    // increment the load count.  If it succeeds, its
                    // there.  If it fails, it not there and we can add
                    // our new PFF to the PFT.

                    #ifdef LANGPACK

                        // do this under the public font table semaphore to
                        // serialize access to the

                        pffmo.vSetUniqueness();
                    #endif

                        if((*pPPFF = pPFFGet(pwszPathname, cwc, cFiles, pdv, cjDV, &ppPFF, bEUDC)) &&
                            (cFonts = chpfeIncrPFF(*pPPFF,&bRet,flEmbed,pEudcLoadData)))
                        {
                        // Some other process got in and put it in before we
                        // could.  chpfeIncrPFF has already incremented the
                        // count for us.  We only need to delete the PFF that
                        // we made which will occur automatically if
                        // bRet = FALSE

                            *pcFonts = cFonts;
                        }
                        else
                        {
                        // Not already in the table, so we really are going
                        // to add it to the PFT.

                            *pPPFF = pffmo.pPFFGet();
                            if(pffmo.bAddHash(bEUDC))
                            {
                            // add entry to head of a doubly linked collision
                            // list

                                pPFT->cFiles++;
                                if (*ppPFF)
                                {
                                    (*ppPFF)->pPFFPrev = *pPPFF;
                                }
                                (*pPPFF)->pPFFNext = *ppPFF;
                                (*pPPFF)->pPFFPrev = 0;
                                *ppPFF = *pPPFF;

                                pffmo.vKeepIt();

                            // need to reset the file paths pointers

                                pwszTmp = pffmo.pwszPathname();

                                for (iFile = 0; iFile < cFiles; iFile++)
                                {
                                    apfv[iFile]->pwszPath = pwszTmp;

                                // get to the next file in the multiple path

                                    while (*pwszTmp++)
                                        ;
                                }
                                bRet           = TRUE;
                            }
                            else
                            {
                                WARNING("pffmo.bAddHash() failed\n");
                                *pcFonts = 0;
                                pffmo.vRemoveHash();
                            }
                        }
                    }

                    if (!bRet)
                    {
                    // must unmap the files before calling pPFFC_Delete()
                    // because this function will delete apfv memory so that unmap
                    // will fail

                        for (iFile = 0; iFile < cFiles; iFile++)
                        {
                            EngUnmapFontFileFD((ULONG_PTR)apfv[iFile]);
                        }

                        pffmo.vPFFC_DeleteAndCleanup();  // new code
                        return bRet;
                    }
                }
            }
        }

    // If you get to here then the font driver recognized the font. Since
    // we cannot be sure that the font will be used immediately, we will
    // unmap font font file and free the memory containing the image of the
    // font file.

        for ( iFile = 0; iFile < cFiles; iFile++ )
        {
            EngUnmapFontFileFD( (ULONG_PTR) apfv[iFile] );
        }

        if (!bRet)
        {
            VFREEMEM(apfv);
        }

        return(bRet);
    }
    else
    {
        PFFCLEANUP *pPFFC = 0;

    // Clone the hffNew and make a new PFF object
        PFFMEMOBJ pffmo(pPFFTemp, fl, flEmbed, pPFT);

        bRet = FALSE;

        cFonts = pPFFTemp->cFonts;

        if (pffmo.bValid())
        {
        // Tell the PFF user object to load its table of
        // HPFE's for each font in file.

            if (!pffmo.bLoadFontFileTable(pwszPathname, cFonts, (HANDLE) 0, NULL, pEudcLoadData))
            {
                *pcFonts = 0;
            }
            else
            {

            // Font load has succeeded.  If some other process hasn't
            // already snuck in and added it while the ghsemPublicPFT
            // semaphore was released, add the new PFF to the PFT.
            // Stabilize font table before searching or modifying it.

                SEMOBJ so2(ghsemPublicPFT);

            // Is PFF already in table?  We check this by
            // assuming that it already is and attempt to
            // increment the load count.  If it succeeds, its
            // there.  If it fails, it not there and we can add
            // our new PFF to the PFT.

            #ifdef LANGPACK

            // do this under the public font table semaphore to
            // serialize access to the

                pffmo.vSetUniqueness();
            #endif

                if((*pPPFF = pPFFGet(pwszPathname, cwc, cFiles, pdv, cjDV, &ppPFF, bEUDC)) &&
                     (cFonts = chpfeIncrPFF(*pPPFF,&bRet,flEmbed,pEudcLoadData)))
                {
                // Some other process got in and put it in before we
                // could.  chpfeIncrPFF has already incremented the
                // count for us.  We only need to delete the PFF that
                // we made which will occur automatically if
                // bRet = FALSE

                    *pcFonts = cFonts;
                }
                else
                {
                // Not already in the table, so we really are going
                // to add it to the PFT.

                    *pPPFF = pffmo.pPFFGet();


                    if(pffmo.bAddHash(bEUDC))
                    {
                    // add entry to head of a doubly linked collision
                    // list

                        pPFT->cFiles++;
                        if (*ppPFF)
                        {
                            (*ppPFF)->pPFFPrev = *pPPFF;
                        }

                        (*pPPFF)->pPFFNext = *ppPFF;
                        (*pPPFF)->pPFFPrev = 0;
                        *ppPFF = *pPPFF;

                        pffmo.vKeepIt();

                        bRet           = TRUE;
                    }
                    else
                    {
                        WARNING("pffmo.bAddHash() failed\n");
                        *pcFonts = 0;
                        pffmo.vRemoveHash();
                    }
                }
            }

            if (!bRet)
            {

            // must unmap the files before calling pPFFC_Delete()
            // because this function will delete apfv memory so that unmap
            // will fail
                pffmo.vPFFC_DeleteAndCleanup();  // new code
            }
        }

        return(bRet);
    }
}


/******************************Public*Routine******************************\
* BOOL PUBLIC_PFTOBJ::bLoadRemoteFonts
*
* Warning:
*
*   This routine or any of the routines that it calls must
*   call EngMapFontFile and EngUnmapFontFile in pairs.
*
* History:
*  Thu 02-Feb-1995 2:04:06 by Gerrit van Wingerden [gerritv]
* Wrote it.
\**************************************************************************/

#define QUICK_VIEWS  4

ULONG PUBLIC_PFTOBJ::ulRemoteUnique = 0;


BOOL PUBLIC_PFTOBJ::bLoadRemoteFonts(
    XDCOBJ &dco,
    PFONTFILEVIEW *ppfv, // points to a pre mapped view of the font
                         // EngMapFontFile must NOT be called
                         // before sending it to the font driver
                         // EngUnmapFontFile must be called at
                         // the end of this routine for possible
                         // error cleanup
    UINT           cNumFonts, // number of files needed to represent this font
    DESIGNVECTOR  *pdv,        // dv for the mm instance
    PUNIVERSAL_FONT_ID  pufi
    )
{
    COUNT cFonts;                   // count of fonts in font file
    BOOL  bRet = FALSE;             // assume failure
    HFF hffNew = HFF_INVALID;       // IFI handle to font file
    ULONG        cjDV = (pdv ? SIZEOFDV(pdv->dvNumAxes) : 0);
    FNTCHECKSUM  fntCheckSum;

    PVOID pvQuickBuffer[QUICK_VIEWS], *ppvViews;
    ULONG pcjQuickBuffer[QUICK_VIEWS], *pcjViews;

    if(cNumFonts > QUICK_VIEWS)
    {
        if(!(ppvViews = (VOID**) PALLOCMEM((sizeof(void*)+sizeof(ULONG*))*cNumFonts,
                                           'vffG')))
        {
            WARNING("bLoadRemoteFonts unable to allocate memory\n");

            // need to free ppfv if this function (bLoadRemoteFonts) fails
            if (ppfv)
            {
                VFREEMEM (ppfv);
            }
            return(FALSE);
        }

        pcjViews = (ULONG*) &ppvViews[QUICK_VIEWS];
    }
    else
    {
        ppvViews = pvQuickBuffer;
        pcjViews = pcjQuickBuffer;
    }

    UINT i;

    for(i = 0; i < cNumFonts; i++)
    {
        ppvViews[i] = ppfv[i]->fv.pvViewFD;
        pcjViews[i] = ppfv[i]->fv.cjView;
    }

    PPDEV   ppDevList;

// order of grabbing semaphores important

    GreAcquireSemaphoreEx(ghsemDriverMgmt, SEMORDER_DRIVERMGMT, NULL);
    vLoadFontFileView(NULL, 0, ppfv, cNumFonts, ppvViews, pcjViews, pdv, cjDV, &hffNew, &ppDevList, &fntCheckSum);
    PDEVOBJ pdo((HDEV)ppDevList);
    GreReleaseSemaphoreEx(ghsemDriverMgmt);

    if(ppvViews != pvQuickBuffer)
    {
        VFREEMEM(ppvViews);
    }

    ASSERTGDI(bRet==FALSE,"bRet != FALSE\n");

    if (hffNew != HFF_INVALID)
    {
        //
        // cFonts = number of faces in the file
        //

        cFonts = pdo.QueryFontFile( hffNew, QFF_NUMFACES, 0, NULL);

        if (cFonts && cFonts != FD_ERROR)
        {
            WCHAR awc[30];

            // Create a (hopefully) unique file name for
            // the remote font of the form "REMOTE nnnnnnnn"

            swprintf(
                awc,
                L"REMOTE-%u",
                ulGetNewUniqueness(PUBLIC_PFTOBJ::ulRemoteUnique));
                ULONG cwc = wcslen(awc) + 1;

            // Create new PFF with table big enough to accomodate
            // the new fonts and pathname.

            PFFCLEANUP *pPFFC = 0;
            PFFMEMOBJ
            pffmo (cFonts,
                   awc, cwc, cNumFonts,  // pwsz, cwc, cFiles
                   pdv, cjDV,            // pdv, cjDV,
                   hffNew,
                   pdo.hdev(),
                   0,
                   pPFT,
                   PFF_STATE_DCREMOTE_FONT,
                   FR_NOT_ENUM, // never enum fonts that are temporarily
                   &fntCheckSum,
                   ppfv,        // loaded on printer server until print job is done
                   pufi);       // use this ufi instead of calculate from the ppfv for remote printing
            if (pffmo.bValid())
            {
                // Tell the PFF user object to load its table of
                // HPFE's for each font in file.


                if (  pffmo.bLoadFontFileTable(awc,
                                               cFonts,
                                               dco.hdc(),
                                               pufi,   // fonts can be mapped only by bFoundForcedMatch() calls
                                               NULL    // for remote printing.
                                              ))
                {
                    // Stabilize font table before searching or modifying it.

                    SEMOBJ so2(ghsemPublicPFT);

                    if(bRet = pffmo.bAddHash(FALSE))
                    {
                        PFF **ppPFF, *pPFF;

                        pPFF = pPFFGet(awc, cwc, cNumFonts, pdv, cjDV, &ppPFF);

                        if (pPFF)
                        {
                        #if DBG
                            KdPrint(("\"%ws\" has been found on the font table\n"));
                            KdBreakPoint();
                        #endif

                            bRet = FALSE;
                        }
                        else
                        {
                            pPFF = pffmo.pPFFGet();
                            if( bRet = dco.bAddRemoteFont( pPFF ) )
                            {
                                pPFT->cFiles++;

                                // place the pointer to this new remote
                                // PFF at the head of the public PFT.

                                if (*ppPFF)     // head of list exist?
                                {               // yes make it follow new PFF
                                    (*ppPFF)->pPFFPrev = pPFF;
                                }
                                pPFF->pPFFNext = *ppPFF;
                                pPFF->pPFFPrev = 0; // new PFF is first in list
                                *ppPFF = pPFF;

                                pffmo.vKeepIt();
                            }
                        }
                    }
                    else
                    {
                        pffmo.vRemoveHash();
                    }

                    // Here we should add it to our HDC's font table.
                }

                // call this if the above addition to the HDC's font table
                // fails

                if (!bRet)
                {
            pffmo.vPFFC_DeleteAndCleanup();  // new code
        }
            }
        }
    }
    return(bRet);
}


/******************************Public*Routine******************************\
* PFTOBJ::bLoadDeviceFonts
*
* This function loads the device fonts of the device identified by the pair
* (pldo, hdev) into the public table.  There are cFonts number of device
* fonts.
*
* The function will enlarge the PFT and create a PFF to contain the new fonts.
* The actual work of loading each device font into the tables is carrided
* out by PFF::bLoadDeviceFontTable().
*
* Note:
*   All the device fonts of a particular physical device are grouped together
*   as if they were in a single file and are placed all within a single PFF,
*   with each font represented by a single PFE.
*
* Note:
*   The function does not bother to check if the device fonts already are
*   in the tree.*
*
* Returns:
*   TRUE if successful, FALSE if an error occurs.
*
* History:
*  Mon 15-Aug-1994 11:57:14 by Kirk Olynyk [kirko]
* Modified it for the new hashing scheme (not the same thing as font name
* hashing, which remains unchanged).
*  18-Mar-1991 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/

BOOL
DEVICE_PFTOBJ::bLoadFonts(
    PPDEVOBJ    ppdo
    )
{
    PFF *pPFF, **ppPFF;
    BOOL bRet = FALSE;
    FNTCHECKSUM fntCheckSum;

    {
        SEMOBJ so(ghsemPublicPFT);
        if (pPFFGet(ppdo->hdev(), &ppPFF))
        {
            bRet = TRUE;
        }
    }

    if (!bRet)
    {
        //
        // create new PFF with table big enough to accomodate the
        // new device fonts
        //
        // the 'dhpdev' is used only for drivers that are font producers,
        // and consequently are not affected by dynamic mode changing.
        // We have to call 'dhpdevNotDynamic' to avoid an assert
        //

        fntCheckSum.ulFastCheckSum = 0;
        fntCheckSum.ulCheckSum = 0;

        PFFMEMOBJ pffmo(ppdo->cFonts(),
                        NULL,0,0,         // no path, no files,
                        NULL, 0,          // no pdv, cjDV,
                        HFF_INVALID,
                        ppdo->hdev(),
                        ppdo->dhpdevNotDynamic(),
                        pPFT,
                        0,
                        0,       // flEmbed
                        &fntCheckSum,    // pointer to PFNTCHECKSUM, on return fill in slow check sum
                        NULL,    // no views of the mapped font files
                        NULL     // pufi
                        );

        if (pffmo.bValid())
        {
            if (!pffmo.bLoadDeviceFontTable(ppdo))
            {
                WARNING("pffmo.bLoadDeviceFontTable() failed\n");
            }
            else
            {
                SEMOBJ so(ghsemPublicPFT);

                // if (!font_is_loaded_already) add_font_to_table;

                if (!(pPFF = pPFFGet(ppdo->hdev(), &ppPFF)))
                {
                    if (!pffmo.bAddHash(FALSE))
                    {
                        WARNING("gdisrv!bLoadDeviceFontsPFTOBJ()"
                                ": failed to add to font hash\n");
                        pffmo.vRemoveHash();
                    }
                    else
                    {
                        // Add file to font table

                        // Insert PFF at the head of the linked list
                        // pointed to by ppPFF

                        pPFF = pffmo.pPFF;  // convenient pointer.
                        pPFT->cFiles += 1;  // Increment total number
                                            //               of files in table.
                        if (*ppPFF)         // Is there a PFF at the head
                                            //         of the linked list?
                            (*ppPFF)->pPFFPrev = pPFF; // Yes, put this new
                        pPFF->pPFFNext = *ppPFF;       //  PFF in front of old.
                        pPFF->pPFFPrev = 0; // Nothing before new font.
                        *ppPFF = pPFF;      // Reset pointer to head of list.
                        pffmo.vKeepIt();    // Prevent ~PFFMEMOBJ from
                                            //                  freeing memory.
                        bRet = TRUE;
                    }
                }
            }
            if (!bRet)
            {
                pffmo.vPFFC_DeleteAndCleanup();  // new code
            }
        }
    }
    return(bRet);
}

#if 0

typedef struct _FONT_STRUCT_DATA {
    ULONG fontDataSize;
    ULONG fontMaxDataSize;
    ULONG cRegistryFonts;
    ULONG cMaxRegistryFonts;
    ULONG cHashBuckets;
    PBYTE pFont;
} FONT_STRUCT_DATA, *PFONT_STRUCT_DATA;

extern "C"
NTSTATUS
QueryRegistryFontListRoutine
(
    PWSTR ValueName,
    ULONG ValueType,
    PVOID ValueData,
    ULONG ValueLength,
    PVOID Context,
    PVOID EntryContext
)
{

    PFONT_STRUCT_DATA pFontStructData = (PFONT_STRUCT_DATA) Context;
    ULONG Length;

    if ( (pFontStructData->fontDataSize + ValueLength >
          pFontStructData->fontMaxDataSize) ||
         (pFontStructData->cRegistryFonts >= pFontStructData->cMaxRegistryFonts) ||
         (pFontStructData->cRegistryFonts >= pFontStructData->cHashBuckets) )
    {
        //
        // The buffer is too small - reallocate it (leave lots of place to
        // build the hash table at the end
        //

        PBYTE pjBuffer;
        ULONG i;
        ULONG oldMaxSize = pFontStructData->fontMaxDataSize;

        pFontStructData->fontMaxDataSize += 0x100;
        pFontStructData->cMaxRegistryFonts += 10;
        pFontStructData->cHashBuckets = pFontStructData->cMaxRegistryFonts * 2;

        pjBuffer = (PBYTE) PALLOCMEM(pFontStructData->fontMaxDataSize +
                                     pFontStructData->cMaxRegistryFonts *
                                         sizeof(PBYTE) +
                                     pFontStructData->cHashBuckets *
                                          sizeof(REGHASHBKT) * 2, 'gerG');

        //
        // The buffer has three sections
        // 1) the first part of the buffer contains all the NULL terminated
        //    strings of the font files.
        // 2) an array of pointers to these strings.
        // 3) space for the hash table
        //
        // When copying the buffer, 1) can just be moved, 2) has to be adjusted
        // and 3) is not touched - has to be zero initialized
        //

        if (pjBuffer)
        {
            //
            // If we have an old one, move it to the new one, and then
            // always reset the pointer.
            //

            if (pFontStructData->fontDataSize)
            {
                //
                // Adjust the pointers - requires doing arithmetic on the
                // pointers themselves !
                //

                for (i=0; i < pFontStructData->cRegistryFonts; i++)
                {
                    *( ((PULONG)(pjBuffer +
                    pFontStructData->fontMaxDataSize)) + i ) =
                        *( ((PULONG)(pFontStructData->pFont + oldMaxSize)) + i )
                        + pjBuffer - pFontStructData->pFont;
                }

                //
                // Copy all the data to the new Buffer
                //

                RtlMoveMemory(pjBuffer,
                              pFontStructData->pFont,
                              pFontStructData->fontDataSize);

                VFREEMEM(pFontStructData->pFont);
            }

            pFontStructData->pFont = pjBuffer;
        }
        else
        {
            //
            // we do not have enough memory - return failiure
            //

            return STATUS_NO_MEMORY;
        }
    }

    Length = cCapString((PWSTR) (pFontStructData->pFont +
                                     pFontStructData->fontDataSize),
                        (const WCHAR*) ValueData,
                        ValueLength / 2);

    ASSERTGDI(Length * 2 + 2 == ValueLength,
              "QueryRegistryFontListRoutine CapString problem\n");

    * ( ((PBYTE *)(pFontStructData->pFont + pFontStructData->fontMaxDataSize)) +
        pFontStructData->cRegistryFonts) =
            pFontStructData->pFont + pFontStructData->fontDataSize;

    pFontStructData->fontDataSize += ValueLength;
    pFontStructData->cRegistryFonts += 1;

    return STATUS_SUCCESS;

}

#endif

/******************************Public*Routine******************************\
*
* BOOL PFTOBJ::bUnloadAllButPermanentFonts
*
* If bUnloadPermanent == FALSE (default):
*
* Called at log-off time to force unloading off all but permanent
* fonts Permanent fonts are defined as either console fonts or
* fonts from Gre_Initialize section of win.ini (i.e.  registry).
* Fonts from the "Fonts" section in win.ini (registry) are also
* permanent if they are on the local hard drive.  If they are
* remote they will get reloaded at the log on time.  This should
* be done after the net connections from the user profile are
* restored so that the font can get reloaded.
*
* If bUnloadPermanent == TRUE:
*
* All fonts in table are unloaded.  Only used for MultiUserGreCleanupAllFonts
* (i.e, MultiUserGreCleanup or Hydra processing).
*
* History:
*  30-Nov-1993 -by- Bodin Dresevic [BodinD]
* Wrote it.
\**************************************************************************/

typedef struct _FONTVICTIM
{
    PFF   *pPFFVictim;
    RFONT *prfntVictims;
} FONTVICTIM;

FONTVICTIM gFntVict[64];

BOOL PFTOBJ::bUnloadAllButPermanentFonts (BOOL bUnloadPermanent)
{
    // pointer to the array of cFonts victim structures.  Only as
    // many entries of this array will be initialized as there are
    // non-permanent fonts in the pft.  These fonts will be deleted
    // outside of the pft semaphore.

    FONTVICTIM *pvict, *pvictCur;
    COUNT      cFile, cFonts;
    PFF        *pPFF;
    BOOL        bAlloc = FALSE;

    // Look for the PFF to unload.

    {
        // Stablize table while we scan it for victims.

        SEMOBJ so(ghsemPublicPFT);

        // alloc mem for the array of font victims
        // It is essential that this memory is zero initialized
        // This must be done under semaphore, otherwise cFonts might change;

        cFonts = pPFT->cFiles;

        if (cFonts == 0)
        {
            // gpPFTDevice initialized but no device font loaded.
            // Seen this on Hydra.

            return TRUE;
        }

        if ( cFonts > 64)
        {
            if (!(pvict = (FONTVICTIM *)PALLOCNOZ(cFonts * sizeof(FONTVICTIM),'ivfG')))
            {
                WARNING(
                    "PFTOBJ::bUnloadAllButPermanentFonts failure\n"
                    "Failed to allocate memeory for font victim list\n");

                return FALSE;
            }

            bAlloc = TRUE;
        }
        else
        {
            pvict = &gFntVict[0];
        }

        pvictCur = pvict;

        // Caution with this code: pPFT->cFiles changes in the loop
        // This loop does two things:
        // a) stores the pPFFVictim information in the pvict array
        //    for the fonts that are going to be unloaded outside
        //    the semaphore.
        // b) contracts the pft table to contain only the permanent
        //    fonts upon the exit of the loop

        for (
            PFF **ppPFF = pPFT->apPFF
          ; ppPFF < pPFT->apPFF + pPFT->cBuckets
          ; ppPFF++
        )
        {
          for (pPFF = *ppPFF; pPFF; pPFF = pPFF->pPFFNext)
          {
            // Create a PFF user object.  There shouldn't be any invalid
            // handles in the PFT.

            PFFOBJ  pffo(pPFF);
            ASSERTGDI(pffo.bValid(),
                "gdisrv!bUnloadFontPFTOBJ(file): bad PPFF in public PFT\n");

            // Is it a font driver loaded file?  And if so, is this not a
            // permanent file (listed in Gre_Initialize or loaded by
            // console or local font from "fonts" section of the registry)
            // We also leave alone fonts loaded temporarily for printing

            if (bUnloadPermanent || !(pffo.bPermanent() || pffo.bDCRemote()))
            {
                ASSERTGDI(!pffo.bDCRemote(), "bUnloadAllButPermanentFonts: "
                          "EMF spooler playback fonts still present!\n");

                // Tell PFF to decrement its load count and ask it if is
                // ready to die.  If it returns TRUE, we will need to delete
                // (outside of semaphore since PFF deletion may cause driver
                // to be called).

                // we force the load count to zero. We are forcing the unload
                // of this font

                pffo.vSet_cLoaded((COUNT)0); // not loaded any more,
                                             // avoid asserts
                pffo.vSet_cNotEnum((COUNT)0);

                pffo.vKill();

                {
                    // unlink the PFF from the collision list

                    if (*ppPFF == pPFF)
                    {
                        // The hash bucket contains a pointer to the first
                        // PFF in the collision list. If it turns out that
                        // the victim is this first in the list, then the
                        // address storred in the hash bucket must be changed

                        *ppPFF = pPFF->pPFFNext;
                    }
                    if (pPFF->pPFFNext)
                    {
                        pPFF->pPFFNext->pPFFPrev = pPFF->pPFFPrev;
                    }
                    if (pPFF->pPFFPrev)
                    {
                        pPFF->pPFFPrev->pPFFNext = pPFF->pPFFNext;
                    }
                }
                // Save handle of victim.

                pvictCur->pPFFVictim = pffo.pPFFGet();

                // Remove PFF and PFEs from hash tables.  Fonts in this
                // font file will no longer be enumerated or mapped to.

                pffo.vRemoveHash();
                pPFT->cFiles--;

                // Construct a "kill" list of RFONTs.

                pvictCur->prfntVictims = prfntKillList(pffo);

                // point to the next entry in pvictCur array

                pvictCur++;
            }
            else
            {
                // this is a permanent or a device font, leave them in
                // set init to 1 for the next logon session

                if (pffo.bPermanent() && !(pPFF->flState & PFF_STATE_EUDC_FONT))
                {
                    if ( pffo.cLoaded() )
                    {
                        pffo.vSet_cLoaded((COUNT)1);
                        pffo.vSet_cNotEnum((COUNT)0);
                    }
                    else
                    {
                        pffo.vSet_cLoaded((COUNT)0);
                        pffo.vSet_cNotEnum((COUNT)1);
                    }
                }
            }
          }
        } // end of the for loop

    // at this time if any font were in the private font table, the process
    // cleanup should have removed them (this is logoff time!), therefore there
    // is nothing we need to do about private font table

        #if DBG

        PUBLIC_PFTOBJ pftop(gpPFTPrivate);

        ASSERTGDI((gpPFTPrivate == NULL) || (pftop.cFiles() == 0),
            "some private fonts still around at logoff time\n");

        #endif
    }

// Delete the victims that were found:
// Overload cFonts to mean cFontsToBeDeleted:

// Sundown truncation

    ASSERT4GB((ULONGLONG)(pvictCur - pvict));
    cFonts = (ULONG)(pvictCur - pvict);

    for (cFile = 0; cFile < cFonts; cFile++)
    {
        ASSERTGDI(
            pvict[cFile].pPFFVictim != (PPFF) NULL,
            "GreRemoveAllButPermanentFonts, pPFFVictim IS null\n"
            );
        PFFOBJ pffoVictim(pvict[cFile].pPFFVictim);
        ASSERTGDI(pffoVictim.bValid(),
            "gdisrv!bUnloadFontPFTOBJ(device): PFF victim bad\n");

    // If we need to kill any RFONT victims, now is the time to do it.
    // bKillRFONTList() can handle NULL prfntVictims case.
    // Note that we do not check the return, we go on to the
    // next font [bodind]

        bKillRFONTList(pffoVictim, pvict[cFile].prfntVictims);
    }

// release memory

    if (bAlloc)
        VFREEMEM(pvict);

// We didn't delete anything, but we're ok as long as we found the right
// PFF.  PFF still referenced (either load count or RFONT count) and will
// be deleted later.

    return(TRUE);
}

/******************************Public*Routine******************************\
* bUnloadWorkhorse
*
* History:
*  Mon 15-Aug-1994 14:10:53 by Kirk Olynyk [kirko]
* Wrote it.
\**************************************************************************/

BOOL PFTOBJ::bUnloadWorkhorse(
    PFF *pPFF,
    PFF **ppPFFHead,             // bucket address
    HSEMAPHORE hsem,             // if the pointer is not zero,
                                 //  then this must be a pointer
                                 //  to the public font table
                                 //  semaphore and must be released
                                 //  before this procedure returns
    ULONG   flEmbed              //  Embedding/private flag
)
{
    GDIFunctionID(PFTOBJ::bUnloadWorkhorse);

    PFF *pPFFVictim     = 0;    // Pointer to PFF to be deleted, only
                                // non zero when found and deleted

    BOOL bFoundPFF = FALSE;     // signals PFF was found (does not
                                // indicate deletion status);

    static const PSZ pszReleaseSem = "PFTOBJ::bUnloadWorkhorse()"
                                     " releasing gpPFTPublic";

    TRACE_FONT((
        "Entering PFTOBJ::bUnloadWorkhorse\n"
        "\tpPFF=%-#x\n"
        "\tppPFFHead=%-#x\n",
        "\thsem=%-#x\n",
        pPFF, ppPFFHead, hsem
    ));
    ASSERTGDI(!hsem || hsem==ghsemPublicPFT, "hsem!=ghsemPublicPFT\n");

    if ( pPFF )
    {
        PFFOBJ pffo(pPFF);
        ASSERTGDI(pffo.bValid(), "bad PPFF in public PFT\n");
        PVTDATA *pPvtData = NULL;

        if ((!bIsPrivatePFT()) || (pPvtData = pffo.pPvtDataMatch()))
        {
            // Tell PFF to decrement its load count and ask it if is
            // ready to die.  If it returns TRUE, we will need to
            // delete (outside of semaphore since PFF deletion may
            // cause driver to be called).

            bFoundPFF = TRUE;
            BOOL        bWrongFlags = FALSE;

            if ( pffo.bDeleteLoadRef(flEmbed, pPvtData, &bWrongFlags) )
            {
                // Remove PFF and PFEs from hash tables.  Fonts in this
                // font file will no longer be enumerated or mapped to.

                pffo.vRemoveHash();

                // now remove it from the font table hash

                pPFFVictim = pPFF;

                // If ppPFFHead is NULL then it means that we are
                // unloading  a font that has been added to the DC
                // as a remote font and the this must be the public
                // font table

                PFF **ppPFF = ppPFFHead;
                if( ppPFF == 0 )
                {
                    PUBLIC_PFTOBJ *pTemp;
                    PFF *pPFF_Found;

                    ASSERTGDI(pPFF->pPFT==gpPFTPublic || pPFF->pPFT==gpPFTPrivate,"PFF not in public font table\n");

                    pTemp = (PUBLIC_PFTOBJ*) this;

                    pPFF_Found = pTemp->pPFFGet(pPFF->pwszPathname_,
                                                pPFF->cwc,
                                                pPFF->cFiles,
                                                pPFF->pdv_,
                                                pPFF->cjDV_,
                                                &ppPFF
                                                );

                    ASSERTGDI(pPFF==pPFF_Found,"Could not find remote PFF in the font table\n");
                }
                if (*ppPFF == pPFF)
                {
                    *ppPFF = pPFF->pPFFNext;
                }
                if (pPFF->pPFFNext)
                {
                    (pPFF->pPFFNext)->pPFFPrev = pPFF->pPFFPrev;
                }
                if (pPFF->pPFFPrev)
                {
                    (pPFF->pPFFPrev)->pPFFNext = pPFF->pPFFNext;
                }
                pPFT->cFiles--;
            }
            else
            {
            // Set the return value as FALSE for private/embedded fonts

                if (bIsPrivatePFT() && bWrongFlags)
                {
                    bFoundPFF = FALSE;
                }
            }
        }
        if ( pPFFVictim )
        {
            PFFOBJ pffoVictim(pPFFVictim);
            if ( !pffoVictim.bValid() )
            {
                RIP("pffoVictim is not valid\n");
                bFoundPFF = 0;
            }
            else
            {
                if ( hsem )
                {
                    // The victim has been removed from the table
                    // so the semaphore for the table may be safely
                    // released. It is necessary to do this because
                    // bKillRFONTList() calls RFONTOBJ::bDeleteRFONT()
                    // which in turn locks the display. If we do
                    // not release the font table semaphore before
                    // the device lock, we will have deadlock.

                    TRACE_FONT(("%ws\n", pszReleaseSem));
                    GreReleaseSemaphoreEx(hsem);
                    hsem = 0;
                }

                bFoundPFF = bKillRFONTList( pffoVictim, prfntKillList( pffoVictim ));
            }
        }

        // We didn't delete anything, but we're ok as long as we found
        // the right PFF.  PFF still referenced (either load count or
        // RFONT count) and will be deleted later.
    }

    // Make sure the semampore is released before the procedure ends
    if( hsem )
    {
        TRACE_FONT(("%ws\n", pszReleaseSem));
        GreReleaseSemaphoreEx(hsem);
    }

    TRACE_FONT(("Exiting PFTOBJ::bUnloadWorkhorse\n"
                "\treturn value = %d\n", bFoundPFF));
    return( bFoundPFF );
}

/****************************************************************************
*  INT PFTOBJ::QueryFonts( PUNIVERSAL_FONT_ID, ULONG, PLARGE_INTEGER )
*
*  History:
*   5/24/1995 by Gerrit van Wingerden [gerritv]
*  Wrote it.
*****************************************************************************/


INT PUBLIC_PFTOBJ::QueryFonts(
    PUNIVERSAL_FONT_ID pufi,
    ULONG nBufferSize,
    PLARGE_INTEGER pTimeStamp
)
{
    ULONG cFonts = 0;
    *pTimeStamp = PFTOBJ::FontChangeTime;

// if we aren't supplied with a buffer just return the time stamp and number
// of fonts

    if( ( pufi == NULL ) || ( nBufferSize == 0 ) )
    {
        return(pPFT->cFiles + (UFI_TYPE1_RASTERIZER(&gufiLocalType1Rasterizer) ? 1 : 0));
    }

    PFF *pPFF;
    SEMOBJ so(ghsemPublicPFT);

// Fill the first position with the identifier for the local rasterizer if one
// exists.  This must be the first UFI in the list if it exists.

    if(UFI_TYPE1_RASTERIZER(&gufiLocalType1Rasterizer))
    {
        pufi[cFonts++] = gufiLocalType1Rasterizer;
    }

    for (
        PFF **ppPFF = pPFT->apPFF
      ; (ppPFF < pPFT->apPFF + pPFT->cBuckets) && (cFonts < nBufferSize)
      ; ppPFF++
    )
    {
      for (pPFF = *ppPFF; (pPFF) && (cFonts<nBufferSize); pPFF = pPFF->pPFFNext)
      {
        // Create a PFF user object.  There shouldn't be any invalid
        // handles in the PFT.

        PFFOBJ  pffo(pPFF);
        ASSERTGDI(pffo.bValid(),
            "gdisrv!bUnloadFontPFTOBJ(file): bad PPFF in public PFT\n");

        // be sure not to include remote fonts in list

        if (!pffo.bDCRemote())
        {
        // Set the Index to 1.  This value can be anything since we will only
        // be using the UFI's passed back to determine if font file match.
        // We could just pass back checksums but we may need to expand the
        // UFI structure to include more than checksum's which is why I'm
        // using UFI's.

            pufi[cFonts].Index = 1;
            pufi[cFonts++].CheckSum = pffo.ulCheckSum();
        }
      }
    }

    return(cFonts);
}




/******************************Public*Routine******************************\
* prfntKillList
*
* Scans the display PDEV list looking for inactive RFONTs that realized
* from the given PFF.  These RFONTs are put into a linked list (using the
* PDEV RFONTLINKs) that is returned as the function return.
*
* The function is quite aggressinve in its definition of an inactive RFONT.
* In addition to looking for victims on the inactive list of each PDEV,
* the function also scans the DC list off each PDEV for RFONTs that are
* selected into currently unused DCs.
*
* We're not worried about being aggressive with non-display PDEVs.  The
* PDEV cleanup code will destroy extraneous RFONTs directly using the PDEV's
* RFONT list(s).
*
* The reason we are building a list of RFONT victims rather than killing
* them immediately is because we are holding the ghsemPublicPFT semaphore
* when this function is called.
*
* Returns:
*   Pointer to the kill list, NULL if the list is empty.
*
* History:
*  11-Mar-1993 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
static
RFONT *prfntKillList(PFFOBJ &pffoVictim)
{
    TRACE_FONT((
        "Entering prfntKillList\n\tpffoVictim.pPFF = %-#x\n",pffoVictim.pPFF));
    RFONT *prfntDeadMeat = PRFNTNULL;

    // Must hold this semaphore to be sure that the display
    // PDEV list is stable.

    SEMOBJ so1(ghsemDriverMgmt);

    // Must hold this semaphore so we can manipulate the RFONT links and
    // RFONT::cSelected.

    SEMOBJ so2(ghsemRFONTList);
    TRACE_FONT(("Acquiring ghsemRFONTList\n"));

    // Must hold this mutex so that no one else tries to come in and lock
    // a DC while we're scanning the DC lists off the PDEVs.
    //
    // Since we're holding this mutex, we must be extremely careful not
    // to create any user objects that will try to regrab the mutex.
    // That is bad bad bad bad.

    MLOCKFAST mlf;
    TRACE_FONT(("Acquiring handle management semaphore\n"));

    PDEV *pPDEV = gppdevList;

    // Scan through the list of display PDEVs.

    while (pPDEV != NULL)
    {
        if (pPDEV->fl & PDEV_DISPLAY)
        {
            // Scan the RFONT active list for candidates made inactive by our
            // scan of the DC list.

            RFONT *prfntCandidate;

            for ( prfntCandidate = pPDEV->prfntActive;
                  prfntCandidate != PRFNTNULL;
                )
            {
                RFONTTMPOBJ rfo(prfntCandidate);

                // We have to grab the next pointer before we (possibly)
                // remove the current RFONT from the list.

                prfntCandidate = prfntCandidate->rflPDEV.prfntNext;

                // If this is an interesting RFONT (i.e., uses our PFF),
                // then take it out of the list.

                if ( (rfo.pPFF() == pffoVictim.pPFFGet()) && !rfo.bActive() )
                {
                    RFONT *prfntHead = pffoVictim.prfntList();
                    rfo.vRemove(&prfntHead, PFF_LIST);
                    pffoVictim.prfntList(prfntHead);

                    rfo.vRemove(&pPDEV->prfntActive, PDEV_LIST);
                    rfo.vInsert(&prfntDeadMeat, PDEV_LIST);
                }
            }

            // Scan the RFONT inactive list for candidates.

            for (prfntCandidate = pPDEV->prfntInactive;
                 prfntCandidate != PRFNTNULL;
                 )
            {
                RFONTTMPOBJ rfo(prfntCandidate);

                // We have to grab the next pointer before we (possibly)
                // remove the current RFONT from the list.

                prfntCandidate = prfntCandidate->rflPDEV.prfntNext;

                // If this is an interesting RFONT (i.e., uses our PFF),
                // then take it out of the list.

                if ( rfo.pPFF() == pffoVictim.pPFFGet() )
                {
                    RFONT *prfntHead = pffoVictim.prfntList();
                    rfo.vRemove(&prfntHead, PFF_LIST);
                    pffoVictim.prfntList(prfntHead);

                    rfo.vRemove(&pPDEV->prfntInactive, PDEV_LIST);
                    rfo.vInsert(&prfntDeadMeat, PDEV_LIST);

                    // Since we've removed a font from the inactive list, we
                    // need to update the count in the PDEV.

                    pPDEV->cInactive -= 1;
                }
            }
        }
        pPDEV = pPDEV->ppdevNext;
    }
    TRACE_FONT(("Releasing handle management semaphore\n"));
    TRACE_FONT(("Releasing ghsemRFONTList\n"));
    TRACE_FONT(("Releasing ghsemDriverMgmt\n"));
    TRACE_FONT(("Exiting prfntKillList\n\treturn value=%-#x\n", prfntDeadMeat));
    return(prfntDeadMeat);
}

/******************************Public*Routine******************************\
* bKillRFONTList
*
* Runs down a linked list (that is linked via the PDEV RFONTLINK's) and
* deletes each RFONT on it.  Hold no global semaphores while calling this
* because we may call out to a driver.
*
* History:
*  11-Mar-1993 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/
static
BOOL bKillRFONTList(PFFOBJ &pffoVictim, RFONT *prfntVictims)
{
    // If kill list is NULL, it is already OK to delete the PFF.
    // However, we will have to do the work in here rather than let
    // RFONTOBJ::bDeleteRFONTRef() do the work for us.

    BOOL bRet;
    TRACE_FONT((
        "Entering bKillRFONTList\n"
        "\t*pffoVictim.pPFF=%-#x\n"
        "\tprfntVictims=%-#x\n"
        , pffoVictim.pPFF, prfntVictims
    ));

    if (prfntVictims == (PRFONT) NULL)
    {
        BOOL    bCleanUp = FALSE;

        PFFCLEANUP pffc;

        {
            // Need semaphore to access cRFONT.

            SEMOBJ so(ghsemPublicPFT);

            // If no more RFONTs for this PFF, OK to delete.
            // Load count is implied to be zero
            // (only time we call this function).

            // For private/embedded fonts, pPvtDataHead needs to be NULL too.

            ASSERTGDI( (pffoVictim.cLoaded() == 0 && pffoVictim.cNotEnum() == 0 && pffoVictim.pPvtDataHeadGet() == NULL),
                "gdisrv!bKillRFONTList(): PFF load count not zero\n");

            if (pffoVictim.cRFONT() == 0)
            {
            // It is now safe to delete the PFF.

                pffoVictim.vPFFC_Delete(&pffc);

                bCleanUp = TRUE;
            }
        }

        // Call the driver outside of the semaphore.

        if (bCleanUp)
        {
            vCleanupFontFile(&pffc);     // function can handle NULL case
        }

        bRet = TRUE;

    }
    else
    {

        // Otherwise, we will delete the RFONTs in the kill list.  If and when
        // the last RFONT dies, RFONTOBJ::bDeleteRFONTRef() will delete the PFF.

        PRFONT prfnt;

        while ( (prfnt = prfntVictims) != (PRFONT) NULL )
        {
            prfntVictims = prfntVictims->rflPDEV.prfntNext;

            RFONTTMPOBJ rflo(prfnt);

            ASSERTGDI(!rflo.bActive(),
                "gdisrv!bKillRFONTList(): RFONT still active\n");

            PDEVOBJ pdo(rflo.hdevConsumer());
            ASSERTGDI(pdo.bValid(), "gdisrv!bKillRFONTList(): invalid HPDEV\n");

            rflo.bDeleteRFONT((PDEVOBJ *) NULL, (PFFOBJ *) NULL);
            bRet = pffoVictim.bDeleteRFONTRef();
        }
    }
    TRACE_FONT(("Exiting bKillRFONTList\n\treturn value = %d\n", bRet));
    return(bRet);
}

/******************************Public*Routine******************************\
* cCapString (pwcDst,pwcSrc,cMax)                                          *
*                                                                          *
* A useful routine to capitalize a string.  This is adapted to our name    *
* strings that show up in logical fonts.  They may or may not have NULL    *
* terminators, but they always fit in a given width.                       *
*                                                                          *
* We assume that we may overwrite the last character in the buffer if      *
* there is no terminator!  (That's what the code was doing when I got      *
* to it.)                                                                  *
*                                                                          *
* Returns: The length, in characters, of the resultant string.             *
*                                                                          *
* History:                                                                 *
*  Sun 13-Dec-1992 17:22:25 -by- Charles Whitmer [chuckwh]                 *
* Wrote it.                                                                *
\**************************************************************************/

LONG cCapString(WCHAR *pwcDst, const WCHAR *pwcSrc,INT cMax)
{
    UNICODE_STRING csSrc,csDst;
    const WCHAR *pwc,*pwcEnd;
    INT cLen;

    // Count the length of the given string, but note that we can be given a
    // string with cMax characters and no terminator!
    // In that case, we truncate the last character and replace it with NULL.

    pwc = pwcSrc;
    pwcEnd = pwc + cMax - 1;

    while (pwc<pwcEnd && *pwc)
        pwc++;

    // Sundown: cMax is int, pwcEnd = cMax -1, safe to truncate

    cLen = (int)(pwc - pwcSrc);            // cLen <= cMax-1, always.

    if (cLen)
    {
        // Initialize the counted string structures.

        csSrc.Length = (USHORT)(cLen * sizeof(WCHAR));    // Measured in bytes!
        csSrc.Buffer = const_cast<WCHAR *>(pwcSrc);
        csSrc.MaximumLength = (USHORT)(cMax * sizeof(WCHAR));

        csDst.Buffer = pwcDst;
        csDst.MaximumLength = (USHORT)(cMax * sizeof(WCHAR));

        // Convert the string.

        RtlUpcaseUnicodeString(&csDst,&csSrc,FALSE);
    }

    // NULL terminate the result.

    pwcDst[cLen] = 0;
    return(cLen);
}

/******************************Member*Function*****************************\
* UINT iHash                                                               *
*                                                                          *
* A case dependent hashing routine for Unicode strings.                    *
*                                                                          *
* Input:                                                                   *
*                                                                          *
*   pwsz                    pointer to the string to be hashed             *
*   c                       number to be mod'ed against at the end         *
*                                                                          *
* Reutrns:                                                                 *
*                                                                          *
*   a 'random' number in the range 0,1,...,c-1                             *
*                                                                          *
* Note: All strings must be capitalized!                                   *
*                                                                          *
* History:                                                                 *
*  Wed 07-Sep-1994 08:12:22 by Kirk Olynyk [kirko]                         *
* Since chuck is gone the mice are free to play. So I have replaced        *
* it with my own variety. Tests show that this one is better. Of           *
* course, once I have gone someone will replace mine. By the way,          *
* just adding the letters and adding produces bad distributions.           *
*  Tue 15-Dec-1992 03:13:15 -by- Charles Whitmer [chuckwh]                 *
* Wrote it.  It looks crazy, but I claim there's a theory behind it.       *
\**************************************************************************/
static
UINT iHash(const WCHAR * pwsz, UINT c)
{
    unsigned i = 0;
    while (*pwsz)
    {
        // use the lower byte since that is where most of the
        // interesting stuff happens

        i += 256*i + (UCHAR) *pwsz++;
    }
    return(i % c);
}

/******************************Member*Function*****************************\
* FHOBJ::vInit                                                             *
*                                                                          *
* History:                                                                 *
*  Mon 14-Dec-1992 18:38:35 -by- Charles Whitmer [chuckwh]                 *
* Compressed the table to contain only pointers to buckets.                *
*                                                                          *
*  Tue 14-Apr-1992 13:48:53 by Kirk Olynyk [kirko]                         *
* Wrote it.                                                                *
\**************************************************************************/

VOID FHOBJ::vInit(FONTHASHTYPE fht_,UINT c)
{
    pfh->id       = FONTHASH_ID;
    pfh->fht      = fht_;
    pfh->cBuckets = c;

    // Currently, none of the buckets are in use

    pfh->cUsed = 0;
    pfh->cCollisions = 0;
    RtlZeroMemory(pfh->apbkt,sizeof(*(pfh->apbkt)) * pfh->cBuckets);

    // Setup head and tail pointers to the doubly linked list of
    // buckets.  This list is maintained in load order.  The ordinal
    // of a bucket is the load time of the earliest loaded PFE in a
    // bucket's list.

    pfh->pbktFirst = (HASHBUCKET *) NULL;
    pfh->pbktLast  = (HASHBUCKET *) NULL;
}

/******************************Member*Function*****************************\
* FHOBJ::vFree                                                             *
*                                                                          *
* History:                                                                 *
*  Tue 15-Dec-1992 00:53:39 -by- Charles Whitmer [chuckwh]                 *
* Deletes remaining hash buckets.                                          *
*                                                                          *
*  Tue 14-Apr-1992 13:48:56 by Kirk Olynyk [kirko]                         *
* Wrote it.                                                                *
\**************************************************************************/

VOID FHOBJ::vFree()
{
    HASHBUCKET *pbkt,*pbktNext;

    if (pfh)
    {
        // Unfortunately, we get called here while a string of PFE's may be
        // hanging on.  One of the PFTOBJ::bUnloadFont calls kills the PFE's
        // separately.
        // We still need to free the small pfel bloks that
        // define enumeration links

        // Clean up any hash buckets.

        for (UINT ii=0; ii<pfh->cBuckets; ii++)
        {
            for
            (
                pbkt = pfh->apbkt[ii];
                pbkt != (HASHBUCKET *) NULL;
                pbkt = pbktNext
            )
            {
                pbktNext = pbkt->pbktCollision;

                // now free the small linking blocks:

                {
                    PFELINK *ppfel = pbkt->ppfelEnumHead;
                    PFELINK *ppfelNext;
                    for ( ; ppfel ; ppfel = ppfelNext)
                    {
                        ppfelNext = ppfel->ppfelNext;
                        VFREEMEM(ppfel);
                    #if DBG
                        if (ppfelNext == NULL)
                        {
                            ASSERTGDI(ppfel == pbkt->ppfelEnumTail,
                               "FHOBJ::vFree(), problem with ppfelEnumTail\n");
                        }
                    #endif
                    }
                }

                VFREEMEM(pbkt);
            }
        }

        // Free the table itself.

        VFREEMEM(pfh);
    }
    pfh   = 0;
    *ppfh = 0;
}

/******************************Member*Function*****************************\
* FHOBJ::pbktSearch (pwsz,pi)                                              *
*                                                                          *
* Tries to locate a HASHBUCKET for the given string.  If found, a pointer  *
* is returned, else NULL.  If pi is non-NULL, the hash index is returned   *
* in either case.                                                          *
*                                                                          *
* History:                                                                 *
*  Mon 14-Dec-1992 21:11:14 -by- Charles Whitmer [chuckwh]                 *
* Wrote it.  Differs from KirkO's old iSearch in that it assumes that all  *
* strings are capitalized, and the hash table is full of pointers to       *
* HASHBUCKETs instead of HASHBUCKETs.                                      *
\**************************************************************************/

HASHBUCKET *FHOBJ::pbktSearch(const WCHAR * pwsz,UINT *pi,PUNIVERSAL_FONT_ID pufi, BOOL bEquiv)
{
    UINT i;
    HASHBUCKET *pbkt;

// If we are requested to look only for equivalency buckets, and we find it,
// we shall return it.

// If we are asked to look for any kind of bucket, and we found equivalency
// bucket first in the linked list, we shall continue to search the linked
// list until we possibly find a non-equivalency bucket. If found both
// equivalency and non-equivalency bucket, we return non-equivalency bucket.
// If we find a non-equivalency bucket, we shall just return.

    HASHBUCKET *pbktEquiv = NULL;

// Locate the hash entry.

    if( pwsz == NULL )
    {
        if( pufi == NULL )
        {
            return NULL;
        }
        i = UFI_HASH_VALUE(pufi) % pfh->cBuckets;
    }
    else
    {
        i = iHash(pwsz,pfh->cBuckets);
    }

// Return the index for those who care.

    if (pi != (UINT *) NULL)
        *pi = i;

// Try to find an existing bucket that matches exactly.

    for
    (
      pbkt =  pfh->apbkt[i];
      pbkt != (HASHBUCKET *) NULL;
      pbkt = pbkt->pbktCollision
    )
    {
        if( pufi != NULL )
        {
            if( UFI_SAME_FILE(&pbkt->u.ufi,pufi) )
            {
                return(pbkt);
            }
        }
        else
        {
            if (!bEquiv || (pbkt->fl & HB_EQUIV_FAMILY))
            {
                const WCHAR *pwcA,*pwcB;
                for (pwcA=pwsz,pwcB=pbkt->u.wcCapName; *pwcA==*pwcB; pwcA++,pwcB++)
                {
                    if (*pwcA == 0)
                    {
                        if (bEquiv)
                        {
                            return(pbkt);
                        }
                        else
                        {

                            if (pbkt->fl & HB_EQUIV_FAMILY)
                            {
                                pbktEquiv = pbkt;
                                break;
                            }
                            else
                            {
                                return(pbkt);
                            }
                        }
                    }
                }
            }
        }
    }
    return(pbktEquiv);
}


/******************************Public*Routine******************************\
*
* BOOL FHOBJ::bAddPFELink
*
* History:
*  02-Jul-1997 -by- Bodin Dresevic [BodinD]
* Wrote it.
\**************************************************************************/



BOOL FHOBJ::bAddPFELink(
    HASHBUCKET *pbkt,    // pointer to bucket with this family name/ufi (if found)
    UINT        iBucket, // index into hash table for this pfe
    WCHAR      *pwcCap,  // capitalized family name
    PFEOBJ&     pfeoNew, // pfe for which we are adding the link
    BOOL        bEquiv   // create equiv or non-equivalency bucket
)
{

    PFELINK *ppfel = NULL;

    if (ppfel = (PFELINK *)PALLOCMEM(sizeof(PFELINK), 'knlG'))
    {
        ppfel->ppfelNext = NULL; // we have just added it;
        ppfel->ppfe      = pfeoNew.ppfeGet();

    // we will create a new bucket if the bucket with this face name does not exist
    // or if we are attempting to create a non-equivalency bucket and we have only
    // found an equivalency name bucket with this family name.

        if ((pbkt == (HASHBUCKET *) NULL) || (!bEquiv && (pbkt->fl & HB_EQUIV_FAMILY)))
        {
            pbkt = (HASHBUCKET *) PALLOCMEM(sizeof(HASHBUCKET), 'bahG');
            if (pbkt == (HASHBUCKET *) NULL)
            {
                VFREEMEM(ppfel);
                return(FALSE);
            }

            // Link the PFE into the empty lists.

            pbkt->ppfelEnumHead = pbkt->ppfelEnumTail = ppfel;

            // Set up the linked list pointers.  We always add new buckets at the
            // tail of the load order linked list.

            if ( pfh->pbktFirst == (HASHBUCKET *) NULL )
            {
                // Special case: this is the first bucket to be put on the list.

                pfh->pbktFirst = pbkt;
                pfh->pbktLast = pbkt;

                pbkt->pbktPrev = (HASHBUCKET *) NULL;
                pbkt->pbktNext = (HASHBUCKET *) NULL;
            }
            else
            {
                pbkt->pbktPrev = pfh->pbktLast;
                pbkt->pbktNext = (HASHBUCKET *) NULL;

                pfh->pbktLast->pbktNext = pbkt;
                pfh->pbktLast = pbkt;
            }

            // Record the time stamp of the bucket.  Its time stamp is the
            // time stamp of its oldest (or first) PFE.  Since this is a new
            // bucket, the time stamp is automatically that of pfeoNew.

            pbkt->ulTime = pfeoNew.ulTimeStamp();

            // Finish up.

            pbkt->fl        = bEquiv ? HB_EQUIV_FAMILY : 0;
            pbkt->cTrueType = (pfeoNew.flFontType() & TRUETYPE_FONTTYPE) ? 1 : 0;
            pbkt->cRaster   = (pfeoNew.flFontType() & RASTER_FONTTYPE) ? 1 : 0;

            // Copy in the string.

            if( fht() == FHT_UFI )
            {
                pfeoNew.vUFI( &(pbkt->u.ufi) );
            }
            else
            {
                for (INT ii=0; ii<LF_FACESIZE; ii++)
                    pbkt->u.wcCapName[ii] = pwcCap[ii];
            }

            // link the bucket into the hash table.

            pbkt->pbktCollision = pfh->apbkt[iBucket];
            if (pbkt->pbktCollision != (HASHBUCKET *) NULL)
                pfh->cCollisions++;
            pfh->apbkt[iBucket] = pbkt;
            pfh->cUsed++;
        }
        else
        {
            // In the following we have found an existing HASHBUCKET.
            // We can assume that its lists are non-empty.

            // Insert into the font enumeration list.  The new PFE is inserted at
            // the tail because we want to preserve the order in which fonts are
            // added to the system (Windows 3.1 compatibility).

            // Append new PFELINK to old tail and fixup the tail pointer

            pbkt->ppfelEnumTail->ppfelNext = ppfel;
            pbkt->ppfelEnumTail = ppfel;

            // Track the number of TrueType fonts.

            if (pfeoNew.flFontType() & TRUETYPE_FONTTYPE)
                pbkt->cTrueType++;

            // Track the number of Raster fonts.

            if (pfeoNew.flFontType() & RASTER_FONTTYPE)
                pbkt->cRaster++;
        }
    }

    return (ppfel != NULL);
}


/******************************Member*Function*****************************\
* FHOBJ::bInsert                                                           *
*                                                                          *
* Insert a new PFE into the font hash table.                               *
*                                                                          *
* History:                                                                 *
*  Mon 14-Dec-1992 22:51:22 -by- Charles Whitmer [chuckwh]                 *
* Moved HASHBUCKETs out of the hash table.  We now create them as needed.  *
*                                                                          *
*  06-Aug-1992 00:43:37 by Gilman Wong [gilmanw]                           *
* Added support for font enumeration list.                                 *
*                                                                          *
*  Tue 14-Apr-1992 13:49:24 by Kirk Olynyk [kirko]                         *
* Wrote it.                                                                *
\**************************************************************************/

BOOL FHOBJ::bInsert(PFEOBJ& pfeoNew)
{
// Capitalize the given string.  We will always match on the capitalized
// string.

    WCHAR wcCap[LF_FACESIZE];

    HASHBUCKET *pbkt;
    UINT iBucket;

// Insert into facename hash only if the typographic face name
// is different from the typeographic family name.  Case insensitive
// since searching in the font hash table is case insensitive.

    if ((fht() == FHT_FACE) &&
        !_wcsicmp(pfeoNew.pwszFaceName(),pfeoNew.pwszFamilyName()))
    {
        return TRUE; // nothing to do.
    }

    if( fht() == FHT_UFI )
    {
        UNIVERSAL_FONT_ID ufi;

        pfeoNew.vUFI( &ufi );
        pbkt = pbktSearch(NULL,&iBucket,&ufi);

    }
    else
    {
        cCapString(wcCap,pwszName(pfeoNew),LF_FACESIZE);

    // Locate the hashbucket.

        pbkt = pbktSearch(wcCap,&iBucket);
    }

// link the pfe into appropriate lists:

    if (!bAddPFELink(pbkt, iBucket, wcCap, pfeoNew, FALSE))
        return FALSE;

// Do we need to add equivalence buckets for this pfe to the hash table?
// This way the same pfe may show up in linked lists hanging off several buckets.

    if ( pfeoNew.bEquivNames() && (fht() == FHT_FAMILY) )
    {
        HASHBUCKET *pbktEquiv;
        PWSZ pwszEquivName = pwszName(pfeoNew);

    // Skip to first equiv name.

        while (*pwszEquivName++);

        // Process each equiv. name until we hit the list terminator (NULL).

        while (*pwszEquivName)
        {
        // Capitalize the name.

            cCapString(wcCap,pwszEquivName,LF_FACESIZE);

        // Locate the hashbucket. We only search for equiv buckets

            pbktEquiv = pbktSearch(wcCap,&iBucket, NULL, TRUE);

            if (!bAddPFELink(pbktEquiv, iBucket, wcCap, pfeoNew, TRUE))
                return FALSE;

        // Skip to next name.

            while (*pwszEquivName++);
        }
    }

    return(TRUE);
}



/******************************Public*Routine******************************\
*
* VOID FHOBJ::vDeletePFELink(HASHBUCKET *phbkt, PFEOBJ& pfeoV)
*
* Delete pfe from the linked list hanging off the bucket and possibly
* also remove the bucket itself, after removing the last pfe from the llist
*
* History:
*  27-Jun-1997 -by- Bodin Dresevic [BodinD]
* Wrote it.
\**************************************************************************/



VOID FHOBJ::vDeletePFELink(HASHBUCKET *phbkt, UINT iBucket,  PFEOBJ& pfeoV)
{
    // Capitalize the search string.

    PFELINK *ppfel, *ppfelV = NULL;

    #if DBG
        BOOL bFoundVictim;      // used only for debugging
    #endif

    // Does the list exist?  It is possible that on the facename list this PFE
    // may not exist.  The set of PFEs in the facename list is a subset of the
    // set of PFEs in the family name list.

    // Return if there is no list.

    if (phbkt == (HASHBUCKET *) NULL)
    {
        // ASSERTGDI(fht() == FHT_FACE, "trying to remove nonexisting pfe\n");
        return;
    }

    // ----------------------------------
    // Remove from font enumeration list.
    // ----------------------------------

    // Check for special case: victim is at the head of list.

    if (phbkt->ppfelEnumHead->ppfe == pfeoV.ppfeGet())
    {
        // remember the pointer, we shall have to free the mem;

        ppfelV = phbkt->ppfelEnumHead;

        // Victim found, new head of list.

        phbkt->ppfelEnumHead = phbkt->ppfelEnumHead->ppfelNext;

        // Tail check.  List may now be empty, so we may need to adjust tail.

        if (phbkt->ppfelEnumHead == NULL)
        {
            phbkt->ppfelEnumTail = NULL;
        }
    }
    else
    {
    // If we're here, victim is either in the middle or end of the list.

        ppfel = phbkt->ppfelEnumHead;

        #if DBG
            bFoundVictim = FALSE;
        #endif

    // Search loop; look for victim on the linked list.

        while (ppfel->ppfelNext)
        {
            if (ppfel->ppfelNext->ppfe == pfeoV.ppfeGet())
            {
                // Victim found.

                ppfelV = ppfel->ppfelNext;
                ppfel->ppfelNext = ppfelV->ppfelNext;

                #if DBG
                    bFoundVictim = TRUE;
                #endif

                // Tail check.  If victim is also the tail, we need a new tail.

                if (ppfelV->ppfelNext == NULL)
                {
                    ASSERTGDI(phbkt->ppfelEnumTail == ppfelV, "ppfelEnumTail problem");
                    phbkt->ppfelEnumTail = ppfel;
                }

                // Get out of search loop.

                break;
            }

            ppfel = ppfel->ppfelNext;
        }

        // PFE must exist somewhere on the list.
        // We saw the case where PFE doesn't exist in the list on Hydra
        // Somehow pffmo.bAddHash failed in bLoadFonts which caused the
        // pffmo.vRemoveHash was called right after.

    }

    if (ppfelV)
    {
    // free the link itself

    VFREEMEM(ppfelV);

    //
    // Track the number of TrueType fonts.
    //

    if (pfeoV.flFontType() & TRUETYPE_FONTTYPE)
    {
        phbkt->cTrueType--;
    }

    //
    // Track the number of Raster fonts.
    //

    if (pfeoV.flFontType() & RASTER_FONTTYPE)
    {
        phbkt->cRaster--;
    }

    //
    // If the bucket has no PFE's attached, delete it.
    //

    if (phbkt->ppfelEnumHead == NULL)
    {
        //
        // We have to remove the HASHBUCKET from the load order linked list.
        //

        if ( phbkt->pbktPrev )
        {
            phbkt->pbktPrev->pbktNext = phbkt->pbktNext;
        }
        else
        {
            pfh->pbktFirst = phbkt->pbktNext;   // new head of list
        }

        if ( phbkt->pbktNext )
        {
            phbkt->pbktNext->pbktPrev = phbkt->pbktPrev;
        }
        else
        {
            pfh->pbktLast = phbkt->pbktPrev;    // new tail of list
        }

        // We also have to remove the HASHBUCKET from the collision list.

        for
        (
          HASHBUCKET **ppbkt = &pfh->apbkt[iBucket];
          *ppbkt != phbkt;
          ppbkt = &((*ppbkt)->pbktCollision)
        )
        {}

        *ppbkt = phbkt->pbktCollision;

        // Reduce the counts in the hash table.

        pfh->cUsed--;
        if (pfh->apbkt[iBucket])
        {
            pfh->cCollisions--;
        }

        // Delete the HASHBUCKET.

        VFREEMEM(phbkt);
    }
    else
    {
        // If we haven't deleted the bucket,
        // check to see if its time stamp should be changed.

        // The time stamp of a bucket is the time stamp of its oldest
        // PFE.  Since the font enumeration PFE list is also maintained
        // in load order, the bucket time stamp is equivalent to the time
        // stamp of the first bucket in its font enumeration list.

        if ( phbkt->ulTime == phbkt->ppfelEnumHead->ppfe->ulTimeStamp )
        {
            // If the time stamps are equal, the head of the list was not
            // deleted.  Therefore, the position of this bucket in the
            // load order list has not changed and we are done.

            return;
        }

        // Update the time stamp.

        phbkt->ulTime = phbkt->ppfelEnumHead->ppfe->ulTimeStamp;

        // The bucket can only get younger if the head of the list is removed.
        // Therefore we need only probe forward for the new position of the
        // hash bucket.

        // We will stop the scan when we are pointing at the bucket that
        // precedes the new position.

        for ( HASHBUCKET *pbktProbe = phbkt;
              (pbktProbe->pbktNext != (HASHBUCKET *) NULL)
              && (pbktProbe->pbktNext->ulTime < phbkt->ulTime);
              pbktProbe = pbktProbe->pbktNext
            );

        // If we found a new position and it isn't the one we already occupy,
        // move the bucket.

        if (pbktProbe != phbkt)
        {
            // Remove the bucket from its current position.

            if (phbkt->pbktPrev )
            {
                phbkt->pbktPrev->pbktNext = phbkt->pbktNext;
            }
            else
            {
                pfh->pbktFirst = phbkt->pbktNext;   // new head of list
            }

            if (phbkt->pbktNext )
            {
                phbkt->pbktNext->pbktPrev = phbkt->pbktPrev;
            }

            // It is not necessary to handle the case of a new tail
            // because if this were the current tail, we would not be
            // attempting to move it.

            // Insert at its new position.  Remember: pbktProbe is pointing to
            // the bucket that should precede this one.

            phbkt->pbktPrev = pbktProbe;
            phbkt->pbktNext = pbktProbe->pbktNext;

            pbktProbe->pbktNext = phbkt;
            if (phbkt->pbktNext )
            {
                phbkt->pbktNext->pbktPrev = phbkt;
            }
            else
            {
                pfh->pbktLast = phbkt;  // new tail for the list
            }
        }
    }
    }
}



/******************************Member*Function*****************************\
* FHOBJ::vDelete                                                           *
*                                                                          *
* Removes a PFE from all the lists hanging off the hash table.             *
*                                                                          *
* History:                                                                 *
*
*  Fri 27-Jun-1997 -by- Bodin Dresevic [BodinD]
* update:
* Added removing pfe's from equivalency buckets, I think this was missing
*
*  Mon 14-Dec-1992 23:39:28 -by- Charles Whitmer [chuckwh]                 *
* Changed to search for buckets.  Made it delete the bucket at the end,    *
* instead of reconstructing the whole table.                               *
*                                                                          *
*  06-Aug-1992 00:43:37 by Gilman Wong [gilmanw]                           *
* New deletion algorithm.  Also, added support for font enumeration list.  *
*                                                                          *
*  Tue 14-Apr-1992 13:49:05 by Kirk Olynyk [kirko]                         *
* Wrote it.                                                                *
\**************************************************************************/

VOID FHOBJ::vDelete(PFEOBJ& pfeoV)
{
    // Capitalize the search string.

    WCHAR wcCapName[LF_FACESIZE];
    UINT iBucket;
    HASHBUCKET *phbkt;

// Delete from facename hash only if the typographic face name
// is different from the typeographic family name. Case insensitive
// since searching in the font hash table is case insensitive.

    if ((fht() == FHT_FACE) &&
        !_wcsicmp(pfeoV.pwszFaceName(),pfeoV.pwszFamilyName()))
    {
        return; // nothing to do.
    }

    if( fht() == FHT_UFI )

    {
        UNIVERSAL_FONT_ID ufi;

        pfeoV.vUFI( &ufi );
        phbkt = pbktSearch(NULL,&iBucket,&ufi);

    }
    else
    {
        cCapString(wcCapName,pwszName(pfeoV),LF_FACESIZE);

        // Determine hash position in the table.

        phbkt = pbktSearch(wcCapName,&iBucket);
    }

    vDeletePFELink(phbkt,iBucket,pfeoV);

    // this pfe may need to be deleted from the lists hanging off of
    // equivalency buckets:

    if (pfeoV.bEquivNames() && (fht() == FHT_FAMILY))
    {
        HASHBUCKET *pbktEquiv;
        PWSZ pwszEquivName = pwszName(pfeoV);

    // Skip to first equiv name.

        while (*pwszEquivName++);

        // Process each equiv. name until we hit the list terminator (NULL).

        while (*pwszEquivName)
        {
        // Capitalize the name.

            cCapString(wcCapName,pwszEquivName,LF_FACESIZE);

        // Locate the hashbucket. Only search for equivalency buckets

            pbktEquiv = pbktSearch(wcCapName,&iBucket, NULL, TRUE);
            vDeletePFELink(pbktEquiv,iBucket,pfeoV);

        // Skip to next name.

            while (*pwszEquivName++);
        }
    }

}

/******************************Public*Routine******************************\
* ENUMFONTSTYLE efsCompute(BOOL *abFoundStyle, PFEOBJ &pfeo)
*
* Computes a font enumeration style category for the given pfeo.
*
* An array of flags, abFoundStyle, is passed in.  There is a flag
* for each style classification returned by PFEOBJ::efsCompute().
*
* These flags are set as PFEs for each category are found.
* Once a category is filled, then all subsequent fonts of the
* same category are marked as either EFSTYLE_OTHER (if facename
* is different than family name, thereby allowing us to use it
* to distinguish from other fonts of this family) or EFSTYLE_SKIP
* (if facename is the same as the family name).
*
* This is to support Win 3.1 EnumFonts() behavior which can only
* discriminate 4 different styles for each family of fonts.
*
* History:
*  07-Aug-1992 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/

ENUMFONTSTYLE efstyCompute(BOOL *abFoundStyle, PFEOBJ &pfeo)
{
    ENUMFONTSTYLE efsty = pfeo.efstyCompute();

    if ( !abFoundStyle[efsty] )
    {
        abFoundStyle[efsty] = TRUE;
    }
    else
    {
        if ( _wcsicmp(pfeo.pwszFamilyName(), pfeo.pwszFaceName()) )
        {
            efsty = EFSTYLE_OTHER;
        }
        else
        {
            efsty = EFSTYLE_SKIP;
        }
    }

    return efsty;
}

/******************************Member*Function*****************************\
* BOOL FHOBJ::bScanLists                                                   *
*                                                                          *
* This implements the behavior of EnumFonts() and EnumFontFamilies() when  *
* a NULL name is passed in.  If the bComputeStyles flag is TRUE, the       *
* EnumFonts() behavior of enumerating some fonts by their facename (rather *
* than family name) is used.                                               *
*                                                                          *
* This function puts HPFEs from the hash table and lists into the EFSOBJ.  *
* If bComputeStyles is FALSE, only the font enumeration list heads from    *
* each bucket are added to the EFSOBJ.                                     *
*                                                                          *
* If bComputeStyles is TRUE, then each list is scanned and a style         *
* classification (EFSTYLE) is computed.  Fonts classified as EFSTYLE_OTHER *
* are also added to the EFSOBJ.                                            *
*                                                                          *
* Return:                                                                  *
*   Returns FALSE if an error occurs; TRUE otherwise.                      *
*                                                                          *
* History:                                                                 *
*  15-Jan-1993 -by- Gilman Wong [gilmanw]                                  *
* Changed to use the linked list that preserves PFE load order for outer   *
* loop.                                                                    *
*                                                                          *
*  Mon 14-Dec-1992 23:50:10 -by- Charles Whitmer [chuckwh]                 *
* Changed outer loop logic for new hashing.                                *
*                                                                          *
*  07-Aug-1992 -by- Gilman Wong [gilmanw]                                  *
* Wrote it.                                                                *
\**************************************************************************/

BOOL FHOBJ::bScanLists (
    EFSOBJ *pefso,          // fill this EFSOBJ
    ULONG   iEnumType,      // Enum Fonts, Families or FamiliesEx
    EFFILTER_INFO *peffi    // filtering information
)
{
    HASHBUCKET *phbkt;
    // better C++ code generation if you always return a variable
    BOOL bRet = FALSE;
    FLONG       flAdd = 0;
    PFELINK     *ppfel;


    if (iEnumType == TYPE_ENUMFONTFAMILIES)
        flAdd |= FL_ENUMFAMILIES;
    if (iEnumType == TYPE_ENUMFONTFAMILIESEX)
        flAdd |= FL_ENUMFAMILIESEX;

// Scan through the hash table using the load ordered linked list.

    for (phbkt = pfh->pbktFirst;
         phbkt != (HASHBUCKET *) NULL;
         phbkt = phbkt->pbktNext
        )
    {
    // If the list exists, need to scan it.  We skip over equiv. name
    // HASHBUCKETs.  These are here only to allow the mapper to alias
    // printer font names to other "equivlaent" names.  We do not
    // enumerate them.

        if (
            phbkt->ppfelEnumHead
            && !(phbkt->fl & HB_EQUIV_FAMILY)
        )
        {
            ppfel = phbkt->ppfelEnumHead;
            PFEOBJ pfeo(ppfel->ppfe);

            ASSERTGDI (
                pfeo.bValid(),
                "gdisrv!bScanListsFHOBJ(NULL): bad HPFE handle\n"
                );

        // This flag is used only if bComputeStyles is TRUE (i.e.,
        // processing an EnumFonts() request).  We use this to track
        // whether or not the first suitable font in the list is found
        // yet.  The first font PLUS fonts that are EFSTYLE_OTHER
        // are put in the enumeration.

            BOOL bFoundFirst = FALSE;

        // These flags are set as PFEs for each category are found.
        // Once a category is filled, then all subsequent fonts of the
        // same category are marked as either EFSTYLE_OTHER (if facename
        // is different than family name, thereby allowing us to use it
        // to distinguish from other fonts of this family) or EFSTYLE_SKIP
        // (if facename is the same as the family name).
        //
        // This is to support Win 3.1 EnumFonts() behavior which can only
        // discriminate 4 different styles for each family of fonts.

            BOOL abFoundStyle[EFSTYLE_MAX];
            RtlZeroMemory((PVOID) abFoundStyle, EFSTYLE_MAX * sizeof(BOOL));

        // Windows 3.1 compatibility
        //
        // When NULL is passed into EnumFonts or EnumFontFamilies,
        // raster fonts are not enumerated if a TrueType font of the same
        // name exists.  We can emulate this behavior by turning on
        // the "TrueType duplicate" filter (the same one used by the
        // (GACF_TTIGNORERASTERDUPE app compatibility flag) for the NULL case.

            peffi->bTrueTypeDupeFilter = TRUE;

        // Win3.1 App compatibility flag GACF_TTIGNORERASTERDUPE.  Need
        // to copy count of TrueType from bucket into EFFILTER_INFO, peffi.

            peffi->cTrueType = phbkt->cTrueType;

            // Scan the list for candidates.

            do
            {
                pfeo.ppfeSet(ppfel); // "relock" ppfe;

            // Skip this PFE if it needs to be filtered out.

                if ( pfeo.bFilteredOut(peffi) )
                    continue;

            // EnumFonts() or EnumFontFamilies() processing (bComputeStyles
            // is TRUE for EnumFonts()).

                if (iEnumType != TYPE_ENUMFONTS)
                {
                // EnumFontFamilies --
                // Need only the first one on the list.

                    if (!pefso->bAdd(pfeo.ppfeGet(),EFSTYLE_REGULAR,flAdd,peffi->lfCharSetFilter))
                    {
                    // Error return.  bAdd() will set error code.

                        WARNING(
                            "gdisrv!bScanListsFHOBJ(NULL): "
                            "abandon enum, cannot grow list\n"
                            );
                        return bRet;
                    }

                // Break out of the do..while loop.
                //
                    break;
                }
                else
                {
                    // Compute the style category for this PFE.

                    ENUMFONTSTYLE efsty = efstyCompute(abFoundStyle, pfeo);

                // EnumFonts --
                // If style is EFSTYLE_OTHER, this font falls into an already
                // occupied category but it has a facename that allow it to be
                // distinguished from other fonts of this family.  So it
                // should be added.
                //
                    if ( !bFoundFirst || (efsty == EFSTYLE_OTHER) )
                    {
                        if (!pefso->bAdd(pfeo.ppfeGet(),efsty))
                        {
                            // Error return.  bAdd() will set error code.

                            WARNING(
                                "gdisrv!bScanListsFHOBJ(NULL): "
                                "abandon enum, cannot grow list\n");
                            return bRet;
                        }

                    //
                    // First one has been found.  From now on, we will only
                    // take EFSTYLE_OTHER fonts.
                    //
                        bFoundFirst = TRUE;
                    }

                }

            } while (ppfel = ppfel->ppfelNext);
        }
    }

// Success.
    bRet = TRUE;
    return bRet;
}

/******************************Member*Function*****************************\
* BOOL FHOBJ::bScanLists                                                   *
*                                                                          *
* This implements the behavior of EnumFonts() and EnumFontFamilies() when  *
* a non-NULL name is passed in.  If the bComputeStyles flag is TRUE, the   *
* EnumFonts() behavior of enumerating some fonts by their facename (rather *
* than family name) is used.                                               *
*                                                                          *
* This function puts HPFEs from the hash table and lists into the EFSOBJ.  *
* If bComputeStyles is FALSE, the entire font enumeration list is added    *
* to the EFSOBJ.                                                           *
*                                                                          *
* If bComputeStyles is TRUE, then each list is scanned and a style         *
* classification (EFSTYLE) is computed.  Fonts classified as EFSTYLE_OTHER *
* are excluded from the EFSOBJ.  (These fonts are enumerated by their      *
* facename rather than their family name).                                 *
*                                                                          *
* Return:                                                                  *
*   Returns FALSE if an error occurs; TRUE otherwise.                      *
*                                                                          *
* History:                                                                 *
*  Mon 14-Dec-1992 23:54:37 -by- Charles Whitmer [chuckwh]                 *
* Modified hash lookup.                                                    *
*                                                                          *
*  07-Aug-1992 -by- Gilman Wong [gilmanw]                                  *
* Wrote it.                                                                *
\**************************************************************************/

BOOL FHOBJ::bScanLists
(
    EFSOBJ *pefso,              // fill this EFSOBJ
    PWSZ    pwszName,           // search on this name
    ULONG   iEnumType,          // Enum Fonts, Families or FamiliesEx
    EFFILTER_INFO *peffi        // filtering information
)
{

    WCHAR wcCapName[LF_FACESIZE];

    BOOL bRet = FALSE;          // for better code generation
    FLONG       flAdd = 0;
    PFELINK    *ppfel;

    if (iEnumType == TYPE_ENUMFONTFAMILIESEX)
        flAdd |= FL_ENUMFAMILIESEX;

    // Capitalize the search name.

    cCapString(wcCapName,pwszName,LF_FACESIZE);

    // Search for head of the list.

    HASHBUCKET *pbkt = pbktSearch(wcCapName,(UINT *) NULL);

    // If the list exists, need to scan it.  Unless this is an equiv. name
    // HASHBUCKET.  These are here only to allow the mapper to alias
    // printer font names to other "equivlaent" names.  We do not
    // enumerate them.

    if (pbkt)
    {
        ppfel = pbkt->ppfelEnumHead;
        PFEOBJ pfeo(ppfel->ppfe);

        ASSERTGDI (
            pfeo.bValid(),
            "gdisrv!bScanListsFHOBJ(): bad HPFE handle\n"
            );

        // These flags are set as PFEs for each category are found.
        // Once a category is filled, then all subsequent fonts of the
        // same category are marked as either EFSTYLE_OTHER (if facename
        // is different than family name, thereby allowing us to use it
        // to distinguish from other fonts of this family) or EFSTYLE_SKIP
        // (if facename is the same as the family name).
        //
        // This is to support Win 3.1 EnumFonts() behavior which can only
        // discriminate 4 different styles for each family of fonts.

        BOOL abFoundStyle[EFSTYLE_MAX];
        RtlZeroMemory((PVOID) abFoundStyle, EFSTYLE_MAX * sizeof(BOOL));
        ENUMFONTSTYLE efsty = EFSTYLE_REGULAR;

    //
    // Win3.1 App compatibility flag GACF_TTIGNORERASTERDUPE.  Need
    // to copy count of TrueType from bucket into EFFILTER_INFO, peffi.
    //
        peffi->cTrueType = pbkt->cTrueType;

    //
    // Scan the list for candidates.
    //
        do
        {
            pfeo.ppfeSet(ppfel); // "relock" ppfe;

        // Skip this PFE if it needs to be filtered out.

            if ( pfeo.bFilteredOut(peffi) )
                continue;

        // If servicing an EnumFonts() call (bComputeStyles is TRUE),
        // then some fonts may be excluded.  EnumFontFamilies, however,
        // wants the entire list.

            if (iEnumType == TYPE_ENUMFONTS)
            {
            //
            // Compute the style category for this PFE.
            //
                efsty = efstyCompute(abFoundStyle, pfeo);

            // EnumFonts --
            // If style is EFSTYLE_OTHER, this font falls into an
            // already occupied category but it has a facename that allows
            // it to be distinguished from other fonts of this family.
            // So it will be excluded from this enumeration.  (It will
            // be enumerated by its facename).

                if ( efsty == EFSTYLE_OTHER )
                    continue;

            }

            // Add the font to the enumeration.

            if (!pefso->bAdd(pfeo.ppfeGet(),efsty,flAdd, peffi->lfCharSetFilter))
            {
                // Error return.  bAdd() will set error code.

                WARNING(
                    "gdisrv!bScanListsFHOBJ(): "
                    "abandon enum, cannot grow list\n");
                return bRet;
            }

        } while (ppfel = ppfel->ppfelNext);
    }

    // Success.
    bRet = TRUE;
    return bRet;

}

/******************************Member*Function*****************************\
* FHMEMOBJ::FHMEMOBJ                                                       *
*                                                                          *
* Allocates memory for a font hash table.                                  *
*                                                                          *
* History:                                                                 *
*  Tue 14-Apr-1992 14:44:35 by Kirk Olynyk [kirko]                         *
* Wrote it.                                                                *
\**************************************************************************/

FHMEMOBJ::FHMEMOBJ(FONTHASH **ppfhNew, FONTHASHTYPE fht_, UINT c)
{
    ppfh = ppfhNew;
    *ppfh = (FONTHASH*)
        PALLOCMEM (offsetof(FONTHASH,apbkt) + sizeof(*(pfh->apbkt)) * c, 'sahG');

    pfh = *ppfh;

    if (pfh != (FONTHASH*) NULL)
    {
        vInit(fht_,c);
    }
}

#if DBG
/******************************Public*Routine******************************\
* VOID PFTOBJ::vDump ()
*
* Debugging code.
*
* History:
*  25-Feb-1991 -by- Gilman Wong [gilmanw]
* Wrote it.
\**************************************************************************/

VOID PFTOBJ::vPrint()
{
    PFF *pPFF, **ppPFF;
    int i;

    DbgPrint("\nContents of PFT, PPFT = 0x%p\n", pPFT);
    DbgPrint("pfhFamily = %-#p\n", pPFT->pfhFamily);
    DbgPrint("pfhFace   = %-#p\n", pPFT->pfhFace);
    DbgPrint("pfhUFI   = %-#p\n", pPFT->pfhUFI);
    DbgPrint("cBuckets  = %ld\n", pPFT->cBuckets);
    DbgPrint("cFiles    = %ld\n", pPFT->cFiles);
    DbgPrint("PPFF table\n");
    for (
        ppPFF = pPFT->apPFF,i=0
      ; ppPFF < pPFT->apPFF + pPFT->cBuckets
      ; ppPFF++,i++)
    {
        if (pPFF = *ppPFF)
        {
            DbgPrint("\tPFT->apPFF[%d]\n",i);
            while (pPFF)
            {
                if (!pPFF->hdev)
                {
                    DbgPrint("%p\t\"%ws\" %u\n"
                        , pPFF
                        , pPFF->pwszPathname_
                        , pPFF->sizeofThis
                        );
                }
                else
                {
                    DbgPrint("%p\t%p %u\n"
                      , pPFF
                      , pPFF->hdev
                      , pPFF->sizeofThis
                      );
                }
                pPFF = pPFF->pPFFNext;
            }
        }
    }
    DbgPrint("\n");
}
/******************************Member*Function*****************************\
* FHOBJ::vPrint
*
* History:
*  Tue 14-Apr-1992 13:49:51 by Kirk Olynyk [kirko]
* Wrote it.
\**************************************************************************/

VOID FHOBJ::vPrint(VPRINT print)
{
    UINT i;
    HASHBUCKET *pbkt;
    PFELINK    *ppfel;

    print("    FHOBJ::vPrint()\n\n");
    print("    ppfh           = %-#8lx\n",ppfh);
    print("    pfh            = %-#8lx\n",pfh);
    print(
        "    pfh->id        = %c%c%c%c\n",
        ((char*) (&pfh->id))[0],
        ((char*) (&pfh->id))[1],
        ((char*) (&pfh->id))[2],
        ((char*) (&pfh->id))[3]
        );
    print(
        "         fht       = %s\n",
        pfh->fht == FHT_FAMILY ? "FHT_FAMILY" :
        (pfh->fht == FHT_FACE   ? "FHT_FACE" :
        (pfh->fht == FHT_UFI    ? "FHT_UFI" : "BOGUS VALUE" ))
        );
    print("         cBuckets    = %d\n",pfh->cBuckets);
    print("         cUsed       = %d\n",pfh->cUsed);
    print("         cCollisions = %d\n",pfh->cCollisions);

    for (i = 0; i < pfh->cBuckets; i++)
    {
      for
      (
        pbkt = pfh->apbkt[i];
        pbkt != (HASHBUCKET *) NULL;
        pbkt = pbkt->pbktCollision
      )
      {
        print("         ahbkt[%04d] \"%ws\"\n",i,pbkt->u.wcCapName);
      }
    }

    print(
        "\n\n        hpfe        %s\n\n",
        pfh->fht ? "FamilyName" : "FaceName"
        );

    for (i = 0; i < pfh->cBuckets; i++)
    {
      BOOL bFirst;

      for
      (
        pbkt = pfh->apbkt[i];
        pbkt != (HASHBUCKET *) NULL;
        pbkt = pbkt->pbktCollision
      )
      {
        ppfel   = pbkt->ppfelEnumHead;
        bFirst = TRUE;
        while (ppfel)
        {
            PFEOBJ pfeo(ppfel->ppfe);

            if (bFirst)
            {
                print("        %-#8x    \"%ws\"\n",ppfel->ppfe,pwszName(pfeo));
                bFirst = FALSE;
            }
            else
            {
                print("        %-#8x\n",ppfel->ppfe);
            }
            ppfel = ppfel->ppfelNext;
        }
      }
    }
    print("\n\n");
}
#endif


/******************************Public*Routine******************************\
*
* Routine Name:
*
*   GetLanguageID
*
* Routine Description:
*
*   This routines returns the default language ID.  Normally, we would call
*   GetLocaleInfoW to get this information but that API is not available in
*   kernel mode.  Since GetLocaleInfoW gets it from the registry we'll do the
*   same.
*
* Arguments: none
*
* Called by:
*
* Return Value:
*
*   The default language ID.  If the call fails it will just return 409
*   for English.
*
\**************************************************************************/

USHORT GetLanguageID()
{
    NTSTATUS NtStatus;
    USHORT Result = 0x409;
    HANDLE RegistryKeyHandle;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING UnicodeString;
    PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;

    #define NLS_TABLE_KEY \
       L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Nls\\Language"

    RtlInitUnicodeString(&UnicodeString, NLS_TABLE_KEY);

    InitializeObjectAttributes(&ObjectAttributes,
                               &UnicodeString,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);

    NtStatus = ZwOpenKey(&RegistryKeyHandle, GENERIC_READ, &ObjectAttributes);

    if(NT_SUCCESS(NtStatus))
    {
        PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;

        ULONG BufferSize = sizeof(WCHAR) * MAX_PATH +
          sizeof(KEY_VALUE_FULL_INFORMATION);

        KeyValueInformation = (PKEY_VALUE_PARTIAL_INFORMATION) PALLOCMEM(BufferSize,'dilG');

        if(KeyValueInformation)
        {
            ULONG ValueReturnedLength;

            RtlInitUnicodeString(&UnicodeString,L"Default");

            NtStatus = ZwQueryValueKey(RegistryKeyHandle,
                                       &UnicodeString,
                                       KeyValuePartialInformation,
                                       KeyValueInformation,
                                       BufferSize,
                                       &BufferSize);

            if(NT_SUCCESS(NtStatus))
            {
                ULONG Temp;
                RtlInitUnicodeString(&UnicodeString,
                                     (PCWSTR) &(KeyValueInformation->Data[0]));
                RtlUnicodeStringToInteger(&UnicodeString, 16, &Temp);
                Result = (USHORT) Temp;
            }
            else
            {
                WARNING("GetLanguageID failed to read registry\n");
            }
            VFREEMEM(KeyValueInformation);
        }
        else
        {
            WARNING("GetLanguageID out of memory\n");
        }

        ZwCloseKey(RegistryKeyHandle);
    }
    else
    {
        WARNING("GetLanguageID failed to open NLS key\n");
    }

    return(Result);
}

BOOL PFTOBJ::bUnloadEUDCFont(PWSZ pwszPathname)
{
    PFF *pPFF, **ppPFF;
    WCHAR szUcPathName[MAX_PATH + 1];
    BOOL bRet = FALSE;

    cCapString(szUcPathName,
               pwszPathname,
               wcslen(pwszPathname)+1);


    PUBLIC_PFTOBJ pfto;              // access the public font table
    GreAcquireSemaphoreEx(ghsemPublicPFT, SEMORDER_PUBLICPFT, NULL);     // This is a very high granularity
                                     // and will prevent text output

    pPFF = pfto.pPFFGet(szUcPathName, wcslen(szUcPathName) + 1, 1,
                        NULL, 0,        // pdv, cjDV
                        &ppPFF,TRUE);

    if (pPFF)
    {
        // bUnloadWorkhorse() guarantees that the public font table
        // semaphore will be released before it returns

        bRet = pfto.bUnloadWorkhorse(pPFF, ppPFF, ghsemPublicPFT, 0);
    }
    else
    {
        GreReleaseSemaphoreEx(ghsemPublicPFT);
    }

    return( bRet );
}


/******************************Public*Routine******************************\
* HANDLE PUBLIC_PFTOBJ::hLoadMemFonts                                      *
*                                                                          **                                                                          *                                                                          *
* Returns zero on failure.                                                 *
*                                                                          *
* History:                                                                 *
*  20-May-1997 -by- Xudong Wu [TessieW}                                    *
* Wrote it.                                                                *
\**************************************************************************/

ULONG PUBLIC_PFTOBJ::ulMemoryUnique = 0;

HANDLE PUBLIC_PFTOBJ::hLoadMemFonts
(
    PFONTFILEVIEW  *ppfv,             // font file image
    DESIGNVECTOR *pdv,
    ULONG       cjDV,
    ULONG       *pcFonts
    )
{
    BOOL    bOK = FALSE;
    HANDLE  hMMFont = 0;
    ULONG   cFonts;
    FNTCHECKSUM fntCheckSum;

    PVOID    ppvViews[1];
    ULONG    pcjViews[1];

    ppvViews[0] = ppfv[0]->fv.pvViewFD;
    pcjViews[0] = ppfv[0]->fv.cjView;

    HFF hffNew = HFF_INVALID;
    PPDEV   ppDevList;

// order of grabbing semaphores important

    GreAcquireSemaphoreEx(ghsemDriverMgmt, SEMORDER_DRIVERMGMT, NULL);
    vLoadFontFileView(NULL, 0, ppfv, 1, ppvViews, pcjViews, pdv, cjDV, &hffNew ,&ppDevList, &fntCheckSum);
    PDEVOBJ pdo((HDEV)ppDevList);
    GreReleaseSemaphoreEx(ghsemDriverMgmt);

    if (hffNew != HFF_INVALID)
    {
        cFonts = pdo.QueryFontFile( hffNew, QFF_NUMFACES, 0, NULL);

        if (cFonts && cFonts != FD_ERROR)
        {
            WCHAR awc[30];

            *pcFonts = cFonts;

            // create a unique file name for the memory font
            // in the form of "Memory NNN"

            swprintf(awc, L"MEMORY-%u", ulGetNewUniqueness(PUBLIC_PFTOBJ::ulMemoryUnique));

            ULONG cwc = wcslen(awc) + 1;

            PFFCLEANUP *pPFFC = 0;

            PFFMEMOBJ
            pffmo(cFonts,
                  awc, cwc, 1,
                  pdv, cjDV,
                  hffNew, pdo.hdev(),
                  0, pPFT,
                  PFF_STATE_MEMORY_FONT,
                  FR_PRIVATE | FR_NOT_ENUM,  //always use FR_PRIVATE | FR_NOT_ENUM for memory fonts
                  &fntCheckSum,
                  ppfv,
                  NULL);          // pufi

            if (pffmo.bValid())
            {
                if (pffmo.bLoadFontFileTable(awc, cFonts, (HANDLE)0, NULL, NULL))
                {
                    SEMOBJ so2(ghsemPublicPFT);

                    if(bOK = pffmo.bAddHash(FALSE))
                    {
                        PFF **ppPFF, *pPFF;

                        pPFF = pPFFGet(awc, cwc, 1, pdv, cjDV, &ppPFF);

                        if (pPFF)
                        {
                            KdPrint(("bLoadMemFonts(): \"%ws\" has been found on the font table\n"));
                            KdBreakPoint();
                            bOK = FALSE;
                        }
                        else
                        {
                            pPFF = pffmo.pPFFGet();
                            pPFT->cFiles++;

                            //place this new pff at the head of the hash bucket list
                            if (*ppPFF)
                            {
                                (*ppPFF)->pPFFPrev = pPFF;
                            }
                            pPFF->pPFFNext = *ppPFF;
                            pPFF->pPFFPrev = 0;
                            *ppPFF = pPFF;

                            pffmo.vKeepIt();

                            //Sundown: hMMFont is not a real handle but the checksum
                            hMMFont = (HANDLE)(ULONG_PTR)pPFF->ulCheckSum;
                        }
                    }
                    else
                    {
                        pffmo.vRemoveHash();
                    }
                }

                if (!bOK)
                {
                    pffmo.vPFFC_DeleteAndCleanup();  // new code (not so new anymore)
                    bOK = TRUE;
                }
            }
        }
    }

    if (!bOK)
    {
        VFREEMEM(ppfv);
    }
    return hMMFont;
}

ULONG PUBLIC_PFTOBJ::GetEmbedFonts()
{
    ULONG i, cEmbedFonts = 0;
    PFF *pPFF, **ppPFF;
    PVTDATA  *pPvtData;
    DWORD pid, tid;

    if (!bIsPrivatePFT())
        return 0;

    pid = (DWORD) W32GetCurrentPID();
    tid = (DWORD) W32GetCurrentTID();

    SEMOBJ so(ghsemPublicPFT);

    for (i = 0; i < CPRIVATEBUCKETS; i++)
    {
        ppPFF = &pPFT->apPFF[i];
        if (ppPFF)
        {
            pPFF = *ppPFF;
            while (pPFF)
            {
                pPvtData = pPFF->pPvtDataHead;
                while (pPvtData)
                {
                    if (pPvtData->fl & FRW_EMB_TID)
                    {
                        if (pPvtData->dwID == tid)
                            cEmbedFonts++;
                    }
                    else
                    {
                        if (pPvtData->dwID == pid)
                            cEmbedFonts++;
                    }
                    pPvtData = pPvtData->pPvtDataNext;
                }
                pPFF = pPFF->pPFFNext;
            }
        }
    }
    return cEmbedFonts;
}

BOOL PUBLIC_PFTOBJ::VerifyFontID(VOID *fontID)
{
    ULONG i;
    PFF *pPFF, **ppPFF;
    BOOL bRet = FALSE;

    if (!bIsPrivatePFT())
        return FALSE;


    SEMOBJ so(ghsemPublicPFT);

    for (i = 0; (i < CPRIVATEBUCKETS && !bRet); i++)
    {
        ppPFF = &pPFT->apPFF[i];
        if (ppPFF)
        {
            pPFF = *ppPFF;
            while (pPFF)
            {
                if ((PFF *)fontID == pPFF)          // PFF match
                {
                    return TRUE;
                }

                pPFF = pPFF->pPFFNext;
            }
        }
    }
    return bRet;
}

BOOL PUBLIC_PFTOBJ::ChangeGhostFont(VOID *fontID, BOOL bLoad)
{
    ULONG i;
    PFF *pPFF, **ppPFF;
    PVTDATA  *pPvtData;
    DWORD pid, tid;
    BOOL bRet = FALSE;

    if (!bIsPrivatePFT())
        return FALSE;

    pid = (DWORD) W32GetCurrentPID();
    tid = (DWORD) W32GetCurrentTID();

    SEMOBJ so(ghsemPublicPFT);

    for (i = 0; (i < CPRIVATEBUCKETS && !bRet); i++)
    {
        ppPFF = &pPFT->apPFF[i];
        if (ppPFF)
        {
            pPFF = *ppPFF;
            while (pPFF)
            {
                if ((PFF *)fontID == pPFF)          // PFF match
                {
                    pPvtData = pPFF->pPvtDataHead;
                    while(pPvtData)
                    {
                        if (((pPvtData->fl & FRW_EMB_TID) && (pPvtData->dwID == tid)) ||
                             ((!(pPvtData->fl & FRW_EMB_TID)) && (pPvtData->dwID == pid)))
                        {
                            if (bLoad)
                            {
                                pPvtData->cNotEnum++;
                                pPvtData->fl |= FR_PRINT_EMB_FONT;
                                bRet = TRUE;
                            }
                            else
                            {
                                if (pPvtData->cNotEnum)
                                {
                                    pPvtData->cNotEnum--;
                                    pPvtData->fl &= ~FR_PRINT_EMB_FONT;
                                }
                            }
                            break;
                        }
                        pPvtData = pPvtData->pPvtDataNext;
                    }
                }

                if (bRet)
                    break;

                pPFF = pPFF->pPFFNext;
            }
        }
    }
    return bRet;
}