|
|
/******************************Module*Header*******************************\
* Module Name: pffobj.hxx * * The physical font file (PFF) user object, and memory objects. * * The physical font file object: * ------------------------------ * * o represents the IFI font file * * o stores UNICODE filename of the font * * o stores the HFF used by the IFI driver to identify a font file * * o a single PFF is used to represent each device and its fonts * (treated as if all device fonts were in a single file) * * o caches the driver used to access the file * * o HFDEV for IFI fonts * * o HLDEV for device fonts * * o has counts of total RFONTs using this PFF * * o needed when deleting a font * * o all the RFONTs must be inactive (i.e., not mapped to any * logical font currently selected into a DC) for deletion * * o provides the PFTOBJ with methods to support loading and removing * fonts as well as enumeration * * if private font tables are added to the system, a count of * PFTs should be added to this * * Created: 11-Dec-1990 09:29:58 * Author: Gilman Wong [gilmanw] * * Copyright (c) 1990-1999 Microsoft Corporation * \**************************************************************************/
#ifndef _PFFOBJ_
#define _PFFOBJ_
#ifndef GDIFLAGS_ONLY // used for gdikdx
/*********************************Class************************************\
* REGHASHBKT * * Used to contsruct a hash table that contains all the registry font entries. * At logoff time we can quickly determine whether a font is permanent or * not by looking it up in the hash table. * * * History: * 07-Jul-1994 -by- Gerrit van Wingerden [gerritv] * Wrote it. \**************************************************************************/
#if 0
typedef struct tagRHB { LPWSTR pwszPath; // complete path (if it exists) of file in this bucket
LPWSTR pwszBareName; // bare file name of file in this bucket
tagRHB *pRHB; // next bucket in this slot (for collisions)
} REGHASHBKT; #endif
/*********************************Class************************************\
* class PFFCLEANUP * * Resources associated with a font file that need to be released or unloaded * when removing a font file from the system. We've got this stuff stored * here because we need to call the driver to release these things outside * of the semaphore used to protect PFF deletion. * * History: * 08-Mar-1993 -by- Gilman Wong [gilmanw] * Wrote it. \**************************************************************************/
class PFFCLEANUP /* pffc */ { public: HDEV hdev; HFF hff; PFF *pPFFClone; };
#endif // GDIFLAGS_ONLY used for gdikdx
// following flags are defined in wingdi.h
//#define FR_PRIVATE 0x10
//#define FR_NOT_ENUM 0x20
// FR_PRINT_EMB_FONT is used internally to indicate that the current process
// has used the private/embedded font for local printing
#define FR_PRINT_EMB_FONT 0x40
#ifndef GDIFLAGS_ONLY // used for gdikdx
// Data used for private font list
typedef struct tagPvtData { COUNT cPrivate; // private load count
COUNT cNotEnum; // cound for FR_PRIVATE | FR_NOT_ENUM
ULONG fl; // FR_PRIVATE, FR_PRIVATE | FR_NOT_ENUM, FRW_EMB_PID, FRW_EMB_TID, FR_PRINT_EMB_FONT (local printing only)
DWORD dwID; // PID or TID
struct tagPvtData *pPvtDataNext; // next data
}PVTDATA, PPVTDATA;
#endif // GDIFLAGS_ONLY used for gdikdx
// GS_EXTENDED is used only for device symbol font
// if its glyphset doesn't contain unicode range [f020, f0ff]
#define GS_EXTENDED 0X00000010
/*********************************Class************************************\
* class PFF * * Physical font file (PFF) object * * flState Represents state of font file. * * State Descriptipn * ======================================================= * PFF_STATE_READY2DIE * set if this file has been * unloaded from the API point of * view (i.e., cLoaded has been * decremented to 0), but some * one is still using a realization * of a font from this file. * * PFF_STATE_PERMANENT_FONT * this is either a stock font or a console font or * a font which is not a remote font (see below) and is * listed in the registry. * These fonts should not be removed at logoff time, * * PFF_STATE_NETREMOTE_FONT * this font is somewhere on the net, or to be precise * on one of the drives that do not have permanent drive * letter assignments. That is, different users may refer * to those drives by a different drive letters. * * PFF_STATE_MEMORY_FONT * this font is added to the system through a pointer, * font should be removed when the process terminates. * * PFF_STATE_DCREMOTE_FONT * added temporarily via AddRemoteFontToDC for during the * print job, different from PFF_STATE_REMOTE_FONT * this font is always associated with particular DC * * cLoaded Count of the number of times the engine has been * requested to load the font file * * cNotEnum Count of the number of times that engine has been requested * to load the font file as "Don't Enumerate" * * cRFONT The total number of RFONTs using this physical font file. * * ufd Union which represents the driver used to access the font. * If the font is an IFI font, then ufd is an HFDEV. * If the font is a device font, then ufd is an HLDEV. * * Along with lhFont, this is enough to make glyph queries. * * hff The handle by which the font driver identifies a loaded * font file. * * hdev This is 0 if PFF represents an IFI font file. * If it is not 0, then this is the physical * device handle and the PFF encapsulates the device fonts * of this physical device. * * dhpdev Device handle of the physical device for which this PFF * was created. Only used with device fonts * * cFonts Number of fonts (i.e., HPFEs) stored in the data buffer. * * aulData Data buffer used to store a table of HPFEs representing * the fonts in this font file, and the font file's * UNICODE pathname (path + filename). * * ___________________ * | | * | | * | HPFE table | * | | * |_________________| * | | <-- (PWSZ) &(aulData[cFonts]) * | | * | Pathname | * | | * | (NULL | * | terminated) | * | | * |_________________| * | | * | DesignVector | * | (if present) | // only there for mm instances
* |_________________| * * * History: * Tue 09-Nov-1993 -by- Patrick Haluptzok [patrickh] * Remove from handle manager * * 10-Dec-1990 -by- Gilman Wong [gilmanw] * Wrote it. \**************************************************************************/
#define PFF_STATE_READY2DIE 0x01
#define PFF_STATE_PERMANENT_FONT 0x02
#define PFF_STATE_NETREMOTE_FONT 0x04
#define PFF_STATE_EUDC_FONT 0x08
#define PFF_STATE_MEMORY_FONT 0x10
#define PFF_STATE_DCREMOTE_FONT 0x20
#define PFF_STATE_SYNTH_FONT 0x40
#ifndef GDIFLAGS_ONLY // used for gdikdx
class PFT;
extern PFT *gpPFTPrivate;
class PFF {
public:
SIZE_T sizeofThis;
// connects PFF's sharing the same hash bucket
PFF *pPFFNext; PFF *pPFFPrev;
// pwszPathname_ points to the Unicode upper case path
// name of the associated font file which is stored at the
// end of the data structure.
PWSZ pwszPathname_; ULONG cwc; // total for all strings
ULONG cFiles; // # of files associated with this font
DESIGNVECTOR *pdv_; // if present at all stored after pathname
ULONG cjDV_; // sizeof DESIGNVECTOR, somewhat redundant
// state
FLONG flState; // state (ready to die?)
COUNT cLoaded; // load count
COUNT cNotEnum; // load count for "not enum"
COUNT cRFONT; // total number of RFONTs
// RFONT list
RFONT *prfntList; // pointer to head of doubly linked list
// driver information
HFF hff; // font driver handle to font file
HDEV hdev; // physical device handle
DHPDEV dhpdev; // device handle of PDEV
FONTHASH *pfhFace; // face name hash table for this device
FONTHASH *pfhFamily; // face name hash table for this device
FONTHASH *pfhUFI; // UFI hash table for this device
PFT *pPFT; // pointer to the PFT that contains this entry
ULONG ulCheckSum; // checksum info used for UFI's
#ifdef LANGPACK
UINT uUniqueness; #endif
// fonts in this file (and filename slimed in)
COUNT cFonts; // number of fonts (same as chpfe)
PFONTFILEVIEW *ppfv; // array of cFiles pointers to FILEVIEW structures
// embeding information
PVTDATA *pPvtDataHead; // private font data link list
PFF *pPFFClone;
// collection of PFE
PFEC *pPFEC; ULONG_PTR aulData[1]; // data buffer for HPFE and filename
};
/*********************************Class************************************\
* class PFFOBJ * * User object for physical font files. * * History: * Tue 09-Nov-1993 -by- Patrick Haluptzok [patrickh] * Remove from handle manager * * 11-Dec-1990 -by- Gilman Wong [gilmanw] * Wrote it. \**************************************************************************/
class PUBLIC_PFTOBJ;
class PFFOBJ /* pffo */ { #ifdef LANGPACK
// system wide uniqueness value
static UINT uGlobalUniqueness; #endif
friend PFE *ppfeGetAMatch // FONTMAP.CXX
( XDCOBJ& dco , ENUMLOGFONTEXDVW *pelfwWishSrc , PWSZ pwszFaceName , ULONG ulMaxPenalty , FLONG fl , FLONG *pflSim , POINTL *pptlSim , FLONG *pflAboutMatch );
friend class MAPPER;
friend HEFS hefsDeviceAndEngine ( PWSZ pwszName, BOOL bEnumFonts, EFFILTER_INFO *peffi, PUBLIC_PFTOBJ &pfto, PFFOBJ &pffoDevice, PDEVOBJ &pdo, ULONG *pulCount );
public:
PFF *pPFF; // pointer to PFF object
PFFOBJ(PFF *pPFFNew) {pPFF = pPFFNew;} PFFOBJ() {} ~PFFOBJ() {}
// bValid -- Returns TRUE if lock successful.
BOOL bValid () { return(pPFF != NULL); }
// bDeleteLoadRef -- Decrements the load count and returns TRUE if caller
// should delete PFF.
BOOL bDeleteLoadRef (ULONG fl, PVTDATA *pPvtData, BOOL *pbWrongFlags); // PFFOBJ.CXX
// bDeleteRFONTRef -- Decrements the RFONT count and, if RFONT count reaches
// zero and PFF in READY2DIE state, calls bDelete.
BOOL bDeleteRFONTRef (); // PFFOBJ.CXX
// bAddHash -- Adds the PFF's set of PFEs to the font hash tables
// (used for font mapping and enumeration).
BOOL bAddHash(BOOL bEUDC); // PFFOBJ.CXX
// vRemoveHash -- Removes the PFF's set of PFEs from the font hash tables.
VOID vRemoveHash(); // PFFOBJ.CXX
// vPFFC_Delete -- Deletes the PFF and PFEs, while preserving the information
// that must be passed to the driver to complete the font file
// unload (saved in PFFCLEANUP structure).
//
// Changed so that it does not return a pointer to a PFFCLEANUP
// structure. Instead, it takes a pointer to a PFFCLEANUP
// structure as an argument. Thus, the caller must allocate
// and free the memory to the PFFCLEANUP structure. [dchinn 11/24/98]
VOID vPFFC_Delete(PFFCLEANUP *pPFFC); // PFFOBJ.CXX
// vPFFC_DeleteAndCleanup -- Functionally, this method does what vPFFC_Delete does,
// except that if there are more than CFONTS_PFFCLEANUP fonts in the
// font file, the PFFCLEANUP structure is declared as a local
// variable (so that the memory is on the stack). Also, it calls
// vCleanupFontFile. [dchinn 11/24/98]
VOID vPFFC_DeleteAndCleanup (); // PFFOBJ.CXX
PFF *pPFFGet() { return(pPFF); }
// bDeviceFonts -- Returns TRUE is this is a PFF that encapsulates a set of
// device specific fonts. We can only get glyph metrics from
// such fonts.
BOOL bDeviceFonts () { return(pPFF->hff == HFF_INVALID); }
// bDead -- Returns TRUE if the font is in a READY2DIE state.
BOOL bDead () { return(pPFF->flState & PFF_STATE_READY2DIE); }
// determines if the font should stay loaded after logoff and before logon
BOOL bPermanent();
// returns TRUE if remote font
BOOL bNetRemote() { return(pPFF->flState & PFF_STATE_NETREMOTE_FONT); }
// return true if the font is added temporarily for printing purposes
BOOL bDCRemote() { return(pPFF->flState & PFF_STATE_DCREMOTE_FONT); }
// returns TRUE if the font is loaded to the system through a pointer
BOOL bMemFont() { return(pPFF->flState & PFF_STATE_MEMORY_FONT); }
// Return the checksum for this font file.
ULONG ulCheckSum() { return(pPFF->ulCheckSum); }
// vKill -- Puts font in a "ready to die" state.
// vRevive -- Clears the "ready to die" state.
VOID vKill (); // PFFOBJ.CXX
VOID vRevive (); // PFFOBJ.CXX
#ifdef FE_SB
// bEUDC -- Returns TRUE if font was loaded as an EUDC font or FALSE otherwise.
BOOL bEUDC () { return(pPFF->flState & PFF_STATE_EUDC_FONT); }
// vSetEUDC -- Mark this font as EUDC font.
VOID vSetEUDC () { pPFF->flState |= PFF_STATE_EUDC_FONT; }
// ppfeEUDCGet() -- Gets EUDC pfes (for Normal and Vertical face)
VOID vGetEUDC (PEUDCLOAD pEudcLoadData); // flinkgdi.cxx
#endif
// hff -- Return IFI font file handle (NULL for device fonts).
HFF hff () { return(pPFF->hff); }
// hpdev -- Return HPDEV (NULL for IFI font files)
HDEV hdev () { return(pPFF->hdev); }
// dhpdev -- Return DHPDEV (NULL for IFI font files)
DHPDEV dhpdev () { return pPFF->dhpdev; }
// ppfe -- Return an HPFE handle from the table by index.
PFE *ppfe (ULONG iFont) { return(((PFE **) (pPFF->aulData))[iFont]); }
// Return internal PFE table statistics.
COUNT cFonts () { return(pPFF->cFonts); } COUNT cLoaded () { return(pPFF->cLoaded); } VOID vSet_cLoaded(COUNT c) { pPFF->cLoaded = c; }
COUNT cNotEnum() { return(pPFF->cNotEnum); } VOID vSet_cNotEnum(COUNT c) { pPFF->cNotEnum = c; } FONTFILEVIEW **ppfvGet() { return pPFF->ppfv; }
// vLoadIncr -- Increment the load count.
VOID vLoadIncr (ULONG flEmbed) { (flEmbed & FR_NOT_ENUM) ? pPFF->cNotEnum++ : pPFF->cLoaded++;
// May be neccessary to resurrect PFF if it had previously been in a ready
// to die state.
vRevive(); }
// design vector
DESIGNVECTOR *pdv() {return pPFF->pdv_;} ULONG cjDV() {return pPFF->cjDV_;}
// bInPrivatePFT() -- PFF in Private or Public PFT
BOOL bInPrivatePFT() { return(pPFF->pPFT == gpPFTPrivate); }
// pPvtDataHeadGet() -- Get the pPvtDataHead pointer
PVTDATA *pPvtDataHeadGet() { return(pPFF->pPvtDataHead); }
// ppPvtDataMatch() -- Used to find whether the current process has a PvtData
PVTDATA *pPvtDataMatch(); //PFFOBJ.CXX
// bAddPvtData -- Add PvtData block to the pPvtDataHead link list
BOOL bAddPvtData(ULONG flEmbed); //PFFOBJ.CXX
// bRemovePvtData -- Remove the PvtData block when cPrivate== 0
BOOL bRemovePvtData(PVTDATA *pPvtData); //PFFOBJ.CXX
// vAddRefFromRFONT -- Increment the RFONT count.
VOID vAddRFONTRef () { pPFF->cRFONT++; }
// cRFONT -- Return the RFONT count.
COUNT cRFONT() { return pPFF->cRFONT; }
// pwszPathname -- Return a pointer to the font file's pathname (UNICODE).
PWSZ pwszPathname() {return(pPFF->pwszPathname_);} PWSZ pwszCalcPathname() { return((PWSZ) &(((PFE **) pPFF->aulData)[pPFF->cFonts])); }
// cNumFiles -- return the count of files associated with this font
COUNT cNumFiles() {return(pPFF->cFiles);} COUNT cSizeofPaths() {return(pPFF->cwc);} // size of path in WCHARS includes
// NULL terminators
// prfntList -- Return/set head of RFONT list.
RFONT *prfntList() { return(pPFF->prfntList); } RFONT *prfntList(RFONT *prfntNew) { return(pPFF->prfntList = prfntNew); }
// pfhFace -- Return face name font hash table.
FONTHASH *pfhFace() { return pPFF->pfhFace; }
// pfhFamily -- Return family name font hash table.
FONTHASH *pfhFamily() { return pPFF->pfhFamily; }
#ifdef LANGPACK
// uUniqueness -- return uniqueness value for the PFF obj
UINT uUniqueness() { return(pPFF->uUniqueness); }
// vSetUniqueness -- set uniqueness assumes this call is being
// protected by a global semaphore
void vSetUniqueness() {pPFF->uUniqueness = PFFOBJ::uGlobalUniqueness++;} #endif
// vGetHPFE, bCreateHPFE and vDeleteHPFE
BOOL bCreatePFEC(ULONG cFonts); VOID vDeletePFEC(PVOID *ppvPFE); PFEC * pfec() {return (pPFF->pPFEC);} // vDump -- Print internals for debugging.
VOID vDump (); // PFFOBJ.CXX
};
typedef PFFOBJ *PPFFOBJ;
/******************************Class***************************************\
* PFFREFOBJ * * * * Holds up a reference to a PFF while the global PFT semaphore is not * * being held. Keeps the reference only if told to. * * * * Sun 27-Dec-1992 10:40:48 -by- Charles Whitmer [chuckwh] * * Wrote it. * \**************************************************************************/
class PFFREFOBJ : public PFFOBJ { public:
BOOL bKeepIt;
PFFREFOBJ() {pPFF = (PFF *) NULL;}
void vInitRef(PFF *pPFFNew) { // Caller must hold the ghsemPublicPFT which protects the ref. counts.
pPFF = (PFF *) pPFFNew; vAddRFONTRef(); bKeepIt = FALSE; }
~PFFREFOBJ() { if ((pPFF != (PFF *) NULL) && !bKeepIt) bDeleteRFONTRef(); }
void vKeepIt() {bKeepIt = TRUE;} };
/*********************************Class************************************\
* class PFFMEMOBJ : public PFFOBJ * * Memory object for physical font tables. * * Public Interface: * * PFFMEMOBJ () // allocate default size PFF
* PFFMEMOBJ (SIZE cjSize); // allocate non-default size PFF
* ~PFFMEMOBJ () // destructor
* * BOOL bValid () // validator
* VOID vKeepIt () // preserve memory object
* VOID vInit ( // initialize object
* BOOL bLoadFontFileTable ( // load up the PFF table
* BOOL bLoadDeviceFontTable ( // load up the PFF table with device
* BOOL bAddEntry ( // add PFE entry to table
* * History: * Tue 09-Nov-1993 -by- Patrick Haluptzok [patrickh] * Remove from handle manager * * 11-Dec-1990 -by- Gilman Wong [gilmanw] * Wrote it. \**************************************************************************/
#define PFFMO_KEEPIT 0x0002
class PDEVOBJ;
class PFFMEMOBJ : public PFFOBJ /* pffmo */ { public:
// Constructors -- Allocate memory for PFF objects and lock.
PFFMEMOBJ ();
PFFMEMOBJ( unsigned cFonts , PWSZ pwszUpperCasePath , ULONG cwc , ULONG cFiles , DESIGNVECTOR *pdv , ULONG cjDV , HFF hffFontFile , HDEV hdevDevice , DHPDEV dhpdevDevice , PFT *ppftParent , FLONG fl , FLONG flEmbed , PFNTCHECKSUM pCheckSum , PFONTFILEVIEW *ppfv , PUNIVERSAL_FONT_ID pufi // This can only be !NULL for remote printing
);
PFFMEMOBJ(PFF *pPFF, FLONG fl, FLONG flEmbed, PFT *ppftParent);
// Destructor -- Unlocks PFF object.
~PFFMEMOBJ (); // PFFOBJ.CXX
// bValid -- Validator which returns TRUE if lock successful.
BOOL bValid () { return(pPFF != NULL); }
// vKeepIt -- Prevent destructor from deleting RFONT.
VOID vKeepIt () { fs |= PFFMO_KEEPIT; }
// bLoadFontFileTable -- Load fonts from font file into table.
BOOL bLoadFontFileTable ( PWSZ pwszPathname , COUNT cFontsToLoad , HANDLE hdc , PUNIVERSAL_FONT_ID pufi // used to indicate PFE_UFIMATCH fonts
#ifdef FE_SB
, PEUDCLOAD pEudcLoadData = (PEUDCLOAD) NULL #endif
);
// bLoadDeviceFontTable -- Load device fonts into table.
BOOL bLoadDeviceFontTable (PDEVOBJ *ppdo);
// bAddEntry -- Add a PFE handle to the PFF's table.
BOOL bAddEntry ( ULONG iFont , FD_GLYPHSET *pfdg , ULONG_PTR idfdg , PIFIMETRICS pifi , ULONG_PTR idifi , HANDLE hdc , PUNIVERSAL_FONT_ID pufi #ifdef FE_SB
, PEUDCLOAD pEudcLoadData = (PEUDCLOAD) NULL #endif
);
FSHORT fs; };
extern VOID vCleanupFontFile(PFFCLEANUP *pPFFc);
#endif // GDIFLAGS_ONLY used for gdikdx
#endif
|