FontManager Class Reference

The font manager controlling class. More...

#include <fontman.h>

Inheritance diagram for FontManager:

List of all members.

Public Member Functions
	FontManager ()
	Constructor for the font manager class.
	~FontManager ()
BOOL	Init ()
	Get Camelots Font manager going. We simply cache the default font so unknown fonts can be sensibly replaced.
BOOL	LegalFontClass (INT32 Class, FontClass &RealClass)
	Check whether a numeric value actually indicates a valid class of font ie lies in the range of supported font types. This is used generally for loading purpose where the font class is loaded as a numeric value.
WORD	CacheNamedFont (String_64 *FontName, FontClass Class=FC_UNDEFINED)
	Given a font name try to cache all the data for that font so that we can actually us it. The cache will be checked first to make sure the font is not already installed.
CachedFontItem *	AddFont (String_64 *Name, FontClass Class, WORD &Handle)
	Creates a new font item for this named font. The font will not be fully cached. To cache all the data for the font, call CacheFontData(Handle).
CachedFontItem *	GetFont ()
	Return the precached default font data to use for rendering.
CachedFontItem *	GetFont (WORD Handle)
	Return the font data to use for rendering. This function performs a specific job in avoiding caching the font data. If the font is already cached then fine, it is returned for use. If not, the default font is returned.
CachedFontItem *	GetFont (String_64 *pFontName, FontClass Class=FC_UNDEFINED)
	Return the font data to use for rendering. This function performs a specific job in avoiding caching the font data. If the font is already cached then fine, it is returned for use. If not, the default font is returned.
WORD	GetFontHandle (String_64 *pFontName, FontClass Class=FC_UNDEFINED)
	Get the handle on a cached font (if cached) otherwise return the default font handle.
String_64 *	GetFontName (WORD Handle)
	Return a pointer to the font name given its font handle.
BOOL	GetFontName (WORD Handle, String_64 &OutputString)
FontClass	GetFontClass (WORD Handle)
	Return what class of font this handle is.
ENUMLOGFONT *	GetEnumLogFont (WORD Handle)
	Return the ENUMLOGFONT structure for this font handle. Note the function will automatically substitute the default font if the handle provided is invalid or the font it describes is not fully cached.
OUTLINETEXTMETRIC *	GetOutlineTextMetric (WORD Handle)
	Return the ENUMLOGFONT structure for this font handle Note the function will automatically substitute the default font if the handle provided is invalid or the font it describes is not fully cached.
CachedFontItem *	GetFirstFont ()
CachedFontItem *	GetNextFont (CachedFontItem *pItem)
CachedFontItem *	GetCachedFont (WORD Handle)
	This function returns the font associated with the handle passed. If the font is not in the cache it will return NULL. It differs from GetFont in that it will not attempt to return the DefaultFontItem if it cannot find the item specified.
INT32	DoesFontExist (String_64 *pFontName, BOOL SearchCache, BOOL SearchInstalled)
	First check in the cache if necessary, then through the installed set of fonts to find whether the named font actually exists.
BOOL	IsFontValid (WORD Handle)
	Check to see if the font described is actually valid, ie all the metrics for the font have been cached correctly.
BOOL	IsFontInstalled (String_64 *pFontName, FontClass Class=FC_UNDEFINED)
	Search through all the installed sets of fonts for the named font.
BOOL	IsFontDefault (WORD Handle)
	Check to see if the font handle described is the handle of the default font ie the font which is used to replace unknown fonts (fonts not resident on the host machine).
BOOL	IsFontDefault (CachedFontItem *pItem)
BOOL	IsFontReplaced (WORD Handle)
	Check to see if the font described has been replaced.
BOOL	IsFontReplaced (String_64 *pFontName, FontClass Class=FC_UNDEFINED)
BOOL	IsFontUsedInDoc (WORD Handle, Document *pDocument)
	Find out whether a given font is used in a document.
void	OnDocumentLoaded (Document *pDocument)
	Called after a document has been loaded - allows us to fix the current and default fonts if they are not installed. They are only changed if they are not used in the document.
void	GetCompatibleFont (const String_64 &EncodedName, String_64 &CompatibleFont, INT32 &Style)
	Find a compatible font to that specified in the encoded font name. An encoded name looks something like....
void	EncodeFontName (String_64 &FontName, String_64 &Encoded, INT32 Styles)
	Output a font name with bold and italic flags attached. All spaces are converted to dashes. The font is first checked for the existance of style words bold and italic before new styles are added.
void	EncodeAndMapFontName (String_64 &FontName, String_64 &Encoded, INT32 Styles)
	This function first calls EncodeFontName, to generate an approximated PostScript font name, before calling a second function to get the PostScript font mapping.
INT32	DecodeFontName (const String_64 &IStringRef, String_64 &OStringRef)
	Given a fontname encoded for EPS files, return the actual font name suitable for font matching and its style definintions (if applicable).
void	ClearTempFont ()
	Throws away any font data stored in the temp font.
void	SetTempFont (FontClass Class, String_64 *pFontName, ENUMLOGFONT *lpelf)
BOOL	TempFontValid ()
void	RefreshCache ()
	Scans all the cached fonts and checks to see if any are invalid. If a font is invalid it is attempted to be made valid. This function is generally called when the external worlds fonts have changed via install/deinstall.
void	ValidateItem (FontClass Class, String_64 *pFontName, ENUMLOGFONT *lpelf)
	Used as a way of revalidating a cached font. This function is called from the various oil level font managers when we've asked them to refresh our cache. They simply need to scan their font lists and call this function with the new data.
void	DumpFontCache ()
	Dubugging facitity - dumps out the contents of our cache.
void	DumpFont (WORD Handle)
	Dubugging facitity - dumps out the contents of a font from our cache.
WORD	FindTypeface (String_64 &TypeFaceName, FontClass Class)
	Used by the new file format, to check if a particular typeface (and font class) is installed and available. See Also: class FontComponent.
WORD	FindClosestFont (const CCPanose &PanoseNumber)
	Performs panose matching on the installed fonts.
BOOL	FindClosestFontFullTry (FontClass Class, String_64 *pTypeFaceName, ENUMLOGFONT *pEnumLogFont)
void	InvalidateCharMetrics ()
	Invalidate char metrics cache.
BOOL	GetCharMetrics (CNativeDC *pDC, WCHAR ch, CharDescription &FontDesc, CharMetrics *pCharMetrics)
	Get the char metrics for the given char and font Just dispenses the call to the FontMetricsCache.
MILLIPOINT	GetCharsKerning (CNativeDC *pDC, WCHAR chLeft, WCHAR chRight, CharDescription &FontDesc)
	Finds the kerning distance between two chars.
BOOL	GetCharPath (CharDescription &ChDesc, DocCoord **ppCoords, PathVerb **ppVerbs, UINT32 *pNumCoords, CNativeDC *pDC=NULL)
	Get the path associated with a given char.
Private Member Functions
WORD	FindClosestFontFull (const CCPanose &PanoseNumber)
WORD	FindClosestFontQuick (const CCPanose &PanoseNumber)
BOOL	FindClosestFontQuickTry (WORD FontHandle)
CachedFontItem *	FindFont (WORD Handle)
	Find the entry in the font managers font cache which corresponds to this handle.
CachedFontItem *	FindFont (String_64 *pFontName, FontClass Class=FC_UNDEFINED)
	Find the entry in the font managers font list which corresponds to this fontname and font class Note: One might be tempted to include the default font item in the comparison and return the default font handle when the default font name is passed, but this does not happen and this is by design. See OnDocumentLoaded for further information.
WORD	GetNextHandle ()
	Return a unique handle for the font cache handler Handles range from 1..n, 0 is explicitly reserved for the default handle, 0x7FFF is defined as an illegal handle.
CachedFontItem *	GetFirstFontType (FontClass fclass)
	Find the entry in the font managers font list which corresponds to the first 'FontClass' font cached.
BOOL	IsFullyCached (WORD Handle)
	Find out if the font is fully cached and ready to use. This will generally be true of all fonts added by CacheNamedFont. If the font is not fully cached then call CacheFontData(). It will not be if AddFont has been used to add the font to the font list.
BOOL	TempCacheNamedFont (String_64 *pFontName, FontClass=FC_UNDEFINED, INT32 Pass=1)
	Search through all the installed sets of fonts for the named font and place the result in a temp font.
BOOL	CacheDefaultFont ()
	Cache the default font so we can use this as a replacement when unable to find strange fonts.
CachedFontItem *	AddTempFont (String_64 *pFontName, FontClass Class, WORD &hndle)
	Given the temp font data, this function goes and caches that data under the provided name and returns the font handle.
void	InvalidateCache ()
	Scans all the cached fonts deletes all cached data. If the entries are not recached all visible fonts will be replaced by the default font.
void	ResetDefaultFont ()
	Cache the default font so we can use this as a replacement when unable to find strange fonts. The cache is checked first to see if the default font is already there.
BOOL	IsFontUsedInSiblings (Node *pNode, WORD Handle, WORD CurrentHandle, UINT32 Level)
	Find out whether a given font is used in a document.
Private Attributes
WORD	FindClosestFontHandle
CCPanose	FindClosestPanoseNumber
UINT32	FindClosestDistance
String_64	FindClosestTypeFaceName
FontClass	FindClosestFontClass
ENUMLOGFONT	FindClosestEnumLogFont
WORD	UniqueHandle
WORD	DefaultHandle
List	TheFontList
CachedFontItem	DefaultFontItem
FontClass	TempFontClass
String_64	TempFontName
ENUMLOGFONT	TempEnumLogFont

---

Detailed Description

The font manager controlling class.

Author:

Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>

Date:

13/9/95

See also:

This font manager class acts as both a cache of used fonts in the various documents loaded into Camelot and an interface to the various font managers available to us.

Definition at line 187 of file fontman.h.

---

Constructor & Destructor Documentation

FontManager::FontManager (   )

Constructor for the font manager class. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/09/95 Definition at line 461 of file fontman.cpp. { UniqueHandle = FIRSTFONTHANDLE; DefaultHandle = DEFAULTHANDLE; TempFontClass = FC_UNDEFINED; }

FontManager::~FontManager (   )

Definition at line 468 of file fontman.cpp. { TheFontList.DeleteAll(); }

---

Member Function Documentation

CachedFontItem * FontManager::AddFont (  String_64 *  Name, FontClass  fclass, WORD &  retHandle )

Creates a new font item for this named font. The font will not be fully cached. To cache all the data for the font, call CacheFontData(Handle). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: Name  = a pointer to the font name [INPUTS] fclass = a reference to the class of font to add Handle  = ILLEGALFHANDLE if the font could not be added [OUTPUTS] Handle = The font handle if ok Returns: NULL if the font could not be added A pointer to the font record Definition at line 596 of file fontman.cpp. { TRACEUSER("wuerthne", _T("FontManager::AddFont %s"), (TCHAR*)*Name); CachedFontItem* pItem = new CachedFontItem; if (pItem==NULL) return NULL; FontBase* pClass = OILFontMan::CreateNewFont(fclass,Name); if (pClass==NULL) { delete pItem; pItem=NULL; return NULL; } pItem->pFontClass = pClass; pItem->Handle = GetNextHandle(); TheFontList.AddTail(pItem); retHandle = pItem->Handle; TRACEUSER("wuerthne", _T("AddFont, returning %d"), retHandle); return pItem; }

CachedFontItem * FontManager::AddTempFont (  String_64 *  pFontName, FontClass  Class, WORD &  hndle )  [private]

Given the temp font data, this function goes and caches that data under the provided name and returns the font handle. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: pFontName  = a pointer to the font name [INPUTS] Class = describes the type of class (see typedef for details) FC_UNDEFINED then ignore the class match and match the first item with the same name whatever font class it is Handle  = ILLEGALFHANDLE if the font could not be added [OUTPUTS] Handle = The font handle if ok Returns: NULL if the font could not be added A pointer to the font record Definition at line 1925 of file fontman.cpp. { CachedFontItem* pItem = NULL; if (TempFontClass==FC_UNDEFINED) { if (Class!=FC_UNDEFINED) pItem = AddFont(pFontName, Class, hndle); else { // ERROR3("Trying to add a font of an unknown class"); pItem = AddFont(pFontName, FC_TRUETYPE, hndle); } } else { pItem = AddFont(pFontName, TempFontClass, hndle); if (pItem) pItem->SetCacheData(&TempEnumLogFont); } return pItem; }

BOOL FontManager::CacheDefaultFont (   )  [private]

Cache the default font so we can use this as a replacement when unable to find strange fonts. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the default font has been cached FALSE if not Definition at line 1591 of file fontman.cpp. { PORTNOTE("text","FontManager::CacheDefaultFont - do nothing"); #ifndef DISABLE_TEXT_RENDERING if (DefaultFontItem.pFontClass!=NULL) { ERROR3("CacheDefaultFont called but a default font is already resident"); return TRUE; } // now scan all installed lists an set out local temp font data String_64 DefFont(DEFAULTFONTNAME); if (!TempCacheNamedFont(&DefFont)) if (!TempCacheNamedFont(NULL)) return FALSE; FontBase* pClass = OILFontMan::CreateNewFont(TempFontClass,&TempFontName); if (pClass==NULL) return FALSE; DefaultFontItem.pFontClass = pClass; DefaultFontItem.Handle = DEFAULTHANDLE; if (!DefaultFontItem.SetCacheData(&TempEnumLogFont)) { DefaultFontItem.Delete(); return FALSE; } return TRUE; #else return TRUE; #endif }

WORD FontManager::CacheNamedFont (  String_64 *  pFontName, FontClass  Class = FC_UNDEFINED )

Given a font name try to cache all the data for that font so that we can actually us it. The cache will be checked first to make sure the font is not already installed. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: pFontName  = a pointer to a font name [INPUTS] Class : the class of font to cache FC_UNDEFINED - then try to cache any font by asking each font manager in turn. -  [OUTPUTS] Returns: ILLEGALFHANDLE - if unable to cache the named font A unique font handle if cached Definition at line 1668 of file fontman.cpp. { ERROR2IF(pFontName==NULL, ILLEGALFHANDLE, "Bad fontname passed to CacheNamedFont"); // try to find the font in the cache first CachedFontItem *pItem = FindFont(pFontName, Class); if (pItem!=NULL) return pItem->Handle; // now scan all installed lists and set our local temp font data if (!TempCacheNamedFont(pFontName, Class, 1)) { // ok we couldn't find the exact font. It may be possible // to create the font we are after. ATM for instance allows // named font instances to be created from their base multiple // master outlines. TempCacheNamedFont(pFontName, Class, 2); } // add the font that has been returned to us, even if none has. // if no font has been installed then we will end up having a font cache // object which describes a font as invalid. This is fine as we now know // we've done a search for it and it does not exist so we'll use the default WORD hndle=ILLEGALFHANDLE; AddTempFont(pFontName, Class, hndle); TRACEUSER("wuerthne", _T("FontManager::CacheNamedFont = %d"), hndle); return (hndle); }

void FontManager::ClearTempFont (   )

Throws away any font data stored in the temp font. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Definition at line 1879 of file fontman.cpp. { TempFontClass=FC_UNDEFINED; TempFontName.Empty(); }

INT32 FontManager::DecodeFontName (  const String_64 &  IStringRef, String_64 &  OStringRef )

Given a fontname encoded for EPS files, return the actual font name suitable for font matching and its style definintions (if applicable). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 18/4/95 Parameters: IStringRef  the string to decode. [INPUTS] OStringRef  contains the decoded fontname suitable for font matching [OUTPUTS] Returns: Flags b0 = 1 then Bold style is enabled b1 = 1 then Italic style is enabled Definition at line 2253 of file fontman.cpp. { String_32 Match; String_64 Temp; INT32 pos,Flags; OStringRef.Empty(); Flags=0; Temp=IStringRef; Match = _R(IDS_FONTMAN_MINUS_BOLDITALIC); // "-BoldItalic"; pos = Temp.Sub(Match,0,0); if (pos>-1) { Flags |= 3; Temp.Left(&OStringRef,pos); Temp=OStringRef; } Match = _R(IDS_FONTMAN_MINUS_BOLD); // "-Bold"; pos = Temp.Sub(Match,0,0); if (pos>-1) { Flags |= 1; Temp.Left(&OStringRef,pos); Temp=OStringRef; } Match = _R(IDS_FONTMAN_MINUS_ITALIC); // "-Italic"; pos = Temp.Sub(Match,0,0); if (pos>-1) { Flags |= 2; Temp.Left(&OStringRef,pos); Temp=OStringRef; } // Remove the front _ char Match = _T("_"); if (Temp.Sub(Match,0,0)==0) Temp.Remove(0,1); Temp.SwapChar('-',' '); OStringRef = Temp; return Flags; }

INT32 FontManager::DoesFontExist (  String_64 *  pFontName, BOOL  SearchCache, BOOL  SearchInstalled )

First check in the cache if necessary, then through the installed set of fonts to find whether the named font actually exists. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/05/95 Parameters: FontName  : Name of font to find [INPUTS] SearchCache : TRUE then search our internal cached fonts SearchInstalled: TRUE then search through the installed set of fonts too -  [OUTPUTS] Returns: 0 if the font cannot be found in the specified search areas 1 if the font has been installed 2 if the font has been cached Definition at line 834 of file fontman.cpp. { if (SearchCache) if (FindFont(pFontName) != NULL) return 2; if (SearchInstalled) if (IsFontInstalled(pFontName)) return 1; return 0; }

void FontManager::DumpFont (  WORD  Handle  )

Dubugging facitity - dumps out the contents of a font from our cache. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Definition at line 1862 of file fontman.cpp. { CachedFontItem *pItem = FindFont(Handle); if (pItem) pItem->Dump(); }

void FontManager::DumpFontCache (   )

Dubugging facitity - dumps out the contents of our cache. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Definition at line 1842 of file fontman.cpp. { CachedFontItem *pItem = GetFirstFont(); while (pItem) { pItem->Dump(); pItem = GetNextFont(pItem); } }

void FontManager::EncodeAndMapFontName (  String_64 &  FontName, String_64 &  Encoded, INT32  Styles )

This function first calls EncodeFontName, to generate an approximated PostScript font name, before calling a second function to get the PostScript font mapping. Author: Graeme_Sutherland (Xara Group Ltd) <camelotdev@xara.com> Date: 31/3/00 Parameters: FontName  - The TrueType font name. [INPUTS] Encoded - A string into which the PostScript font name will be written. Styles - Whether the font is bold, italic, or a combination. Encoded  - Populated with the encoded font name. [OUTPUTS] Returns: - Definition at line 2099 of file fontman.cpp. { String_64 Mapped; // First encode the font name. EncodeFontName ( FontName, Encoded, Styles ); // And then make the mapping. if ( Camelot.GetPrefDirect ( _T("EPSFontMapping"), ( TCHAR * ) Encoded, &Mapped ) ) { // There is a PostScript equivalent stored for this font, so use the mapped // version as the encoded name. Encoded = Mapped; } }

void FontManager::EncodeFontName (  String_64 &  FontName, String_64 &  Encoded, INT32  Styles )

Output a font name with bold and italic flags attached. All spaces are converted to dashes. The font is first checked for the existance of style words bold and italic before new styles are added. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 18/4/95 Parameters: FontName  A reference to a font name to encode [INPUTS] Encoded 'none constant' string reference to a output string buffer Styles = 1 then try to append 'Bold' = 2 then try to append 'Italic' = 3 then try to append 'BoldItalic' Encoded  contains the string built by this function suitable for output [OUTPUTS] to an Illustrator 3.0, 5.0 format file. Returns: - Notes: FontNames --------- Encodings: FaceName (Bold) (BoldItalic) GaramondE GaramondE-Bold GaramondE-BoldItalic EuropeExtraBold EuropeExtraBold-Bold EuropeExtraBold-BoldItalic European Bold Oblique European-Bold-Oblique European-Bold-Oblique deGaulleBlack Italic deGualleBlack-BoldItalic deGualleBlack-BoldItalic Definition at line 1995 of file fontman.cpp. { String_64 Copy(FontName); String_32 Match; // Replace all spaces with a hyphen. Copy.SwapChar(_T(' '),_T('-')); INT32 Length = Copy.Length(); // Find the last hyphen in the font's name. INT32 LastHyphen = Copy.ReverseFind ( '-' ); // If there is a -XX extension to the name, remove the hyphen. if ( LastHyphen == Length - 3 ) { Copy.Remove ( LastHyphen, 1 ); } // Check for bold/italic. Match = _R(IDS_FONTMAN_MINUS_BOLD); //"-Bold"; INT32 Bld = (Copy.Sub(Match,0,0)); Match = _R(IDS_FONTMAN_MINUS_ITALIC); //"-Italic"; INT32 Ital = (Copy.Sub(Match,0,0)); switch (Styles) { case 1: { if (Bld<0 && Ital<0) { Copy += String_16(_R(IDS_FONTMAN_MINUS_BOLD)); // "-Bold"; break; } if( ( Bld < 0 ) && ( Ital > -1 ) && ( Length - 7 == Ital ) ) { Copy.Insert( String_32(_R(IDS_FONTMAN_BOLD)), Ital ); } break; } case 2: { if (Bld<0 && Ital<0) { Copy += String_16(_R(IDS_FONTMAN_MINUS_ITALIC)); // "-Italic"; break; } if ((Ital<0) && (Bld>-1) && (Length-5==Bld)) Copy += String_16(_R(IDS_FONTMAN_ITALIC)); //"Italic"; break; } case 3: { if (Bld<0 && Ital<0) { Copy += String_16(_R(IDS_FONTMAN_MINUS_BOLDITALIC)); // "-BoldItalic"; break; } // If the font contains the word bold at the end, append italic if( ( Ital < 0 ) && ( Bld > -1 ) && ( Length - 5 == Bld ) ) { Copy += String_16(_R(IDS_FONTMAN_ITALIC)); //"Italic"; break; } // If the font already has italic, insert Bold if( ( Bld < 0 ) && ( Ital > -1 ) && ( Length - 7 == Ital ) ) { Copy.Insert( String_32(_R(IDS_FONTMAN_BOLD)), Ital ); } break; } } // Set the encoded output string Encoded=Copy; }

WORD FontManager::FindClosestFont (  const CCPanose &  PanoseNumber  )

Performs panose matching on the installed fonts. Author: Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com> Date: 20/08/96 Parameters: PanoseNumber  - panose number to search against [INPUTS] Returns: Font handle of the closest font Definition at line 1309 of file fontman.cpp. { // check, is this a 'simple' panose number with just Weight and Letterform components? if (PanoseNumber.GetFamilyType()==PAN_ANY && PanoseNumber.GetSerifStyle()==PAN_ANY && PanoseNumber.GetProportion()==PAN_ANY && PanoseNumber.GetContrast()==PAN_ANY && PanoseNumber.GetStrokeVariation()==PAN_ANY && PanoseNumber.GetArmStyle()==PAN_ANY && PanoseNumber.GetMidline()==PAN_ANY && PanoseNumber.GetXHeight()==PAN_ANY) { // These 'simple' panose numbers get saved out for old files and ATM fonts. Obviously // we can't do any sensible font matching, so just return the default font handle. return DEFAULTHANDLE; } else { // shove the data we need into class members. FindClosestFontHandle = ILLEGALFHANDLE; FindClosestPanoseNumber = PanoseNumber; FindClosestDistance = 0xffffffff; FindClosestTypeFaceName = _T(""); FindClosestFontClass = FC_UNDEFINED; // normalise the panose number. FindClosestPanoseNumber.BodgeToNormal(); // choose whichever panose font matching algorithm you require: PORTNOTE("text","TrueType/Win specific code removed") #ifndef EXCLUDE_FROM_XARALX // quick - just checks the seven fonts from the Microsoft(tm) Web Font Pack(tm) return FindClosestFontQuick(PanoseNumber); #endif // full - checks all the fonts installed on the machine. return FindClosestFontFull(PanoseNumber); } }

WORD FontManager::FindClosestFontFull (  const CCPanose &  PanoseNumber  )  [private]

Definition at line 1418 of file fontman.cpp. { WORD MyFontHandle; CachedFontItem *pCachedFontItem; // this is particularly rubbish code, since we ask the OS for information about each font // (the OUTLINETEXTMETRIC structure) and then throw it away if its not needed, rather than // caching it for the next time. Of course, if this font manager actually held information // about all the fonts on the system, rather than those in use, it would all be much easier. // call the OILFontMan to find the closest font. OILFontMan::FindClosestFont(); // We've got the typeface name and font class of the best match, so get the font handle pCachedFontItem = FindFont(&FindClosestTypeFaceName, FindClosestFontClass); if (pCachedFontItem!=NULL) { // the font is already cached, so grab the font handle from the CachedFontItem MyFontHandle=pCachedFontItem->Handle; } else { // the font hasn't been cached yet, so cache it now. pCachedFontItem = AddFont(&FindClosestTypeFaceName, FindClosestFontClass, MyFontHandle); pCachedFontItem->SetCacheData(&FindClosestEnumLogFont); } // return with this font handle return MyFontHandle; }

BOOL FontManager::FindClosestFontFullTry (  FontClass  Class, String_64 *  pTypeFaceName, ENUMLOGFONT *  pEnumLogFont )

Definition at line 1450 of file fontman.cpp. { ERROR2IF(pEnumLogFont==NULL, FALSE, "FindClosestTry called with pEnumLogFont==NULL."); OUTLINETEXTMETRIC *pOutlineTextMetric; CCPanose MyPanoseNumber; UINT32 MyDistance; pOutlineTextMetric = OILFontMan::GetOutlineTextMetric(Class, &(pEnumLogFont->elfLogFont)); if (pOutlineTextMetric!=NULL) { MyPanoseNumber = (pOutlineTextMetric->otmPanoseNumber); MyPanoseNumber.BodgeToNormal(); MyDistance = CCPanose::Distance(FindClosestPanoseNumber, MyPanoseNumber); if (MyDistance<FindClosestDistance) { FindClosestDistance = MyDistance; FindClosestFontClass = Class; FindClosestTypeFaceName = *(pTypeFaceName); FindClosestEnumLogFont = *(pEnumLogFont); } free(pOutlineTextMetric); } return TRUE; }

WORD FontManager::FindClosestFontQuick (  const CCPanose &  PanoseNumber  )  [private]

Definition at line 1351 of file fontman.cpp. { WORD MyFontHandle; String_64 MyFontName; // try "Arial" MyFontName = _T("Arial"); MyFontHandle = CacheNamedFont(&MyFontName, FC_TRUETYPE); FindClosestFontQuickTry(MyFontHandle); // try "Arial Black" MyFontName = _T("Arial Black"); MyFontHandle = CacheNamedFont(&MyFontName, FC_TRUETYPE); FindClosestFontQuickTry(MyFontHandle); // try "Comic Sans" MyFontName = _T("Comic Sans"); MyFontHandle = CacheNamedFont(&MyFontName, FC_TRUETYPE); FindClosestFontQuickTry(MyFontHandle); // try "Courier New" MyFontName = _T("Courier New"); MyFontHandle = CacheNamedFont(&MyFontName, FC_TRUETYPE); FindClosestFontQuickTry(MyFontHandle); // try "Impact" MyFontName = _T("Impact"); MyFontHandle = CacheNamedFont(&MyFontName, FC_TRUETYPE); FindClosestFontQuickTry(MyFontHandle); // try "Times New Roman" MyFontName = _T("Times New Roman"); MyFontHandle = CacheNamedFont(&MyFontName, FC_TRUETYPE); FindClosestFontQuickTry(MyFontHandle); // try "Verdana" MyFontName = _T("Verdana"); MyFontHandle = CacheNamedFont(&MyFontName, FC_TRUETYPE); FindClosestFontQuickTry(MyFontHandle); return FindClosestFontHandle; }

BOOL FontManager::FindClosestFontQuickTry (  WORD  FontHandle  )  [private]

Definition at line 1395 of file fontman.cpp. { OUTLINETEXTMETRIC *pOutlineTextMetric = GetOutlineTextMetric(MyFontHandle); if (pOutlineTextMetric!=NULL) { CCPanose MyPanoseNumber = pOutlineTextMetric->otmPanoseNumber; MyPanoseNumber.BodgeToNormal(); UINT32 MyDistance = CCPanose::Distance(FindClosestPanoseNumber, MyPanoseNumber); if (MyDistance<FindClosestDistance) { FindClosestFontHandle = MyFontHandle; FindClosestDistance = MyDistance; } } return TRUE; }

CachedFontItem * FontManager::FindFont (  String_64 *  pFontName, FontClass  Class = FC_UNDEFINED )  [private]

Find the entry in the font managers font list which corresponds to this fontname and font class Note: One might be tempted to include the default font item in the comparison and return the default font handle when the default font name is passed, but this does not happen and this is by design. See OnDocumentLoaded for further information. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: pFontName  = a pointer to a font name [INPUTS] Class = describes the type of class (see typedef for details) FC_UNDEFINED then ignore the class match and match the first item with the same name whatever font class it is -  [OUTPUTS] Returns: A pointer to the font managers cached font record for this font NULL if unable to find the font Definition at line 670 of file fontman.cpp. { CachedFontItem* pItem = GetFirstFont(); if (Class==FC_UNDEFINED) { while (pItem!=NULL) { if (pItem->Compare(pFontName)) return pItem; pItem = GetNextFont(pItem); } } else { while (pItem!=NULL) { if (pItem->Compare(pFontName)) { if (pItem->GetFontClass() == Class) return pItem; } pItem = GetNextFont(pItem); } } return NULL; }

CachedFontItem * FontManager::FindFont (  WORD  Handle  )  [private]

Find the entry in the font managers font cache which corresponds to this handle. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: Handle  = The font manager font handle [INPUTS] -  [OUTPUTS] Returns: A pointer to the font managers cached font record for this handle Definition at line 635 of file fontman.cpp. { // Check the cache first CachedFontItem* pItem = GetFirstFont(); while (pItem!=NULL) { if (pItem->Handle == Handle) return pItem; pItem = GetNextFont(pItem); } return NULL; }

WORD FontManager::FindTypeface (  String_64 &  TypeFaceName, FontClass  Class )

Used by the new file format, to check if a particular typeface (and font class) is installed and available. See Also: class FontComponent. Author: Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com> Date: 19/08/96 Parameters: TypeFaceName  - Typeface name of font to search for [INPUTS] Class - font class to search for Returns: Font handle of typeface, or ILLEGALFHANDLE if not found Definition at line 1265 of file fontman.cpp. { WORD FontHandle = ILLEGALFHANDLE; CachedFontItem *pItem=FindFont(&TypeFaceName, Class); if (pItem!=NULL) { // font is in the cached font list. FontHandle=pItem->Handle; } // now scan the installed lists for this font, and set the local temp font data else if (TempCacheNamedFont(&TypeFaceName, Class, 1)) { AddTempFont(&TypeFaceName, Class, FontHandle); } // Okay, so we couldn't find the exact font. It may be possible to create the // font we are after. ATM for instance allows named font instances to be created // from the base multiple master outlines. else if (TempCacheNamedFont(&TypeFaceName, Class, 2)) { AddTempFont(&TypeFaceName, Class, FontHandle); } else // completly unsuccessful. :( { FontHandle=ILLEGALFHANDLE; } return FontHandle; }

CachedFontItem * FontManager::GetCachedFont (  WORD  Handle  )

This function returns the font associated with the handle passed. If the font is not in the cache it will return NULL. It differs from GetFont in that it will not attempt to return the DefaultFontItem if it cannot find the item specified. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: Handle  = The font manager font handle [INPUTS] -  [OUTPUTS] Returns: A pointer to a cached font record or NULL Definition at line 714 of file fontman.cpp. { if (Handle==DefaultHandle) return (&DefaultFontItem); return FindFont(Handle); }

BOOL FontManager::GetCharMetrics (  CNativeDC *  pDC, WCHAR  ch, CharDescription &  FontDesc, CharMetrics *  pCharMetrics )

Get the char metrics for the given char and font Just dispenses the call to the FontMetricsCache. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 15/1/96 Parameters: pDC  - pointer to DC (rather than creating one each time) [INPUTS] ch - the char whose metrics are required FontDesc - the font pCharMetrics  - the metrics [OUTPUTS] Returns: FALSE if fails Definition at line 1508 of file fontman.cpp. { return OILFontMan::GetCharMetrics(pDC, ch, FontDesc, pCharMetrics); }

BOOL FontManager::GetCharPath (  CharDescription &  ChDesc, DocCoord **  ppCoords, PathVerb **  ppVerbs, UINT32 *  pNumCoords, CNativeDC *  pDC = NULL )

Get the path associated with a given char. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 28/9/95 Parameters: ChDesc  = description of char [INPUTS] pDC = (possible) pointer to a DC (for optimisation) defaults to NULL ppCoords  = pointer to path coords buffer [OUTPUTS] ppVerbs = pointer to path verbs buffer pNumCoords = number of elements in path Returns: FALSE if unable to return the outline Definition at line 1552 of file fontman.cpp. { ERROR2IF(ppCoords==NULL,FALSE,"FontManager::GetCharPath pCoords==NULL"); ERROR2IF(ppVerbs==NULL,FALSE,"FontManager::GetCharPath ppVerbs==NULL"); ERROR2IF(pNumCoords==NULL,FALSE,"FontManager::GetCharPath pNumCoords==NULL"); CachedFontItem* pItem = GetFont(ChDesc.GetTypefaceHandle()); if (pItem==NULL) return FALSE; if (pItem->IsCorrupt()) return FALSE; BOOL Success = OILFontMan::GetCharPath(pItem->GetFontClass(), ChDesc, ppCoords, ppVerbs, pNumCoords, pDC); if (!Success) pItem->SetIsCorrupt(TRUE); return Success; }

MILLIPOINT FontManager::GetCharsKerning (  CNativeDC *  pDC, WCHAR  chLeft, WCHAR  chRight, CharDescription &  FontDesc )

Finds the kerning distance between two chars. Author: Jonathan_Payne (Xara Group Ltd) <camelotdev@xara.com> Date: 15/10/2000 Parameters: pDC  - pointer to DC (rather than creating one each time) [INPUTS] chLeft - the left char of a kerning pair chRight - the right char of a kerning pair FontDesc - the font Returns: Kern distance between chars or 0 on error or no kern Definition at line 1526 of file fontman.cpp. { // TRACEUSER("wuerthne", _T("FontManager::GetCharsKerning called\n") ); return OILFontMan::GetCharsKerning(pDC, chLeft, chRight, FontDesc); }

void FontManager::GetCompatibleFont (  const String_64 &  EncodedName, String_64 &  CompatibleFont, INT32 &  Style )

Find a compatible font to that specified in the encoded font name. An encoded name looks something like.... void FontManager::GetCompatibleFont(const String_64& EncodedName, String_64& CompatibleFont, INT32& Style) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 18/4/95 Parameters: EncodedName  the encoded font name to find a compatible font for. [INPUTS] encoded names are those read direct from the native file. CompatibleFont  contains the decoded fontname suitable for font matching [OUTPUTS] Style b0 = 1 then Bold style should be enabled b1 = 1 then Italic style should be enabled Returns: Times-New-Roman Times-New-Roman-Bold Times-New-Roman-Italic Times-New-Roman-BoldItalic ChiversCond-Bold-Oblique The algorithm used is based on diminishing returns, ie try to find the exact font first, then break the fontname up in various increasingly complex ways until a valid substitution is found. This substitution can then be used for font caching. Note if the fontmanager fails to find any match it will return the encodedname as a last resort. When this is cached, its metrics will be NULL and hence be replaced by the default font automatically be the font manager. extras: This function tries to use the font name as specified. If it does not exist the function will attempt to use the fontname without styles and create styles to fit but only if this new fontname exists. ie it will do the following FontName Styles NameExists StylesOutput (1) Times New Roman BoldItalic Yes BoldOff / ItalicOff (2) Times New Roman Bold/Italic Yes BoldOn / ItalicOn (3) Times New Roman BoldItalic No BoldOn / ItalicOn Returns: Errors: Definition at line 2163 of file fontman.cpp. { // first make a copy of the encoded name String_64 TryFont(EncodedName); // now set the return style Style=0; // Usually the fontnames in the file are saved as /_FontName.Attr-BoldItalic format if( TryFont.Sub( String_32( _T("_") ),0 ,0 ) == 0 ) TryFont.Remove(0,1); // remove our inserted - symbols which are encoded as separators on saving TryFont.SwapChar('-',' '); // Try to find the specified font name, search internal and external caches INT32 found = DoesFontExist(&TryFont,TRUE,TRUE); if (found>0) { CompatibleFont=TryFont; return; } // Ok, if we can't find the whole thing, try decoding String_64 DecodedName; Style = DecodeFontName(EncodedName, DecodedName); // find out what styles this font has BOOL Bold,Italic; Bold=((Style & 1) != 0); Italic=((Style & 2) != 0); // if both bold and italic found if (Bold && Italic) { String_64 HoldName(TryFont); // try to find bold first INT32 pos = HoldName.Sub( String_32( _T("Italic") ), 0, 0 ); HoldName.Remove(pos,6); found = DoesFontExist(&HoldName,TRUE,TRUE); if (found>0) { CompatibleFont=HoldName; return; } // Then try Italic HoldName=TryFont; pos = HoldName.Sub( String_32( _T("Bold") ), 0, 0 ); HoldName.Remove(pos,4); found = DoesFontExist(&HoldName,TRUE,TRUE); if (found>0) { CompatibleFont=HoldName; return; } } // Does the decoded name exist?, so we can make the rest up in styles? found = DoesFontExist(&DecodedName,TRUE,TRUE); if (found>0) { CompatibleFont=DecodedName; return; } // otherwise, we have a font with an extension, eg Trinity.Bold // (1) Trinity.Bold - does not exist // (2) Trinity - does not exist // now we set the font to (1), which will be replaced by Times-Roman. // Now we should also set the font styles too to give us TimesRoman bold CompatibleFont=TryFont; }

ENUMLOGFONT * FontManager::GetEnumLogFont (  WORD  Handle  )

Return the ENUMLOGFONT structure for this font handle. Note the function will automatically substitute the default font if the handle provided is invalid or the font it describes is not fully cached. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: Handle  = The font manager font handle [INPUTS] -  [OUTPUTS] Returns: A pointer to the ENUMLOGFONT structure for this font NULL if none Definition at line 1144 of file fontman.cpp. { // ok, we need to get the font data for this particular font item CachedFontItem *pItem = GetFont(Handle); if (pItem!=NULL) { return (pItem->GetEnumLogFont()); } else { return NULL; } }

CachedFontItem * FontManager::GetFirstFont (   )

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Returns: A pointer to the first cached font item (NULL if none) Definition at line 555 of file fontman.cpp. { return (CachedFontItem*)TheFontList.GetHead(); }

CachedFontItem * FontManager::GetFirstFontType (  FontClass  Class  )  [private]

Find the entry in the font managers font list which corresponds to the first 'FontClass' font cached. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: Class  = the class of font to retrieve [INPUTS] -  [OUTPUTS] Returns: A pointer to a cached font record or NULL Definition at line 1116 of file fontman.cpp. { CachedFontItem* pItem = GetFirstFont(); while (pItem!=NULL) { if (pItem->GetFontClass() == Class) return pItem; pItem = GetNextFont(pItem); } return NULL; }

CachedFontItem * FontManager::GetFont (  String_64 *  pFontName, FontClass  Class = FC_UNDEFINED )

Return the font data to use for rendering. This function performs a specific job in avoiding caching the font data. If the font is already cached then fine, it is returned for use. If not, the default font is returned. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: pFontName  = a pointer to a font name [INPUTS] Class = describes the type of class (see typedef for details) FC_UNDEFINED then ignore the class match and match the first item with the same name whatever font class it is -  [OUTPUTS] Returns: A pointer to a cached font record or NULL Definition at line 806 of file fontman.cpp. { CachedFontItem* pItem = FindFont(pFontName, Class); if ((pItem!=NULL) && (pItem->IsFullyCached())) return pItem; return &DefaultFontItem; }

CachedFontItem * FontManager::GetFont (  WORD  Handle  )

Return the font data to use for rendering. This function performs a specific job in avoiding caching the font data. If the font is already cached then fine, it is returned for use. If not, the default font is returned. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: Handle  = The font manager font handle [INPUTS] -  [OUTPUTS] Returns: A pointer to a cached font record or NULL Definition at line 780 of file fontman.cpp. { CachedFontItem* pItem = FindFont(Handle); if ((pItem!=NULL) && (pItem->IsFullyCached())) return pItem; return &DefaultFontItem; }

CachedFontItem * FontManager::GetFont (   )

Return the precached default font data to use for rendering. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A pointer to a cached font record or NULL Definition at line 760 of file fontman.cpp. { return &DefaultFontItem; }

FontClass FontManager::GetFontClass (  WORD  Handle  )

Return what class of font this handle is. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: Handle  = The font manager font handle [INPUTS] -  [OUTPUTS] Returns: A font class FC_UNDEFINED if the handle is unknown Definition at line 1238 of file fontman.cpp. { CachedFontItem* pItem = GetCachedFont(Handle); if (pItem==NULL) { ERROR3("FontManager::GetFontClass() - given an illegal handle"); return FC_UNDEFINED; } return pItem->GetFontClass(); }

WORD FontManager::GetFontHandle (  String_64 *  pFontName, FontClass  Class = FC_UNDEFINED )

Get the handle on a cached font (if cached) otherwise return the default font handle. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: pFontName  = a pointer to a font name [INPUTS] Class = describes the class of font to get the handle of -  [OUTPUTS] Returns: The handle of the font if the font exists The default handle if the font does not exist and Replace is true ILLEGALFHANDLE if not Definition at line 737 of file fontman.cpp. { ERROR2IF(pFontName==NULL, 0, "FontManager::GetFontHandle() called with an illegal font name pointer"); CachedFontItem* pItem=FindFont(pFontName,Class); if (pItem!=NULL) return pItem->GetFontHandle(); return DefaultHandle; }

BOOL FontManager::GetFontName (  WORD  Handle, String_64 &  OutputString )

Definition at line 1212 of file fontman.cpp. { CachedFontItem* pItem = GetCachedFont(Handle); if (pItem==NULL) { ERROR3("FontManager::GetFontName() - given an illegal handle"); return FALSE; } OutputString = *(pItem->GetFontName()); return TRUE; }

String_64 * FontManager::GetFontName (  WORD  Handle  )

Return a pointer to the font name given its font handle. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: Handle  = The font manager font handle [INPUTS] -  [OUTPUTS] Returns: A pointer to the font name associated with this handle NULL if the handle is illegal Definition at line 1200 of file fontman.cpp. { CachedFontItem* pItem = GetCachedFont(Handle); if (pItem==NULL) { ERROR3("FontManager::GetFontName() - given an illegal handle"); return NULL; } return pItem->GetFontName(); }

CachedFontItem * FontManager::GetNextFont (  CachedFontItem *  pItem  )

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: A  pointer to a font item to find the next from. [INPUTS] Returns: A pointer to the next cached font item from pItem (NULL if none) Definition at line 572 of file fontman.cpp. { return (CachedFontItem*)TheFontList.GetNext(pItem); }

WORD FontManager::GetNextHandle (   )  [private]

Return a unique handle for the font cache handler Handles range from 1..n, 0 is explicitly reserved for the default handle, 0x7FFF is defined as an illegal handle. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: -  [INPUTS] The  next font handle. [OUTPUTS] Returns: - Definition at line 509 of file fontman.cpp. { WORD CurrHandle=UniqueHandle; UniqueHandle++; return (CurrHandle); }

OUTLINETEXTMETRIC * FontManager::GetOutlineTextMetric (  WORD  Handle  )

Return the ENUMLOGFONT structure for this font handle Note the function will automatically substitute the default font if the handle provided is invalid or the font it describes is not fully cached. Author: Andy_Hayward (Xara Group Ltd) <camelotdev@xara.com> Date: 15/08/96 Parameters: Handle  = the font manager handle [INPUTS] Returns: Pointer to the OUTLINETEXTMETRIC structure for this font, NULL if none Definition at line 1172 of file fontman.cpp. { // ok, we need to get the font data for this particular font item CachedFontItem *pItem = GetFont(Handle); if (pItem!=NULL) { return pItem->GetOutlineTextMetric(); } else { return NULL; } }

BOOL FontManager::Init (  void   )

Get Camelots Font manager going. We simply cache the default font so unknown fonts can be sensibly replaced. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/09/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the fontmanager was able to initialise correctly FALSE if not Reimplemented from SimpleCCObject. Definition at line 531 of file fontman.cpp. { // initialise the OIL cache of enumerated fonts by simply enumerating them // and ignoring the result - since we do not want to see the names, we do // not even have to create a subclass OILEnumFonts enumerator; enumerator.Execute(); if (!CacheDefaultFont()) { ERROR3("FontManager::Init() - Unable to cache the default font"); } return TRUE; }

void FontManager::InvalidateCache (  void   )  [private]

Scans all the cached fonts deletes all cached data. If the entries are not recached all visible fonts will be replaced by the default font. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 13/9/95 Definition at line 1820 of file fontman.cpp. { CachedFontItem *pItem = GetFirstFont(); while (pItem) { pItem->DeleteMetrics(); pItem->SetIsCorrupt(FALSE); pItem->SetIsReplaced(TRUE); pItem = GetNextFont(pItem); } }

void FontManager::InvalidateCharMetrics (   )

Invalidate char metrics cache. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 15/1/96 Definition at line 1489 of file fontman.cpp. { OILFontMan::InvalidateCharMetrics(); }

BOOL FontManager::IsFontDefault (  CachedFontItem *  pItem  )

Definition at line 967 of file fontman.cpp. { return (pItem == (&DefaultFontItem)); }

BOOL FontManager::IsFontDefault (  WORD  Handle  )

Check to see if the font handle described is the handle of the default font ie the font which is used to replace unknown fonts (fonts not resident on the host machine). Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: Handle  = The font manager font handle [INPUTS] -  [OUTPUTS] Returns: TRUE if the font handle is the handle describing the default font FALSE if not. Definition at line 962 of file fontman.cpp. { return (Handle==DefaultHandle); }

BOOL FontManager::IsFontInstalled (  String_64 *  pFontName, FontClass  Class = FC_UNDEFINED )

Search through all the installed sets of fonts for the named font. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/05/95 Parameters: pFontName  : Name of font to search for [INPUTS] Class : The class of font to cache FC_UNDEFINED - then try to cache any font -  [OUTPUTS] Returns: TRUE if the font has been installed Definition at line 1736 of file fontman.cpp. { return TempCacheNamedFont(pFontName, Class); }

BOOL FontManager::IsFontReplaced (  String_64 *  pFontName, FontClass  Class = FC_UNDEFINED )

Definition at line 916 of file fontman.cpp. { BOOL Result = FALSE; // Check whether its the default font, if it is then obviously it's not been replaced. if (DefaultFontItem.Compare(pFontName)) { Result = FALSE; } else { CachedFontItem *pItem = FindFont(pFontName, Class); if (pItem==NULL) { Result = TRUE; // font doesn't exist } else if (pItem->IsReplaced()) { Result = TRUE; // IsReplaced flag is set } else if (!pItem->IsValid()) { Result = TRUE; // The font isn't valid } } return Result; }

BOOL FontManager::IsFontReplaced (  WORD  FontHandle  )

Check to see if the font described has been replaced. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: pFontName  = a pointer to a font name [INPUTS] Class = describes the type of class (see typedef for details) FC_UNDEFINED then ignore the class match and match the first item with the same name whatever font class it is -  [OUTPUTS] Returns: TRUE if the font has been replaced by the default FALSE if not. Definition at line 886 of file fontman.cpp. { BOOL Result = FALSE; // check whether its the default font, if it is then obviously it's not been replaced. if (IsFontDefault(FontHandle)) { Result = FALSE; } else { CachedFontItem *pItem = FindFont(FontHandle); if (pItem==NULL) { Result = TRUE; // font doesn't exist } else if (pItem->IsReplaced()) { Result = TRUE; // IsReplaced flag is set } else if (!pItem->IsValid()) { Result = TRUE; // The font isn't valid } } return Result; }

BOOL FontManager::IsFontUsedInDoc (  WORD  Handle, Document *  pDocument )

Find out whether a given font is used in a document. Author: Martin Wuerthner <xara@mw-software.com> Date: 01/08/06 Parameters: Handle  - a font handle [INPUTS] pDocument - pointer to a document Returns: When called with Handle == DEFAULTHANDLE it returns TRUE if the default attribute applies to a text object. Otherwise, it returns TRUE if the supplied font handle is used in the document Definition at line 1023 of file fontman.cpp. { Node* pNode = pDocument->GetFirstNode(); return IsFontUsedInSiblings(pNode, Handle, ILLEGALFHANDLE, 0); }

BOOL FontManager::IsFontUsedInSiblings (  Node *  pNode, WORD  Handle, WORD  CurrentHandle, UINT32  Level )  [private]

Find out whether a given font is used in a document. Author: Martin Wuerthner <xara@mw-software.com> Date: 01/08/06 Parameters: pNode  - the root node of the subtree to check [INPUTS] Handle - a font handle CurrentHandle - the font handle applying to the current subtree Level - level in the tree (level 0 is NodeDocument, level 1 are default attributes) Returns: Returns TRUE if a font attribute with the given handle applies to a text object. Definition at line 988 of file fontman.cpp. { // perform a standard child-first recursion keeping track of the current font while(pNode) { Node* pFirstChild = pNode->FindFirstChild(); if (pFirstChild && IsFontUsedInSiblings(pFirstChild, Handle, CurrentHandle, Level + 1)) return TRUE; if (IS_A(pNode, AttrTxtFontTypeface)) { AttrTxtFontTypeface* pAttr = (AttrTxtFontTypeface*)pNode; CurrentHandle = pAttr->Value.HTypeface; ENSURE(!(CurrentHandle == DEFAULTHANDLE && Level > 1), "FontManager::IsFontUsedInSiblings is based on the assumption that we do not have non-default attribute nodes referencing the default font"); } if (CurrentHandle == Handle && (IS_A(pNode, TextStory) || IS_A(pNode, TextLine) || IS_A(pNode, TextChar))) return TRUE; pNode = pNode->FindNext(); } return FALSE; }

BOOL FontManager::IsFontValid (  WORD  Handle  )

Check to see if the font described is actually valid, ie all the metrics for the font have been cached correctly. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: Handle  = The font manager font handle [INPUTS] -  [OUTPUTS] Returns: TRUE if the font is valid and ready to use FALSE if not. Definition at line 862 of file fontman.cpp. { CachedFontItem* pItem = GetCachedFont(Handle); return ( (pItem!=NULL) && (pItem->IsFullyCached()) ); }

BOOL FontManager::IsFullyCached (  WORD  Handle  )  [private]

Find out if the font is fully cached and ready to use. This will generally be true of all fonts added by CacheNamedFont. If the font is not fully cached then call CacheFontData(). It will not be if AddFont has been used to add the font to the font list. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: Handle  = The font manager font handle [INPUTS] -  [OUTPUTS] Returns: TRUE if the font exists and is cached FALSE if not Definition at line 1758 of file fontman.cpp. { CachedFontItem* pItem = GetCachedFont(Handle); if (pItem!=NULL) return pItem->IsFullyCached(); return FALSE; }

BOOL FontManager::LegalFontClass (  INT32  Class, FontClass &  RealClass )

Check whether a numeric value actually indicates a valid class of font ie lies in the range of supported font types. This is used generally for loading purpose where the font class is loaded as a numeric value. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/09/95 Parameters: A  INT32 describing the font class [INPUTS] The  real font class to use for this numeric value [OUTPUTS] Returns: TRUE if the font class is supported, FALSE if not Definition at line 488 of file fontman.cpp. { return OILFontMan::LegalFontClass(Class, RealClass); }

void FontManager::OnDocumentLoaded (  Document *  pDocument  )

Called after a document has been loaded - allows us to fix the current and default fonts if they are not installed. They are only changed if they are not used in the document. Author: Martin Wuerthner <xara@mw-software.com> Date: 01/08/06 Parameters: pDocument  - pointer to the newly created/loaded document [INPUTS] Fixing the current font is useful because it stops "Arial (missing)" from being displayed after start-up if Arial is not installed. The same happens when loading a document with the current font set to Arial (or any other font that is not installed). We do not touch the current font if it is actually used in the document because then, it is possible that it was set deliberately (maybe even in a template). One might consider a similar approach for the default font, but by definition, the default font is always installed (though it may or may not be Times New Roman), so there is no need to change anything. The default attributes are not saved with the document, so, in contrast to the current font, there cannot be any surprises with fonts that are not installed. The font name referenced by the default font does not matter because the default font attribute is never inherited by any text object in the document. This is down to the behaviour of FindFont(String_64*,FontClass), which never returns the default font handle, so any font attribute created by the text tool based on a font name (which involves calling FindFont at some stage) is always different from the default attribute (even if it happens to be the same font as the default font) and hence this attribute is not optimised away. Therefore, each and every text object has a non-default font attribute applied to it. Definition at line 1064 of file fontman.cpp. { // check if the current font is installed and change it in case it is not (only if the font is not used) NodeAttribute* pAttr = pDocument->GetAttributeMgr().GetCurrentAttribute(CC_RUNTIME_CLASS(BaseTextClass), CC_RUNTIME_CLASS(AttrTxtFontTypeface)); if (pAttr) { AttrTxtFontTypeface* pTypeface = (AttrTxtFontTypeface*)pAttr; WORD Handle = pTypeface->Value.HTypeface; TRACEUSER("wuerthne", _T("found current font attribute, handle = %d"), Handle); CachedFontItem *pItem = FindFont(Handle); if (pItem) { String_64* SurfaceFontName = pItem->GetFontName(); TRACEUSER("wuerthne", _T("current font name is %s"), (TCHAR*)*SurfaceFontName); ENUMLOGFONT *pEnumLogFont = pItem->GetEnumLogFont(); if (pEnumLogFont) { if (!IsFontInstalled(SurfaceFontName) && !IsFontUsedInDoc(Handle, pDocument)) { // the current font is not installed and not used in the document, // so find out what the replacement font is and use that instead TRACEUSER("wuerthne", _T("font replaced and not used")); String_64* NativeFontName = OILFontMan::GetNativeFontName(pItem->GetFontClass(), &pEnumLogFont->elfLogFont); WORD NewHandle = CacheNamedFont(NativeFontName, pItem->GetFontClass()); if (NewHandle != ILLEGALFHANDLE) { TRACEUSER("wuerthne", _T("change current font to handle %d"), NewHandle); // modify the current attribute directly pTypeface->Value.HTypeface = NewHandle; } } } } } }

void FontManager::RefreshCache (   )

Scans all the cached fonts and checks to see if any are invalid. If a font is invalid it is attempted to be made valid. This function is generally called when the external worlds fonts have changed via install/deinstall. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 13/9/95 Definition at line 1779 of file fontman.cpp. { InvalidateCache(); OILFontMan::ValidateCache(); ResetDefaultFont(); }

void FontManager::ResetDefaultFont (   )  [private]

Cache the default font so we can use this as a replacement when unable to find strange fonts. The cache is checked first to see if the default font is already there. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1642 of file fontman.cpp. { DefaultFontItem.Delete(); CacheDefaultFont(); }

void FontManager::SetTempFont (  FontClass  Class, String_64 *  pFontName, ENUMLOGFONT *  lpelf )

Definition at line 1896 of file fontman.cpp. { ERROR3IF(lpelf==NULL,"FontManager::SetTempFont() given a null ENUMLOGFONT structure"); ERROR3IF(Class==FC_UNDEFINED, "FontManager::SetTempFont() given an illegal font class"); TempFontClass=Class; TempFontName=(*pFontName); TempEnumLogFont=(*lpelf); }

BOOL FontManager::TempCacheNamedFont (  String_64 *  pFontName, FontClass  Class = FC_UNDEFINED, INT32  Pass = 1 )  [private]

Search through all the installed sets of fonts for the named font and place the result in a temp font. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 19/05/95 Parameters: pFontName  : Name of font to search for [INPUTS] Class : The class of font to cache FC_UNDEFINED - then try to cache any font Pass : 1 - first pass, try to match the font exactly : 2 - second pass, try to find a compatible font -  [OUTPUTS] Returns: TRUE if the font has been temporarily installed Definition at line 1716 of file fontman.cpp. { return (OILFontMan::CacheNamedFont(pFontName, Class, Pass)); }

BOOL FontManager::TempFontValid (   )

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 12/9/95 Returns: TRUE if the temp font has been set to a valid font FALSE if not Definition at line 1958 of file fontman.cpp. { return (TempFontClass!=FC_UNDEFINED); }

void FontManager::ValidateItem (  FontClass  Class, String_64 *  pFontName, ENUMLOGFONT *  lpelf )

Used as a way of revalidating a cached font. This function is called from the various oil level font managers when we've asked them to refresh our cache. They simply need to scan their font lists and call this function with the new data. void FontManager::ValidateItem(FontClass Class, String_64 * pFontName, ENUMLOGFONT * lpelf) Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 13/9/95 Definition at line 1799 of file fontman.cpp. { CachedFontItem *pItem = FindFont(pFontName,Class); if (pItem) { pItem->SetCacheData(lpelf); pItem->SetIsReplaced(FALSE); } }

---

Member Data Documentation

CachedFontItem FontManager::DefaultFontItem [private]

Definition at line 298 of file fontman.h.

WORD FontManager::DefaultHandle [private]

Definition at line 296 of file fontman.h.

UINT32 FontManager::FindClosestDistance [private]

Definition at line 258 of file fontman.h.

ENUMLOGFONT FontManager::FindClosestEnumLogFont [private]

Definition at line 261 of file fontman.h.

FontClass FontManager::FindClosestFontClass [private]

Definition at line 260 of file fontman.h.

WORD FontManager::FindClosestFontHandle [private]

Definition at line 256 of file fontman.h.

CCPanose FontManager::FindClosestPanoseNumber [private]

Definition at line 257 of file fontman.h.

String_64 FontManager::FindClosestTypeFaceName [private]

Definition at line 259 of file fontman.h.

ENUMLOGFONT FontManager::TempEnumLogFont [private]

Definition at line 303 of file fontman.h.

FontClass FontManager::TempFontClass [private]

Definition at line 301 of file fontman.h.

String_64 FontManager::TempFontName [private]

Definition at line 302 of file fontman.h.

List FontManager::TheFontList [private]

Definition at line 297 of file fontman.h.

WORD FontManager::UniqueHandle [private]

Definition at line 295 of file fontman.h.

---

The documentation for this class was generated from the following files:

• Kernel/fontman.h (r1785/r1642)
• Kernel/fontman.cpp (r1785/r1642)

---