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

//

#include <e32std.h>

#include <e32base.h>

#include <centralrepository.h>

#include <w32std.h>

#include <coemain.h>

#include <coedef.h>

#include "CoeDataStorage.h"

#include <fepbase.h>

#include <fepitfr.h>

#include <fepbpanic.h>

#include "FEPBPRIV.H"

#include <graphics/cone/coedefkeys.h>

inline TBool IsSurrogate(TText a) { return 0xD800 == (a & 0xF800); }

inline TBool IsHighSurrogate(TText a) { return 0xD800 == (a & 0xFC00); }

inline TBool IsLowSurrogate(TText a) { return 0xDC00 == (a & 0xFC00); }

inline TChar JoinSurrogates(TText aHigh, TText aLow)

	{

	return ((aHigh - 0xd7f7) << 10) + aLow;

	}

LOCAL_C void Panic(TFepBasePanic aPanic)

	{

	User::Panic(KLitFepBasePanicText, aPanic);

	}

enum { EUndefinedEventResponse=100 };

enum TFlags

	{

	EFlagOnState			=0x00000001,

	EFlagIsHandlingKeyEvent	=0x00000002,

	EFlagNoDownUpFilter		=0x00000004

	};

// internal class definitions

struct CCoeFep::SKeyEvent

	{

	TEventCode iEventCode;

	TKeyEvent iKeyEvent;

	TKeyResponse iKeyResponse;

	};

class CCoeFep::CHighPriorityActive : public CActive

	{

public:

	static CHighPriorityActive* NewL(CCoeEnv& aConeEnvironment);

	virtual ~CHighPriorityActive();

	void MakeDeferredFunctionCall(MDeferredFunctionCall& aDeferredFunctionCall);

	void SimulateKeyEventL(const TKeyEvent& aKeyEvent);

	inline TBool IsSimulatingKeyEvent() const {return (iFlags&EFlagIsSimulatingKeyEvent);}

	void SendKeyEventToApplicationNowL(TEventCode aEventCode, const TKeyEvent& aKeyEvent);

	TBool MustBeAndNowWillBeDestroyedLater();

private:

	enum

		{

		EFlagIsSimulatingKeyEvent		=0x00000001,

		EFlagOwnsSelf					=0x00000002,

		EFlagRecursionLevelIncremented	=0x00000004

		};

	struct SStackedFlags

		{

		inline SStackedFlags(TUint& aFlags) :iFlags(aFlags), iOldFlags(aFlags) {}

		TUint& iFlags;

		const TUint iOldFlags;

		};

	class CFlagClearer : public CActive

		{

	public:

		static CFlagClearer* NewL();

		virtual ~CFlagClearer();

		void TurnOffFlagIsSimulatingKeyEventDeferred(SStackedFlags& aStackedFlags);

	private:

		CFlagClearer();

		// from CActive

		virtual void DoCancel();

		virtual void RunL();

	private:

		SStackedFlags* iStackedFlags;

		};

private:

	CHighPriorityActive(CCoeEnv& aConeEnvironment);

	void ConstructL();

	void MakeReadyToRun();

	void DoSendKeyEventToApplicationNowL(TEventCode aEventCode, const TKeyEvent& aKeyEvent);

	static void DecrementRecursionLevelAndDestroySelfIfZeroAndOwnsSelf(TAny* aThis);

	static void CancelFlagClearer(TAny* aFlagClearer);

	static void TurnOffFlagIsSimulatingKeyEvent(TAny* aStackedFlags);

	static void DoTurnOffFlagIsSimulatingKeyEvent(SStackedFlags& aStackedFlags);

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

	virtual TInt RunError(TInt aError);

private:

	CCoeEnv& iConeEnvironment;

	TUint iFlags;

	MDeferredFunctionCall* iDeferredFunctionCall;

	RArray<TKeyEvent> iArrayOfKeyEvents;

	CFlagClearer* iFlagClearer;

	TInt iRecursionLevel;

private:

	friend class CFlagClearer;

	};

class CCoeFep::CLowPriorityActive : public CActive

	{

public:

	static CLowPriorityActive* NewL(CHighPriorityActive& aHighPriorityActive);

	virtual ~CLowPriorityActive();

	void SendKeyEventToApplicationDeferred(TEventCode aEventCode, const TKeyEvent& aKeyEvent);

private:

	CLowPriorityActive(CHighPriorityActive& aHighPriorityActive);

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

private:

	CHighPriorityActive& iHighPriorityActive;

	TEventCode iEventCode;

	TKeyEvent iKeyEvent;

	};

NONSHARABLE_CLASS(COnStateTracker) : public CActive

	{

public:

	static COnStateTracker* NewL(CCoeFep& aFep);

	virtual ~COnStateTracker();

private:

	COnStateTracker(CCoeFep& aFep);

	void ConstructL();

	void Queue();

	void SetOnState();

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

private:

	CCoeFep& iFep;

	CRepository* iRepository;

	};

// non-class-member functions

EXPORT_C void FepObserverHandleStartOfTransactionL(MCoeFepObserver& aFepObserver)

	{

	aFepObserver.HandleStartOfTransactionL();

	}

LOCAL_C void FepObserverHandleCompletionOfTransactionL(MCoeFepObserver& aFepObserver)

	{

	aFepObserver.HandleCompletionOfTransactionL();

	}

// CCoeFep::CLowPriorityActive

CCoeFep::CLowPriorityActive* CCoeFep::CLowPriorityActive::NewL(CHighPriorityActive& aHighPriorityActive)

	{

	return new(ELeave) CLowPriorityActive(aHighPriorityActive);

	}

CCoeFep::CLowPriorityActive::~CLowPriorityActive()

	{

	Cancel();

	}

void CCoeFep::CLowPriorityActive::SendKeyEventToApplicationDeferred(TEventCode aEventCode, const TKeyEvent& aKeyEvent)

	{

	Cancel();

	iEventCode=aEventCode;

	iKeyEvent=aKeyEvent;

	TRequestStatus* requestStatus=&iStatus;

	User::RequestComplete(requestStatus, KErrNone);

	SetActive();

	}

CCoeFep::CLowPriorityActive::CLowPriorityActive(CHighPriorityActive& aHighPriorityActive)

	:CActive(EActivePriorityWsEvents-1), // the priority of CLowPriorityActive objects just needs to be less than the priority with which key-events are handled

	 iHighPriorityActive(aHighPriorityActive)

	{

	CActiveScheduler::Add(this);

	}

void CCoeFep::CLowPriorityActive::DoCancel()

	{

	}

void CCoeFep::CLowPriorityActive::RunL()

	{

	iHighPriorityActive.SendKeyEventToApplicationNowL(iEventCode, iKeyEvent);

	}

// COnStateTracker

COnStateTracker* COnStateTracker::NewL(CCoeFep& aFep)

	{ // static

	COnStateTracker* const self=new(ELeave) COnStateTracker(aFep);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

COnStateTracker::~COnStateTracker()

	{

	Cancel();

	delete iRepository;

	}

COnStateTracker::COnStateTracker(CCoeFep& aFep)

	:CActive(EActivePriorityWsEvents+30),

	 iFep(aFep)

	{

	CActiveScheduler::Add(this);

	}

void COnStateTracker::ConstructL()

	{

	iRepository=CRepository::NewL(TUid::Uid(KUidFepFrameworkRepository));

	// We'd like to call "Queue" and "SetOnState" here, but we can't call SetOnState from here as it involves the CCoeFep-derived object's implementation of IsOnHasChangedState being called inside the CCoeFep::BaseConstructL, which probably happens at the start of its contruction routine, before it's ready for its implementation of IsOnHasChangedState to be called. So instead we just make ourselves ready to run so that our RunL gets called as soon as it can

	TRequestStatus* requestStatus=&iStatus;

	User::RequestComplete(requestStatus, KErrNone);

	SetActive();

	}

void COnStateTracker::Queue()

	{

#if defined(_DEBUG)

	const TInt error=

#endif

	iRepository->NotifyRequest(ERepositoryKeyMask_OnState, ERepositoryKeyMask_OnState, iStatus);

	__ASSERT_DEBUG(error==KErrNone, Panic(EPanicUnexpectedError2));

	SetActive();

	}

void COnStateTracker::SetOnState()

	{

	TBool onState=EFalse;

	CFepGenericGlobalSettings::ReadOnState(*iRepository, onState);

	iFep.SetOnState(onState);

	}

void COnStateTracker::DoCancel()

	{

	iRepository->NotifyCancel(ERepositoryKeyMask_OnState, ERepositoryKeyMask_OnState);

	}

void COnStateTracker::RunL()

	{

	const TInt error=iStatus.Int();

	Queue();

	User::LeaveIfError(error);

	SetOnState();

	}

// MCoeFepObserver

/** Handles the start of a FEP transaction. 

The implementation of this function might move focus to an existing edit window, 

or might launch a new dialog (if the dialog should appear as soon 

as the user starts composing their text in the FEP rather than when the text 

contained in the FEP is committed to it).

This function should be called by the FEP when it receives the first event 

which begins a FEP transaction. It should be called after using CoeFep::MakeDeferredFunctionCall() 

to handle the event.

The FEP calls this function indirectly by calling CCoeEnv::ForEachFepObserverCall() 

passing in FepObserverHandleStartOfTransactionL. Internally, this calls HandleStartOfTransactionL() 

for each MCoeFepObserver object that has been registered with the control 

environment by calling CCoeEnv::AddFepObserverL().

@see CCoeFep::MakeDeferredFunctionCall() */

EXPORT_C void MCoeFepObserver::HandleStartOfTransactionL()

	{

	}

/** If an application needs to get more information about a FEP transaction than 

is provided by the FEP framework, (for example, a Japanese FEP may want the 

pronunciation of the transaction's text as well as the text itself), then 

it should override this function to retrieve the information it wants from the 

FEP.

This assumes that the application knows which concrete FEP is above it so 

that it can call the specialised functions in that FEP. An application can 

safely do this by calling CCoeEnv::Fep() to get the address of the current 

FEP (this is NULL if there is no FEP above it) and downcasting this address 

to the specific derived class of the FEP it is expecting, on condition that 

the CCoeEnv::FepUid() function returns the UID of the FEP it is expecting.

This function is called by the FEP framework. If the FEP is doing inline editing, 

HandleCompletionOfTransactionL() is called inside MCoeFepAwareTextEditor's 

CommitFepInlineEditL(). If it isn't doing inline editing, HandleCompletionOfTransactionL() 

is called (inside an active object) after the key events generated by one 

or more calls to CCoeFep's SimulateKeyEventsL() have been sent to the application. */

EXPORT_C void MCoeFepObserver::HandleCompletionOfTransactionL()

	{

	}

EXPORT_C void MCoeFepObserver::MCoeFepObserver_Reserved_1()

	{

	}

EXPORT_C void MCoeFepObserver::MCoeFepObserver_Reserved_2()

	{

	}

// TArrayTransformer

class TArrayTransformer : private CCoeFep::MModifiedCharacter

	{

public:

	TArrayTransformer(const TArray<TUint>& aArrayOfCharacters);

	TArray<CCoeFep::MModifiedCharacter> ArrayOfModifiedCharacters(); // this function is deliberately non-const so that its client is not tempted to create an anonymous (temporary) TArrayTransformer object whose lifetime may turn out to be too short

private:

	static TInt NumberOfModifiedCharacters(const CBase* aThis); // aThis is really a TArrayTransformer

	static const TAny* ModifiedCharacter(const CBase* aThis, TInt aIndex); // aThis is really a TArrayTransformer

	// from CCoeFep::MModifiedCharacter

	virtual TUint CharacterCode() const;

	virtual TUint ModifierMask() const;

	virtual TUint ModifierValues() const;

private:

	const TArray<TUint>& iArrayOfCharacters;

	TInt iCurrentIndex;

	};

TArrayTransformer::TArrayTransformer(const TArray<TUint>& aArrayOfCharacters)

	:iArrayOfCharacters(aArrayOfCharacters),

	 iCurrentIndex(-1)

	{

	}

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

	{

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

	}

TInt TArrayTransformer::NumberOfModifiedCharacters(const CBase* aThis)

	{

	return REINTERPRET_CAST(TArrayTransformer*, CONST_CAST(CBase*, aThis))->iArrayOfCharacters.Count();

	}

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

	{

	TArrayTransformer& thisObject=*REINTERPRET_CAST(TArrayTransformer*, CONST_CAST(CBase*, aThis));

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

	__ASSERT_ALWAYS(aIndex<thisObject.iArrayOfCharacters.Count(), Panic(EPanicBadIndex2));

	thisObject.iCurrentIndex=aIndex;

	return aThis;

	}

TUint TArrayTransformer::CharacterCode() const

	{

	__ASSERT_ALWAYS(iCurrentIndex>=0, Panic(EPanicBadIndex3));

	__ASSERT_ALWAYS(iCurrentIndex<iArrayOfCharacters.Count(), Panic(EPanicBadIndex4));

	return iArrayOfCharacters[iCurrentIndex];

	}

/**

Returns a <code>TUint</code> which indicates which modifiers to

override, rather than using the current state of the keyboard's

modifiers.

@return   "TUint"

            The modifiers to override in the key combination.

*/

TUint TArrayTransformer::ModifierMask() const

	{

	return 0;

	}

/**

Returns a <code>TUint</code> which indicates which of the modifiers

specified in the mask (returned by <code>ModifierMask()</code>) must

be on and which must be off.

@return   "TUint"

            Indicates which of the modifiers specified in the mask

            (returned by <code>ModifierMask()</code>) must be on

            and which must be off.

*/            

TUint TArrayTransformer::ModifierValues() const

	{

	return 0;

	}

// CCoeFep::CCoeFepExtra

NONSHARABLE_CLASS(CCoeFep)::CCoeFepExtra : public CBase

	{

public:

	CCoeFepExtra();

	virtual ~CCoeFepExtra();

public:

	CCoeFep::CLowPriorityActive* iLowPriorityActive;

	CFepSettingsTracker* iSettingsTracker;

	COnStateTracker* iOnStateTracker;

	};

CCoeFep::CCoeFepExtra::CCoeFepExtra()

	{

	}

CCoeFep::CCoeFepExtra::~CCoeFepExtra()

	{

	delete iLowPriorityActive;

	delete iSettingsTracker;

	delete iOnStateTracker;

	}

// CCoeFep

/** Destructor.

Removes the FEP from the control environment's message observer list prior 

to its destruction. */

EXPORT_C CCoeFep::~CCoeFep()

	{

	iConeEnvironment.RemoveForegroundObserver(*this);

	iConeEnvironment.RemoveFocusObserver(*this);

	iConeEnvironment.RemoveMessageObserver(*this);

	if (iHighPriorityActive!=NULL)

		{

		if (!iHighPriorityActive->MustBeAndNowWillBeDestroyedLater()) // if this return "true", the iHighPriorityActive object now "owns itself", i.e. it will be destroyed just before the outermost CHighPriorityActive::SendKeyEventToApplicationNowL call on the call-stack returns

			{

			delete iHighPriorityActive;

			}

		}

	delete iExtra;

	delete iLastKeyEvent;

	}

/** Tests whether or not the FEP is simulating key events.

This function should be called early in the FEP's implementation of OfferKeyEventL(). 

If it returns ETrue, OfferKeyEventL() should immediately return EKeyWasNotConsumed 

so that the application gets the key event as intended. 

It is called by the FEP_START_KEY_EVENT_HANDLER_L and FEP_START_KEY_EVENT_HANDLER_NO_DOWN_UP_FILTER_L 

macros.

@return ETrue if the FEP is simulating key events, EFalse if not. */

EXPORT_C TBool CCoeFep::IsSimulatingKeyEvent() const

	{

	return iHighPriorityActive->IsSimulatingKeyEvent();

	}

/** Since the advent of Platform security in Symbian OS, the turning on/off of FEPs is handled

via a different means (which is secure). Hence this function now only ever returns EFalse. 

@deprecated

@param aKeyEvent No longer used.

@return Always returns EFalse.

*/

EXPORT_C TBool CCoeFep::IsTurnedOnByL(const TKeyEvent& /*aKeyEvent*/) const

	{

	return EFalse;

	}

/** Since the advent of Platform security in Symbian OS, the turning on/off of FEPs is handled

via a different means (which is secure). Hence this function now only ever returns EFalse. 

@deprecated

@param aKeyEvent No longer used.

@return Always returns EFalse.

*/

EXPORT_C TBool CCoeFep::IsTurnedOffByL(const TKeyEvent& /*aKeyEvent*/) const

	{

	return EFalse;

	}

/**

@internalComponent

Note that we should maintain BC for this function as it is used by 

the published-All macro FEP_START_KEY_EVENT_HANDLER_L

*/

EXPORT_C void CCoeFep::OnStartingHandlingKeyEvent_WithDownUpFilterLC()

	{

	DoOnStartingHandlingKeyEventLC(0);

	}

/**

@internalComponent

Note that we should maintain BC for this function as it is used by 

the published-All macro FEP_START_KEY_EVENT_HANDLER_NO_DOWN_UP_FILTER_L

*/

EXPORT_C void CCoeFep::OnStartingHandlingKeyEvent_NoDownUpFilterLC()

	{

	DoOnStartingHandlingKeyEventLC(EFlagNoDownUpFilter);

	}

/**

@internalComponent

Note that we should maintain BC for this function as it is used by 

the published-All macros FEP_START_KEY_EVENT_HANDLER_L and FEP_END_KEY_EVENT_HANDLER_L

*/

EXPORT_C TKeyResponse CCoeFep::OnFinishingHandlingKeyEvent_WithDownUpFilterL(TEventCode aEventCode, const TKeyEvent& aKeyEvent, TKeyResponse aKeyResponse)

	{

	__ASSERT_ALWAYS((iFlags&EFlagNoDownUpFilter)==0, Panic(EPanicNoDownUpFilter));

	return DoOnFinishingHandlingKeyEventL(aEventCode, aKeyEvent, aKeyResponse);

	}