/*

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

* Functions added to Word for test purposes now that Word is no longer a standard EPOC application.

*

*/

#include <e32std.h>

#include <techview/eikcfdlg.h>

#include <techview/eikon.rsg>

#include "WPAPPUI.H"

#include "WPTEXTED.H"

#include "WPTEST.H"

#include "WPTESTPICTURE.H"

struct TKeyAction

	{

	TInt Compare(TInt aKeyCode,TInt aState) const;

	TInt iKeyCode;			// key pressed by user

	TInt iState;			// state in which this action fires

	TInt iCharToInsert;		// character to insert; if 0xFFFF, none

	TInt iNewState;			// new state

	};

TInt TKeyAction::Compare(TInt aKeyCode,TInt aState) const

	{

	if (iKeyCode - aKeyCode)

		return iKeyCode - aKeyCode;

	return iState - aState;

	}

struct TKeyboardMap

	{

	const TKeyAction* Find(TInt aKeyCode,TInt aState) const;

	const TKeyAction* iKeyAction;	// action table

	TInt iKeyActions;				// number of entries in table

	};

const TKeyAction* TKeyboardMap::Find(TInt aKeyCode,TInt aState) const

	{

	const TKeyAction* base = iKeyAction;

	const TKeyAction* end = iKeyAction + iKeyActions;

	while (base < end)

		{

		int n = end - base;

		const TKeyAction* a = &base[n / 2];

		int diff = a->Compare(aKeyCode,aState);

		if (diff > 0)

			end = a;

		else if (diff < 0)

			base = a + 1;

		else

			return a;

		}

	return NULL;

	}

static const TKeyAction TheArabicKeyAction[] =

	{

	{ 'A', 0, 0x0649, 0 },

	{ 'B', 0, 0xFFFF, 0 },

	{ 'C', 0, 0xFFFF, 0 },

	{ 'D', 0, 0x0636, 0 },

	{ 'E', 0, 0xFFFF, 0 },

	{ 'F', 0, 0xFFFF, 0 },

	{ 'G', 0, 0x063A, 0 },

	{ 'H', 0, 0x062D, 0 },

	{ 'I', 0, 0xFFFF, 0 },

	{ 'J', 0, 0xFFFF, 0 },

	{ 'K', 0, 0xFFFF, 0 },

	{ 'L', 0, 0xFFFF, 0 },

	{ 'M', 0, 0xFFFF, 0 },

	{ 'N', 0, 0xFFFF, 0 },

	{ 'O', 0, 0xFFFF, 0 },

	{ 'P', 0, 0xFFFF, 0 },

	{ 'Q', 0, 0xFFFF, 0 },

	{ 'R', 0, 0xFFFF, 0 },

	{ 'S', 0, 0x0635, 0 },

	{ 'T', 0, 0x0637, 0 },

	{ 'U', 0, 0xFFFF, 0 },

	{ 'V', 0, 0xFFFF, 0 },

	{ 'W', 0, 0xFFFF, 0 },

	{ 'X', 0, 0xFFFF, 0 },

	{ 'Y', 0, 0xFFFF, 0 },

	{ 'Z', 0, 0x0638, 0 },

	{ 'a', 0, 0x0627, 0 },

	{ 'b', 0, 0x0628, 0 },

	{ 'c', 0, 0xFFFF, 0 },

	{ 'd', 0, 0x062F, 0 },

	{ 'e', 0, 0xFFFF, 0 },

	{ 'f', 0, 0x0641, 0 },

	{ 'g', 0, 0x0639, 0 },

	{ 'h', 0, 0x0647, 0 },

	{ 'i', 0, 0xFFFF, 0 },

	{ 'j', 0, 0x062C, 0 },

	{ 'k', 0, 0x0643, 0 },

	{ 'l', 0, 0x0644, 0 },

	{ 'm', 0, 0x0645, 0 },

	{ 'n', 0, 0x0646, 0 },

	{ 'o', 0, 0xFFFF, 0 },

	{ 'p', 0, 0x067E, 0 },

	{ 'q', 0, 0x0642, 0 },

	{ 'r', 0, 0x0631, 0 },

	{ 's', 0, 0x0633, 0 },

	{ 't', 0, 0x062A, 0 },

	{ 'u', 0, 0xFFFF, 0 },

	{ 'v', 0, 0xFFFF, 0 },

	{ 'w', 0, 0x0648, 0 },

	{ 'x', 0, 0x062E, 0 },

	{ 'y', 0, 0x064A, 0 },

	{ 'z', 0, 0x0632, 0 },

	};

static const TKeyboardMap TheArabicKeyboardMap =

	{

	TheArabicKeyAction,

	sizeof(TheArabicKeyAction) / sizeof(TKeyAction)

	};

static const TKeyAction TheGreekKeyAction[] =

	{

	{ 'A', 0, 0x0391, 0 },

	{ 'B', 0, 0x0392, 0 },

	{ 'C', 0, 0xFFFF, 0 },

	{ 'D', 0, 0x0394, 0 },

	{ 'E', 0, 0x0395, 0 },

	{ 'F', 0, 0x03A6, 0 },

	{ 'G', 0, 0x0393, 0 },

	{ 'H', 0, 0x03A7, 0 },

	{ 'I', 0, 0x0399, 0 },

	{ 'J', 0, 0x0397, 0 },

	{ 'K', 0, 0x039A, 0 },

	{ 'L', 0, 0x039B, 0 },

	{ 'M', 0, 0x039C, 0 },

	{ 'N', 0, 0x039D, 0 },

	{ 'O', 0, 0x039F, 0 },

	{ 'P', 0, 0x03A0, 0 },

	{ 'Q', 0, 0x0398, 0 },

	{ 'R', 0, 0x03A1, 0 },

	{ 'S', 0, 0x03A3, 0 },

	{ 'T', 0, 0x03A4, 0 },

	{ 'U', 0, 0x03A5, 0 },

	{ 'V', 0, 0x03A8, 0 },

	{ 'W', 0, 0x03A9, 0 },

	{ 'X', 0, 0x039E, 0 },

	{ 'Y', 0, 0xFFFF, 0 },

	{ 'Z', 0, 0x0396, 0 },

	{ 'a', 0, 0x03B1, 0 },

	{ 'b', 0, 0x03B2, 0 },

	{ 'c', 0, 0x03C2, 0 },

	{ 'd', 0, 0x03B4, 0 },

	{ 'e', 0, 0x03B5, 0 },

	{ 'f', 0, 0x03C6, 0 },

	{ 'g', 0, 0x03B3, 0 },

	{ 'h', 0, 0x03C7, 0 },

	{ 'i', 0, 0x03B9, 0 },

	{ 'j', 0, 0x03B7, 0 },

	{ 'k', 0, 0x03BA, 0 },

	{ 'l', 0, 0x03BB, 0 },

	{ 'm', 0, 0x03BC, 0 },

	{ 'n', 0, 0x03BD, 0 },

	{ 'o', 0, 0x03BF, 0 },

	{ 'p', 0, 0x03C0, 0 },

	{ 'q', 0, 0x03B8, 0 },

	{ 'r', 0, 0x03C1, 0 },

	{ 's', 0, 0x03C3, 0 },

	{ 't', 0, 0x03C4, 0 },

	{ 'u', 0, 0x03C5, 0 },

	{ 'v', 0, 0x03C8, 0 },

	{ 'w', 0, 0x03C9, 0 },

	{ 'x', 0, 0x03BE, 0 },

	{ 'y', 0, 0xFFFF, 0 },

	{ 'z', 0, 0x03B6, 0 },

	};

static const TKeyboardMap TheGreekKeyboardMap =

	{

	TheGreekKeyAction,

	sizeof(TheGreekKeyAction) / sizeof(TKeyAction)

	};

static const TKeyAction TheRussianKeyAction[] =

	{

	{ 'A', 0, 0x0410, 0 },

	{ 'B', 0, 0x0411, 0 },

	{ 'C', 0, 0x0426, 0 },

	{ 'D', 0, 0x0414, 0 },

	{ 'E', 0, 0x0415, 0 },

	{ 'F', 0, 0x0424, 0 },

	{ 'G', 0, 0x0413, 0 },

	{ 'H', 0, 0x0425, 0 },

	{ 'I', 0, 0x0418, 0 },

	{ 'J', 0, 0xFFFF, 0 },

	{ 'K', 0, 0x041A, 0 },

	{ 'L', 0, 0x041B, 0 },

	{ 'M', 0, 0x041C, 0 },

	{ 'N', 0, 0x041D, 0 },

	{ 'O', 0, 0x041E, 0 },

	{ 'P', 0, 0x041F, 0 },

	{ 'Q', 0, 0xFFFF, 0 },

	{ 'R', 0, 0x0420, 0 },

	{ 'S', 0, 0x0421, 0 },

	{ 'T', 0, 0x0422, 0 },

	{ 'U', 0, 0x0423, 0 },

	{ 'V', 0, 0x0412, 0 },

	{ 'W', 0, 0xFFFF, 0 },

	{ 'X', 0, 0xFFFF, 0 },

	{ 'Y', 0, 0x0419, 0 },

	{ 'Z', 0, 0x0417, 0 },

	{ 'a', 0, 0x0430, 0 },

	{ 'b', 0, 0x0431, 0 },

	{ 'c', 0, 0x0446, 0 },

	{ 'd', 0, 0x0434, 0 },

	{ 'e', 0, 0x0435, 0 },

	{ 'f', 0, 0x0444, 0 },

	{ 'g', 0, 0x0433, 0 },

	{ 'h', 0, 0x0445, 0 },

	{ 'i', 0, 0x0438, 0 },

	{ 'j', 0, 0xFFFF, 0 },

	{ 'k', 0, 0x043A, 0 },

	{ 'l', 0, 0x043B, 0 },

	{ 'm', 0, 0x043C, 0 },

	{ 'n', 0, 0x043D, 0 },

	{ 'o', 0, 0x043E, 0 },

	{ 'p', 0, 0x043F, 0 },

	{ 'q', 0, 0xFFFF, 0 },

	{ 'r', 0, 0x0440, 0 },

	{ 's', 0, 0x0441, 0 },

	{ 't', 0, 0x0442, 0 },

	{ 'u', 0, 0x0443, 0 },

	{ 'v', 0, 0x0432, 0 },

	{ 'w', 0, 0xFFFF, 0 },

	{ 'x', 0, 0xFFFF, 0 },

	{ 'y', 0, 0x0439, 0 },

	{ 'z', 0, 0x0437, 0 },

	};

static const TKeyboardMap TheRussianKeyboardMap =

	{

	TheRussianKeyAction,

	sizeof(TheRussianKeyAction) / sizeof(TKeyAction)

	};

CWordTest* CWordTest::NewL(CTextView* aTextView)

	{

	return new(ELeave) CWordTest(aTextView);

	}

CWordTest::CWordTest(CTextView* aTextView):

	iTextView(aTextView),

	iKeyboard(EStandardKeyboard),

	iKeyboardState(0),

	iRuledPaper(FALSE),

	iBackgroundBitmap(NULL),

	iTruncateWithEllipsis(FALSE),

	iCursorFlashing(TRUE),

	iCursorPlacement(ECursorVertical),

	iCursorWeight(3),

	iCursorXorColor(KRgbWhite),

	iStyleIndex(0),

	iPositioningHint(TCursorPosition::EPosHintUndefined)

	{

	}

CWordTest::~CWordTest()

	{

	delete iBackgroundBitmap;

	}

TKeyResponse CWordTest::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aEventCode,TChar& aCharToInsert)

	{

	if (iKeyboard == EStandardKeyboard)

		return EKeyWasNotConsumed;

	if (aEventCode != EEventKey)

		return EKeyWasNotConsumed;

	if (aKeyEvent.iCode >= ESpecialKeyBase && aKeyEvent.iCode < ESpecialKeyBase + ESpecialKeyCount)

		return EKeyWasNotConsumed;

	if (aKeyEvent.iCode >= ENonCharacterKeyBase && aKeyEvent.iCode < ENonCharacterKeyBase + ENonCharacterKeyCount)

		return EKeyWasNotConsumed;

	aCharToInsert = 0xFFFF;

	const TKeyboardMap* map = NULL;

	switch (iKeyboard)

		{

	case EArabicKeyboard:

		map = &TheArabicKeyboardMap;

		break;

	case EGreekKeyboard:

		map = &TheGreekKeyboardMap;

		break;

	case ERussianKeyboard:

		map = &TheRussianKeyboardMap;

		break;

	default:

		break;

		}

	if (map)

		{

		const TKeyAction* action = map->Find(aKeyEvent.iCode,iKeyboardState);

		if (action)

			{

			aCharToInsert = action->iCharToInsert;

			iKeyboardState = action->iNewState;

			return EKeyWasConsumed;

			}

		}

	return EKeyWasNotConsumed;

	}

void CWordTest::SetKeyboardL(TKeyboardCode aKeyboard)

	{

	switch (aKeyboard)

		{

	case EArabicKeyboard:

		SetCursorPositioningHintL(TCursorPosition::EInsertStrongR2L);

		break;

	default:

		SetCursorPositioningHintL(TCursorPosition::EInsertStrongL2R);

		break;

		}

	iKeyboard = aKeyboard;

	}

void CWordTest::SetPictureAlignmentL(CEikRichTextEditor* aEditor,TFontPresentation::TAlignment aAlignment)

	{

	TCharFormat format;

	format.iFontPresentation.iPictureAlignment = aAlignment;

	TCharFormatMask mask;

	mask.SetAttrib(EAttFontPictureAlignment);

	aEditor->ApplyCharFormatL(format,mask);

	}

void CWordTest::SetWrapL(CEikRichTextEditor* aEditor,TBool aWrap)

	{

	CParaFormat format;

	format.iWrap = aWrap;

	TParaFormatMask mask;

	mask.SetAttrib(EAttWrap);

	aEditor->ApplyParaFormatL(&format,mask);

	}

void CWordTest::InsertPictureL(CEikRichTextEditor* aEditor)

	{

	CWordTestPicture* pic=CWordTestPicture::NewLC();

	TPictureHeader header;

   	header.iPictureType = KUidWordTestPictureType;

   	header.iPicture=pic;

 	TInt pos = aEditor->CursorPos();

 	aEditor->RichText()->InsertL(pos, header); 

//CRichText::InsertL takes ownership of the picture via TPictureHeader 	

 	CleanupStack::Pop(pic); 

 	aEditor->HandleTextChangedL();

 	aEditor->SetCursorPosL(pos+1, EFalse);	

	}

void CWordTest::ToggleCaseL(CEikRichTextEditor* aEditor)

	{

	TCursorSelection sel = aEditor->Selection();

	int start = sel.LowerPos();

	int end = start;

	TBool to_upper = TRUE;

	while (end < sel.HigherPos())

		{

		TPtrC text;

		TCharFormat f;

		aEditor->RichText()->GetChars(text,f,start);

		int length = text.Length();

		if (start + length > sel.HigherPos())

			length = sel.HigherPos() - start;

		end = start + length;

		if (start == sel.LowerPos() && end > start)

			{

			if (TChar(text[0]).IsUpper())

				to_upper = FALSE;

			}

		TText* p = (TText*)text.Ptr();

		TText* q = p + length;

		while (p < q)

			{

			if (to_upper)

				*p = (TText)(TChar(*p).GetUpperCase());

			else

				*p = (TText)(TChar(*p).GetLowerCase());

			p++;

			}

		start = end;

		}

	aEditor->TextView()->HandleRangeFormatChangeL(sel);

	}

void CWordTest::BenchmarkL()

	{

	TTime start, end;

	start.HomeTime();

	const int n = 100;

	for (int i = 0; i < n; i++)

		iTextView->FormatTextL();

	end.HomeTime();

	int ms = (I64LOW(end.Int64()) - I64LOW(start.Int64())) / 1000;

	TBuf<128> message;

#ifdef _DEBUG

	_LIT(build,"debug");

#else

	_LIT(build,"release");

#endif

	message.Format(_L("form%d %S: reformatting %d times took %d milliseconds"),

		iTextView->Layout()->MajorVersion(),&build,n,ms);

	User::InfoPrint(message);

	}

void CWordTest::SetTruncateWithEllipsisL(CEikRichTextEditor* aEditor,TBool aOn)

	{

	iTruncateWithEllipsis = aOn;

	aEditor->TextLayout()->SetTruncating(aOn);

	aEditor->NotifyNewFormatL();

	}

void CWordTest::ToggleCursorFlash()

	{

	iCursorFlashing = !iCursorFlashing;

	iTextView->SetCursorFlash(iCursorFlashing);

	}

void CWordTest::SetCursorPlacement(TTmCursorPlacement aPlacement)

	{

	iCursorPlacement = aPlacement;

	iTextView->SetCursorPlacement(aPlacement);

	}

void CWordTest::SetCursorWeight(TInt aWeight)

	{

	iCursorWeight = aWeight;

	iTextView->SetCursorWeight(aWeight);

	}

void CWordTest::SetCursorXorColor(TRgb aColor)

	{

	iCursorXorColor = aColor;

	iTextView->SetCursorXorColor(aColor);

	}

void CWordTest::TurnOnCustomDrawing(CTextLayout* aLayout)

	{

	if (aLayout->MajorVersion() == 2) // custom drawing is not supported in FORM1

		aLayout->SetCustomDraw(this);

	}

void CWordTest::SetSelectionHighlightStyle(TInt aStyleIndex)

	{

	iStyleIndex = aStyleIndex;

	}

TInt CWordTest::SelectionHighlightStyle() const

	{

	return iStyleIndex;

	}

void CWordTest::DrawLineGraphics(const TParam& aParam,const TLineInfo& aLineInfo) const

	{

	if (iRuledPaper)

		{

		aParam.iGc.SetPenColor(KRgbRed);

		TPoint p(aLineInfo.iOuterRect.iTl.iX,aLineInfo.iInnerRect.iBr.iY - 1);

		TPoint q(aLineInfo.iOuterRect.iBr.iX,aLineInfo.iInnerRect.iBr.iY - 1);

		aParam.iGc.DrawLine(p,q);

		}

	}

void CWordTest::DrawText(const TParam& aParam,const TLineInfo& aLineInfo,const TCharFormat& aFormat,const TDesC& aText,

						 const TPoint& aTextOrigin,TInt aExtraPixels) const

	{

	/*

	Draw outlined text by drawing the text nine times: eight times in the background colour, moving the origin

	one pixel up, down, right, and left to make a box, and once in the foreground colour, not offset.

	*/

	if (aFormat.iFontPresentation.iHighlightStyle == TFontPresentation::EFontHighlightFirstCustomStyle)

		{

		aParam.iGc.SetPenColor(aFormat.iFontPresentation.iTextColor);

		for (int x = -1; x <= 1; x++)

			for (int y = -1; y <= 1; y++)

				if (x || y)

					{

					if (aExtraPixels)

						aParam.iGc.SetCharJustification(aExtraPixels,aText.Length());

					TPoint p(aTextOrigin);

					p.iX += x;

					p.iY += y;

					aParam.iGc.DrawText(aText,p);

					}

		aParam.iGc.SetPenColor(aFormat.iFontPresentation.iHighlightColor);

		}

	MFormCustomDraw::DrawText(aParam,aLineInfo,aFormat,aText,aTextOrigin,aExtraPixels);

	}

void CWordTest::DrawBackground(const TParam& aParam,const TRgb& aBackground,TRect& aDrawn) const

	{

	if (iBackgroundBitmap)

		{

		aParam.iGc.SetClippingRect(aParam.iDrawRect);

		aDrawn.SetRect(aParam.iTextLayoutTopLeft,iBackgroundBitmap->SizeInPixels());

		aParam.iGc.DrawBitmap(aDrawn,iBackgroundBitmap);

		}

	else

		MFormCustomDraw::DrawBackground(aParam,aBackground,aDrawn);

	}

TRgb CWordTest::SystemColor(TUint aColorIndex, TRgb aDefaultColor) const

	{

	if (aColorIndex == TLogicalRgb::ESystemSelectionForegroundIndex)

		{

		switch (iStyleIndex)

			{

		case 1: