--- a/fontservices/fontstore/tfs/T_fontsessioncache.cpp	Thu Jun 24 11:25:56 2010 +0800
+++ b/fontservices/fontstore/tfs/T_fontsessioncache.cpp	Mon Jul 12 14:38:26 2010 +0800
@@ -92,7 +92,7 @@
 
 void CTFontSessionCache::ConstructL()
     {
-    User::LeaveIfError(iChunk.CreateGlobal(KNullDesC,500,500));
+    User::LeaveIfError(iChunk.CreateGlobal(KNullDesC,0x10000,0x10000));
     iSharedHeap = UserHeap::ChunkHeap(iChunk,0x10000,0x1000,0x10000,0,EFalse,0);
     if(iSharedHeap == NULL)
         {

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/bwins/LINEBREAKU.DEF	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,9 @@
+EXPORTS
+	?GetLineBreak@MLineBreaker@@QBEHABVTDesC16@@HHHPAVMContingentLineBreaker@@AAH2@Z @ 1 NONAME ; public: int __thiscall MLineBreaker::GetLineBreak(class TDesC16 const &,int,int,int,class MContingentLineBreaker *,int &,int &)const 
+	?GetLineBreakInContext@MLineBreaker@@UBEHABVTDesC16@@HHHAAH@Z @ 2 NONAME ; public: virtual int __thiscall MLineBreaker::GetLineBreakInContext(class TDesC16 const &,int,int,int,int &)const 
+	?GetLineBreakL@MLineBreaker@@QBEHABVTDesC16@@HHHPAVMContingentLineBreakerL@@AAH2@Z @ 3 NONAME ; public: int __thiscall MLineBreaker::GetLineBreakL(class TDesC16 const &,int,int,int,class MContingentLineBreakerL *,int &,int &)const 
+	?IsHangingCharacter@MLineBreaker@@UBEHI@Z @ 4 NONAME ; public: virtual int __thiscall MLineBreaker::IsHangingCharacter(unsigned int)const 
+	?LineBreakClass@MLineBreaker@@UBEIIAAI0@Z @ 5 NONAME ; public: virtual unsigned int __thiscall MLineBreaker::LineBreakClass(unsigned int,unsigned int &,unsigned int &)const 
+	?LineBreakPossible@MLineBreaker@@UBEHIIH@Z @ 6 NONAME ; public: virtual int __thiscall MLineBreaker::LineBreakPossible(unsigned int,unsigned int,int)const 
+	?ExtendedInterface@MLineBreaker@@UBEPAXAAVTUid@@@Z @ 7 NONAME ; public: virtual void * __thiscall MLineBreaker::ExtendedInterface(class TUid &)const 
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/eabi/LineBreakU.def	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,11 @@
+EXPORTS
+	_ZNK12MLineBreaker12GetLineBreakERK7TDesC16iiiP22MContingentLineBreakerRiS5_ @ 1 NONAME
+	_ZNK12MLineBreaker13GetLineBreakLERK7TDesC16iiiP23MContingentLineBreakerLRiS5_ @ 2 NONAME
+	_ZNK12MLineBreaker14LineBreakClassEjRjS0_ @ 3 NONAME
+	_ZNK12MLineBreaker17ExtendedInterfaceER4TUid @ 4 NONAME
+	_ZNK12MLineBreaker17LineBreakPossibleEjji @ 5 NONAME
+	_ZNK12MLineBreaker18IsHangingCharacterEj @ 6 NONAME
+	_ZNK12MLineBreaker21GetLineBreakInContextERK7TDesC16iiiRi @ 7 NONAME
+	_ZTI12MLineBreaker @ 8 NONAME ; #<TI>#
+	_ZTV12MLineBreaker @ 9 NONAME ; #<VT>#
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/group/BLD.INF	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,75 @@
+// Copyright (c) 2010 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:
+// textbase
+// 
+//
+
+/**
+ @file
+*/
+
+
+PRJ_PLATFORMS
+
+DEFAULT
+
+
+PRJ_EXPORTS
+
+../inc/textbase.h SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(textbase.h)
+../inc/BIDI.H SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(bidi.h)
+../inc/BidiText.h SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(biditext.h)
+../inc/LineBreak.h SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(linebreak.h)
+../inc/BidiVisual.h SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(bidivisual.h)
+../inc/ShapeInfo.h SYMBIAN_OS_LAYER_PUBLIC_EXPORT_PATH(shapeinfo.h)
+../inc/ShapeImpl.h	SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(graphics/shapeimpl.h)
+
+../inc/glyphsample.h 	SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(graphics/gdi/glyphsample.h)
+../inc/gdiinline.inl	SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(graphics/gdi/gdiinline.inl)
+../inc/gdiplatapi.h	SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(graphics/gdi/gdiplatapi.h)
+
+../inc/hextree.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(hextree.h)
+../inc/hextree.inl SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(hextree.inl)
+
+// new added ones
+// BidiCompact.h and GlyphSel.h are only used by TGdiServer.
+../sgdi/BidiCompact.h	SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(graphics/gdi/BidiCompact.h)
+../sgdi/GlyphSel.h	SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(graphics/gdi/GlyphSel.h)
+
+PRJ_MMPFILES
+
+../group/textbase.mmp
+../group/LineBreak.mmp
+
+
+PRJ_TESTMMPFILES
+
+../group/ttextbaseserver.mmp
+
+
+PRJ_TESTEXPORTS
+
+// batch file that runs all automatic gdi tests on hardware
+../group/textbasetest.iby    /epoc32/rom/include/textbasetest.iby
+
+../tgdi/scripts/textbasetest_run.bat				z:/textbasetest/textbasetest_run.bat
+../tgdi/scripts/textbasetest.bat					z:/textbasetest/textbasetest.bat
+
+../tgdi/scripts/textbasetest_T_All.script			z:/textbasetest/textbasetest_t_all.script
+../tgdi/scripts/textbasetest_T_Types.script			z:/textbasetest/textbasetest_t_types.script
+../tgdi/scripts/textbasetest_T_BiDiDefect.script		z:/textbasetest/textbasetest_t_bididefect.script
+../tgdi/scripts/textbasetest_T_LineBreak.script		z:/textbasetest/textbasetest_t_linebreak.script
+../tgdi/scripts/textbasetest_T_GlyphSelection.script	z:/textbasetest/textbasetest_t_glyphselection.script
+../tgdi/scripts/textbasetest_T_BiDi.script			z:/textbasetest/textbasetest_t_bidi.script
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/group/LineBreak.mmp	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,45 @@
+// Copyright (c) 2002-2010 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:
+// linebreak.dll Line-break support
+// 
+//
+
+/**
+ @file
+*/
+
+ 
+target linebreak.dll
+CAPABILITY All -Tcb
+targettype dll
+uid 0x1000008D 0x101F747F
+VENDORID 0x70000001
+
+sourcepath ../sgdi
+
+userinclude ../inc ../sgdi
+OS_LAYER_SYSTEMINCLUDE_SYMBIAN
+
+source LineBreak.cpp 
+source LinebreakComplex.cpp
+
+library euser.lib
+
+
+#ifdef WINSCW
+DEFFILE LINEBREAK.DEF
+#else
+DEFFILE LineBreak.def
+#endif
+SMPSAFE

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/group/textbase.mmp	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,44 @@
+// Copyright (c) 2010 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:
+// textbase
+// 
+//
+
+TARGET		  textbase.lib
+TARGETTYPE	  lib
+UID			 0
+
+USERINCLUDE	 ..\inc
+OS_LAYER_SYSTEMINCLUDE_SYMBIAN
+
+SOURCEPATH	  ..\sgdi
+SOURCE	BIDI.CPP
+SOURCE	BidiCompact.cpp
+SOURCE	BidiCopy.cpp
+SOURCE	BidiText.cpp
+SOURCE	BidiVisual.cpp
+SOURCE	FONT.CPP
+SOURCE	FontArabic.cpp
+SOURCE	FontIndic.cpp
+SOURCE	FontThai.cpp
+SOURCE	GlyphSel.cpp
+SOURCE	ShaperCli.cpp
+SOURCE	TFSTORE.CPP
+SOURCE hextree.cpp
+SOURCE	TextBasePanic.cpp
+
+
+#ifdef ENABLE_ABIV2_MODE
+DEBUGGABLE_UDEBONLY
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/group/textbase.mrp	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,26 @@
+#
+# Copyright (c) 2010 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: 
+#
+
+component	textbase
+source	\sf\os\textandloc\fontservices\textbase
+binary	\sf\os\textandloc\fontservices\textbase\group	all
+exports	\sf\os\textandloc\fontservices\textbase\group
+notes_source	\component_defs\release.src
+
+
+ipr D 
+ipr T \sf\os\textandloc\fontservices\textbase\tgdi
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/group/textbasetest.iby	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,41 @@
+// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// 
+// 
+//
+
+#ifndef __TEXT_FONT_TEST_IBY__
+#define __TEXT_FONT_TEST_IBY__
+
+#include <graphics_testharness.iby>
+#include <IcuLayoutEngine.iby>
+
+// batch file that runs all automatic gdi tests
+data=DATAZ_\TextBaseTest\TextBaseTest_run.bat	\TextBaseTest_run.bat
+data=DATAZ_\TextBaseTest\TextBaseTest.bat		\TextBaseTest.bat
+
+//script file
+data=DATAZ_\TextBaseTest\TextBaseTest_T_All.script			\TextBaseTest\TextBaseTest_T_All.script
+data=DATAZ_\TextBaseTest\TextBaseTest_T_Rgb.script			\TextBaseTest\TextBaseTest_T_Rgb.script
+data=DATAZ_\TextBaseTest\TextBaseTest_T_Types.script			\TextBaseTest\TextBaseTest_T_Types.script
+data=DATAZ_\TextBaseTest\TextBaseTest_T_BiDiDefect.script		\TextBaseTest\TextBaseTest_T_BiDiDefect.script
+data=DATAZ_\TextBaseTest\TextBaseTest_T_LineBreak.script		\TextBaseTest\TextBaseTest_T_LineBreak.script
+data=DATAZ_\TextBaseTest\TextBaseTest_T_GlyphSelection.script	\TextBaseTest\TextBaseTest_T_GlyphSelection.script
+data=DATAZ_\TextBaseTest\TextBaseTest_T_BiDi.script			\TextBaseTest\TextBaseTest_T_BiDi.script
+
+// GDI test code
+file=ABI_DIR\DEBUG_DIR\TTextBaseServer.exe		TEST\TTextBaseServer.exe
+
+#endif
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/group/ttextbaseserver.mmp	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,65 @@
+// Copyright (c) 2010 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:
+// 
+//
+
+TARGET		TTextBaseServer.exe
+TARGETTYPE		exe
+UID           	0x1000007A 0x10273367
+VENDORID 0x70000001
+
+//capability all -tcb
+CAPABILITY       All -Tcb 
+
+userinclude	../../../../graphics/graphicstest/graphicstestharness/inc
+userinclude ../tgdi ../inc ../sgdi
+SYSTEMINCLUDE	/epoc32/include/test
+OS_LAYER_SYSTEMINCLUDE_SYMBIAN
+
+SOURCEPATH  ../tgdi
+SOURCE		TGdiServer.cpp
+SOURCE		TTFSTORE.CPP
+SOURCE		TTYPES.CPP
+SOURCE 		TBiDi.cpp 
+SOURCE 		TGraphicsContext.cpp 
+SOURCE 		TBiDiDefect.cpp
+SOURCE 		TLineBreak.cpp
+SOURCE 		TGlyphSel.cpp
+
+
+
+LIBRARY         euser.lib
+LIBRARY         gdi.lib	
+LIBRARY         palette.lib
+LIBRARY		efsrv.lib
+LIBRARY		estor.lib
+LIBRARY 	linebreak.lib
+LIBRARY	    	testexecuteutils.lib tgraphicsharness.lib
+LIBRARY	    	testexecutelogclient.lib
+
+LIBRARY 	ecom.lib
+LIBRARY		fntstr.lib 
+LIBRARY  	bitgdi.lib
+LIBRARY		fbscli.lib
+
+#if !defined(WINS)
+LIBRARY  viewsrv.lib
+#endif
+
+STATICLIBRARY textbase.lib
+
+// We're quite heavy on the stack... 4k in WinS isn't enough...
+EPOCSTACKSIZE	0x10000
+
+SMPSAFE

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/BIDI.H	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,210 @@
+/*
+* Copyright (c) 2003-2010 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:
+* Definitions for bidirectional text reordering.
+* 
+*
+*/
+
+
+
+#ifndef BIDI_H_
+#define BIDI_H_
+
+#include <e32std.h>
+
+class RWriteStream;
+class RReadStream;
+
+
+class TBidirectionalState
+/** 
+The bidirectional state class. 
+This class contains functions that implement the Unicode Bidirectional Algorithm, 
+which changes text from logical order to display order for the correct display 
+of right-to-left scripts, like Arabic and Hebrew. A TBidirectionalState object 
+carries the embedding level and stack from one line to the next. On construction 
+it is in its 'start of paragraph' state. 
+@publishedAll
+@released
+*/
+	{
+	friend class CTBiDi;
+	
+public:
+	
+	class TRunInfo
+	/** 
+	Information about a run of characters with the same bidirectional 
+	category. 
+
+	An array of these representing a line is passed into, and reordered by, 
+	ReorderLine(). 
+	@publishedAll
+	@released
+	*/
+		{
+		public:
+		/** Category of a run of text: passed to ReorderLine(); these are 
+		passed in as TChar::TBdCategory values but are modified for internal 
+		use. */
+		TUint iCategory;		
+		/** Embedding level of this run: used internally by ReorderLine(). */
+		TUint8 iEmbeddingLevel;	
+		/** Resolved direction of this run: 0 for left to right, 1 for right 
+		to left. */
+		TUint8 iDirection;		
+		/** Index of this run after reordering. */
+		TInt iIndex;			
+		/** Start of text; returned by ReorderText(). */
+		TInt iStart;			
+		/** Length of text; returned by ReorderText(). */
+		TInt iLength;			
+		};
+
+	IMPORT_C TBidirectionalState();
+	IMPORT_C void ReorderLine(TRunInfo* aRunInfo,TInt aRuns,TBool aParStart,TBool aParEnd,TBool aParRightToLeft,
+					 TChar::TBdCategory aNextCategory,TChar::TBdCategory aNextStrongCategory,
+					 TBool& aVisualEndIsAmbiguous);
+	IMPORT_C void ReorderLine(TRunInfo* aRunInfo,TInt aRuns,TBool aParStart,TBool aParEnd,TBool aParRightToLeft,
+					 TChar::TBdCategory aNextCategory,TChar::TBdCategory aNextStrongCategory);
+	IMPORT_C static TInt ReorderText(const TText* aText,TInt aLength,TBool aParRightToLeft,TText*& aNewText);
+	IMPORT_C static void ReverseGroups(TText* aStart,TInt aLength);
+	IMPORT_C void Reset();
+	IMPORT_C TBool IsDefault() const;
+	IMPORT_C TBool operator==(const TBidirectionalState& aState) const;
+	IMPORT_C void ExternalizeL(RWriteStream& aDest);
+	IMPORT_C void InternalizeL(RReadStream& aSource);
+	TBool ParRightToLeft() const { return iStack[0].iEmbeddingLevel & 1; }
+
+private:
+	// Bidirectional categories coded as bit flags
+	enum TCategory
+		{
+		ELeftToRight = 1 << TChar::ELeftToRight, 
+		ELeftToRightEmbedding = 1 << TChar::ELeftToRightEmbedding,
+		ELeftToRightOverride = 1 << TChar::ELeftToRightOverride,
+		ERightToLeft = 1 << TChar::ERightToLeft,
+		ERightToLeftArabic = 1 << TChar::ERightToLeftArabic,
+		ERightToLeftEmbedding = 1 << TChar::ERightToLeftEmbedding, 
+		ERightToLeftOverride = 1 << TChar::ERightToLeftOverride,
+		EPopDirectionalFormat = 1 << TChar::EPopDirectionalFormat, 
+		EEuropeanNumber = 1 << TChar::EEuropeanNumber, 
+		EEuropeanNumberSeparator = 1 << TChar::EEuropeanNumberSeparator, 
+		EEuropeanNumberTerminator = 1 << TChar::EEuropeanNumberTerminator, 
+		EArabicNumber = 1 << TChar::EArabicNumber,
+		ECommonNumberSeparator = 1 << TChar::ECommonNumberSeparator, 
+		ENonSpacingMark = 1 << TChar::ENonSpacingMark, 
+		EBoundaryNeutral = 1 << TChar::EBoundaryNeutral, 
+		EParagraphSeparator = 1 << TChar::EParagraphSeparator, 
+		ESegmentSeparator = 1 << TChar::ESegmentSeparator, 
+		EWhitespace = 1 << TChar::EWhitespace, 
+		EOtherNeutral = 1 << TChar::EOtherNeutral,
+
+		// useful groups
+		EBdControlsGroup = ELeftToRightEmbedding | ERightToLeftEmbedding |
+						   ELeftToRightOverride | ERightToLeftOverride | EPopDirectionalFormat,
+		ELeftToRightGroup = ELeftToRight | EEuropeanNumber | ELeftToRightOverride | ELeftToRightEmbedding,
+		ERightToLeftGroup = ERightToLeft | EArabicNumber | ERightToLeftArabic | ERightToLeftOverride |
+							ERightToLeftEmbedding,
+		EStrongGroup = ELeftToRightEmbedding | ERightToLeftEmbedding
+			| ELeftToRightOverride | ERightToLeftOverride
+			| ELeftToRight | ERightToLeft | ERightToLeftArabic,
+
+		ENoCategory = 0
+		};
+
+	enum
+		{
+		EMaxExplicitLevel = 61,
+		EMaxLevel = 63,
+		EMaxStackLevels = 62
+		};
+
+	enum TOverrideState
+		{
+		ENoOverrideState = 0,
+		ELeftToRightOverrideState = ELeftToRightOverride,
+		ERightToLeftOverrideState = ERightToLeftOverride
+		};
+
+	class TStackItem
+		{
+	public:
+		TUint8 iEmbeddingLevel;			// embedding level
+		TOverrideState iOverrideState;	// directional override state
+		TCategory iStartCategory;		// category that started this level; EOtherNeutral if none
+		};
+
+private:
+	/**	The information needed during line reordering.
+	WARNING: Class for internal use ONLY.  Compatibility is not guaranteed in future releases.	
+	 */
+	class TReorderContext
+		{
+	public:
+		void SetNextCategory(TChar::TBdCategory aCat);
+		void SetNextStrongCategory(TChar::TBdCategory aCat);
+	public:
+		/** Category at start of next line, or ON if at the end of the
+		paragraph. */
+		TCategory iNextCategory;
+		/** Which of L, R or AL appears first in the remainder of the
+		paragraph, or ON if none. */
+		TCategory iNextStrongCategory;
+		/** The run array for this line. */
+		TRunInfo* iRunInfo;
+		/** The length of iRunInfo. */
+		TInt iRuns;
+		/** Bitmap of categories currently present in iRunInfo. */
+		TUint32 iCategories;
+		/** Found by the algorithm to set iPreviousStrongCategory. */
+		TCategory iLastStrongCategory;
+		};
+
+public:
+	static TInt GenerateBdRunArray(const TText* aText, TInt aLength,
+		TBidirectionalState::TRunInfo* aRun, TInt aMaxRuns);
+
+private:
+	const TStackItem& State() const { return iStack[iStackLevel]; }
+	TCategory Push(TCategory aStartCategory);
+	TCategory Pop();
+
+public:
+	TBidirectionalState(TChar::TBdCategory aPrevCat,
+		TChar::TBdCategory aPrevStrongCat, TBool aParRightToLeft);
+	void HandleBdControls(TReorderContext& aContext); 
+	void ResolveWeakTypesW1W2W3(TReorderContext& aContext);
+	void ResolveWeakTypesW4W5W6(TReorderContext& aContext); 
+	void ResolveWeakTypesW7(TReorderContext& aContext); 
+	void ResolveNeutralTypes(TReorderContext& aContext); 
+	void ResolveImplicitLevels(TReorderContext& aContext); 
+	void PrepareForNextLine(const TReorderContext& aContext);
+	void ReorderRuns(TReorderContext& aContext);
+	static TInt CatToNumber(TInt aCat);
+	static TCategory CharToBdCat(TChar::TBdCategory aCat);
+	static TCategory UintToBdCat(TUint aCat);
+	static void DeneutralizeRuns(TRunInfo* aStart, TRunInfo* aEnd,
+		TCategory aStartCategory, TCategory aEndCategory);
+private:
+	TCategory iPreviousCategory;			// category at end of last line, or EStartOfParagraph if at start of par
+	TCategory iPreviousStrongCategory;		// L or R; derived from embedding level if at start of par
+	TInt16 iStackLevel;						// current stack level
+	TInt8 iPushesBeyond60;	// number of times Push called with iStackLevel == 60 and Left-To-Right category
+	TInt8 iPushesBeyond61;	// number of times Push called with iStackLevel == 61
+	TStackItem iStack[EMaxStackLevels];		// the stack of embedding levels
+	};
+
+#endif // BIDI_H_

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/BidiText.h	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,157 @@
+// Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef BIDITEXT_H_
+#define BIDITEXT_H_
+
+#include <e32std.h>
+#include <gdi.h>	// class CGraphicsContext
+#include <bidi.h>	// class TBidirectionalState::TRunInfo
+enum CGraphicsContext::TTextAlign;
+class MLineBreaker;
+class RRunInfoArray;
+class CBidiTextTls;
+
+
+/**
+This enumeration holds the possible panic codes that may be raised 
+by the BidiText API on detecting an unrecoverable error.
+@publishedAll
+@released
+*/
+enum TBidiPanic
+	{
+	/** The call to RRunInfoArray::OpenL() has not been made prior to this call to TBidiText::SetText()
+	@see TBidiText::SetText	*/
+	EBidiPanic_RunArrayNull						= 0,
+	
+	/** Maximum number of lines that the text will need to be split into is invalid i.e less than zero or negative.
+	@see TBidiText::NewL
+	@see TBidiText::MinimumSize	*/
+	EBidiPanic_InvalidMaxline					= 1,
+	
+	/** Maximum number of characters are invalid i.e less than zero or negative.
+	@see TBidiText::NewL */
+	EBidiPanic_InvalidReservedMaxLength			= 2,
+	
+	/** Maximum width of the text in pixels is invalid i.e zero or negative.
+	@see TBidiText::MinimumSize */
+	EBidiPanic_InvalidWrappingWidth				= 3,
+	
+	/** Number of empty pixels between two lines of text are invalid i.e zero or negative.
+	@see TBidiText::MinimumSize */
+	EBidiPanic_InvalidLineGap					= 4,
+	
+	/** Text length for display is invalid i.e zero or negative.
+	@see TBidiText::DisplayText
+	@see TBidiText::LineOfDisplayText */
+	EBidiPanic_InvalidVisualOrderedTextLength	= 5,
+	
+	/** Line number to retrieve is invalid i.e zero or negative. 
+	@see TBidiText::LineOfDisplayText */
+	EBidiPanic_InvalidLineNumber				= 6
+	};
+
+/** 
+This class works as a replacement for HBufC in those cases where a small 
+amount of text is being formatted simply. The text must be all of one style 
+and broken into lines of all the same length. The number of lines and the text 
+itself is specified on construction, and the text may then be re-broken, 
+re-truncated and re-drawn with non-leaving functions. 
+@publishedAll
+@released
+*/
+class TBidiText
+	{
+public:
+	/** Overall directionality of the text. */
+	enum TDirectionality
+		{
+		/** Text reading begins on the left. */
+		ELeftToRight = 0,
+		/** Text reading begins on the right. */
+		ERightToLeft = 1
+		};
+
+	/** Class specific panic codes 
+	@deprecated This enum has been replaced by TBidiPanic.
+    */
+	enum TPanicCodes
+		{
+		EPanicRunArrayNull,
+		};
+
+	IMPORT_C static TDirectionality ScriptDirectionality(TLanguage aLanguage);
+	IMPORT_C static TDirectionality TextDirectionality(
+		const TDesC& aText, TBool* aFound = 0);
+protected:
+	TBidiText();
+public:
+	IMPORT_C static TBidiText* NewL(TInt aReservedMaxLength, TInt aMaxLines);
+	IMPORT_C static TBidiText* NewL(const TDesC& aText, TInt aMaxLines);
+	IMPORT_C static TBidiText* NewL(const TDesC& aText, TInt aMaxLines,
+		TDirectionality aDirectionality);
+	IMPORT_C TInt SetText(const TDesC& aText, RRunInfoArray& aRunInfoArray);
+	IMPORT_C TInt SetText(const TDesC& aText, TDirectionality aDirectionality, RRunInfoArray& aRunInfoArray);
+	IMPORT_C void SetTruncationChar(TChar aTruncateWith);
+	IMPORT_C void WrapText(TInt aWrappingWidth, const CFont& aFont,
+		const MLineBreaker* aBreaker, TInt aMaxLines);
+	IMPORT_C void WrapText(TInt aWrappingWidth, const CFont& aFont,
+		const MLineBreaker* aBreaker = NULL);
+	IMPORT_C TSize MinimumSize(TInt aWrappingWidth, const CFont& aFont, TInt aLineGap, TInt aMaxLines = -1,
+		const MLineBreaker* aBreaker = NULL) const;	
+	IMPORT_C TPtrC Text() const;
+	IMPORT_C TPtrC DisplayText() const;
+	IMPORT_C TInt WrappingWidth() const;
+	IMPORT_C TDirectionality Directionality() const;
+	IMPORT_C TChar TruncationChar() const;
+	IMPORT_C TInt NumberOfLinesInDisplayText() const;
+	IMPORT_C TPtrC LineOfDisplayText(TInt aLine, TInt& aWidthInPixels) const;
+	IMPORT_C void DrawText(CGraphicsContext& aGc, const TPoint& aLeft) const;
+	IMPORT_C void DrawText(CGraphicsContext& aGc,
+		const TPoint& aLeft, TInt aBaseLineSpacing,
+		CGraphicsContext::TTextAlign aAlignment) const;
+	IMPORT_C void DrawText(CGraphicsContext& aGc,
+		const TPoint& aLeft, TInt aBaseLineSpacing) const;
+private:
+	TInt DoWrapText(TInt aWrappingWidth, const CFont& aFont, const MLineBreaker* aBreaker, 
+		TInt aMaxLines, TText*& aOutputText, TInt& aNumLines, TInt16* aLineWidthArray) const;
+	};
+
+
+/**
+This class is used to keep track of the shared run info array. 
+Keep it open for as long as the TBidiText object is used. The same
+RRunInfoArray object can be used with several different TBidiText objects.
+@publishedAll
+@released
+*/
+class RRunInfoArray
+	{
+	friend class TBidiText;
+
+public:	
+	IMPORT_C RRunInfoArray();
+	IMPORT_C void OpenL();
+	IMPORT_C void Close();
+
+private:
+	TBidirectionalState::TRunInfo* RunArray() const;
+
+private:
+	CBidiTextTls* iTls;
+	};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/BidiVisual.h	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,51 @@
+// Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef BIDIVISUAL_H_
+#define BIDIVISUAL_H_
+
+#include <bidi.h>
+
+class TBidiLogicalToVisual
+/** 
+This class is a low-level class for bi-directionally reordering text. It 
+allows the re-ordering of text using no leaving functions at all, and provides 
+a finer degree of control than TBidiText. However, it should not be used 
+without understanding the basics of the Unicode Bi-directional Reordering 
+Algorithm. 
+@publishedAll
+@released
+*/
+	{
+public:
+	enum {KMinCharAvailable = 4};
+
+	IMPORT_C TBidiLogicalToVisual(const TDesC& aText, TBool aRightToLeft,
+		TBidirectionalState::TRunInfo* aRunInfoArray, TInt aRunInfoLength);
+	IMPORT_C TBidiLogicalToVisual(const TDesC& aText,
+		TBidirectionalState::TRunInfo* aRunInfoArray, TInt aRunInfoLength);
+	IMPORT_C TInt Reorder();
+	IMPORT_C void GetVisualLine(TDes& aLine, TInt aStart, TInt aEnd,
+		TChar aTruncationChar);
+private:
+	const TDesC& iText;
+	TBool iRightToLeft;
+	TBidirectionalState::TRunInfo* iRunInfoArray;
+	TInt iRunInfoArrayLength;
+	TInt iRuns;
+	TUint32 iSpare2;
+	};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/LineBreak.h	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,229 @@
+// Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef LINEBREAK_H_
+#define LINEBREAK_H_
+
+#include <e32def.h>
+class MContingentLineBreaker;
+class MContingentLineBreakerL;
+class TDesC16;
+class TUid;
+
+
+/**
+ This enumeration holds the possible panic codes that may be raised
+ by the LineBreak API on detecting an unrecoverable error.
+@publishedAll
+@released
+*/
+enum TLineBreakPanic
+	{
+	/** Not used */
+	ELineBreakPanic_Unknown				= 0,
+	/** Internal error, error found in data table */
+	ELineBreakPanic_BadTable			= 1,
+	/** One or more of the input parameters to the interface were invalid */
+	ELineBreakPanic_InvalidInputParam	= 2,
+	/** Raised when an output parameter breaks an API condition */
+	ELineBreakPanic_InvalidOutputParam	= 3,
+	};
+
+
+
+class MLineBreaker
+/**
+Customizes the Unicode line-breaking algorithm. 
+@publishedAll
+@released
+*/
+	{
+public:
+	/** The Unicode line breaking classes; see Unicode Technical Report 14.
+	Not a named enumerated type, so that overriding classes may add new
+	line breaking classes freely.
+	The description of each constant gives the name of the line-breaking
+	class, an example and a brief, imprecise description of the default
+	behaviour of characters of that class.	 */
+	enum
+		{
+		/** Opening Punctuation (e.g. '['). Breaking after prohibited. */
+		EOpLineBreakClass,
+		/** Closing Punctuation (e.g. ']'). Breaking before prohibited. */
+		EClLineBreakClass,
+		/** Ambiguous Quotes (e.g. '"'). Breaking before and after prohibited. */
+		EQuLineBreakClass,
+		/** Glue (e.g. Non-breaking space). Breaking before and after prohibited
+		unless spaces are present. */
+		EGlLineBreakClass,
+		/** Non-Starter (e.g. small Japanese kana). Breaking before prohibited
+		if no spaces present. */
+		ENsLineBreakClass,
+		/** Exclamation or Interrogation (e.g. '?'). Like closing punctuation
+		except before Postfix or Non-starter. */
+		EExLineBreakClass,
+		/** Symbol (e.g. '/'. Like Alphabetic, but allows breaking before
+		Alphabetic. */
+		ESyLineBreakClass,
+		/** Numeric Infix Separator (e.g. ','). Forbids breaking after any and before
+		Numeric. */
+		EIsLineBreakClass,
+		/** Numeric Prefix (e.g. '$'). Forbids breaking before Numeric. */
+		EPrLineBreakClass,
+		/** Numeric Postfix (e.g. '%'). Forbids breaking after Numeric. */
+		EPoLineBreakClass,
+		/** Numeric (e.g. '1'). */
+		ENuLineBreakClass,
+		/** Alphabetic (e.g. 'a'). */
+		EAlLineBreakClass,
+		/** Ideographic (e.g. Japanese Kanji). Generally break before or after */
+		EIdLineBreakClass,
+		/** Inseparable (e.g. ellipsis). Forbid breaks between Inseparables. */
+		EInLineBreakClass,
+		/** Hyphen (e.g. '-'). Allows a break after except before Numeric. */
+		EHyLineBreakClass,
+		/** Break After. Generally allow a break after. Breaking between Break
+		Afters not separated by spaces is prohibited. */
+		EBaLineBreakClass,
+		/** Break Before. Generally allow a break before. Breaking between Break
+		Befores not separated by spaces is prohibited. */
+		EBbLineBreakClass,
+		/** Break Before and After. Generally allow a break before or after.
+		Breaking between Break Before and Afters is prohibited, even if spaces
+		are present. */
+		EB2LineBreakClass,
+		/** Zero-Width Space. Allow a break. */
+		EZwLineBreakClass,
+		/** Combining Mark. Takes on the class of its base class. */
+		ECmLineBreakClass,
+		/** Mandatory Break. */
+		EBkLineBreakClass,
+		/** Carriage Return. Break after unless part of a CRLF pair. */
+		ECrLineBreakClass,
+		/** Line Feed. Break after. */
+		ELfLineBreakClass,
+		/** Surrogate. Half of a surrogate pair. */
+		ESgLineBreakClass,
+		/** Contingent Break (e.g. embedded pictures). Uses external
+		information */
+		ECbLineBreakClass,
+
+		/** Space. Intervening characters of class Space are indicated by
+		aHaveSpaces in LineBreakPossible. */
+		ESpLineBreakClass, 
+
+		/** Complex Context (e.g. Thai). Runs of Complex Context are passed to
+		GetLineBreakInContext. */
+		ESaLineBreakClass,
+
+		/** Ambiguous. Characters of ambiguous East Asian width are treated
+		as Alphabetic, unless they are resolved as being "Wide", in which case
+		they are treated as Ideographic. */
+		EAiLineBreakClass,
+
+		/** The Xx class is used when the class is unknown; e.g.; outside the provided context. */
+		EXxLineBreakClass,
+
+		/** The number of Unicode line break classes. */
+		ELineBreakClasses
+		};
+
+	IMPORT_C virtual TUint LineBreakClass(TUint aCode,
+		TUint& aRangeStart, TUint& aRangeEnd) const;
+	IMPORT_C virtual TBool LineBreakPossible(TUint aPrevClass, TUint aNextClass,
+		TBool aHaveSpaces) const;
+	IMPORT_C virtual TBool GetLineBreakInContext(const TDesC16& aText,
+		TInt aMinBreakPos, TInt aMaxBreakPos, TBool aForwards,
+		TInt& aBreakPos) const;
+	IMPORT_C virtual TBool IsHangingCharacter(TUint aChar) const;
+	IMPORT_C TBool GetLineBreak(const TDesC16& aText,
+		TInt aMinBreakPos, TInt aMaxBreakPos, TBool aForwards,
+		MContingentLineBreaker* aCbDelegate,
+		TInt& aBreakPos, TInt& aBreakPosAfterSpaces) const;
+	IMPORT_C TBool GetLineBreakL(const TDesC16& aText,
+		TInt aMinBreakPos, TInt aMaxBreakPos, TBool aForwards,
+		MContingentLineBreakerL* aCbDelegate,
+		TInt& aBreakPos, TInt& aBreakPosAfterSpaces) const;
+	IMPORT_C virtual void* ExtendedInterface(TUid& aUid) const;
+	};
+
+
+class MContingentLineBreaker
+/**
+Used to determine the line breaks around pictures and other characters with 
+the CB (contingent line break) class in situations where this operation cannot 
+leave. 
+@publishedAll
+@released
+*/
+	{
+public:
+	/** Determines if a break is legal before the picture at aTextPosition. 
+	
+	@param aTextPosition The position of a character of line breaking class ECbLineBreakClass 
+	in the text as supplied to MLineBreaker::GetLineBreak(), which may refer to 
+	a picture.
+	@param aPrecedingClass The class of the character preceding aTextPosition.
+	@param aHasSpaces ETrue if spaces separate the preceding class from this.
+	@return ETrue if a line break is legal here. */
+	virtual TBool IsLegalBreakBefore(TInt aTextPosition, TInt aPrecedingClass,
+		TBool aHasSpaces) = 0;
+	/** Determines if a break is legal after the picture at aTextPosition. 
+	
+	@param aTextPosition The position of a character of line breaking class ECbLineBreakClass 
+	in the text as supplied to MLineBreaker::GetLineBreak, which may refer to 
+	a picture.
+	@param aFollowingClass The class of the character immediately following aTextPosition.
+	@param aHasSpaces ETrue if spaces separate the following class from this.
+	@return ETrue if a line break is legal here. */
+	virtual TBool IsLegalBreakAfter(TInt aTextPosition, TInt aFollowingClass,
+		TBool aHasSpaces) = 0;
+	};
+
+
+
+class MContingentLineBreakerL
+/**
+Used to determine the line breaks around pictures and other characters with 
+the CB (contingent line break) class in situations where this operation may 
+leave. 
+@publishedAll
+@released
+*/
+	{
+public:
+	/** Determines if a break is legal before the picture at aTextPosition. 
+	
+	@param aTextPosition The position of a character of line breaking class ECbLineBreakClass 
+	in the text as supplied to MLineBreaker::GetLineBreak(), which may refer to 
+	a picture.
+	@param aPrecedingClass The class of the character preceding aTextPosition.
+	@param aHasSpaces ETrue if spaces separate the preceding class from this.
+	@return ETrue if a line break is legal here. */
+	virtual TBool IsLegalBreakBeforeL(TInt aTextPosition, TInt aPrecedingClass,
+		TBool aHasSpaces) = 0;
+	/** Determines if a break is legal after the picture at aTextPosition. 
+	
+	@param aTextPosition The position of a character of line breaking class ECbLineBreakClass 
+	in the text as supplied to MLineBreaker::GetLineBreak(), which may refer to 
+	a picture.
+	@param aFollowingClass The class of the character immediately following aTextPosition.
+	@param aHasSpaces ETrue if spaces separate the preceding class from this.
+	@return ETrue if a line break is legal here. */
+	virtual TBool IsLegalBreakAfterL(TInt aTextPosition, TInt aFollowingClass,
+		TBool aHasSpaces) = 0;
+	};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/ShapeImpl.h	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,86 @@
+// Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef SHAPEIMPL_H_
+#define SHAPEIMPL_H_
+
+#include <e32cmn.h>
+
+/**@file
+@internalTechnology
+*/
+
+class CFont;
+class TDesC16;
+
+const TUid KFontGetShaping = {0x10274246};
+const TUid KFontDeleteShaping = {0x102744D7};
+
+/** Internal class describing shaping information. */
+class TShapeHeader
+	{
+public:
+	/** Number of glyphs output. */
+	TInt iGlyphCount;
+	/** Number of characters consumed from the input. */
+	TInt iCharacterCount;
+	/** Reserved for future expansion. */
+	TInt iReserved0;
+	/** Reserved for future expansion. */
+	TInt iReserved1;
+	/** The glyph, position and indices data.
+
+	The first iGlyphCount * 4 bytes contain the glyph codes
+	as 2-byte values. The next iGlyphCount * 4 + 4 bytes contain the
+	positions in which these glyphs are to be drawn, in pixels, taking
+	the original pen position as origin, with the x axis going right and
+	the y axis going down. The next iGlyphCount * 2 bytes contain the
+	indices of the characters in the input string that correspond to the
+	glyphs in the output.
+	
+	The final entry in the position array is the total advance of the text.
+
+	Therefore this buffer is actually iGlyphCount * 10 + 4 bytes long. */
+	TInt8 iBuffer[1];
+	};
+
+/** For CFont::ExtendedFunctions aParam argument, with KFontGetShaping
+function ID. */
+class TFontShapeFunctionParameters
+	{
+public:
+	/** The text, including context. */
+	const TDesC16* iText;
+	/** The start of the meat within iText. */
+	TInt iStart;
+	/** The end of the meat within iText. */
+	TInt iEnd;
+	/** Script code. */
+	TInt iScript;
+	/** Language code. 0 for default. */
+	TInt iLanguage;
+	/** Output from the shaper; a TShapeHeader on the shared heap. */
+	const TShapeHeader* iShapeHeaderOutput;
+	};
+
+/** For CFont::ExtendedFunctions aParam argument, with KFontDeleteShaping
+function ID. */
+class TFontShapeDeleteFunctionParameters
+	{
+public:
+	const TShapeHeader* iShapeHeader;
+	};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/ShapeInfo.h	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,59 @@
+// Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef SHAPEINFO_H_
+#define SHAPEINFO_H_
+
+#include <e32cmn.h>
+
+class CFont;
+class TDesC16;
+class TShapeHeader;
+
+/** Holds shaping information for text that requires it (for example Indic
+text).
+@publishedAll
+@released
+*/
+class RShapeInfo
+	{
+public:
+	struct TPoint16
+		{
+		TInt16 iX;
+		TInt16 iY;
+		};
+	IMPORT_C RShapeInfo();
+	TInt Open(const CFont* aFont, const TDesC16& aText,
+		TInt aStartOfTextToShape, TInt aEndOfTextToShape,
+		TInt aScriptCode, TInt aLanguageCode);
+	IMPORT_C void Close();
+	TInt GlyphCount() const;
+	const TInt32* Glyphs() const;
+	const TPoint16* GlyphPositions() const;
+	TPoint16 Advance() const;
+	const TInt16* Indices() const;
+	TInt EndOfShapedText();
+	IMPORT_C TBool IsOpen();
+	void SetContext(TAny* aContextualProcessFunc);
+	TAny* GetContext();
+private:
+	const CFont* iFont;
+	const TShapeHeader* iHeader;
+	TInt iEndOfShapedText;
+	TAny* iContextualProcessFunc;
+	};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/gdiinline.inl	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,95 @@
+// Copyright (c) 1998-2010 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:
+// Contains the inline functions IsAlphaChannel, QuoteOrBracketPair and IsIgnoredCharacterForLocalisedProcFunc.
+// 
+//
+#ifndef GDIINLINE_INL
+#define GDIINLINE_INL
+
+	
+/** Utility function to check if a display mode has Alpha channel information
+@param aDisplayMode - the display mode being queried
+@return ETrue if display mode contains Alpha information.
+@internalTechnology
+@released
+*/
+inline TBool IsAlphaChannel(TDisplayMode aDisplayMode)
+	{
+	if(aDisplayMode == EColor16MAP || aDisplayMode == EColor16MA) 
+		return ETrue;
+	else
+		return EFalse;
+	}
+
+/**
+@internalTechnology
+@released
+*/
+inline TUint QuoteOrBracketPair(TUint code)
+	{
+	// given the opening/closing quote or bracket, return the corresponding closing/opening quote or bracket
+	switch(code)
+		{
+		case 0x0022: return 0x0022; // "..."
+		case 0x0027: return 0x0027; // '...'
+		case 0x0028: return 0x0029; // (...)
+		case 0x003c: return 0x003e; // <...>
+		case 0x005b: return 0x005d; // [...]
+		case 0x007b: return 0x007d; // {...}
+		case 0x2018: return 0x2019; // Single quotation marks
+		case 0x201b: return 0x2019; // Single high-reversed-9 quotation mark
+		case 0x201c: return 0x201d; // Double quotation marks
+		case 0x201f: return 0x201d; // Double high-reversed-9 quotation mark
+		case 0x2035: return 0x2032; // Single primes
+		case 0x2036: return 0x2033; // Double primes
+		case 0x2037: return 0x2034; // Triple primes
+		case 0x2039: return 0x203a; // Single left/right-pointing angle quotation marks
+		case 0x2045: return 0x2046; // Square brackets with quill
+		
+		case 0x0029: return 0x0028; // (...)
+		case 0x003e: return 0x003c; // <...>
+		case 0x005d: return 0x005b; // [...]
+		case 0x007d: return 0x007b; // {...}
+		case 0x2019: return 0x2018; // Single quotation marks
+		case 0x201d: return 0x201c; // Double quotation marks
+		case 0x2032: return 0x2035; // Single primes
+		case 0x2033: return 0x2036; // Double primes
+		case 0x2034: return 0x2037; // Triple primes
+		case 0x203a: return 0x2039; // Single left/right-pointing angle quotation marks
+		case 0x2046: return 0x2045; // Square brackets with quill
+				
+		default: return 0;
+		}
+	}
+
+/**
+@internalTechnology
+@released
+*/	
+inline TBool IsIgnoredCharacterForLocalisedProcFunc(TChar aCode)
+	{
+	TChar::TBdCategory cat = aCode.GetBdCategory();
+
+	if ((cat == TChar::ELeftToRight ||
+		cat == TChar::ERightToLeft ||
+		cat == TChar::ERightToLeftArabic) && aCode != 0 && aCode != 0xFFFF)
+		return EFalse;
+	
+	return ETrue;
+	}
+
+
+
+
+#endif /* GDIINLINE_INL */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/gdiplatapi.h	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,79 @@
+// Copyright (c) 1998-2010 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef __GDIPLATAPI_H__
+#define __GDIPLATAPI_H__
+
+#include <e32base.h>
+
+/*
+ * Please note that RFontTable API is officially supported from SymTB10.1.
+ * It is not guaranteed to work in SymTB9.2 or earlier.
+ * 
+ * The class keeps the parameter 'aFont', and will use it in Close(). 
+ * Destructing the CFont object before calling Close() can result in Panic.
+ * 
+ * @publishedPartner
+ */
+class RFontTable 
+    {
+public:
+    IMPORT_C RFontTable();
+    IMPORT_C TInt Open(CFont& aFont, TUint32 aTag);
+    IMPORT_C TInt TableLength() const;
+    IMPORT_C const TUint8* TableContent() const;
+    IMPORT_C void Close();
+private:
+    TAny* iTableContent;
+    TInt iLength;
+    
+    // need to remember font and table name, to be used in releasing the table
+    const CFont* iFont;
+    TUint32 iTag;
+    };
+
+
+/*
+ * Please note that RGlyphOutlineIterator API is officially supported 
+ * from SymTB10.1. It is not guaranteed to work in SymTB9.2 or earlier.
+ * 
+ * The class keeps the parameter 'aFont', and will use it in Close(). 
+ * Destructing the CFont object before calling Close() can result in Panic.
+ * 
+ * @publishedPartner
+ */
+class RGlyphOutlineIterator 
+    {
+public:
+    IMPORT_C RGlyphOutlineIterator();
+    IMPORT_C TInt Open(CFont& aFont, const TUint* aCodes, TInt aCount, TBool aHinted = EFalse);
+    IMPORT_C TInt Next();
+    IMPORT_C const TUint8 *Outline() const;
+    IMPORT_C TInt OutlineLength() const;
+    IMPORT_C void Close();
+private:
+    TAny** iOutlines;
+    TInt* iLengths;
+    TInt iCursor;
+    TInt iCount;
+    
+    // these information is needed in Close().
+    const CFont* iFont;
+    TUint* iCodes;
+    TBool iHinted;
+    };
+
+
+#endif __GDIPLATAPI_H__

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/glyphsample.h	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,55 @@
+// Copyright (c) 1998-2010 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:
+// GlyphSample class.
+
+#ifndef GLYPHSAMPLE_H
+#define GLYPHSAMPLE_H
+
+/**
+Provides methods to map a TLanguage type to some pre-defined glyph samples.
+Samples are defined per writing script, e.g. specifying ELangFrench or
+ELangGerman will return the same set of samples.
+These samples are typically the tallest and 'deep'est characters w.r.t
+various scripts, useful for font rasterizers when calculating metrics.
+@internalTechnology
+*/
+NONSHARABLE_CLASS(GlyphSample)
+	{
+public:
+	/**
+	Writing scripts defined according to Unicode.
+	*/
+	enum TScript
+		{
+		EScriptDefault			= 0x0,	// No script, can't be bothered
+		EScriptNone				= 0x1,	// No script, really
+		EScriptOther			= 0x2,	// Unsupported scripts
+		EScriptLatin			= 0x3,	// European
+		EScriptGreek			= 0x4,	// European
+		EScriptCyrillic			= 0x5,	// European
+		EScriptHebrew			= 0x6,	// Middle Eastern
+		EScriptArabic			= 0x7,	// Middle Eastern
+		EScriptDevanagari		= 0x8,	// Indic
+		EScriptThai				= 0x9,	// SE Asian
+		EScriptHanIdeographs	= 0xA,	// E Asian
+		};
+public:
+	IMPORT_C static TInt TLanguage2TScript(TLanguage aLanguage);
+	IMPORT_C static const TPtrC TScript2GlyphSample(TInt aScript);
+private:
+	static const TInt KTLanguage2TScript[];
+	static const TText* const KTScript2GlyphSample[];
+	};
+
+#endif /* GLYPHSAMPLE_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/hextree.h	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,74 @@
+// Copyright (c) 2010 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:
+// Hexadecimal trees - declaration
+//
+
+#ifndef HEXTREE_H
+#define HEXTREE_H
+
+#include <e32std.h>
+
+/**
+Base class that provides the implementation for RHexTree, which is just a thin
+template.
+
+An instance of this class can have up to eight 16-way prefix trees, with heights
+from 1 to 8. All the values are stored in the leaves. To find a value from a
+32-bit key, first the key is decomposed into 8 hexadecimal digits and then the
+prefix tree with height matching the number of digits in the key (ignoring zeros
+to the left) is traversed using the sequence of digits in the key as the
+indexing string. Offsets are internally used instead of pointers to allow
+instances to be placed in a heap shared between several processes.
+*/
+class RHexTreeBase
+    {
+public:
+    IMPORT_C void ResetAndDestroy();
+protected:
+    IMPORT_C RHexTreeBase(RHeap* aHeap);
+    IMPORT_C TInt SetAt(TUint aKey, TAny* aValue);
+    IMPORT_C TAny* At(TUint aKey) const;
+private:
+    TInt SetAt(TUint aKey, TAny* aLeaf, TInt aHeight);
+    TInt SetAt(TUint aKey, TAny* aLeaf, TInt aHeight, TAny* aNode, TInt aLevel);
+    TAny* At(TUint aKey, TInt aHeight) const;
+    void ResetAndDestroy(TInt aHeight, TAny* aNode, TInt aLevel);
+private:
+    enum { EMaxNumHexDigits = 8 };
+private:
+    RHeap* iHeap;
+    TInt iRootOffsets[EMaxNumHexDigits];
+    };
+
+/**
+An associative array implementation optimised for the case where the keys are
+32-bit codes with spatial locality of reference. The values can be of any
+self-contained data type (that is, without destructor or clean-up functions).
+It allows multiple-readers, single-writer concurrent access from different
+processes in an SMP-safe manner without locking, excluding deletion of
+individual key-value pairs.
+*/
+template<class T>
+class RHexTree : public RHexTreeBase
+    {
+public:
+    inline RHexTree(RHeap* aHeap);
+    inline TInt SetAt(TUint aKey, T* aValue);
+    inline const T* At(TUint aKey) const;
+    inline T* At(TUint aKey);
+    };
+
+#include <hextree.inl>
+
+#endif // HEXTREE_H

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/hextree.inl	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,83 @@
+// Copyright (c) 2010 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:
+// Hexadecimal trees - inline functions
+//
+
+#ifndef HEXTREE_INL
+#define HEXTREE_INL
+
+/**
+Constructor. It constructs an associative array with no key-value pairs.
+
+@param aHeap A pointer to the heap to be used by the associative array
+       implementation to allocate memory for internal data structures. This
+       heap can be shared between several processes.
+*/
+template<class T>
+inline RHexTree<T>::RHexTree(RHeap* aHeap)
+    : RHexTreeBase(aHeap)
+    {
+    }
+
+/**
+Adds a key-value pair to this associative array.
+
+@param aKey The 32-bit key to add to this associative array.
+@param aValue A pointer to the value to associate with aKey. It must have been
+       allocated on the same heap as the one used by the associative array
+       implementation to allocate memory for internal data structures. Ownership
+       is transferred to this associative array.
+@return KErrNone if the key-value pair was added successfully. KErrNoMemory if
+        there was not enough memory in the heap for internal data structures.
+        KErrAlreadyExists if an attempt was made to add a duplicate key.
+*/
+template<class T>
+inline TInt RHexTree<T>::SetAt(TUint aKey, T* aValue)
+    {
+    return RHexTreeBase::SetAt(aKey, aValue);
+    }
+
+/**
+Looks up a given key in this associative array and returns a pointer to the
+corresponding value.
+
+@param aKey The 32-bit key to look up.
+@return A pointer to the corresponding value in this associative array, if the
+        given key was found. The value may not be modified via this pointer.
+        NULL if the given key was not found.
+*/
+template<class T>
+inline const T* RHexTree<T>::At(TUint aKey) const
+    {
+    return static_cast<T*>(RHexTreeBase::At(aKey));
+    }
+
+/**
+Looks up a given key in this associative array and returns a pointer to the
+corresponding value. Note that if values are modified after being added to an
+associative array, then the user is responsible for synchronisation when
+concurrent access is needed.
+
+@param aKey The 32-bit key to look up.
+@return A pointer to the corresponding value in this associative array, if the
+        given key was found. The value may be modified via this pointer.
+        NULL if the given key was not found.
+*/
+template<class T>
+inline T* RHexTree<T>::At(TUint aKey)
+    {
+    return static_cast<T*>(RHexTreeBase::At(aKey));
+    }
+
+#endif // HEXTREE_INL

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/inc/textbase.h	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,1180 @@
+// Copyright (c) 2010 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:
+// This file is a subset of original gdi.h.
+//
+// IMPORTANT NOTE to maintainer:
+//     If you add new exports, to make sure they are exported by GDI.DLL,
+//     remember to update /graphics/graphicsdeviceinterface/gdi/sgdi/TextBaseStub.cpp.
+//
+// Text related types/consts are moved from gdi.h to this file, as listed below.
+//
+// enum TFontPosture
+// enum TFontStrokeWeight
+// enum TFontPrintPosition
+//
+// const KMaxTypefaceNameLength
+// class TTypeface
+// enum TGlyphBitmapType
+// class FontEffect
+// class TFontStyle
+// class TFontSpec
+// class TTypefaceSupport
+// const KSuperSubScalingPercentage
+// const KSuperscriptOffsetPercentage
+// const KSubscriptOffsetPercentage
+// class CTypefaceStore
+// const KMaxFontCacheEntries
+// class CFontCache
+//
+// const KFontCapitalAscent
+// const KFontMaxAscent
+// const KFontStandardDescent
+// const KFontMaxDescent
+// const KFontLineGap
+// const KFontGetFontTable
+// const KFontGetGlyphOutline
+// const KFontReleaseGlyphOutline
+// const KFontReleaseFontTable
+// class CFont
+
+
+#ifndef __TEXTBASE_H__
+#define __TEXTBASE_H__
+
+#include <e32base.h>
+#include <f32file.h>
+#include <s32std.h>
+
+class TOpenFontCharMetrics;
+class RShapeInfo;
+
+
+#ifndef __GLYPHSEL_TEXTBASE_H__
+#define __GLYPHSEL_TEXTBASE_H__
+/**
+This enumeration holds the possible panic codes that may be raised 
+by the TextBase API on detecting an unrecoverable error. */
+enum TTextBasePanic
+	{
+	/** Not used */
+	ETextBasePanic_Unknown				= 0,
+	/** One or more of the input parameters to the interface were invalid */
+	ETextBasePanic_InvalidInputParam		= 1,
+	/** Insufficient text for successful completion of the method */
+	ETextBasePanic_OutOfText				= 2,
+	/** Internal failure. */
+	ETextBasePanic_Invariant				= 3,
+	/** Reserved panic codes. Not to be used. */
+	ETextBasePanic_Reserved1				= 4,
+	ETextBasePanic_Reserved2				= 5,
+	/** Setting a typeface name that is too long */
+	ETextBasePanic_TypefaceNameOverflow	= 6,
+	};
+#endif
+
+
+/**
+Font posture flags.
+Fonts can be either upright or italic. 
+@publishedAll	
+@released
+*/
+enum TFontPosture
+	{
+	/** Font posture is normal (upright). */
+	EPostureUpright,
+	/** Font posture is italic. */
+	EPostureItalic
+	};
+
+
+/**
+Font stroke weight flags. 
+@publishedAll	
+@released
+*/
+enum TFontStrokeWeight
+	{
+	/** Font stroke weight is normal. */
+	EStrokeWeightNormal,
+	/** Font stroke weight is bold. */
+	EStrokeWeightBold
+	};
+
+/**
+Font print position flags.
+Fonts can be normal, superscript or subscript. 
+@publishedAll	
+@released
+*/
+enum TFontPrintPosition
+	{
+	/** Font is normal. */
+	EPrintPosNormal,
+	/** Font is superscript. */
+	EPrintPosSuperscript,
+	/** Font is subscript. */
+	EPrintPosSubscript
+	};
+
+
+/**
+The maximum length of a typeface name (in characters). 
+@publishedAll	
+@released
+*/
+const TInt KMaxTypefaceNameLength=0x18;
+
+
+/** Typeface name and attributes.
+
+This class identifies a typeface by name, and contains the combination of 
+attributes of the typeface. These attributes define whether it is a symbol 
+typeface, whether the typeface is proportional, and whether it is serif or 
+sans-serif. 
+
+The combination of attributes for a typeface are stored in a bitmask, with 
+the various bits indicating different attributes. The bitmask is calculated 
+for any particular attribute combination by ORing the enumerated value for 
+each individual attribute. 
+@publishedAll 
+@released
+*/
+class TTypeface
+    {
+public:
+	enum
+		{
+		/** Typeface is a proportional typeface (e.g. Swiss)
+		*/
+		EProportional = 1,
+		/** Typeface is a serif typeface (e.g. Times)
+		*/
+		ESerif = 2,
+		/** Typeface is a symbol typeface (e.g. Symbol)
+		*/
+		ESymbol = 4,
+		};
+public:
+	IMPORT_C TTypeface();
+	IMPORT_C TBool operator==(const TTypeface& aTypeface) const;
+	IMPORT_C void InternalizeL(RReadStream& aStream);
+	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+	IMPORT_C void SetAttributes(TInt aAttributes);
+	IMPORT_C void SetIsProportional(TBool aIsProportional);
+	IMPORT_C void SetIsSerif(TBool aIsSerif);
+	IMPORT_C void SetIsSymbol(TBool aIsSymbol);
+	IMPORT_C TInt Attributes() const;
+	IMPORT_C TBool IsProportional() const;
+	IMPORT_C TBool IsSerif() const;
+	IMPORT_C TBool IsSymbol() const;
+	IMPORT_C void SetScriptTypeForMetrics(TLanguage aLanguage);
+	IMPORT_C void SetScriptTypeForMetrics(TInt aScript);
+	IMPORT_C TInt ScriptTypeForMetrics() const;
+	IMPORT_C void SetName(const TDesC& aName);
+	IMPORT_C const TDesC& Name() const;
+private:
+	void ResetAttributes();
+	void ResetScriptType();
+public:
+	/** The typeface name. */
+    TBufC<KMaxTypefaceNameLength> iName;
+private:
+    TUint32 iFlags;
+    };
+
+
+/**
+An enumerated type for the format of a glyph bitmap. This type is currently 
+used to indicate whether glyph bitmaps for scalable fonts are drawn anti-aliased. 
+Additional values may be defined in the future.
+
+@see TFontStyle::SetBitmapType()
+@see CFbsTypefaceStore::SetDefaultBitmapType() 
+@publishedAll
+@released	
+*/
+enum TGlyphBitmapType
+	{
+	/** The font store's default glyph bitmap format is used. */
+	EDefaultGlyphBitmap = 0,
+	/** The standard monochrome format: no anti-aliasing, 1 bit per pixel, 
+	run-length encoded. */
+	EMonochromeGlyphBitmap,
+	/** Standard 8-bits-per-pixel with anti-aliasing. */
+	EAntiAliasedGlyphBitmap,
+	/** The format used when sub-pixel font rendering is used. */
+	ESubPixelGlyphBitmap,
+	/** The format used when outline and shadow font rendering is used. 
+
+	If the raterizer supports the outline and shadow fonts, it will set the bitmaptype as 
+	EFourColourBlendGlyphBitmap but only when glyph bitmap type is set as EAntiAliasedGlyphBitmap and 
+	when any of the EDropShadow or EOutline effect is on. Only rasterizer providers can use this enum.
+	*/
+	EFourColourBlendGlyphBitmap,
+	/**
+	This is used for glyphs, and not fonts, and is needed to inform the font drawing routines
+	that the character should be drawn using the overall font setting. 
+	For Internal Use Only.
+	*/
+	EGlyphBitmapTypeNotDefined,
+	/**
+	This is used to inform the rasterizer that the best match should be
+	found for the bitmap type based upon its knowledge.
+	For Internal Use Only.
+	*/
+	EAntiAliasedOrMonochromeGlyphBitmap,
+	};
+
+/**
+Defines a set of font effects flags.
+
+@publishedAll 
+@released
+WARNING: This Class is for use by system/UI software ONLY.
+*/
+NONSHARABLE_CLASS(FontEffect)
+	{
+public:
+	enum TEffect
+		{
+		ENone			= 0x0,		// No effects.
+		EAlgorithmicBold= 0x10,		// Font is algorithmic bold (a.k.a pseudo bold.)
+		EDropShadow		= 0x20,		// Font has a drop shadow.
+		EOutline		= 0x40,		// Font is an outline font.
+		EEmbossed		= 0x80,		// Font is embossed.
+		EEngraved		= 0x100,	// Font is engraved.
+		ESoftEdge		= 0x200,	// Font is soft edged.
+		EReserved1		= 0x400,	// Reserved for Symbian use.
+		EReserved2		= 0x800,	// Reserved for Symbian use.
+		EReserved3		= 0x1000,	// Reserved for Symbian use.
+		EReserved4		= 0x2000,	// Reserved for Symbian use.
+		EReserved5		= 0x4000,	// Reserved for Symbian use.
+		EReserved6		= 0x8000,	// Reserved for Symbian use.
+		};
+public:
+	IMPORT_C static TBool IsEffectOn(TEffect aEffect, TUint32 aFontEffect);
+	IMPORT_C static void SetEffect(TEffect aEffect, TBool aOn, TUint32& aFontEffect);
+	};
+
+/** Encapsulates a font style. 
+
+The font style information is comprised of:
+
+the posture of the font upright or italic
+
+the stroke weight of the font  normal or bold
+
+the print position of the font normal, subscript or superscript
+
+Note that the underline and strike-through attributes are not included in 
+this class, but are set in the graphics context.
+
+@see CGraphicsContext::SetUnderlineStyle()
+@see CGraphicsContext::SetStrikethroughStyle() 
+@publishedAll
+@released
+*/
+class TFontStyle
+	{
+public:
+	IMPORT_C TFontStyle();
+	IMPORT_C TFontStyle(TFontPosture aPost,TFontStrokeWeight aStrWgt,TFontPrintPosition aPrintPos);
+	IMPORT_C void InternalizeL(RReadStream& aStream);
+	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+	IMPORT_C TFontPosture Posture() const;
+	IMPORT_C TFontStrokeWeight StrokeWeight() const;
+	IMPORT_C TFontPrintPosition PrintPosition() const;
+	IMPORT_C void SetPosture(TFontPosture aPosture);
+	IMPORT_C void SetStrokeWeight(TFontStrokeWeight aStrokeWeight);
+	IMPORT_C void SetPrintPosition(TFontPrintPosition aPrintPosition);
+	inline TGlyphBitmapType BitmapType() const;
+	inline void SetBitmapType(TGlyphBitmapType aBitmapType);
+	IMPORT_C TBool operator==(const TFontStyle& aFontStyle) const;
+	IMPORT_C TUint32 Effects() const;
+	IMPORT_C TBool IsEffectOn(FontEffect::TEffect aEffect) const;
+	IMPORT_C void SetEffects(TUint32 aEffects);
+	IMPORT_C void SetEffects(FontEffect::TEffect aEffect, TBool aOn);
+private:
+	enum
+		{
+		EItalic=0x1,
+		EBold=0x2,
+		ESuper=0x4,
+		ESub=0x8
+		};
+private:
+	TUint32 iFlags; // bitmap type - 16 bits (high), font effects - 12 bits (middle), style - 4 bits (low)
+	TAny* iReserved1;
+	TAny* iReserved2;
+	};
+
+
+
+/**
+Specifies the font specification in device independent terms.
+@publishedAll 
+@released
+*/
+class TFontSpec
+	{
+public:
+	IMPORT_C TFontSpec();
+	IMPORT_C TFontSpec(const TDesC& aTypefaceName,TInt aHeight);
+	IMPORT_C TBool operator==(const TFontSpec& aFontSpec) const;
+	IMPORT_C void InternalizeL(RReadStream& aStream);
+	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+	IMPORT_C void SetScriptTypeForMetrics(TLanguage aLanguage);
+	IMPORT_C TInt ScriptTypeForMetrics() const;
+public:
+	/** The typeface. */
+	TTypeface iTypeface;
+	/** The height of the typeface (in twips). */
+	TInt iHeight;
+	/** The font style of the typeface. */
+	TFontStyle iFontStyle;
+	};
+
+
+
+/** Typeface family support information.
+
+This data-only class includes the name and attributes of a typeface, how many 
+font heights are available, its minimum and maximum heights, and whether or 
+not it is scaleable  a typeface is scaleable if it supports heights at 
+fixed intervals between the minimum and maximum heights. 
+@publishedAll 
+@released
+*/
+class TTypefaceSupport
+    {
+public:
+	/** The name and attributes of the typeface. */
+    TTypeface iTypeface;
+	/** The number of distinct font heights available in the typeface. */
+    TInt iNumHeights;
+	/** The typeface's minimum font height, in twips. */
+    TInt iMinHeightInTwips;
+	/** The typeface's maximum font height, in twips. */
+    TInt iMaxHeightInTwips;
+	/** Whether the typeface is scaleable. ETrue if it is scaleable, otherwise 
+	EFalse. */
+    TBool iIsScalable; // supports heights from min to max at fixed interval
+    };
+
+/**
+The percentage used to multiply a normal font height when calculating its 
+superscript or subscript height. 
+@publishedAll	
+@released
+*/
+const TInt KSuperSubScalingPercentage=67;
+
+/**
+The percentage of a font height used to calculate its baseline offset for a 
+superscript print position. 
+@publishedAll	
+@released
+*/
+const TInt KSuperscriptOffsetPercentage=-28;
+
+/**
+The percentage of a font height used to calculate its baseline offset for a 
+subscript print position. 
+@publishedAll	
+@released
+*/
+const TInt KSubscriptOffsetPercentage=14;
+
+class CFont;
+
+/** Typeface store abstract base interface.
+
+This class provides the interface to a store for typefaces.
+
+See also CFontStore. 
+@publishedAll
+@released
+*/
+class CTypefaceStore : public CBase
+	{
+public:
+	IMPORT_C ~CTypefaceStore();
+
+	/**
+	Gets the font which is the nearest to the given font specification.
+
+	When the font is no longer needed, call @c ReleaseFont().
+
+	Note that this deprecated function is replaced by the new @c GetNearestFontToDesignHeightInTwips() 
+	yielding (virtually) the same result. However clients are strongly encouraged to use the new
+	@c GetNearestFontToMaxHeightInTwips() function instead. This will guarantee that every 
+	character within any given text string will fit within the given amount of twips, whereas the design 
+	height is an aesthetic unit decided by the font designer without strict physical meaning, which 
+	may result in cropped characters.
+
+	@param aFont On return, contains a pointer to the nearest font.
+	@param aFontSpec The specification of the font to be matched.
+	@return KErrNone if successful; a system-wide error code otherwise.
+	@publishedAll
+	@deprecated Use GetNearestFontToDesignHeightInTwips
+	*/
+	virtual TInt GetNearestFontInTwips(CFont*& aFont, const TFontSpec& aFontSpec) = 0;
+
+	/**
+	Gets the font which is the nearest to the given font specification.
+	
+	When the font is no longer needed, call @c ReleaseFont().
+
+	This new function replaces the deprecated @c GetNearestFontInTwips() yielding (virtually) the 
+	same result. However clients are strongly encouraged to use the new
+	@c GetNearestFontToMaxHeightInTwips() function instead. This will guarantee that every 
+	character within any given text string will fit within the given amount of twips, whereas the design 
+	height is an aesthetic unit decided by the font designer without strict physical meaning, which 
+	may result in cropped characters.
+
+	@param aFont On return, contains a pointer to the nearest font.
+	@param aFontSpec The specification of the font to be matched.
+	@return KErrNone if successful; a system-wide error code otherwise.
+	@publishedAll
+	@released
+	*/
+	virtual TInt GetNearestFontToDesignHeightInTwips(CFont*& aFont, const TFontSpec& aFontSpec) = 0;
+	
+	/**
+	Gets the font which is the nearest to the given font specification.
+	
+	When the font is no longer needed, call @c ReleaseFont().
+
+	The font and bitmap server returns a pointer to the nearest matching font 
+	from those available. Matches to max height of font - this does its best 
+	to return a font that will fit within the maximum height specified (but 
+	note that variations due to hinting algorithms may rarely result in this 
+	height being exceeded by up to one pixel). Problems can also be 
+	encountered with bitmap fonts where the typeface exists but doesn't have 
+	a font small enough.
+
+	@param aFont On return, contains a pointer to the nearest font.
+	@param aFontSpec The specification of the font to be matched.
+	@param aMaxHeight The maximum height within which the font must fit.
+	@return KErrNone if successful; a system-wide error code otherwise.
+	@publishedAll
+	@released
+	*/
+	virtual TInt GetNearestFontToMaxHeightInTwips(CFont*& aFont, const TFontSpec& aFontSpec, TInt aMaxHeight) = 0;
+
+	/** Gets the number of typefaces supported by the typeface store.
+	
+	@return The number of supported typefaces. */
+	virtual TInt NumTypefaces() const=0;
+
+	/** Gets typeface information for a specified typeface index.
+ 
+ 	This information is returned in aTypefaceSupport, and
+	includes the typeface name and typeface attributes, the number of font
+ 	heights, the maximum and minimum font heights, and whether it is a
+	scaleable typeface.
+ 
+ 	@param aTypefaceSupport On return, if the function executed successfully, 
+ 	this object contains the typeface information.
+  	@param aTypefaceIndex A typeface index number, in the range: zero to
+             (NumTypefaces() - 1). */
+	virtual void TypefaceSupport(TTypefaceSupport& aTypefaceSupport,TInt aTypefaceIndex) const=0;
+
+	/** Gets the height of the font with specified height and typeface indices, 
+	in twips.
+	
+	The value returned is rounded up or down to the nearest font height in twips.
+	
+	@param aTypefaceIndex A typeface index number, in the range: 0 to 
+	(NumTypefaces() - 1). 
+	@param aHeightIndex A font height index number.
+	@return The height of the font, in twips. */
+	virtual TInt FontHeightInTwips(TInt aTypefaceIndex,TInt aHeightIndex) const=0;
+	IMPORT_C void ReleaseFont(CFont* aFont);
+	IMPORT_C static TInt BaselineOffset(TInt aHeight,TFontPrintPosition aPos);
+	IMPORT_C static TInt SuperSubHeight(TInt aHeight,TFontPrintPosition aPos);
+protected:
+	IMPORT_C CTypefaceStore();
+	IMPORT_C void ConstructL();
+	IMPORT_C void AddFontL(CFont* aFont);
+	IMPORT_C TBool IncrementFontCount(const CFont* aFont);
+private:
+	TBool FindFont(const CFont* aFont, TInt& aIdx) const;
+	NONSHARABLE_CLASS(TFontAccess)
+	/**
+	Pairs a font with a count of how many clients of the typeface store 
+	are accessing that font. 
+    */
+		{
+	public:
+		/** A device specific font. */
+		CFont* iFont;
+		/** The number of clients accessing the font. */
+		TInt iAccessCount;
+		};
+protected:
+	/** A list of fonts accessed by clients of the typeface store, which pairs 
+	a font with a count of the number of clients accessing the font.
+	
+	Implemented as an array of TFontAccess objects.
+	
+	An object is added to this array for every font accessed. If the font is 
+	released by all clients, and the access count drops to zero, the font is 
+	removed from the list. */
+	CArrayFixFlat<TFontAccess>* iFontAccess;
+	};
+
+/** The maximum number of entries in the font cache.
+
+@see CFontCache */
+const TInt KMaxFontCacheEntries=32;
+
+/** Font cache. 
+
+When a CFont* needs to be found for a particular TFontSpec, the cache can 
+be searched to see if the TFontSpec is already in the cache. If the TFontSpec 
+is in the cache, its corresponding CFont* can be returned. Otherwise 
+GetNearestFontInTwips() must be used to search all of the available fonts for 
+the nearest CFont- a procedure which takes much longer than a simple cache
+search.
+
+The current font cache should be destroyed and a new cache created whenever 
+the zoom factor or device map changes, as these changes break the relation 
+between CFont and TFontSpec. 
+@publishedAll
+@released
+*/
+class CFontCache : public CBase
+	{
+public:
+	IMPORT_C CFontCache();
+	IMPORT_C CFontCache(TInt aMaxEntries);
+	IMPORT_C ~CFontCache();
+	IMPORT_C CFont* Search(const TFontSpec& aFontSpec);
+	IMPORT_C CFont* AddEntryL(CFont* aFont,const TFontSpec& aFontSpec);
+	IMPORT_C CFont* RemoveFirstEntry();
+public:
+	/** The number of cache hits since the font cache was created i.e. 
+	successful results from CFontCache::Search(). */
+	TInt iNumHits;
+	/** The number of cache misses since the font cache was created i.e. 
+	unsuccessful results from CFontCache::Search(). */
+	TInt iNumMisses;
+private:
+	class CFontCacheEntry : public CBase
+		{
+	public:
+		CFontCacheEntry(CFont* aFont,const TFontSpec& aFontSpec,CFontCacheEntry* aNext);
+	public:
+		CFont* iFont;
+		TFontSpec iSpec;
+		CFontCacheEntry* iNext;
+		};
+private:
+	TInt iNumEntries;
+	TInt iMaxEntries;
+	CFontCacheEntry* iFirst;
+	};
+
+/**
+WARNING: this Class is for internal use ONLY.  Compatibility is not guaranteed in future releases.
+UIDs corresponding to the CFont API extension functions
+@internalTechnology
+*/
+const TUid KFontCapitalAscent	= {0x1020498E};
+const TUid KFontMaxAscent		= {0x10204B10};
+const TUid KFontStandardDescent	= {0x10204B11};
+const TUid KFontMaxDescent		= {0x10205AFC};
+const TUid KFontLineGap			= {0x10204B12};
+const TUid KFontGetFontTable    = {0x102872C1};
+const TUid KFontGetGlyphOutline = {0x102872C2};
+const TUid KFontReleaseGlyphOutline = {0x2002A1FD};
+const TUid KFontReleaseFontTable = {0x2002AC24};
+
+
+/** Abstract font interface.
+
+The CFont class provides a device-independent interface to a device-dependent 
+font usually obtained from a call to GetNearestFont...() on a graphics device. 
+It is used as a handle in CGraphicsContext::UseFont() and to obtain 
+device-dependent information about the font - notably the pixel width of a text 
+string.
+
+@see CFbsFont
+@see CGraphicsContext::UseFont() 
+@publishedAll 
+@released
+*/
+class CFont : public CBase
+	{
+	friend class CTypefaceStore;
+public:
+
+	/** Text direction flags.
+
+	This enum is used in TMeasureTextInput and determines whether the text is 
+	drawn horizontally or vertically. Note: text is drawn vertically in some 
+	styles of Japanese, etc.
+
+	@see TMeasureTextInput */
+	enum TTextDirection
+		{
+	/** Text is drawn horizontally. */
+ 		/** Text is drawn horizontally. */
+   		EHorizontal,
+ 		/** Text is drawn vertically. */
+		EVertical
+		};
+
+	/** Complicated parameter block used for contextual glyph selection, 
+	ligature creation and diacritic placement when drawing text in complex 
+	scripts
+
+	This class declares a constructor, another scoped class, and several other 
+	enums. However this class is unlikely to be useful to third party developers.
+
+	@see CFont::GetCharacterPosition()
+	@see CFont::GetCharacterPosition2()
+	@publishedAll
+	@released
+	*/
+	class TPositionParam
+		{
+	public:
+		/** Standard constructor. */
+		TPositionParam():
+			iDirection(EHorizontal),
+			iFlags(0),
+			iPosInText(0),
+			iOutputGlyphs(0)
+			{
+			}
+
+		enum
+			{
+			EMaxInputChars = 18,	// ligatures cannot be made from more than 18 components
+			EMaxOutputGlyphs = 8	// output can consist of up to 8 characters (one base and 7 combining characters)
+			};
+
+		/**Flags for TPositionParam::iFlags. */
+		enum TFlags
+			{
+			/** Input text is logically ordered not visually ordered. */
+			EFLogicalOrder = 1
+			};
+
+		/** Input: Orientation (EHorizontal or EVertical) in which to draw
+		the text. */
+		TInt16 iDirection;
+		/** Input: Flags from TFlags. */
+		TUint16 iFlags;
+		/** Input: Text containing the characters to be positioned. */
+		TPtrC iText;
+
+		/** Input and output: Position within iText to shape. On exit
+		it will index the first character not positioned */
+		TInt iPosInText;
+		/** Input and output: Pen position. */
+		TPoint iPen;			
+
+		/** Output of GetCharacterPosition and GetCharacterPosition2.
+		@see CFont::GetCharacterPosition
+		@see CFont::GetCharacterPosition2
+		@publishedAll
+		@released */
+		class TOutput
+			{
+		public:
+			/** Standard constructor. */
+			TOutput() : iBitmapSize(TSize::EUninitialized),
+				iBounds(TRect::EUninitialized) {}
+			/** Character or glyph code. */
+			TUint iCode;			
+			/** Bitmap data for the glyph, if available */
+			const TUint8* iBitmap;	
+			/** Size of the bitmap before algorithmic bolding, size 
+			multiplication, etc. */
+			TSize iBitmapSize;		
+			/** Bitmap bounds relative to the original pen position. */
+			TRect iBounds;			
+			};
+
+		/** Information about the glyphs that were output. */
+		TOutput iOutput[EMaxOutputGlyphs];	
+		/** Number of glyphs actually output. */
+		TInt iOutputGlyphs;					
+		};	
+
+
+	/** Input parameter block.
+
+	This is optionally used by CFont::MeasureText(), which is the powerful text 
+	measurement function underlying all the other text measurement functions.
+
+	@see CFont::MeasureText() 
+	@publishedAll
+	@released
+	*/
+	class TMeasureTextInput
+		{
+	public:
+		TMeasureTextInput():
+			iStartInputChar(0),
+			iEndInputChar(KMaxTInt),
+			iDirection(EHorizontal),
+			iFlags(0),
+			iMaxAdvance(KMaxTInt),
+			iMaxBounds(KMaxTInt),
+			iCharJustNum(0),
+			iCharJustExcess(0),
+			iWordJustNum(0),
+			iWordJustExcess(0)
+			{
+			}
+
+		/**Flags for TMeasureTextInput::iFlags. */
+		enum TFlags
+			{
+ 			/** Input text is visually ordered left-to-right. */
+ 			EFVisualOrder = 1,
+ 			/** Input text is visually ordered right-to-left.
+ 			Overrides EFVisualOrder. */
+ 			EFVisualOrderRightToLeft = 2,
+ 			/** Flag to consider side bearings when checking bounds for line-break */
+ 			EFIncludePenPositionInBoundsCheck = 4
+			};
+
+		/** Starting index specifying first input character in iText.
+	
+		Together with iEndInputChar, this allows some context before and 
+		after the measured text to be supplied so that shaping can work 
+		properly. */
+		TInt iStartInputChar;	
+	
+		/** Index specifying the final input character.
+	
+		Together with iStartInputChar, this allows some context before and 
+		after the measured text to be supplied so that shaping can work 
+		properly. */
+		TInt iEndInputChar;		
+	
+		/** The direction in which to draw the text. */
+		TUint16 iDirection;
+	
+		/** Flags from TFlags. */
+		TUint16 iFlags;
+	
+		/** The maximum advance. */
+		TInt iMaxAdvance;		
+		
+		/** The maximum width (or height if drawing vertically) of bounds. */
+		TInt iMaxBounds;		
+	
+		/** The number of glyph groups to be letter-spaced. */
+		TInt iCharJustNum;		
+	
+		/** The amount of space to be used for letter spacing. */
+		TInt iCharJustExcess;	
+		
+		/** The number of spaces to be used for word spacing. */
+		TInt iWordJustNum;		
+	
+		/** The amount of space to be used for word spacing. */
+		TInt iWordJustExcess;	
+		};
+
+	/** Output parameter block.
+
+	This is optionally used by CFont::MeasureText(), which is the powerful text 
+	measurement function underlying all the other text measurement functions.
+
+	@see CFont::MeasureText() 
+	@publishedAll
+	@released
+	*/
+	class TMeasureTextOutput
+		{
+		public:
+		/** The number of input characters that would be drawn.
+	
+		This may be less than the length of the text if a maximum advance or bounding 
+		box size is specified. */
+		TInt iChars;			
+		/** The number of glyphs that would be drawn. */
+		TInt iGlyphs;			
+		/** The number of groups that would be drawn.
+	
+		A group is a base glyph plus one or more combining characters. */
+		TInt iGroups;			
+		/** The number of word spaces (U+0020) that would be drawn. */
+		TInt iSpaces;			
+		/** The bounding box of all the glyphs that would be drawn. */
+		TRect iBounds;			
+		/** The maximum width and height of any glyph. */
+		TSize iMaxGlyphSize;	
+		};
+
+	/**
+	Data availability flags.
+
+	Some fonts like printer fonts may only have width information and can return 
+	ECharacterWidthOnly to show this: the text drawing routines in CFont synthesize 
+	the rest of the data if necessary.
+
+	@see GetCharacterData() 
+	@publishedAll	
+	@released
+	*/
+	enum TCharacterDataAvailability
+		{
+		/** No font information available. */
+		ENoCharacterData,
+		/** Width information only is available. */
+		ECharacterWidthOnly,
+		/** All character data is available. */
+		EAllCharacterData
+		};
+
+private:
+	// virtual functions have been made protected and public non-virtual ones
+	// added to convert CFont to a handle-body pattern. SC is kept throught the
+	// new functions and BC is kept by keeping the protected functions in the
+	// same place in the class, and therefore in the same place in the vtable
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TUid DoTypeUid() const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoHeightInPixels() const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoAscentInPixels() const=0;
+	IMPORT_C virtual TInt DoDescentInPixels() const;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoCharWidthInPixels(TChar aChar) const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoTextWidthInPixels(const TDesC& aText) const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoBaselineOffsetInPixels() const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoTextCount(const TDesC& aText,TInt aWidthInPixels) const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoTextCount(const TDesC& aText,TInt aWidthInPixels,TInt& aExcessWidthInPixels) const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoMaxCharWidthInPixels() const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TInt DoMaxNormalCharWidthInPixels() const=0;
+	/**
+	@publishedAll
+	WARNING: Function for internal use ONLY.  Compatibility is not guaranteed in future releases. Please see derived class for implementation.
+	*/
+	virtual TFontSpec DoFontSpecInTwips() const=0;
+
+protected:	
+	IMPORT_C virtual TCharacterDataAvailability DoGetCharacterData(TUint aCode, TOpenFontCharMetrics& aMetrics,const TUint8*& aBitmap,TSize& aBitmapSize) const;
+	IMPORT_C virtual TBool DoGetCharacterPosition(TPositionParam& aParam) const;
+	IMPORT_C virtual TInt DoExtendedFunction(TUid aFunctionId, TAny* aParam = NULL) const;
+
+protected:
+	IMPORT_C virtual ~CFont();
+
+public:
+	inline TInt FontCapitalAscent() const;
+	inline TInt FontMaxAscent() const;
+	inline TInt FontStandardDescent() const;
+	inline TInt FontMaxDescent() const;
+	inline TInt FontLineGap() const;
+	inline TInt FontMaxHeight() const;
+
+public:
+	/** Gets run-time identity of the actual font type. This enables safe casting to 
+	a derived type.
+	
+	For example, if the derived type is a CFbsFont, the return value is KCFbsFontUid. 
+	You would need to cast to a CFbsFont to get a character bounding box. Similarly, 
+	a CBitmapFont returns KCBitmapFontUidVal.
+	
+	@return The font-type identifier. */
+	IMPORT_C TUid TypeUid() const;
+
+	/** Gets the font height in pixels.
+	Note that this deprecated function is replaced by the new @c FontMaxHeight().
+
+	@return The font height in pixels.
+	@see FontMaxHeight()
+	@deprecated */
+	IMPORT_C TInt HeightInPixels() const;
+
+	/** Gets the font ascent in pixels.
+	Note that this deprecated function is replaced by the new @c FontMaxAscent()
+	or in some cases @c FontCapitalAscent().	
+	
+	@return The font ascent in pixels.
+	@see FontCapitalAscent()
+	@see FontMaxAscent()
+	@deprecated */
+	IMPORT_C TInt AscentInPixels() const;
+	
+	/** Gets the font descent in pixels.
+	Note that this deprecated function is replaced by the new @c FontMaxDescent()
+	or in some cases @c FontStandardDescent().	
+	
+	@return The font descent in pixels.
+	@see FontStandardDescent() 
+	@see FontMaxDescent()
+	@deprecated */
+	IMPORT_C TInt DescentInPixels() const;
+
+	/** Gets the width in pixels in this font of the specified character.
+	
+	Note: For OpenType fonts this function returns the horizontal advance of
+	the character, which may be different from the actual width.
+	
+	@param aChar The character whose width should be determined. 
+	@return The width in pixels of the specified character in this font. */
+	IMPORT_C TInt CharWidthInPixels(TChar aChar) const;
+
+	/** Gets the width in pixels of the specified descriptor when displayed in this 
+	font.
+	
+	@param aText The descriptor whose width should be determined. 
+	@return The width of the specified descriptor when displayed in this font, 
+	in pixels. */
+	IMPORT_C TInt TextWidthInPixels(const TDesC& aText) const;
+
+	/** Gets the baseline offset in pixels. 
+	
+	The baseline offset is how far a font is raised or lowered from its normal 
+	baseline.
+	
+	@return Offset from normal baseline, in pixels. */
+	IMPORT_C TInt BaselineOffsetInPixels() const;
+
+	/** Gets how much of the specified descriptor can be displayed in this font without 
+	exceeding the specified width.
+	
+	Note:
+	
+	This function does not display any of the descriptor itself - it is used 
+	before display, to test whether the whole descriptor can be displayed.
+	
+	@param aText The descriptor. 
+	@param aWidthInPixels The available width for character display. 
+	@return The number of characters which will be able to be displayed without 
+	exceeding the specified width. The count starts from the beginning of the 
+	descriptor. */
+	IMPORT_C TInt TextCount(const TDesC& aText,TInt aWidthInPixels) const;
+
+	/** Gets how much of the specified descriptor can be displayed in this font without 
+	exceeding the specified width. 
+	
+	It also returns the excess width - defined as the specified available width 
+	minus the width of the portion of the descriptor which can be displayed without 
+	exceeding the available width.
+	
+	@param aText The descriptor. 
+	@param aWidthInPixels The available width for character display. 
+	@param aExcessWidthInPixels The excess width after displaying the portion of 
+	the descriptor, in pixels. 
+	@return The number of characters which will be able to be displayed without 
+	exceeding the specified width. The count starts from the beginning of the 
+	descriptor. */
+	IMPORT_C TInt TextCount(const TDesC& aText,TInt aWidthInPixels,TInt& aExcessWidthInPixels) const;
+
+	/** Gets the width in pixels of the widest character in this font.
+	
+	@return The width of the maximum width character, in pixels. */
+	IMPORT_C TInt MaxCharWidthInPixels() const;
+
+	/** Gets the width in pixels of the widest normal character in this font.
+	
+	Normal characters include all character in a character set except non-alphabetic 
+	characters (e.g. the copyright symbol, or a block graphics symbol, for example).
+	
+	@return The width of the maximum width normal character, in pixels. */
+	IMPORT_C TInt MaxNormalCharWidthInPixels() const;
+
+	/** Gets the font specification of this font in twips.
+	
+	@return The font specification of this font (in twips). */
+	IMPORT_C TFontSpec FontSpecInTwips() const;
+	IMPORT_C TCharacterDataAvailability GetCharacterData(TUint aCode, TOpenFontCharMetrics& aMetrics,const TUint8*& aBitmap,TSize& aBitmapSize) const;
+	IMPORT_C TBool GetCharacterPosition(TPositionParam& aParam) const;
+	IMPORT_C TInt WidthZeroInPixels() const;
+	IMPORT_C TInt MeasureText(const TDesC& aText, const TMeasureTextInput* aInput = NULL, TMeasureTextOutput* aOutput = NULL) const;
+	IMPORT_C static TBool CharactersJoin(TInt aLeftCharacter, TInt aRightCharacter);
+	IMPORT_C TInt ExtendedFunction(TUid aFunctionId, TAny* aParam = NULL) const;
+	IMPORT_C TBool GetCharacterPosition2(TPositionParam& aParam, RShapeInfo& aShapeInfo) const;
+
+	/** Gets the width in pixels of the specified descriptor when displayed in this 
+	font.
+	
+	@param aText The descriptor whose width should be determined.
+	@param aParam Parameter block that controls how much of aText is measured
+	@return The width of the specified descriptor when displayed in this font, 
+	in pixels. */
+	IMPORT_C TInt TextWidthInPixels(const TDesC& aText,const TMeasureTextInput* aParam) const;
+	};
+
+
+// inline functions from original gdi.inl
+/** 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
+*/
+inline TInt CFont::FontCapitalAscent() const
+    {
+    return ExtendedFunction(KFontCapitalAscent);
+    }
+
+/** 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. 
+@return The positive distance from the font baseline to the top of the
+highest pre-composed glyph (including accents) above the baseline
+@publishedAll
+@released
+*/
+inline TInt CFont::FontMaxAscent() const
+    {
+    return ExtendedFunction(KFontMaxAscent);
+    }
+
+/** Gets the descent of an ANSI descending character in the font.
+Whether or not there are any ANSI descenders in the font.
+@return The positive distance from the font baseline to the bottom of the
+lowest ANSI descender
+@publishedAll
+@released
+*/
+inline TInt CFont::FontStandardDescent() const
+    {
+    return ExtendedFunction(KFontStandardDescent);
+    }
+
+/** 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.
+@return The positive distance from the font baseline to the bottom of the
+lowest pre-composed glyph (including accents) below the baseline
+@publishedAll
+@released
+*/
+inline TInt CFont::FontMaxDescent() const
+    {
+    return ExtendedFunction(KFontMaxDescent);
+    }
+
+/** 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 CFont::FontLineGap() const
+    {
+    return ExtendedFunction(KFontLineGap);
+    }
+
+/**
+Gets the (positive) maximum height in pixels of the font.
+This may differ from the design height.
+
+@return The maximum height of the font.
+@publishedAll
+@released
+*/
+inline TInt CFont::FontMaxHeight() const
+    {
+    return FontMaxAscent() + FontMaxDescent();
+    }
+
+
+// from original gdistruct.h
+/*
+Structure used to pass input/output parameters between RFontTable and CFbsFont.
+@internalTechnology
+*/
+class TGetFontTableParam 
+    {
+public:
+    TUint32 iTag;
+    TAny *iContent;
+    TInt iLength;
+    };
+
+/*
+Structure used to pass input/output parameters between RGlyphOutlineIterator and CFbsFont.
+Used when opening an outline iterator.
+@internalTechnology
+*/
+class TGetGlyphOutlineParam 
+    {
+public:
+    TInt iCount;
+    const TUint *iCodes; 
+    TBool iHinted;
+    TAny **iOutlines;
+    TInt *iLengths; 
+    };
+
+/*
+Structure used to pass input/output parameters between RGlyphOutlineIterator and CFbsFont.
+Used when closing an outline iterator.
+@internalTechnology
+*/
+class TReleaseGlyphOutlineParam 
+    {
+public:
+    TInt iCount;
+    const TUint *iCodes;
+    TBool iHinted;
+    };
+
+
+#endif // __TEXTBASE_H__

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/mglyph/mglyphtool.pl	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,364 @@
+# Copyright (c) 2006-2010 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:
+#
+
+use strict;
+
+## Used as global variables, probably need to change and pass variables through as parameters.
+my %globalValues=();
+##initialise filenames
+$globalValues{'inputFile'} = 'mglyphs.txt';
+$globalValues{'outputFileName'} = 'mglyphs.inl';
+$globalValues{'htmlFileName'} = 'mglyphs.html';
+$globalValues{'lgtablesize'} = 9; # Default tablesize value is 512
+$globalValues{'tablesize'} = 1 << $globalValues{'lgtablesize'};
+$globalValues{'storeashex'} = 0;
+$globalValues{'stepOffset'} = 72;
+$globalValues{'stepShift'} = 0;
+
+## die if the correct number of argumements have not been entered
+&extractFlags(\@ARGV, \%globalValues);
+&printDebug("Remainder:$globalValues{'tablesize'}\n");
+&printDebug("StoreAsHex:$globalValues{'storeashex'}\n");
+
+if ($globalValues{"information"})
+	{
+	&dieShowingUsage();
+	}
+
+&printDebug("Creating HashTable....\n");
+my %hashTable = &createHashTable($globalValues{'inputFile'});
+if (!defined(%hashTable))
+	{
+	die("ERROR: Hash table was not created\n");
+	}
+if ($globalValues{"outputtohtml"})
+	{
+	my $htmlFileName = $globalValues{'htmlFileName'};
+	&printDebug("Creating HTML output to file: $htmlFileName\n");	
+	&createHTMLOfMappings($htmlFileName, %hashTable);
+	}
+my $outputFileName = $globalValues{'outputFileName'};
+&printDebug("Writing Hash table to file: $outputFileName\n");
+&writeHashTableToFile($outputFileName, %hashTable);
+&printDebug("$outputFileName created.");
+
+##################### end of main section 
+sub extractFlags
+	{
+	my $aArgumentArray=shift;
+	my $aArguments=shift;
+	my $expectedArg = 'lgtablesize';
+	my $expectedExtension;
+	foreach my $argument (@$aArgumentArray)
+		{
+		if ($argument =~ m!^[-/]([a-zA-Z].*)$!)
+			{
+			my $switch = $1;
+			$expectedArg = 'lgtablesize';
+			$expectedExtension = undef;
+			if ($switch=~/^(x|hexoutput)$/i)
+				{
+				$$aArguments{'storeashex'}=1;
+				}
+			elsif ($switch=~/^(\?|help)$/i)
+				{
+				$$aArguments{'information'}=1;
+				}
+			elsif ($switch=~/^(v|verbose)$/i)
+				{
+				$$aArguments{'verbose'}=1;
+				}
+			elsif ($switch=~/^(h|outputtohtml)$/i)
+				{
+				$$aArguments{'outputtohtml'}=1;
+				$expectedArg = 'htmlFileName';
+				$expectedExtension = '.html';
+				}
+			elsif ($switch=~/^(i|input)$/i)
+				{
+				$expectedArg = 'inputFile';
+				}
+			elsif ($switch=~/^(o|output)$/i)
+				{
+				$expectedArg = 'outputFileName';
+				$expectedExtension = '.inl';
+				}
+			elsif ($switch=~/^(offset)$/i)
+				{
+				$expectedArg = 'stepOffset';
+				}
+			elsif ($switch=~/^(shift)$/i)
+				{
+				$expectedArg = 'stepShift';
+				}
+			}
+		else
+			{
+			if (defined $expectedExtension && $argument !~ m!\.[^/\\]*$!)
+				{
+				$argument .= $expectedExtension;
+				}
+			$$aArguments{$expectedArg} = $argument;
+			$expectedArg = 'lgtablesize';
+			}
+		}
+	$globalValues{'tablesize'} = 1 << $globalValues{'lgtablesize'};
+	$globalValues{'stepOffset'} &= 0xFFFFFE;
+	}
+#####################
+sub dieShowingUsage
+	{
+	print <<USAGE_EOF;
+
+Usage:
+
+perl -w mglyphtool.pl [-?] [<lg-table-size>] [-x] [-i <input-file-name>]
+		[-o <output-file-name>] [-h [<output-html-file-name]]
+		[-offset <value-for-offset>] [-shift <value-for-shift>]
+
+<lg-table-size> the default log(base 2) table size is 9. This gives a table
+size of 512 entries (2 to the power 9). So 7 gives a size of 128, 8 gives
+256, 9 gives 512, 10 gives 1024 and so on.
+
+options: -x -o -i -h
+
+	-? Shows help
+
+	The -x flag stores values into the .inl file in hex format: 
+		hex(OriginalKeyCodeMirrorGlyphCode), 
+	By default the values are stored in string hex format i.e 0x220C2209
+
+	The -h flag generates a html file displaying hash table information.
+	This may be followed by the filename to be output.
+	Default is 'mglyphs.html'
+
+	The -i file specifies input file name. Default is 'mglyphs.txt'.
+
+	The -o file specifies output file name. Default is 'mglyphs.inl'.
+
+	-shift and -offset alter the "step" hash algorithm.
+	
+USAGE_EOF
+	exit 0;
+	}
+######### 
+#
+# Writes a hash table to file.
+# Current format:
+# 	Hex mode: 		"hex number created"
+#	Hex string mode:	"Original keyMapped key"
+#####################
+sub writeHashTableToFile
+	{
+	&printDebug("Writing to .inl file");
+	my ($aOutputFileName, %aHashTable) = @_;
+	open(OUTPUT_FILE, '> ' . $aOutputFileName) or die('Error: could not open $aOutputFileName to write to\n');
+	## Print comments at top of .inl file
+	printf(OUTPUT_FILE "\/\/ mGlyphs.inl\n");
+	printf(OUTPUT_FILE "\/\/\n");
+	printf(OUTPUT_FILE "\/\/ Generated by mglyphtool.pl from '$globalValues{'inputFile'}'\n");
+	printf(OUTPUT_FILE "\/\/\n\n");
+	## Declare array and fill in values
+	printf(OUTPUT_FILE "const unsigned long mGlyphArray[] = {\n\t");
+	for (my $counter = 0; $counter < $globalValues{'tablesize'}; $counter++)
+		{
+		my $storeValue = "00000000";
+		if (defined($aHashTable{$counter}))
+			{
+			$storeValue = $aHashTable{$counter};
+			}
+		$storeValue = ($globalValues{'storeashex'}) ? hex($storeValue) : "0x$storeValue";
+		print OUTPUT_FILE $storeValue;
+		if (($counter+1) < $globalValues{'tablesize'})
+			{
+			print OUTPUT_FILE (($counter + 1) % 8 == 0? ",\n\t" : ', ');
+			}
+		}
+	print(OUTPUT_FILE "};\n");
+	print(OUTPUT_FILE "\nconst int KLgMirrorTableSize=$globalValues{'lgtablesize'};\n");
+	print(OUTPUT_FILE "const int KMirrorTableSize=$globalValues{'tablesize'};\n");
+	# Inline functions
+	# Get a Hash value from a given key	
+	print(OUTPUT_FILE "\n// Returns the first index to probe for character aKey.\n");
+	print(OUTPUT_FILE "inline long MirrorStart(long aKey)\n");
+	print(OUTPUT_FILE "\t{ return aKey \& (KMirrorTableSize-1); }\n");
+	print(OUTPUT_FILE "\n// Returns the offset for further probes for character aKey.\n");
+	print(OUTPUT_FILE "inline long MirrorStep(long aKey)\n");
+	my $stepShift = $globalValues{'stepShift'};
+	print(OUTPUT_FILE "\t{ return (");
+	if ($stepShift == 0)
+		{
+		print(OUTPUT_FILE "aKey");
+		}
+	elsif (0 < $stepShift)
+		{
+		print(OUTPUT_FILE "(aKey >> $stepShift)");
+		}
+	else
+		{
+		$stepShift = -$stepShift;
+		print(OUTPUT_FILE "(aKey << $stepShift)");
+		}
+	print(OUTPUT_FILE " | 1) + $globalValues{'stepOffset'}; }\n\n");
+
+	close(OUTPUT_FILE);
+	}	
+##################### listing of hash indexes values for original and mirrored glyphs
+sub createHTMLOfMappings
+	{
+	my ($aOutputFileName, %aHashTable )= @_;
+	open(OUTPUT_FILE, '> ' . $aOutputFileName) or die('Error: could not open $aOutputFileName to create HTML output');
+	printf(OUTPUT_FILE "<HTML><HEAD><TITLE>MirrorGlyph Hash Output<\/TITLE><\/HEAD><BODY>");
+## print hash table details
+	printf(OUTPUT_FILE "<P>Values in hash Table - <B>(Hash Function: Key mod $globalValues{'tablesize'})<\/B><\/P><TABLE border=1>");
+	printf(OUTPUT_FILE "<TR><TD><B>---<\/B><\/TD><TD BGCOLOR=\#8888FF><B>Character code:<\/B><\/TD><TD><B>Hash Index:<\/B><\/TD><TD BGCOLOR=\#8888FF><B>Mirror Glyph Value:<\/B><\/TD><TD><b>Search Jump Count<\/b>");	
+	my %keySet;
+	foreach my $value (values %aHashTable)
+		{
+		$keySet{&getLower(hex $value)} = 1;
+		}
+	foreach my $key (32..127)
+		{
+		$keySet{$key} = 1;
+		}
+	my @keys = sort {$a <=> $b} (keys %keySet);
+	foreach my $key (@keys)
+		{
+		my $counter = 0;
+		my $HKey = &findHashTableIndex($key, \$counter, \%aHashTable);
+		my $stored = $aHashTable{$HKey};
+		my $storedValue = 'no change';
+		my $storedKey = $key;
+		if (defined $stored)
+			{
+			$storedValue = sprintf('%02x', &getLower(hex $stored));
+			$storedKey = &getUpper(hex $stored);
+			}
+		if ($storedKey)
+			{
+			die('incorrect key found in hash table') unless ($storedKey == $key);
+			printf(OUTPUT_FILE "<TR><TD>---<\/TD><TD BGCOLOR=\#8888FF><B>%02x<\/B><\/TD><TD>%02x<\/TD><TD BGCOLOR=\#8888FF><B>%s<\/B><\/TD><TD>%d<\/TD><\/TR>", $key, $HKey, $storedValue, $counter);
+			}
+		}
+	printf(OUTPUT_FILE "<\/TABLE>");
+	printf(OUTPUT_FILE "<\/BODY><\/HTML>");
+	close(OUTPUT_FILE);
+	}
+#####################
+# Hash Table functions	
+##################### 
+
+#####################
+#Returns a new Hash Table 
+#####################
+sub createHashTable
+	{	
+	my $aInputFileName = shift;	
+	my $lineNumber = 1;
+	my %newHashTable = ();
+	open(INPUT_FILE, '< ' . $aInputFileName) or die('ERROR: Could not open $aInputFileName to read from');
+	while (my $line=<INPUT_FILE>)
+		{
+		if ($line=~/^(.*);\s(.*\w)\s\W.*$/) ## Grab Original glyph value and mirrored glyph value
+			{		
+			&updateHashTable($1, $2, \%newHashTable);
+			}
+		$lineNumber++;
+		}		
+	close(INPUT_FILE);
+	return %newHashTable;
+	}
+##################### 
+#
+# Retrieves a HashKey which is not currently being used in a given HashTable
+#
+#####################
+sub findHashTableIndex
+	{
+	my ($aHashKey, $aCounter, $aHashTable) = @_;	
+	my $current = &hashFunction($aHashKey);
+	my $step = &hashStepFunction($aHashKey);
+	my $tableSize = $globalValues{'tablesize'};
+	while (defined($$aHashTable{$current}) && &getUpper(hex($$aHashTable{$current})) != $aHashKey)
+		{
+		++$$aCounter;
+		$current += $step;
+		$current &= $tableSize - 1;
+		}
+	if (2 < $$aCounter)
+		{
+		printf STDERR ("WARNING: Jumped $$aCounter times, inefficient hash for %02x ($current, $step)\n", $aHashKey);
+		}
+	return $current;
+	}
+
+#####################
+sub updateHashTable
+{
+	my ($aKey, $aValueToStore, $aHashTable) = @_;
+	my $counter = 0;
+	my $key = hex($aKey);
+	my $hashKey = &findHashTableIndex($key, \$counter, $aHashTable);
+	$$aHashTable{$hashKey} = "$aKey$aValueToStore";
+	return $hashKey;
+}
+##################### 
+# Returns a hash key for a given key
+# Currently using a simple hash function 
+#####################
+sub hashFunction
+	{
+	my $aKey = shift;
+	return $aKey & ($globalValues{'tablesize'}-1);
+	}
+
+# Returns second hash value: used for the step size
+sub hashStepFunction
+	{
+	my $aKey = shift;
+	my $stepShift = $globalValues{'stepShift'};
+	if ($stepShift < 0)
+		{
+		$aKey <<= -$stepShift;
+		}
+	elsif (0 < $stepShift)
+		{
+		$aKey >>= $stepShift;
+		}
+	return ($aKey | 1) + $globalValues{'stepOffset'};
+	}
+	
+#####################
+# Utility functions 
+#####################
+sub getLower
+	{
+	my $aValue = shift;
+	return $aValue & hex("0000FFFF");
+	}
+sub getUpper
+	{
+	my $aValue = shift;
+	return ($aValue & hex("FFFF0000")) >> 16;				
+	}
+sub printDebug
+	{
+	my $string = shift;
+	if ($globalValues{'verbose'})
+		{
+		print $string;
+		}
+	}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/mglyph/release.txt	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,30 @@
+Mirror Glyph Tool release 001
+----------
+Made by Michael Lang 08 August 2002
+
+
+- Features:
+* The tool generates a hash table used to locate mirrorglyph characters, using the original character as a key. 
+The hash table is stored in C++ format in the form of a .inl file.
+	
+
+(Command line options can be found by calling the perl script with the -? option)
+
+
+- Inputs:
+* The script requires the use of an input file which should be named mglyphs.txt
+	- Points to note:
+		- The input data to place in the file can be found here:
+			http://www.unicode.org/Public/3.0-Update1/BidiMirroring-1.txt
+		- Take this file and rename it mglpyhs.txt, placing it in the same directory as the tool
+
+
+- Outputs:
+	- A HTML file
+		- One of the command line options allows for a HTML file to be generated in 
+		order to display output.
+		- This file is called mglyphs.html by default
+		
+	- A .INL file
+		- The tool generates a file called mglyphs.inl by default
+		(see command line options for output format)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textbase/sgdi/BIDI.CPP	Mon Jul 12 14:38:26 2010 +0800
@@ -0,0 +1,1163 @@
+// Copyright (c) 2000-2010 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:
+// Bidirectional text reordering; based on the Unicode Bidirectional Reordering Algorithm.
+// 
+//
+
+#include <bidi.h>
+#include "BidiCopy.h"
+#include <s32std.h>
+
+const TInt KBidirectionalStateOverrideStreamValueNone = 0;
+const TInt KBidirectionalStateOverrideStreamValueLeftToRight = 1;
+const TInt KBidirectionalStateOverrideStreamValueRightToLeft = 2;
+
+inline TBool IsSupplementary(TUint aChar)
+/**
+@param aChar The 32-bit code point value of a Unicode character.
+
+@return True, if aChar is supplementary character; false, otherwise.
+*/
+	{
+	return (aChar > 0xFFFF);
+	}
+
+inline TBool IsHighSurrogate(TText16 aInt16)
+/**
+@return True, if aText16 is high surrogate; false, otherwise.
+*/
+	{
+	return (aInt16 & 0xFC00) == 0xD800;
+	}
+
+inline TBool IsLowSurrogate(TText16 aInt16)
+/**
+@return True, if aText16 is low surrogate; false, otherwise.
+*/
+	{
+	return (aInt16 & 0xFC00) == 0xDC00;
+	}
+
+inline TUint JoinSurrogate(TText16 aHighSurrogate, TText16 aLowSurrogate)
+/**
+Combine a high surrogate and a low surrogate into a supplementary character.
+
+@return The 32-bit code point value of the generated Unicode supplementary
+        character.
+*/
+	{
+	return ((aHighSurrogate - 0xD7F7) << 10) + aLowSurrogate;
+	}
+
+TBool TextDefaultsToRightToLeft(const TDesC& aText, TBool* aFound);
+
+TBidirectionalState::TCategory TBidirectionalState::CharToBdCat(TChar::TBdCategory aCat)
+	{
+	return static_cast<TBidirectionalState::TCategory>(
+		1 << static_cast<TInt>(aCat));
+	}
+
+TBidirectionalState::TCategory TBidirectionalState::UintToBdCat(TUint aCat)
+	{
+	return static_cast<TBidirectionalState::TCategory>(1 << aCat);
+	}
+
+void TBidirectionalState::TReorderContext::SetNextCategory(
+	TChar::TBdCategory aCat)
+	{
+	iNextCategory = CharToBdCat(aCat);
+	}
+
+void TBidirectionalState::TReorderContext::SetNextStrongCategory(
+	TChar::TBdCategory aCat)
+	{
+	iNextStrongCategory = CharToBdCat(aCat);
+	}
+
+
+EXPORT_C void TBidirectionalState::ReverseGroups(TText* aStart,TInt aLength)
+/** A utility to reverse text apart from combining characters, which remains after 
+their base characters. This is what is needed when drawing right-to-left text.
+
+@param aStart Start position of text to be reversed.
+@param aLength Length of text to be reversed. */
+	{
+	BidiCopy::ReverseCodes(aStart, aLength);
+	BidiCopy::DeleteUnreversedSurrogates(aStart, aLength);
+	BidiCopy::SubstituteMirrorImages(aStart, aLength);
+	BidiCopy::CorrectGroups(aStart, aLength);
+	BidiCopy::CorrectSurrogatePairs(aStart, aLength);
+	}
+
+
+// A local helper function. Get the next character from a buffer. This
+// function won't check buffer length.
+//
+// @param aText The text buffer to read character from.
+// @param aCharacterIndex Count of characters to skip in aText.
+// @return The character.
+TUint GetOneCharacter(const TText16 *aText, TInt aCharacterIndex)
+	{
+	const TText16 *p = aText;
+	TUint c = 0xFFFF;
+	while (aCharacterIndex >= 0)
+		{
+		c = *p++;
+		ASSERT(!IsLowSurrogate(c));
+		if (IsHighSurrogate(c))
+			{
+			ASSERT(IsLowSurrogate(*p));
+			c = JoinSurrogate(c, *p++);
+			}
+		--aCharacterIndex;
+		}
+	return c;
+	}
+
+
+TInt TBidirectionalState::GenerateBdRunArray(const TText* aText, TInt aLength,
+	TBidirectionalState::TRunInfo* aRun, TInt aMaxRuns)
+/** Analyse the input text for runs of characters that share the same
+bidirectional class. Categories TChar::EEuropeanNumberSeparator and
+TChar::ECommonNumberSeparator are kept as singletons due to a limitation in
+the reordering logic.
+@param aText The text to be analysed.
+@param aLength The length of the text to be analysed.
+@param aRun	Output buffer for the runs after analysis. May be null if there 
+is to be no output.
+@param aMaxRuns The size of the aRun array. No more than this number of runs 
+will be	output.
+@return The number of runs that are required for the full results of the
+analysis.
+@internalTechnology */	
+    {
+	if (aLength == 0)
+		{
+		if (aRun && 0 < aMaxRuns)
+			{
+			aRun[0].iCategory = TChar::EOtherNeutral;
+			aRun[0].iStart = 0;
+			aRun[0].iLength = 0;
+			}
+		return 1;
+		}
+	int runs = 0;
+	int run_start = 0;
+	int run_end = 1;
+	const TText* p = aText;
+	const TText* q = p + aLength;
+	
+	// get the character pointed by 'p', then move 'p' to next character, and adjust 'run_end' if need
+	TChar pc = ::GetOneCharacter(p, 0);
+	TChar::TBdCategory cur_cat = pc.GetBdCategory();
+	++p;
+	if (IsSupplementary(pc))
+		{
+		++p;
+		run_end = 2;	// run_end points to "end" of current character
+		}
+	
+	while (p < q)
+		{
+		// get the character pointed by 'p'
+		pc = ::GetOneCharacter(p, 0);
+		
+		TChar::TBdCategory new_cat = pc.GetBdCategory();
+		if (new_cat != cur_cat)
+			{
+			if (new_cat == TChar::ENonSpacingMark &&
+				cur_cat != TChar::ELeftToRightEmbedding &&
+				cur_cat != TChar::ELeftToRightOverride &&
+				cur_cat != TChar::ERightToLeftEmbedding &&
+				cur_cat != TChar::ERightToLeftOverride &&
+				cur_cat != TChar::EPopDirectionalFormat)
+				new_cat = cur_cat;
+			else if (p < q - 1 &&
+					 (new_cat == TChar::EWhitespace ||
+					  new_cat == TChar::EEuropeanNumberSeparator ||
+					  new_cat == TChar::ECommonNumberSeparator))
+				{
+				TChar nextChar = ::GetOneCharacter(p, 1);
+				TChar::TBdCategory next_cat = nextChar.GetBdCategory();
+				if (new_cat == TChar::EWhitespace)
+					{
+					if ((cur_cat == TChar::ELeftToRight ||
+						 cur_cat == TChar::ERightToLeft ||
+						 cur_cat == TChar::ERightToLeftArabic) && cur_cat == next_cat)
+						new_cat = cur_cat;
+					}
+				else if (cur_cat == TChar::EEuropeanNumber && next_cat == TChar::EEuropeanNumber)
+					new_cat = TChar::EEuropeanNumber;
+				}
+			}
+
+		if (new_cat != cur_cat ||
+			cur_cat == TChar::EEuropeanNumberSeparator ||
+			cur_cat == TChar::ECommonNumberSeparator)
+			{
+			if (aRun && runs < aMaxRuns)
+				{
+				aRun[runs].iCategory = cur_cat;
+				aRun[runs].iStart = run_start;
+				aRun[runs].iLength = run_end - run_start;
+				}
+			
+			runs++;
+			run_start = run_end;
+			}
+
+		p++;
+		run_end++;
+
+		// adjust 'p' and 'run_end'
+		if (IsSupplementary(pc))
+			{
+			p++;
+			run_end++;
+			}
+
+		cur_cat = new_cat;
+		}
+
+	if (aRun && runs < aMaxRuns)
+		{
+		aRun[runs].iCategory = cur_cat;
+		aRun[runs].iStart = run_start;
+		aRun[runs].iLength = run_end - run_start;
+		}
+
+	return runs + 1;
+	}
+
+
+EXPORT_C TInt TBidirectionalState::ReorderText(const TText* aText,TInt aLength,TBool aParRightToLeft,
+											   TText*& aNewText)
+/** Reorders text according to the Unicode Bidirectional Reordering algorithm.
+
+Reorders the input text from logical order (which may be bidirectional) to 
+display order (strictly left to right).
+
+@param aText The input text in logical order.
+@param aLength The length of the input text.
+@param aParRightToLeft ETrue if the default directionality of the text to be 
+re-ordered is right-to-left.
+@param aNewText Returns the re-ordered text. If the text did not need re-ordering, 
+or if there was an error, aText will be returned. Otherwise, ownership of 
+a newly allocated buffer will be returned to the caller. This buffer must 
+be deleted with delete[] (or CleanupArrayDeletePushL()) and not delete (or 
+CleanupStack::PushL()).
+@return A system-wide error value if there has been an error; KErrNone if there 
+has not. */
+	{
+	aNewText = const_cast<TText*>(aText);
+	if (aLength < 2)
+		return KErrNone;
+
+	int error = KErrNone;
+	TBidirectionalState::TRunInfo run_info;
+	run_info.iDirection = 0;
+	run_info.iIndex = 0;
+	run_info.iStart = 0;
+	run_info.iLength = aLength;
+	TBidirectionalState::TRunInfo* run_info_array = &run_info;
+	TBidirectionalState::TRunInfo* allocated_run_info_array = 0;
+	int runs = GenerateBdRunArray(aText, aLength, run_info_array, 1);
+	if (runs > 1)
+		{
+		allocated_run_info_array = new TBidirectionalState::TRunInfo[runs];
+		if (allocated_run_info_array)
+			{
+			run_info_array = allocated_run_info_array;
+			GenerateBdRunArray(aText, aLength, run_info_array, runs);
+			}
+		else
+			{
+			// the run cannot be allocated: stick with our single l-to-r run
+			error = KErrNoMemory;
+			runs = 1;
+			}
+		}
+	if (error == KErrNone)
+		{
+		TBidirectionalState state;
+		state.ReorderLine(run_info_array, runs, ETrue, ETrue, aParRightToLeft,
+			TChar::EOtherNeutral, TChar::EOtherNeutral);
+		}
+
+	// If there was only one run and it's left-to-right, we've finished.
+	if (!allocated_run_info_array && run_info.iDirection == 0)
+		return error;
+
+	// Reorder the text into a new buffer.
+	TText* buffer = new TText[aLength];
+	if (!buffer)
+		{
+		delete [] allocated_run_info_array;
+		return KErrNoMemory;
+		}
+	const TBidirectionalState::TRunInfo* r = run_info_array;
+	TText* dest = buffer;
+	for (int i = 0; i < runs; i++, r++)
+		{
+		const TText* source = &aText[r->iStart];
+		int length = r->iLength;
+		Mem::Copy(dest,source,length * sizeof(TText));
+		if (r->iDirection)
+			ReverseGroups(dest,length);
+		dest += length;
+		}
+
+	delete [] allocated_run_info_array;
+	aNewText = buffer;
+	return KErrNone;
+	}
+
+
+EXPORT_C TBidirectionalState::TBidirectionalState()
+/** Standard constructor. */
+	{
+	Reset();
+	}
+
+
+/** Reorders a line of text and updates the bidirectional state for the next line.
+
+@param aRunInfo An array of objects representing runs of characters with the 
+same bidirectional category. Any number of characters can be combined into 
+a run if they have the same category, except for the categories TChar::EEuropeanNumberSeparator 
+and TChar::ECommonNumberSeparator, which should be put into single-character 
+runs because the reordering logic depends on this.
+@param aRuns Number of 'run info' objects.
+@param aParStart Tells the function whether the line is the first line of a 
+paragraph.
+@param aParEnd Tells the function whether the line is the last line of a paragraph.
+@param aParRightToLeft ETrue if the default directionality of the text to be 
+re-ordered is right-to-left.
+@param aNextCategory The category of the character immediately after the end 
+of the line. This is ignored if aParEnd is ETrue.
+@param aNextStrongCategory The category of the first strong character (one 
+of the categories ELeftToRight, ELeftToRightEmbedding, ELeftToRightOverride, 
+ERightToLeft, ERightToLeftArabic, ERightToLeftEmbedding or ERightToLeftOverride) 
+after the end of the line. This is ignored if aParEnd is ETrue.
+@param aVisualEndIsAmbiguous EFalse if the logical end of this line is at the
+visual end and the logical beginning of the next line is at the visual beginning.
+*/
+EXPORT_C void TBidirectionalState::ReorderLine(TRunInfo* aRunInfo, TInt aRuns,
+	TBool aParStart, TBool aParEnd, TBool aParRightToLeft,
+	TChar::TBdCategory aNextCategory, TChar::TBdCategory aNextStrongCategory,
+	TBool& aVisualEndIsAmbiguous)
+	{
+	ReorderLine(aRunInfo, aRuns, aParStart, aParEnd, aParRightToLeft,
+		aNextCategory, aNextStrongCategory);
+	if (iStackLevel  != 0)
+		{
+		aVisualEndIsAmbiguous = ETrue;
+		return;
+		}
+	TCategory nextCat = CharToBdCat(aNextCategory);
+	TCategory nextStrong = CharToBdCat(aNextStrongCategory);
+	const TUint KAllStrongLeftToRight =
+		ELeftToRight | ELeftToRightEmbedding | ELeftToRightOverride;
+	const TUint KAllStrongRightToLeft =
+		ERightToLeft | ERightToLeftArabic | ERightToLeftEmbedding | ERightToLeftOverride;
+	if (aParRightToLeft)
+		{
+		// Ambiguous if any of the surrounding categories are strongly left-to-right
+		aVisualEndIsAmbiguous =
+			(iPreviousStrongCategory | iPreviousCategory | nextCat | nextStrong)
+			& KAllStrongLeftToRight;
+		}
+	else
+		{
+		// Ambiguous if any of the surrounding categories are strongly right-to-left
+		aVisualEndIsAmbiguous =
+			(iPreviousStrongCategory | iPreviousCategory | nextCat | nextStrong)
+			& KAllStrongRightToLeft;
+		}
+	}
+/** Reorders a line of text and updates the bidirectional state for the next line.
+
+@param aRunInfo An array of objects representing runs of characters with the 
+same bidirectional category. Any number of characters can be combined into 
+a run if they have the same category, except for the categories TChar::EEuropeanNumberSeparator 
+and TChar::ECommonNumberSeparator, which should be put into single-character 
+runs because the reordering logic depends on this.
+@param aRuns Number of 'run info' objects.
+@param aParStart Tells the function whether the line is the first line of a 
+paragraph.
+@param aParEnd Tells the function whether the line is the last line of a paragraph.
+@param aParRightToLeft ETrue if the default directionality of the text to be 
+re-ordered is right-to-left.
+@param aNextCategory The category of the character immediately after the end 
+of the line. This is ignored if aParEnd is ETrue.
+@param aNextStrongCategory The category of the first strong character (one 
+of the categories ELeftToRight, ELeftToRightEmbedding, ELeftToRightOverride, 
+ERightToLeft, ERightToLeftArabic, ERightToLeftEmbedding or ERightToLeftOverride) 
+after the end of the line. This is ignored if aParEnd is ETrue. */
+EXPORT_C void TBidirectionalState::ReorderLine(TRunInfo* aRunInfo, TInt aRuns,
+	TBool aParStart, TBool aParEnd, TBool aParRightToLeft,
+	TChar::TBdCategory aNextCategory, TChar::TBdCategory aNextStrongCategory)
+	{
+	// Reset if this is a new paragraph.
+	if (aParStart)
+		{
+		Reset();
+		iPreviousCategory = EOtherNeutral;
+		if (aParRightToLeft)
+			{
+			iStack[0].iEmbeddingLevel = 1;
+			iPreviousStrongCategory = ERightToLeft;
+			}
+		}
+
+	// Initialise the context object.
+	TReorderContext context;
+	context.iRunInfo = aRunInfo;
+	context.iRuns = aRuns;
+	context.iLastStrongCategory = iPreviousStrongCategory;
+	if (aParEnd)
+		context.iNextCategory = context.iNextStrongCategory = EOtherNeutral;
+	else
+		{
+		context.iNextCategory = CharToBdCat(aNextCategory);
+		context.iNextStrongCategory = CharToBdCat(aNextStrongCategory);
+		}
+
+	// Initialise output data and find out what categories are present so that unnecessary steps can be skipped.
+	context.iCategories = iPreviousCategory | context.iNextCategory | context.iNextStrongCategory;
+	for (TInt i = 0; i != aRuns; ++i)
+		{
+		aRunInfo[i].iEmbeddingLevel = iStack[0].iEmbeddingLevel;
+		aRunInfo[i].iDirection = 0;
+		aRunInfo[i].iIndex = i;
+		aRunInfo[i].iCategory = UintToBdCat(aRunInfo[i].iCategory);
+		context.iCategories |= aRunInfo[i].iCategory;
+		}
+
+	// Do nothing if no right-to-left material is present.
+	if (aRuns == 0 ||
+		(iStackLevel == 0 && iStack[0].iEmbeddingLevel == 0 &&
+		 !(context.iCategories & (ERightToLeftGroup | EBdControlsGroup))))
+		return;
+
+	// Perform the bidirectional algorithm.
+	if ((context.iCategories & EBdControlsGroup) ||
+		State().iOverrideState != ENoOverrideState)
+		HandleBdControls(context);
+	ResolveWeakTypesW1W2W3(context);
+	ResolveWeakTypesW4W5W6(context);
+	ResolveWeakTypesW7(context);
+	if (context.iCategories & EOtherNeutral)
+		ResolveNeutralTypes(context);
+	ResolveImplicitLevels(context);
+	PrepareForNextLine(context);
+	ReorderRuns(context);
+	}
+
+
+void TBidirectionalState::PrepareForNextLine(const TReorderContext& aContext)
+/**
+Fold context information back into TBidirectionalState.
+@internalComponent
+*/	
+   {
+	if (aContext.iRuns != 0)
+		{
+		iPreviousCategory = static_cast<TCategory>(
+			aContext.iRunInfo[aContext.iRuns - 1].iCategory);
+		iPreviousStrongCategory = aContext.iLastStrongCategory;
+		}
+	}
+
+
+void TBidirectionalState::HandleBdControls(TReorderContext& aContext)
+/**
+Handle LRO, RLO, LRE, RLE and PDF. After this phase, these categories will no
+longer be found.
+
+This corresponds to Unicode(3.2) Bidirectional Algorithm phases X1-X7.
+Phase X8 is not required as the run is assumed to be all in one paragraph.
+Phases X9-X10 are implicit in other functions.
+
+@internalComponent
+*/	
+   {
+	aContext.iCategories = iPreviousCategory | aContext.iNextCategory;
+	for (TInt i = 0; i != aContext.iRuns; ++i)
+		{
+		TRunInfo* r = aContext.iRunInfo + i;
+		TCategory nextCatInLine = i < aContext.iRuns - 1?
+			(TCategory)(r[1].iCategory) : ENoCategory;
+
+		TBool was_pdf = FALSE;
+		if (r->iCategory & EBdControlsGroup)
+			{
+			if (r->iCategory == EPopDirectionalFormat)
+				{
+				if (iStackLevel > 0)
+					{
+					was_pdf = TRUE;
+					r->iEmbeddingLevel = State().iEmbeddingLevel;
+					if (nextCatInLine == State().iStartCategory)
+						// Ignore POP-PUSH pair with nothing between.
+						// This is surely wrong? Perhaps it is a hack to
+						// help other parts of the algorithm. Must investigate.
+						// TPB.
+						r->iCategory = r[1].iCategory = EBoundaryNeutral;
+					else
+						{
+						r->iCategory = Pop();
+						}
+					}
+				else
+					r->iCategory = EBoundaryNeutral;
+				}
+			else
+				{
+				// Category is LRE, RLE, LRO or RLO.
+				if (nextCatInLine == EPopDirectionalFormat)
+					// Ignore PUSH-POP pair with nothing between.
+					r->iCategory = r[1].iCategory = EBoundaryNeutral;
+				else
+					r->iCategory = Push(static_cast<TCategory>(r->iCategory));
+				}
+			}
+
+		if (!was_pdf)
+			{
+			switch (State().iOverrideState)
+				{
+				case ELeftToRightOverrideState:
+					r->iCategory = ELeftToRight;
+					break;
+				case ERightToLeftOverrideState:
+					r->iCategory = ERightToLeft;
+					break;
+				default:
+					break;
+				}
+			r->iEmbeddingLevel = State().iEmbeddingLevel;
+			}
+		if (r->iCategory & EStrongGroup)
+			aContext.iLastStrongCategory = static_cast<TCategory>(r->iCategory);
+		aContext.iCategories |= r->iCategory;
+		}
+	}
+
+
+void TBidirectionalState::ResolveWeakTypesW1W2W3(TReorderContext& aContext)
+/**
+Unicode(3.2) Bidirectional Algorithm phases W1, W2 and W3.
+@internalComponent
+*/	
+    {
+	if (!(aContext.iCategories
+		& (ENonSpacingMark | ERightToLeftArabic | EEuropeanNumber)))
+		return;
+
+	TRunInfo* endOfRuns = aContext.iRunInfo + aContext.iRuns;
+	TCategory prev_cat = iPreviousCategory;
+	TBool european_to_arabic_number = iPreviousStrongCategory == ERightToLeftArabic;
+
+	aContext.iCategories = iPreviousCategory | aContext.iNextCategory;
+	for (TRunInfo* r = aContext.iRunInfo; r != endOfRuns; r++)
+		{
+		switch (r->iCategory)
+			{
+			case ENonSpacingMark:					// non-spacing marks change to the previous category
+				r->iCategory = prev_cat;
+				break;
+			case ELeftToRight:
+				european_to_arabic_number = EFalse;
+				break;
+			case ERightToLeft:
+				european_to_arabic_number = EFalse;
+				break;
+			case ERightToLeftArabic:				// Arabic letters change to R
+				european_to_arabic_number = ETrue;
+				r->iCategory = ERightToLeft;
+				break;
+			case EEuropeanNumber:				    // European numbers change to Arabic if last strong category was R
+				if (european_to_arabic_number)
+					r->iCategory = EArabicNumber;
+				break;
+			default:
+				break;
+			}
+		aContext.iCategories |= r->iCategory;
+		prev_cat = static_cast<TCategory>(r->iCategory);
+		}
+	}
+/**
+This phase removes categories NSM, AL, ES, ET, CS, BS, S, WS and BN, leaving
+only L, R, EN, AN and ON.
+@internalComponent
+*/
+void TBidirectionalState::ResolveWeakTypesW4W5W6(TReorderContext& aContext)
+	{
+	int i;
+	TRunInfo* r;
+	TCategory prev_cat = iPreviousCategory;
+	TCategory next_cat = EOtherNeutral;
+
+	// Phase P0b.
+	prev_cat = iPreviousCategory;
+	if (aContext.iCategories & EBoundaryNeutral)
+		{
+		for (i = 0, aContext.iCategories = iPreviousCategory | aContext.iNextCategory, r = aContext.iRunInfo;
+			 i < aContext.iRuns;
+			 i++, aContext.iCategories |= r->iCategory, r++)
+			{
+			if (r->iCategory == EBoundaryNeutral)		// runs of boundary neutrals change to EN, ET or AN if adjacent to
+				{										// one of these, otherwise to ON
+				int end = i + 1;
+				while (end < aContext.iRuns && aContext.iRunInfo[end].iCategory == EBoundaryNeutral)
+					end++;
+				next_cat = end < aContext.iRuns ? (TCategory)(aContext.iRunInfo[end].iCategory) : aContext.iNextCategory;
+				TCategory c = EOtherNeutral;
+				if (prev_cat == EEuropeanNumber || next_cat == EEuropeanNumber)
+					c = EEuropeanNumber;
+				else if (prev_cat == EEuropeanNumberTerminator || next_cat == EEuropeanNumberTerminator)
+					c = EEuropeanNumberTerminator;
+				else if (prev_cat == EArabicNumber || next_cat == EArabicNumber)
+					c = EArabicNumber;
+				for (int j = i; j < end; j++)
+					aContext.iRunInfo[j].iCategory = c;
+				i = end - 1;
+				r = &aContext.iRunInfo[i];
+				}
+			prev_cat = (TCategory)r->iCategory;
+			}
+		}
+
+	// Phase P1.
+	prev_cat = iPreviousCategory;
+	if (aContext.iCategories & (EEuropeanNumberSeparator | ECommonNumberSeparator))
+		{
+		for (i = 0, aContext.iCategories = iPreviousCategory | aContext.iNextCategory, r = aContext.iRunInfo;
+			 i < aContext.iRuns;
+			 i++, aContext.iCategories |= r->iCategory, r++)
+			{
+			next_cat = i < aContext.iRuns - 1 ? (TCategory)(r[1].iCategory) : aContext.iNextCategory;
+			switch (r->iCategory)
+				{
+				case EEuropeanNumberSeparator:			// European separators change to EN if between two ENs, else to ON
+					if (prev_cat == EEuropeanNumber && next_cat == EEuropeanNumber)
+						r->iCategory = EEuropeanNumber;
+					else
+						r->iCategory = EOtherNeutral;
+					break;
+				case ECommonNumberSeparator:			// CSs change to EN or AN if between two of the same, else to ON
+					if (prev_cat == EEuropeanNumber && next_cat == EEuropeanNumber)
+						r->iCategory = EEuropeanNumber;
+					else if (prev_cat == EArabicNumber && next_cat == EArabicNumber)
+						r->iCategory = EArabicNumber;
+					else
+						r->iCategory = EOtherNeutral;
+					break;
+				default:
+					break;
+				}
+			prev_cat = (TCategory)r->iCategory;
+			}
+		}
+
+	/*
+	Phase L1: tabs, whitespace before tabs, and trailing whitespace, is set to the base embedding level.
+	We ought to do this just before the final reordering, but the whitespace and segment separator
+	categories have disappeared by then so we use the sentinel value 255 which tells
+	ResolveImplicitLevels what to do.
+	*/
+	TBool demote_whitespace = TRUE;
+	for (i = aContext.iRuns - 1, r = &aContext.iRunInfo[i]; i >= 0; i--, r--)
+		{
+		switch (r->iCategory)
+			{
+			case EWhitespace:
+				break;
+			case ESegmentSeparator:
+				demote_whitespace = TRUE;
+				break;
+			default:
+				demote_whitespace = FALSE;
+				break;
+			}
+		if (demote_whitespace)
+			r->iEmbeddingLevel = 255;
+		}
+
+	// Phases P2 and P3.
+	prev_cat = iPreviousCategory;
+	if (aContext.iCategories & (EEuropeanNumberTerminator | ESegmentSeparator | EWhitespace))
+		{
+		for (i = 0, aContext.iCategories = iPreviousCategory | aContext.iNextCategory, r = aContext.iRunInfo;
+			 i < aContext.iRuns;
+			 i++, aContext.iCategories |= r->iCategory, r++)
+			{
+			next_cat = i < aContext.iRuns - 1 ? (TCategory)(r[1].iCategory) : aContext.iNextCategory;
+			switch (r->iCategory)
+				{
+				case EEuropeanNumberTerminator:			// runs of ETs change to ENs if next to an EN, else to ON
+					{
+					int end = i + 1;
+					while (end < aContext.iRuns && aContext.iRunInfo[end].iCategory == EEuropeanNumberTerminator)
+						end++;
+					next_cat = end < aContext.iRuns ? (TCategory)(aContext.iRunInfo[end].iCategory) : aContext.iNextCategory;
+					TCategory c = EOtherNeutral;
+					if (prev_cat == EEuropeanNumber || next_cat == EEuropeanNumber)
+						c = EEuropeanNumber;
+					for (int j = i; j < end; j++)
+						aContext.iRunInfo[j].iCategory = c;
+					i = end - 1;
+					r = &aContext.iRunInfo[i];
+					}
+					break;
+				case ESegmentSeparator:					// S and WS change to ON
+				case EWhitespace:
+					r->iCategory = EOtherNeutral;
+					break;
+				default:
+					break;
+				}
+			prev_cat = (TCategory)r->iCategory;
+			}
+		}
+	}
+
+void TBidirectionalState::ResolveWeakTypesW7(TReorderContext& aContext)
+	{
+	if (!(aContext.iCategories & EEuropeanNumber))
+		return;
+
+	TCategory prev_strong_cat = iPreviousStrongCategory;
+
+	aContext.iCategories = iPreviousCategory | aContext.iNextCategory;
+	TRunInfo* endOfRuns = aContext.iRunInfo + aContext.iRuns;
+	for (TRunInfo* r = aContext.iRunInfo; r != endOfRuns; r++)
+		{
+		switch (r->iCategory)
+			{
+			case ELeftToRight:
+				prev_strong_cat = ELeftToRight;
+				break;
+			case ERightToLeft:
+				prev_strong_cat = ERightToLeft;
+				break;
+			case EEuropeanNumber: 
+				if (prev_strong_cat == ELeftToRight)
+					r->iCategory = ELeftToRight;
+				break;
+			default:
+				break;
+			}
+		aContext.iCategories |= r->iCategory;
+		}
+	}
+
+
+
+void TBidirectionalState::DeneutralizeRuns(TRunInfo* aStart, TRunInfo* aEnd,
+	TCategory aStartCategory, TCategory aEndCategory)
+/**
+Turn all ON (Other Neutral) into non-neutrals according to the rules N1 and N2.
+@param aStart The start of the run array to be altered.
+@param aEnd One past the end of the run array to be altered.
+@param aStartCategory
+	The last non-neutral before the run, must be ELeftToRight or ERightToLeft.
+@param aEndCategory
+	The first non-neutral after the run, must be ELeftToRight or ERightToLeft.
+@internalComponent
+*/	{
+	// if sandwiched by the same category, neutrals become that.
+	if (aStartCategory == aEndCategory)
+		{
+		for (; aStart != aEnd; ++aStart)
+			aStart->iCategory = aStartCategory;
+		return;
+		}
+	// otherwise look at the embedding level in each case
+	for (; aStart != aEnd; ++aStart)
+		{
+		aStart->iCategory = aStart->iEmbeddingLevel & 1?
+			ERightToLeft : ELeftToRight;
+		}
+	}
+
+
+void TBidirectionalState::ResolveNeutralTypes(TReorderContext& aContext)
+	/**
+This phase removes the ON (Other Neutral) category, leaving only L, R, EN, and
+AN; no need to update aContext.iCategories.
+@internalComponent
+*/
+    {
+	// Really we should find if any number intervenes, but this would require
+	// a BC break.
+	TCategory prevNonNeutral = iPreviousStrongCategory;
+	if (prevNonNeutral & ELeftToRightGroup)
+		prevNonNeutral = ELeftToRight;
+	else if (prevNonNeutral & ERightToLeftGroup)
+		prevNonNeutral = ERightToLeft;
+	TRunInfo *prevNonNeutralRun = aContext.iRunInfo;	// one past the last non-neutral found
+	TRunInfo *endOfRuns = aContext.iRunInfo + aContext.iRuns;
+
+	// All neutrals have now been changed to ON; change them to L or R depending on context.
+	for (TRunInfo *p = aContext.iRunInfo; p != endOfRuns; ++p)
+		{
+		TCategory nonNeutral = EOtherNeutral;
+		switch (p->iCategory)
+			{
+			case ELeftToRight:
+				nonNeutral = ELeftToRight;
+				break;
+			case ERightToLeft:
+				nonNeutral = ERightToLeft;
+				break;
+			case EArabicNumber:
+			case EEuropeanNumber: 
+				nonNeutral = ERightToLeft;
+				break;
+			default:
+				break;
+			}
+		if (nonNeutral != EOtherNeutral)
+			{
+			if (p != prevNonNeutralRun)
+				DeneutralizeRuns(prevNonNeutralRun, p,
+					prevNonNeutral, nonNeutral);
+			prevNonNeutral = nonNeutral;
+			prevNonNeutralRun = p + 1;
+			}
+		}
+	DeneutralizeRuns(prevNonNeutralRun, endOfRuns, prevNonNeutral,
+		aContext.iNextStrongCategory);
+	}
+
+
+void TBidirectionalState::ResolveImplicitLevels(TReorderContext& aContext)
+/**
+Phases I1 and I2.
+@internalComponent
+*/	{
+	int i;
+	TRunInfo* r;
+	for (i = 0, r = aContext.iRunInfo; i < aContext.iRuns; i++, r++)
+		{
+		if (r->iEmbeddingLevel == 255) // sentinel indicating this is a tab or segment-final whitespace
+			r->iEmbeddingLevel = iStack[0].iEmbeddingLevel;
+		else switch (r->iCategory)
+			{
+			case ELeftToRight:
+				if (r->iEmbeddingLevel & 1)
+					r->iEmbeddingLevel++;
+				break;
+			case ERightToLeft:
+				if (!(r->iEmbeddingLevel & 1))
+					r->iEmbeddingLevel++;
+				break;
+			case EEuropeanNumber: case EArabicNumber:
+				if (r->iEmbeddingLevel & 1)
+					r->iEmbeddingLevel++;
+				else
+					r->iEmbeddingLevel += 2;
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+
+void TBidirectionalState::ReorderRuns(TReorderContext& aContext)
+/**
+Phase L2.
+@internalComponent
+*/	{
+	// Find the highest level and lowest odd level.
+	int i;
+	TRunInfo* r;
+	int highest = 0;
+	int lowest_odd = EMaxLevel;
+	int level = 0;
+	for (i = 0, r = aContext.iRunInfo; i < aContext.iRuns; i++, r++)
+		{
+		level = r->iEmbeddingLevel;
+		if (level > highest)
+			highest = level;
+		if ((level & 1) && level < lowest_odd)
+			lowest_odd = level;
+		}
+
+	// From the highest level to the lowest odd level, reverse any run at that level or higher.
+	for (level = highest; level >= lowest_odd; level--)
+		{
+		int run_start = 0;
+		r = aContext.iRunInfo;
+		while (run_start < aContext.iRuns)
+			{
+			while (run_start < aContext.iRuns && r->iEmbeddingLevel < level)
+				{
+				run_start++;
+				r++;
+				}
+			int run_end = run_start;
+			while (run_end < aContext.iRuns && r->iEmbeddingLevel >= level)
+				{
+				r->iDirection = !r->iDirection;
+				run_end++;
+				r++;
+				}
+			TRunInfo* p = &aContext.iRunInfo[run_start];
+			TRunInfo* q = &aContext.iRunInfo[run_end - 1];
+			while (p < q)
+				{
+				TRunInfo temp = *p;
+				*p = *q;
+				*q = temp;
+				p++;
+				q--;
+				}
+			run_start = run_end;
+			}
+		}
+	}
+
+
+TBidirectionalState::TCategory TBidirectionalState::Push(TCategory aStartCategory)
+/** @internalComponent */
+	{
+	TInt rightToLeftFlag = (static_cast<TInt>(aStartCategory)
+		& ERightToLeftGroup)? 1 : 0;
+	TInt oldLevel = State().iEmbeddingLevel;
+	TInt newLevel = oldLevel + 1;
+	// And add an extra one if the bottom bit is not correct.
+	newLevel += (newLevel & 1) ^ rightToLeftFlag;
+
+	if (EMaxExplicitLevel < newLevel)
+		{
+		if (oldLevel == 60)
+			++iPushesBeyond60;
+		else
+			++iPushesBeyond61;
+		return EBoundaryNeutral;
+		}
+
+	++iStackLevel;
+	TStackItem& state = iStack[iStackLevel];
+	state.iEmbeddingLevel = static_cast<TUint8>(newLevel);
+	state.iOverrideState = static_cast<TOverrideState>(aStartCategory
+		& (ELeftToRightOverride | ERightToLeftOverride));
+	state.iStartCategory = aStartCategory;
+
+	return rightToLeftFlag? ERightToLeft : ELeftToRight;
+	}
+
+
+TBidirectionalState::TCategory TBidirectionalState::Pop()
+/** @internalComponent */	
+   {
+	__ASSERT_DEBUG(0 < iStackLevel, User::Invariant());
+	TInt level = State().iEmbeddingLevel;
+	if (level < 60)
+		--iStackLevel;
+	else if (iPushesBeyond61 != 0)
+		--iPushesBeyond61;
+	else if (level == 61)
+		--iStackLevel;
+	else if (iPushesBeyond60)
+		--iPushesBeyond60;
+	else
+		--iStackLevel;
+	return (level & 1)? ERightToLeft : ELeftToRight;
+	}
+
+
+EXPORT_C void TBidirectionalState::Reset()
+/** Sets the object to its default 'start of paragraph' state. */
+	{
+	iStackLevel = 0;
+	iPushesBeyond60 = 0;
+	iPushesBeyond61 = 0;
+	iStack[0].iEmbeddingLevel = 0;
+	iStack[0].iOverrideState = ENoOverrideState;
+	iStack[0].iStartCategory = EOtherNeutral;
+	iPreviousCategory = ELeftToRight;
+	iPreviousStrongCategory = ELeftToRight;
+	}
+
+
+EXPORT_C TBool TBidirectionalState::IsDefault() const
+/** Returns Gets the default 'start of paragraph' state.
+
+@return ETrue if the object is in its default 'start of paragraph' state. */
+	{
+	return iStackLevel == 0 &&
+		   iStack[0].iEmbeddingLevel == 0 &&
+		   iStack[0].iOverrideState == ENoOverrideState &&
+		   iStack[0].iStartCategory == EOtherNeutral &&
+		   iPreviousCategory == ELeftToRight &&
+		   iPreviousStrongCategory == ELeftToRight;
+	}
+
+
+EXPORT_C TBool TBidirectionalState::operator==(const TBidirectionalState& aState) const
+/** Return ETrue if two bidirectional states are identical.
+
+@param aState A bidirectional state.
+@return ETrue if two bidirectional states are identical. */
+	{
+	if (iPreviousCategory != aState.iPreviousCategory ||
+		iPreviousStrongCategory != aState.iPreviousStrongCategory ||
+		iStackLevel != aState.iStackLevel)
+		return FALSE;
+	const TStackItem* p = iStack;
+	const TStackItem* q = aState.iStack;
+	for (int i = 0; i <= iStackLevel; i++, p++, q++)
+		{
+		if (p->iStartCategory != q->iStartCategory ||
+			p->iOverrideState != q->iOverrideState ||
+			p->iEmbeddingLevel != q->iEmbeddingLevel)
+			return FALSE;
+		}
+	return TRUE;
+	}
+
+
+TInt TBidirectionalState::CatToNumber(TInt aCat)
+/**
+Finds the highest bit set in the input. Used to convert
+TBidirectionalState::TCategory into TChar::TBdCategory.
+@param aCat a TBidirectionalState::TCategory.
+@return The equivalent TChar::TBdCategory.
+@internalComponent
+*/	{
+	TInt shifts = 0;
+	TInt bits = 32;
+	TInt mask = ~0L;
+	while (bits != 0)
+		{
+		bits >>= 1;
+		mask <<= bits;
+		if ((aCat & mask) == 0)
+			{
+			aCat <<= bits;
+			shifts += bits;
+			}
+		}
+	return 31 - shifts;
+	}
+
+
+EXPORT_C void TBidirectionalState::ExternalizeL(RWriteStream& aDest)
+/** Serializes a bidirectional state to an output stream.
+
+@param aDest An output stream. */
+	{
+	//+ put the prev cat, prev strong cat and stack levels in one number?
+	// Write the previous category and previous strong category.
+	aDest.WriteInt8L(CatToNumber(iPreviousCategory));
+	aDest.WriteInt8L(CatToNumber(iPreviousStrongCategory));
+
+	// Write the number of stack levels
+	aDest.WriteInt8L(iStackLevel);
+
+	/*
+	Write each stack level as a single number: 5 bits for the start category, 2 for the override state,
+	6 for the embedding level.
+	*/
+	for (int i = 0; i <= iStackLevel; i++)
+		{
+		TInt x = CatToNumber(iStack[i].iStartCategory);
+		if (iStack[i].iOverrideState == ELeftToRightOverrideState)
+			{
+			x |= (KBidirectionalStateOverrideStreamValueLeftToRight << 5);	
+			}
+        else if (iStack[i].iOverrideState == ERightToLeftOverrideState)
+        	{
+        	x |= (KBidirectionalStateOverrideStreamValueRightToLeft << 5); 	
+        	}
+       	x |= ((TInt)iStack[i].iEmbeddingLevel << 7);
+		aDest.WriteInt16L(x);
+		}
+
+	TInt level = State().iEmbeddingLevel;
+	if (60 <= level)
+		{
+		aDest.WriteInt8L(iPushesBeyond60);
+		aDest.WriteInt8L(iPushesBeyond61);
+		}
+	}
+
+
+EXPORT_C void TBidirectionalState::InternalizeL(RReadStream& aSource)
+/** Reads a bidirectional state from an input stream, translating it from its serialized 
+form.
+
+@param aSource A source stream. */
+	{
+	// Read the previous category and the previous strong category.
+	TInt x = aSource.ReadInt8L();
+	iPreviousCategory = (TCategory)(1 << x);
+	x = aSource.ReadInt8L();
+	iPreviousStrongCategory = (TCategory)(1 << x);
+
+	// Read the number of stack levels.
+	iStackLevel = aSource.ReadInt8L();
+
+	// Read the stack levels.
+	for (int i = 0; i <= iStackLevel; i++)
+		{
+		x = aSource.ReadInt16L();
+		iStack[i].iStartCategory = (TCategory)(1 << (x & 0x1F));
+		switch ((x >> 5) & 3)
+        	{
+    	case KBidirectionalStateOverrideStreamValueLeftToRight: 
+    		iStack[i].iOverrideState = ELeftToRightOverrideState;
+    		break;
+    	case KBidirectionalStateOverrideStreamValueRightToLeft:
+    		iStack[i].iOverrideState = ERightToLeftOverrideState; 
+    		break;
+    	case KBidirectionalStateOverrideStreamValueNone:
+    	default: iStack[i].iOverrideState = ENoOverrideState; break;
+        	};
+		iStack[i].iEmbeddingLevel = (TUint8)(x >> 7);
+		}
+
+	TInt level = State().iEmbeddingLevel;
+	if (60 <= level)
+		{
+		iPushesBeyond60 = aSource.ReadInt8L();
+		iPushesBeyond61 = aSource.ReadInt8L();
+		}
+	else
+		{
+		iPushesBeyond60 = 0;
+		iPushesBeyond61 = 0;
+		}
+	}
+
+
+TBidirectionalState::TBidirectionalState(TChar::TBdCategory aPrevCat,
+	TChar::TBdCategory aPrevStrongCat,
+	TBool aParRightToLeft)
+	/**
+Constructor suitable for test code.
+@internalComponent
+*/
+    {
+	Reset();
+	iPreviousCategory = CharToBdCat(aPrevCat);
+	iPreviousStrongCategory = CharToBdCat(aPrevStrongCat);
+	iStack[0].iEmbeddingLevel = (TUint8) (aParRightToLeft? 1 : 0);
+	}