diff -r b9ad20498fb4 -r 8b9155204a54 fontservices/fontstore/inc/OPENFONT.H --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fontservices/fontstore/inc/OPENFONT.H Fri Jun 04 10:37:54 2010 +0100 @@ -0,0 +1,2489 @@ +/* +* Copyright (c) 1998-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: +* A header for the open font system, which allows SymbianOS +* to use fonts of arbitrary types, including TrueType/OpenType +* and other outline font formats. +* +*/ + + +#ifndef __OPENFONT_H__ +#define __OPENFONT_H__ + +#include +#include +#include + +#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#include +#include +#include +#include +#include +#endif + +class CFont; +class COpenFontFile; +class COpenFontGlyph; +class COpenFontGlyphCache; +class COpenFontGlyphTreeEntry; +class COpenFontPositioner; +class COpenFontSessionCache; +class COpenFontSessionCacheList; +class RFs; +class TCharacterMetrics; +class TFontSpec; +class TOpenFontFaceAttrib; +class CFontStore; +class TOpenFontFileData; +class TShapeHeader; +class CBitmapFont; +class CShaperFactory; +class CShaper; +class TShapeHeader; +class TFontShapeFunctionParameters; +class TFontShapeDeleteFunctionParameters; +class RShapeInfo; +class TShapeMessageParameters; +class CRasterizerLinkedTypefaceSpecification; +class TLinkedTypefaceSpecificationArgs; + +/** +Supplied to COpenFont::ExtendedInterface() to access the extended +API interface MOpenFontShapingExtension. + +@see COpenFont::ExtendedInterface() +@see MOpenFontShapingExtension +@publishedAll +@released +*/ +const TUid KUidOpenFontShapingExtension = {0x10274DB9}; + +/** +Supplied to COpenFont::ExtendedInterface() to access the extended +API interface MOpenFontTrueTypeExtension. + +@see COpenFont::ExtendedInterface() +@see MOpenFontTrueTypeExtension +@publishedAll +@released +*/ +const TUid KUidOpenFontTrueTypeExtension = {0x1027553E}; +const TUid KUidOpenFontGlyphOutlineExtension = {0x102872CE}; + +/** +Supplied to CShaper::ExtendedInterface() to get the language and script +code with which the current shaper is instatsiated. +@see CShaper::ExtendedInterface() +@publishedAll +@released +*/ +const TUid KUidShaperGetScript = {0x20009966}; +const TUid KUidShaperGetLang = {0x20009967}; + +/** +Font metrics. + +@see CFbsFont::GetFontMetrics() +@publishedAll +@released +*/ +class TOpenFontMetrics + { +public: + inline TOpenFontMetrics(); + IMPORT_C TOpenFontMetrics(const CFont* aFont); + inline TInt Size() const; + inline TInt Ascent() const; + inline TInt Descent() const; + inline TInt MaxHeight() const; + inline TInt MaxDepth() const; + inline TInt MaxWidth() const; + inline void SetSize(TInt aSize); + inline void SetAscent(TInt aAscent); + inline void SetDescent(TInt aDescent); + inline void SetMaxHeight(TInt aMaxHeight); + inline void SetMaxDepth(TInt aMaxDepth); + inline void SetMaxWidth(TInt aMaxWidth); + /** WARNING: Function for internal and partner use ONLY. Compatibility is not guaranteed in future releases.*/ + IMPORT_C void SetBaselineCorrection(TInt aBaselineCorrection); + IMPORT_C TInt BaselineCorrection(); +private: + TInt16 iDesignHeight; // size of the font ('pointsize' in pixels) + TInt16 iAscent; // typographic ascent + TInt16 iDescent; // typographic descent + TInt16 iMaxHeight; // maximum height of a character; may be greater than iAscent + TInt16 iMaxDepth; // maximum depth of a character; may be greater than iDescent + TInt16 iMaxWidth; // maximum width of a character + TInt16 iBaselineCorrection; + TInt16 iReserved; + }; + + +/** +Character metrics includes more information than TCharacterMetrics. + +Character metrics allow characters to be placed horizontally or vertically. +The character metrics encapsulated by this class are: Height, Width, Horizontal +Bearing X, Horizontal Bearing Y, Horizontal Advance, Vertical Bearing X, +Vertical Bearing Y, and Vertical Advance. Their meanings are described in the +associated setter and getter functions. + +Note : + +Vertical drawing (in the sense of characters drawn with horizontal baselines, +but in a vertical line) is not yet supported by Symbian OS. + +@see CFont::GetCharacterData() +@see CFbsFont::GetCharacterData() +@publishedAll +@released +*/ +class TOpenFontCharMetrics + { +public: + enum TUninitialized { EUninitialized }; +public: + /** Default constructor initializes all members to 0. */ + inline TOpenFontCharMetrics(); + + /** Constructor that does not initialize any members. */ + TOpenFontCharMetrics(TUninitialized) {} + IMPORT_C TOpenFontCharMetrics(const TCharacterMetrics& aMetrics); + IMPORT_C TBool GetTCharacterMetrics(TCharacterMetrics& aMetrics) const; + inline TInt Width() const; + inline TInt Height() const; + inline TInt HorizBearingX() const; + inline TInt HorizBearingY() const; + inline TInt HorizAdvance() const; + inline TInt VertBearingX() const; + inline TInt VertBearingY() const; + inline TInt VertAdvance() const; + inline void GetHorizBounds(TRect& aBounds) const; + inline void GetVertBounds(TRect& aBounds) const; + inline void SetWidth(TInt aWidth); + inline void SetHeight(TInt aHeight); + inline void SetHorizBearingX(TInt aHorizBearingX); + inline void SetHorizBearingY(TInt aHorizBearingY); + inline void SetHorizAdvance(TInt aHorizAdvance); + inline void SetVertBearingX(TInt aVertBearingX); + inline void SetVertBearingY(TInt aVertBearingY); + inline void SetVertAdvance(TInt aVertAdvance); + IMPORT_C void SetGlyphType(TGlyphBitmapType); + IMPORT_C TGlyphBitmapType GlyphType() const; +private: + TInt16 iWidth; // width of the glyph + TInt16 iHeight; // height of the glyph + TInt16 iHorizBearingX; // x component of horizontal bearing + TInt16 iHorizBearingY; // y component of horizontal bearing + TInt16 iHorizAdvance; // horizontal advance + TInt16 iVertBearingX; // x component of vertical bearing + TInt16 iVertBearingY; // y component of vertical bearing + TInt16 iVertAdvance; // vertical advance + TUint16 iGlyphBitmapType;// Glyph bitmap type; TGlyphBitmapType + TInt16 iReserved; + }; + + +/** +Font glyph data. + +Objects of this type are used by rasterizers to supply glyph data to font +and bitmap server clients. Unless you are writing a rasterizer you will not +need to use an object of this type. + +The object cannot be constructed and destroyed by normal means. It resides +on a specified heap. It is created by New() and deleted by RHeap::Free(). + +@see COpenFont::RasterizeL() +@publishedAll +@released +*/ +class TOpenFontGlyphData + { +public: + IMPORT_C static TOpenFontGlyphData* New(RHeap* aHeap,TInt aBufferSize); + inline TBool Overflow() const; + inline TInt BytesNeeded() const; + inline TPtrC8 Bitmap() const; + inline const TUint8* BitmapPointer() const; + inline const TOpenFontCharMetrics* Metrics() const; + inline TInt GlyphIndex() const; + inline TUint8* BufferStart(); + inline TUint8* BufferEnd(); + inline void SetBytesNeeded(TInt aBytes); + inline void SetBitmapPointer(const TUint8* aBitmap); + inline void SetMetricsPointer(const TOpenFontCharMetrics* aMetrics); + inline void SetPointersToInternalBuffers(); + inline void SetMetrics(TOpenFontCharMetrics& aMetrics); + inline void SetGlyphIndex(TInt aGlyphIndex); +private: + /* + Prevent construction and destruction by normal means; the object resides + on a specified heap and is created by New and deleted by RHeap::Free. + */ + TOpenFontGlyphData(); + ~TOpenFontGlyphData(); +private: + TInt iBitmapBufferSize; // size of the buffer in bytes + TInt iBytesNeeded; // bytes needed for the bitmap + TOpenFontCharMetrics iMetricsBuffer; // the metrics + const TUint8* iBitmap; // pointer to the bitmap; points either to iBitmapBuffer or to + // the cache if the character was already rasterized + const TOpenFontCharMetrics* iMetrics; // pointer to the metrics; points either to iMetricsBuffer or to + // the cache if the character was already rasterized + TInt iGlyphIndex; // the glyph index + TAny* iReserved; // unused; for future expansion + TUint8 iBitmapBuffer[1]; // buffer used to write the bitmap when it is first rasterized; this + // is actually of size iBitmapBufferSize. + }; + +class COpenFontGlyph; +/** +Open Font System font abstract base class. + +Derive a class from this class to represent an instance of a typeface at a +particular size, provide bitmaps of the glyphs, and determine whether +characters exist in the typeface. + +Writing derived classes construction: + +You must call the constructor of this class when creating your derived object, +passing the arguments aHeap and aSessionCacheList supplied to +COpenFontFile::GetNearestFontInPixelsL(), and the address of the COpenFontFile +object that creates the object as aFile. + +The derived object must be created on the shared heap aHeap because it is +shared by several processes: the font and bitmap server and its clients. +To do this, use aHeap->AllocL() to obtain memory, then construct in place +using a placement argument to new. + +Derived classes must implement the pure virtual function RasterizeL(). +Information about this function is provided in the function definition below. + +Information about deriving from this class is also provided in the API guide. + +@see COpenFontFile::GetNearestFontInPixelsL() +@publishedAll +@released +*/ +class COpenFont: public CBase + { +public: + /** Creates a bitmap for the specified Unicode character. + + Implementations of this function should put the bitmap in + aGlyphData->iBitmapBuffer, and the character metrics are placed in + aGlyphData->iMetricsBuffer. The other parts of aGlyphData should be left + alone. + + There are a number of strategies for achieving this, e.g. pass the + rasterization task all the way up to the rasterizer engine. These are + discussed in the API guide. + + At present you must write the bitmap in the Symbian platform's + run-length-encoded format. This is a packed binary format starting on a + byte boundary and made up of a number of sections. Each section starts + with a five-bit header. If the first bit of the header is 0 the next four + bits are a repeat count, starting with the least significant bit, and a + single row of bits (the number of bits in a row is specified by + aGlyphData->iMetricsBuffer.Width()) follows. If the first bit of the header + is 1 the next four bits are a count of non-repeating rows, again starting + with the least significant bit, and that many rows of bits follow. + + @param aCode The character code of the Unicode character for which the + bitmap is required. + @param aGlyphData On return, contains a pointer to a TOpenFontGlyphData + containing the character's bitmap and metrics. */ + virtual void RasterizeL(TInt aCode,TOpenFontGlyphData* aGlyphData) = 0; + IMPORT_C virtual void ExtendedInterface(TUid aUid, TAny*& aParam); + IMPORT_C COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,COpenFontFile* aFile); + IMPORT_C COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,COpenFontFile* aFile,TInt aFaceIndex); + IMPORT_C ~COpenFont(); + IMPORT_C void operator delete(TAny*); + inline const TOpenFontMetrics& Metrics() const; + inline const TOpenFontFaceAttrib* FaceAttrib() const; + inline COpenFontFile* File() const; + inline TInt FaceIndex() const; + inline TBool CharacterNeedsToBeRasterized(TInt aSessionHandle,TInt aCode) const; + void SetShaper(CShaper* aShaper); + CShaper* GetShaper(); + TBool HasShaper() const; + TShapeHeader* GetShapedData(TInt aSessionHandle,TFontShapeFunctionParameters* aParams); + TShapeHeader* InsertShapedDataIntoCache(TInt aSessionHandle,TFontShapeFunctionParameters* aParams, TShapeHeader* aShapeHeader); + TInt FreeShaperCacheMemory(TInt aBytesNeeded); + TInt DecrementCachedRefCount(TInt aSessionHandle,TShapeHeader* aShapeHeader,TBool aResetAll=EFalse); + TBool Rasterize(TInt aSessionHandle,TInt aCode,TOpenFontGlyphData* aGlyphData); + TBool HasCharacterL(TInt aCode) const; + TBool GetCharacterData(TInt aSessionHandle,TInt aCode,const TOpenFontCharMetrics*& aMetrics,const TUint8*& aBitmap) const; + void OnFileDeleted(); + COpenFontGlyphCache* GetGlyphCache(); + inline TInt FontCapitalAscent() const; + inline TInt FontMaxAscent() const; + inline TInt FontStandardDescent() const; + inline TInt FontMaxDescent() const; + inline TInt FontLineGap() const; + inline TInt FontMaxHeight() const; + void DeleteShaper() const; + TInt GetFontTable(TUint32 aTag, TAny*& aTableContent, TInt& aLength); + TInt GetGlyphOutline(TUint aCode, TBool aHinted, TAny*& aOutline, TInt& aLength); + +protected: + /** WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases. + */ + TInt PointerToThisOffset(const TAny* aAny); + /** WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases. + */ + TAny* ThisOffsetToPointer(const TInt aOffset); + +protected: + RHeap* iHeap; + TOpenFontMetrics iMetrics; +private: + /** The shaper for performing complex character positioning and + substitution, if available. Null otherwise. + + WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. + */ + CShaper* iShaper; + +protected: + /** The positive distance in pixels from the baseline to + the top of an ANSI capital (whether or not there are + ANSI capitals in the font) */ + TInt iFontCapitalAscent; + /** The positive distance in pixels from the baseline to + the top of the highest pre-composed glyph in the font */ + TInt iFontMaxAscent; + /** The positive distance in pixels from the baseline to + the bottom of the lowest ANSI descender (whether or + not there are ANSI chars in the font)*/ + TInt iFontStandardDescent; + /** The positive distance in pixels from the baseline to + the bottom of the lowest pre-composed glyph in the font */ + TInt iFontMaxDescent; + /** The recommended baseline to baseline gap for successive + lines of text in the font */ + TInt iFontLineGap; +private: + const COpenFontGlyph* Glyph(TInt aSessionHandle,TInt aCode) const; +protected: + + /** WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases. + */ + const COpenFontGlyph* FontCacheGlyph(TInt aCode,TInt*& aNode); + const COpenFontGlyph* FontCacheGlyph(TInt aCode); + + void SetGlyphCache(COpenFontGlyphCache* aGlyphCache); + +private: + const COpenFontGlyph* SessionCacheGlyph(RHeap* aHeap,TInt aSessionHandle,TInt aCode, + COpenFontSessionCache*& aCache,TInt& aIndex,TBool aCreate) const; + void RasterizeHelperL(TInt aCode,TOpenFontGlyphData* aGlyphData,TOpenFontGlyphData*& aTempGlyphData); + + COpenFontSessionCacheList* SessionCacheList()const; + + void SetSessionCacheList(COpenFontSessionCacheList* aSessionCacheList); + + void SetFile(COpenFontFile* aFile); +private: + + // Offset from the address of the file used by this font. + // If the file has been deleted or cannot be used, the offest will be zero. + TInt iFileOffset; + + TInt iFaceIndex; // index of the face in the font file +protected: + /** + WARNING: Compatibility is not guaranteed in future releases. Please use the provided APIs only. + Offset from the address of this font of the per-font glyph cache which is owned by the font + @internalTechnology + */ + TInt iGlyphCacheOffset; +private: + // Offset from the address of this font of the list of per-session glyph + // caches which are owned by CFontStore + TInt iSessionCacheListOffset; + + TAny* iReserved; // unused; for future expansion + }; + +/** Open Font System Extension Interface abstract base class. + +COpenFont derivers should also derive from this interface to enable complex +font "shaping". + +This interface should be returned by the overridden +COpenFont::ExtendedInterface function when KUidOpenFontShapingExtension is +supplied as the UID. + +@see COpenFont +@see KUidOpenFontShapingExtension +@publishedAll +@released +*/ +class MOpenFontShapingExtension + { +public: + /** Various font metrics. */ + class TExtensionFontMetrics + { + public: + /** The number of font design units per em. */ + TInt iUnitsPerEm; + /** The width of the font's em square in pixels. */ + TReal iXPixelsPerEm; + /** The height of the font's em square in pixels. */ + TReal iYPixelsPerEm; + /** The horizontal scaling factor from the font's transform; + the number of horizontal pixels per font unit. */ + TReal iXScaleFactor; + /** The vertical scaling factor from the font's transform; + the number of vertical pixels per font unit. */ + TReal iYScaleFactor; + private: + /** Reserved for future expansion. */ + TInt iReserved[4]; + }; + + /** Creates a bitmap for the specified Glyph code. + + Implementations of this function should put the bitmap in + aGlyphData->iBitmapBuffer, and the character metrics are placed in + aGlyphData->iMetricsBuffer. The other parts of aGlyphData should be left + alone. + + This function provides the same functionality as the + COpenFont::RasterizeL() except that the glyph code is supplied rather than + the unicode. + + For more information: + @see COpenFont::RasterizeL() + + @param aCode The glyph code of the character for which the bitmap is required. + @param aGlyphData The function puts its output here. + */ + virtual void RasterizeGlyphL(TInt aCode,TOpenFontGlyphData* aGlyphData) = 0; + + /** Maps a character to a glyph index. + @param aUnicodeCharacter Unicode character code to be mapped. + @return Glyph code corresponding to aUnicodeCharacter. */ + virtual TInt GlyphIndex(TInt aUnicodeCharacter) const = 0; + + /** Returns the hinted pixel coordinates of a particular point in the + outline of the given glyph. + @param aGlyphPoint The glyph index. + @param aPointNumber The number of the point. + @param aX Returns the point's X pixel value. + @param aY Returns the point's Y pixel value. + @return True on success, false otherwise. */ + virtual TBool GlyphPointInHintedPixels(TInt aGlyphIndex, TInt aPointNumber, + TReal& aX, TReal& aY) const = 0; + + /** Returns the coordinates of a particular (unhinted) point in the outline + of the given glyph in font units. + @param aGlyphPoint The glyph index. + @param aPointNumber The number of the point. + @param aX Returns the point's X co-ordinate in font units. + @param aY Returns the point's Y co-ordinate in font units. + @return True on success, false otherwise. */ + virtual TBool GlyphPointInFontUnits(TInt aGlyphIndex, TInt aPointNumber, + TInt& aX, TInt& aY) const = 0; + + /** Returns font metrics. + @param aOut Font metrics returned. */ + virtual void GetExtensionFontMetrics(TExtensionFontMetrics& aOut) = 0; + }; + +/** TrueType extension for Open Fonts. + +If an open font is able to load TrueType or OpenType tables it should derive +from this class. + +This class will be used by + +This interface should be returned by the overridden +COpenFont::ExtendedInterface function when KUidOpenFontTrueTypeExtension is +supplied as the UID. +@see KUidOpenFontTrueTypeExtension +@publishedAll +@released +*/ +class MOpenFontTrueTypeExtension + { +public: + /** Returns the specified table. The table need not be released by the + caller, so the deriver is responsible for ensuring that any memory + allocated is ultimately cleaned up. The caller must not delete or modify + the data returned. + @param aError + Returns KErrNone if successful or one of the system-wide error codes if + unsuccessful. Returns KErrNotSupported if the table does not exist in + the font file. + @param aTag + The tag of the table, with the first character in the most significant + byte. For example, the "vhea" table is obtained by passing in 'v'<<24 | + 'h'<<16 | 'e'<<8 | 'a'. + @param aLength + The length of the table in bytes that has been returned or 0 if + unsuccessful. + @return The table, if successful. + @see ReleaseTrueTypeTable */ + virtual TAny* GetTrueTypeTable(TInt& aError, TUint32 aTag, TInt* aLength) = 0; + /** Releases a table obtained by GetTrueTypeTable. The caller must not + use the table after this call. + @param aTable The table to be released. + @see GetTrueTypeTable */ + virtual TInt ReleaseTrueTypeTable(TAny* aTable) = 0; + /** Determines if the font file has a particular table. + @param aTag The tag of the table as for GetTrueTypeTable. + @return True if the table exists in the font file, false otherwise. + @see GetTrueTypeTable */ + virtual TBool HasTrueTypeTable(TUint32 aTag) = 0; + }; + +class MOpenFontGlyphOutlineExtension + { +public: + virtual TInt GetGlyphOutline(TUint aCode, TBool aIsGlyphId, + TBool aHinted, TAny*& aOutline, TInt& aLength) = 0; + }; +/** +Font attribute base class. + +This class is not intended for user derivation. + +@see TOpenFontFaceAttrib +@see TOpenFontSpec +@publishedAll +@released +*/ +class TOpenFontFaceAttribBase + { +public: + inline TOpenFontFaceAttribBase(); + inline TBool HasLatin() const; + inline TBool HasGreek() const; + inline TBool HasCyrillic() const; + inline TBool HasKana() const; + inline TBool HasHangul() const; + inline TBool HasCJK() const; + inline TBool IsSymbol() const; + inline TBool IsBold() const; + inline TBool IsItalic() const; + inline TBool IsSerif() const; + inline TBool IsMonoWidth() const; + inline TPtrC Name() const; + inline const TUint* Coverage() const; + inline void SetName(const TDesC& aName); + inline void SetCoverage(TUint aCoverage0,TUint aCoverage1 = 0,TUint aCoverage2 = 0,TUint aCoverage3 = 0); + inline void SetBold(TBool aBold); + inline void SetItalic(TBool aItalic); + inline void SetSerif(TBool aSerif); + inline void SetMonoWidth(TBool aMonoWidth); + inline TBool operator==(const TOpenFontFaceAttribBase& aAttrib) const; + + // Unicode ranges for iCoverage[0] (see the TrueType documentation for other values which are not included) + enum + { + ELatinSet = 0x1, // 0000-007F + EGreekSet = 0x80, // 0370-03FF + ECyrillicSet = 0x200, // 0400-04FF + EArmenianSet = 0x400, // 0530-058F + EHebrewSet = 0x800, // 0590-05FF + EArabicSet = 0x2000, // 0600-06FF + EDevanagariSet = 0x8000, // 0900-097F + EBengaliSet = 0x10000, // 0980-09FF + EGurmukhiSet = 0x20000, // 0A00-0A7F + EGujuratiSet = 0x40000, // 0A80-0AFF + EOriyaSet = 0x80000, // 0B00-0B7F + ETamilSet = 0x100000, // 0B80-0BFF + ETeluguSet = 0x200000, // 0C00-0C7F + EKannadaSet = 0x400000, // 0C80-0CFF + EMalayalamSet = 0x800000, // 0D00-0D7F + EThaiSet = 0x1000000, // 0E00-0E7F + ELaoSet = 0x2000000, // 0E80-0EFF + EGeorgianSet = 0x8000000, // 10A0-10FF + EHangulJamoSet = 0x10000000,// 1100-11FF + }; + + // Unicode ranges for iCoverage[1] + enum + { + ESymbolSets = 0xFFFE, + EKanaSets = 0x60000, + EHangulSet = 0x100000, + ECJKSet = 0x8000000 + }; + + // Attribute flags + enum + { + EBold = 0x1, // weight > 500 in Windows terms + EItalic = 0x2, // italic or oblique - any forward slant counts + ESerif = 0x4, // characters have serifs + EMonoWidth = 0x8 // all characters are the same width + }; + + // Other constants + enum + { + ENameLength = 32 // we allow 32 but names that are compatible with old-style fonts are limited to 24 + }; +protected: + TBufC iName; // the name of the typeface; whether this is the full name or family name + // or is in English or another language depends on the context + TUint iCoverage[4]; // bitmap of the character sets supported by the typeface; + // these are the same as the fields ulUnicodeRange1 .. ulUnicodeRange4 + // in the OS/2 table in TrueType fonts + TInt iStyle; // bold, italic serif, and mono-width + TInt32 iReserved; + }; + + +/** +Typeface attributes. + +These attributes include the name, family name, and supported scripts. + +@see CFbsFont::GetFaceAttrib() +@publishedAll +@released +*/ +class TOpenFontFaceAttrib: public TOpenFontFaceAttribBase + { +public: + inline TOpenFontFaceAttrib(); + inline TBool operator==(const TOpenFontFaceAttrib& aAttrib) const; + inline TPtrC FullName() const; + inline TPtrC FamilyName() const; + inline TPtrC LocalFullName() const; + inline TPtrC LocalFamilyName() const; + inline TPtrC ShortFullName() const; + inline TPtrC ShortFamilyName() const; + inline TPtrC ShortLocalFullName() const; + inline TPtrC ShortLocalFamilyName() const; + inline void SetFullName(const TDesC& aName); + inline void SetFamilyName(const TDesC& aName); + inline void SetLocalFullName(const TDesC& aName); + inline void SetLocalFamilyName(const TDesC& aName); + inline TInt MinSizeInPixels() const; + inline void SetMinSizeInPixels(TInt aSize); +private: + TBufC iFamilyName; // the name without any style suffixes; usually a truncation of iFullName + TBufC iLocalFullName; // the full name in the language of the current locale + TBufC iLocalFamilyName; // the family name in the language of the current locale + TInt iMinSizeInPixels; // minimum supported size, (or readable size if scalable) in pixels + TInt32 iReserved2; + }; + + +/** +Font specification allowing more attributes to be specified than TFontSpec. + +In addition to the attributes specified by TFontSpec, this font specification +allows stretching and slanting in the x dimension, and other algorithmic effects. +This is used to correct for non-square pixels, and to allow algorithmic slanting +and bold. The width factor and slant factor transform any point (x,y) to (x +* iWidthFactor + y * iSlantFactor,y). The width and slant factors are 16.16 +fixed-point numbers. + +The font specification also provides access to information about the scripts +which are supported by the font. This information is not always reliable, +because it may be incorrectly specified, or not specified at all, by some +font manufacturers. +@publishedAll +@released +*/ +class TOpenFontSpec : public TOpenFontFaceAttribBase + { +public: + IMPORT_C TOpenFontSpec(); + IMPORT_C TOpenFontSpec(const TFontSpec& aFontSpec); + IMPORT_C void operator=(const TFontSpec& aFontSpec); + inline TBool operator==(const TOpenFontSpec& aFontSpec) const; + TBool operator!=(const TOpenFontSpec& aOpenFontSpec) const; + IMPORT_C void SetAttrib(const TOpenFontFaceAttribBase& aAttrib); + IMPORT_C void GetTFontSpec(TFontSpec& aFontSpec) const; + IMPORT_C void CompensateForAspectRatio(TInt aPixelWidth,TInt aPixelHeight); + IMPORT_C void CompensateForAspectRatio(const MGraphicsDeviceMap& aMap); + inline TInt Height() const; + inline TInt32 WidthFactor() const; + inline TInt32 SlantFactor() const; + inline TGlyphBitmapType BitmapType() const; + inline TUint32 Effects() const; + inline TFontPrintPosition PrintPosition() const; + inline void SetHeight(TInt aHeight); + inline void SetWidthFactor(TInt32 aWidthFactor); + inline void SetSlantFactor(TInt32 aSlantFactor); + inline void SetBitmapType(TGlyphBitmapType aBitmapType); + inline void SetEffects(TUint32 aEffects); + IMPORT_C void SetEffects(FontEffect::TEffect aEffect, TBool aOn); + IMPORT_C TBool IsEffectOn(FontEffect::TEffect aEffect) const; + IMPORT_C void SetScriptTypeForMetrics(TLanguage aLanguage); + IMPORT_C TInt ScriptTypeForMetrics() const; + static TBool IsCompensationForAspectRatioNeeded(TInt aPixelWidth, TInt aPixelHeight); + static TInt ApplyRatio(TInt& aValue,TInt aNumerator,TInt aDenominator); + static TInt ApplyRatio(TInt32& aValue,TInt aNumerator,TInt aDenominator); +public: + /** Algorithmic effects flags. + + These can be combined using an OR operation. + + WARNING: Enum for internal and partner use ONLY. Compatibility is not guaranteed in future releases. + + @deprecated Use FontEffect::TEffect instead. + */ + enum + { + /** Font is algorithmic bold. */ + EAlgorithmicBold = 1, + /** Font has a drop shadow. */ + EDropShadow = 2, + /** Font is an outline font. */ + EOutline = 4 + }; +private: + void SetScriptTypeForMetrics(TInt aScript); + void SetSymbol(TBool aSymbol); + TBool Symbol() const; + IMPORT_C TBool OperatorEquality(const TOpenFontSpec& aOpenFontSpec) const; + IMPORT_C TUint32 DoEffects() const; + IMPORT_C void DoSetEffects(TUint32 aEffects); +private: + TInt iHeight; // em height + TInt32 iWidthFactor; // algorithmic width factor as a 16.16 fixed-point number + TInt32 iSlantFactor; // algorithmic slant factor as a 16.16 fixed-point number + TInt iBitmapType; // non-anti-aliased, standard anti-aliased, etc.; zero means 'default' + TUint32 iEffects; // bit flags for font effects + TInt iSymbol; // a symbol font as understood by TFontSpec (bit 1), script type (bits 2-5) + // The following data member exists only to allow round-trip conversion between TFontSpec and TOpenFontSpec + TFontPrintPosition iPrintPosition; // normal, superscript or subscript + + TInt iReserved2; + }; + +/** +Font file abstract base class. + +Write a class derived from COpenFontFile to manage a file with the font format +supported by your DLL. The derived class must implement the virtual +GetNearestFontInPixelsL() function. This function takes a font description +and creates a COpenFont derived object if the description matches a typeface +contained in the font file. + +Derived classes must also load typeface attributes from the file into the +protected typeface attribute array during construction. This array is what +is searched when getting font attribute information see AddFaceL(), +GetNearestFontHelper(). + +Writing derived classes construction: + +Call the COpenFontFile constructor in the constructor for your derived object, +passing it aUid and aFileName arguments. These values are the arguments passed +when the constructor is called by COpenFontRasterizer::NewFontFileL(). + +A file may contain one or more typefaces. During construction the derived +object should extract the information for each typeface and add it to this +object's protected typeface attribute array see AddFaceL(). This process +will probably leave under some conditions. It should therefore be implemented +in a second phase constructor. + +Writing derived classes implement the pure virtual functions: + +Derived classes must also implement the two pure virtual functions +GetNearestFontInPixelsL() and HasUnicodeCharacterL(). Information about +these functions is provided in the definitions below. Information about +deriving from this class is also provided in the API guide. + +@see COpenFontRasterizer::NewFontFileL() +@see CWsScreenDevice::AddFile() +@publishedAll +@released +*/ +class COpenFontFile : public CBase + { +public: + /** + Gets the font which is the nearest to the given font specification. + + Implementations of this pure virtual function should create the COpenFont + derived object that most closely matches aDesiredFontSpec, while fitting within + aMaxHeight, and place a pointer to it in aFont. If this cannot be done, + e.g. if the font name doesn't match, aFont should be set to NULL. + + The other two arguments, aHeap and aSessionCacheList, should be passed to + the COpenFont constructor. + + Implementations may use the utility function GetNearestFontHelper() + to get the attributes of the closest matching font. + + @param aHeap Shared heap. This value should be passed to the + COpenFont derived classes' constructor. + @param aSessionCacheList The session cache list. This value should be passed + to the COpenFont derived classes' constructor. + @param aDesiredFontSpec The desired font specification. + @param aPixelWidth The width of a pixel. Used with aPixelHeight for calculating + the algorithmic slant of the typeface. + @param aPixelHeight The height of a pixel. Used with aPixelWidth for calculating + the algorithmic slant of the typeface. + @param aFont On return, contains a pointer to the newly created COpenFont + derived object, or NULL if no font matching aDesiredFontSpec exists. + @param aActualFontSpec The actual font specification of the font retrieved into aFont. + @see GetNearestFontHelper() + */ + virtual void GetNearestFontInPixelsL( + RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList, + const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight, + COpenFont*& aFont, TOpenFontSpec& aActualFontSpec) = 0; + + /** + Gets the font which is the nearest to the given font specification. + + Implementations of this pure virtual function should create the COpenFont + derived object that most closely matches aDesiredFontSpec, while fitting within + aMaxHeight, and place a pointer to it in aFont. If this cannot be done, + e.g. if the font name doesn't match, aFont should be set to NULL. + + The other two arguments, aHeap and aSessionCacheList, should be passed to + the COpenFont constructor. + + Implementations may use the utility function GetNearestFontHelper() + to get the attributes of the closest matching font. + + @param aHeap Shared heap. This value should be passed to the COpenFont + derived classes' constructor. + @param aSessionCacheList The session cache list. This value should be passed + to the COpenFont derived classes' constructor. + @param aDesiredFontSpec The desired font specification. + @param aPixelWidth The width of a pixel. Used with aPixelHeight for calculating + the algorithmic slant of the typeface. + @param aPixelHeight The height of a pixel. Used with aPixelWidth for calculating + the algorithmic slant of the typeface. + @param aFont On return, contains a pointer to the newly created COpenFont + derived object, or NULL if no font matching aDesiredFontSpec exists. + @param aActualFontSpec The actual font specification of the font retrieved into aFont. + @see GetNearestFontHelper() + */ + virtual void GetNearestFontToDesignHeightInPixelsL( + RHeap* /*aHeap*/, COpenFontSessionCacheList* /*aSessionCacheList*/, + const TOpenFontSpec& /*aDesiredFontSpec*/, TInt /*aPixelWidth*/, TInt /*aPixelHeight*/, + COpenFont*& /*aFont*/, TOpenFontSpec& /*aActualFontSpec*/) {} + /** + Gets the font which is the nearest to the given font specification. + + Implementations of this pure virtual function should create the COpenFont + derived object that most closely matches aDesiredFontSpec, while fitting within + aMaxHeight, and place a pointer to it in aFont. If this cannot be done, + e.g. if the font name doesn't match, aFont should be set to NULL. + + The other two arguments, aHeap and aSessionCacheList, should be passed to + the COpenFont constructor. + + Implementations may use the utility function GetNearestFontHelper() + to get the attributes of the closest matching font. + + @param aHeap Shared heap. This value should be passed to the COpenFont + derived classes' constructor. + @param aSessionCacheList The session cache list. This value should be passed + to the COpenFont derived classes' constructor. + @param aDesiredFontSpec The desired font specification. + @param aPixelWidth The width of a pixel. Used with aPixelHeight for calculating + the algorithmic slant of the typeface. + @param aPixelHeight The height of a pixel. Used with aPixelWidth for calculating + the algorithmic slant of the typeface. + @param aFont On return, contains a pointer to the newly created COpenFont + derived object, or NULL if no font matching aDesiredFontSpec exists. + @param aActualFontSpec The actual font specification of the font retrieved into aFont. + @param aMaxHeight The maximum height (vertical extent) within which the font must fit. + @see GetNearestFontHelper() + */ + virtual void GetNearestFontToMaxHeightInPixelsL( + RHeap* /*aHeap*/, COpenFontSessionCacheList* /*aSessionCacheList*/, + const TOpenFontSpec& /*aDesiredFontSpec*/, TInt /*aPixelWidth*/, TInt /*aPixelHeight*/, + COpenFont*& /*aFont*/, TOpenFontSpec& /*aActualFontSpec*/, TInt /*aMaxHeight*/) {} + + /** Tests whether a specified typeface contains a particular character. + + @param aFaceIndex The index of the typeface to be tested. + @param aCode The Unicode character code for the character to be tested. + @return ETrue if the typeface contains aCode, otherwise EFalse. */ + virtual TBool HasUnicodeCharacterL(TInt aFaceIndex,TInt aCode) const = 0; + IMPORT_C virtual void ExtendedInterface(TUid aUid, TAny*& aParam); + IMPORT_C COpenFontFile(TInt aUid,const TDesC& aFileName); + IMPORT_C ~COpenFontFile(); + IMPORT_C TBool GetNearestFontHelper(const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight, + TInt& aFaceIndex,TOpenFontSpec& aActualFontSpec) const; + IMPORT_C void AddFaceL(const TOpenFontFaceAttrib& aAttrib); + inline TUid Uid() const; + inline const TDesC& FileName() const; + inline const TOpenFontFaceAttrib& FaceAttrib(TInt aFaceIndex) const; + inline TInt FaceCount() const; + inline void IncRefCount(); + inline TBool DecRefCount(); + TInt GetNearestFontInPixels( + RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList, + const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight, + COpenFont*& aFont, TOpenFontSpec& aActualFontSpec); + TInt GetNearestFontToDesignHeightInPixels( + RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList, + const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight, + COpenFont*& aFont, TOpenFontSpec& aActualFontSpec); + TInt GetNearestFontToMaxHeightInPixels( + RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList, + const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight, + COpenFont*& aFont, TOpenFontSpec& aActualFontSpec, TInt aMaxHeight); + void RemoveFontFromList(const COpenFont* aFont); + void SetFontStoreL(CFontStore* aFontStore); + CFontStore* GetFontStore(); + CArrayPtrFlat* GetOpenFontList(); +protected: + IMPORT_C TBool GetNearestFontHelperOld(const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight, + TInt& aFaceIndex,TOpenFontSpec& aActualFontSpec) const; +private: + // A class to contain the public font attributes and private positioning information (for kerning, ligatures, etc.) + class TAttrib: public TOpenFontFaceAttrib + { + public: + COpenFontPositioner* iPositioner; // if non-null, positioning information for the typeface + }; + static TInt ScoreByName(const TOpenFontSpec& aDesiredFontSpec, const TAttrib& aAttrib); + static TInt ScoreByStyle(const TOpenFontSpec& aDesiredFontSpec, const TAttrib& aAttrib); + void GetNearestFontToDesignHeightInPixelsAndAddToListL( + RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList, + const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight, + COpenFont*& aFont, TOpenFontSpec& aActualFontSpec); + void GetNearestFontToMaxHeightInPixelsAndAddToListL( + RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList, + const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight, + COpenFont*& aFont, TOpenFontSpec& aActualFontSpec, TInt aMaxHeight); + +private: + CArrayFixFlat iFaceAttrib; + TUid iUid; + TBuf iFileName; + TInt iRefCount; + CArrayPtrFlat iFontList; + TOpenFontFileData* iData; + }; + +/** +Convenience class from which rasterizer contexts may be derived. + +A rasterizer context object may (optionally) be created to provide the link +between the rasterizer DLL code supported by the Open Font System, and the +rasterizer engine code. A rasterizer context object class should get the +requested bitmap from the associated rasterizer engine. It should then convert +this into Symbian run-length-encoded format. This class contains convenience +functions to make the conversion easier. + +Deriving from this class is described in greater detail in the API guide. +@publishedAll +@released +*/ +class COpenFontRasterizerContext: public CBase + { +public: + inline COpenFontRasterizerContext(); + inline void StartGlyph(TOpenFontGlyphData* aGlyphData); + inline void WriteGlyphBit(TInt aBit); + inline void WriteGlyphByte(TInt aByte); + inline void EndGlyph(); +private: + TOpenFontGlyphData* iGlyphData; + TUint8* iGlyphDataStart; + TUint8* iGlyphDataPtr; + TUint8* iGlyphDataEnd; + TInt iGlyphBit; + TInt iBytesNeeded; + TBool iOverflow; + TAny* iReserved; // unused; for future expansion + }; + + +/** +Shaper abstract class. All shaper implementations derive from this +@publishedAll +@released +*/ +class CShaper : public CBase + { +public: + class TInput + { + public: + /** The text to be shaped possibly including context. */ + const TDesC* iText; + /** The index of the first character in iText to be shaped. */ + TInt iStart; + /** (One past) the end of the text in iText to be shaped. */ + TInt iEnd; + /** Script code, for example 'd'<<24 | 'e'<<16 | 'v'<<8 | 'a' + for Devanagari. */ + TInt iScript; + /** Language code. 0 implies "default" */ + TUint32 iLanguage; + /** Maximum advance in pixels. Shaping beyond this + advance is not required (but is not harmful). */ + TInt iMaximumAdvance; + /** Flags. Currently none is defined. */ + TInt iFlags; + /** Session handle. To be used if rasterization is needed. */ + TInt iSessionHandle; + /** Reserved for future expansion. Must be set to 0. */ + TInt iReserved1; + }; + /** Constructor */ + IMPORT_C CShaper(); + + /** Destructor */ + IMPORT_C virtual ~CShaper(); + + /** construct a shaper object + @param aBitmapFont The font to be shaped. + @param aHeap The heap to be used by the shaper. + @return KErrNone if this font can be shaper or system wide error code*/ + virtual TInt ConstructL(CBitmapFont* aBitmapFont, TInt aScript, TInt aLanguage, RHeap* iHeap) = 0; + + /** If possible, shape the text described by aInput, placing the output on aHeapForOutput. + @param aOutput The output, as a newly allocate object on aHeapForOutput. + @param aInput The input text and other parameters. + @param aHeapForOutput On success, aOutput should be allocated from this and nothing else. + On failure, nothing should be allocated from it. + @return Error value from one of the system-wide error codes on failure, KErrNone on success. + @see TShapeHeader */ + virtual TInt ShapeText(TShapeHeader*& aOutput, const TInput& aInput, RHeap* aHeapForOutput) = 0; + + /** For future expansion. Any overriders must base-call + if aInterface is unrecognized. + + WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases. + + @param aInterfaceId The ID of the interface to return. + @return A pointer to the extension interface. + */ + IMPORT_C virtual void* ExtendedInterface(TUid aInterfaceId); + }; + +/** ECOM plug-in base class for shaper factories. +@publishedAll +@released +*/ +class CShaperFactory : public CBase + { +public: + /** Create a shaper if possible, for typeface aFaceIndex + within file aFileName. + @param aFont The font to be shaped. + @param iHeap The heap to use for constructing the shaper. + @return 0 If the font is not understood or inappropriate for any shaper that might be constructed + by this class, otherwise returns the newly-constructed shaper on iHeap. */ + virtual CShaper* NewShaperL(CBitmapFont* aFont, TInt aScript, TInt aLanguage, RHeap* iHeap) = 0; + + inline static CShaperFactory* NewL(TUid aInterfaceImplUid); + inline virtual ~CShaperFactory(); + + /** For future expansion. Any overriders must base-call if aInterface is unrecognized. + + WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases. + + @param aInterfaceId The ID of the interface to return. + @return A pointer to the extension interface. + */ + virtual void* ExtendedInterface(TUid aInterfaceId); + +private: + TUid iDtor_ID_Key;//ECOM identifier used during destruction + }; + +// Inline functions start here. +/** Default C++ constructor. + +This creates then zero fills the object. */ +inline TOpenFontMetrics::TOpenFontMetrics() + { + Mem::FillZ(this,sizeof(*this)); + } + +/** Gets the font's size. + +@return The font's size. +@see SetSize() */ +inline TInt TOpenFontMetrics::Size() const + { + return iDesignHeight; + } + +/** Gets the font's ascent. + +This is the ascent for the Latin character which is highest above the baseline. + +@return The font's ascent, in pixels. +@see SetAscent() */ +inline TInt TOpenFontMetrics::Ascent() const + { + return iAscent; + } + +/** Gets the font's descent. + +This is the descent for the Latin character in the font which falls furthest below the baseline. + +@return The font's descent, in pixels. +@see SetDescent() */ +inline TInt TOpenFontMetrics::Descent() const + { + return iDescent; + } + +/** Sets the font's maximum height. + +Note that if this object was initialised from the CFont this will be the same +as the ascent. + +This is the ascent for the character which is highest above the baseline. +In many fonts this will be the height of an accented character like Â, +including the accent. + +@return The maximum height of the font, in pixels. +@see SetMaxDepth() */ +inline TInt TOpenFontMetrics::MaxHeight() const + { + return iMaxHeight; + } + +/** Gets the font's maximum depth. + +Note: If this object was initialised from the CFont this will be the same as the +descent. + +This is the descent for the character in the font which falls furthest below +the baseline. + +@return The font's maximum depth. +@see SetMaxDepth() */ +inline TInt TOpenFontMetrics::MaxDepth() const + { + return iMaxDepth; + } + +/** Gets the maximum character width, in pixels. + +@return The maximum character width, in pixels. +@see SetMaxWidth() */ +inline TInt TOpenFontMetrics::MaxWidth() const + { + return iMaxWidth; + } + +/** Sets the font's size. + +@param aSize The font's size. +@see Size() */ +inline void TOpenFontMetrics::SetSize(TInt aSize) + { + iDesignHeight = static_cast(aSize); + } + +/** Sets the ascent. + +@param aAscent The ascent, in pixels. +@see Ascent() */ +inline void TOpenFontMetrics::SetAscent(TInt aAscent) + { + iAscent = static_cast(aAscent); + } + +/** Sets the descent. + +@param aDescent The descent, in pixels. +@see Descent() */ +inline void TOpenFontMetrics::SetDescent(TInt aDescent) + { + iDescent = static_cast(aDescent); + } + +/** Sets the font's maximum height. + +@param aMaxHeight The font's maximum height, in pixels. +@see MaxHeight() */ +inline void TOpenFontMetrics::SetMaxHeight(TInt aMaxHeight) + { + iMaxHeight = static_cast(aMaxHeight); + } + +/** Sets the font's maximum depth. + +@param aMaxDepth The font's maximum depth, in pixels. +@see MaxDepth() */ +inline void TOpenFontMetrics::SetMaxDepth(TInt aMaxDepth) + { + iMaxDepth = static_cast(aMaxDepth); + } + +/** Sets the maximum character width, in pixels. + +@param aMaxWidth The maximum character width, in pixels. +@see MaxWidth() */ +inline void TOpenFontMetrics::SetMaxWidth(TInt aMaxWidth) + { + iMaxWidth = static_cast(aMaxWidth); + } + +/** Default C++ constructor. + +The constructor initialises all data members to zero. As for other T classes, +there is no need to explicitly cleanup TOpenFontCharMetrics objects. */ +inline TOpenFontCharMetrics::TOpenFontCharMetrics() + { + Mem::FillZ(this,sizeof(*this)); + } + +/** Gets the width of the character's bitmap. + +@return The width of the bitmap in pixels. */ +inline TInt TOpenFontCharMetrics::Width() const + { + return iWidth; + } + +/** Gets the height of the character's bitmap. + +@return The character's height in pixels. */ +inline TInt TOpenFontCharMetrics::Height() const + { + return iHeight; + } + +/** Gets the horizontal bearing X. + +This is the distance in pixels from the pen point before the character is +drawn (the origin) to the left edge of the bitmap, when drawing horizontally. +A positive value means that the left edge of the bitmap is right of the origin. + +@return The horizontal bearing X in pixels */ +inline TInt TOpenFontCharMetrics::HorizBearingX() const + { + return iHorizBearingX; + } + +/** Gets horizontal bearing Y. + +This is the vertical distance in pixels from the pen point before the character +is drawn (the origin) to the top edge of the bitmap, when drawing horizontally. +A positive value means that the top edge of the bitmap is above the origin + +@return The horizontal bearing Y in pixels. */ +inline TInt TOpenFontCharMetrics::HorizBearingY() const + { + return iHorizBearingY; + } + +/** Gets the horizontal advance. + +This is the amount added to the x co-ordinate of the origin after the character +is drawn what most people understand by the width or escapement of a character. +The origin here is the pen point before the character is drawn. + +@return The horizontal advance in pixels */ +inline TInt TOpenFontCharMetrics::HorizAdvance() const + { + return iHorizAdvance; + } + +/** Gets the vertical bearing X. + +This is the distance in pixels from the pen point before the character is +drawn (the origin) to the left edge of the bitmap, when drawing vertically. +A positive value means that the left edge of the bitmap is right of the origin. + +@return The vertical bearing X in pixels. */ +inline TInt TOpenFontCharMetrics::VertBearingX() const + { + return iVertBearingX; + } + +/** Gets the vertical bearing Y. + +This is the distance in pixels from the pen point before the character is +drawn (the origin) to the top edge of the bitmap, when drawing vertically. +A positive value means that the top edge of the bitmap is above the origin. + +@return The vertical bearing Y in pixels. */ +inline TInt TOpenFontCharMetrics::VertBearingY() const + { + return iVertBearingY; + } + +/** Gets the vertical advance. + +When drawing vertically, this is the amount added to the y co-ordinate of +the origin after the character is drawn what most people understand by +the height of a character. The origin here is the pen point before the character +is drawn. + +Note: Vertical drawing is not supported in v5. + +@return The vertical advance in pixels. */ +inline TInt TOpenFontCharMetrics::VertAdvance() const + { + return iVertAdvance; + } + +/** Gets the bounds of the character relative to its origin when setting text +horizontally. + +The origin here is the pen point before the character is drawn. + +@param aBounds The character's bounds. */ +inline void TOpenFontCharMetrics::GetHorizBounds(TRect& aBounds) const + { + aBounds.iTl.iX = iHorizBearingX; + aBounds.iTl.iY = -iHorizBearingY; + aBounds.iBr.iX = aBounds.iTl.iX + iWidth; + aBounds.iBr.iY = aBounds.iTl.iY + iHeight; + } + +/** Gets the bounds of the character relative to its origin when setting text +vertically. + +The origin here is the pen point before the character is drawn. + +@param aBounds The character's bounds. */ +inline void TOpenFontCharMetrics::GetVertBounds(TRect& aBounds) const + { + aBounds.iTl.iX = -iVertBearingX; + aBounds.iTl.iY = iVertBearingY; + aBounds.iBr.iX = aBounds.iTl.iX + iWidth; + aBounds.iBr.iY = aBounds.iTl.iY + iHeight; + } + +/** Sets the width of the character's bitmap. + +@param aWidth The width of the bitmap in pixels. */ +inline void TOpenFontCharMetrics::SetWidth(TInt aWidth) + { + iWidth = (TInt16)aWidth; + } + +/** Sets the height of the character's bitmap. + +@param aHeight The character height (in pixels). */ +inline void TOpenFontCharMetrics::SetHeight(TInt aHeight) + { + iHeight = (TInt16)aHeight; + } + +/** Sets the horizontal bearing X. + +This is the distance in pixels from the pen point before the character is +drawn (the origin) to the left edge of the bitmap, when drawing horizontally. +A positive value means that the left edge of the bitmap is right of the origin. + +@param aHorizBearingX The horizontal bearing X (in pixels). */ +inline void TOpenFontCharMetrics::SetHorizBearingX(TInt aHorizBearingX) + { + iHorizBearingX = (TInt16)aHorizBearingX; + } + +/** Sets the horizontal bearing Y. + +This is the distance in pixels from the pen point before the character is +drawn (the origin) to the top edge of the bitmap, when drawing horizontally. +A positive value means that the top edge of the bitmap is above the origin. + +@param aHorizBearingY The horizontal bearing Y (in pixels). */ +inline void TOpenFontCharMetrics::SetHorizBearingY(TInt aHorizBearingY) + { + iHorizBearingY = (TInt16)aHorizBearingY; + } + +/** Sets the horizontal advance. + +This is the amount added to the x co-ordinate of the origin after the character +is drawn, what most people understand by the width or escapement of a character. +The origin here is the pen point before the character is drawn. + +@param aHorizAdvance The horizontal advance (in pixels). */ +inline void TOpenFontCharMetrics::SetHorizAdvance(TInt aHorizAdvance) + { + iHorizAdvance = (TInt16)aHorizAdvance; + } + +/** Set vertical bearing X. + +This is the distance in pixels from the pen point before the character is +drawn (the origin) to the left edge of the bitmap, when drawing vertically. +A positive value means that the left edge of the bitmap is right of the origin. + +@param aVertBearingX The vertical bearing X (in pixels). */ +inline void TOpenFontCharMetrics::SetVertBearingX(TInt aVertBearingX) + { + iVertBearingX = (TInt16)aVertBearingX; + } + +/** Sets the vertical bearing Y. + +This is the distance in pixels from the pen point before the character is +drawn (the origin) to the top edge of the bitmap, when drawing vertically. +A positive value means that the top edge of the bitmap is above the origin. + +@param aVertBearingY The vertical bearing Y (in pixels). */ +inline void TOpenFontCharMetrics::SetVertBearingY(TInt aVertBearingY) + { + iVertBearingY = (TInt16)aVertBearingY; + } + +/** Sets the vertical advance. + +When drawing vertically, this is the amount added to the y co-ordinate of +the origin after the character is drawn what most people understand by +the height of a character. The origin here is the pen point before the character +is drawn. + +Note: Vertical drawing is not supported in v5. + +@param aVertAdvance The vertical advance (in pixels). */ +inline void TOpenFontCharMetrics::SetVertAdvance(TInt aVertAdvance) + { + iVertAdvance = (TInt16)aVertAdvance; + } + +/** Gets the character metrics for this font. + +@return The character metrics for this font. */ +inline const TOpenFontMetrics& COpenFont::Metrics() const + { + return iMetrics; + } + +/** Gets the glyph index. + +This is the index of a particular glyph within the font file. + +Note: This makes it possible to gain access to glyphs which are not referenced +by the Unicode character set. However, this feature is not yet supported by +Symbian OS. + +@return The glyph index. +@see SetGlyphIndex() */ +inline TInt TOpenFontGlyphData::GlyphIndex() const + { + return iGlyphIndex; + } + +/** Gets the typeface attributes. + +These are the attributes of the font represented by this object. + +@return The typeface attributes. */ +inline const TOpenFontFaceAttrib* COpenFont::FaceAttrib() const + { + return iFileOffset == 0 ? NULL : &File()->FaceAttrib(iFaceIndex); + } + +/** Gets a pointer to the COpenFontFile which created this object. + +This is the COpenFontFile which owns the file that contains the definition +of the typeface. It can be used to get information about the typeface, or +to access the rasterizer context (engine). + +@return The COpenFontFile which created this object. */ +inline COpenFontFile* COpenFont::File() const + { + return iFileOffset == 0 ? NULL : reinterpret_cast(const_cast(PtrAdd(this, iFileOffset))); + } + +/** Gets the index of this typeface within the font file. + +@return The index of this typeface within the font file. */ +inline TInt COpenFont::FaceIndex() const + { + return iFaceIndex; + } + +/** Tests whether or not a character needs to be rasterized. + +Characters that have been rasterized are cached there is no need to regenerate +the character bitmap. This function should only be called by the Font and +Bitmap server. + +@param aSessionHandle A handle to the font and bitmap server session. +@param aCode The code for the Unicode character. +@return ETrue if the character needs to be rasterized, otherwise EFalse. */ +inline TBool COpenFont::CharacterNeedsToBeRasterized(TInt aSessionHandle,TInt aCode) const + { + return Glyph(aSessionHandle,aCode) == NULL; + } + +/** Gets the ascent of an ANSI capital letter in the font whether or not +there are any ANSI capitals in the font. +@return The positive distance from the font baseline to the top of a +standard ANSI capital letter +@publishedAll +@released +@see AscentInPixels() +*/ +inline TInt COpenFont::FontCapitalAscent() const + { + return iFontCapitalAscent; + } + +/** Gets the max ascent of any pre-composed glyph in the font. This will +include accents or diacritics that form part of pre-composed glyphs. It is +not guaranteed to cover the max ascent of composite glyphs that have to be +created by a layout engine. This is also the recommended distance between +the top of a text box and the baseline of the first line of text. + +The value may be affected by the TLanguage value set by SetScriptTypeForMetrics(). + +@return The positive distance from the font baseline to the top of the +highest pre-composed glyph (including accents) above the baseline. +@publishedAll +@released +@see AscentInPixels() +@see SetScriptTypeForMetrics() +*/ +inline TInt COpenFont::FontMaxAscent() const + { + return iFontMaxAscent; + } + +/** Gets the descent of an ANSI descending character in the font. +Whether or not there are any ANSI descenders in the font. + +The value may be affected by the TLanguage value set by SetScriptTypeForMetrics(). + +@return The positive distance from the font baseline to the bottom of the +lowest ANSI descender. +@publishedAll +@released +@see DescentInPixels() +@see SetScriptTypeForMetrics() +*/ +inline TInt COpenFont::FontStandardDescent() const + { + return iFontStandardDescent; + } + +/** Gets the max descent of any pre-composed glyph in the font. This will +include accents or diacritics that form part of pre-composed glyphs. It is +not guaranteed to cover the max descent of composite glyphs that have to be +created by a layout engine. + +The value may be affected by the TLanguage value set by SetScriptTypeForMetrics(). + +@return The positive distance from the font baseline to the bottom of the +lowest pre-composed glyph (including accents) below the baseline +@publishedAll +@released +@see DescentInPixels() +@see SetScriptTypeForMetrics() +*/ +inline TInt COpenFont::FontMaxDescent() const + { + return iFontMaxDescent; + } + +/** Gets the suggested line gap for the font. This is the recommended +baseline to baseline distance between successive lines of text in the font. +@return The positive recommended gap between successive lines +@publishedAll +@released +*/ +inline TInt COpenFont::FontLineGap() const + { + return iFontLineGap; + } + +/** Gets the maximum height for the font. This is the sum of the max ascent +of the font and the max descent of the font. + +The value may be affected by the TLanguage value set by SetScriptTypeForMetrics(). + +@return The positive maximum height of the font +@publishedAll +@released +@see HeightInPixels() +@see SetScriptTypeForMetrics() +*/ +inline TInt COpenFont::FontMaxHeight() const + { + return iFontMaxAscent + iFontMaxDescent; + } + +/** Default C++ constructor. + +This sets all attribute fields to zero. As for other T classes, there is no +need to explicitly clean-up objects derived from this class. */ +inline TOpenFontFaceAttribBase::TOpenFontFaceAttribBase() + { + Mem::FillZ(this,sizeof(*this)); + } + +/** Default C++ constructor. + +The function initialises the minimum typeface size to zero, the names to NULL, +and the coverage and style flags to zero. */ +inline TOpenFontFaceAttrib::TOpenFontFaceAttrib(): + iMinSizeInPixels(0), + iReserved2(0) + { + } + +/** Tests for support of Latin characters. + +Note: A return value of ETrue implies that the font has a usable set of +characters. It does not imply exhaustive coverage. + +@return ETrue if Latin characters are supported */ +inline TBool TOpenFontFaceAttribBase::HasLatin() const + { + return iCoverage[0] & ELatinSet; + } + +/** Tests for support of Greek characters. + +Note: A return value of ETrue implies that the font has a usable set of +characters. It does not imply exhaustive coverage. + +@return ETrue if Greek characters are supported. */ +inline TBool TOpenFontFaceAttribBase::HasGreek() const + { + return iCoverage[0] & EGreekSet; + } + +/** Tests for support of Cyrillic characters. + +Note: A return value of ETrue implies that the font has a usable set of +characters. It does not imply exhaustive coverage. + +@return ETrue if Cyrillic characters are supported. */ +inline TBool TOpenFontFaceAttribBase::HasCyrillic() const + { + return iCoverage[0] & ECyrillicSet; + } + +/** Tests for support of Japanese syllabic characters. + +This function tests for the presence of Hiragana and Katakana syllabic +characters in the font, collectively called kana. These characters are not +sufficient for the Japanese language, which also makes use of Chinese characters. + +Note: A return value of ETrue implies that the font has a usable set of +characters. It does not imply exhaustive coverage. + +@return ETrue if Japanese characters are supported +@see HasCJK() */ +inline TBool TOpenFontFaceAttribBase::HasKana() const + { + return iCoverage[1] & EKanaSets; + } + +/** Tests for support of Korean Hangul characters. + +Korean may also make use of Chinese characters. + +Note: A return value of ETrue implies that the font has a usable set of +characters. It does not imply exhaustive coverage. + +@return ETrue if Korean characters are supported +@see HasCJK() */ +inline TBool TOpenFontFaceAttribBase::HasHangul() const + { + return iCoverage[1] & EHangulSet; + } + +/** Tests for support of Chinese ideographic characters. + +These are used in Chinese, Japanese and Korean. + +Note: A return value of ETrue implies that the font has a usable set of +characters. It does not imply exhaustive coverage. + +@return ETrue if Chinese ideographs are supported. */ +inline TBool TOpenFontFaceAttribBase::HasCJK() const + { + return iCoverage[1] & ECJKSet; + } + +/** Tests if the typeface contains symbols only. + +@return ETrue if the typeface contains symbols only. */ +inline TBool TOpenFontFaceAttribBase::IsSymbol() const + { + return iCoverage[0] == 0 && iCoverage[2] == 0 && iCoverage[3] == 0 && + iCoverage[1] & ESymbolSets && !(iCoverage[1] & ~ESymbolSets); + } + +/** Tests if the typeface is inherently bold. + +@return ETrue if the typeface is inherently bold. */ +inline TBool TOpenFontFaceAttribBase::IsBold() const + { + return iStyle & EBold; + } + +/** Tests if the typeface is inherently italic. + +@return ETrue if the typeface is inherently italic. */ +inline TBool TOpenFontFaceAttribBase::IsItalic() const + { + return iStyle & EItalic; + } + +/** Tests if the typeface has serifs. + +@return ETrue if the typeface has serifs. */ +inline TBool TOpenFontFaceAttribBase::IsSerif() const + { + return iStyle & ESerif; + } + +/** Tests if all the characters have the same width. + +@return ETrue if all the characters have the same width. */ +inline TBool TOpenFontFaceAttribBase::IsMonoWidth() const + { + return iStyle & EMonoWidth; + } + +/** Gets the typeface's name. + +@return Descriptor containing typeface name. */ +inline TPtrC TOpenFontFaceAttribBase::Name() const + { + return iName; + } + +/** Gets the full name. + +The full name of the typeface includes style attributes like Italic, Bold, +and Cursive. + +@return The full name of the typeface. +@see FamilyName() */ +inline TPtrC TOpenFontFaceAttrib::FullName() const + { + return Name(); + } + +/** Gets the family name. + +Note: The family name of the typeface does not include style attributes like +"Italic". + +@return The family name of the typeface. +@see FullName() */ +inline TPtrC TOpenFontFaceAttrib::FamilyName() const + { + return iFamilyName; + } + +/** Gets the local full name. + +The local full name of the typeface includes style attributes like Italic, +Bold, and Cursive. + +The local name of the typeface is the name in the language of the current +locale, where this is provided by the font file. If the local name is not +available then the local name will be the same as the ordinary name. + +@return The local full name of the typeface. */ +inline TPtrC TOpenFontFaceAttrib::LocalFullName() const + { + return iLocalFullName; + } + +/** Gets the local family name. + +The local name of the typeface is the name in the language of the current +locale, where this is provided by the font file. If the local name is not +available then the local name will be the same as the ordinary name. + +Note: The family name of the typeface does not include style attributes like +'Italic'. + +@return The local family name of the typeface. */ +inline TPtrC TOpenFontFaceAttrib::LocalFamilyName() const + { + return iLocalFamilyName; + } + +/** Gets the short full name. + +This is the full name of the typeface, truncated to KMaxTypefaceNameLength, +if necessary. + +Note: Short names are names truncated to KMaxTypefaceNameLength (24) characters +where necessary so that they can be used in the TTypeFace class. The Open +Font Framework allows 32 characters as a maximum name length. + +@return The short full name of the typeface. +@see FullName() */ +inline TPtrC TOpenFontFaceAttrib::ShortFullName() const + { + // Can't use TDesC::Left for this because it panics if the desired length is > the existing length! + return TPtrC(iName.Ptr(),Min(iName.Length(),KMaxTypefaceNameLength)); + } + +/** Gets the short family name. + +This is the family name, truncated to KMaxTypefaceNameLength, if necessary. + +Note: Short names are names truncated to KMaxTypefaceNameLength (24) characters +where necessary so that they can be used in the TTypeFace class. The Open +Font Framework allows 32 characters as a maximum name length. + +@return The short family name of the typeface. +@see FamilyName() */ +inline TPtrC TOpenFontFaceAttrib::ShortFamilyName() const + { + return TPtrC(iFamilyName.Ptr(),Min(iFamilyName.Length(),KMaxTypefaceNameLength)); + } + +/** Gets the short local full name. + +This is the local full name of the typeface, truncated to KMaxTypefaceNameLength, +if necessary. + +Note: Short names are names truncated to KMaxTypefaceNameLength (24) characters +where necessary so that they can be used in the TTypeFace class. The Open +Font Framework allows 32 characters as a maximum name length. + +@return The short local full name of the typeface. +@see LocalFullName() */ +inline TPtrC TOpenFontFaceAttrib::ShortLocalFullName() const + { + return TPtrC(iLocalFullName.Ptr(),Min(iLocalFullName.Length(),KMaxTypefaceNameLength)); + } + +/** Gets the short local family name. + +This is the local family name of the typeface, truncated to KMaxTypefaceNameLength, +if necessary. + +Note: Short names are names truncated to KMaxTypefaceNameLength (24) characters +where necessary so that they can be used in the TTypeFace class. The Open +Font Framework allows 32 characters as a maximum name length. + +@return The short local family name of the typeface. +@see LocalFamilyName() */ +inline TPtrC TOpenFontFaceAttrib::ShortLocalFamilyName() const + { + return TPtrC(iLocalFamilyName.Ptr(),Min(iLocalFamilyName.Length(),KMaxTypefaceNameLength)); + } + +/** Gets a pointer to the sets of flags that indicate the font's Unicode coverage. + +Each flag that is set represents a supported Unicode range. The mapping is +defined in the TrueType documentation under the OS/2 table. + +Note: Some useful subsets are defined as anonymous enumerated constants at the end +of this class, see ELatinSet etc. + +@return A pointer to the flags that indicate the font's Unicode coverage. +The flags are stored in an array of four 32-bit integers. When no information +is available, all four integers are zero. +@see SetCoverage() */ +inline const TUint* TOpenFontFaceAttribBase::Coverage() const + { + return iCoverage; + } + +/** Gets the minimum typeface size. + +This is the smallest size that can be drawn legibly. + +@return The minimum typeface size (in pixels). */ +inline TInt TOpenFontFaceAttrib::MinSizeInPixels() const + { + return iMinSizeInPixels; + } + +/** Sets the name attribute. + +@param aName Descriptor containing typeface name. */ +inline void TOpenFontFaceAttribBase::SetName(const TDesC& aName) + { + iName = TPtrC(aName.Ptr(),Min(aName.Length(),(TInt)ENameLength)); + } + +/** Sets the full name. + +@param aName The full name of the typeface. +@see FullName() */ +inline void TOpenFontFaceAttrib::SetFullName(const TDesC& aName) + { + SetName(aName); + } + +/** Sets the family name. + +@param aName The family name of the typeface. +@see FamilyName() */ +inline void TOpenFontFaceAttrib::SetFamilyName(const TDesC& aName) + { + iFamilyName = TPtrC(aName.Ptr(),Min(aName.Length(),(TInt)ENameLength)); + } + +/** Sets the local full name. + +@param aName The local full name of the typeface. +@see LocalFullName() */ +inline void TOpenFontFaceAttrib::SetLocalFullName(const TDesC& aName) + { + iLocalFullName = TPtrC(aName.Ptr(),Min(aName.Length(),(TInt)ENameLength)); + } + +/** Sets the local family name. + +@param aName The local family name of the typeface. +@see LocalFamilyName() */ +inline void TOpenFontFaceAttrib::SetLocalFamilyName(const TDesC& aName) + { + iLocalFamilyName = TPtrC(aName.Ptr(),Min(aName.Length(),(TInt)ENameLength)); + } + +/** Sets the coverage flags. + +The flags are held in four 32 bit integers. Each flag that is set represents +a range of Unicode characters that is supported by the typeface: Latin, +Greek, Cyrillic etc. The mapping is defined in the TrueType documentation +under the OS/2 table. + +Note: Some useful subsets are defined as anonymous enumerated constants at +the end of this class, see ELatinSet etc. + +@param aCoverage0 The first set of coverage flags (bits 0-31). +@param aCoverage1 The second set of coverage flags (bits 32-63). +@param aCoverage2 The third set of coverage flags (bits 64-95). +@param aCoverage3 The fourth set of coverage flags (bits 96-127). */ +inline void TOpenFontFaceAttribBase::SetCoverage(TUint aCoverage0,TUint aCoverage1,TUint aCoverage2,TUint aCoverage3) + { + iCoverage[0] = aCoverage0; + iCoverage[1] = aCoverage1; + iCoverage[2] = aCoverage2; + iCoverage[3] = aCoverage3; + } + +/** Set the minimum typeface size. + +This is the smallest size that can be drawn legibly. + +@param aSize Sets the minimum typeface size (in pixels). +@see MinSizeInPixels() */ +inline void TOpenFontFaceAttrib::SetMinSizeInPixels(TInt aSize) + { + iMinSizeInPixels = aSize; + } + +/** Equality operator. + +Compares this and another set of font attributes, including the coverage, +the family name, the local full name, the local family name, and the minimum +size in pixels. + +@param aAttrib Contains the font attributes and names to compare. +@return ETrue if all values are equal, EFalse if not. */ +inline TBool TOpenFontFaceAttrib::operator==(const TOpenFontFaceAttrib& aAttrib) const + { + return TOpenFontFaceAttribBase::operator==(aAttrib) && + iFamilyName == aAttrib.iFamilyName && + iLocalFullName == aAttrib.iLocalFullName && + iLocalFamilyName == aAttrib.iLocalFamilyName && + iMinSizeInPixels == aAttrib.iMinSizeInPixels; + } + +/** Sets the bold attribute. + +@param aBold The bold attribute takes this value: ETrue or EFalse. */ +inline void TOpenFontFaceAttribBase::SetBold(TBool aBold) + { + if (aBold) + iStyle |= EBold; + else + iStyle &= ~EBold; + } + +/** Sets the italic attribute. + +@param aItalic The italic attribute takes this value ETrue or EFalse. */ +inline void TOpenFontFaceAttribBase::SetItalic(TBool aItalic) + { + if (aItalic) + iStyle |= EItalic; + else + iStyle &= ~EItalic; + } + +/** Sets the serif attribute. + +@param aSerif The serif attribute takes this value ETrue or EFalse. */ +inline void TOpenFontFaceAttribBase::SetSerif(TBool aSerif) + { + if (aSerif) + iStyle |= ESerif; + else + iStyle &= ~ESerif; + } + +/** Sets the mono-width attribute. + +@param aMonoWidth The mono-width attribute takes this value: ETrue or EFalse. */ +inline void TOpenFontFaceAttribBase::SetMonoWidth(TBool aMonoWidth) + { + if (aMonoWidth) + iStyle |= EMonoWidth; + else + iStyle &= ~EMonoWidth; + } + +/** Equality operator. + +Compares this and a specified set of font attributes, including the coverage +and the typeface name. + +In version 6.1, and earlier, the return value was TInt. + +@param aAttrib The font attributes to compare. This is an object of TOpenFontFaceAttribBase +or of a derived class. +@return ETrue if the values are equal. */ +inline TBool TOpenFontFaceAttribBase::operator==(const TOpenFontFaceAttribBase& aAttrib) const + { + return iStyle == aAttrib.iStyle && + iCoverage[0] == aAttrib.iCoverage[0] && + iCoverage[1] == aAttrib.iCoverage[1] && + iCoverage[2] == aAttrib.iCoverage[2] && + iCoverage[3] == aAttrib.iCoverage[3] && + iName.CompareF(aAttrib.iName) == 0; + } + +/** Compares this and another open font specification. Compares all the properties +of the two fonts. +@publishedAll +@released +@param aFontSpec The open font specification to compare with this one. +@return ETrue if all values are equal, EFalse if not. +*/ +inline TBool TOpenFontSpec::operator==(const TOpenFontSpec& aOpenFontSpec) const + { + return + iHeight == aOpenFontSpec.iHeight && + iWidthFactor == aOpenFontSpec.iWidthFactor && + iSlantFactor == aOpenFontSpec.iSlantFactor && + iBitmapType == aOpenFontSpec.iBitmapType && + iEffects == aOpenFontSpec.iEffects && + iSymbol == aOpenFontSpec.iSymbol && + iPrintPosition == aOpenFontSpec.iPrintPosition && + TOpenFontFaceAttribBase::operator==(aOpenFontSpec); + } + +/** Gets the height of the font. + +@return The height of the font, in pixels or twips. +@see SetHeight() */ +inline TInt TOpenFontSpec::Height() const + { + return iHeight; + } + +/** Gets the algorithmic width factor. + +@return The algorithmic width factor as a 16.16 fixed-point number. +@see SetWidthFactor() */ +inline TInt32 TOpenFontSpec::WidthFactor() const + { + return iWidthFactor; + } + +/** Gets the algorithmic slant factor. + +@return The algorithmic slant factor as a 16.16 fixed-point number. +@see SetSlantFactor() */ +inline TInt32 TOpenFontSpec::SlantFactor() const + { + return iSlantFactor; + } + +/** Gets the anti-aliasing setting for the font, as set by SetBitmapType(). + +@return Indicates whether or not the font should be drawn using anti-aliasing. */ +inline TGlyphBitmapType TOpenFontSpec::BitmapType() const + { + return (TGlyphBitmapType)iBitmapType; + } + +/** Gets the font effects flags. +Because the flags encoded in the Effects are anonymous, the return value should only + be tested for the specific bits that are of interest, and never tested as a whole. +@publishedAll +@released +@return The font effects flags. +@see TOpenFontSpec::SetEffects() +*/ +inline TUint32 TOpenFontSpec::Effects() const + { + return iEffects; + } + +/** Gets the print position. + +@return The print position. */ +inline TFontPrintPosition TOpenFontSpec::PrintPosition() const + { + return iPrintPosition; + } + +/** Sets the font's height. + +@param aHeight The font's height, in pixels or twips. +@see Height() */ +inline void TOpenFontSpec::SetHeight(TInt aHeight) + { + iHeight = aHeight; + } + +/** Sets the algorithmic width factor. + +The width factor is multiplied by the pixel's x position to get the new position, +causing characters to become wider or narrower. A width factor of 1 (65536 +in 16.16 fixed-point number format) should be used if the character width +is not to be changed. + +@param aWidthFactor The algorithmic width factor as a 16.16 fixed-point number. +@see WidthFactor() */ +inline void TOpenFontSpec::SetWidthFactor(TInt32 aWidthFactor) + { + iWidthFactor = aWidthFactor; + } + +/** Sets the algorithmic slant factor. + +Note: The slant factor is used to create an italic effect for characters which +do not have an italic glyph in the typeface. When slanting is active, pixel x +co-ordinates are shifted by a factor relative to the y co-ordinate (i.e. x += x + y x slant factor). + +The slant factor is a 32 bit, 16.16 fixed-point number. This means that the +first 16 bits are treated as a whole number, and the second 16 as the fractional +part. e.g. if aSlantFactor=0, there is no slant. If aSlantFactor=65536 this +is equivalent to an integer slant value of 1, which causes a 45 degree slant +on the character. + +@param aSlantFactor The slant factor as a 16.16 fixed-point number. +@see SlantFactor() */ +inline void TOpenFontSpec::SetSlantFactor(TInt32 aSlantFactor) + { + iSlantFactor = aSlantFactor; + } + +/** Sets whether the font should be drawn using anti-aliasing. If set, this value +overrides the default setting (set by CFbsTypefaceStore::SetDefaultBitmapType()) +for this font. + +Anti-aliasing can only be used for scalable fonts. There is currently no anti-aliasing +support for bitmapped fonts. + +@param aBitmapType Indicates whether or not the font should be drawn using +anti-aliasing. */ +inline void TOpenFontSpec::SetBitmapType(TGlyphBitmapType aBitmapType) + { + iBitmapType = aBitmapType; + } + +/** Sets the font effects flags. +Prior to calling this routine, the value from Effects() should be read, + and its flags modified as required, before passing them back in. +@publishedAll +@released +@param aEffect The font effects flags to be set. +@see TOpenFontSpec::Effects() +*/ +inline void TOpenFontSpec::SetEffects(TUint32 aEffects) + { + iEffects = aEffects; + } + +/** Gets the font file's UID. + +@return The uid of the file. */ +inline TUid COpenFontFile::Uid() const + { + return iUid; + } + +/** Gets the full path and filename of the font file + +This is the filename that was passed to the constructor when the object is +created. + +@return The filename of the font file. */ +inline const TDesC& COpenFontFile::FileName() const + { + return iFileName; + } + +/** Gets the typeface at a specified index in the typeface attribute array. + +@param aFaceIndex The index of the typeface for which the attributes are required. +@return The attributes of the typeface with the specified index. +@see AddFaceL() +@see FaceCount() */ +inline const TOpenFontFaceAttrib& COpenFontFile::FaceAttrib(TInt aFaceIndex) const + { + return iFaceAttrib[aFaceIndex]; + } + +/** Gets the number of typefaces in the typeface attributes array. + +This is the number of typefaces in the font file: the attributes for each +typeface should be loaded into the array when the derived object is constructed. + +@return The number of typefaces in the font file. +@see AddFaceL() +@see FaceAttrib() */ +inline TInt COpenFontFile::FaceCount() const + { + return iFaceAttrib.Count(); + } + +/** Increments a reference count by one. + +@see DecRefCount() */ +inline void COpenFontFile::IncRefCount() + { + iRefCount++; + } + +/** Decrement a reference count by one. + +@return ETrue if the reference count has reached zero (i.e. is less than or +equal to zero); EFalse if the reference count has not yet reached zero (i.e. +is positive). +@see IncRefCount() */ +inline TBool COpenFontFile::DecRefCount() + { + iRefCount--; + return iRefCount <= 0; + } + +/** Default C++ constructor. */ +inline COpenFontRasterizerContext::COpenFontRasterizerContext(): + iGlyphData(NULL) + { + } + +/** Start writing the glyph data. + +Use this function to initialise the buffer to which the glyph bitmap is to +be written. Call WriteGlyphBit() to add bits to the buffer. + +@param aGlyphData A pointer to the glyph data. */ +inline void COpenFontRasterizerContext::StartGlyph(TOpenFontGlyphData* aGlyphData) + { + aGlyphData->SetPointersToInternalBuffers(); + iGlyphData = aGlyphData; + iGlyphDataStart = iGlyphDataPtr = aGlyphData->BufferStart(); + // Allow 4 extra bytes; BITGDI requires this. + iGlyphDataEnd = aGlyphData->BufferEnd() - 4; + iGlyphBit = 1; + *iGlyphDataPtr = 0; + iBytesNeeded = 1; + iOverflow = FALSE; + } + +/** Writes a bit to the glyph buffer. + +Before calling this function you should first call StartGlyph(). + +@param aBit The bit to be added to the buffer. */ +inline void COpenFontRasterizerContext::WriteGlyphBit(TInt aBit) + { + if (aBit && !iOverflow) + *iGlyphDataPtr |= iGlyphBit; + iGlyphBit <<= 1; + if (iGlyphBit == 256) + { + iGlyphBit = 1; + iBytesNeeded++; + if (++iGlyphDataPtr < iGlyphDataEnd) + *iGlyphDataPtr = 0; + else + iOverflow = TRUE; + } + } + +/** Writes a byte to the glyph buffer. + +Before calling this function you should first call StartGlyph(). + +@param aByte The byte to be added to the buffer. */ +inline void COpenFontRasterizerContext::WriteGlyphByte(TInt aByte) + { + if (iGlyphDataPtr < iGlyphDataEnd) + *iGlyphDataPtr++ = (TUint8)aByte; + else + iOverflow = TRUE; + iBytesNeeded++; + } + +/** Completes writing glyph data. + +Use this function to complete writing the glyph bitmap to the buffer. Call +it after adding all necessary bits using WriteGlyphBit(). */ +inline void COpenFontRasterizerContext::EndGlyph() + { + // Add 4 bytes to the data size; some BITGDI functions require this. + iGlyphData->SetBytesNeeded(iBytesNeeded + 4); + iGlyphData = NULL; + } + +/** Tests whether the bitmap buffer is large enough to hold the bitmap. + +@return ETrue if the bitmap will overflow its buffer, otherwise EFalse. */ +inline TBool TOpenFontGlyphData::Overflow() const + { + return iBytesNeeded > iBitmapBufferSize; + } + +/** Gets the number of bytes needed to store the glyph bitmap. + +@return The number of bytes needed to store the glyph bitmap. +@see SetBytesNeeded() */ +inline TInt TOpenFontGlyphData::BytesNeeded() const + { + return iBytesNeeded; + } + +/** Gets a constant pointer descriptor containing the bitmap this object +represents. + +@return Pointer descriptor for the glyph. */ +inline TPtrC8 TOpenFontGlyphData::Bitmap() const + { + return TPtrC8(iBitmap,iBytesNeeded); + } + +/** Gets a pointer to the bitmap. + +This points either to the buffer used to write the bitmap when it is first +rasterized, or to the cache if the character was already rasterized. + +@return A pointer to the bitmap. */ +inline const TUint8* TOpenFontGlyphData::BitmapPointer() const + { + return iBitmap; + } + +/** Gets the character's metrics. + +@return The character's open font metrics. */ +inline const TOpenFontCharMetrics* TOpenFontGlyphData::Metrics() const + { + return iMetrics; + } + +/** Gets a pointer to the start of the bitmap buffer. + +@return A pointer to the start of the bitmap buffer. */ +inline TUint8* TOpenFontGlyphData::BufferStart() + { + return iBitmapBuffer; + } + +/** Gets a pointer to the end of the bitmap buffer. + +@return A pointer to the end of the bitmap buffer. */ +inline TUint8* TOpenFontGlyphData::BufferEnd() + { + return iBitmapBuffer + iBitmapBufferSize; + } + +/** Sets the number of bytes needed to store the glyph bitmap. + +@param aBytes The number of bytes needed to store the glyph bitmap. +@see BytesNeeded() */ +inline void TOpenFontGlyphData::SetBytesNeeded(TInt aBytes) + { + iBytesNeeded = aBytes; + } + +/** Sets the pointer to the bitmap buffer. + +@param aBitmap The pointer to the bitmap buffer. */ +inline void TOpenFontGlyphData::SetBitmapPointer(const TUint8* aBitmap) + { + iBitmap = aBitmap; + } + +/** Sets the character's metrics, passing a pointer to a TOpenFontCharMetrics object. + +@param aMetrics A pointer to the character's open font character metrics. */ +inline void TOpenFontGlyphData::SetMetricsPointer(const TOpenFontCharMetrics* aMetrics) + { + iMetrics = aMetrics; + } + +/** Sets the bitmap and metrics pointers to point to the internal buffers. + +The alternative is that the pointers point to the cache of metrics and bitmaps +that have already been rasterized. */ +inline void TOpenFontGlyphData::SetPointersToInternalBuffers() + { + iBitmap = iBitmapBuffer; + iMetrics = &iMetricsBuffer; + } + +/** Sets the character's metrics, passing a reference to a TOpenFontCharMetrics +object. + +@param aMetrics The character's open font character metrics. */ +inline void TOpenFontGlyphData::SetMetrics(TOpenFontCharMetrics& aMetrics) + { + iMetricsBuffer = aMetrics; + iMetrics = &iMetricsBuffer; + } + +/** Sets the glyph index. + +@param aGlyphIndex The glyph index. */ +inline void TOpenFontGlyphData::SetGlyphIndex(TInt aGlyphIndex) + { + iGlyphIndex = aGlyphIndex; + } + +/** Uses ECOM plug-in framework to instantiate the shaper factory interface +implementation given its implementation UID. + +@param aInterfaceImplUid The UID of the interface implementation required + +@return CShaperFactory* A pointer to a CShaperFactory object. */ +inline CShaperFactory* CShaperFactory::NewL(TUid aInterfaceImplUid) + { + return reinterpret_cast ( + REComSession::CreateImplementationL( + aInterfaceImplUid, + _FOFF(CShaperFactory, iDtor_ID_Key))); + } + +/** Default destructor */ +inline CShaperFactory::~CShaperFactory() +{ + REComSession::DestroyedImplementation(iDtor_ID_Key); +} + +#endif // __OPENFONT_H__