// Copyright (c) 2005-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 <e32std.h>

#include <e32base.h>

#include <e32math.h>

#include <e32keys.h>

#include <s32strm.h>

#include <gdi.h>

#include <fbs.h>

#include <w32std.h>

#include <coemain.h>

#include <coeaui.h>

#include <coecntrl.h>

#include <coefepff.h>

#include <fepbase.h>

#include <bautils.h>

#include <techview/eikon.hrh>

#include <techview/eikdialg.h>

#include <techview/eikchkbx.h>

#include <techview/eikbutb.h>

#include "tfep2.hrh"

#include "TFEP2.H"

#include "tfep2com.h"

#define DEBUGGING_MESSAGES

#if defined(DEBUGGING_MESSAGES)

#include <e32svr.h>

#endif

// constants

enum TPanic

	{

	EPanicTimerActive1=1,

	EPanicTimerActive2,

	EPanicUnexpectedError1,

	EPanicUnexpectedError2,

	EPanicUnexpectedError3,

	EPanicUnexpectedError4,

	EPanicUnexpectedError5,

	EPanicUnexpectedError6,

	EPanicBadIndex1,

	EPanicBadIndex2,

	EPanicBadAttributeUid1,

	EPanicBadAttributeUid2,

	EPanicBadAttributeUid3,

	EPanicBadAttributeUid4,

	EPanicLowLevelFlagsDoNotReflectStateOfRemoteObjects,

	EPanicArithmeticConfusion,

	EPanicBadLengthOfTextBeforeSelection,

	EPanicSelectionExtendsPastEndOfDocument,

	EPanicBadLengthOfTextAfterSelection,

	EPanicBadLengthOfSelection,

	EPanicBadKeyCode1,

	EPanicBadKeyCode2,

	EPanicBadHeight,

	EPanicIsAlreadyActive,

	EPanicInconsistentUpperCaseSetting,

	EPanicBadFlagAffectingWhetherActive,

	EPanicBadKeyResponse,

	EPanicBadCheckBoxState,

	EPanicUnexpectedButtonId,

	EPanicBadNumberOfAttributes

	};

#if defined(_UNICODE)

const TUint KEllipsisCharacter=0x2026;

#else

const TUint KEllipsisCharacter=0x85;

#endif

_LIT(KLitTFEP2, "TFEP2");

_LIT(KLitBitmapHandleSynchronizationMutexName, "0x10003eaa-Mutex"); // using the same UID here as in the MMP file

_LIT(KLitDllNameOfWindowServerPlugIn, "\\system\\fep\\TFEP2BE.ANI");

_LIT(KLitStatusFontTypefaceName, "arial");

_LIT(KLitNotAvailable, "[not available]");

//_LIT(KLitTooLong, "[too long]");

_LIT(KLitQuotationMark, "\"");

_LIT(KLitTextBeforeSelectionColonSpace, "Text before selection: ");

_LIT(KLitTextAfterSelectionColonSpace, "Text after selection: ");

_LIT(KLitSelectionColonSpace, "Selection: ");

_LIT(KLitUpperCaseColonSpace, "Upper case: ");

_LIT(KLitOn, "on");

_LIT(KLitOff, "off");

_LIT(KLitScribbleAreaColonSpace, "Scribble area: ");

_LIT(KLitWholeScreen, "whole screen");

_LIT(KLitWindow, "window");

_LIT(KLitPointerBufferColonSpace, "Pointer buffer: ");

_LIT(KLitEnabled, "enabled");

_LIT(KLitDisabled, "disabled");

_LIT(KLitOpeningSquareBracket, "[");

_LIT(KLitCaptionColonSpace, "Caption: ");

_LIT(KLitInputCapabilitiesColonSpace, "Input-capabilities: ");

_LIT(KLitNone, "none");

_LIT(KLitWesternNumericIntegerPositive, "Western numeric integer positive");

_LIT(KLitWesternNumericIntegerNegative, "Western numeric integer negative");

_LIT(KLitWesternNumericReal, "Western numeric real");

_LIT(KLitWesternAlphabetic, "Western alphabetic");

_LIT(KLitJapaneseHiragana, "Japanese hiragana");

_LIT(KLitJapaneseKatakanaHalfWidth, "Japanese katakana half-width");

_LIT(KLitJapaneseKatakanaFullWidth, "Japanese katakana full-width");

_LIT(KLitDialableCharacters, "dialable characters");

_LIT(KLitSecretText, "secret text");

_LIT(KLitAllText, "all text");

_LIT(KLitNavigation, "navigation");

_LIT(KLitCommaSpace, ", ");

_LIT(KLitClosingSquareBracket, "]");

// local and global functions

LOCAL_C void Panic(TPanic aPanic)

	{

	User::Panic(KLitTFEP2, aPanic);

	}

GLDEF_C TInt E32Dll(

					)

	{

	return KErrNone;

	}

// CTstScribbleWindow

CTstScribbleWindow* CTstScribbleWindow::NewL(CTstFep& aFep, RWindowTreeNode& aParent)

	{

	CTstScribbleWindow* const scribbleWindow=new(ELeave) CTstScribbleWindow(aFep);

	CleanupStack::PushL(scribbleWindow);

	scribbleWindow->ConstructL(aParent);

	CleanupStack::Pop(); // scribbleWindow

	return scribbleWindow;

	}

CTstScribbleWindow::~CTstScribbleWindow()

	{

	// there is no need here to call FreePointerMoveBuffer on the window, as the buffer gets freed when the window gets destroyed

	iArrayOfPolyLines.ResetAndDestroy();

	iArrayOfPolyLines.Close();

	delete iTimeOutTimer;

	}

void CTstScribbleWindow::SetPointerBufferEnabled(TBool aPointerBufferEnabled)

	{

	RDrawableWindow& window=*DrawableWindow();

	if (!aPointerBufferEnabled!=!(iFlags&EFlagPointerBufferActuallyEnabled)) // fold non-zero values on both sides before comparing for inequality

		{

		if (aPointerBufferEnabled)

			{

			window.EnablePointerMoveBuffer();

			iFlags|=EFlagPointerBufferActuallyEnabled;

			}

		else

			{

			window.DisablePointerMoveBuffer();

			iFlags&=~EFlagPointerBufferActuallyEnabled;

			}

		}

	}

void CTstScribbleWindow::HandleTimeOutL()

	{

	TInt i;

	TInt minimumX=KMaxTInt;

	TInt maximumX=KMinTInt;

	for (i=iArrayOfPolyLines.Count()-1; i>=0; --i)

		{

		const CArrayFix<TPoint>& polyLine=*iArrayOfPolyLines[i];

		for (TInt j=polyLine.Count()-1; j>=0; --j)

			{

			const TInt x=polyLine[j].iX;

			if (minimumX>x)

				{

				minimumX=x;

				}

			if (maximumX<x)

				{

				maximumX=x;

				}

			}

		}

	const TInt numberOfCharacters=((maximumX-minimumX)/80)+1;

	CArrayFix<TUint>* arrayOfCharacters=new(ELeave) CArrayFixFlat<TUint>(numberOfCharacters); // a RArray would be better than a CArrayFix, but unfortunately RArray doesn't (yet) have a TArray interface

	CleanupStack::PushL(arrayOfCharacters);

	const TUint baseCharacter=iFep.UpperCase()? 'A': 'a';

	TTime homeTime;

	homeTime.HomeTime();

	TInt64 seedForRandomNumber=homeTime.Int64();

	for (i=0; i<numberOfCharacters; ++i)

		{

		arrayOfCharacters->AppendL(baseCharacter+(Math::Rand(seedForRandomNumber)%26));

		}

	iFep.SimulateKeyEventsL(arrayOfCharacters->Array());

	CancelTransactionAndDrawNow();

	CleanupStack::PopAndDestroy(); // arrayOfCharacters

	}

void CTstScribbleWindow::CancelTransactionAndDrawNow()

	{

	TBool changeWasMade;

	CancelTransaction(changeWasMade);

	if (changeWasMade)

		{

		DrawNow();

		}

	}

void CTstScribbleWindow::CancelTransaction(TBool& aChangeWasMade)

	{

	aChangeWasMade=EFalse;

	iTimeOutTimer->Cancel();

	if (iArrayOfPolyLines.Count()>0)

		{

		iArrayOfPolyLines.ResetAndDestroy();

		aChangeWasMade=ETrue;

		}

	}

void CTstScribbleWindow::HandlePointerEventL(const TPointerEvent& aPointerEvent)

	{

	switch (aPointerEvent.iType)

		{

	case TPointerEvent::EDrag:

		{

		if (iFlags&EFlagPointerIsDown) // this test is needed in the case where there was a "leave" when handling the TRawEvent::EButton1Down event

			{

			__ASSERT_DEBUG(!iTimeOutTimer->IsActive(), Panic(EPanicTimerActive1));

			CArrayFix<TPoint>& polyLine=*iArrayOfPolyLines[iArrayOfPolyLines.Count()-1];

			polyLine.AppendL(aPointerEvent.iPosition);

			ActivateGc();

			CWindowGc& graphicsContext=SystemGc();

			graphicsContext.SetPenStyle(CGraphicsContext::ESolidPen);

			graphicsContext.SetPenColor(KRgbBlack);

			graphicsContext.DrawLine(polyLine[polyLine.Count()-2], aPointerEvent.iPosition);

			graphicsContext.Plot(aPointerEvent.iPosition);

			DeactivateGc();

			}

		}

		break;

	case TPointerEvent::EButton1Down:

		{

		iTimeOutTimer->Cancel();

		CArrayFix<TPoint>* const polyLine=new(ELeave) CArrayFixSeg<TPoint>(50);

		CleanupStack::PushL(polyLine);

		polyLine->AppendL(aPointerEvent.iPosition);

		User::LeaveIfError(iArrayOfPolyLines.Append(polyLine));

		CleanupStack::Pop(); // polyLine

		ActivateGc();

		CWindowGc& graphicsContext=SystemGc();

		graphicsContext.SetPenStyle(CGraphicsContext::ESolidPen);

		graphicsContext.SetPenColor(KRgbBlack);

		graphicsContext.Plot(aPointerEvent.iPosition);

		DeactivateGc();

		iFlags|=EFlagPointerIsDown;

		if (iArrayOfPolyLines.Count()==1)

			{

			iCoeEnv->ForEachFepObserverCall(FepObserverHandleStartOfTransactionL); // called at the end of handling this event as it may launch a waiting dialog

			}

		}

		break;

	case TPointerEvent::EButton1Up:

		if (iFlags&EFlagPointerIsDown) // this test is needed in the cases where (i) there was a "leave" when handling the TRawEvent::EButton1Down event, and (ii) the window server sends a TPointerEvent::EButton1Up event if ClaimPointerGrab is called when the pointer is not down (this behaviour is the window-server's spec, it is not a bug)

			{

			__ASSERT_DEBUG(!iTimeOutTimer->IsActive(), Panic(EPanicTimerActive2));

			iTimeOutTimer->After(ETimeOutInMicroSeconds);

			iFlags&=~EFlagPointerIsDown;

			}

		break;

#if defined(__GCC32__)

	default:

		break;

#endif

		}

	}

void CTstScribbleWindow::HandlePointerBufferReadyL()

	{

	TPoint arrayOfPoints[ENumberOfPointsInBuffer];

	TPtr8 bufferOfPoints(REINTERPRET_CAST(TUint8*, arrayOfPoints), 0, ENumberOfPointsInBuffer*sizeof(TPoint));

	User::LeaveIfError(DrawableWindow()->RetrievePointerMoveBuffer(bufferOfPoints));

	if (iFlags&EFlagPointerIsDown) // this test is needed in the case where there was a "leave" when handling the TRawEvent::EButton1Down event

		{

		const TInt numberOfPointsInBuffer=bufferOfPoints.Length()/sizeof(TPoint);

		if (numberOfPointsInBuffer>0)

			{

			CArrayFix<TPoint>& polyLine=*iArrayOfPolyLines[iArrayOfPolyLines.Count()-1];

			for (TInt i=0; i<numberOfPointsInBuffer; ++i)

				{

				polyLine.AppendL(arrayOfPoints[i]);

				}

			ActivateGc();

			CWindowGc& graphicsContext=SystemGc();

			graphicsContext.SetPenStyle(CGraphicsContext::ESolidPen);

			graphicsContext.SetPenColor(KRgbBlack);

			graphicsContext.DrawLine(polyLine[polyLine.Count()-(numberOfPointsInBuffer+1)], arrayOfPoints[0]);

			graphicsContext.DrawPolyLine(arrayOfPoints, numberOfPointsInBuffer); // draws the end-point of the last line segment of the poly-line

			DeactivateGc();

			}

		}

	}

CTstScribbleWindow::CTstScribbleWindow(CTstFep& aFep)

	:iFep(aFep),

	 iFlags(0),

	 iArrayOfPolyLines(12),

	 iTimeOutTimer(NULL)

	{

	}

void CTstScribbleWindow::ConstructL(RWindowTreeNode& aParent)

	{

	CreateWindowL(aParent);

	EnableDragEvents();

	ClaimPointerGrab();

	SetNonFocusing();

	RDrawableWindow& window=*DrawableWindow();

	User::LeaveIfError(window.AllocPointerMoveBuffer(ENumberOfPointsInBuffer, 0));

	iFlags|=EFlagPointerBufferActuallyEnabled;

	iTimeOutTimer=CTimeOutTimer::NewL(*this);

	}

void CTstScribbleWindow::Draw(const TRect&) const

	{

	CWindowGc& graphicsContext=SystemGc();

	graphicsContext.SetBrushStyle(CGraphicsContext::ESolidBrush);

	graphicsContext.SetBrushColor(KRgbWhite);

	graphicsContext.SetPenStyle(CGraphicsContext::ESolidPen);

	graphicsContext.SetPenColor(KRgbWhite);

	graphicsContext.DrawRect(Rect());

	graphicsContext.SetPenColor(KRgbBlack);

	for (TInt i=iArrayOfPolyLines.Count()-1; i>=0; --i)

		{

		graphicsContext.DrawPolyLine(iArrayOfPolyLines[i]); // draws the end-point of the last line segment of the poly-line

		}

	}

// CTstScribbleWindow::CTimeOutTimer

CTstScribbleWindow::CTimeOutTimer* CTstScribbleWindow::CTimeOutTimer::NewL(CTstScribbleWindow& aScribbleWindow)

	{

	CTimeOutTimer* const timeOutTimer=new(ELeave) CTimeOutTimer(aScribbleWindow);

	CleanupStack::PushL(timeOutTimer);

	CActiveScheduler::Add(timeOutTimer);

	timeOutTimer->ConstructL();

	CleanupStack::Pop(); // timeOutTimer

	return timeOutTimer;

	}

CTstScribbleWindow::CTimeOutTimer::~CTimeOutTimer()

	{

	Cancel();

	}

CTstScribbleWindow::CTimeOutTimer::CTimeOutTimer(CTstScribbleWindow& aScribbleWindow)

	:CTimer(EPriorityLow),

	 iScribbleWindow(aScribbleWindow)

	{

	}

void CTstScribbleWindow::CTimeOutTimer::RunL()

	{

	iScribbleWindow.HandleTimeOutL();

	}

// CTstWholeScreenScribbleArea

CTstWholeScreenScribbleArea* CTstWholeScreenScribbleArea::NewL(RWsSession& aWindowServerSession, RWindowGroup& aWindowGroup, const TSize& aScreenSize, TDisplayMode aDisplayMode, const TDesC& aDllName)

	{

	CTstWholeScreenScribbleArea* const wholeScreenScribbleArea=new(ELeave) CTstWholeScreenScribbleArea(aWindowServerSession);

	CleanupStack::PushL(wholeScreenScribbleArea);

	wholeScreenScribbleArea->ConstructL(aWindowGroup, aScreenSize, aDisplayMode, aDllName);

	CleanupStack::Pop(); // wholeScreenScribbleArea

	return wholeScreenScribbleArea;

	}

CTstWholeScreenScribbleArea::~CTstWholeScreenScribbleArea()

	{

	if (iFlags&EFlagMutexIsConstructed)

		{

		iMutex.Wait();

		iHandWritingRecognizer.Close();

		iSprite.Close();

		iDll.Close();

		delete iSpriteMember.iBitmap;

		delete iSpriteMember.iMaskBitmap;

		iMutex.Signal();

		}

	}

CTstWholeScreenScribbleArea::CTstWholeScreenScribbleArea(RWsSession& aWindowServerSession)

	:iFlags(0),

	 iDll(aWindowServerSession),

	 iSprite(aWindowServerSession)

	{

	iSpriteMember.iBitmap=NULL;

	iSpriteMember.iMaskBitmap=NULL;

	}

void CTstWholeScreenScribbleArea::ConstructL(RWindowGroup& aWindowGroup, const TSize& aScreenSize, TDisplayMode aDisplayMode, const TDesC& aDllName)

	{

	// the mutex *must* be created first as it is used in the construction and destruction routines of this class

	TInt error=iMutex.CreateGlobal(KLitBitmapHandleSynchronizationMutexName);

	if (error==KErrAlreadyExists)

		{

		error=iMutex.OpenGlobal(KLitBitmapHandleSynchronizationMutexName);

		}

	User::LeaveIfError(error);

	iFlags|=EFlagMutexIsConstructed;

	iMutex.Wait();

	CleanupStack::PushL(TCleanupItem(SignalMutex, &iMutex));

	User::LeaveIfError(iDll.Load(aDllName));

	User::LeaveIfError(iSprite.Construct(aWindowGroup, TPoint(0, 0), ESpriteNoChildClip|ESpriteNoShadows));

	STstBitmapHandles bitmapHandles;

	iHandWritingRecognizer=RHandWritingRecognizer(iDll);

	iHandWritingRecognizer.ConstructL(iSprite, bitmapHandles);

	iSpriteMember.iBitmap=CreateBitmapL(bitmapHandles.iMain, aScreenSize, aDisplayMode);

	iSpriteMember.iMaskBitmap=CreateBitmapL(bitmapHandles.iMask, aScreenSize, aDisplayMode);

	iSpriteMember.iInvertMask=ETrue;

	iSpriteMember.iDrawMode=CGraphicsContext::EDrawModePEN;

	iSpriteMember.iOffset.iX=0;

	iSpriteMember.iOffset.iY=0;

	iSpriteMember.iInterval=0;

	User::LeaveIfError(iSprite.AppendMember(iSpriteMember));

	iHandWritingRecognizer.FinishConstructionL();

	CleanupStack::PopAndDestroy(); // TCleanupItem(SignalMutex, &iMutex)

	}

CFbsBitmap* CTstWholeScreenScribbleArea::CreateBitmapL(TInt aHandleOfBitmapToUse, const TSize& aScreenSize, TDisplayMode aDisplayMode)

	{

	CFbsBitmap* const bitmap=new(ELeave) CFbsBitmap;

	CleanupStack::PushL(bitmap);

	if (aHandleOfBitmapToUse!=0)

		{

		User::LeaveIfError(bitmap->Duplicate(aHandleOfBitmapToUse));

		}

	else

		{

		User::LeaveIfError(bitmap->Create(aScreenSize, aDisplayMode)); // bitmaps are automatically cleared to white when first created

		}

	CleanupStack::Pop(); // bitmap

	return bitmap;

	}

void CTstWholeScreenScribbleArea::SignalMutex(TAny* aMutex)

	{

	STATIC_CAST(RMutex*, aMutex)->Signal();

	}

// CTstWholeScreenScribbleArea::RHandWritingRecognizer

void CTstWholeScreenScribbleArea::RHandWritingRecognizer::ConstructL(const RWsSprite& aSprite, STstBitmapHandles& aBitmapHandles)

	{

	TPckg<STstBitmapHandles> bitmapHandles(aBitmapHandles);

	TIpcArgs ipcArgs;

	ipcArgs.Set(EIpcSlot, &bitmapHandles);

	User::LeaveIfError(RAnim::Construct(aSprite, EAnimTypeHandWritingRecognizer, KNullDesC8, ipcArgs));

	}

void CTstWholeScreenScribbleArea::RHandWritingRecognizer::FinishConstructionL()

	{

	const TInt error=CommandReply(EHandWritingRecognizerCommandFinishConstructionL, KNullDesC8());

	__ASSERT_ALWAYS(error==KErrNone, Panic(EPanicUnexpectedError1));

	}

void CTstWholeScreenScribbleArea::RHandWritingRecognizer::RequestNotificationOfStartOfTransaction(TRequestStatus& aRequestStatus)

	{

	AsyncCommandReply(aRequestStatus, EHandWritingRecognizerCommandRequestNotificationOfStartOfTransaction, TIpcArgs());

	}

void CTstWholeScreenScribbleArea::RHandWritingRecognizer::CancelRequestForNotificationOfStartOfTransaction()

	{

	const TInt error=CommandReply(EHandWritingRecognizerCommandCancelRequestForNotificationOfStartOfTransaction);

	__ASSERT_ALWAYS(error==KErrNone, Panic(EPanicUnexpectedError3));

	}

void CTstWholeScreenScribbleArea::RHandWritingRecognizer::RequestCharacters(TRequestStatus& aRequestStatus, TDes8& aCharacterBuffer, TBool /*aUpperCase*/)

	{

	TIpcArgs ipcArgs;

	ipcArgs.Set(EAsyncIpcSlot, &aCharacterBuffer);

	AsyncCommandReply(aRequestStatus, EHandWritingRecognizerCommandRequestCharacters, ipcArgs);

	}

void CTstWholeScreenScribbleArea::RHandWritingRecognizer::CancelRequestForCharacters()

	{

	const TInt error=CommandReply(EHandWritingRecognizerCommandCancelRequestForCharacters);

	__ASSERT_ALWAYS(error==KErrNone, Panic(EPanicUnexpectedError5));

	}

void CTstWholeScreenScribbleArea::RHandWritingRecognizer::SetUpperCase(TBool aUpperCase)

	{

	TPckgBuf<STstParametersForHandWritingRecognizerCommandSetUpperCase> parameters;

	parameters().iUpperCase=aUpperCase;

	const TInt error=CommandReply(EHandWritingRecognizerCommandSetUpperCase, parameters);

	__ASSERT_ALWAYS(error==KErrNone, Panic(EPanicUnexpectedError6));

	}

// CTstControl

CTstControl* CTstControl::NewL(CTstFep& aFep)

	{

	CTstControl* const control=new(ELeave) CTstControl(aFep);

	CleanupStack::PushL(control);

	control->ConstructL();

	CleanupStack::Pop(); // control

	return control;

	}

CTstControl::~CTstControl()

	{

	delete iScribbleWindow;

	delete iHandlerForStartOfTransaction;

	delete iHandlerForCharacters;