// Copyright (c) 1997-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 <techview/eikon.hrh>

#include <techview/eikdialg.h>

#include <techview/eikchkbx.h>

#include <techview/eikbutb.h>

#include <techview/eikchlst.h>

#include <gulutil.h>	// for FontUtils, together with egul.lib

#include "tfep4.hrh"

#include "TFEP4.H"

#include "TFEP4COM.H"

// constants

enum TPanic

	{

	EPanicBackupAlreadyExists=1,

	EPanicBadIndex1,

	EPanicBadIndex2,

	EPanicNotExpectedToBeSimulatingKeyEvent1,

	EPanicNotExpectedToBeSimulatingKeyEvent2,

	EPanicBadAttributeUid1,

	EPanicBadAttributeUid2,

	EPanicBadAttributeUid3,

	EPanicBadAttributeUid4,

	EPanicBadInputMethod1,

	EPanicBadInputMethod2,

	EPanicBadInputMethod3,

	EPanicBadInputMethod4,

	EPanicBadInputMethod5,

	EPanicBadTextLength1,

	EPanicBadTextLength2,

	EPanicBadKeyCode1,

	EPanicBadKeyCode2,

	EPanicBadKeyCode3,

	EPanicBadKeyCode4,

	EPanicBadCharacterInBuffer,

	EPanicInconsistentState,

	EPanicNegativeIndex,

	EPanicArithmeticConfusion,

	EPanicBadLengthOfTextBeforeSelection,

	EPanicSelectionExtendsPastEndOfDocument,

	EPanicBadLengthOfTextAfterSelection,

	EPanicBadLengthOfSelection,

	EPanicBadHeight,

	EPanicIsAlreadyActive,

	EPanicNoFepAwareTextEditorAlthoughCurrentlyInlineEditing,

	EPanicBadKeyResponse,

	EPanicUnexpectedButtonId,

	EPanicBadCheckBoxState,

	EPanicBadNumberOfAttributes

	};

_LIT(KLitTFEP4, "TFEP4");

#if defined(_UNICODE)

const TUint KEllipsisCharacter=0x2026;

_LIT(KLitCompositionFontTypefaceName, "publicDomainUnicode");

//_LIT(KLitCompositionFontTypefaceName, "SimHei");

//_LIT(KLitCompositionFontTypefaceName, "STFangSong");

#else

const TUint KEllipsisCharacter=0x85;

_LIT(KLitCompositionFontTypefaceName, "courier");

#endif

_LIT(KLitStatusFontTypefaceName, "SwissA");		// original "arial"

_LIT(KLitNoFocusedFepAwareTextEditor, "No focused FEP-aware text-editor");

_LIT(KLitNoFocusedFepAwareTextEditorSupportingState, "No focused FEP-aware text-editor supporting state");

_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(KLitPinYin, "pin yin");

_LIT(KLitInlineEditingColonSpace, "Inline editing: ");

_LIT(KLitEnabled, "enabled");

_LIT(KLitDisabled, "disabled");

_LIT(KLitOpeningSquareBracket, "[");

_LIT(KLitCaptionColonSpace, "Caption: ");

_LIT(KLitStateColonSpace, "State: ");

_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(KLitExtensionsColonSpace, "extensions: ");

_LIT(KLitPhoneticAlphabet, "phonetic alphabet");

_LIT(KLitCommaSpace, ", ");

_LIT(KLitClosingSquareBracket, "]");

LOCAL_D const TText* const KPhoneticAlphabet[]=

	{

	_S("Alpha"),

	_S("Bravo"),

	_S("Charlie"),

	_S("Delta"),

	_S("Echo"),

	_S("Foxtrot"),

	_S("Golf"),

	_S("Hotel"),

	_S("India"),

	_S("Juliette"),

	_S("Kilo"),

	_S("Lima"),

	_S("Mike"),

	_S("November"),

	_S("Oscar"),

	_S("Papa"),

	_S("Quebec"),

	_S("Romeo"),

	_S("Sierra"),

	_S("Tango"),

	_S("Uniform"),

	_S("Victor"),

	_S("Whiskey"),

	_S("X-Ray"),

	_S("Yankee"),

	_S("Zulu")

	};

// local and global functions

LOCAL_C inline TBool IsLowSurrogate(TText16 aInt16)

/**

@return True, if aText16 is low surrogate; false, otherwise.

*/

    {

    return (aInt16 & 0xFC00) == 0xDC00;

    }

LOCAL_C void Panic(TPanic aPanic)

	{

	User::Panic(KLitTFEP4, 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;

		}

	}

// TTstArrayOfOneCtrlCharacter

TTstArrayOfOneCtrlCharacter::TTstArrayOfOneCtrlCharacter(TUint aCharacter)

	:iCharacter(aCharacter)

	{

	}

TArray<CCoeFep::MModifiedCharacter> TTstArrayOfOneCtrlCharacter::ArrayOfModifiedCharacters()

	{

	return TArray<CCoeFep::MModifiedCharacter>(NumberOfModifiedCharacters, ModifiedCharacter, (const CBase*)this);

	}

TInt TTstArrayOfOneCtrlCharacter::NumberOfModifiedCharacters(const CBase*)

	{

	return 1;

	}

const TAny* TTstArrayOfOneCtrlCharacter::ModifiedCharacter(const CBase* aThis, TInt aIndex)

	{

	__ASSERT_ALWAYS(aIndex==0, Panic(EPanicBadIndex1));

	return aThis;

	}

TUint TTstArrayOfOneCtrlCharacter::CharacterCode() const

	{

	return iCharacter;

	}

TUint TTstArrayOfOneCtrlCharacter::ModifierMask() const

	{

	return EModifierCtrl|EModifierShift|EModifierLeftShift|EModifierRightShift;

	}

TUint TTstArrayOfOneCtrlCharacter::ModifierValues() const

	{

	return EModifierCtrl;

	}

// 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;

	}

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

	{

	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(EPanicBadIndex2);

		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 != EInputMethodPinYin))

			{

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