/*

* Copyright (c) 2002-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 "TCustomWrap.h"

#include "TGraphicsContext.h"

#include "TBitmapDoc.h"

#include "TestPicture.h"

#include <e32std.h>

#include <e32test.h>

#include <frmtlay.h>

#include <frmtview.h>

#include <txtlaydc.h>

#include <fbs.h>

#include <w32std.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "TAGMA_INTERNAL.H"

#endif

namespace LocalToFile {

_LIT(KTTextView2, "TTextView2");

const TInt KDisplayWidth = 100;

const TInt KDisplayHeight = 100;

const TInt KAleph = 0x5D0;

const TInt KPictureCharacter = 0xFFFC;

const TInt KRightToLeftMarker = 0x200F;

const TInt KZeroWidthNonJoiner = 0x200C;

RTest test(KTTextView2);

/** Simple test picture. */

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");

/** Lightweight test document model. */

class TDocModel : public MLayDoc

	{

public:

	TDocModel(const TDesC& aDes)

		: iDes(&aDes), iParagraphFormat(0), iBreakPos(0) {}

	void SetParagraphFormat(CParaFormat* a)

		{

		iParagraphFormat = a;

		}

	/** Sets the segmentation of the buffer to cut at this point.

	aParam a 0 means no break at all. */

	void SetBreakPos(TInt a)

		{

		iBreakPos = 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

		{

		TCharFormat cf;

		aFormat = cf;

		TInt docLength = LdDocumentLength();

		if (aStartPos < iBreakPos && iBreakPos < docLength)

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

		else if (aStartPos == docLength)

			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;

	TInt iBreakPos;

	};

}

// Remaps whatever character is used in construction to the letter 'E'

class TTestCustomRemap : public MFormCustomInvisibleCharacterRemapper

	{

public:

	TTestCustomRemap(TUint aChar)

		{

		iChar = aChar;

		}

	TUint Remap(TUint aChar, const TNonPrintingCharVisibility aNonPrintingCharVisibility,

		const TLayDocTextSource& aLayDoc)

		{

	    if (aChar == iChar)

	        {

			return 'E';

	        }

	    else

	    	{

		    return DefaultMapping(aChar, aNonPrintingCharVisibility, aLayDoc);

	    	}

		}

private:

	TUint iChar;

	};

// Remaps all break characters to the letter 'E'

class TTestCustomRemapper : public MFormCustomInvisibleCharacterRemapper

	{

public:

	TUint Remap(TUint aChar, const TNonPrintingCharVisibility aNonPrintingCharVisibility,

		const TLayDocTextSource& aLayDoc)

		{

	    switch (aChar)

	        {

	        case CEditableText::ELineBreak:

	        case CEditableText::EParagraphDelimiter:

	        case CEditableText::EPageBreak:

				return 'E';

	        default:

	            break; // do nothing

	        }

	    return DefaultMapping(aChar, aNonPrintingCharVisibility, aLayDoc);

		}

	};

using namespace LocalToFile;

class CTestTextView

	{

public:

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

		{

		aView->iOffScreenContext = aContext;

		}

	static TRect GetInvalidRect(CTextView* aView)

		{

		return aView->iDisplay.ClippingRect();

		}

	static int GetFormattedHeight(CTextView* aView)

		{

		return aView->iFormattedUpTo;

		}

	static void TestMemberOffsetsL()

		{

		// The members of these classes must not move due to inline method offsets.

		// Any of the following tests failing will indicate a BC break.

		test(_FOFF(CTextView, iLayout)==64);

		test(_FOFF(CTextView, iCursorPos)==192);

		test(_FOFF(CTextView, iFlags)==240);

		test(_FOFF(CTextView, iObserver)==264);

		}

	};

class CTestTextLayout

	{

public:

	static void TestMemberOffsetsL()

		{

		// The members of these classes must not move due to inline method offsets.

		// Any of the following tests failing will indicate a BC break.

		test(_FOFF(CTextLayout, iText)==4);

		test(_FOFF(CTextLayout, iBandTop)==104);

		test(_FOFF(CTextLayout, iScrollFlags)==116);

		test(_FOFF(CTextLayout, iHighlightExtensions)==128);

		}

	};

// Test for TET-5D7MCV: Sound object focus indicators flickering

_LIT(KPicture, "\xFFFC");

_LIT(KInitialText, "xy");

void SetViewRect1(CTextView *aView)

	{

	TRect view(0, 0, 100, 100);

	aView->SetViewRect(view);

	}

void SetViewRect2(CTextView *aView)

	{

	TRect view(10, 15, 60, 65);

	aView->SetViewRect(view);

	}

void TET_5D7MCV_L(TDes& aText, CTestGraphicsDevice* aDevice, CTextView* aView,

	CTextLayout* aLayout)

	{

	// This is supposed to test flicker-free redraw, but that is very difficult

	// to test properly, so we do what we can:

	// 1) If flicker-free redraw is disabled and there is no off-screen context set,

	//    there should be drawing to the real device

	// 2) If there is an off-screen context set, there should be drawing to the

	//    off-screen context, and not the real device

	// 3) If flicker-free redraw is enabled and there is no off-screen context set,

	//    there should be no drawing to the real device.

	// We are not testing that the correct thing is drawn to the internal off-screen

	// bitmap when flicker-free redraw is enabled. This is bad, but I can't work

	// out a good way round it. As the off-screen context uses much of the same

	// machinery as flicker-free redraw, it tests maybe 80% of it.

	SetViewRect1(aView);

	CTestGraphicsDevice* offScreenDevice = CTestGraphicsDevice::NewL(aDevice->SizeInPixels(), 0);

	CleanupStack::PushL(offScreenDevice);

	CWindowGc* offScreenContext;

	User::LeaveIfError(offScreenDevice->CreateContext(offScreenContext));

	CleanupStack::PushL(offScreenContext);

	CTestTextView::SetOffScreenContext(aView, 0);

	aView->DisableFlickerFreeRedraw();

	aText.Append(KInitialText);

	aView->HandleInsertDeleteL(TCursorSelection(0,KInitialText().Length()), 0, EFalse);

	aText.Insert(1, KPicture);

	aView->HandleInsertDeleteL(TCursorSelection(1,2), 0, ETrue);

	aView->SetCursorVisibilityL(TCursor::EFCursorVisible, TCursor::EFCursorVisible);

	aView->SetSelectionVisibilityL(ETrue);

	aView->EnablePictureFrameL(ETrue);

	TRect* pictureRectPtr;

	TInt frameEdges;

	aView->SetXyPosL(TPoint(11, 1), EFalse, pictureRectPtr, frameEdges);

	test(pictureRectPtr != 0);

	aDevice->ClearAreaDrawnWithCondition();

	offScreenDevice->ClearAreaDrawnWithCondition();

	aView->DrawL(TRect(0, 0, CPinkSquare::KWidth, CPinkSquare::KHeight));

	test(!aDevice->AreaDrawnWithCondition().IsEmpty());

	test(offScreenDevice->AreaDrawnWithCondition().IsEmpty());

	aDevice->ClearAreaDrawnWithCondition();

	offScreenDevice->ClearAreaDrawnWithCondition();

	CTestTextView::SetOffScreenContext(aView, offScreenContext);

	aView->EnableFlickerFreeRedraw();

	aView->DrawL(TRect(0, 0, CPinkSquare::KWidth, CPinkSquare::KHeight));

	test(aDevice->AreaDrawnWithCondition().IsEmpty());

	TRect xoredArea = offScreenDevice->AreaDrawnWithCondition();

	test(!xoredArea.IsEmpty());

	offScreenDevice->ClearAreaDrawnWithCondition();

	SetViewRect1(aView);

	const TRect &viewRect = aView->ViewRect();

	aView->DrawL(viewRect);

	test(aDevice->AreaDrawnWithCondition().IsEmpty());

	test(offScreenDevice->AreaDrawnWithCondition() == xoredArea);

	// We need a CFbsDevice -- this will supply fonts that can be drawn to the

	// offscreen bitmap created by the flicker-free redraw code.

	CFbsBitmap* bm = new CFbsBitmap;

	CleanupStack::PushL(bm);

	bm->Create(TSize(1,1), EGray2);

	CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bm);

	CleanupStack::PushL(bitmapDevice);

	aLayout->SetImageDeviceMap(bitmapDevice);

	CTestTextView::SetOffScreenContext(aView, 0);

	aView->EnableFlickerFreeRedraw();

	aView->DrawL(TRect(0, 0, CPinkSquare::KWidth, CPinkSquare::KHeight));

	test(aDevice->AreaDrawnWithCondition().IsEmpty());

	xoredArea = offScreenDevice->AreaDrawnWithCondition();

	test(!xoredArea.IsEmpty());

	offScreenDevice->ClearAreaDrawnWithCondition();

	SetViewRect1(aView);

	aView->DrawL(viewRect);

	test(aDevice->AreaDrawnWithCondition().IsEmpty());

	aLayout->SetImageDeviceMap(aDevice);

	CleanupStack::PopAndDestroy(bitmapDevice);

	CleanupStack::PopAndDestroy(bm);

	CTestTextView::SetOffScreenContext(aView, 0);

	aView->DisableFlickerFreeRedraw();

	aDevice->ClearAreaDrawnWithCondition();

	offScreenDevice->ClearAreaDrawnWithCondition();

	aView->DrawL(viewRect);

	test(offScreenDevice->AreaDrawnWithCondition().IsEmpty());

	xoredArea.Move(viewRect.iTl);

	test(aDevice->AreaDrawnWithCondition() == xoredArea);

	CleanupStack::PopAndDestroy(offScreenContext);

	CleanupStack::PopAndDestroy(offScreenDevice);

	}

/**

@SYMTestCaseID          SYSLIB-FORM-CT-4014

@SYMTestCaseDesc	    Tests CTextView::IsPictureFrameSelected doesn't panic with EFNoPictureFrame

@SYMTestPriority 	    High

@SYMTestActions

@SYMTestExpectedResults Resulting document position are where expected and frame drawn correctly.

 						In  this case picture frame is not drawn as we set the selection visibility to "off"

@SYMDEF                 PDEF118831

*/

void RunPDEF118831TestL()

	{

	//create editor/bitmap

 	CTestBitmapFile* bitMap = CTestBitmapFile::NewLC(TRect(0, 0, 140, 185));

	//create the picture to insert (this one is a red box)

	CTestPicture* pic = new(ELeave)CTestPicture();

 	CleanupStack::PushL(pic);

   	pic->SetSizeInTwips(TSize(400,400));

   	//add some text before the pictures

   	bitMap->AppendL(_L("A"));

	//Add 2 pictures

	TInt pos = 0;

	for (pos=0;pos<2;pos++)

		bitMap->AppendL(pic);

	//add some text after the pictures

	bitMap->AppendL(_L("A"));

	bitMap->View()->HandleGlobalChangeL();

	//As a result we have

	//            A+Pict+Pict+A

	//with cursor pos: 01 1 2  2 3  4

	//SetSelectionVisibility to false

	bitMap->View()->SetSelectionVisibilityL(EFalse);

	// Place the cursor at the end of the last picture added and start moving the cursor left.

	TCursorPosition::TMovementType type = TCursorPosition::EFLeft;

	// Docuemnt position is already at the end, but it is Trailing. Make it Leading and set it.

	TTmDocPosSpec::TType docPosType = TTmDocPosSpec::ELeading;

	TTmDocPos thisPos;

	TTmDocPosSpec docPos;

	docPos.iPos = 4;

	docPos.iType = docPosType;

	TRect dummyRect;

	TInt dummyPos;

	TBool selectionIsPictureFrame;

	// Cursor on last letter "A"

	bitMap->View()->SetDocPosL(docPos);

	bitMap->View()->GetCursorPos(thisPos);

	selectionIsPictureFrame

	= bitMap->View()->IsPictureFrameSelected(dummyRect, dummyPos);

	test(thisPos.iPos == 4 && type == TCursorPosition::EFLeft);

	test(selectionIsPictureFrame == 0);

	// Move cursor left

	// Cursor moved to first (from the right) picture but picture frame not selected

	bitMap->View()->MoveCursorL(type, EFalse);

	bitMap->View()->GetCursorPos(thisPos);

	selectionIsPictureFrame

	= bitMap->View()->IsPictureFrameSelected(dummyRect, dummyPos);

	test(thisPos.iPos == 3 && type == TCursorPosition::EFLeft);

	test(selectionIsPictureFrame == 0);

	// Move cursor left

	// Cursor still on first picture and now picture frame has been selected

	bitMap->View()->MoveCursorL(type, EFalse);

	bitMap->View()->GetCursorPos(thisPos);

	selectionIsPictureFrame

	= bitMap->View()->IsPictureFrameSelected(dummyRect, dummyPos);

	test(thisPos.iPos == 2 && type == TCursorPosition::EFLeft);

	test(selectionIsPictureFrame == 1);

	// Move cursor left

	// Cursor on second picture and picture frame not selected

	bitMap->View()->MoveCursorL(type, EFalse);

	bitMap->View()->GetCursorPos(thisPos);

	selectionIsPictureFrame

	= bitMap->View()->IsPictureFrameSelected(dummyRect, dummyPos);

	test(thisPos.iPos == 2 && type == TCursorPosition::EFLeft);

	test(selectionIsPictureFrame == 0);

	// Move cursor left

	// Cusror still on second picture and picture frame has been selected

	bitMap->View()->MoveCursorL(type, EFalse);

	bitMap->View()->GetCursorPos(thisPos);

	selectionIsPictureFrame

	= bitMap->View()->IsPictureFrameSelected(dummyRect, dummyPos);

	test(thisPos.iPos == 1 && type == TCursorPosition::EFLeft);

	test(selectionIsPictureFrame == 1);

	// Move cursor left

	// Cursor moved to second letter "A"

	bitMap->View()->MoveCursorL(type, EFalse);

	bitMap->View()->GetCursorPos(thisPos);

	selectionIsPictureFrame

	= bitMap->View()->IsPictureFrameSelected(dummyRect, dummyPos);

	test(thisPos.iPos == 1 && type == TCursorPosition::EFLeft);

	test(selectionIsPictureFrame == 0);

	//Move cursor left

	bitMap->View()->MoveCursorL(type, EFalse);

	bitMap->View()->GetCursorPos(thisPos);

	selectionIsPictureFrame

	= bitMap->View()->IsPictureFrameSelected(dummyRect, dummyPos);

	test(thisPos.iPos == 0 && type == TCursorPosition::EFLeft);

	test(selectionIsPictureFrame == 0);

	CleanupStack::Pop(pic);

	CleanupStack::PopAndDestroy(1);

	}

/**

Test for defect INC020746: Visual cursor position update incorrect at end of

document

*/

void INC020746_L(TDes& aText, CTextView* aView)

	{

	aText.Zero();

	aText.Append('A');

	aText.Append(0x5D0);	// Aleph

	SetViewRect1(aView);

	aView->DisableFlickerFreeRedraw();

	aView->HandleGlobalChangeL();

	TTmDocPosSpec pos(2, TTmDocPosSpec::ELeading);

	aView->SetDocPosL(pos);

	TTmDocPos posOut;

	aView->GetCursorPos(posOut);

	test(posOut.iPos == 2);

	test(posOut.iLeadingEdge);

	pos.iType = TTmDocPosSpec::ETrailing;

	aView->SetDocPosL(pos);

	aView->GetCursorPos(posOut);

	test(posOut.iPos == 2);

	test(!posOut.iLeadingEdge);

	}

/**

@SYMTestCaseID SYSLIB-FORM-UT-1653

@SYMTestCaseDesc Test to make sure an ordinary hyphen is returned when a potential hyphen is inserted.

@SYMTestPriority Critical.

@SYMTestActions Insets a potential hyphen into some text and then check the output once it has passed

				 	through MTmCustom::Map.

@SYMTestExpectedResults The test must not fail.

@SYMDEF INC080603: Soft Hyphen is not replaced by Ordinary Hyphen in Tagma

*/

// Test code had to be changed because of a problem in BullseyeCoverage, which does not like

// dealing with certain hexadecimal character combinations in string literals.

void INC080603L(TDes& aText, CTestGraphicsDevice* aDevice,CTextLayout* aLayout, CTextView* aView)

	{

	_LIT(KInputText,  "ABCDEFABCDEF");

	const TUint16 Hyphen = 0x00ad;

	aDevice->LineArray().ResetLineArray();

	aDevice->LineArray().Enable();

	aText.Zero();

	aText = KInputText;

	aText.Insert(6, (TPtrC(&Hyphen,1)));