// 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:

 //

 /**

  @file

  @internalComponent

 */

 //#include <textbase.h>

 #include <gdi.h>

 #include "FontArabic.h"

 #include "TextBasePanic.h"

 //

 // Arabic Presentation Forms.

 //

 /**

  The contextual forms of each character in the range 0621 - 064A, in

  the order final, initial, medial; followed by the forms of

  the lam-alef ligatures (lam with 0622, 0623, 0625 and 0627);

  followed by the forms of the characters in the range 0671 - 06D3

 */

 LOCAL_D const TUint16 TheArabicShapeTable[] =

 	{

 	// Contextual forms for standard Arabic letters

 	0x621, 0x621, 0x621,			// 621

 	0xfe82, 0x622, 0x622,			// 622

 	0xfe84, 0x623, 0x623,			// 623

 	0xfe86, 0x624, 0x624,			// 624

 	0xfe88, 0x625, 0x625,			// 625

 	0xfe8a, 0xfe8b, 0xfe8c,			// 626

 	0xfe8e, 0x627,	0x627,			// 627

 	0xfe90, 0xfe91, 0xfe92,			// 628

 	0xfe94, 0x629, 0x629,			// 629

 	0xfe96, 0xfe97, 0xfe98,			// 62a

 	0xfe9a, 0xfe9b, 0xfe9c,			// 62b

 	0xfe9e, 0xfe9f, 0xfea0,			// 62c

 	0xfea2, 0xfea3, 0xfea4,			// 62d

 	0xfea6, 0xfea7, 0xfea8,			// 62e

 	0xfeaa, 0x62f, 0x62f,			// 62f

 	0xfeac, 0x630, 0x630,			// 630

 	0xfeae, 0x631, 0x631,			// 631

 	0xfeb0, 0x632, 0x632,			// 632

 	0xfeb2, 0xfeb3, 0xfeb4,			// 633

 	0xfeb6, 0xfeb7, 0xfeb8,			// 634

 	0xfeba, 0xfebb, 0xfebc,			// 635

 	0xfebe, 0xfebf, 0xfec0,			// 636

 	0xfec2, 0xfec3, 0xfec4,			// 637

 	0xfec6, 0xfec7, 0xfec8,			// 638

 	0xfeca, 0xfecb, 0xfecc,			// 639

 	0xfece, 0xfecf, 0xfed0,			// 63a

 	0x63b, 0x63b, 0x63b,			// placeholder

 	0x63c, 0x63c, 0x63c,			// placeholder

 	0x63d, 0x63d, 0x63d,			// placeholder

 	0x63e, 0x63e, 0x63e,			// placeholder

 	0x63f, 0x63f, 0x63f,			// placeholder

 	0x640, 0x640, 0x640,			// 640

 	0xfed2, 0xfed3, 0xfed4,			// 641

 	0xfed6, 0xfed7, 0xfed8,			// 642

 	0xfeda, 0xfedb, 0xfedc,			// 643

 	0xfede, 0xfedf, 0xfee0,			// 644

 	0xfee2, 0xfee3, 0xfee4,			// 645

 	0xfee6, 0xfee7, 0xfee8,			// 646

 	0xfeea, 0xfeeb, 0xfeec,			// 647

 	0xfeee, 0x648, 0x648,			// 648

 	0xfef0, 0xfbe8, 0xfbe9,			// 649

 	0xfef2, 0xfef3, 0xfef4,			// 64A

 	// Contextual forms for lam-alef ligatures

 	0xfef6, 0xfef5, 0xfef5,			// 644 + 622

 	0xfef8, 0xfef7, 0xfef7,			// 644 + 623

 	0xfefa, 0xfef9, 0xfef9,			// 644 + 625

 	0xfefc, 0xfefb, 0xfefb,			// 644 + 627

 	// Contextual forms for extended Arabic letters for Persian, Urdu, Sindhi, etc.

 	0xfb51, 0x0671, 0x0671,			// 671

 	0x0672, 0x0672, 0x0672,			// placeholder

 	0x0673, 0x0673, 0x0673,			// placeholder

 	0x0674, 0x0674, 0x0674,			// placeholder

 	0x0675, 0x0675, 0x0675,			// placeholder

 	0x0676, 0x0676, 0x0676,			// placeholder

 	0x0677, 0x0677, 0x0677,			// placeholder

 	0x0678, 0x0678, 0x0678,			// placeholder

 	0xfb67, 0xfb68, 0xfb69,			// 679

 	0xfb5f, 0xfb60, 0xfb61,			// 67a

 	0xfb53, 0xfb54, 0xfb55,			// 67b

 	0x067c, 0x067c, 0x067c,			// placeholder

 	0x067d, 0x067d, 0x067d,			// placeholder

 	0xfb57, 0xfb58, 0xfb59,			// 67e

 	0xfb63, 0xfb64, 0xfb65,			// 67f

 	0xfb5b, 0xfb5c, 0xfb5d,			// 680

 	0x0681, 0x0681, 0x0681,			// placeholder

 	0x0682, 0x0682, 0x0682,			// placeholder

 	0xfb77, 0xfb78, 0xfb79,			// 683

 	0xfb73, 0xfb74, 0xfb75,			// 684

 	0x0685, 0x0685, 0x0685,			// placeholder

 	0xfb7b, 0xfb7c, 0xfb7d,			// 686

 	0xfb7f, 0xfb80, 0xfb81,			// 687

 	0xfb89, 0x0688, 0x0688,			// 688

 	0x0689, 0x0689, 0x0689,			// placeholder

 	0x068a, 0x068a, 0x068a,			// placeholder

 	0x068b, 0x068b, 0x068b,			// placeholder

 	0xfb85, 0x068c, 0x068c,			// 68c

 	0xfb83, 0x068d, 0x068d,			// 68d

 	0xfb87, 0x068e, 0x068e,			// 68e

 	0x068f, 0x068f, 0x068f,			// placeholder

 	0x0690, 0x0690, 0x0690,			// placeholder

 	0xfb8d, 0x0691, 0x0691,			// 691

 	0x0692, 0x0692, 0x0692,			// placeholder

 	0x0693, 0x0693, 0x0693,			// placeholder

 	0x0694, 0x0694, 0x0694,			// placeholder

 	0x0695, 0x0695, 0x0695,			// placeholder

 	0x0696, 0x0696, 0x0696,			// placeholder

 	0x0697, 0x0697, 0x0697,			// placeholder

 	0xfb8b, 0x0698, 0x0698,			// 698

 	0x0699, 0x0699, 0x0699,			// placeholder

 	0x069a, 0x069a, 0x069a,			// placeholder

 	0x069b, 0x069b, 0x069b,			// placeholder

 	0x069c, 0x069c, 0x069c,			// placeholder

 	0x069d, 0x069d, 0x069d,			// placeholder

 	0x069e, 0x069e, 0x069e,			// placeholder

 	0x069f, 0x069f, 0x069f,			// placeholder

 	0x06a0, 0x06a0, 0x06a0,			// placeholder

 	0x06a1, 0x06a1, 0x06a1,			// placeholder

 	0x06a2, 0x06a2, 0x06a2,			// placeholder

 	0x06a3, 0x06a3, 0x06a3,			// placeholder

 	0xfb6b, 0xfb6c, 0xfb6d,			// 6a4

 	0x06a5, 0x06a5, 0x06a5,			// placeholder

 	0xfb6f, 0xfb70, 0xfb71,			// 6a6

 	0x06a7, 0x06a7, 0x06a7,			// placeholder

 	0x06a8, 0x06a8, 0x06a8,			// placeholder

 	0xfb8f, 0xfb90, 0xfb91,			// 6a9

 	0x06aa, 0x06aa, 0x06aa,			// 6aa

 	0x06ab, 0x06ab, 0x06ab,			// 6ab

 	0x06ac, 0x06ac, 0x06ac,			// 6ac

 	0xfbd4, 0xfbd5, 0xfbd6,			// 6ad

 	0x06ae, 0x06ae, 0x06ae,			// 6ae

 	0xfb93, 0xfb94, 0xfb95,			// 6af

 	0x06b0, 0x06b0, 0x06b0,			// placeholder

 	0xfb9b, 0xfb9c, 0xfb9d,			// 6b1

 	0x06b2, 0x06b2, 0x06b2,			// 6b2

 	0xfb97, 0xfb98, 0xfb99,			// 6b3

 	0x06b4, 0x06b4, 0x06b4,			// placeholder

 	0x06b5, 0x06b5, 0x06b5,			// placeholder

 	0x06b6, 0x06b6, 0x06b6,			// placeholder

 	0x06b7, 0x06b7, 0x06b7,			// placeholder

 	0x06b8, 0x06b8, 0x06b8,			// placeholder

 	0x06b9, 0x06b9, 0x06b9,			// placeholder

 	0xfb9f, 0x06ba, 0x06ba,			// 6ba

 	0xfba1, 0xfba2, 0xfba3,			// 6bb

 	0x06bc, 0x06bc, 0x06bc,			// placeholder

 	0x06bd, 0x06bd, 0x06bd,			// placeholder

 	0xfbab, 0xfbac, 0xfbad,			// 6be

 	0x06bf, 0x06bf, 0x06bf,			// placeholder

 	0xfba5, 0x06c0, 0x06c0,			// 6c0

 	0xfba7, 0xfba8, 0xfba9,			// 6c1

 	0x06c2, 0x06c2, 0x06c2,			// placeholder

 	0x06c3, 0x06c3, 0x06c3,			// placeholder

 	0x06c4, 0x06c4, 0x06c4,			// placeholder

 	0xfbe1, 0x06c5, 0x06c5,			// 6c5

 	0xfbda, 0x06c6, 0x06c6,			// 6c6

 	0xfbd8, 0x06c7, 0x06c7,			// 6c7

 	0xfbdc, 0x06c8, 0x06c8,			// 6c8

 	0xfbe3, 0x06c9, 0x06c9,			// 6c9

 	0x06ca, 0x06ca, 0x06ca,			// placeholder

 	0xfbdf, 0x06cb, 0x06cb,			// 6cb

 	0xfbfd, 0xfbfe, 0xfbff,			// 6cc

 	0x06cd, 0x06cd, 0x06cd,			// placeholder

 	0x06ce, 0x06ce, 0x06ce,			// placeholder

 	0x06cf, 0x06cf, 0x06cf,			// placeholder

 	0xfbe5, 0xfbe6, 0xfbe7,			// 6d0

 	0x06d1, 0x06d1, 0x06d1,			// placeholder

 	0xfbaf, 0x06d2, 0x06d2,			// 6d2

 	0xfbb1, 0x06d3, 0x06d3			// 6d3

 	};

 static const int KFinal = 0;

 static const int KInitial = 1;

 static const int KMedial = 2;

 static const int KStandardShapeTableOffset = 0x621;

 static const int KLamAlefShapeTableStart = 0x64B - 0x621;

 static const int KExtendedShapeTableOffset = 0x671 - (0x64f - 0x621);

 static inline TInt ArabicShapeTableIndex(TInt aCode)

 	{

 	if (aCode >= 0x621 && aCode <= 0x64a)

 		return (aCode - KStandardShapeTableOffset) * 3;

 	if (aCode >= 0x671 && aCode <= 0x6d3)

 		return (aCode - KExtendedShapeTableOffset) * 3;

 	return KErrNotFound;

 	}

 static inline TBool IsArabicPoint(TInt aCode)

 	{

 	return (aCode >= 0x64B && aCode <= 0x655) || aCode == 0x670;

 	}

 TInt ConsumeCharsAndDeterminePresentationForm(const TUtf32Iterator& aText,

 	TUint aFlags, TInt& aLigaturePortionsRemaining)

 /**

  Get the Arabic or other presentation form, consuming as many characters 

  as necessary. This function can cope with text that has already been 

  reversed.

 @internalComponent

 */

 	{

 	TUint c = aText.Get();

 	TInt index = ArabicShapeTableIndex(c);

 	if (index != -1)

 		{

 		if (aLigaturePortionsRemaining != 0)

 			{

 			--aLigaturePortionsRemaining;

 			TEXTBASE_ASSERT_DEBUG(!aText.AtEnd(), ETextBasePanic_Invariant);

 			return 0xFFFF;

 			}

 		int position = -1;

 		// Find previous and next character, skipping Arabic points.

 		TUtf32Iterator tmpText(aText);		

 		tmpText.Prev();

         TUint prev = 0xFFFF;

         while (!tmpText.BeforeStart() && (prev == 0xFFFF || IsArabicPoint(prev)))

             prev = tmpText.GetThenPrev();		

 		tmpText = aText;

 		tmpText.Next();

         TUint next = 0xFFFF;

         while (!tmpText.AtEnd() && (next == 0xFFFF || IsArabicPoint(next)))

             next = tmpText.GetThenNext();		

 		TInt possible_lam = (aFlags & CFont::TPositionParam::EFLogicalOrder)?

 			c : next;

 		TInt possible_alef = (aFlags & CFont::TPositionParam::EFLogicalOrder)?

 			next : c;

 		// Perform lam-alef ligation if necessary.

 		if (possible_lam == 0x644 &&

 			(possible_alef == 0x622 || possible_alef == 0x623 || possible_alef == 0x625 || possible_alef == 0x627))

 			{

 			switch(possible_alef)

 				{

 				case 0x622:

 					{

 					c = 0xfef5;

 					index = KLamAlefShapeTableStart;

 					break;

 					}

 				case 0x623:

 					{

 					c = 0xfef7;

 					index = KLamAlefShapeTableStart + 1;

 					break;

 					}

 				case 0x625:

 					{

 					c = 0xfef9;

 					index = KLamAlefShapeTableStart + 2;

 					break;

 					}

 				default:

 					{

 					c = 0xfefb;

 					index = KLamAlefShapeTableStart + 3;

 					}

 				}

 			index *= 3;

 			aLigaturePortionsRemaining = 2;

 			next = 0xFFFF;

 			while (!tmpText.AtEnd() && (next == 0xFFFF || IsArabicPoint(next)))

 				{

 				next = tmpText.Get();

 				tmpText.Next();

 				}

 			}

 		TInt left = (aFlags & CFont::TPositionParam::EFLogicalOrder)? prev : next;

 		TInt right = (aFlags & CFont::TPositionParam::EFLogicalOrder)? next : prev;

 		TBool prefix = FALSE;

 		if (left == 0x640 || left == 0x200D) // kashida or Zero-Width Joiner

 			prefix = TRUE;

 		else

 			{

 			TInt left_index = ArabicShapeTableIndex(left);

 			if (left_index != -1)

 				{

 				if (static_cast<TInt>(TheArabicShapeTable[left_index + KInitial]) != left ||

 					static_cast<TInt>(TheArabicShapeTable[left_index + KMedial]) != left)

 					prefix = TRUE;

 				}

 			}

 		TBool suffix = FALSE;

 		if (right == 0x640 || right == 0x200D) // kashida or Zero-Width Joiner

 			suffix = TRUE;

 		else 

 			{

 			TInt right_index = ArabicShapeTableIndex(right);

 			if (right_index != -1)

 				{

 				if (static_cast<TInt>(TheArabicShapeTable[right_index + KFinal]) != right ||

 					static_cast<TInt>(TheArabicShapeTable[right_index + KMedial]) != right)

 					suffix = TRUE;

 				}

 			}

 		TBool medial = static_cast<TUint>(TheArabicShapeTable[index + KMedial]) != c;

 		if (medial)

 			{

 			if (prefix && suffix)

 				position = KMedial;

 			else if (prefix)

 				position = KFinal;

 			else if (suffix)

 				position = KInitial;

 			}

 		else

 			{

 			if (prefix)

 				position = KFinal;

 			else if (suffix)

 				position = KInitial;

 			}

 		if (position >= 0)

 			c = TheArabicShapeTable[index + position];

 		}

 	return c;

 	}

 // 

 //

 // GlyphSelector_Arabic Class definition

 //

 //

 TBool GlyphSelector_Arabic::Process(TGlyphSelectionState& aGss, RShapeInfo&) 

 	{

 	// Select glyph - use presentation form if applicable.

 	TInt ligaturePortions = aGss.iLigaturePortionsRemaining;

 	TUint flags = aGss.iParam.iFlags;

 	TUint code = ConsumeCharsAndDeterminePresentationForm(aGss.iText,

 		flags, ligaturePortions);

 	aGss.iText.Next();

 	aGss.iClusterState = !aGss.iText.AtEnd() &&

 		(aGss.iText.Get().GetCategory() & 0xF0) == TChar::EMarkGroup?

 		TGlyphSelectionState::EGClusterNotComplete

 		: TGlyphSelectionState::EGClusterComplete;

 	// If we are beginning a new portion of a ligature, we must set the state.

 	if (ligaturePortions != aGss.iLigaturePortionsRemaining)

 		{

 		if (ligaturePortions != 1)

 			aGss.iClusterState = TGlyphSelectionState::EGClusterNotComplete;

 		aGss.iLigaturePortionFirstMark = aGss.iParam.iOutputGlyphs;

 		if (ligaturePortions < aGss.iLigaturePortionsRemaining)

 			{

 			aGss.iLigaturePortionsRemaining = ligaturePortions;

 			// We have just swallowed a non-initial part of the ligature, which

 			// must not be drawn.

 			TEXTBASE_ASSERT_DEBUG(code == 0xFFFF, ETextBasePanic_Invariant);

 			return ETrue;

 			}

 		aGss.iLigaturePortionsRemaining = ligaturePortions;

 		}

 	// In this method we always output the glyph code calculate previously.

 	if (!aGss.AppendGlyphToCluster(code))

 		return EFalse;

 	if (!aGss.IsCombiningClass())

 		{

 		aGss.iPen = TGlyphSelectionState::EPenAdvance_Yes;

 		return ETrue;

 		}

 	// Adjust glyph's bounds further to position this character.

 	aGss.iPen = TGlyphSelectionState::EPenAdvance_No;

 	TRect baseBounds = aGss.iParam.iOutput[0].iBounds;

 	TInt firstMark = 1;

 	if (aGss.iLigaturePortionsRemaining != 0)

 		{

 		TInt centre = (baseBounds.iBr.iX + baseBounds.iTl.iX) >> 1;

 		TBool firstHalf = aGss.iLigaturePortionsRemaining == 2;

 		TBool rightHandSide = flags & CFont::TPositionParam::EFLogicalOrder?

 			firstHalf : !firstHalf;

 		if (rightHandSide)

 			baseBounds.iTl.iX = centre;

 		else

 			baseBounds.iBr.iX = centre;

 		if (firstHalf)

 			aGss.iClusterState = TGlyphSelectionState::EGClusterNotComplete;

 		firstMark = aGss.iLigaturePortionFirstMark;

 		}

 	aGss.CombineLastGlyphToBase(baseBounds, firstMark);

 	return ETrue;

 	}

 TBool GlyphSelector_Arabic::CharactersJoin(TInt aLeftCharacter, TInt aRightCharacter)

 	{

 	// All the characters join to the right, so we don't need to look them up.

 	// as long as they are there at all, it is OK.

 	TBool leftIsFixedJoiner = aLeftCharacter == 0x640 || aLeftCharacter == 0x200D;

 	if (!leftIsFixedJoiner)

 		{

 		TInt leftIndex = ArabicShapeTableIndex(aLeftCharacter);

 		if (leftIndex == -1)

 			return EFalse;

 		if (static_cast<TInt>(TheArabicShapeTable[leftIndex + KFinal])

 			== aLeftCharacter)

 			return EFalse;

 		}

 	if (aRightCharacter == 0x640 || aRightCharacter == 0x200D)

 		return !leftIsFixedJoiner;

 	TInt rightIndex = ArabicShapeTableIndex(aRightCharacter);

 	return rightIndex != -1

 		&& static_cast<TInt>(TheArabicShapeTable[rightIndex + KInitial])

 			!= aRightCharacter;

 	}