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

/*********************************************************************************
 * misceudc.cxx
 *
 * This file contains EUDC specific methods for various GRE object.  I am moving
 * them to a separate file to make it easier to modify them after checkin freezes.
 * Once FE_SB ifdefs are removed we will probably want to move these object back
 * to the appropriate xxxobj.cxx files.
 *
 * 5-1-96 Gerrit van Wingerden [gerritv]
 *
 * Copyright (c) 1996-1999 Microsoft Corporation
 ********************************************************************************/

#include "precomp.hxx"

extern HSEMAPHORE ghsemEUDC2;

LONG lNormAngle(LONG lAngle);

/******************************Public*Routine******************************\
* GLYPHDATA *RFONTOBJ::pgdGetEudcMetrics()
*
*  9-29-1993 Gerrit van Wingerden [gerritv]
* Wrote it.
\**************************************************************************/

GLYPHDATA *RFONTOBJ::pgdGetEudcMetrics(WCHAR wc, RFONTOBJ* prfoBase)
{
    if (prfnt->wcgp == NULL)
    {
        if (!bAllocateCache(prfoBase))
        {
            return(NULL);
        }
    }

    if (prfnt->wcgp->cRuns == 0)
    {
        WARNING("EUDC -- pgdGetEudcMetrics - empty glyphset\n");
        return pgdDefault();
    }

    GPRUN *pwcRun = prfnt->wcgp->agpRun; // initialize with guess for loop below

    GLYPHDATA *wpgd;

// Find the correct run, if any.
// Try the current run first.

    UINT swc = (UINT)wc - pwcRun->wcLow;
    if ( swc >= pwcRun->cGlyphs )
    {
        pwcRun = gprunFindRun(wc);

        swc = (UINT)wc - pwcRun->wcLow;

        if ( swc < pwcRun->cGlyphs )
        {
            wpgd = pwcRun->apgd[swc];
        }
        else
        {
            return(NULL);
        }
    }
    else
    {

    // Look up entry in current run
    // This path should go in line

        wpgd = pwcRun->apgd[swc];
    }

// check to make sure in cache, insert if needed

    if ( wpgd == NULL )
    {
    // This path should go out of line

        if ( !bInsertMetrics(&pwcRun->apgd[swc], wc) )
        {

        // when insert fails trying to get just metrics, it is a hard
        // failure.  Get out of here!

            WARNING("EUDC -- bGetGlyphMetrics - bInsertMetrics failed\n");
            return(NULL);
        }

        wpgd = pwcRun->apgd[swc];
    }

    return wpgd;
}

/******************************Public*Routine******************************\
* GLYPHDATA *RFONTOBJ::pgdGetEudcMetricsPlus()
*
*
*  9-29-1993 Gerrit van Wingerden [gerritv]
* Wrote it.
\**************************************************************************/

GLYPHDATA *RFONTOBJ::pgdGetEudcMetricsPlus
(
    WCHAR wc,
    RFONTOBJ*  prfoBase
)
{
    if (prfnt->wcgp == NULL)
    {
        if (!bAllocateCache(prfoBase))
        {
            return(NULL);
        }
    }

    if (prfnt->wcgp->cRuns == 0)
    {
        WARNING("EUDC -- pgdGetEudcMetricsPlus - empty glyphset\n");
        return pgdDefault();
    }

    GPRUN *pwcRun = prfnt->wcgp->agpRun; // initialize with guess for loop below

    GLYPHDATA *wpgd;

// Find the correct run, if any.
// Try the current run first.

    UINT swc = (UINT)wc - pwcRun->wcLow;
    if ( swc >= pwcRun->cGlyphs )
    {
        pwcRun = gprunFindRun(wc);

        swc = (UINT)wc - pwcRun->wcLow;

        if ( swc < pwcRun->cGlyphs )
        {
            wpgd = pwcRun->apgd[swc];
        }
        else
        {
            return(NULL);
        }
    }
    else
    {

    // Look up entry in current run
    // This path should go in line

        wpgd = pwcRun->apgd[swc];
    }


// check to make sure in cache, insert if needed


    if ( wpgd == NULL )
    {

    // This path should go out of line

        if ( !bInsertMetricsPlus(&pwcRun->apgd[swc], wc) )
        {

        // when insert fails trying to get just metrics, it is a hard
        // failure.  Get out of here!

            WARNING("EUDC -- bGetGlyphMetricsPlus - bInsertMetrics failed\n");
            return(NULL);
        }

        wpgd = pwcRun->apgd[swc];
    }


// Don't bother inserting glyphs since we are going to force the driver to
// enum anyway.

    return wpgd;
}

/******************************Public*Routine******************************\
* RFONTOBJ::bCheckEudcFontCaps
*
* History:
*  9-Nov-93 -by- Hideyuki Nagase
* Wrote it.
\**************************************************************************/

BOOL RFONTOBJ::bCheckEudcFontCaps
(
    IFIOBJ  &ifioEudc
)
{
    // Check FontLink configuration.

    if( ulFontLinkControl & FLINK_DISABLE_LINK_BY_FONTTYPE )
    {

    // Fontlink for Device font is disabled ?

        if( bDeviceFont() )
        {
            if( ulFontLinkControl & FLINK_DISABLE_DEVFONT )
            {
                return(FALSE);
            }
        }
         else
        {

        // Fontlink for TrueType font is disabled ?

            if( (ulFontLinkControl & FLINK_DISABLE_TTFONT) &&
                (prfnt->flInfo & FM_INFO_TECH_TRUETYPE   )    )
            {
                return( FALSE );
            }

        // Fontlink for Vector font is disabled ?

            if( (ulFontLinkControl & FLINK_DISABLE_VECTORFONT) &&
                (prfnt->flInfo & FM_INFO_TECH_STROKE         )    )
            {
                return( FALSE );
            }

        // Fontlink for Bitmap font is disabled ?

            if( (ulFontLinkControl & FLINK_DISABLE_BITMAPFONT) &&
                (prfnt->flInfo & FM_INFO_TECH_BITMAP         )    )
            {
                return( FALSE );
            }
        }
    }

    BOOL bRotIs90Degree;

// Can EUDC font do arbitarary tramsforms ?

    if( ifioEudc.bArbXforms() )
        return( TRUE );

// Can its Orientation degree be divided by 900 ?

    bRotIs90Degree = (prfnt->ulOrientation % 900) == 0;

// if the Orientation is 0, 90, 270, 360... and the EUDC font can be
// rotated by 90 degrees, we accept this link.

    if( ifioEudc.b90DegreeRotations() && bRotIs90Degree )
        return( TRUE );

// if not, we reject this link.

    return( FALSE );
}


/******************************Public*Routine******************************\
* IsSingularEudcGlyph
*
* History:
*
*  25-Jul-95 -by- Hideyuki Nagase
* Wrote it.
\**************************************************************************/

BOOL IsSingularEudcGlyph
(
    GLYPHDATA *wpgd, BOOL bSimulatedBold
)
{
//
// Determine this is really registerd EUDC glyph or not.
//
// [NT 3.51 code for reference]
//
//  if( wpgd->rclInk.left == 0 &&
//      wpgd->rclInk.top  == 0 &&
//      (wpgd->rclInk.right  == 0 || wpgd->rclInk.right  == 1) &&
//      (wpgd->rclInk.bottom == 0 || wpgd->rclInk.bottom == 1)
//    )
//      return( TRUE );
//
// This glyph does not have advance width, it might be non-registered
// character, then return TRUE to let replace this with EUDC default
// character.
//

// dchinn 5/12/99: The code used to use the bSimulatedBold flag.
// If bSimulatedBold were TRUE and if fxD == 0x10, then we return TRUE.
// That code is no longer needed because ClaudeBe made a change elsewhere
// to leave fxD as 0x00 when doing bold simulation.  So, the test below
// is correct whether or not bSimulatedBold is TRUE.

    if( wpgd->fxD == 0 ) return( TRUE );

//
// Otherwise, use this glyph.
//
    return( FALSE );
}

BOOL RFONTOBJ::bInitSystemTT(XDCOBJ &dco)
{
    UINT iPfeOffset = (prfnt->bVertical ? PFE_VERTICAL : PFE_NORMAL);
    RFONTOBJ rfo;
    EUDCLOGFONT SystemTTLogfont;

    ComputeEUDCLogfont(&SystemTTLogfont, dco);

    PFE *ppfeSystem = (gappfeSystemDBCS[iPfeOffset] == NULL) ?
      gappfeSystemDBCS[PFE_NORMAL] : gappfeSystemDBCS[iPfeOffset];

    rfo.vInit(dco,ppfeSystem,&SystemTTLogfont,FALSE );

    if( rfo.bValid() )
    {
        FLINKMESSAGE(DEBUG_FONTLINK_RFONT,
                     "vInitSystemTT() -- linking system DBCS font");

        prfnt->prfntSystemTT = rfo.prfntFont();

    }
    return(prfnt->prfntSystemTT != NULL);
}


GLYPHDATA *RFONTOBJ::FindLinkedGlyphDataPlus
(
    XDCOBJ  *pdco,
    ESTROBJ *pto,
    WCHAR    wc,
    COUNT    index,
    COUNT    c,
    BOOL    *pbAccel,
    BOOL     bSystemTTSearch,
    BOOL     bGetBits
)
{
    GLYPHDATA *wpgd;

    LONG *plPartition = pto ? pto->plPartitionGet() : NULL;

// don't setup system EUDC font if there are remote links

    if(!pdco->uNumberOfLinkedUFIs() && bSystemTTSearch && bIsSystemTTGlyph(wc))
    {
        if(!prfnt->prfntSystemTT)
        {
            WARNING("Error initializing TT system font 2\n");
            return(pgdDefault());
        }
        
        if(pto && !(pto->bSystemPartitionInit()))
        {
        // this call can't fail for the SystemTT case
            pto->bPartitionInit(c,0,FALSE);
        }

    // mark the glyph as coming from a SystemTT font

        RFONTTMPOBJ rfo;

        rfo.vInit(prfnt->prfntSystemTT);

        if(rfo.bValid() &&
           (wpgd = bGetBits ? rfo.pgdGetEudcMetricsPlus(wc, this) : rfo.pgdGetEudcMetrics(wc, this)))
        {

            if (pto)
            {
                ASSERTGDI(pto->bSystemPartitionInit(),
                          "FindLinkedGlyphDataPlus: FontLink partition no initialized\n");

                pto->vTTSysGlyphsInc();
                plPartition[index] = EUDCTYPE_SYSTEM_TT_FONT;

            // turn off accelerator since we're going to mess with the driver

                *pbAccel = FALSE;
            }

            return(wpgd);
        }
         else
        {
            return(pgdDefault());
        }
    }

// next search through all the EUDC fonts in order to see if the glyph is one of them

    for( UINT uiFont = 0;
              uiFont < prfnt->uiNumLinks;
              uiFont ++ )
    {
        RFONTTMPOBJ rfo;

        rfo.vInit( prfnt->paprfntFaceName[uiFont] );

        if(rfo.bValid())
        {
            if( (wpgd = bGetBits ? rfo.pgdGetEudcMetricsPlus(wc, this)
                                : rfo.pgdGetEudcMetrics(wc, this)) != NULL )
            {
        if( !IsSingularEudcGlyph(wpgd, rfo.pfo()->flFontType & FO_SIM_BOLD) )
                {

                    if (pto)
                    {
                        plPartition[index] = EUDCTYPE_FACENAME + uiFont;
                        pto->vFaceNameInc(uiFont);

                    // turn off accelerator since we're going to mess with the driver

                        *pbAccel = FALSE;
                    }

                    return( wpgd );
                }
            }
        }
    }

// see if the glyph is in the DEFAULT EUDC font

    if( prfnt->prfntDefEUDC != NULL )
    {
        RFONTTMPOBJ rfo( prfnt->prfntDefEUDC );

        if (rfo.bValid())
        {
            wpgd = bGetBits ? rfo.pgdGetEudcMetricsPlus(wc, this)
                            : rfo.pgdGetEudcMetrics(wc, this);

            if( wpgd != NULL )
            {
        if( !IsSingularEudcGlyph(wpgd, rfo.pfo()->flFontType & FO_SIM_BOLD) )
                {
                    if (pto)
                    {
                    // mark this character as an EUDC character

                        plPartition[index] = EUDCTYPE_DEFAULT;

                    // increment count of Sys EUDC glyphs

                        pto->vDefGlyphsInc();

                    // turn off accelerator since we're going to mess with the driver

                        *pbAccel = FALSE;
                    }

                    return( wpgd );
                }
            }
        }
    }

// see if the glyph is in the SYSTEM-WIDE EUDC font

    if( prfnt->prfntSysEUDC != NULL )
    {
        RFONTTMPOBJ rfo( prfnt->prfntSysEUDC );

        if (rfo.bValid())
        {
            wpgd = bGetBits ? rfo.pgdGetEudcMetricsPlus(wc, this)
                            : rfo.pgdGetEudcMetrics(wc, this);

            if( wpgd != NULL )
            {
        if( !IsSingularEudcGlyph(wpgd, rfo.pfo()->flFontType & FO_SIM_BOLD))
                {
                    if (pto)
                    {
                    // mark this character as an EUDC characte and indicate that there
                    // are EUDC glyphs in the font

                        plPartition[index] = EUDCTYPE_SYSTEM_WIDE;
                        pto->vSysGlyphsInc();

                    // turn off accelerator since we're going to mess with the driver

                        *pbAccel = FALSE;
                    }
                    return( wpgd );
                }
            }
        }
    }

    return( NULL );
}

/******************************Public*Routine******************************\
* RFONTOBJ::wpgdGetLinkMetricsPlus
*
* If GetGlyphMetricsPlus encounters a default character call off to this
* routine to try and get it from the EUDC and face name linked fonts.
*
* History:
*
*  19-Jan-95 -by- Hideyuki Nagase
* Rewrote it.
*
*  14-Jul-93 -by- Gerrit van Wingerden
* Wrote it.
\**************************************************************************/

GLYPHDATA *RFONTOBJ::wpgdGetLinkMetricsPlus
(
    XDCOBJ      *pdco,
    ESTROBJ     *pto,
    WCHAR       *pwc,
    WCHAR       *pwcInit,
    COUNT        c,
    BOOL        *pbAccel,
    BOOL         bGetBits
)
{
    GLYPHDATA *wpgd;
    WCHAR *pwcCurrent = pwc;
    WCHAR *pwcEnd = pwcInit + c;

    // bLinkingTurnedOff forces linking to be turned off.  It will be TRUE
    // when we are printing an EMF file that originated on a machine that
    // had no fontlinking turned on

    if(pdco == NULL ||
       pdco->bLinkingTurnedOff() ||
       (!gbAnyLinkedFonts && !IS_SYSTEM_EUDC_PRESENT() && (pdco->uNumberOfLinkedUFIs() == 0)))
    {
        return(pgdDefault());
    }


    for (; (pwcCurrent < pwcEnd && (*pwcCurrent >= 0x80) && (*pwcCurrent <= 0x9F) ); pwcCurrent+=1)
    {
    }

    if (pwcCurrent == pwcEnd)
    {
        // all the characters are in the range 0x80 to 0x9F
        // we don't want to look through font linking for characters in that range

        // this is a performance issue to avoid calling font linking code on English system with 
        // far east language pack installed

        // client side caching is requesting through iGetPublicWidthTable() the width for ANSI codes
        // 0x00 to 0xFF, those code are converted to Unicode. Some code in the range 0x80->0x9F
        // are not converted and stay in that range causing the linked fonts to be loaded to look for those characters
        // Unicode in that range belong to the C1 controls, it doesn't make sense to look for them through
        // font linking, see Windows bug 157772.

        return(pgdDefault());
    }


    // always initialize the System TT to avoid a deadlock situation

    if (!pdco->uNumberOfLinkedUFIs() && prfnt->bIsSystemFont)
    {
        if((!prfnt->prfntSystemTT) && !bInitSystemTT(*pdco))
        {
            WARNING("Error initializing TT system font 4\n");
        }
        else
        {
            GreAcquireSemaphore(prfnt->hsemEUDC);
            
            if(!(prfnt->flEUDCState & TT_SYSTEM_INITIALIZED))
            {
                INCREMENTEUDCCOUNT;
                RFONTTMPOBJ rfo(prfnt->prfntSystemTT);
                rfo.vGetCache();
    
                prfnt->flEUDCState |= TT_SYSTEM_INITIALIZED;
            }

            GreReleaseSemaphore(prfnt->hsemEUDC);
        }
    }

// if this is an SBCS system font and the glyph exists in the DBCS TT system front
// grab it from there

    if(!pdco->uNumberOfLinkedUFIs() && bIsSystemTTGlyph(*pwc))
    {
        if(!prfnt->prfntSystemTT)
        {
            WARNING("Invalid prfntSystemTT\n");
            return(pgdDefault());
        }

        if(pto && !(pto->bSystemPartitionInit()))
        {
        // this call can't fail for the SystemTT case
            pto->bPartitionInit(c,0,FALSE);
        }

    // mark the glyph as coming from a SystemTT font

        RFONTTMPOBJ rfo;

        rfo.vInit(prfnt->prfntSystemTT);

        if(rfo.bValid() &&
           (wpgd = (bGetBits ? rfo.pgdGetEudcMetricsPlus(*pwc, this)
                                : rfo.pgdGetEudcMetrics(*pwc, this))))
        {
            if (pto)
            {
                ASSERTGDI(pto->bSystemPartitionInit(),
                          "wpgdGetLinkMetricsPlus: FontLink partition no initialized\n");

                LONG *plPartition = pto->plPartitionGet();
                pto->vTTSysGlyphsInc();
                plPartition[pwc-pwcInit] = EUDCTYPE_SYSTEM_TT_FONT;

            // turn off accelerator since we're going to mess with the driver

                *pbAccel = FALSE;
            }

            return(wpgd);
        }
        else
        {
            return(pgdDefault());
        }
    }

// if the codepoint is not in any linked font or the EUDC information is
// being changed just return the default character

    if(!pdco->uNumberOfLinkedUFIs() &&!bIsLinkedGlyph( *pwc ))
    {
        return( pgdDefault() );
    }

    // initialize EUDC fonts if we haven't done so already
    {
        GreAcquireSemaphore(prfnt->hsemEUDC);

        if( !( prfnt->flEUDCState & EUDC_INITIALIZED ) )
        {

        // this value will be decremented in RFONTOBJ::dtHelper()

            INCREMENTEUDCCOUNT;

            FLINKMESSAGE2(DEBUG_FONTLINK_RFONT,
                      "wpgdGetLinkMetricsPlus():No request to change EUDC data %d\n", gcEUDCCount);
    
            vInitEUDC( *pdco );

        // lock the font cache semaphores for any EUDC rfonts linked to this font

            if( prfnt->prfntSysEUDC != NULL )
            {
            // lock the SystemEUDC RFONT cache

                RFONTTMPOBJ rfo( prfnt->prfntSysEUDC );
                rfo.vGetCache();
            }

            if( prfnt->prfntDefEUDC != NULL )
            {
                RFONTTMPOBJ rfo( prfnt->prfntDefEUDC );
                rfo.vGetCache();
            }

            for( UINT ii = 0; ii < prfnt->uiNumLinks; ii++ )
            {
                if( prfnt->paprfntFaceName[ii] != NULL )
                {
                    RFONTTMPOBJ rfo( prfnt->paprfntFaceName[ii] );
                    rfo.vGetCache();
                }
            }

            prfnt->flEUDCState |= EUDC_INITIALIZED;

        }

        GreReleaseSemaphore(prfnt->hsemEUDC);
    }
    
    if (pto && !(pto->bPartitionInit()) )
    {
    // Sets up partitioning pointers and glyph counts in the ESTROBJ.

        if( !(pto->bPartitionInit(c,prfnt->uiNumLinks,TRUE)) )
        {
            return( pgdDefault() );
        }
    }

// Find linked font GLYPHDATA

    wpgd = FindLinkedGlyphDataPlus(
               pdco,pto,*pwc,(COUNT)(pwc-pwcInit),c,pbAccel,FALSE, bGetBits);

    if( wpgd == NULL )
    {
    // load EudcDefault Char GlyphData from "Base font".

        wpgd = bGetBits ?
               pgdGetEudcMetricsPlus(EudcDefaultChar, NULL) :
               pgdGetEudcMetrics(EudcDefaultChar, NULL);

        if( wpgd != NULL )
        {
            return( wpgd );
        }

    // load EudcDefault Char GlyphData from "Linked font".

        wpgd = FindLinkedGlyphDataPlus(pdco,pto,EudcDefaultChar,(COUNT)(pwc-pwcInit),c,pbAccel,TRUE, bGetBits);

        if( wpgd != NULL )
        {
            return( wpgd );
        }

    // Otherwise return default char of base font.

        return( pgdDefault() );
    }

    return( wpgd );
}

/******************************Public*Routine******************************\
 * RFONTOBJ::dtHelper()
 *
 *  Thu 12-Jan-1995 15:00:00 -by- Hideyuki Nagase [hideyukn]
 * Rewrote it.
 **************************************************************************/

VOID RFONTOBJ::dtHelper(BOOL bReleaseEUDC2)
{

    FLINKMESSAGE(DEBUG_FONTLINK_RFONT,"Calling dtHelper()\n");

    GreAcquireSemaphore(prfnt->hsemEUDC);


// if SystemTT RFONTOBJ was used release it

    if((prfnt->flEUDCState & TT_SYSTEM_INITIALIZED) &&
       !(prfnt->flEUDCState & EUDC_NO_CACHE))
    {
        if (prfnt->prfntSystemTT)
        {
            RFONTTMPOBJ rfo(prfnt->prfntSystemTT);
            rfo.vReleaseCache();
            DECREMENTEUDCCOUNT;
        }
    }

// if EUDC was initizlized for this RFONTOBJ, clean up its.

    if( prfnt->flEUDCState & EUDC_INITIALIZED )
    {

        if(!(prfnt->flEUDCState & EUDC_NO_CACHE))
        {
            for( INT ii = prfnt->uiNumLinks - 1; ii >= 0; ii-- )
            {
                if( prfnt->paprfntFaceName[ii] != NULL )
                {
                    RFONTTMPOBJ rfo( prfnt->paprfntFaceName[ii] );
                    rfo.vReleaseCache();
                }
            }

            if( prfnt->prfntDefEUDC != NULL )
            {
                RFONTTMPOBJ rfo( prfnt->prfntDefEUDC );
                rfo.vReleaseCache();
            }

            if( prfnt->prfntSysEUDC != NULL )
            {
                RFONTTMPOBJ rfo( prfnt->prfntSysEUDC );
                rfo.vReleaseCache();
            }
        }

        if (bReleaseEUDC2)
        {
            ASSERTGDI(gcEUDCCount > 0, "gcEUDCCount <= 0\n");
            DECREMENTEUDCCOUNT;
        }
    }

    prfnt->flEUDCState &= ~(EUDC_INITIALIZED|TT_SYSTEM_INITIALIZED|EUDC_NO_CACHE);

    GreReleaseSemaphore(prfnt->hsemEUDC);
    
}


/******************************************************************************
 * void RFONTOBJ::ComputeEUDCLogfont(EUDCLOGFONT*)
 *
 * This function computes an EUDCLOGFONT from a base font.
 *
 *****************************************************************************/


void RFONTOBJ::ComputeEUDCLogfont(EUDCLOGFONT *pEudcLogfont, XDCOBJ& dco)
{
    PDEVOBJ pdo(dco.hdev());
    LFONTOBJ lfo(dco.pdc->hlfntCur(), &pdo);

    PFEOBJ pfeo(prfnt->ppfe);
    RFONTTMPOBJ rfoT(prfnt);
    DCOBJ       dcoT(dco.hdc());
    IFIOBJR     ifio(pfeo.pifi(),rfoT,dcoT);
    BOOL        bFixedPitch = FALSE;

    if (!lfo.bValid())
        return;

    pEudcLogfont->fsSelection    = ifio.fsSelection();
    pEudcLogfont->flBaseFontType = pfo()->flFontType;
    pEudcLogfont->lBaseHeight    = lfo.lHeight();
    pEudcLogfont->lBaseWidth     = lfo.lWidth();
    pEudcLogfont->lEscapement    = lfo.lEscapement();
    pEudcLogfont->ulOrientation  = lfo.ulOrientation();

    LONG  lInternalLeading = 0;

    if(ifio.bFixedPitch())
        bFixedPitch = TRUE;

// We have to try to scale linked font as exactly same size as base font.

    if( !(pEudcLogfont->bContinuousScaling = ifio.bContinuousScaling()) )
    {
        if (dco.pdc->bWorldToDeviceIdentity())
        {
        // We only need to get the AveCharWidth for FIX_PITCH

            if (bFixedPitch)
                pEudcLogfont->lBaseWidth  = ifio.fwdAveCharWidth();

        // these are special case hacks to get better linking with Ms San Serif
        // we force a bitmap for size 8 and 10 and also use ascent based
        // mapping for all other size.
        //
        // Old comment:
        //    for NT 5.0 make this more general
        //    and make it configurable in the registry.
        //

            if(!_wcsicmp(ifio.pwszFaceName(), L"Ms Sans Serif"))
            {

                if(fxMaxExtent() > LTOFX(12) && fxMaxExtent() < LTOFX(17))
                {
                    pEudcLogfont->lBaseHeight = 12;
                }
                else
                {
                    pEudcLogfont->lBaseHeight =
                      LONG_FLOOR_OF_FIX(fxMaxAscent() + FIX_HALF);
                }
            }

            else
            if(ulFontLinkControl & FLINK_SCALE_EUDC_BY_HEIGHT)
            {
                pEudcLogfont->lBaseHeight = LONG_FLOOR_OF_FIX(fxMaxExtent() + FIX_HALF);
            }
            else
            {
                pEudcLogfont->lBaseHeight = LONG_FLOOR_OF_FIX(fxMaxAscent() + FIX_HALF);
            }
        }
        else
        {
            if (bFixedPitch)
                pEudcLogfont->lBaseWidth = lCvt(efDtoWBase_31(),((LONG) ifio.fwdAveCharWidth()) << 4);

            if (ulFontLinkControl & FLINK_SCALE_EUDC_BY_HEIGHT)
            {
                pEudcLogfont->lBaseHeight = lCvt(efDtoWAscent_31(),(LONG) fxMaxExtent());
            }
            else
            {
                pEudcLogfont->lBaseHeight = lCvt(efDtoWAscent_31(),(LONG) fxMaxAscent());
            }
        }

    // Multiply raster interger scaling value.
    // (Only for Width, Height was already scaled value.)

        if (bFixedPitch)
            pEudcLogfont->lBaseWidth *= prfnt->ptlSim.x;

        FLINKMESSAGE(DEBUG_FONTLINK_DUMP,"GDISRV:BaseFont is RASTER font\n");
    }
    else
    {
        LONG    lBaseHeight;

        if (dco.pdc->bWorldToDeviceIdentity())
        {
            lBaseHeight = LONG_FLOOR_OF_FIX(fxMaxExtent() + FIX_HALF);
        }
         else
        {
            lBaseHeight = lCvt(efDtoWAscent_31(),(LONG) fxMaxExtent());
        }

        if (lNonLinearIntLeading() == MINLONG)
        {
        // Rather than scaling the notional internal leading, try
        // to get closer to HINTED internal leading by computing it
        // as the difference between the HINTED height and UNHINTED
        // EmHeight.

            lInternalLeading = lBaseHeight - lCvt(efNtoWScaleAscender(),ifio.fwdUnitsPerEm());
            if (bFixedPitch)
                pEudcLogfont->lBaseWidth = lCvt(efNtoWScaleBaseline(), ifio.tmAveCharWidth());        
        }
        else
        {
        // But if the font provider has given us a hinted internal leading,
        // just use it.

            lInternalLeading =
            lCvt(efDtoWAscent_31(),lNonLinearIntLeading());
            if (bFixedPitch)
                pEudcLogfont->lBaseWidth = lCvt(efDtoWBase_31(), lNonLinearAvgCharWidth());        
        }

        // Check we should eliminate the internal leading for EUDC size.

        if( lInternalLeading < 0 )
            pEudcLogfont->lBaseHeight = lBaseHeight + lInternalLeading;
        else
            pEudcLogfont->lBaseHeight = lBaseHeight - lInternalLeading;

        if ((pEudcLogfont->lBaseHeight <= 13))
        {
            if (pEudcLogfont->lBaseHeight == 11 && lBaseHeight >= 12)
                pEudcLogfont->lBaseHeight = 12;
            else if (pEudcLogfont->lBaseHeight == 13 && lBaseHeight >= 15)
                pEudcLogfont->lBaseHeight = 15;
        }
    }


// if the base font is Raster font. we need to adjust escapement/orientation.
// because they can not generate arbitaraty rotated glyphs.

    if(!(ifio.bArbXforms()))
    {
        if( ifio.b90DegreeRotations() )
        {
        // font provider can support per 90 degree rotations.

            if( pEudcLogfont->ulOrientation )
            {
                ULONG ulTemp;
                ulTemp = lNormAngle(pEudcLogfont->ulOrientation);
                pEudcLogfont->ulOrientation =
                    (ulTemp / ORIENTATION_90_DEG) * ORIENTATION_90_DEG;

                if( (dco.pdc->bYisUp()) && (ulTemp % ORIENTATION_90_DEG))
                    pEudcLogfont->ulOrientation =
                        lNormAngle(pEudcLogfont->ulOrientation + ORIENTATION_90_DEG);
            }

            if( pEudcLogfont->lEscapement )
            {
                LONG lTemp;
                lTemp = lNormAngle(pEudcLogfont->lEscapement);
                pEudcLogfont->lEscapement =
                    (lTemp / ORIENTATION_90_DEG) * ORIENTATION_90_DEG;

                if( (dco.pdc->bYisUp()) && (lTemp % ORIENTATION_90_DEG))
                    pEudcLogfont->lEscapement =
                         lNormAngle(pEudcLogfont->lEscapement + ORIENTATION_90_DEG);
            }
        }
         else
        {
        // font provider can generate only horizontal glyph

            pEudcLogfont->ulOrientation = 0L;
            pEudcLogfont->lEscapement   = 0L;
        }
    }

    #if DBG
    if(gflEUDCDebug & DEBUG_FONTLINK_DUMP)
    {
        DbgPrint(" Base font face name %ws \n", ifio.pwszFaceName());
        DbgPrint("GDISRV:lBaseWidth  = %d\n",pEudcLogfont->lBaseWidth);
        DbgPrint("GDISRV:lBaseHeight = %d\n",pEudcLogfont->lBaseHeight);
        DbgPrint("GDISRV:lInternalL  = %d\n",lInternalLeading);
        DbgPrint("GDISRV:lEscapement  = %d\n",pEudcLogfont->lEscapement);
        DbgPrint("GDISRV:lOrientation = %d\n",pEudcLogfont->ulOrientation);
    }
    #endif
}


/******************************************************************************
 * PFE *ppfeFromUFI(PUNIVERSAL_FONT_ID pufi)
 *
 * Given a UFI, returns a corresponding PFE.  This function assume the caller
 * has grabed the ghsemPublicPFT semaphore.
 *
 *****************************************************************************/


PFE *ppfeFromUFI(PUNIVERSAL_FONT_ID pufi)
{
    PUBLIC_PFTOBJ pfto;
    FHOBJ fho(&pfto.pPFT->pfhUFI);
    HASHBUCKET  *pbkt;

    PFE         *ppfeRet = NULL;

    pbkt = fho.pbktSearch( NULL, (UINT*)NULL, pufi );

    if( pbkt != NULL )
    {
        PFELINK  *ppfel;

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

        // if the UFI's match and (in the case of a remote font) the process
        // that created the remote font is the same as the current one then
        // we've got a match

            if(UFI_SAME_FACE(pfeo.pUFI(),pufi) && pfeo.SameProccess())
            {
                if( pfeo.bDead() )
                {
                    WARNING("MAPPER::bFoundForcedMatch mapped to dead PFE\n");
                }
                else
                {
                    ppfeRet = ppfel->ppfe;
                    break;
                }
            }
        }

    #if DBG
        if (!ppfel)
        {
            WARNING1("ppfeFromUFI couldn't map to PFE\n");
        }
    #endif

    }
    else
    {
        WARNING("ppfeFromUFI pbkt is NULL\n");
    }

    return ppfeRet;
}


void RFONTOBJ::vInitEUDCRemote(XDCOBJ& dco)
{

#if DBG
    DbgPrint("calling remote vinit\n");
#endif // DBG

    if((prfnt->paprfntFaceName != NULL) &&
       (prfnt->paprfntFaceName[0] != NULL))
    {
    // If there is at least one facename link then the remote links must be initialized.
    // The set of links for a particular RFONT will never change during a print
    // job and the RFONT can only be used for this print-job (PDEV).  Thus we
    // don't have to check a time stamp or anything else to determine if the links
    // have changed and can simply return.

        return;
    }

// remote UFIs get treated as facename links so first initialize the facename array

    if(prfnt->paprfntFaceName == (PRFONT *)NULL)
    {
        if(dco.uNumberOfLinkedUFIs() > QUICK_FACE_NAME_LINKS)
        {
            if(!(prfnt->paprfntFaceName =
                 (PRFONT *)PALLOCMEM(dco.uNumberOfLinkedUFIs() * sizeof(PRFONT),'flnk')))
            {
                WARNING("vInitEUDCRemote: out of memory\n");
                return;
            }
        }
        else
        {
            prfnt->paprfntFaceName = prfnt->aprfntQuickBuff;
        }
    }

    prfnt->uiNumLinks = 0;

// Lock and Validate the LFONTOBJ user object.

    UINT u;
    PFEOBJ pfeo(prfnt->ppfe);
    PDEVOBJ pdo(dco.hdev());
    LFONTOBJ lfo(dco.pdc->hlfntCur(), &pdo);

    RFONTTMPOBJ rfoT(prfnt);
    DCOBJ       dcoT(dco.hdc());
    IFIOBJR     ifio(pfeo.pifi(),rfoT,dcoT);

// Fill up LogFont for EUDC.

    EUDCLOGFONT EudcLogFont;

    ComputeEUDCLogfont(&EudcLogFont, dco);

    for(u = 0; u < dco.uNumberOfLinkedUFIs(); u++)
    {
        {
         // this set of brackets is to make sure the ppfref descructor gets called
            PFE *ppfe;
            PFFREFOBJ pffref;
            RFONTOBJ rfo;

#if DBG
            DbgPrint("Trying to get pfe %d\n", u);
#endif // DBG

            {
                SEMOBJ  so(ghsemPublicPFT);

                if(ppfe = ppfeFromUFI(&dco.pufiLinkedFonts()[u]))
                {
                    PFEOBJ  pfeo1(ppfe);
                    pffref.vInitRef(pfeo1.pPFF());
#if DBG
                    DbgPrint("Found it\n");
#endif // DBG
                }

            }

            if(ppfe)
            {
                rfo.vInit(dco, ppfe, &EudcLogFont, FALSE);

                if(rfo.bValid())
                {
#if DBG
                    DbgPrint("Got a valid RFONT ENTRY\n");
#endif // DBG
                    prfnt->paprfntFaceName[prfnt->uiNumLinks++] =
                      rfo.prfntFont();
                }
            }
        }
    }

#if DBG
    DbgPrint("done: font has %d remote links\n", prfnt->uiNumLinks);
#endif // DBG
}


/******************************Public*Routine******************************\
* RFONTOBJ::vInitEUDC( XDCOBJ )
*
* This routine is called during text out when the first character that isn't
* in the base font is encountered.  vInitEUDC will then realize any EUDC RFONTS
* (if they haven't already been realized on previous text outs) so that they
* can possibly be used if the character(s) are in the EUDC fonts.
*
*  Thu 12-Jan-1995 15:00:00 -by- Hideyuki Nagase [hideyukn]
* Wrote it.
\**************************************************************************/

VOID RFONTOBJ::vInitEUDC( XDCOBJ& dco )
{

    if(dco.uNumberOfLinkedUFIs())
    {
        vInitEUDCRemote(dco);
        return;
    }

    FLINKMESSAGE(DEBUG_FONTLINK_RFONT,
                 "Calling vInitEUDC()\n");

// If we have already initialized System EUDC font, and NOT have
// any FaceName Linked font, we have nothing to do in this function.

    PFEOBJ pfeo(prfnt->ppfe);

// In most cases, we have the system EUDC font, at least.
// If the system eudc was initizlied, we might short-cut the eudc realization.

    if((prfnt->prfntSysEUDC != NULL) || (!IS_SYSTEM_EUDC_PRESENT()))
    {
    // if default eudc scheme is disabled or is already initizlied. we can
    // short-cut the realization.

        if((!bFinallyInitializeFontAssocDefault && !gbSystemDBCSFontEnabled) ||
           (prfnt->prfntDefEUDC != NULL) )
        {
        // if there is no facename eudc for this font or, is already initizlied
        // we can return here...

            if((pfeo.pGetLinkedFontEntry() == NULL) ||
               ((prfnt->paprfntFaceName != NULL) &&
                (pfeo.pGetLinkedFontEntry() != NULL) &&
                (prfnt->bFilledEudcArray == TRUE) &&
                (prfnt->ulTimeStamp == pfeo.ulGetLinkTimeStamp())))
            {
                return;
            }
        }
    }

// Lock and Validate the LFONTOBJ user object.

    PDEVOBJ pdo(dco.hdev());
    LFONTOBJ lfo(dco.pdc->hlfntCur(), &pdo);

    RFONTTMPOBJ rfoT(prfnt);
    DCOBJ       dcoT(dco.hdc());
    IFIOBJR     ifio(pfeo.pifi(),rfoT,dcoT);

// Fill up LogFont for EUDC.

    EUDCLOGFONT EudcLogFont;

    ComputeEUDCLogfont(&EudcLogFont, dco);

// first handle the system EUDC font

    UINT iPfeOffset = (prfnt->bVertical ? PFE_VERTICAL : PFE_NORMAL);

    if((prfnt->prfntSysEUDC == NULL) &&
       (gappfeSysEUDC[iPfeOffset] != NULL))
    {
        RFONTOBJ    rfo;
        PFEOBJ      pfeoEudc(gappfeSysEUDC[iPfeOffset]);
        IFIOBJ      ifioEudc(pfeoEudc.pifi());

         FLINKMESSAGE(DEBUG_FONTLINK_RFONT,
                      "Connecting System wide EUDC font....\n");

    // check Eudc font capacity

        if(!bCheckEudcFontCaps(ifioEudc))
        {
        // font capacity is not match we won't use system eudc.

            prfnt->prfntSysEUDC = (RFONT *)NULL;
        }
        else
        {
            rfo.vInit( dco,
                       gappfeSysEUDC[iPfeOffset],
                       &EudcLogFont,
                       FALSE );      // prfnt->cache.bSmallMetrics );

            if( rfo.bValid() )
            {
                FLINKMESSAGE(DEBUG_FONTLINK_RFONT,
                             "vInitEUDC() -- linking System EUDC\n");

                prfnt->prfntSysEUDC = rfo.prfntFont();
            }
        }
    }

// next handle default links

    if(bFinallyInitializeFontAssocDefault && (prfnt->prfntDefEUDC == NULL))
    {
        BYTE jWinCharSet        = (ifio.lfCharSet());
        BYTE jFamily            = (ifio.lfPitchAndFamily() & 0xF0);
        UINT iIndex             = (jFamily >> 4);
        BOOL bEnableDefaultLink = FALSE;

        FLINKMESSAGE(DEBUG_FONTLINK_RFONT,
                     "Connecting Default EUDC font....\n");

    // Check default font association is disabled for this charset or not.

        switch (jWinCharSet)
        {
        case ANSI_CHARSET:
        case OEM_CHARSET:
        case SYMBOL_CHARSET:
            //
            // following code is equal to
            //
            // if ((Char == ANSI_CHARSET   && fFontAssocStatus & ANSI_ASSOC)  ||
            //     (Char == OEM_CHARSET    && fFontAssocStatus & OEM_ASSOC)   ||
            //     (Char == SYMBOL_CHARSET && fFontAssocStatus & SYMBOL_ASSOC)  )
            //
            if( ((jWinCharSet + 2) & 0xf) & fFontAssocStatus )
            {
                bEnableDefaultLink = TRUE;
            }
             else
                bEnableDefaultLink = FALSE;
            break;

        default:
            bEnableDefaultLink = FALSE;
            break;
        }

        if( bEnableDefaultLink )
        {
        // Check the value is valid or not.

            if( iIndex < NUMBER_OF_FONTASSOC_DEFAULT )
            {
                ASSERTGDI( (FontAssocDefaultTable[iIndex].DefaultFontType == jFamily),
                            "GDISRV:FONTASSOC DEFAULT:Family index is wrong\n");

            // if the registry data for specified family's default is ivalid
            // use default.....

                if( !FontAssocDefaultTable[iIndex].ValidRegData )
                {
                    iIndex = (NUMBER_OF_FONTASSOC_DEFAULT-1);
                }
            }
             else
            {
            // iIndex is out of range, use default one....

                WARNING("GDISRV:FontAssoc:Family is strange, use default\n");

                iIndex = (NUMBER_OF_FONTASSOC_DEFAULT-1);
            }


        // If vertical font is selected for base font, but the vertical font for
        // default EUDC is not available, but normal font is provided, use normal
        // font.

            if((iPfeOffset == PFE_VERTICAL) &&
               (FontAssocDefaultTable[iIndex].DefaultFontPFEs[PFE_VERTICAL] ==
                PPFENULL) &&
                (FontAssocDefaultTable[iIndex].DefaultFontPFEs[PFE_NORMAL] != PPFENULL))
            {
                iPfeOffset = PFE_NORMAL;
            }

            RFONTOBJ    rfo;
            PFEOBJ pfeoEudc(FontAssocDefaultTable[iIndex].DefaultFontPFEs[iPfeOffset]);

        // Check the PFE in default table is valid or not.

            if( pfeoEudc.bValid() )
            {
                IFIOBJ      ifioEudc(pfeoEudc.pifi());

                if( !bCheckEudcFontCaps(ifioEudc) )
                {
                    prfnt->prfntDefEUDC = (RFONT *)NULL;
                }
                 else
                {
                    rfo.vInit( dco,
                               FontAssocDefaultTable[iIndex].DefaultFontPFEs[iPfeOffset],
                               &EudcLogFont,
                               FALSE );      // prfnt->cache.bSmallMetrics );

                    if( rfo.bValid() )
                    {
                        FLINKMESSAGE(DEBUG_FONTLINK_RFONT,
                                     "vInitEUDC() -- linking default EUDC\n");

                        prfnt->prfntDefEUDC = rfo.prfntFont();
                    }
                }
            }
        }
        else
        {
        // FontAssociation is disabled for this charset.

            prfnt->prfntDefEUDC = (RFONT *)NULL;
        }
    }
    else
    {
        prfnt->prfntDefEUDC = NULL;
    }

// next handle all the face name links

    if(pfeo.pGetLinkedFontEntry() != NULL)
    {
        BOOL bNeedToBeFilled = !(prfnt->bFilledEudcArray);

        FLINKMESSAGE(DEBUG_FONTLINK_RFONT,"Connecting Face name EUDC font....\n");

        //
        // if this RFONT has linked RFONT array and its linked font information
        // is dated, just update it here..
        //

        if((prfnt->paprfntFaceName != NULL) &&
           (prfnt->ulTimeStamp != pfeo.ulGetLinkTimeStamp()))
        {
            FLINKMESSAGE(DEBUG_FONTLINK_RFONT,
                         "vInitEUDC():This RFONT is dated, now updating...\n");

            //
            // Inactivating old linked RFONT.
            //
            // if Eudc font that is linked to this RFONT was removed, the removed
            // RFONT entry contains NULL, and its Eudc RFONT is already killed during
            // EudcUnloadLinkW() function. then we should inactivate all Eudc RFONT that
            // is still Active (Not Killed)..
            //

            for( UINT ii = 0 ; ii < prfnt->uiNumLinks ; ii++ )
            {
                //
                // Check Eudc RFONT is still active..
                //

                if( prfnt->paprfntFaceName[ii] != NULL )
                {
                    RFONTTMPOBJ rfoTmp( prfnt->paprfntFaceName[ii] );

                    #if DBG
                    if( gflEUDCDebug & DEBUG_FONTLINK_RFONT )
                    {
                        DbgPrint("vInitEUDC() deactivating linked font %x\n",
                                  prfnt->paprfntFaceName[ii]);
                    }
                    #endif

                    rfoTmp.bMakeInactiveHelper((PRFONT *)NULL);

                    prfnt->paprfntFaceName[ii] = NULL;
                }
            }

            //
            // Free this Array if it was allocated..
            //

            if( prfnt->paprfntFaceName != prfnt->aprfntQuickBuff )
                VFREEMEM( prfnt->paprfntFaceName );

            //
            // Invalidate the pointer.
            //

            prfnt->paprfntFaceName = (PRFONT *)NULL;
            prfnt->uiNumLinks      = 0;
        }

        if( prfnt->paprfntFaceName == (PRFONT *)NULL )
        {
            if(pfeo.pGetLinkedFontEntry()->uiNumLinks > QUICK_FACE_NAME_LINKS)
            {
                prfnt->paprfntFaceName =
                  (PRFONT *)PALLOCMEM(pfeo.pGetLinkedFontEntry()->uiNumLinks *
                                      sizeof(PRFONT),'flnk');
            }
             else
            {
                prfnt->paprfntFaceName = prfnt->aprfntQuickBuff;
            }

            bNeedToBeFilled = TRUE;
        }

        if( bNeedToBeFilled )
        {
            PLIST_ENTRY p = pfeo.pGetLinkedFontList()->Flink;
            UINT        uiRfont = 0;

            while( p != pfeo.pGetLinkedFontList() )
            {
                #if DBG
                if( gflEUDCDebug & DEBUG_FONTLINK_RFONT )
                {
                    DbgPrint("vInitEUDC() -- linking FaceName %d\n", uiRfont);
                }
                #endif

                PPFEDATA ppfeData = CONTAINING_RECORD(p,PFEDATA,linkedFontList);

                //
                // Check this linked font have Vertical facename or not,
                // if it doesn't have, use normal facename...
                //

                UINT iPfeOffsetLocal;

                if( ppfeData->appfe[iPfeOffset] == NULL )
                    iPfeOffsetLocal = PFE_NORMAL;
                 else
                    iPfeOffsetLocal = iPfeOffset;

                PFEOBJ   pfeoEudc(ppfeData->appfe[iPfeOffsetLocal]);
                IFIOBJ   ifioEudc(pfeoEudc.pifi());

                if( bCheckEudcFontCaps(ifioEudc) )
                {
                    RFONTOBJ rfo;

                    rfo.vInit( dco,
                               ppfeData->appfe[iPfeOffsetLocal],
                               &EudcLogFont,
                               FALSE );        // prfnt->cache.bSmallMetrics );

                    if( rfo.bValid() )
                    {
                        ASSERTGDI(uiRfont < pfeo.pGetLinkedFontEntry()->uiNumLinks ,
                                 "uiRfont >= pfeo.uiNumLinks\n");
                        prfnt->paprfntFaceName[uiRfont] = rfo.prfntFont();

                        //
                        // Increase real linked font number.
                        //

                        uiRfont++;
                    }
                }

                p = p->Flink;
            }


            prfnt->uiNumLinks = uiRfont;

            prfnt->ulTimeStamp = pfeo.ulGetLinkTimeStamp();

            prfnt->bFilledEudcArray = TRUE;
        }
    }
    else
    {
    // if this PFE has no eudc link list..
    // the pointer to linked RFONT array should be NULL.

        ASSERTGDI(prfnt->paprfntFaceName == NULL,
                  "vInitEUDC():The font has not linked font, but has its Array\n");
    }

    #if DBG
    if(gflEUDCDebug & DEBUG_FONTLINK_DUMP) lfo.vDump();
    #endif
}

/******************************Public*Routine******************************\
* RFONTOBJ::vInit (DCOBJ, PFE*, LONG, FIX)
*
* This is a special constructor used for EUDC fonts.  Rather than use the
* LOGFONT currently selected into the DC to map to a PFE, it is passed in
* a PFE.  If lBaseWidth of lBaseHeight is non-zero vInit will try to realize a
* font with width and height as close as possible to those lBaseWidth/Height.
*
*  Tue 24-Oct-1995 12:00:00 -by- Hideyuki Nagase [hideyukn]
* Rewrote it.
*
*  Thu 23-Feb-1995 10:00:00 -by- Hideyuki Nagase [hideyukn]
* SmallMetrics support.
*
*  Fri 25-Mar-1993 10:00:00 -by- Gerrit van Wingerden [gerritv]
* Wrote it.
\**************************************************************************/

VOID RFONTOBJ::vInit(
    XDCOBJ      &dco,
    PFE         *ppfeEUDCFont,
    EUDCLOGFONT *pEudcLogFont,
    BOOL         bSmallMetrics
    )
{
    SEMOBJ  sem(ghsemEUDC2);
        
    BOOL bNeedPaths = dco.pdc->bActive() ? TRUE : FALSE;

    FLINKMESSAGE(DEBUG_FONTLINK_RFONT,"gdisrv!vInit():Initializing EUDC font.\n");

    ASSERTGDI(bSmallMetrics == FALSE,"gdisrv!bSmallMetrics is 1 for EUDC font\n");

    BOOL bRet = FALSE;

// Get PDEV user object (need for bFindRFONT).
// This must be done before the ghsemPublicPFT is locked down.

    PDEVOBJ pdo(dco.hdev());
    ASSERTGDI(pdo.bValid(), "gdisrv!RFONTOBJ(dco): bad pdev in dc\n");

// Lock and Validate the LFONTOBJ user object.

    LFONTOBJ lfo(dco.pdc->hlfntCur(), &pdo);
    if (!lfo.bValid())
    {
        WARNING("gdisrv!RFONTOBJ(dco): bad LFONT handle\n");
        prfnt = PRFNTNULL;  // mark RFONTOBJ invalid
        return;
    }

// Now we're ready to track down this RFONT we want...
// Compute the Notional to Device transform for this realization.

    PFEOBJ  pfeo(ppfeEUDCFont);
    IFIOBJ  ifio(pfeo.pifi());

    ASSERTGDI(pfeo.bValid(), "gdisrv!RFONTOBJ(dco): bad ppfe from mapping\n");

// Set bold and italic simulation flags if neccesary

    FLONG flSim = 0;

// if base font is originally italialized or simulated, we
// also generate italic font.

    if ( (pEudcLogFont->flBaseFontType & FO_SIM_ITALIC) ||
         (pEudcLogFont->fsSelection    & FM_SEL_ITALIC)    )
    {
        flSim |= lfo.flEudcFontItalicSimFlags(ifio.bNonSimItalic(),
                                              ifio.bSimItalic());
    }

// If the basefont is BMP font then we only embolden the linked font for Display
// If the basefont is scalable then we embolden linked font at any device.

    if ( (pdo.bDisplayPDEV() || pEudcLogFont->bContinuousScaling) &&
         ((pEudcLogFont->fsSelection & FM_SEL_BOLD) ||
         (pEudcLogFont->flBaseFontType & FO_SIM_BOLD)))
    {
        flSim |= lfo.flEudcFontBoldSimFlags((USHORT)ifio.lfWeight());
    }

//
//
//  We won't set bold simulation flag to font driver.
//  This is for following situation.
// if the base font is FIXED_PITCH font, and enbolden, then
// we need to scale EUDC font as same width of based font.
// but font enbolden simulation is depend on the font driver, we
// might not get exact same witdh of scaled eudc font.
//

//
// this is needed only by ttfd to support win31 hack: VDMX XFORM QUANTIZING
// NOTE: in the case that the requested height is 0 we will pick a default
// value which represent the character height and not the cell height for
// Win 3.1 compatibility.  Thus I have he changed this check to be <= 0
// from just < 0. [gerritv]
//
    if (ifio.bTrueType() && (lfo.plfw()->lfHeight <= 0))
        flSim |= FO_EM_HEIGHT;

// Now we need to check if the base font is going to be antialiased,
// if so we also want to antialias the linked font, if it is capable of it

    if ((pEudcLogFont->flBaseFontType & FO_GRAY16) && (pfeo.pifi()->flInfo & FM_INFO_4BPP))
    {
        flSim |= (pEudcLogFont->flBaseFontType & (FO_GRAY16 | FO_CLEARTYPE_X));
    }

// Hack the width of the logfont to get same width of eudc font as base font.

    LONG lWidthSave         = lfo.lWidth( pEudcLogFont->lBaseWidth );
    LONG lHeightSave        = lfo.lHeight( pEudcLogFont->lBaseHeight );
    ULONG ulOrientationSave = lfo.ulOrientation( pEudcLogFont->ulOrientation );
    ULONG lEscapementSave   = lfo.lEscapement( pEudcLogFont->lEscapement );

    FD_XFORM fdx;           // realize with this notional to device xform
    POINTL   ptlSim;        // for bitmap scaling simulations

    if (!ifio.bContinuousScaling())
    {
        WARNING("EUDC font could not be ContinuousScaling\n");
        prfnt = PRFNTNULL;  // mark RFONTOBJ invalid
        return;
    }
     else
    {
        ptlSim.x = 1; ptlSim.y = 1; // this will be not used for scalable font...
    }

    bRet = pfeo.bSetFontXform(dco, lfo.plfw(), &fdx,
                              0,
                              flSim,
                              (POINTL* const) &ptlSim,
                              ifio,
                              TRUE  // font is linked
                             );

// if bSetFontXform() was fail, return here....

    if( !bRet )
    {
        lfo.lWidth( lWidthSave );
        lfo.lHeight( lHeightSave );
        lfo.ulOrientation( ulOrientationSave );
        lfo.lEscapement( lEscapementSave );
        WARNING("gdisrv!RFONTOBJ(dco): failed to compute font transform\n");
        prfnt = PRFNTNULL;  // mark RFONTOBJ invalid
        return;
    }

// Tell PFF about this new reference, and then release the global sem.
// Note that vInitRef() must be called while holding the semaphore.

    PFFREFOBJ pffref;
    {
        SEMOBJ  so(ghsemPublicPFT);
        pffref.vInitRef(pfeo.pPFF());
    }

// go find the font

    EXFORMOBJ xoWtoD(dco.pdc->mxWorldToDevice());
    ASSERTGDI(xoWtoD.bValid(), "gdisrv!RFONTOBJ(dco) - \n");

// Attempt to find an RFONT in the lists cached off the PDEV.  Its transform,
// simulation state, style, etc. all must match.

    if ( bFindRFONT(&fdx,
                    flSim,
                    0, // lfo.pelfw()->elfStyleSize,
                    pdo,
                    &xoWtoD,
                    ppfeEUDCFont,
                    bNeedPaths,
                    dco.pdc->iGraphicsMode(),
                    bSmallMetrics,

                    RFONT_TYPE_UNICODE  // must be unicode for EUDC
                    ) )
    {

        FLINKMESSAGE2(DEBUG_FONTLINK_RFONT,"EUDC RFONT is %x\n",prfnt);

    // now restore the old width

        lfo.lWidth( lWidthSave );
        lfo.lHeight( lHeightSave );
        lfo.ulOrientation( ulOrientationSave );
        lfo.lEscapement( lEscapementSave );

    // Grab cache semaphore.

        vGetCache();
        dco.pdc->vXformChange(FALSE);

        return;
    }

// If we get here, we couldn't find an appropriate font realization.
// Now, we are going to create one just for us to use.

    bRet = bRealizeFont(&dco,
                        &pdo,
                        lfo.pelfw(),
                        ppfeEUDCFont,
                        &fdx,
                        (POINTL* const) &ptlSim,
                        flSim,
                        0, // lfo.pelfw()->elfStyleSize,
                        bNeedPaths,
                        bSmallMetrics,
                        RFONT_TYPE_UNICODE
                       );
// now restore the old width

    lfo.lWidth( lWidthSave );
    lfo.lHeight( lHeightSave );
    lfo.ulOrientation( ulOrientationSave );
    lfo.lEscapement( lEscapementSave );


    if( !bRet )
    {
        WARNING("gdisrv!RFONTOBJ(dco): realization failed, RFONTOBJ invalidated\n");
        prfnt = PRFNTNULL;  // mark RFONTOBJ invalid
        return;
    }

    ASSERTGDI(bValid(), "gdisrv!RFONTOBJ(dco): invalid hrfnt from realization\n");

// We created a new RFONT, we better hold the PFF reference!

    pffref.vKeepIt();

// Finally, grab the cache semaphore.

    vGetCache();
    dco.pdc->vXformChange(FALSE);

    FLINKMESSAGE2(DEBUG_FONTLINK_RFONT,"EUDC RFONT is %x\n",prfnt);

    return;
}

/******************************Public*Routine******************************\
* BOOL RFONTOBJ::bIsLinkedGlyph (WCHAR wc)
*
* Does a quick check to see if a character is in either the system EUDC
* font or a font that has been linked to this RFONT.
*
*  Tue 17-Jan-1995 14:00:00 -by- Hideyuki Nagase [hideyukn]
* Rewrote it.
*
*  Wed 11-Aug-1993 10:00:00 -by- Gerrit van Wingerden [gerritv]
* Wrote it.
\**************************************************************************/

#define IS_PRIVATE_EUDC_AREA(wc) \
        (((wc) >= 0xE000) && ((wc) <= 0xF8FF))

BOOL RFONTOBJ::bIsLinkedGlyph( WCHAR wc )
{
    GreAcquireSemaphore( ghsemEUDC1 );

// we don't release ghsemEUDC1 mutex here, we have to guard the current eudc
// link data. All of the API that change eudc data, try to hold this
// mutex, if we hold it, nobody can process the request...
//
// if another thread will change eudc link between this thread is in after
// release the mutex (end of this function) and before we increment gcEUDCCount
// in vInitEUDC(). In the case, this function might return TRUE for non-linked
// char or return FALSE for linked char, but we don't need to worry about this.
// because following line in wpgdGetLinkMetricsPlus() will returns NULL and
// we will return default char. the cost is only time..

    BOOL bRet = FALSE;

// EudcDefaultChar should be displayed for 'Private User Area', when there is no
// font are linked. (font's default character should not be came up).

    if( IS_PRIVATE_EUDC_AREA(wc) )
    {
        bRet = TRUE;
    }

    if( (bRet == FALSE) && IS_SYSTEM_EUDC_PRESENT() && IS_IN_SYSTEM_EUDC(wc) )
    {
        bRet = TRUE;
    }

    if( (bRet == FALSE) && bFinallyInitializeFontAssocDefault )
    {
        //
        // THIS CODEPATH SHOULD BE OPTIMIZED....
        //
        // UNDER_CONSTRUCTION.
        //
        UINT   iPfeOffset = (prfnt->bVertical ? PFE_VERTICAL : PFE_NORMAL);
        PFEOBJ pfeo(prfnt->ppfe);
        IFIOBJ ifio(pfeo.pifi());
        BYTE   jFamily = (ifio.lfPitchAndFamily() & 0xF0);
        UINT   iIndex  = (jFamily >> 4);

        //
        // Check the value is valid or not.
        //
        if( iIndex < NUMBER_OF_FONTASSOC_DEFAULT )
        {
            ASSERTGDI( (FontAssocDefaultTable[iIndex].DefaultFontType == jFamily),
                        "GDISRV:FONTASSOC DEFAULT:Family index is wrong\n");

            //
            // if the registry data for specified family's default is ivalid
            // use default.....
            //
            if( !FontAssocDefaultTable[iIndex].ValidRegData )
            {
                iIndex = (NUMBER_OF_FONTASSOC_DEFAULT-1);
            }
        }
         else
        {
            //
            // iIndex is out of range, use default..
            //
            WARNING("GDISRV:FontAssoc:Family is strange, use default\n");

            iIndex = (NUMBER_OF_FONTASSOC_DEFAULT-1);
        }

        //
        // If vertical font is selected for base font, but the vertical font for
        // default EUDC is not available, but normal font is provided, use normal
        // font.
        //
        if( (iPfeOffset == PFE_VERTICAL) &&
            (FontAssocDefaultTable[iIndex].DefaultFontPFEs[PFE_VERTICAL] == PPFENULL) &&
            (FontAssocDefaultTable[iIndex].DefaultFontPFEs[PFE_NORMAL]   != PPFENULL))
        {
            iPfeOffset = PFE_NORMAL;
        }

        PFEOBJ      pfeoEudc(FontAssocDefaultTable[iIndex].DefaultFontPFEs[iPfeOffset]);

        //
        // Check the PFE in default table is valid or not.
        //
        if( pfeoEudc.bValid() )
        {
            if( IS_IN_FACENAME_LINK( pfeoEudc.pql(), wc ))
            {
                bRet = TRUE;
            }
        }
    }
    else
    if(gbSystemDBCSFontEnabled)
    {
        PFEOBJ pfeo(prfnt->ppfe);

        if(pfeo.bSBCSSystemFont())
        {
        // we assume that the set of glyphs is the same for the vertical and
        // non vertical PFE's so for simplicity always use the normal pfe.

            PFEOBJ pfeSystemDBCSFont(gappfeSystemDBCS[PFE_NORMAL]);

            ASSERTGDI(pfeSystemDBCSFont.bValid(),
                      "bIsLinkedGlyph: invalid SystemDBCSFont pfe\n");

            if(IS_IN_FACENAME_LINK(pfeSystemDBCSFont.pql(),wc))
            {
                bRet = TRUE;
            }
        }
    }

// Walk through FaceName link list if we haven't found it yet.

    if( bRet == FALSE )
    {
        //
        // Is this a FaceName EUDC character ?
        //
        UINT iPfeOffset = (prfnt->bVertical ? PFE_VERTICAL : PFE_NORMAL);

        PFEOBJ pfeo(prfnt->ppfe);
        PLIST_ENTRY p = pfeo.pGetLinkedFontList()->Flink;

        //
        // Scan the linked font list for this base font.
        //

        while( p != pfeo.pGetLinkedFontList() )
        {
            PPFEDATA ppfeData = CONTAINING_RECORD(p,PFEDATA,linkedFontList);

            //
            // Check this linked font have Vertical facename or not,
            // if it doesn't have, use normal facename...
            //

            UINT iPfeOffsetLocal;

            if( ppfeData->appfe[iPfeOffset] == NULL )
                iPfeOffsetLocal = PFE_NORMAL;
             else
                iPfeOffsetLocal = iPfeOffset;

            PFEOBJ   pfeoEudc(ppfeData->appfe[iPfeOffsetLocal]);

            ASSERTGDI( pfeoEudc.pql() != NULL ,
                      "bIsLinkedGlyph() pfeoEudc.pql() == NULL\n" );

            if(IS_IN_FACENAME_LINK( pfeoEudc.pql(), wc ))
            {
                bRet = TRUE;
                break;
            }

            p = p->Flink;
        }
    }

    GreReleaseSemaphore( ghsemEUDC1 );

    return(bRet);
}






/******************************Public*Routine******************************\
* BOOL STROBJ_bEnumLinked (pstro,pc,ppgpos)
*
* The glyph enumerator.
*
* History:
*  Tue 28-Sep-1993 11:37:00 -by- Gerrit van Wingerden
* Converted to a special helper function to handle linked fonts.
*
*  Tue 17-Mar-1992 10:35:05 -by- Charles Whitmer [chuckwh]
* Simplified it and gave it the quick exit.  Also let drivers call here
* direct.
*
*  02-Oct-1991 -by- Bodin Dresevic [BodinD]
* Wrote it.
\**************************************************************************/

BOOL STROBJ_bEnumLinked(ESTROBJ *peso, ULONG *pc,PGLYPHPOS  *ppgpos)
{
// Quick exit.

    if( peso->cgposCopied == 0 )
    {
        for( peso->plNext = peso->plPartition, peso->pgpNext = peso->pgpos;
            *(peso->plNext) != peso->lCurrentFont;
            (peso->pgpNext)++, (peso->plNext)++ );
        {
        }
    }
    else
    {
       if( peso->cgposCopied == peso->cGlyphs )
       {
        // no more glyphs so just return
            *pc = 0;
            return(FALSE);
       }
       else
       {
        // find next glyph

            for( (peso->plNext)++, (peso->pgpNext)++;
                 *(peso->plNext) != (peso->lCurrentFont);
                 (peso->pgpNext)++, (peso->plNext)++ );
            {
            }
       }
    }

    if (peso->prfo == NULL)  // check for journaling
    {
        WARNING("ESTROBJ::bEnum(), bitmap font, prfo == NULL\n");
        *pc = 0;
        return(FALSE);
    }

    if( peso->prfo->cGetGlyphData(1,peso->pgpNext) == 0 )
    {
        WARNING("couldn't get glyph for some reason\n");
        *pc = 0;
        return(FALSE);
    }

    peso->cgposCopied += 1;     // update enumeration state
    *pc = 1;
    *ppgpos = peso->pgpNext;

    return(peso->cgposCopied < peso->cGlyphs);  // TRUE => more to come.
}

/******************************Public*Routine******************************\
* VOID ESTROBJ fxBaseLineAdjust( _fxBaseLineAdjust )
*
* History:
*  24-Dec-1993 -by- Hideyuki Nagase
* Wrote it.
\**************************************************************************/

VOID ESTROBJ::ptlBaseLineAdjustSet( POINTL& _ptlBaseLineAdjust )
{
    INT ii;
    UINT uFound;

    ptlBaseLineAdjust = _ptlBaseLineAdjust;

    if( !(ptlBaseLineAdjust.x || ptlBaseLineAdjust.y) )
        return;

    for( ii = 0,uFound = 0 ; uFound < cGlyphs ; ii++ )
    {
        if( plPartition[ii] == lCurrentFont )
        {
            pgpos[ii].ptl.x += ptlBaseLineAdjust.x;
            pgpos[ii].ptl.y += ptlBaseLineAdjust.y;
            uFound++;
        }
    }
}

/******************************Public*Routine******************************\
* BOOL ESTROBJ bPartitionInit( c, uiNumLinks )
*
* History:
*  29-Nov-1995 -by- Hideyuki Nagase
* Add initialize for FaceNameGlyphs array.
*
*  29-Sep-1993 -by- Gerrit van Wingerden
* Wrote it.
\**************************************************************************/

BOOL ESTROBJ::bPartitionInit(COUNT c, UINT uiNumLinks, BOOL bEudcInit)
{

// Always initialize at least for the SystemTTEUDC Font.  We can't initialize
// the EUDC specific stuff until we've called RFONTOBJ::vInitEUDC, something
// we won't do when just outputing System DBCS glyphs

// the first thing we should do is clear the SO_ZERO_BEARINGS and
// SO_CHAR_INC_EQUAL_BM_BASE flags in the TEXOBJ since this will turn
// off potentially fatal optimizations in the H3 case.

    flAccel &= ~(SO_CHAR_INC_EQUAL_BM_BASE|SO_ZERO_BEARINGS);

    if(!(flTO & TO_SYS_PARTITION))
    {
        plPartition = (LONG*) &pgpos[c];
        pwcPartition = (WCHAR*) &plPartition[c];
        RtlZeroMemory((VOID*)plPartition, c * sizeof(LONG));
        pacFaceNameGlyphs = NULL;

        cSysGlyphs = 0;
        cDefGlyphs = 0;
        cTTSysGlyphs = 0;

        flTO |= TO_SYS_PARTITION;
    }

    if(bEudcInit)
    {
        if( uiNumLinks >= QUICK_FACE_NAME_LINKS )
        {
            pacFaceNameGlyphs = (ULONG *) PALLOCMEM(uiNumLinks * sizeof(UINT),'flnk');

            if (pacFaceNameGlyphs == (ULONG *) NULL)
            {
            // if we fail allocate memory, we just cancel eudc output.
                return (FALSE);
            }

            flTO |= TO_ALLOC_FACENAME;
        }
        else
        {
            pacFaceNameGlyphs = acFaceNameGlyphs;
            RtlZeroMemory((VOID*) pacFaceNameGlyphs, uiNumLinks * sizeof(UINT));
        }

        flTO |= TO_PARTITION_INIT;
    }

    return (TRUE);
}


/****************************************************************************
* RFONTOBJ::GetLinkedFontUFIs
*
* This routine returns the UFI's for the font(s) that are linked to this
* RFONT.  If pufi is NULL, simply returns the number of UFI's linked to
* this RFONT.
*
*****************************************************************************/

INT RFONTOBJ::GetLinkedFontUFIs(XDCOBJ& dco, PUNIVERSAL_FONT_ID pufi, INT NumUFIs)
{
    UINT u;
    INT UFICount = 0;

// check pui

    if (NumUFIs && pufi == NULL)
    {
        WARNING("RFONTOBJ::GetLinkedFontUFIs() pufi == NULL but NumUFIs != 0\n");
        return (0);
    }

// initialize system TT font if applicable

    if(prfnt->bIsSystemFont)
    {
        if((!prfnt->prfntSystemTT) && !bInitSystemTT(dco))
        {
            WARNING("Error initializing TT system font 5\n");
            return(0);
        }
        prfnt->flEUDCState |= EUDC_NO_CACHE;
    }

// initialize EUDC fonts if we haven't done so already

    {
        GreAcquireSemaphore(prfnt->hsemEUDC);
        
        if( !( prfnt->flEUDCState & EUDC_INITIALIZED ) )
        {
        // this value will be decremented in RFONTOBJ::dtHelper()

            INCREMENTEUDCCOUNT;

            vInitEUDC(dco);
            prfnt->flEUDCState |= (EUDC_INITIALIZED | EUDC_NO_CACHE);
        }

        GreReleaseSemaphore(prfnt->hsemEUDC);
    }
    
    if(prfnt->prfntSystemTT)
    {
        if(UFICount++ < NumUFIs)
        {
            RFONTTMPOBJ rfo(prfnt->prfntSystemTT);
            rfo.vUFI(pufi);
            pufi++;
        }
    }

    for(u = 0; u < prfnt->uiNumLinks; u++)
    {
        ASSERTGDI(prfnt->paprfntFaceName[u],"GDI:uGetLinkedFonts: null facename font\n");

        if(UFICount++ < NumUFIs)
        {
            RFONTTMPOBJ rfo(prfnt->paprfntFaceName[u]);
            rfo.vUFI(pufi);
            pufi++;
        }
    }

    if(prfnt->prfntDefEUDC)
    {
        if(UFICount++ < NumUFIs)
        {
            RFONTTMPOBJ rfo(prfnt->prfntDefEUDC);
            rfo.vUFI(pufi);
            pufi++;
        }
    }

    if(prfnt->prfntSysEUDC)
    {
        if(UFICount++ < NumUFIs)
        {
            RFONTTMPOBJ rfo(prfnt->prfntSysEUDC);
            rfo.vUFI(pufi);
            pufi++;
        }
    }

    return(UFICount);
}