1 /*

     2 * Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 * A header for the open font system, which allows SymbianOS

    16 * to use fonts of arbitrary types, including TrueType/OpenType

    17 * and other outline font formats.

    18 *

    19 */

    20 

    21 

    22 #ifndef __OPENFONT_H__

    23 #define __OPENFONT_H__

    24 

    25 #include <e32base.h>

    26 #include <gdi.h>

    27 #include <ecom/ecom.h>

    28 

    29 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

    30 #include <linkedfonts.h>

    31 #include <graphics/openfontconstants.h>

    32 #include <graphics/openfontrasterizer.h>

    33 #include <openfontlinkedtypefaceelementspec.h>

    34 #include <graphics/openfontlinkedtypefacespecification.h>

    35 #include <graphics/openfontlinkedtypefaceextension.h>

    36 #endif

    37 

    38 class CFont;

    39 class COpenFontFile;

    40 class COpenFontGlyph;

    41 class COpenFontGlyphCache;

    42 class COpenFontGlyphTreeEntry;

    43 class COpenFontPositioner;

    44 class COpenFontSessionCache;

    45 class COpenFontSessionCacheList;

    46 class RFs;

    47 class TCharacterMetrics;

    48 class TFontSpec;

    49 class TOpenFontFaceAttrib;

    50 class CFontStore;

    51 class TOpenFontFileData;

    52 class TShapeHeader;

    53 class CBitmapFont;

    54 class CShaperFactory;

    55 class CShaper;

    56 class TShapeHeader;

    57 class TFontShapeFunctionParameters;

    58 class TFontShapeDeleteFunctionParameters;

    59 class RShapeInfo;

    60 class TShapeMessageParameters;

    61 class CRasterizerLinkedTypefaceSpecification;

    62 class TLinkedTypefaceSpecificationArgs;

    63 

    64 /**

    65 Supplied to COpenFont::ExtendedInterface() to access the extended

    66 API interface MOpenFontShapingExtension.

    67 

    68 @see	COpenFont::ExtendedInterface()

    69 @see	MOpenFontShapingExtension

    70 @publishedAll

    71 @released

    72 */

    73 const TUid KUidOpenFontShapingExtension = {0x10274DB9};

    74 

    75 /**

    76 Supplied to COpenFont::ExtendedInterface() to access the extended

    77 API interface MOpenFontTrueTypeExtension.

    78 

    79 @see	COpenFont::ExtendedInterface()

    80 @see	MOpenFontTrueTypeExtension

    81 @publishedAll

    82 @released

    83 */

    84 const TUid KUidOpenFontTrueTypeExtension = {0x1027553E};

    85 const TUid KUidOpenFontGlyphOutlineExtension = {0x102872CE};

    86 

    87 /**

    88 Supplied to CShaper::ExtendedInterface() to get the language and script

    89 code with which the current shaper is instatsiated.

    90 @see	CShaper::ExtendedInterface()

    91 @publishedAll

    92 @released

    93 */

    94 const TUid KUidShaperGetScript = {0x20009966};

    95 const TUid KUidShaperGetLang = {0x20009967};

    96 

    97 /**

    98 Font metrics.

    99 

   100 @see	CFbsFont::GetFontMetrics()

   101 @publishedAll

   102 @released

   103 */

   104 class TOpenFontMetrics

   105 	{

   106 public:

   107 	inline TOpenFontMetrics();

   108 	IMPORT_C TOpenFontMetrics(const CFont* aFont);

   109 	inline TInt Size() const;

   110 	inline TInt Ascent() const;

   111 	inline TInt Descent() const;

   112 	inline TInt MaxHeight() const;

   113 	inline TInt MaxDepth() const;

   114 	inline TInt MaxWidth() const;

   115 	inline void SetSize(TInt aSize);

   116 	inline void SetAscent(TInt aAscent);

   117 	inline void SetDescent(TInt aDescent);

   118 	inline void SetMaxHeight(TInt aMaxHeight);

   119 	inline void SetMaxDepth(TInt aMaxDepth);

   120 	inline void SetMaxWidth(TInt aMaxWidth);

   121 	/** WARNING: Function for internal and partner use ONLY. Compatibility is not guaranteed in future releases.*/

   122 	IMPORT_C void SetBaselineCorrection(TInt aBaselineCorrection);

   123 	IMPORT_C TInt BaselineCorrection();

   124 private:

   125 	TInt16 iDesignHeight;	// size of the font ('pointsize' in pixels)

   126 	TInt16 iAscent;			// typographic ascent

   127 	TInt16 iDescent;		// typographic descent

   128 	TInt16 iMaxHeight;		// maximum height of a character; may be greater than iAscent

   129 	TInt16 iMaxDepth;		// maximum depth of a character; may be greater than iDescent

   130 	TInt16 iMaxWidth;		// maximum width of a character

   131 	TInt16 iBaselineCorrection;

   132 	TInt16 iReserved;

   133 	};

   134 

   135 

   136 /**

   137 Character metrics  includes more information than TCharacterMetrics.

   138 

   139 Character metrics allow characters to be placed horizontally or vertically. 

   140 The character metrics encapsulated by this class are: Height, Width, Horizontal 

   141 Bearing X, Horizontal Bearing Y, Horizontal Advance, Vertical Bearing X, 

   142 Vertical Bearing Y, and Vertical Advance. Their meanings are described in the 

   143 associated setter and getter functions.

   144 

   145 Note : 

   146 

   147 Vertical drawing (in the sense of characters drawn with horizontal baselines, 

   148 but in a vertical line) is not yet supported by Symbian OS.

   149 

   150 @see	CFont::GetCharacterData()

   151 @see	CFbsFont::GetCharacterData() 

   152 @publishedAll

   153 @released

   154 */

   155 class TOpenFontCharMetrics

   156 	{

   157 public:

   158 	enum TUninitialized { EUninitialized };

   159 public:

   160 	/** Default constructor initializes all members to 0. */

   161 	inline TOpenFontCharMetrics();

   162 

   163 	/** Constructor that does not initialize any members. */

   164 	TOpenFontCharMetrics(TUninitialized) {}

   165 	IMPORT_C TOpenFontCharMetrics(const TCharacterMetrics& aMetrics);

   166 	IMPORT_C TBool GetTCharacterMetrics(TCharacterMetrics& aMetrics) const;

   167 	inline TInt Width() const;

   168 	inline TInt Height() const;

   169 	inline TInt HorizBearingX() const;

   170 	inline TInt HorizBearingY() const;

   171 	inline TInt HorizAdvance() const;

   172 	inline TInt VertBearingX() const;

   173 	inline TInt VertBearingY() const;

   174 	inline TInt VertAdvance() const;

   175 	inline void GetHorizBounds(TRect& aBounds) const;

   176 	inline void GetVertBounds(TRect& aBounds) const;

   177 	inline void SetWidth(TInt aWidth);

   178 	inline void SetHeight(TInt aHeight);

   179 	inline void SetHorizBearingX(TInt aHorizBearingX);

   180 	inline void SetHorizBearingY(TInt aHorizBearingY);

   181 	inline void SetHorizAdvance(TInt aHorizAdvance);

   182 	inline void SetVertBearingX(TInt aVertBearingX);

   183 	inline void SetVertBearingY(TInt aVertBearingY);

   184 	inline void SetVertAdvance(TInt aVertAdvance);

   185 	IMPORT_C void  SetGlyphType(TGlyphBitmapType);

   186 	IMPORT_C TGlyphBitmapType GlyphType() const;

   187 private:

   188 	TInt16 iWidth;			// width of the glyph

   189 	TInt16 iHeight;			// height of the glyph

   190 	TInt16 iHorizBearingX;	// x component of horizontal bearing

   191 	TInt16 iHorizBearingY;	// y component of horizontal bearing

   192 	TInt16 iHorizAdvance;	// horizontal advance

   193 	TInt16 iVertBearingX;	// x component of vertical bearing

   194 	TInt16 iVertBearingY;	// y component of vertical bearing

   195 	TInt16 iVertAdvance;	// vertical advance

   196 	TUint16  iGlyphBitmapType;// Glyph bitmap type; TGlyphBitmapType

   197 	TInt16 iReserved;

   198 	};

   199 

   200 

   201 /**

   202 Font glyph data.

   203 

   204 Objects of this type are used by rasterizers to supply glyph data to font 

   205 and bitmap server clients. Unless you are writing a rasterizer you will not 

   206 need to use an object of this type.

   207 

   208 The object cannot be constructed and destroyed by normal means. It resides 

   209 on a specified heap. It is created by New() and deleted by RHeap::Free().

   210 

   211 @see	COpenFont::RasterizeL()

   212 @publishedAll

   213 @released

   214 */

   215 class TOpenFontGlyphData

   216 	{

   217 public:

   218 	IMPORT_C static TOpenFontGlyphData* New(RHeap* aHeap,TInt aBufferSize);

   219 	inline TBool Overflow() const;

   220 	inline TInt BytesNeeded() const;

   221 	inline TPtrC8 Bitmap() const;

   222 	inline const TUint8* BitmapPointer() const;

   223 	inline const TOpenFontCharMetrics* Metrics() const;

   224 	inline TInt GlyphIndex() const;

   225 	inline TUint8* BufferStart();

   226 	inline TUint8* BufferEnd();

   227 	inline void SetBytesNeeded(TInt aBytes);

   228 	inline void SetBitmapPointer(const TUint8* aBitmap);

   229 	inline void SetMetricsPointer(const TOpenFontCharMetrics* aMetrics);

   230 	inline void SetPointersToInternalBuffers();

   231 	inline void SetMetrics(TOpenFontCharMetrics& aMetrics);

   232 	inline void SetGlyphIndex(TInt aGlyphIndex);

   233 private:

   234 	/*

   235 	Prevent construction and destruction by normal means; the object resides 

   236 	on a specified heap and is created by New and deleted by RHeap::Free.

   237 	*/

   238 	TOpenFontGlyphData();

   239 	~TOpenFontGlyphData();

   240 private:

   241 	TInt iBitmapBufferSize;					// size of the buffer in bytes

   242 	TInt iBytesNeeded;						// bytes needed for the bitmap

   243 	TOpenFontCharMetrics iMetricsBuffer;	// the metrics

   244 	const TUint8* iBitmap;					// pointer to the bitmap; points either to iBitmapBuffer or to

   245 											// the cache if the character was already rasterized

   246 	const TOpenFontCharMetrics* iMetrics;	// pointer to the metrics; points either to iMetricsBuffer or to

   247 											// the cache if the character was already rasterized

   248 	TInt iGlyphIndex;						// the glyph index

   249 	TAny* iReserved;						// unused; for future expansion

   250 	TUint8 iBitmapBuffer[1];				// buffer used to write the bitmap when it is first rasterized; this

   251 											// is actually of size iBitmapBufferSize.

   252 	};

   253 

   254 class COpenFontGlyph;

   255 /**

   256 Open Font System font abstract base class.

   257 

   258 Derive a class from this class to represent an instance of a typeface at a 

   259 particular size, provide bitmaps of the glyphs, and determine whether 

   260 characters exist in the typeface.

   261 

   262 Writing derived classes construction: 

   263 

   264 You must call the constructor of this class when creating your derived object, 

   265 passing the arguments aHeap and aSessionCacheList supplied to 

   266 COpenFontFile::GetNearestFontInPixelsL(), and the address of the COpenFontFile 

   267 object that creates the object as aFile.

   268 

   269 The derived object must be created on the shared heap aHeap because it is 

   270 shared by several processes: the font and bitmap server and its clients. 

   271 To do this, use aHeap->AllocL() to obtain memory, then construct in place 

   272 using a placement argument to new.

   273 

   274 Derived classes must implement the pure virtual function RasterizeL(). 

   275 Information about this function is provided in the function definition below. 

   276 

   277 Information about deriving from this class is also provided in the API guide.

   278 

   279 @see	COpenFontFile::GetNearestFontInPixelsL()

   280 @publishedAll

   281 @released

   282 */

   283 class COpenFont: public CBase

   284 	{

   285 public:

   286 	/** Creates a bitmap for the specified Unicode character.

   287 

   288 	Implementations of this function should put the bitmap in 

   289 	aGlyphData->iBitmapBuffer, and the character metrics are placed in 

   290 	aGlyphData->iMetricsBuffer. The other parts of aGlyphData should be left 

   291 	alone. 

   292 

   293 	There are a number of strategies for achieving this, e.g. pass the 

   294 	rasterization task all the way up to the rasterizer engine. These are 

   295 	discussed in the API guide.

   296 

   297 	At present you must write the bitmap in the Symbian platform's 

   298 	run-length-encoded format. This is a packed binary format starting on a 

   299 	byte boundary and made up of a number of sections. Each section starts 

   300 	with a five-bit header. If the first bit of the header is 0 the next four 

   301 	bits are a repeat count, starting with the least significant bit, and a 

   302 	single row of bits (the number of bits in a row is specified by 

   303 	aGlyphData->iMetricsBuffer.Width()) follows. If the first bit of the header 

   304 	is 1 the next four bits are a count of non-repeating rows, again starting 

   305 	with the least significant bit, and that many rows of bits follow.

   306 

   307 	@param aCode The character code of the Unicode character for which the 

   308 	bitmap is required.

   309 	@param aGlyphData On return, contains a pointer to a TOpenFontGlyphData 

   310 	containing the character's bitmap and metrics. */

   311 	virtual void RasterizeL(TInt aCode,TOpenFontGlyphData* aGlyphData) = 0;

   312 	IMPORT_C virtual void ExtendedInterface(TUid aUid, TAny*& aParam);

   313 	IMPORT_C COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,COpenFontFile* aFile);

   314 	IMPORT_C COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,COpenFontFile* aFile,TInt aFaceIndex);

   315 	IMPORT_C ~COpenFont();

   316 	IMPORT_C void operator delete(TAny*);

   317 	inline const TOpenFontMetrics& Metrics() const;

   318 	inline const TOpenFontFaceAttrib* FaceAttrib() const;

   319 	inline COpenFontFile* File() const;

   320 	inline TInt FaceIndex() const;

   321 	inline TBool CharacterNeedsToBeRasterized(TInt aSessionHandle,TInt aCode) const;

   322 	void SetShaper(CShaper* aShaper);

   323 	CShaper* GetShaper();

   324 	TBool HasShaper() const;

   325 	TShapeHeader* GetShapedData(TInt aSessionHandle,TFontShapeFunctionParameters* aParams);

   326 	TShapeHeader* InsertShapedDataIntoCache(TInt aSessionHandle,TFontShapeFunctionParameters* aParams, TShapeHeader* aShapeHeader);

   327 	TInt FreeShaperCacheMemory(TInt aBytesNeeded);

   328 	TInt DecrementCachedRefCount(TInt aSessionHandle,TShapeHeader* aShapeHeader,TBool aResetAll=EFalse);

   329 	TBool Rasterize(TInt aSessionHandle,TInt aCode,TOpenFontGlyphData* aGlyphData);

   330 	TBool HasCharacterL(TInt aCode) const;

   331 	TBool GetCharacterData(TInt aSessionHandle,TInt aCode,const TOpenFontCharMetrics*& aMetrics,const TUint8*& aBitmap) const;

   332 	void OnFileDeleted();

   333 	COpenFontGlyphCache* GetGlyphCache();

   334 	inline TInt FontCapitalAscent() const;

   335 	inline TInt FontMaxAscent() const;

   336 	inline TInt FontStandardDescent() const;

   337 	inline TInt FontMaxDescent() const;

   338 	inline TInt FontLineGap() const;

   339 	inline TInt FontMaxHeight() const;

   340 	void DeleteShaper() const;

   341 	TInt GetFontTable(TUint32 aTag, TAny*& aTableContent, TInt& aLength);

   342 	TInt GetGlyphOutline(TUint aCode, TBool aHinted, TAny*& aOutline, TInt& aLength);

   343 	

   344 protected:	

   345 	/** WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

   346 	*/

   347 	TInt PointerToThisOffset(const TAny* aAny);

   348 	/** WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

   349 	*/

   350 	TAny* ThisOffsetToPointer(const TInt aOffset);

   351 		

   352 protected:

   353 	RHeap* iHeap;

   354 	TOpenFontMetrics iMetrics;

   355 private:

   356 	/** The shaper for performing complex character positioning and

   357 	substitution, if available. Null otherwise.

   358 	

   359 	WARNING: Member variable for internal use ONLY. Compatibility is not guaranteed in future releases. Please access using the provided get/set APIs only. 

   360     */

   361 	CShaper* iShaper;

   362 

   363 protected:

   364 	/** The positive distance in pixels from the baseline to

   365 		the top of an ANSI capital (whether or not there are

   366 		ANSI capitals in the font) */

   367 	TInt iFontCapitalAscent;

   368 	/** The positive distance in pixels from the baseline to

   369 		the top of the highest pre-composed glyph in the font */

   370 	TInt iFontMaxAscent;

   371 	/** The positive distance in pixels from the baseline to

   372 		the bottom of the lowest ANSI descender (whether or

   373 		not there are ANSI chars in the font)*/

   374 	TInt iFontStandardDescent;

   375 	/** The positive distance in pixels from the baseline to

   376 		the bottom of the lowest pre-composed glyph in the font */

   377 	TInt iFontMaxDescent;

   378 	/** The recommended baseline to baseline gap for successive

   379 		lines of text in the font */

   380 	TInt iFontLineGap;

   381 private:

   382 	const COpenFontGlyph* Glyph(TInt aSessionHandle,TInt aCode) const;

   383 protected:

   384 

   385 	/** WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

   386 	*/

   387 	const COpenFontGlyph* FontCacheGlyph(TInt aCode,TInt*& aNode);

   388 	const COpenFontGlyph* FontCacheGlyph(TInt aCode);

   389 	

   390 	void SetGlyphCache(COpenFontGlyphCache* aGlyphCache);

   391 	

   392 private:

   393 	const COpenFontGlyph* SessionCacheGlyph(RHeap* aHeap,TInt aSessionHandle,TInt aCode,

   394 											COpenFontSessionCache*& aCache,TInt& aIndex,TBool aCreate) const;

   395 	void RasterizeHelperL(TInt aCode,TOpenFontGlyphData* aGlyphData,TOpenFontGlyphData*& aTempGlyphData);

   396 

   397 	COpenFontSessionCacheList* SessionCacheList()const;

   398 	

   399     void SetSessionCacheList(COpenFontSessionCacheList* aSessionCacheList);

   400     

   401     void SetFile(COpenFontFile* aFile);

   402 private:

   403     

   404     // Offset from the address of the file used by this font.

   405     // If the file has been deleted or cannot be used, the offest will be zero.

   406     TInt iFileOffset;

   407     

   408 	TInt iFaceIndex;										// index of the face in the font file

   409 protected:

   410     /**

   411     WARNING: Compatibility is not guaranteed in future releases. Please use the provided APIs only.

   412     Offset from the address of this font of the per-font glyph cache which is owned by the font

   413     @internalTechnology

   414     */  

   415     TInt iGlyphCacheOffset;

   416 private:

   417     // Offset from the address of this font of the list of per-session glyph

   418     // caches which are owned by CFontStore

   419     TInt iSessionCacheListOffset;

   420 

   421 	TAny* iReserved; // unused; for future expansion

   422 	};

   423 

   424 /** Open Font System Extension Interface abstract base class.

   425 

   426 COpenFont derivers should also derive from this interface to enable complex

   427 font "shaping".

   428 

   429 This interface should be returned by the overridden

   430 COpenFont::ExtendedInterface function when KUidOpenFontShapingExtension is

   431 supplied as the UID.

   432 

   433 @see	COpenFont

   434 @see	KUidOpenFontShapingExtension 

   435 @publishedAll

   436 @released

   437 */

   438 class MOpenFontShapingExtension

   439 	{

   440 public:

   441 	/** Various font metrics. */

   442 	class TExtensionFontMetrics

   443 		{

   444 	public:

   445 		/** The number of font design units per em. */

   446 		TInt iUnitsPerEm;

   447 		/** The width of the font's em square in pixels. */

   448 		TReal iXPixelsPerEm;

   449 		/** The height of the font's em square in pixels. */

   450 		TReal iYPixelsPerEm;

   451 		/** The horizontal scaling factor from the font's transform;

   452 		the number of horizontal pixels per font unit. */

   453 		TReal iXScaleFactor;

   454 		/** The vertical scaling factor from the font's transform;

   455 		the number of vertical pixels per font unit. */

   456 		TReal iYScaleFactor;

   457 	private:

   458 		/** Reserved for future expansion. */

   459 		TInt iReserved[4];

   460 		};

   461 

   462 	/** Creates a bitmap for the specified Glyph code.

   463 

   464 	Implementations of this function should put the bitmap in

   465 	aGlyphData->iBitmapBuffer, and the character metrics are placed in

   466 	aGlyphData->iMetricsBuffer. The other parts of aGlyphData should be left

   467 	alone.

   468 

   469 	This function provides the same functionality as the

   470 	COpenFont::RasterizeL() except that the glyph code is supplied rather than

   471 	the unicode.

   472 

   473 	For more information:

   474 	@see	COpenFont::RasterizeL()

   475 

   476 	@param	aCode		The glyph code of the character for which the bitmap is required.

   477 	@param	aGlyphData	The function puts its output here.

   478 	*/

   479 	virtual void RasterizeGlyphL(TInt aCode,TOpenFontGlyphData* aGlyphData) = 0;

   480 

   481 	/** Maps a character to a glyph index.

   482 	@param aUnicodeCharacter Unicode character code to be mapped.

   483 	@return Glyph code corresponding to aUnicodeCharacter. */

   484 	virtual TInt GlyphIndex(TInt aUnicodeCharacter) const = 0;

   485 

   486 	/** Returns the hinted pixel coordinates of a particular point in the

   487 	outline of the given glyph.

   488 	@param aGlyphPoint The glyph index.

   489 	@param aPointNumber The number of the point.

   490 	@param aX Returns the point's X pixel value.

   491 	@param aY Returns the point's Y pixel value.

   492 	@return True on success, false otherwise. */

   493 	virtual TBool GlyphPointInHintedPixels(TInt aGlyphIndex, TInt aPointNumber,

   494 		TReal& aX, TReal& aY) const = 0;

   495 

   496 	/** Returns the coordinates of a particular (unhinted) point in the outline

   497 	of the given glyph in font units.

   498 	@param aGlyphPoint The glyph index.

   499 	@param aPointNumber The number of the point.

   500 	@param aX Returns the point's X co-ordinate in font units.

   501 	@param aY Returns the point's Y co-ordinate in font units.

   502 	@return True on success, false otherwise. */

   503 	virtual TBool GlyphPointInFontUnits(TInt aGlyphIndex, TInt aPointNumber,

   504 		TInt& aX, TInt& aY) const = 0;

   505 

   506 	/** Returns font metrics.

   507 	@param aOut Font metrics returned. */

   508 	virtual void GetExtensionFontMetrics(TExtensionFontMetrics& aOut) = 0;

   509 	};

   510 

   511 /** TrueType extension for Open Fonts.

   512 

   513 If an open font is able to load TrueType or OpenType tables it should derive

   514 from this class.

   515 

   516 This class will be used by 

   517 

   518 This interface should be returned by the overridden

   519 COpenFont::ExtendedInterface function when KUidOpenFontTrueTypeExtension is

   520 supplied as the UID.

   521 @see	KUidOpenFontTrueTypeExtension

   522 @publishedAll

   523 @released

   524 */

   525 class MOpenFontTrueTypeExtension

   526 	{

   527 public:

   528 	/** Returns the specified table. The table need not be released by the

   529 	caller, so the deriver is responsible for ensuring that any memory

   530 	allocated is ultimately cleaned up. The caller must not delete or modify

   531 	the data returned.

   532 	@param aError

   533 		Returns KErrNone if successful or one of the system-wide error codes if

   534 		unsuccessful. Returns KErrNotSupported if the table does not exist in

   535 		the font file.

   536 	@param aTag

   537 		The tag of the table, with the first character in the most significant

   538 		byte. For example, the "vhea" table is obtained by passing in 'v'<<24 |

   539 		'h'<<16 | 'e'<<8 | 'a'.

   540 	@param aLength

   541 		The length of the table in bytes that has been returned or 0 if

   542 		unsuccessful.

   543 	@return The table, if successful.

   544 	@see ReleaseTrueTypeTable */

   545 	virtual TAny* GetTrueTypeTable(TInt& aError, TUint32 aTag, TInt* aLength) = 0;

   546 	/** Releases a table obtained by GetTrueTypeTable. The caller must not

   547 	use the table after this call.

   548 	@param aTable The table to be released.

   549 	@see GetTrueTypeTable */

   550 	virtual TInt ReleaseTrueTypeTable(TAny* aTable) = 0;

   551 	/** Determines if the font file has a particular table.

   552 	@param aTag The tag of the table as for GetTrueTypeTable.

   553 	@return True if the table exists in the font file, false otherwise.

   554 	@see GetTrueTypeTable */

   555 	virtual TBool HasTrueTypeTable(TUint32 aTag) = 0;

   556 	};

   557 

   558 class MOpenFontGlyphOutlineExtension 

   559     {

   560 public:

   561     virtual TInt GetGlyphOutline(TUint aCode, TBool aIsGlyphId, 

   562             TBool aHinted, TAny*& aOutline, TInt& aLength) = 0;

   563     };

   564 /** 

   565 Font attribute base class. 

   566 

   567 This class is not intended for user derivation.

   568 

   569 @see	TOpenFontFaceAttrib

   570 @see	TOpenFontSpec

   571 @publishedAll

   572 @released

   573 */

   574 class TOpenFontFaceAttribBase

   575 	{

   576 public:

   577 	inline TOpenFontFaceAttribBase();

   578 	inline TBool HasLatin() const;

   579 	inline TBool HasGreek() const;

   580 	inline TBool HasCyrillic() const;

   581 	inline TBool HasKana() const;

   582 	inline TBool HasHangul() const;

   583 	inline TBool HasCJK() const;

   584 	inline TBool IsSymbol() const;

   585 	inline TBool IsBold() const;

   586 	inline TBool IsItalic() const;

   587 	inline TBool IsSerif() const;

   588 	inline TBool IsMonoWidth() const;

   589 	inline TPtrC Name() const;

   590 	inline const TUint* Coverage() const;

   591 	inline void SetName(const TDesC& aName);

   592 	inline void SetCoverage(TUint aCoverage0,TUint aCoverage1 = 0,TUint aCoverage2 = 0,TUint aCoverage3 = 0);

   593 	inline void SetBold(TBool aBold);

   594 	inline void SetItalic(TBool aItalic);

   595 	inline void SetSerif(TBool aSerif);

   596 	inline void SetMonoWidth(TBool aMonoWidth);

   597 	inline TBool operator==(const TOpenFontFaceAttribBase& aAttrib) const;

   598 

   599 	// Unicode ranges for iCoverage[0] (see the TrueType documentation for other values which are not included)

   600 	enum

   601 		{

   602 		ELatinSet = 0x1,			// 0000-007F

   603 		EGreekSet = 0x80,			// 0370-03FF

   604 		ECyrillicSet = 0x200,		// 0400-04FF

   605 		EArmenianSet = 0x400,		// 0530-058F

   606 		EHebrewSet = 0x800,			// 0590-05FF

   607 		EArabicSet = 0x2000,		// 0600-06FF

   608 		EDevanagariSet = 0x8000,	// 0900-097F

   609 		EBengaliSet = 0x10000,		// 0980-09FF

   610 		EGurmukhiSet = 0x20000,		// 0A00-0A7F

   611 		EGujuratiSet = 0x40000,		// 0A80-0AFF

   612 		EOriyaSet = 0x80000,		// 0B00-0B7F

   613 		ETamilSet = 0x100000,		// 0B80-0BFF

   614 		ETeluguSet = 0x200000,		// 0C00-0C7F

   615 		EKannadaSet = 0x400000,		// 0C80-0CFF

   616 		EMalayalamSet = 0x800000,	// 0D00-0D7F

   617 		EThaiSet = 0x1000000,		// 0E00-0E7F

   618 		ELaoSet = 0x2000000,		// 0E80-0EFF

   619 		EGeorgianSet = 0x8000000,	// 10A0-10FF

   620 		EHangulJamoSet = 0x10000000,// 1100-11FF

   621 		};

   622 

   623 	// Unicode ranges for iCoverage[1]

   624 	enum

   625 		{

   626 		ESymbolSets = 0xFFFE,

   627 		EKanaSets = 0x60000,

   628 		EHangulSet = 0x100000,

   629 		ECJKSet = 0x8000000

   630 		};

   631 

   632 	// Attribute flags

   633 	enum

   634 		{

   635 		EBold = 0x1,			// weight > 500 in Windows terms

   636 		EItalic = 0x2,			// italic or oblique - any forward slant counts

   637 		ESerif = 0x4,			// characters have serifs

   638 		EMonoWidth = 0x8		// all characters are the same width

   639 		};

   640 

   641 	// Other constants

   642 	enum

   643 		{

   644 		ENameLength = 32		// we allow 32 but names that are compatible with old-style fonts are limited to 24

   645 		};

   646 protected:

   647 	TBufC<ENameLength> iName;				// the name of the typeface; whether this is the full name or family name

   648 											// or is in English or another language depends on the context

   649 	TUint iCoverage[4];						// bitmap of the character sets supported by the typeface;

   650 											// these are the same as the fields ulUnicodeRange1 .. ulUnicodeRange4

   651 											// in the OS/2 table in TrueType fonts

   652 	TInt iStyle;							// bold, italic serif, and mono-width

   653 	TInt32 iReserved;

   654 	};

   655 

   656 

   657 /** 

   658 Typeface attributes.

   659 

   660 These attributes include the name, family name, and supported scripts.

   661 

   662 @see	CFbsFont::GetFaceAttrib()

   663 @publishedAll

   664 @released

   665 */

   666 class TOpenFontFaceAttrib: public TOpenFontFaceAttribBase

   667 	{

   668 public:

   669 	inline TOpenFontFaceAttrib();

   670 	inline TBool operator==(const TOpenFontFaceAttrib& aAttrib) const;

   671 	inline TPtrC FullName() const;

   672 	inline TPtrC FamilyName() const;

   673 	inline TPtrC LocalFullName() const;

   674 	inline TPtrC LocalFamilyName() const;

   675 	inline TPtrC ShortFullName() const;

   676 	inline TPtrC ShortFamilyName() const;

   677 	inline TPtrC ShortLocalFullName() const;

   678 	inline TPtrC ShortLocalFamilyName() const;

   679 	inline void SetFullName(const TDesC& aName);

   680 	inline void SetFamilyName(const TDesC& aName);

   681 	inline void SetLocalFullName(const TDesC& aName);

   682 	inline void SetLocalFamilyName(const TDesC& aName);

   683 	inline TInt MinSizeInPixels() const;

   684 	inline void SetMinSizeInPixels(TInt aSize);

   685 private:

   686 	TBufC<ENameLength> iFamilyName;			// the name without any style suffixes; usually a truncation of iFullName

   687 	TBufC<ENameLength> iLocalFullName;		// the full name in the language of the current locale

   688 	TBufC<ENameLength> iLocalFamilyName;	// the family name in the language of the current locale

   689 	TInt iMinSizeInPixels;					// minimum supported size, (or readable size if scalable) in pixels

   690 	TInt32 iReserved2;

   691 	};

   692 

   693 

   694 /**

   695 Font specification allowing more attributes to be specified than TFontSpec.

   696 

   697 In addition to the attributes specified by TFontSpec, this font specification 

   698 allows stretching and slanting in the x dimension, and other algorithmic effects. 

   699 This is used to correct for non-square pixels, and to allow algorithmic slanting 

   700 and bold. The width factor and slant factor transform any point (x,y) to (x 

   701 * iWidthFactor + y * iSlantFactor,y). The width and slant factors are 16.16 

   702 fixed-point numbers.

   703 

   704 The font specification also provides access to information about the scripts 

   705 which are supported by the font. This information is not always reliable, 

   706 because it may be incorrectly specified, or not specified at all, by some 

   707 font manufacturers. 

   708 @publishedAll

   709 @released

   710 */

   711 class TOpenFontSpec : public TOpenFontFaceAttribBase

   712 	{

   713 public:

   714 	IMPORT_C TOpenFontSpec();

   715 	IMPORT_C TOpenFontSpec(const TFontSpec& aFontSpec);

   716 	IMPORT_C void operator=(const TFontSpec& aFontSpec);

   717 	inline TBool operator==(const TOpenFontSpec& aFontSpec) const;

   718 	TBool operator!=(const TOpenFontSpec& aOpenFontSpec) const;

   719 	IMPORT_C void SetAttrib(const TOpenFontFaceAttribBase& aAttrib);

   720 	IMPORT_C void GetTFontSpec(TFontSpec& aFontSpec) const;

   721 	IMPORT_C void CompensateForAspectRatio(TInt aPixelWidth,TInt aPixelHeight);

   722 	IMPORT_C void CompensateForAspectRatio(const MGraphicsDeviceMap& aMap);

   723 	inline TInt Height() const;

   724 	inline TInt32 WidthFactor() const;

   725 	inline TInt32 SlantFactor() const;

   726 	inline TGlyphBitmapType BitmapType() const;

   727 	inline TUint32 Effects() const;

   728 	inline TFontPrintPosition PrintPosition() const;

   729 	inline void SetHeight(TInt aHeight);

   730 	inline void SetWidthFactor(TInt32 aWidthFactor);

   731 	inline void SetSlantFactor(TInt32 aSlantFactor);

   732 	inline void SetBitmapType(TGlyphBitmapType aBitmapType);

   733 	inline void SetEffects(TUint32 aEffects);

   734 	IMPORT_C void SetEffects(FontEffect::TEffect aEffect, TBool aOn);

   735 	IMPORT_C TBool IsEffectOn(FontEffect::TEffect aEffect) const;

   736 	IMPORT_C void SetScriptTypeForMetrics(TLanguage aLanguage);

   737 	IMPORT_C TInt ScriptTypeForMetrics() const;

   738 	static TBool IsCompensationForAspectRatioNeeded(TInt aPixelWidth, TInt aPixelHeight);

   739 	static TInt ApplyRatio(TInt& aValue,TInt aNumerator,TInt aDenominator);

   740 	static TInt ApplyRatio(TInt32& aValue,TInt aNumerator,TInt aDenominator);

   741 public:

   742 	/** Algorithmic effects flags.

   743 

   744 	These can be combined using an OR operation.

   745 

   746 	WARNING: Enum for internal and partner use ONLY.  Compatibility is not guaranteed in future releases.

   747  

   748 	@deprecated Use FontEffect::TEffect instead.

   749 	*/

   750 	enum

   751 		{

   752 		/** Font is algorithmic bold. */

   753 		EAlgorithmicBold = 1,

   754 		/** Font has a drop shadow. */

   755 		EDropShadow = 2,

   756 		/** Font is an outline font. */

   757 		EOutline = 4

   758 		};

   759 private:

   760 	void SetScriptTypeForMetrics(TInt aScript);

   761 	void SetSymbol(TBool aSymbol);

   762 	TBool Symbol() const;

   763 	IMPORT_C TBool OperatorEquality(const TOpenFontSpec& aOpenFontSpec) const;

   764 	IMPORT_C TUint32 DoEffects() const;

   765 	IMPORT_C void DoSetEffects(TUint32 aEffects);

   766 private:

   767 	TInt iHeight;						// em height

   768 	TInt32 iWidthFactor;				// algorithmic width factor as a 16.16 fixed-point number

   769 	TInt32 iSlantFactor;				// algorithmic slant factor as a 16.16 fixed-point number

   770 	TInt iBitmapType;					// non-anti-aliased, standard anti-aliased, etc.; zero means 'default'

   771 	TUint32 iEffects;					// bit flags for font effects

   772 	TInt iSymbol;						// a symbol font as understood by TFontSpec (bit 1), script type (bits 2-5)

   773 	// The following data member exists only to allow round-trip conversion between TFontSpec and TOpenFontSpec

   774 	TFontPrintPosition iPrintPosition;	// normal, superscript or subscript

   775 

   776 	TInt iReserved2;

   777 	};

   778 

   779 /**

   780 Font file abstract base class.

   781 

   782 Write a class derived from COpenFontFile to manage a file with the font format 

   783 supported by your DLL. The derived class must implement the virtual 

   784 GetNearestFontInPixelsL() function. This function takes a font description 

   785 and creates a COpenFont derived object if the description matches a typeface 

   786 contained in the font file.

   787 

   788 Derived classes must also load typeface attributes from the file into the 

   789 protected typeface attribute array during construction. This array is what 

   790 is searched when getting font attribute information see AddFaceL(), 

   791 GetNearestFontHelper().

   792 

   793 Writing derived classes  construction:

   794 

   795 Call the COpenFontFile constructor in the constructor for your derived object, 

   796 passing it aUid and aFileName arguments. These values are the arguments passed 

   797 when the constructor is called by COpenFontRasterizer::NewFontFileL().

   798 

   799 A file may contain one or more typefaces. During construction the derived 

   800 object should extract the information for each typeface and add it to this 

   801 object's protected typeface attribute array see AddFaceL(). This process 

   802 will probably leave under some conditions. It should therefore be implemented 

   803 in a second phase constructor.

   804 

   805 Writing derived classes  implement the pure virtual functions:

   806 

   807 Derived classes must also implement the two pure virtual functions 

   808 GetNearestFontInPixelsL() and HasUnicodeCharacterL(). Information about 

   809 these functions is provided in the definitions below. Information about 

   810 deriving from this class is also provided in the API guide. 

   811 

   812 @see	COpenFontRasterizer::NewFontFileL()

   813 @see	CWsScreenDevice::AddFile()

   814 @publishedAll

   815 @released

   816 */

   817 class COpenFontFile : public CBase

   818 	{

   819 public:

   820 	/**

   821 	Gets the font which is the nearest to the given font specification.

   822 

   823 	Implementations of this pure virtual function should create the COpenFont 

   824 	derived object that most closely matches aDesiredFontSpec, while fitting within

   825 	aMaxHeight, and place a pointer to it in aFont. If this cannot be done,

   826 	e.g. if the font name doesn't match, aFont should be set to NULL.

   827 

   828 	The other two arguments, aHeap and aSessionCacheList, should be passed to 

   829 	the COpenFont constructor.

   830 

   831 	Implementations may use the utility function GetNearestFontHelper()

   832 	to get the attributes of the closest matching font.

   833 

   834 	@param	aHeap				Shared heap. This value should be passed to the 

   835 								COpenFont derived classes' constructor.

   836 	@param	aSessionCacheList	The session cache list. This value should be passed 

   837 								to the COpenFont derived classes' constructor.

   838 	@param	aDesiredFontSpec	The desired font specification.

   839 	@param	aPixelWidth			The width of a pixel. Used with aPixelHeight for calculating 

   840 								the algorithmic slant of the typeface.

   841 	@param	aPixelHeight		The height of a pixel. Used with aPixelWidth for calculating 

   842 								the algorithmic slant of the typeface.

   843 	@param	aFont				On return, contains a pointer to the newly created COpenFont 

   844 								derived object, or NULL if no font matching aDesiredFontSpec exists.

   845 	@param	aActualFontSpec		The actual font specification of the font retrieved into aFont.

   846 	@see	GetNearestFontHelper()

   847 	*/

   848 	virtual void GetNearestFontInPixelsL(

   849 		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

   850 		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

   851 		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec) = 0;

   852 

   853 	/**

   854 	Gets the font which is the nearest to the given font specification.

   855 

   856 	Implementations of this pure virtual function should create the COpenFont 

   857 	derived object that most closely matches aDesiredFontSpec, while fitting within

   858 	aMaxHeight, and place a pointer to it in aFont. If this cannot be done,

   859 	e.g. if the font name doesn't match, aFont should be set to NULL.

   860 

   861 	The other two arguments, aHeap and aSessionCacheList, should be passed to 

   862 	the COpenFont constructor.

   863 

   864 	Implementations may use the utility function GetNearestFontHelper()

   865 	to get the attributes of the closest matching font.

   866 

   867 	@param	aHeap				Shared heap. This value should be passed to the COpenFont 

   868 								derived classes' constructor.

   869 	@param	aSessionCacheList	The session cache list. This value should be passed 

   870 								to the COpenFont derived classes' constructor.

   871 	@param	aDesiredFontSpec	The desired font specification.

   872 	@param	aPixelWidth			The width of a pixel. Used with aPixelHeight for calculating 

   873 								the algorithmic slant of the typeface.

   874 	@param	aPixelHeight		The height of a pixel. Used with aPixelWidth for calculating 

   875 								the algorithmic slant of the typeface.

   876 	@param	aFont				On return, contains a pointer to the newly created COpenFont 

   877 								derived object, or NULL if no font matching aDesiredFontSpec exists.

   878 	@param	aActualFontSpec		The actual font specification of the font retrieved into aFont.

   879 	@see	GetNearestFontHelper()

   880 	*/

   881 	virtual void GetNearestFontToDesignHeightInPixelsL(

   882 		RHeap* /*aHeap*/, COpenFontSessionCacheList* /*aSessionCacheList*/,

   883 		const TOpenFontSpec& /*aDesiredFontSpec*/, TInt /*aPixelWidth*/, TInt /*aPixelHeight*/,

   884 		COpenFont*& /*aFont*/, TOpenFontSpec& /*aActualFontSpec*/) {}

   885 	/**

   886 	Gets the font which is the nearest to the given font specification.

   887 

   888 	Implementations of this pure virtual function should create the COpenFont 

   889 	derived object that most closely matches aDesiredFontSpec, while fitting within

   890 	aMaxHeight, and place a pointer to it in aFont. If this cannot be done,

   891 	e.g. if the font name doesn't match, aFont should be set to NULL.

   892 

   893 	The other two arguments, aHeap and aSessionCacheList, should be passed to 

   894 	the COpenFont constructor.

   895 

   896 	Implementations may use the utility function GetNearestFontHelper()

   897 	to get the attributes of the closest matching font.

   898 

   899 	@param	aHeap				Shared heap. This value should be passed to the COpenFont 

   900 								derived classes' constructor.

   901 	@param	aSessionCacheList	The session cache list. This value should be passed 

   902 								to the COpenFont derived classes' constructor.

   903 	@param	aDesiredFontSpec	The desired font specification.

   904 	@param	aPixelWidth			The width of a pixel. Used with aPixelHeight for calculating 

   905 								the algorithmic slant of the typeface.

   906 	@param	aPixelHeight		The height of a pixel. Used with aPixelWidth for calculating 

   907 								the algorithmic slant of the typeface.

   908 	@param	aFont				On return, contains a pointer to the newly created COpenFont 

   909 								derived object, or NULL if no font matching aDesiredFontSpec exists.

   910 	@param	aActualFontSpec		The actual font specification of the font retrieved into aFont.

   911 	@param	aMaxHeight			The maximum height (vertical extent) within which the font must fit.

   912 	@see	GetNearestFontHelper()

   913 	*/

   914 	virtual void GetNearestFontToMaxHeightInPixelsL(

   915 		RHeap* /*aHeap*/, COpenFontSessionCacheList* /*aSessionCacheList*/,

   916 		const TOpenFontSpec& /*aDesiredFontSpec*/, TInt /*aPixelWidth*/, TInt /*aPixelHeight*/,

   917 		COpenFont*& /*aFont*/, TOpenFontSpec& /*aActualFontSpec*/, TInt /*aMaxHeight*/) {}

   918 

   919 	/** Tests whether a specified typeface contains a particular character.

   920 

   921 	@param	aFaceIndex	The index of the typeface to be tested.

   922 	@param	aCode		The Unicode character code for the character to be tested. 

   923 	@return	ETrue if the typeface contains aCode, otherwise EFalse. */

   924 	virtual TBool HasUnicodeCharacterL(TInt aFaceIndex,TInt aCode) const = 0; 

   925 	IMPORT_C virtual void ExtendedInterface(TUid aUid, TAny*& aParam);

   926 	IMPORT_C COpenFontFile(TInt aUid,const TDesC& aFileName);

   927 	IMPORT_C ~COpenFontFile();

   928 	IMPORT_C TBool GetNearestFontHelper(const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

   929 										TInt& aFaceIndex,TOpenFontSpec& aActualFontSpec) const;

   930 	IMPORT_C void AddFaceL(const TOpenFontFaceAttrib& aAttrib);

   931 	inline TUid Uid() const;

   932 	inline const TDesC& FileName() const;

   933 	inline const TOpenFontFaceAttrib& FaceAttrib(TInt aFaceIndex) const;

   934 	inline TInt FaceCount() const;

   935 	inline void IncRefCount();

   936 	inline TBool DecRefCount();

   937 	TInt GetNearestFontInPixels(

   938 		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

   939 		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

   940 		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec);

   941 	TInt GetNearestFontToDesignHeightInPixels(

   942 		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

   943 		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

   944 		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec);

   945 	TInt GetNearestFontToMaxHeightInPixels(

   946 		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

   947 		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

   948 		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec, TInt aMaxHeight);

   949 	void RemoveFontFromList(const COpenFont* aFont);

   950 	void SetFontStoreL(CFontStore* aFontStore);

   951 	CFontStore* GetFontStore();

   952 	CArrayPtrFlat<COpenFont>* GetOpenFontList();

   953 protected:

   954 	IMPORT_C TBool GetNearestFontHelperOld(const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

   955 										TInt& aFaceIndex,TOpenFontSpec& aActualFontSpec) const;

   956 private:

   957 	// A class to contain the public font attributes and private positioning information (for kerning, ligatures, etc.)

   958 	class TAttrib: public TOpenFontFaceAttrib

   959 		{

   960 	public:

   961 		COpenFontPositioner* iPositioner;	// if non-null, positioning information for the typeface

   962 		};

   963 	static TInt ScoreByName(const TOpenFontSpec& aDesiredFontSpec, const TAttrib& aAttrib);

   964 	static TInt ScoreByStyle(const TOpenFontSpec& aDesiredFontSpec, const TAttrib& aAttrib);

   965 	void GetNearestFontToDesignHeightInPixelsAndAddToListL(

   966 		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

   967 		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

   968 		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec);

   969 	void GetNearestFontToMaxHeightInPixelsAndAddToListL(

   970 		RHeap* aHeap, COpenFontSessionCacheList* aSessionCacheList,

   971 		const TOpenFontSpec& aDesiredFontSpec, TInt aPixelWidth, TInt aPixelHeight,

   972 		COpenFont*& aFont, TOpenFontSpec& aActualFontSpec, TInt aMaxHeight);

   973 

   974 private:

   975 	CArrayFixFlat<TAttrib> iFaceAttrib;

   976 	TUid iUid;

   977 	TBuf<KMaxFileName> iFileName;

   978 	TInt iRefCount;

   979 	CArrayPtrFlat<COpenFont> iFontList;

   980 	TOpenFontFileData* iData;

   981 	};

   982 

   983 /**

   984 Convenience class from which rasterizer contexts may be derived.

   985 

   986 A rasterizer context object may (optionally) be created to provide the link 

   987 between the rasterizer DLL code supported by the Open Font System, and the 

   988 rasterizer engine code. A rasterizer context object class should get the 

   989 requested bitmap from the associated rasterizer engine. It should then convert 

   990 this into Symbian run-length-encoded format. This class contains convenience 

   991 functions to make the conversion easier.

   992 

   993 Deriving from this class is described in greater detail in the API guide.

   994 @publishedAll

   995 @released

   996 */

   997 class COpenFontRasterizerContext: public CBase

   998 	{

   999 public:

  1000 	inline COpenFontRasterizerContext();

  1001 	inline void StartGlyph(TOpenFontGlyphData* aGlyphData);

  1002 	inline void WriteGlyphBit(TInt aBit);

  1003 	inline void WriteGlyphByte(TInt aByte);

  1004 	inline void EndGlyph();

  1005 private:

  1006 	TOpenFontGlyphData* iGlyphData;

  1007 	TUint8* iGlyphDataStart;

  1008 	TUint8* iGlyphDataPtr;

  1009 	TUint8* iGlyphDataEnd;

  1010 	TInt iGlyphBit;

  1011 	TInt iBytesNeeded;

  1012 	TBool iOverflow;

  1013 	TAny* iReserved; // unused; for future expansion

  1014 	};

  1015 

  1016 

  1017 /**

  1018 Shaper abstract class.  All shaper implementations derive from this

  1019 @publishedAll 

  1020 @released

  1021 */

  1022 class CShaper : public CBase

  1023 	{

  1024 public:

  1025 	class TInput

  1026 		{

  1027 	public:

  1028 		/** The text to be shaped possibly including context. */

  1029 		const TDesC* iText;

  1030 		/** The index of the first character in iText to be shaped. */

  1031 		TInt iStart;

  1032 		/** (One past) the end of the text in iText to be shaped. */

  1033 		TInt iEnd;

  1034 		/** Script code, for example 'd'<<24 | 'e'<<16 | 'v'<<8 | 'a'

  1035 		for Devanagari. */

  1036 		TInt iScript;

  1037 		/** Language code. 0 implies "default" */

  1038 		TUint32 iLanguage;

  1039 		/** Maximum advance in pixels. Shaping beyond this

  1040 		advance is not required (but is not harmful). */

  1041 		TInt iMaximumAdvance;

  1042 		/** Flags. Currently none is defined. */

  1043 		TInt iFlags;

  1044 		/** Session handle. To be used if rasterization is needed. */

  1045 		TInt iSessionHandle;

  1046 		/** Reserved for future expansion. Must be set to 0. */

  1047 		TInt iReserved1;

  1048 		};

  1049 	/** Constructor */

  1050 	IMPORT_C CShaper();

  1051 

  1052 	/** Destructor */

  1053 	IMPORT_C virtual ~CShaper();

  1054 

  1055 	/** construct a shaper object

  1056 	@param	aBitmapFont	The font to be shaped.

  1057 	@param	aHeap		The heap to be used by the shaper.

  1058 	@return	KErrNone if this font can be shaper or system wide error code*/

  1059 	virtual TInt ConstructL(CBitmapFont*  aBitmapFont, TInt aScript, TInt aLanguage, RHeap* iHeap) = 0;

  1060 

  1061 	/** If possible, shape the text described by aInput, placing the output on aHeapForOutput.

  1062 	@param	aOutput			The output, as a newly allocate object on aHeapForOutput.

  1063 	@param	aInput			The input text and other parameters.

  1064 	@param	aHeapForOutput	On success, aOutput should be allocated from this and nothing else. 

  1065 							On failure, nothing should be allocated from it.

  1066 	@return	Error value from one of the system-wide error codes on failure, KErrNone on success.

  1067 	@see	TShapeHeader */

  1068 	virtual TInt ShapeText(TShapeHeader*& aOutput, const TInput& aInput, RHeap* aHeapForOutput) = 0;

  1069 

  1070 	/** For future expansion. Any overriders must base-call

  1071 	if aInterface is unrecognized.

  1072 	

  1073 	WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

  1074 	

  1075 	@param	aInterfaceId	The ID of the interface to return.

  1076 	@return	A pointer to the extension interface.

  1077 	*/

  1078 	IMPORT_C virtual void* ExtendedInterface(TUid aInterfaceId);

  1079 	};

  1080 

  1081 /** ECOM plug-in base class for shaper factories.

  1082 @publishedAll

  1083 @released

  1084 */

  1085 class CShaperFactory : public CBase

  1086 	{

  1087 public:

  1088 	/** Create a shaper if possible, for typeface aFaceIndex

  1089 	within file aFileName.

  1090 	@param	aFont	The font to be shaped.

  1091 	@param	iHeap	The heap to use for constructing the shaper.

  1092 	@return	0 If the font is not understood or inappropriate for any shaper that might be constructed 

  1093 			by this class, otherwise returns the newly-constructed shaper on iHeap. */

  1094 	virtual CShaper* NewShaperL(CBitmapFont* aFont, TInt aScript, TInt aLanguage, RHeap* iHeap) = 0;

  1095 

  1096 	inline static CShaperFactory* NewL(TUid aInterfaceImplUid);

  1097 	inline virtual ~CShaperFactory();

  1098 

  1099 	/** For future expansion. Any overriders must base-call if aInterface is unrecognized.

  1100 

  1101 	WARNING: Function for internal use ONLY. Compatibility is not guaranteed in future releases.

  1102 

  1103 	@param	aInterfaceId	The ID of the interface to return.

  1104 	@return	A pointer to the extension interface.	

  1105 	*/

  1106 	virtual void* ExtendedInterface(TUid aInterfaceId);

  1107 

  1108 private:

  1109 	TUid iDtor_ID_Key;//ECOM identifier used during destruction

  1110 	};

  1111 

  1112 // Inline functions start here.

  1113 /** Default C++ constructor.

  1114 

  1115 This creates then zero fills the object. */

  1116 inline TOpenFontMetrics::TOpenFontMetrics()

  1117 	{

  1118 	Mem::FillZ(this,sizeof(*this));

  1119 	}

  1120 

  1121 /** Gets the font's size.

  1122 

  1123 @return	The font's size. 

  1124 @see	SetSize() */

  1125 inline TInt TOpenFontMetrics::Size() const

  1126 	{

  1127 	return iDesignHeight;

  1128 	}

  1129 

  1130 /** Gets the font's ascent.

  1131 

  1132 This is the ascent for the Latin character which is highest above the baseline.

  1133 

  1134 @return The font's ascent, in pixels.