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

//

#if !defined(__TFEP2_H__)

#define __TFEP2_H__

#if !defined(__E32STD_H__)

#include <e32std.h>

#endif

#if !defined(__E32BASE_H__)

#include <e32base.h>

#endif

#if !defined(__GDI_H__)

#include <gdi.h>

#endif

#if !defined(__W32STD_H__)

#include <w32std.h>

#endif

#if !defined(__COEMAIN_H__)

#include <coemain.h>

#endif

#if !defined(__COECNTRL_H__)

#include <coecntrl.h>

#endif

#if !defined(__FEPBASE_H__)

#include <fepbase.h>

#endif

#if !defined(__EIKDIALG_H__)

#include <techview/eikdialg.h>

#endif

class CTstFep;

class CTstScribbleWindow : public CCoeControl // this needs to be a separate control as it needs to be a window with "pointer-buffers" enabled

	{

public:

	static CTstScribbleWindow* NewL(CTstFep& aFep, RWindowTreeNode& aParent);

	virtual ~CTstScribbleWindow();

	void SetPointerBufferEnabled(TBool aPointerBufferEnabled);

	void HandleTimeOutL();

	void CancelTransactionAndDrawNow();

	void CancelTransaction(TBool& aChangeWasMade);

	// from CCoeControl

	virtual void HandlePointerEventL(const TPointerEvent& aPointerEvent);

	virtual void HandlePointerBufferReadyL();

private:

	typedef CArrayFix<TPoint> CPolyLine;

	enum {ENumberOfPointsInBuffer=32};

	enum

		{

		EFlagPointerIsDown					=0x00000001,

		EFlagPointerBufferActuallyEnabled	=0x00000002

		};

	class CTimeOutTimer : public CTimer

		{

	public:

		static CTimeOutTimer* NewL(CTstScribbleWindow& aScribbleWindow);

		virtual ~CTimeOutTimer();

	private:

		CTimeOutTimer(CTstScribbleWindow& aScribbleWindow);

		virtual void RunL();

	private:

		CTstScribbleWindow& iScribbleWindow;

		};

private:

	CTstScribbleWindow(CTstFep& aFep);

	void ConstructL(RWindowTreeNode& aParent);

	// from CCoeControl

	virtual void Draw(const TRect& aRect) const;

private:

	CTstFep& iFep;

	TUint iFlags;

	RPointerArray<CPolyLine> iArrayOfPolyLines;

	CTimeOutTimer* iTimeOutTimer;

	};

struct STstBitmapHandles;

class CFbsBitmap;

class CTstWholeScreenScribbleArea : public CBase

	{

public:

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

	~CTstWholeScreenScribbleArea();

	inline void RequestNotificationOfStartOfTransaction(TRequestStatus& aRequestStatus) {iHandWritingRecognizer.RequestNotificationOfStartOfTransaction(aRequestStatus);}

	inline void CancelRequestForNotificationOfStartOfTransaction() {iHandWritingRecognizer.CancelRequestForNotificationOfStartOfTransaction();}

	inline void RequestCharacters(TRequestStatus& aRequestStatus, TDes8& aCharacterBuffer, TBool aUpperCase) {iHandWritingRecognizer.RequestCharacters(aRequestStatus, aCharacterBuffer, aUpperCase);}

	inline void CancelRequestForCharacters() {iHandWritingRecognizer.CancelRequestForCharacters();}

	inline void SetUpperCase(TBool aUpperCase) {iHandWritingRecognizer.SetUpperCase(aUpperCase);}

private:

	enum

		{

		EFlagMutexIsConstructed=0x00000001

		};

	class RHandWritingRecognizer : public RAnim

		{

	public:

		inline RHandWritingRecognizer() {}

		inline RHandWritingRecognizer(RAnimDll& aAnimDll) :RAnim(aAnimDll) {}

		void ConstructL(const RWsSprite& aSprite, STstBitmapHandles& aBitmapHandles);

		void FinishConstructionL();

		void RequestNotificationOfStartOfTransaction(TRequestStatus& aRequestStatus);

		void CancelRequestForNotificationOfStartOfTransaction();

		void RequestCharacters(TRequestStatus& aRequestStatus, TDes8& aCharacterBuffer, TBool aUpperCase);

		void CancelRequestForCharacters();

		void SetUpperCase(TBool aUpperCase);

		};

private:

	CTstWholeScreenScribbleArea(RWsSession& aWindowServerSession);

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

	static CFbsBitmap* CreateBitmapL(TInt aHandleOfBitmapToUse, const TSize& aScreenSize, TDisplayMode aDisplayMode);

	static void SignalMutex(TAny* aMutex);

private:

	TUint iFlags;

	RMutex iMutex;

	TSpriteMember iSpriteMember;

	RAnimDll iDll;

	RWsSprite iSprite;

	RHandWritingRecognizer iHandWritingRecognizer;

	};

class CFont;

class CTstControl : public CCoeControl

	{

public:

	static CTstControl* NewL(CTstFep& aFep);

	virtual ~CTstControl();

	void CancelTransaction();

	void IsOnHasChangedState();

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

	void OfferPointerBufferReadyEventL(CCoeFep::TEventResponse& aEventResponse, const CCoeControl* aWindowOwningControl);

	inline TBool UpperCase() const {return (iFlags&EFlagUpperCase);}

	static TInt NumberOfAttributes();

	static TUid AttributeAtIndex(TInt aIndex);

	void WriteAttributeDataToStreamL(TUid aAttributeUid, RWriteStream& aStream) const;

	void ReadAttributeDataFromStreamL(TUid aAttributeUid, RReadStream& aStream);

	static void WriteAttributeDataToStreamL(TUid aAttributeUid, RWriteStream& aStream, TBool aUpperCase, TBool aWholeScreen, TBool aPointerBufferEnabled);

	static void ReadAttributeDataFromStreamL(TUid aAttributeUid, RReadStream& aStream, TBool& aUpperCase, TBool& aWholeScreen, TBool& aPointerBufferEnabled);

	void HandleGainingForeground();

	void HandleLosingForeground();

	void HandleChangeInFocus();

	void HandleDestructionOfFocusedItem();

private:

	typedef void (*FChangeFunction)(CTstControl& aControl, TBool& aChangeWasMade, TInt aParameter);

	enum {EArrowHeadSize=4};

	enum {EMaximumLengthOfDisplayOfContextInformation=15};

	enum

		{

		ETstUpperCaseUid=0x10003eab,

		ETstWholeScreenUid=0x1000550c,

		ETstPointerBufferEnabledUid=0x10004d18

		};

	enum

		{

		EFlagForeground						=0x00000001,

		EFlagWindowIsBeingDragged			=0x00000002,

		EFlagUpperCase						=0x00000004,

		EFlagWholeScreen					=0x00000008,

		EFlagPointerBufferEnabled			=0x00000010,

		EFlagActuallyWholeScreen			=0x00000020

		};

	enum

		{

		EHeightOfScribbleWindow	=60,

		EGapLeftOfEachLine		=1,

		EGapAboveTopLine		=1,

		EGapBetweenEachLine		=1,

		EGapBelowBottomLine		=1

		};

	class CHandlerForStartOfTransaction : public CActive

		{

	public:

		static CHandlerForStartOfTransaction* NewL(CTstWholeScreenScribbleArea& aWholeScreenScribbleArea, CCoeEnv& aConeEnvironment);

		virtual ~CHandlerForStartOfTransaction();

	private:

		CHandlerForStartOfTransaction(CTstWholeScreenScribbleArea& aWholeScreenScribbleArea, CCoeEnv& aConeEnvironment);

		void RequestNotificationOfStartOfTransaction();

		virtual void DoCancel();

		virtual void RunL();

	private:

		CTstWholeScreenScribbleArea& iWholeScreenScribbleArea;

		CCoeEnv& iConeEnvironment;

		};

	class CHandlerForCharacters : public CActive

		{

	public:

		static CHandlerForCharacters* NewL(CTstWholeScreenScribbleArea& aWholeScreenScribbleArea, CTstFep& aFep, TBool aForeground);

		virtual ~CHandlerForCharacters();

		inline void SetWholeScreen(TBool aWholeScreen) {SetFlagAffectingWhetherActive(EFlagWholeScreen, aWholeScreen);}

		inline void SetIsOn(TBool aIsOn) {SetFlagAffectingWhetherActive(EFlagIsOn, aIsOn);}

		inline void SetForeground(TBool aForeground) {SetFlagAffectingWhetherActive(EFlagForeground, aForeground);}

		void SetUpperCase(TBool aUpperCase);

	private:

		enum {EMaximumLengthOfCharacterBuffer=4*sizeof(TUint)};

		enum

			{

			EFlagWholeScreen	=0x00000001,

			EFlagIsOn			=0x00000002,

			EFlagForeground		=0x00000004,

			EFlagUpperCase		=0x00000008

			};

	private:

		CHandlerForCharacters(CTstWholeScreenScribbleArea& aWholeScreenScribbleArea, CTstFep& aFep, TBool aForeground);

		void SetFlagAffectingWhetherActive(TUint aFlagAffectingWhetherActive, TBool aSetting); // aFlag may be passed EFlagWholeScreen, EFlagIsOn or EFlagForeground

		void RequestCharacters();

		static TInt NumberOfCharactersInBuffer(const CBase* aCharacterBuffer); // aCharacterBuffer is really a TDesC8

		static const TAny* CharacterInBuffer(const CBase* aCharacterBuffer, TInt aIndex); // aCharacterBuffer is really a TDesC8

		virtual void DoCancel();

		virtual void RunL();

	private:

		CTstWholeScreenScribbleArea& iWholeScreenScribbleArea;

		CTstFep& iFep;

		TUint iFlags;

		TBuf8<EMaximumLengthOfCharacterBuffer> iCharacterBuffer;

		};

private:

	CTstControl(CTstFep& aFep);

	void ConstructL();

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

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

	static void SetUpperCase(CTstControl& aControl, TBool& aChangeWasMade, TInt aParameter);

	static void SetWholeScreen(CTstControl& aControl, TBool& aChangeWasMade, TInt aParameter);

	static void SetPointerBufferEnabled(CTstControl& aControl, TBool& aChangeWasMade, TInt aParameter);

	static void SetInputCapabilities(CTstControl& aControl, TBool& aChangeWasMade, TInt aParameter);

	static void SetFlag(CTstControl& aControl, TBool& aChangeWasMade, TInt aParameter, TUint aFlag);

	void DoSetWholeScreen(TBool aWholeScreen);

	void ChangeSetupAndDrawNow(FChangeFunction aChangeFunction, TInt aParameter=0);

public:

	// from CCoeControl

	virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aEventCode);

private:

	// from CCoeControl

	virtual void HandlePointerEventL(const TPointerEvent& aPointerEvent);

	virtual TInt CountComponentControls() const;

	virtual CCoeControl* ComponentControl(TInt aIndex) const;

	virtual void Draw(const TRect& aRect) const;

private:

	CTstFep& iFep;

	TUint iFlags;

	TCoeInputCapabilities iInputCapabilities;

	CTstScribbleWindow* iScribbleWindow;

	CTstWholeScreenScribbleArea* iWholeScreenScribbleArea;

	CHandlerForStartOfTransaction* iHandlerForStartOfTransaction;

	CHandlerForCharacters* iHandlerForCharacters;

	CFont* iStatusFont;

	TPoint iPositionOnWindowBeingDragged;

	};

class CTstFep : public CCoeFep

	{

public:

	CTstFep(CCoeEnv& aConeEnvironment);

	void ConstructL(const CCoeFepParameters& aFepParameters);

	virtual ~CTstFep();

	inline void SimulateKeyEventsL(const TArray<TUint>& aArrayOfCharacters) {CCoeFep::SimulateKeyEventsL(aArrayOfCharacters);}

	inline void WriteAttributeDataAndBroadcastL(TUid aAttributeUid) {CCoeFep::WriteAttributeDataAndBroadcastL(aAttributeUid);}

	inline TBool IsOn() const {return CCoeFep::IsOn();}

	inline TBool UpperCase() const {return iControl->UpperCase();}

private:

	// from CCoeFep

	virtual void CancelTransaction();

	virtual void IsOnHasChangedState();

	virtual void OfferKeyEventL(TEventResponse& aEventResponse, const TKeyEvent& aKeyEvent, TEventCode aEventCode);

	virtual void OfferPointerEventL(TEventResponse& aEventResponse, const TPointerEvent& aPointerEvent, const CCoeControl* aWindowOwningControl);

	virtual void OfferPointerBufferReadyEventL(TEventResponse& aEventResponse, const CCoeControl* aWindowOwningControl);

	// from MFepAttributeStorer (via CCoeFep)

	virtual TInt NumberOfAttributes() const;

	virtual TUid AttributeAtIndex(TInt aIndex) const;

	virtual void WriteAttributeDataToStreamL(TUid aAttributeUid, RWriteStream& aStream) const;

	virtual void ReadAttributeDataFromStreamL(TUid aAttributeUid, RReadStream& aStream);

	// from MCoeForegroundObserver (via CCoeFep)

	virtual void HandleGainingForeground();

	virtual void HandleLosingForeground();

	// from MCoeFocusObserver (via CCoeFep)

	virtual void HandleChangeInFocus();

	virtual void HandleDestructionOfFocusedItem();

private:

	CTstControl* iControl;

	};

class TTstResourceFileId : public TCleanupItem

	{

public:

	TTstResourceFileId(CCoeEnv& aConeEnvironment, TInt aResourceFileId);

private:

	static void UnloadResourceFile(TAny* aThis);

private:

	CCoeEnv& iConeEnvironment;

	TInt iResourceFileId;

	};

class CTstSettingsDialog : public CEikDialog, private MFepAttributeStorer

	{

public:

	CTstSettingsDialog();

private:

	TUint CheckBoxStateAsFlag(TInt aControlId, TUint aFlag) const;

	void SetCheckBoxState(TInt aControlId, TUint aFlag);

	// from CEikDialog

	virtual TBool OkToExitL(TInt aButtonId);

	virtual void PreLayoutDynInitL();

	// from MFepAttributeStorer

	virtual TInt NumberOfAttributes() const;

	virtual TUid AttributeAtIndex(TInt aIndex) const;

	virtual void WriteAttributeDataToStreamL(TUid aAttributeUid, RWriteStream& aStream) const;

	virtual void ReadAttributeDataFromStreamL(TUid aAttributeUid, RReadStream& aStream);

private:

	enum

		{

		EFlagUpperCase				=0x00000001,

		EFlagWholeScreen			=0x00000002,

		EFlagPointerBufferEnabled	=0x00000004

		};

private:

	TUint iFlags;

	TUid iUid;

	};

#endif