// 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 <e32keys.h>

#include <s32strm.h>

#include <gdi.h>

#include <txtfrmat.h>

#include <fbs.h>

#include <bitstd.h>

#include <bitdev.h>

#include <w32std.h>

#include <frmtlay.h>

#include <coemain.h>

#include <coeaui.h>

#include <coecntrl.h>

#include <coefepff.h>

#include <fepbase.h>

#include <fepitfr.h>

#include <bautils.h>

#include <techview/eikon.hrh>

#include <techview/eikdialg.h>

#include <techview/eikchkbx.h>

#include <techview/eikbutb.h>

#include <techview/eikchlst.h>

#include "tfep3.hrh"

#include "TFEP3.H"

#define DEBUGGING_MESSAGES

#if defined(DEBUGGING_MESSAGES)

#include <e32svr.h>

#endif

// constants

enum TPanic

	{

	EPanicBackupAlreadyExists=1,

	EPanicNotExpectedToBeSimulatingKeyEvent1,

	EPanicNotExpectedToBeSimulatingKeyEvent2,

	EPanicBadIndex,

	EPanicBadAttributeUid1,

	EPanicBadAttributeUid2,

	EPanicBadAttributeUid3,

	EPanicBadAttributeUid4,

	EPanicBadInputMethod1,

	EPanicBadInputMethod2,

	EPanicBadInputMethod3,

	EPanicBadInputMethod4,

	EPanicBadInputMethod5,

	EPanicBadTextLength1,

	EPanicBadTextLength2,

	EPanicBadKeyCode1,

	EPanicBadKeyCode2,

	EPanicBadKeyCode3,

	EPanicBadKeyCode4,

	EPanicBadCharacterInBuffer,

	EPanicInconsistentState,

	EPanicArithmeticConfusion,

	EPanicBadLengthOfTextBeforeSelection,

	EPanicSelectionExtendsPastEndOfDocument,

	EPanicBadLengthOfTextAfterSelection,

	EPanicBadLengthOfSelection,

	EPanicBadHeight,

	EPanicIsAlreadyActive,

	EPanicNoFepAwareTextEditorAlthoughCurrentlyInlineEditing,

	EPanicBadKeyResponse,

	EPanicUnexpectedButtonId,

	EPanicBadCheckBoxState,

	EPanicBadNumberOfAttributes

	};

LOCAL_D const TUint Alpha[10][4] = {{0,0,0,0},{0,0,0,0},{65,66,67,0},{68,69,70,0},{71,72,73,0},{74,75,76,0},{77,78,79,0},{80,81,82,83},{84,85,86,0},{87,88,89,90}} ;

_LIT(KLitTFEP3, "TFEP3");

#if defined(_UNICODE)

const TUint KEllipsisCharacter=0x2026;

_LIT(KLitCompositionFontTypefaceName, "publicDomainUnicode");

#else

const TUint KEllipsisCharacter=0x85;

_LIT(KLitCompositionFontTypefaceName, "courier");

#endif

_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(KLitInputMethodColonSpace, "Input method: ");

_LIT(KLitPlain, "plain");

_LIT(KLitHexadecimalCharacterCode, "hexadecimal character-code");

_LIT(KLitNumberKeyPad, "number keypad");

_LIT(KLitInlineEditingColonSpace, "Inline editing: ");

_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(KLitTFEP3, aPanic);

	}

GLDEF_C TInt E32Dll(

					)

	{

	return KErrNone;

	}

// TTstTextBackup

#pragma warning(disable: 4355) // "'this' : used in base member initializer list"

TTstTextBackup::TTstTextBackup(TDes& aText)

	:iCleanupItem(Cleanup, this),

	 iOriginal(aText),

	 iBackup(NULL)

	{

	}

#pragma warning(default: 4355)

void TTstTextBackup::PushOntoCleanupStackL()

	{

	__ASSERT_DEBUG(iBackup==NULL, Panic(EPanicBackupAlreadyExists));

	iBackup=iOriginal.AllocL();

	CleanupStack::PushL(iCleanupItem);

	}

void TTstTextBackup::PopOffCleanupStack()

	{

	delete iBackup;

	CleanupStack::Pop();

	}

void TTstTextBackup::Cleanup(TAny* aTextBackup)

	{

	TTstTextBackup* const textBackup=STATIC_CAST(TTstTextBackup*, aTextBackup);

	textBackup->iOriginal=*textBackup->iBackup;

	delete textBackup->iBackup;

	}

// CTstInsertionPoint

CTstInsertionPoint* CTstInsertionPoint::NewL(RWindowBase& aWindow, CCoeEnv& aConeEnvironment)

	{

	CTstInsertionPoint* const insertionPoint=new(ELeave) CTstInsertionPoint(aConeEnvironment.WsSession());

	CleanupStack::PushL(insertionPoint);

	insertionPoint->ConstructL(aWindow, aConeEnvironment.ScreenDevice()->DisplayMode());

	CleanupStack::Pop(); // insertionPoint

	return insertionPoint;

	}

CTstInsertionPoint::~CTstInsertionPoint()

	{

	iSprite.Close();

	delete iSpriteMember.iBitmap; // must be deleted after iSprite is closed as iSprite has a reference to it

	// iSpriteMember.iMaskBitmap is not deleted as it is the same as iSpriteMember.iBitmap

	}

void CTstInsertionPoint::SetPosition(const TPoint& aPosition)

	{

	iPosition=aPosition;

	if (iFlags&EFlagOn)

		{

		iSprite.SetPosition(iPosition);

		}

	}

void CTstInsertionPoint::SetOn(TBool aOn)

	{

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

		{

		DoSetOn(aOn);

		}

	}

CTstInsertionPoint::CTstInsertionPoint(RWsSession& aWindowServerSession)

	:iSprite(aWindowServerSession),

	 iPosition(0, 0),

	 iFlags(0)

	{

	iSpriteMember.iBitmap=NULL;

	iSpriteMember.iMaskBitmap=NULL;

	}

void CTstInsertionPoint::ConstructL(RWindowBase& aWindow, TDisplayMode aDisplayMode)

	{

	iSpriteMember.iBitmap=CreateBitmapL(aDisplayMode);

	iSpriteMember.iMaskBitmap=iSpriteMember.iBitmap;

	iSpriteMember.iInvertMask=ETrue;

	iSpriteMember.iDrawMode=CGraphicsContext::EDrawModePEN;

	iSpriteMember.iOffset.iX=-(CTstInsertionPoint::EWidth/2);

	iSpriteMember.iOffset.iY=0;

	iSpriteMember.iInterval=0;

	User::LeaveIfError(iSprite.Construct(aWindow, iPosition, 0));

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

	DoSetOn(EFalse);

	User::LeaveIfError(iSprite.Activate());

	}

CFbsBitmap* CTstInsertionPoint::CreateBitmapL(TDisplayMode aDisplayMode)

	{

	CFbsBitmap* const bitmap=new(ELeave) CFbsBitmap;

	CleanupStack::PushL(bitmap);

	User::LeaveIfError(bitmap->Create(TSize(CTstInsertionPoint::EWidth, CTstInsertionPoint::EHeight), aDisplayMode));

	CFbsBitmapDevice* const bitmapDevice=CFbsBitmapDevice::NewL(bitmap);

	CleanupStack::PushL(bitmapDevice);

	CFbsBitGc* const graphicsContext=CFbsBitGc::NewL();

	CleanupStack::PushL(graphicsContext);

	graphicsContext->Activate(bitmapDevice);

	graphicsContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

	graphicsContext->SetBrushColor(KRgbWhite);

	graphicsContext->SetPenStyle(CGraphicsContext::ESolidPen);

	graphicsContext->SetPenColor(KRgbBlack);

	graphicsContext->Clear();

	const TPoint bottomLeft(0, CTstInsertionPoint::EHeight-1);

	const TPoint bottomRight(CTstInsertionPoint::EWidth-1, CTstInsertionPoint::EHeight-1);

	const TPoint top(CTstInsertionPoint::EWidth/2, 0);

	graphicsContext->DrawLine(bottomLeft, bottomRight);

	graphicsContext->DrawLine(bottomRight, top);

	graphicsContext->DrawLine(top, bottomLeft);

	CleanupStack::PopAndDestroy(2); // graphicsContext and bitmapDevice

	CleanupStack::Pop(); // bitmap

	return bitmap;

	}

void CTstInsertionPoint::DoSetOn(TBool aOn)

	{

	iSprite.SetPosition(aOn? iPosition: TPoint(-(EWidth*4), -(EHeight*4)));

	if (aOn)

		{

		iFlags|=EFlagOn;

		}

	else

		{

		iFlags&=~EFlagOn;

		}

	}

// 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()

	{

	if (iFlags&EFlagInsideInlineEditingTransaction)

		{

		CancelInlineEdit(*iInputCapabilities.FepAwareTextEditor());

		}

	iCoeEnv->ReleaseScreenFont(iCompositionFont);

	iCoeEnv->ReleaseScreenFont(iStatusFont);

	STATIC_CAST(CCoeAppUi*, iCoeEnv->AppUi())->RemoveFromStack(this);

	delete iInsertionPoint;

	delete iMoveCursorTimer;

	}

void CTstControl::CancelTransaction()

	{

	__ASSERT_DEBUG(!iFep.IsSimulatingKeyEvent() || ((~iFlags&EFlagInsideInlineEditingTransaction) && (iBuffer.Length()==0)), Panic(EPanicNotExpectedToBeSimulatingKeyEvent1));

	TBool needToDraw=EFalse;

	if (iFlags&EFlagInsideInlineEditingTransaction)

		{

		CancelInlineEdit(*iInputCapabilities.FepAwareTextEditor());

		needToDraw=ETrue;

		}

	if (iBuffer.Length()>0)

		{

		ResetBuffer();

		needToDraw=ETrue;

		}

	if (needToDraw)

		{

		DrawNow();

		}

	}

void CTstControl::IsOnHasChangedState()

	{

	ChangeSetupAndResetBufferAndDrawNow(NULL);

	}

void CTstControl::OfferPointerEventL(CCoeFep::TEventResponse& aEventResponse, const TPointerEvent& aPointerEvent, const CCoeControl* aWindowOwningControl)

	{

	// this function must correctly set aEventResponse *before* calling anything that can leave

	if (aWindowOwningControl==this)

		{

		aEventResponse=CCoeFep::EEventWasConsumed;

		HandlePointerEventL(aPointerEvent);

		}

	else

		{

		aEventResponse=CCoeFep::EEventWasNotConsumed;

		}

	}

TInt CTstControl::NumberOfAttributes()

	{

	// InlineEditingEnabled & InputMethod...change this if want to add any more attributes...

	return 2;

	}

TUid CTstControl::AttributeAtIndex(TInt aIndex)

	{

	switch (aIndex)

		{

	case 0:

		return TUid::Uid(ETstInlineEditingEnabledUid);

	case 1:

		return TUid::Uid(ETstInputMethodUid);

#if defined(_DEBUG)

	default:

		Panic(EPanicBadIndex);

		break;

#endif

		}

	return KNullUid;

	}

void CTstControl::WriteAttributeDataToStreamL(TUid aAttributeUid, RWriteStream& aStream) const

	{

	switch (aAttributeUid.iUid)

		{

	case ETstInlineEditingEnabledUid:

		aStream.WriteUint8L((iFlags&EFlagInlineEditingEnabled)!=0);

		break;

	case ETstInputMethodUid:

		aStream.WriteUint8L(iInputMethod);

		break;

#if defined(_DEBUG)

	default:

		Panic(EPanicBadAttributeUid1);

		break;

#endif

		}

	}

void CTstControl::ReadAttributeDataFromStreamL(TUid aAttributeUid, RReadStream& aStream)

	{

	switch (aAttributeUid.iUid)

		{

	case ETstInlineEditingEnabledUid:

		ChangeSetupAndResetBufferAndDrawNow(SetFlagInlineEditingEnabled, aStream.ReadUint8L());

		break;

	case ETstInputMethodUid:

		{

		TInt inputMethod=aStream.ReadUint8L();

		if ((inputMethod!=EInputMethodPlain) && (inputMethod!=EInputMethodHexadecimalCharacterCode) && (inputMethod!=EInputMethodNumberKeyPad))

			{

			User::Leave(KErrCorrupt);

			}

		ChangeSetupAndResetBufferAndDrawNow(SetInputMethod, inputMethod);

		}

		break;

#if defined(_DEBUG)

	default:

		Panic(EPanicBadAttributeUid2);

		break;

#endif

		}

	}

void CTstControl::WriteAttributeDataToStreamL(TUid aAttributeUid, RWriteStream& aStream, TBool aInlineEditingEnabled, TInt aInputMethod)

	{

	switch (aAttributeUid.iUid)

		{

	case ETstInlineEditingEnabledUid:

		aStream.WriteUint8L(aInlineEditingEnabled!=EFalse);

		break;

	case ETstInputMethodUid:

		aStream.WriteUint8L(aInputMethod);

		break;

#if defined(_DEBUG)

	default:

		Panic(EPanicBadAttributeUid3);

		break;

#endif

		}

	}

void CTstControl::ReadAttributeDataFromStreamL(TUid aAttributeUid, RReadStream& aStream, TBool& aInlineEditingEnabled, TInt& aInputMethod)

	{

	switch (aAttributeUid.iUid)

		{

	case ETstInlineEditingEnabledUid:

		aInlineEditingEnabled=aStream.ReadUint8L();

		break;

	case ETstInputMethodUid:

		aInputMethod=aStream.ReadUint8L();

		break;

#if defined(_DEBUG)

	default:

		Panic(EPanicBadAttributeUid4);

		break;

#endif

		}

	}

void CTstControl::HandleGainingForeground()

	{

	DrawableWindow()->MoveToGroup(iCoeEnv->WsSession().GetFocusWindowGroup()); // ignore the error returned

	ChangeSetupAndResetBufferAndDrawNow(SetForeground, ETrue);

	}

void CTstControl::HandleLosingForeground()

	{

	ChangeSetupAndResetBufferAndDrawNow(SetForeground, EFalse);

	}

void CTstControl::HandleChangeInFocus()

	{

	ChangeSetupAndResetBufferAndDrawNow(SetInputCapabilities, NULL);

	}

void CTstControl::HandleDestructionOfFocusedItem()

	{

	if (!IsBeingDestroyed())

		{

		const TCoeInputCapabilities inputCapabilities(STATIC_CAST(const CCoeAppUi*, iCoeEnv->AppUi())->InputCapabilities());

		if (inputCapabilities.FepAwareTextEditor()==NULL)

			{

			iFlags&=~EFlagInsideInlineEditingTransaction; // turn this off now so that ChangeSetupAndResetBufferAndDrawNow does not try to call CancelInlineEdit on an object that has probably been destroyed by now

			}

		ChangeSetupAndResetBufferAndDrawNow(SetInputCapabilities, REINTERPRET_CAST(TInt, &inputCapabilities));

		}

	}

CTstControl::CTstControl(CTstFep& aFep)

	:iFep(aFep),

	 iInputMethod(EInputMethodPlain),

	 iFlags(0),

	 iBuffer(KNullDesC),

	 iSelectedCompositionText(0, 0),

	 iInputCapabilities(TCoeInputCapabilities::ENone),

	 iCompositionFont(NULL),

	 iStatusFont(NULL),

	 iInsertionPoint(NULL),

	 iPositionOnWindowBeingDragged(0, 0),

	 iCountKeyPressed(0),

	 iLastKeyPressed(0)

	{

	}

void CTstControl::ConstructL()

	{

	iMoveCursorTimer = CTstControl::CMoveCursorTimer::NewL(*this);

	CreateWindowL();

	EnableDragEvents();

	ClaimPointerGrab();

	SetNonFocusing();

	RDrawableWindow& window=*DrawableWindow();

	window.SetOrdinalPosition(0, ECoeWinPriorityFep);

	window.SetShadowHeight(3);

	TFontSpec compositionFontSpec(KLitCompositionFontTypefaceName, 200);

	compositionFontSpec.iTypeface.SetIsProportional(EFalse);

	iCompositionFont=iCoeEnv->CreateScreenFontL(compositionFontSpec);

	iStatusFont=iCoeEnv->CreateScreenFontL(TFontSpec(KLitStatusFontTypefaceName, 120));

	iInsertionPoint=CTstInsertionPoint::NewL(window, *iCoeEnv);

	SetPositionOfInsertionPointInBuffer(0);

	const TInt statusFontHeightInPixels=iStatusFont->HeightInPixels();

	const TSize size(320, 1+EGapAboveCompositionLine+iCompositionFont->HeightInPixels()+EGapBelowCompositionLine+EGapAboveTopStatusLine+(3*(statusFontHeightInPixels+EGapBetweenEachStatusLine))+statusFontHeightInPixels+EGapBelowBottomStatusLine+1);

	const TSize screenSize=iCoeEnv->ScreenDevice()->SizeInPixels();

	SetExtent(TPoint(screenSize.iWidth-(size.iWidth+10), screenSize.iHeight-(size.iHeight+10)), size);

	STATIC_CAST(CCoeAppUi*, iCoeEnv->AppUi())->AddToStackL(this, ECoeStackPriorityFep, ECoeStackFlagRefusesFocus|ECoeStackFlagSharable);

	ChangeSetupAndResetBufferAndDrawNow(SetForeground, iCoeEnv->RootWin().Identifier()==iCoeEnv->WsSession().GetFocusWindowGroup());

	ChangeSetupAndResetBufferAndDrawNow(SetFocus, EFalse);

	ChangeSetupAndResetBufferAndDrawNow(SetFlagInlineEditingEnabled, ETrue);

	ChangeSetupAndResetBufferAndDrawNow(SetInputMethod, EInputMethodPlain);

	ChangeSetupAndResetBufferAndDrawNow(SetInputCapabilities, NULL);

	}

void CTstControl::SetForeground(CTstControl& aControl, TBool& aChangeWasMade, TInt aParameter)

	{

	SetFlag(aControl, aChangeWasMade, aParameter, EFlagForeground);

	}

void CTstControl::SetFocus(CTstControl& aControl, TBool& aChangeWasMade, TInt aParameter)

	{

	aChangeWasMade=EFalse;

	if (!aParameter!=!aControl.IsFocused()) // fold non-zero values on both sides before comparing for inequality

		{

		CCoeAppUi& appUi=*STATIC_CAST(CCoeAppUi*, aControl.iCoeEnv->AppUi());

		appUi.UpdateStackedControlFlags(&aControl, (aParameter? 0: ECoeStackFlagRefusesFocus), ECoeStackFlagRefusesFocus);

		appUi.HandleStackChanged();