// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

/**
 @file
 @internalComponent
*/


#include <gdi.h>
#include "FontArabic.h"
#include "GDIPANIC.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;
			GDI_ASSERT_DEBUG(!aText.AtEnd(), EGdiPanic_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.
			GDI_ASSERT_DEBUG(code == 0xFFFF, EGdiPanic_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;
	}