/*

* Copyright (c) 2004-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: 

*

*/

//#include "TCustomWrap.h"

#include "TGraphicsContext.h"

#include <e32std.h>

#include <e32test.h>

#include <frmtlay.h>

#include <frmtview.h>

#include <txtlaydc.h>

#include <fbs.h>

#include <w32std.h>

#include <inlinetext.h>

namespace LocalToFile

{

_LIT(KTInlineText, "TInlineText");

const TInt KDisplayWidthWide = 202;

const TInt KDisplayWidthThin = 102;

const TInt KDisplayHeight = 100;

const TInt KPictureCharacter = 0xFFFC;

RTest test(KTInlineText);

enum TInlineTextPanic { EAccessOutsideText = 1 };

void Panic(TInlineTextPanic)

    {

    User::Panic(_L("TInlineText"), EAccessOutsideText);

    }

class CPinkSquare : public CPicture

	{

public:

	// Size of square in twips.

	// 600 is 15 pixels using the standard test graphics device at

	// its default resolution.

	enum { KWidth = 600, KHeight = 600 };

	CPinkSquare()

		{}

	void Draw(CGraphicsContext& aGc, const TPoint& aTopLeft, const TRect& aClipRect, MGraphicsDeviceMap* aMap) const

		{

		// This picture is a magenta square

		TPoint size(KWidth, KHeight);

		if (aMap)

			size = aMap->TwipsToPixels(size);

		TRect rect(aTopLeft, aTopLeft + size);

		aGc.SetClippingRect(aClipRect);

		aGc.SetDrawMode(CGraphicsContext::EDrawModePEN);

		aGc.SetPenColor(KRgbMagenta);

		aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

		aGc.SetBrushColor(KRgbMagenta);

		aGc.DrawRect(rect);

		}

	void ExternalizeL(RWriteStream&) const

		{}

	void GetOriginalSizeInTwips(TSize& a) const

		{

		a.iWidth = CPinkSquare::KWidth;

		a.iHeight = CPinkSquare::KHeight;

		}

	};

_LIT(KEnd, "\x2029");

class TDocModel : public MLayDoc

	{

public:

	TDocModel(const TDesC& aDes)

	 :	iDes(&aDes), iParagraphFormat(0)

		{}

	void SetParagraphFormat(CParaFormat* a)

		{

		iParagraphFormat = a;

		}

	// From MLayDoc

	TInt LdDocumentLength() const

		{ return iDes->Length(); }

	TInt LdToParagraphStart(TInt& a) const

		{

		TInt curr = a;

		if (a < LdDocumentLength())

			{

			a = iDes->Left(a).LocateReverse(0x2029);

			a = a < 0? 0 : a + 1;

			}

		return curr - a;

		}

	void GetParagraphFormatL(CParaFormat* aFormat, TInt) const

		{

		if (iParagraphFormat)

			{

			aFormat->CopyL(*iParagraphFormat);

			return;

			}

		aFormat->Reset();

		TTabStop tabStop;

		tabStop.iTwipsPosition = 1000;

		tabStop.iType = TTabStop::ELeftTab;

		aFormat->StoreTabL(tabStop);

		}

	void GetChars(TPtrC& aView,TCharFormat& aFormat, TInt aStartPos)const

		{

        __ASSERT_ALWAYS(aStartPos <= LdDocumentLength(), Panic(EAccessOutsideText));

        __ASSERT_ALWAYS(aStartPos >= 0, Panic(EAccessOutsideText));

		TCharFormat cf;

		aFormat = cf;

		if (aStartPos == LdDocumentLength())

			aView.Set(KEnd);

		else

			aView.Set(iDes->Mid(aStartPos));

		}

	TInt GetPictureSizeInTwips(TSize& aSize, TInt aPos) const

		{

		if ((*iDes)[aPos] != KPictureCharacter)

			return KErrNotFound;

		aSize.iWidth = CPinkSquare::KWidth;

		aSize.iHeight = CPinkSquare::KHeight;

		return KErrNone;

		}

	CPicture* PictureHandleL(TInt aPos, TForcePictureLoad) const

		{

		if ((*iDes)[aPos] != KPictureCharacter)

			return 0;

		return new(ELeave) CPinkSquare;

		}

	TBool EnquirePageBreak(TInt aPos, TInt aLength)const

		{

		return iDes->Mid(aPos, aLength).Locate(0x000C) < 0?

			EFalse : ETrue;

		}

	TBool SelectParagraphLabel(TInt)

		{ return EFalse; }

	void CancelSelectLabel()

		{}

private:

	const TDesC* iDes;

	CParaFormat* iParagraphFormat;

	};

}

using namespace LocalToFile;

class CTestTextView	// slightly naughty

	{

public:

	static void SetContextForFlickerFreeRedraw(CTextView* aView, CBitmapContext* aContext)

		{

		aView->iOffScreenContext = aContext;

		}

	};

// Utility functions to show contents of test data using test.Printf

_LIT(KAddressMarker, "> ");

_LIT(KSpace, " ");

_LIT(KLength, ", Length of Data = %d 16-bit words\r\n");

_LIT(KSpaces, "                                                                      ");

_LIT(KPeriod, ".");

_LIT(KSingleString, "%s\r\n");

//_LIT(KDoubleString, "%s <%s>\r\n");

//_LIT(KLinefeed, "\r\n");

void PrintTestData (const TDesC& aTitle , const TDesC16& aData)

	{

	TInt i;

	TInt j;

	TInt end;

	TInt length = aData.Length();

	TBuf<80> buffer;

	buffer.Zero();

	buffer.Append(aTitle);

	buffer.Append(KLength);

	test.Printf(buffer, length);

	for (i = 0 ; i < length ; i += 8)

		{

		buffer.Zero();

		buffer.AppendNumFixedWidth(i, EHex, 8);

		buffer += KAddressMarker;

		end = ((length-i) >= 8) ? i+8 : length;

		for (j = i ; j < end ; ++j)

			{

			buffer.AppendNumFixedWidth(aData[j], EHex, 4);

			buffer += KSpace;

			}

		buffer += TPtrC(KSpaces().Ptr(), ((8-(j-i))*5)+4);

		for (j = i ; j < end ; ++j)

			{

			if (aData[j] >= 32)

				{

				buffer.Append(aData[j]);

				}

			else

				{

				buffer += KPeriod;

				}

			}

		buffer.ZeroTerminate();

		test.Printf(KSingleString, buffer.Ptr());

		}

	}

void PrintTestData(const TDesC& aTitle, const TText16* aDataBuffer, const TInt aSize)

	{

	PrintTestData(aTitle, TPtrC16(aDataBuffer, aSize));

	}

class CTestInlineTextSource : public CBase, public MTmInlineTextSource

	{

public:

	static CTestInlineTextSource* NewL(TPtrC aText, TInt aNumChar);

	~CTestInlineTextSource();

public: // From MTmInlineTextSource

	/**

	Reports the next position into which inline text should be inserted

	@param aFrom

		The document position and character edge to start from.

	@param aMaxLength

		The maximum length within which to report inline text.

		It means that inline text at position X should be reported if

		aFrom <= X && X < aFrom + aMaxLength.

		Also report trailing inline text at position aFrom + aMaxLength

		because it is really attached to the preceding character.

		Always report only the first inline text position >= aFrom.

	@param aNext

		On exit the position of the next bit of inline text to be inserted.

		N.B. The position of trailing text following position N and the

		position of leading text preceding position N+1 are both

		considered to be N+1 - and the trailing text comes first so if

		aFrom specifies a leading edge do not report trailing edge

		inline text unless its position is greater than aFrom.

		A panic EBadReturnValue will result otherwise.

	@return

		KErrNone if a position is found within the specified range,

		KErrNotFound otherwise.

	@post

		if KErrNone returned then aFrom <= aNext

		&& GetInlineText(aNext).Length() != 0

		&& (GetInlineText(X).Length() == 0 for all

		TTmDocPos X such that aFrom < X && X < aNext)

		else if KErrNotFound returned

		GetInlineText(X).Length() == 0 for all

		TTmDocPos X such that aFrom <= X && X < aFrom + aMaxLength

	*/

	virtual TInt GetNextInlineTextPosition(const TTmDocPos& aFrom, TInt aMaxLength, TTmDocPos& aNext);

	/**

	Gets a view of the text to be inserted at aAt.

	@param aAt

		Document position, including character edge, being queried.

	@return

		Any inline text that should be attached to the specified character edge at aAt.

	*/

	virtual TPtrC GetInlineText(const TTmDocPos& aAt);

private:

	CTestInlineTextSource();

	void Construct(TPtrC aText, TInt aNumChar);

	TPtrC iNullText;

	TPtrC iText;

	TInt iNumChar;

	};

CTestInlineTextSource::CTestInlineTextSource()

	{

	}

CTestInlineTextSource* CTestInlineTextSource::NewL(TPtrC aText, TInt aNumChar)

	{

	CTestInlineTextSource* self= new(ELeave) CTestInlineTextSource();

	self->Construct(aText, aNumChar);

	return self;

	}

CTestInlineTextSource::~CTestInlineTextSource()

	{

	}

void CTestInlineTextSource::Construct(TPtrC aText, TInt aNumChar)

	{

	iText.Set(aText);

	iNumChar = aNumChar;

	}

// This takes two inputs, each of which is either a real position,

// greater than or equal to 0, or KErrNotFound. If both are real

// positions then it should return the lower. If one is a real position

// then it should be returned. If neither are a real position then

// KErrNone is returned. It is all done with pointers to TInts so that

// when I get the result I can tell which one it is.

TInt* CustomMin(TInt* aPtrPos1, TInt* aPtrPos2)

	{

	if (*aPtrPos2 == KErrNotFound)

		return aPtrPos1;

	if (*aPtrPos1 == KErrNotFound)

		return aPtrPos2;

	if (*aPtrPos1 <= *aPtrPos2)

		return aPtrPos1;

	else

		return aPtrPos2;

	}

TInt CTestInlineTextSource::GetNextInlineTextPosition(const TTmDocPos& aFrom, TInt aMaxLength, TTmDocPos& aNext)

	{

	if (iNumChar == 0)

		return KErrNotFound;

	_LIT(KSS1, "A");

	_LIT(KSS2, "B");

    _LIT(KSS3, "C");

    _LIT(KSS4, "\x05c0");//Hebrew character to test right-to-left text

	TInt from = aFrom.iPos;

	TInt from2 = from;

	if ((from > 0) && (!aFrom.iLeadingEdge))

		from2--; // adjustment takes care of not returning trailing edge if at start pos

	TInt pos1 = iText.Mid(from).Find(KSS1);

	TInt pos2 = iText.Mid(from2).Find(KSS2);

	TInt pos3 = iText.Mid(from).Find(KSS3);

    TInt pos4 = iText.Mid(from2).Find(KSS3);

    TInt pos5 = iText.Mid(from2).Find(KSS4);

	if (pos1 >= 0 ) // adjustments so we compare like for like

		pos1 += from - from2;

	if (pos3 >= 0 )

		pos3 += from - from2;

	// get the smallest real position, if any

	TInt* ptrPos = CustomMin(CustomMin(&pos1, &pos3), CustomMin(CustomMin(&pos2, &pos4),&pos5));

	if (pos1 > 0 ) // now adjust back

		pos1 -= from - from2;

	if (pos3 > 0 )

		pos3 -= from - from2;

	if (*ptrPos == KErrNotFound)

		return KErrNotFound;

	if ((ptrPos == &pos1) || (ptrPos == &pos3))

		{ // it was an A or C with leading text

		aNext.iPos = *ptrPos + from;

		aNext.iLeadingEdge = ETrue;

		}

	else if ((ptrPos == &pos2) || (ptrPos == &pos4))

		{ // it was an B oD with trailing text

		aNext.iPos = *ptrPos + from2 + 1;

		aNext.iLeadingEdge = EFalse;

		}

    else if (ptrPos == &pos5)

        { // it was an Hebrew char with trailing text

        aNext.iPos = *ptrPos + from2 + 1;

        aNext.iLeadingEdge = EFalse;

        }

	else

		{

		// something has gone horribly wrong

		return KErrNotFound;

		}

	if (aNext.iPos - aFrom.iPos > aMaxLength + (aNext.iLeadingEdge ? 0 : 1))

		return KErrNotFound;

	return KErrNone;

	}

TPtrC CTestInlineTextSource::GetInlineText(const TTmDocPos& aAt)

	{

	if (iNumChar == 0)

		return iNullText;

	if ((aAt.iPos == 0) && (!aAt.iLeadingEdge))

		return iNullText;

	_LIT(KSS1, "A");

	_LIT(KSS2, "B");

	_LIT(KSS3, "C");

    _LIT(KSS4, "\x05c0");//Hebrew character to test right-to-left text

	TInt at = aAt.iPos;

	TInt at2 = at;

	if ((at2 > 0) && (!aAt.iLeadingEdge))

		at2--; // adjustment takes care of not returning trailing edge if at start pos

	TInt pos1 = iText.Mid(at).Find(KSS1);

	TInt pos2 = iText.Mid(at2).Find(KSS2);

	TInt pos3 = iText.Mid(at).Find(KSS3);

	TInt pos4 = iText.Mid(at2).Find(KSS3);

    TInt pos5 = iText.Mid(at2).Find(KSS4);

	if (pos1 == 0)

		{

		pos1 += at;

		if ((pos1 == aAt.iPos) && aAt.iLeadingEdge)

			{

			TPtrC tPtrC;

			if (iNumChar == 1)

				{

				_LIT(KIS11, "a");

				tPtrC.Set(KIS11);

				}

			else if (iNumChar == 2)

				{

				_LIT(KIS12, "aa");

				tPtrC.Set(KIS12);

				}

			return tPtrC;

			}

		}

	if (pos2 == 0)

		{

		pos2 += at2;

		if ((pos2 + 1 == aAt.iPos) && !aAt.iLeadingEdge)

			{

			TPtrC tPtrC;

			if (iNumChar == 1)

				{

				_LIT(KIS21, "b");

				tPtrC.Set(KIS21);

				}

			else if (iNumChar == 2)

				{

				_LIT(KIS22, "bb");

				tPtrC.Set(KIS22);

				}

			return tPtrC;

			}

		}

	if ((pos3 == 0) || (pos4 == 0))

		{

		if (((pos3 + at == aAt.iPos) && aAt.iLeadingEdge) || ((pos4 + at2 + 1 == aAt.iPos) && !aAt.iLeadingEdge))

			{

			TPtrC tPtrC;

			if (iNumChar == 1)

				{

				_LIT(KIS31, "c");

				tPtrC.Set(KIS31);

				}

			else if (iNumChar == 2)

				{

				_LIT(KIS32, "cc");

				tPtrC.Set(KIS32);

				}

			return tPtrC;

			}

		}

    if (pos5 == 0)

        {

        pos5 += at2;

        if ((pos5 + 1 == aAt.iPos) && !aAt.iLeadingEdge)

            {

            TPtrC tPtrC;

            if (iNumChar == 1)

                {

                _LIT(KIS41, "\05be");

                tPtrC.Set(KIS41);

                }

            else if (iNumChar == 2)

                {

                _LIT(KIS42, "\05be\05be");

                tPtrC.Set(KIS42);

                }

            return tPtrC;

            }

        }

	return iNullText;

	}

class CTestFormExtendedInterfaceProvider: public CBase, public MFormCustomInterfaceProvider

	{

public:

	static CTestFormExtendedInterfaceProvider* NewL(TPtrC aText, TInt aNumChar);

	~CTestFormExtendedInterfaceProvider();

	TAny* GetExtendedInterface(const TUid& aInterfaceId);

private:

	CTestFormExtendedInterfaceProvider();

	void ConstructL(TPtrC aText, TInt aNumChar);

private:

	CTestInlineTextSource* iTestInlineTextSource; // Owned

	};

CTestFormExtendedInterfaceProvider::CTestFormExtendedInterfaceProvider()

	{

	}

CTestFormExtendedInterfaceProvider* CTestFormExtendedInterfaceProvider::NewL(TPtrC aText, TInt aNumChar)

	{

	CTestFormExtendedInterfaceProvider* self= new(ELeave) CTestFormExtendedInterfaceProvider();

	CleanupStack::PushL(self);

	self->ConstructL(aText, aNumChar);

	CleanupStack::Pop(); // self

	return self;

	}

CTestFormExtendedInterfaceProvider::~CTestFormExtendedInterfaceProvider()

	{

	delete iTestInlineTextSource;

	}

void CTestFormExtendedInterfaceProvider::ConstructL(TPtrC aText, TInt aNumChar)

	{

	iTestInlineTextSource = CTestInlineTextSource::NewL(aText, aNumChar);

	}

TAny* CTestFormExtendedInterfaceProvider::GetExtendedInterface( const TUid& aInterfaceId )

	{

	if (aInterfaceId == KInlineTextApiExtensionUid)

		{

		return static_cast<MTmInlineTextSource*>(iTestInlineTextSource);

		}

	else

		{

		return NULL;

		}

	}