diff -r b9ad20498fb4 -r 8b9155204a54 fontservices/fontstore/inc/FNTSTORE.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fontservices/fontstore/inc/FNTSTORE.h Fri Jun 04 10:37:54 2010 +0100 @@ -0,0 +1,526 @@ +/* +* Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + +#ifndef FNTSTORE_H__ +#define FNTSTORE_H__ + +#include +#include +#include +#include +#include + + +/** Defines the maximum number of linked typefaces that may be placed in a linked typeface specification +WARNING: Constant for internal use ONLY. Compatibility is not guaranteed in future releases. +@publishedAll +@released + */ +const TInt KMaxLinkedTypefaces = 12; +/** Defines the maximum number of linked typeface groups that may be placed in a linked typeface specification +WARNING: Constant for internal use ONLY. Compatibility is not guaranteed in future releases. +@publishedAll +@released + */ +const TInt KMaxLinkedTypefaceGroups = 12; + +/** Defines the maximun number of threads that may tranverse the COpenFontSessionCacheList (read-only) + @publishedAll + @released + */ +const TInt KSessionCacheSemaphoreCount = 12; + +/** Defines the name of the semaphore which is used to exclude threads that may tranverse + * the COpenFontSessionCacheList (read-only) with FBserv. + @publishedAll + @released + */ +_LIT(KSessionCacheSemaphoreName,"FBSSessionCacheSemaphore"); + +class CLinkedTypefaceSpecification; +class TLinkedTypefaceSpecificationArgs; +class CFbClient; +class CFontStoreFile; +class CFontBitmap; +class RReadStream; +class TTypefaceFontBitmap; +class TShapeHeader; +class TShapeMessageParameters; +class CTypefaceSupportInfo; +class COpenFontRasterizer; +class CLinkedTypefaceGroup; +IMPORT_C extern const TInt8 KLinkedFontDrive; +IMPORT_C extern const TUint32 KFontTable_GlyphOutline_CacheMaxMem; + +/** +WARNING: Class for internal use ONLY. Compatibility is not guaranteed in future releases. +@publishedAll +@released + */ +class TCharacterMetrics + { +public: + IMPORT_C TCharacterMetrics(); + +public: + TInt16 iAscentInPixels; + TInt16 iHeightInPixels; + TInt16 iLeftAdjustInPixels; + TInt16 iMoveInPixels; + TInt16 iRightAdjustInPixels; + }; + +/** +An algorithmic style for how a font is drawn. + +Holds attributes such as whether the font is bold or italic, and the width +and height factors. This is used as an input parameter for the GetFontById() method +of some font management classes. See CWsScreenDevice::GetFontById() for more information. +@publishedAll +@released +@see CWsScreenDevice::GetFontById() +@see CFbsTypefaceStore::GetFontById() +@see CFbsDevice::GetFontById() +*/ +class TAlgStyle + { +public: + IMPORT_C TAlgStyle(); + IMPORT_C void SetIsBold(TBool aIsBold); + IMPORT_C void SetIsItalic(TBool aIsItalic); + IMPORT_C void SetIsMono(TBool aIsMono); + IMPORT_C void SetWidthFactor(TInt aWidthFactor); + IMPORT_C void SetHeightFactor(TInt aHeightFactor); + IMPORT_C TBool IsBold() const; + IMPORT_C TBool IsItalic() const; + IMPORT_C TBool IsMono() const; + IMPORT_C TInt WidthFactor() const; + IMPORT_C TInt HeightFactor() const; + IMPORT_C TBool operator==(const TAlgStyle& aAlgStyle) const; + TBool operator!=(const TAlgStyle& aAlgStyle) const; +public: + /** Baseline offset in pixels. */ + TInt iBaselineOffsetInPixels; +private: + enum + { + EBold=1, + EItalic=2, + EMono=4, + }; + /** This member is private and not intended for use. */ + TInt8 iFlags; + /** This member is private and not intended for use. */ + TInt8 iWidthFactor; + /** This member is private and not intended for use. */ + TInt8 iHeightFactor; + }; + +/** +Bitmap font class. +An object of this class may either access and use a bitmap font (a CFontBitmap) +or an open font (a COpenFont). +Stored in a CFontStore. +@publishedAll +@released +*/ +class CBitmapFont : public CFont + { + friend class CFbsFont; + friend class CFontStore; + friend class CFbsBitGc; +public: + // New functions + TUid Uid() const; + IMPORT_C TCharacterMetrics CharacterMetrics(TInt aCode,const TUint8*& aBytes) const; + IMPORT_C TBool GetCharacterData(TInt aSessionHandle, TInt aCode, TOpenFontCharMetrics& aMetrics, const TUint8*& aBitmap) const; + IMPORT_C TBool Rasterize(TInt aSessionHandle,TInt aCode,TOpenFontGlyphData* aGlyphData) const; + IMPORT_C void GetFontMetrics(TOpenFontMetrics& aMetrics) const; + IMPORT_C TBool GetFaceAttrib(TOpenFontFaceAttrib& aAttrib) const; + IMPORT_C TInt BitmapEncoding() const; + IMPORT_C TBool HasCharacterL(TInt aCode) const; + IMPORT_C TBool CharacterNeedsToBeRasterized(TInt aSessionHandle,TInt aCode) const; + IMPORT_C TShapeHeader* ShapeTextL(const TDesC16& aText, + TInt aSessionHandle, const TShapeMessageParameters& aParams); + IMPORT_C void DeleteShape(TInt aSessionHandle,TShapeHeader* aHeader); + IMPORT_C void operator delete(TAny*); + inline TBool IsOpenFont() const; + inline COpenFont* OpenFont() const; + inline TGlyphBitmapType GlyphBitmapType() const; + IMPORT_C TUint32 UniqueFontId(); + IMPORT_C TInt GetFontTable(TUint32 aTag, TAny*& aTableContent, + TInt& aLength, TInt aSessionHandle); + IMPORT_C TInt GetGlyphOutline(TUint aCode, + TBool aHinted, TAny*& aOutline, TInt& aLength, TInt aSessionHandle); + IMPORT_C void ReleaseGlyphOutlines(TInt aCount, const TUint* aCodes, + TBool aHinted, TInt aSessionHandle); + IMPORT_C void ReleaseFontTable(TUint32 aTag, TInt aSessionHandle); + +private: + // From CFont + IMPORT_C virtual TUid DoTypeUid() const; + IMPORT_C virtual TInt DoHeightInPixels() const; + IMPORT_C virtual TInt DoAscentInPixels() const; + IMPORT_C virtual TInt DoCharWidthInPixels(TChar aChar) const; + IMPORT_C virtual TInt DoTextWidthInPixels(const TDesC &aText) const; + IMPORT_C virtual TInt DoBaselineOffsetInPixels() const; + IMPORT_C virtual TInt DoTextCount(const TDesC &aText, TInt aWidthInPixels) const; + IMPORT_C virtual TInt DoTextCount(const TDesC &aText, TInt aWidthInPixels, TInt &aExcessWidthInPixels) const; + IMPORT_C virtual TInt DoMaxCharWidthInPixels() const; + IMPORT_C virtual TInt DoMaxNormalCharWidthInPixels() const; + IMPORT_C virtual TFontSpec DoFontSpecInTwips() const; + IMPORT_C virtual TInt DoExtendedFunction(TUid aFunctionId, TAny* aParam = NULL) const; + +private: + CBitmapFont(RHeap* aHeap,const TFontSpec& aFontSpecInTwips, const TAlgStyle& aAlgStyle, CFontBitmap* aFontBitmap); + CBitmapFont(RHeap* aHeap,const TFontSpec& aFontSpecInTwips, const TAlgStyle& aAlgStyle, COpenFont* aOpenFont); + void ConstructL(); + ~CBitmapFont(); + static CBitmapFont* NewL(RHeap* aHeap, const TFontSpec& aFontSpecInTwips, const TAlgStyle& aAlgStyle, CFontBitmap* aFontBitmap); + static CBitmapFont* NewL(RHeap* aHeap, const TFontSpec& aFontSpecInTwips, const TAlgStyle& aAlgStyle, COpenFont* aOpenFont); + inline void operator delete(TAny*, TAny*) {} + TInt Width(TInt aNum) const; + TInt Height(TInt aNum) const; + CFontBitmap* FontBitmap() const; + void InstallOpenFontShaper(COpenFont* aOpenFont, CShaper::TInput& aShaperInput); + TInt DoTextWidthInPixels(const TDesC &aText, const TMeasureTextInput* aParam) const; + void SetUniqueFontId(TUint32 aUniqueFontId); + +private: + TFontSpec iFontSpecInTwips; + +public: + /** The algorithmic font style. */ + TAlgStyle iAlgStyle; // must not move this member + +private: + // Binary Compatibility warning - data member iOpenFont is referenced by inline methods + RHeap* iHeap; + TInt iFontBitmapOffset; + + // In order to be able to work with the flexible memory model, iOpenFont is + // actually an offset from the address of this class. + // iOpenFont's type remains unchanged. + // As Qt code that uses OpenFont() must be able to run on new and old versions + // of Symbian OS, it must be able to determine whether iOpenFont is a pointer or + // an offset at run-time. Therefore an offset will have its lowest significant bit set to 1. + // If iOpenFont is null, this object is not an open font. + // Assumption: a pointer always has least significant bit value of zero. + COpenFont* iOpenFont; // if iOpenFont is non-null this is an open font and many functions are forwarded to it + + TUint32 iReserved; + TUint32 iUniqueFontId; // unique id for this instance of this font + }; + +/** +WARNING: Class for internal and partner use ONLY. Compatibility is not guaranteed in future releases. +@publishedAll +@released + */ +class TLinkedTypefaceGroupArgs + { +public: + TInt iGroupId; + CLinkedTypefaceGroup::TScalingOption iScalingOption; + CLinkedTypefaceGroup::TBaselineShift iBaselineShift; + TInt iAntialiasingThreshold; + TInt iBoldnessPercentage; + TInt iItalicAngle; +public: + void operator =(const CLinkedTypefaceGroup* aRhs); + }; + +class COpenFontLinkedTypefaceElementSpec; +class COpenFontLinkedTypefaceSpecification; + +/** +WARNING: Class for internal and partner use ONLY. Compatibility is not guaranteed in future releases. +@publishedAll +@released + */ +class TLinkedTypefaceElementSpecArgs + { +public: + TBufC iName; + TBool iIsCanonical; + TInt iGroupId; + + void operator = (const CLinkedTypefaceElementSpec* aRhs); + void operator = (const COpenFontLinkedTypefaceElementSpec* aRhs); + }; + +/** +WARNING: Class for internal and partner use ONLY. Compatibility is not guaranteed in future releases. +@publishedAll +@released + */ +class TLinkedTypefaceSpecificationArgs + { +public: + TBufC iName; + TLinkedTypefaceElementSpecArgs iTypefaces[KMaxLinkedTypefaces]; + TLinkedTypefaceGroupArgs iGroups[KMaxLinkedTypefaceGroups]; + TInt iSize; + TInt iGroupSize; + TInt iCanonicalIndex; + + IMPORT_C void operator = (const CLinkedTypefaceSpecification& aRhs); + IMPORT_C void operator = (const COpenFontLinkedTypefaceSpecification& aRhs); + }; + + + +class TUnhintedOutlineId; +class THintedOutlineId; +class CFontTableCache; +class CUnhintedOutlineCache; +class CHintedOutlineCache; +class TFontTableGlyphOutlineCacheMemMonitor; + +class CFontStore : public CTypefaceStore +/** +A store for fonts. + +Stores and handles both open and fixed-size fonts. Open fonts are made from +open (scalable) typefaces by Open Font plug-in rasterizers. Fonts of other +typefaces are stored in a limited number of fixed sizes. However, which is +being used is transparent to the user of this class. For example the GetNearestFont...() +functions get a bitmap font which may be retrieved from memory or generated +via a rasterizer. +@publishedAll +@released +*/ + { +friend class CLinkedFonts; +friend class CLinkedTypefaceSpecification; + +public: + IMPORT_C static CFontStore* NewL(RHeap* aHeap); + IMPORT_C ~CFontStore(); + IMPORT_C TUid AddFileL(const TDesC& aName); + IMPORT_C void RemoveFile(TUid aFileUid); + IMPORT_C TInt GetNearestFontInTwips(CFont *&aFont, const TFontSpec& aFontSpec); + IMPORT_C TInt GetNearestFontInPixels(CFont *&aFont, const TFontSpec &aFontSpec); + IMPORT_C TInt GetNearestFontToDesignHeightInTwips(CFont *&aFont, const TFontSpec& aFontSpec); + IMPORT_C TInt GetNearestFontToDesignHeightInPixels(CFont *&aFont, const TFontSpec& aFontSpec); + IMPORT_C TInt GetNearestFontToMaxHeightInTwips(CFont*& aFont, const TFontSpec& aFontSpec, TInt aMaxHeight); + IMPORT_C TInt GetNearestFontToMaxHeightInPixels(CFont*& aFont, const TFontSpec& aFontSpec, TInt aMaxHeight); + IMPORT_C TInt GetNearestFontInTwips(CFont *&aFont, const TOpenFontSpec& aFontSpec); + IMPORT_C TInt GetNearestFontInPixels(CFont *&aFont, const TOpenFontSpec &aFontSpec); + IMPORT_C TInt GetNearestFontToDesignHeightInTwips(CFont *&aFont, const TOpenFontSpec& aFontSpec); + IMPORT_C TInt GetNearestFontToDesignHeightInPixels(CFont *&aFont, const TOpenFontSpec& aFontSpec); + IMPORT_C TInt GetNearestFontToMaxHeightInTwips(CFont*& aFont, const TOpenFontSpec& aFontSpec, TInt aMaxHeight); + IMPORT_C TInt GetNearestFontToMaxHeightInPixels(CFont*& aFont, const TOpenFontSpec& aFontSpec, TInt aMaxHeight); + IMPORT_C TInt GetFontById(CFont *&aFont,TUid aUid,const TAlgStyle& aAlgStyle); + IMPORT_C TInt NumTypefaces() const; + IMPORT_C void TypefaceSupport(TTypefaceSupport &aTypefaceSupport,TInt aTypefaceIndex) const; + IMPORT_C TInt FontHeightInTwips(TInt aTypefaceIndex,TInt aHeightIndex) const; + IMPORT_C TInt FontHeightInPixels(TInt aTypefaceIndex,TInt aHeightIndex) const; + IMPORT_C void InstallRasterizerL(COpenFontRasterizer* aRasterizer); + IMPORT_C void DeleteSessionCache(TInt aSessionHandle); + inline TGlyphBitmapType DefaultBitmapType() const; + inline void SetDefaultBitmapType(TGlyphBitmapType aType); + IMPORT_C void InstallShaperFactoryL(CShaperFactory* aShaperFactory); + const CArrayPtrFlat* ShaperFactoryList() const; + COpenFontSessionCacheList* GetSessionCacheList(); + TInt GetShaperCacheMemUsage(); + void SetShaperCacheMemUsage(TInt aUsage); + CArrayPtrFlat* GetOpenFontFileList(); + void IncNumShaperCaches(); + void DecNumShaperCaches(); + TInt GetNumShaperCaches(); + IMPORT_C TInt CreateLinkedTypeface(const TLinkedTypefaceSpecificationArgs &aLinkedTypefaceSpec, TInt aSession, TInt& aId); + IMPORT_C void GetLinkedTypefaceL(TLinkedTypefaceSpecificationArgs &aLinkedTypefaceSpec); + IMPORT_C TBool HaveTypefaceFamilyName(const TDesC& aName); + IMPORT_C void UpdateLinkedTypefaceL(const TLinkedTypefaceSpecificationArgs& aLinkedTypefaceSpec); + IMPORT_C void LoadFontsAtStartupL(); + IMPORT_C TBool GetFontFilePath(const TDesC& aFontName, TFileName& aFilePath) const; + IMPORT_C void CleanupCacheOnFbsSessionTermination(TInt aSessionHandle); + + TInt CacheFontTable(TUid aFileUid, TUint32 aTag, TAny*& aContent, TInt aLength); + TInt ReleaseFontTable(TUid aFileUid, TUint32 aTag, TInt aSessionHandle); + TInt FindFontTableInCache(TUid aFileUid, TUint32 aTag, TAny*& aContent, TInt& aLength); + TInt IncFontTableRefCount(TUid aFileUid, TUint32 aTag, TInt aSessionHandle); + TInt DecFontTableRefCount(TUid aFileUid, TUint32 aTag, TInt aSessionHandle); + TInt CacheUnhintedOutline(const TUnhintedOutlineId& aOutlineId, TAny* aData, + TInt aLength, TAny*& aOutline, TInt& aLen); + TInt CacheHintedOutline(const THintedOutlineId& aOutlineId, TAny* aData, TInt aLength, + TAny*& aOutline, TInt& aLen); + TInt ReleaseUnhintedOutline(const TUnhintedOutlineId& aOutlineId, TInt aSessionHandle); + TInt ReleaseHintedOutline(const THintedOutlineId& aOutlineId, TInt aSessionHandle); + TInt IncreaseUnhintedOutlineRefCount(const TUnhintedOutlineId& aOutlineId, TInt aSessionHandle); + TInt IncreaseHintedOutlineRefCount(const THintedOutlineId& aOutlineId, TInt aSessionHandle); + TInt FindUnhintedOutlineInCache(const TUnhintedOutlineId& aOutlineId, TAny*& aData, + TInt &aLength); + TInt FindHintedOutlineInCache(const THintedOutlineId& aOutlineId, TAny*& aData, TInt& aLength); + void CleanupCacheOnOpenFontRemoval(COpenFont* aFont); + void CleanupCacheOnOpenFontFileRemoval(COpenFontFile* aFontFile); + +private: + CFontStore(RHeap* aHeap); + void ConstructL(); + void InternalizeFontStoreFileL(CFontStoreFile* aFontStoreFile, TInt aFontVersion); + TTypeface* GetNearestTypeface(const TTypeface& aTypeface) const; + TTypefaceFontBitmap GetNearestTypefaceFontBitmap(const TFontSpec& aFontSpecInPixels, TInt aMaxHeight); + CFontBitmap* GetFontBitmapById(TUid aUid); + TBool IsFontLoaded(CFont*& aFont, const TAlgStyle& aAlgStyle, const TFontSpec& aFontSpecInPixels, TUid aUid, TInt aMaxHeight = 0) const; + TBool IsFontLoaded(CFont*& aFont, const TAlgStyle& aAlgStyle, const TOpenFontSpec& aFontSpecInPixels, TInt aMaxHeight) const; + CBitmapFont* NewFontL(const TFontSpec& aFontSpecInTwips,const TAlgStyle& aAlgStyle,CFontBitmap* aFontBitmap); + CBitmapFont* NewFontL(const TOpenFontSpec& aFontSpecInTwips,const TAlgStyle& aAlgStyle,COpenFont* aOpenFont); + TInt VerticalPixelsToTwips(TInt aPixelHeight) const; + TInt VerticalTwipsToPixels(TInt aTwipsHeight) const; + void GetNearestBitmapFontInPixelsL(CFont*& aFont, TFontSpec& aFontSpec, TInt aMaxHeight); + void GetNearestOpenFontInPixelsL( + CFont*& aFont, TOpenFontSpec& aActualFontSpec, const TOpenFontSpec& aDesiredFontSpec, TInt aMaxHeight); + TInt GetNearestRealFontInPixels(CFont*& aFont, const TOpenFontSpec& aFontSpec, TInt aMaxHeight); + TInt GetNearestFontInPixelsL(CFont*& aFont, const TOpenFontSpec& aFontSpec, TInt aMaxHeight); + TInt CreateLinkedTypefaceL(const TLinkedTypefaceSpecificationArgs &aLinkedTypefaceSpec, TInt aSession, TInt& aId); + TInt GetCanonicalIndex(TInt aTypefaceIndex) const; + void TypefaceSupportLinked(TTypefaceSupport &aTypefaceSupport, TInt aTypefaceIndex) const; + TInt GetNearestFontInPixels(CFont*& aFont, const TOpenFontSpec& aFontSpec, TInt aMaxHeight); + void SanityCheckForTtfL(RFile& aFile, TUint aFontFileSize, TBool aStrictChecking); + void SanityCheckFontFileL(TParse& aParse); + TInt GetNearestOpenFontInPixelsByFontName(COpenFont*& aNearestOpenFont, TOpenFontSpec& aActualFontSpec, const TOpenFontSpec& aDesiredFontSpec, TInt aMaxHeight); + TInt GetNearestOpenFontInPixelsBySimilarity(COpenFont*& aNearestOpenFont, TOpenFontSpec& aActualFontSpec, const TOpenFontSpec& aDesiredFontSpec, TInt aMaxHeight); + TInt AddTypefacesToSupportList(COpenFontFile* aOpenFontFile); + void RemoveTypefacesFromSupportList(COpenFontFile* aOpenFontFile); + TInt FindBitmapFontFileIndexByUid(TUid aUid); + TBool IncRefCountOfLoadedFont(const TParse& aFileName, TUid& aFontUid); + TBool LoadFileAsOpenFontL(const TParse& aFileName, TUid& aFontUid); + TUid LoadFileAsBitmapFontL(const TParse& aParse); + static void CleanupRemoveFontFile(TAny* aCleanupInfo); + const TAny* FontLinkingInterface() const; + TInt ValidateLinkedFontSpecificationL(COpenFontLinkedTypefaceSpecification& aSpec, TBool aOverwrite) const; + void GenerateLinkedFontFileL(COpenFontLinkedTypefaceSpecification& aSpec, const TAny* aExtension, TBool aUpdate); + void LoadFontsL(const TDesC& aFontsDir); + void AddSanityCheckedFontL(const TParse& aFileName, TUid& aUid); +public: + /** The width of 1000 pixels in twips. + + This is set in the constructor. If the appropriate HALData attributes are + set (EDisplayXPixels and EDisplayXTwips) then the value is calculated using + these; otherwise the value is set to 11860. */ + TInt iKPixelWidthInTwips; + + /** The height of 1000 pixels in twips. + + This is set in the constructor. If the appropriate HALData attributes are + set (EDisplayYPixels and EDisplayYTwips) then the value is calculated using + these; otherwise the value is set to 11860. */ + TInt iKPixelHeightInTwips; + +private: + // Binary Compatibility warning - data member iDefaultBitmapType is referenced by inline methods + RFs iFs; + RHeap* iHeap; + CArrayPtrFlat iFontStoreFileList; + CArrayPtrFlat iTypefaceList; + CArrayPtrFlat iFontBitmapList; + CArrayFixFlat iTypefaceFontBitmapList; + CArrayPtrFlat iOpenFontFileList; + TInt iReserved[2]; // keep iDefaultBitmapType at the correct offset + CFontTableCache *iFontTableCache; + CUnhintedOutlineCache *iUnhintedOutlineCache; + CHintedOutlineCache *iHintedOutlineCache; + TFontTableGlyphOutlineCacheMemMonitor *iCacheMemMon; + CArrayPtrFlat iOpenFontRasterizerList; + COpenFontSessionCacheList* iOpenFontSessionCacheList; + TInt iOpenFontUid; + TGlyphBitmapType iDefaultBitmapType; + CArrayPtrFlat iShaperFactoryList; + TInt iOpenFontShaperCacheMemUsage; + TInt iNumberOfShaperCaches; + RPointerArray iOpenFontTypefaceSupportList; + RArray *iHandleArray; + TAny* iUnused2; + TUint32 iUniqueFontIdCount; + }; + +// inline functions start here + +/** Returns whether the bitmap font object is an open font (a COpenFont) rather +than a bitmap font (a CFontBitmap). + +@return ETrue if the bitmap font object is using an open font (a COpenFont); +EFalse if it is using a bitmap font (a CFontBitmap). +@see OpenFont() +*/ +inline TBool CBitmapFont::IsOpenFont() const + { + return iOpenFont != NULL; + } + + +/** Returns a pointer to the open font being used by the bitmap font object. + +@return A pointer to an open font. +@see IsOpenFont() +*/ +inline COpenFont* CBitmapFont::OpenFont() const + { + if (reinterpret_cast(iOpenFont) & 1) + { + return reinterpret_cast(const_cast(PtrAdd(this, reinterpret_cast(iOpenFont) & ~1))); + } + else + { + return iOpenFont; + } + } + +/** Gets the anti-aliasing setting for the font, see TGlyphBitmapType for +the range of values. + +This is only applicable to open fonts (COpenFonts) not bitmap fonts (CBitmapFonts). + +Note that this setting is stored in the device-independent font specification +which is set when the bitmap font object is constructed. + +@return The anti-aliasing setting for the font. +@see IsOpenFont() +@see TGlyphBitmapType +@see COpenFont +@see CBitmapFont +*/ +inline TGlyphBitmapType CBitmapFont::GlyphBitmapType() const + { + return iFontSpecInTwips.iFontStyle.BitmapType(); + } + +/** Returns a default bitmap type. + +@return A default bitmap type. +@see TGlyphBitmapType +*/ +inline TGlyphBitmapType CFontStore::DefaultBitmapType() const + { + return iDefaultBitmapType; + } + +/** Sets a default bitmap type. + +@param aType A default bitmap type. +@see TGlyphBitmapType +*/ +inline void CFontStore::SetDefaultBitmapType(TGlyphBitmapType aType) + { + iDefaultBitmapType = aType; + } + +#endif +