/*

* Copyright (c) 2005-2007 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:  Implementation for peninput animation dll

*

*/

/*

* ============================================================================

*

* Refactoring by Steven Yao

* 

* 2007-03-23

*

* ============================================================================

*/

//INCLUDE

#include "peninputanim.h" 

#include "peninputcmdparam.h"

#include "peninputcmdparamext.h"

#include "peninputcmd.h"

// Modify for bug ETMA-7X2C5Y begin

#include "penpointereventsuppressor.h"

// Modify for bug ETMA-7X2C5Y end

// ----------- Touch feedback additions start

#ifdef RD_TACTILE_FEEDBACK

#include <coecntrl.h>

#include <tactilefeedbackserver.h>

#include <featmgr.h>

#endif //RD_TACTILE_FEEDBACK

// ----------- Touch feedback additions start

#include <avkondomainpskeys.h>

//CONSTANT

const TInt KMsgSlot1 = 1;	//msg slot 2 in IPC

const TInt KMsgSlot2 = 2; 	//msg slot 2 in IPC

const TInt KFlushTimerPeriod = 1000;		//1/1000 second

const TInt KResponseQueueWaitTime = 100000;		//1/10 second

// ======== GLOBAL FUNCTIONS ========

// ---------------------------------------------------------------------------

// CreateCAnimDllL

// This is called by the window server, at the request of the animation 

// client, to construct the CAnimDll derived server side DLL class.

// ---------------------------------------------------------------------------

//

EXPORT_C CAnimDll *CreateCAnimDllL()

    {

	return(new (ELeave) CPeninputAnimDll()); 

    }

// ======== MEMBER FUNCTIONS ========

// class CAnimDll

// ---------------------------------------------------------------------------

// CPeninputAnimDll::CreateInstanceL

// Factory function for animation DLL.

// ---------------------------------------------------------------------------

//

CAnim* CPeninputAnimDll::CreateInstanceL(TInt /*aType*/)

    {

	return new(ELeave) CPeninputAnim();

    }

// class CPeninputAnim

// ---------------------------------------------------------------------------

// CPeninputAnim::CPeninputAnim

// Constructor

// ---------------------------------------------------------------------------

//

CPeninputAnim::CPeninputAnim()

    {

	iIsActive = EFalse;

	//iSpritePosition and iSpriteSize are initialized to 0 by default constructor

	//iSpritePosition = TPoint(0, 0);

	//iSpriteSize = TSize(0, 0);

	iIsPointerCaptured = EFalse;

	iIsPenDown = EFalse;

	iPrimaryTouchPtNum = 0;

	iPrimaryTouchPtDetected = EFalse;

#ifdef RD_TACTILE_FEEDBACK	

	TRAPD( err, FeatureManager::InitializeLibL() );

    if( err == KErrNone )

        {

        iTactileSupported =  FeatureManager::FeatureSupported( KFeatureIdTactileFeedback );

        }

	iFeedback = MTactileFeedbackServer::Instance();

#endif // RD_TACTILE_FEEDBACK	

    iEnableSprite = ETrue;	

    iDSAState = EFalse;	

    }

// ---------------------------------------------------------------------------

// CPeninputAnim::~CPeninputAnim

// Destructor

// ---------------------------------------------------------------------------

//

CPeninputAnim::~CPeninputAnim()

    {

	Deactivate();

	iMsgBufQueue.Close();

	iKeyMsgResponseQueue.Close();

	iResponseQueueSemaphore.Close();

	delete iFlushTimer;

#ifdef RD_TACTILE_FEEDBACK	

	FeatureManager::UnInitializeLib();

	iTactileControl.Close();

	iBackupTactileControl.Close();

#endif // RD_TACTILE_FEEDBACK	

	// Modify for bug ETMA-7X2C5Y begin

	delete iPointerEventSuppressor;

	// Modify for bug ETMA-7X2C5Y end

	if (iDiscreetPopSubscriber)

	    {

	    iDiscreetPopSubscriber->StopSubscribe();

	    }

	iDiscreetPopProperty.Close();

	delete iDiscreetPopSubscriber;

	iAknUiSrv.Close();

    }

// ---------------------------------------------------------------------------

// CPeninputAnim::ConstructL

// Second phase constructor

// ---------------------------------------------------------------------------

//

void CPeninputAnim::ConstructL(TAny* /*aParameters*/)

    {

	// the animation feature is not used

	iFunctions->SetInterval(0);

	iFlushTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    iFunctions->RegisterForNotifications(EDirectScreenAccess);

	// Modify for bug ETMA-7X2C5Y begin

    iPointerEventSuppressor = CPenPointerEventSuppressor::NewL();

    // Modify for bug ETMA-7X2C5Y end

    User::LeaveIfError(iDiscreetPopProperty.Attach(KPSUidAvkonDomain, 

                                         KAknGlobalDiscreetPopupNumChanged));

    iDiscreetPopSubscriber = new (ELeave) CSubscriber(

			TCallBack( DiscreetPopChangeNotification, this), 

			iDiscreetPopProperty);

    iDiscreetPopSubscriber->SubscribeL();

	User::LeaveIfError(iAknUiSrv.Connect());

	iDiscreetPopArea = iAknUiSrv.GetInUseGlobalDiscreetPopupRect();

    if(iDiscreetPopArea.Size().iWidth > 0)

    	{

		iDiscreetPoped = ETrue;

    	}

    }

// ---------------------------------------------------------------------------

// CPeninputAnim::Animate

// Create layout

// ---------------------------------------------------------------------------

//

void CPeninputAnim::Animate(TDateTime* /*aDateTime*/)

    {

    // do nothing

    }

void CPeninputAnim::HandleNotification(const TWsEvent& aEvent)

    {

    switch (aEvent.Type())

        {

        case EEventDirectScreenAccessBegin:

            SetDSAState(ETrue);

            break;

        case EEventDirectScreenAccessEnd:

            SetDSAState(EFalse);

            break;

        default:

            break;

        }

    }

void CPeninputAnim::SetDSAState(TBool aFlag)

    {

    iDSAState = aFlag;

    if(aFlag && iEnableSprite) //close sprite when DSA is on

        {

        TRawEvent event;

        event.Set( TRawEvent::ENone );

        event.SetTip( ETrue );

        PostRawEvent( event );

        FlushRawEventBuffer();

        //Deactivate(); 

        //iEnableSprite = EFalse;

        }

    /*else

        {

        iEnableSprite = iESPrevState;

        }*/

    }

// ---------------------------------------------------------------------------

// CPeninputAnim::OfferRawEvent

// handle raw events, e.g. key presses, pen events, power buttons etc. 

// if the event can be handled then return ETrue, or return EFalse

// ---------------------------------------------------------------------------

//

TBool CPeninputAnim::OfferRawEvent(const TRawEvent& aRawEvent)

    {

    if( iIsSimulatedEvent )

        {

    	return EFalse;

        }

    // Suppress multi-touch events

    switch ( aRawEvent.Type() )

        {

        case TRawEvent::EButton1Down:

        case TRawEvent::EButton1Up:

        case TRawEvent::EPointerMove:

            {

            if ( iPrimaryTouchPtDetected )

                {

                if ( aRawEvent.PointerNumber() != iPrimaryTouchPtNum )

                    {

                    return ETrue;

                    }

                }

            else

                {

                iPrimaryTouchPtNum = aRawEvent.PointerNumber();

                iPrimaryTouchPtDetected = ETrue;

                }

            }

            break;

        default:

            break;

        }

	// Suppress unexpected drag events, refer to error ETMA-7X2C5Y

    TPointerEvent pointerEvent;

    switch ( aRawEvent.Type() )

        {

        case TRawEvent::EButton1Down:

            {

            pointerEvent.iType = TPointerEvent::EButton1Down;

            pointerEvent.iPosition = aRawEvent.Pos();

            break;

            }

        case TRawEvent::EButton1Up:

            {

            pointerEvent.iType = TPointerEvent::EButton1Up;

            break;

            }

        case TRawEvent::EPointerMove:

            {

            pointerEvent.iType = TPointerEvent::EDrag;

            pointerEvent.iPosition = aRawEvent.Pos();

            break;

            }

        default:

            pointerEvent.iType = TPointerEvent::ENullType;

        }

    TBool result = iPointerEventSuppressor->SuppressPointerEvent( pointerEvent );

    if ( result )

        {

        return ETrue;

        }

	switch(aRawEvent.Type())

	    {

		case TRawEvent::EKeyUp:

		case TRawEvent::EKeyDown:

		    {

			return OnRawKeyEvent(aRawEvent);        	

		    }

		case TRawEvent::EButton1Down:

		    {

			return OnRawButton1Down(aRawEvent);

		    }

		case TRawEvent::EButton1Up:

		    {

			return OnRawButton1Up(aRawEvent);

		    }

		case TRawEvent::EPointerMove:

		    {

			return OnRawPointerMove(aRawEvent);

		    }

		default:

		    {

			return EFalse;

		    }            

	    }	

    }

// ---------------------------------------------------------------------------

// CPeninputAnim::Command

// The window server calls this function in response to application 

// calls to the client side command function RAnim::Command()

// ---------------------------------------------------------------------------

//

void CPeninputAnim::Command(TInt aOpcode, TAny* aParams)

    {

    switch(aOpcode)

        {

		case EPeninputOpActivate:

            {

            Activate();

            break;

            }        

        case EPeninputOpDeactivate:

            {

            Deactivate();

            break;

            }        

        case EPeninputOpLayoutUpdateArea:

            {

            PanicClientIfNoParam(aParams);	                

			TUpdateDataArea* area = static_cast<TUpdateDataArea*>(aParams);

			iSpriteFunctions->UpdateMember( 0, area->iRect, area->iUpdateFlag );

			break;

		    }			

        case EPeninputOpCapturePointer:

            {

            PanicClientIfNoParam(aParams);            

	        iIsPointerCaptured = *(static_cast<TBool*>(aParams));

	        break;

            }

        case EPeninputOpSimulateEvent:

            {

            PanicClientIfNoParam(aParams);

            TRawEvent event = *(static_cast<TRawEvent*>(aParams));

            iIsSimulatedEvent = ETrue;

            iFunctions->PostRawEvent(event);

            iIsSimulatedEvent = EFalse;

            break;

            }

#ifdef RD_TACTILE_FEEDBACK         

        case EPeninputOpRegisterFeedbackArea:

            {

            //add the rect to feedback list

            PanicClientIfNoParam(aParams);

            TTactileFeedbackArea area = *(static_cast<TTactileFeedbackArea*>(aParams));

            //Advanced Tactile feedback REQ417-47932

            TTactileControlInfo controlitem(area.iId, area.iNewRect, area.iTactileType);

            iTactileControl.Append(controlitem); 

            }

            break;

        case EPeninputOpDeRegisterFeedbackArea:

            {

            PanicClientIfNoParam(aParams);

            TTactileFeedbackArea area = *(static_cast<TTactileFeedbackArea*>(aParams));

            const TInt KRemoveAllId = -1;

            if( area.iId == KRemoveAllId && area.iNewRect == TRect(0,0,0,0) )

                {

                //remove all

                iTactileControl.Reset();

                break;

                }

            TTactileControlInfo controlitem(area.iId, area.iNewRect, area.iTactileType);

            TInt idx = iTactileControl.Find(controlitem, 

            		TIdentityRelation<TTactileControlInfo>(CPeninputAnim::MatchItemByControlID));

            if(idx != KErrNotFound)

                {  

                iTactileControl.Remove(idx);

                }

            }

            break;  

        case EPeninputOpChangeFeedbackArea:

            {

            PanicClientIfNoParam(aParams);

            TTactileFeedbackArea area = *(static_cast<TTactileFeedbackArea*>(aParams));

            TTactileControlInfo controlitem(area.iId, area.iPrevRect, area.iTactileType);           

            TInt idx = iTactileControl.Find(controlitem, 

                    TIdentityRelation<TTactileControlInfo>(CPeninputAnim::MatchItemByControlIDAndArea));

            if(idx != KErrNotFound)

                {                                

                //change the rect

                iTactileControl[idx].iArea = area.iNewRect;

                }  

            }

            break; 

        case EPeninputOpChangeFeedbackType:

        	{

        	PanicClientIfNoParam(aParams);

            TTactileFeedbackArea area = *(static_cast<TTactileFeedbackArea*>(aParams));

            TTactileControlInfo controlitem(area.iId, area.iNewRect, area.iTactileType);

            TInt idx = iTactileControl.Find(controlitem,                    

					TIdentityRelation<TTactileControlInfo>(CPeninputAnim::MatchItemByControlID));

            if(idx != KErrNotFound)

                {                                

                //change the tactile type

                iTactileControl[idx].iTactileType = area.iTactileType;

                }        	

        	}

            break;

#endif // RD_TACTILE_FEEDBACK

        case EPeninputOpEnalbeSprite:

            {

            PanicClientIfNoParam(aParams);

            iEnableSprite = *(static_cast<TBool*>(aParams));            

            }

            break;

        default:

            {

            //panic the client for unknown command

            iFunctions->Panic();

            break;

            }

	    }

    }

// ---------------------------------------------------------------------------

// CPeninputAnim::CommandReplyL

// The window server calls this function in response to application calls 

// to the client side command function RAnim::CommandReplyL(). 

// This function can't leave. Otherwise window server panic

// ---------------------------------------------------------------------------

//

TInt CPeninputAnim::CommandReplyL( TInt aOpcode, TAny* /*aParams*/)

    {

    TInt retValue = KErrNone;

    const RMessagePtr2* msg = iFunctions->Message();

    switch ( aOpcode )

        {

        case EPeninputOpFinishConstructionL:

            {

            iFunctions->SetSync( MAnimGeneralFunctions::ESyncNone );

            retValue = iMsgBufQueue.OpenGlobal(KMsgEventBufferQueue);

            //event queue for key event response from pen input servers

            iKeyMsgResponseQueue.OpenGlobal(KMsgEventResponseQueue);

            iResponseQueueSemaphore.OpenGlobal(KAnimKeyEventSemaphore);

			break;

            }

        case EPeninputOpActivate:

            {

            Activate();

            break;

            }

        case EPeninputOpDeactivate:

            {

            Deactivate();

            break;

            }       

        case EPeninputOpLayoutUpdateArea:

        	{

        	//TUpdateDataArea s;

			//TPckg<TUpdateDataArea> pkg(s);        	

			TRect rect;

			TBool flag;

		    TPckg<TRect> rectMsg(rect);			

		    TPckg<TBool> flagMsg(flag);    

			msg->ReadL(KMsgSlot1,rectMsg);

			msg->ReadL(KMsgSlot2,flagMsg);

			iSpriteFunctions->UpdateMember(0, rect,flag);			

        	  }

        	  break;

        case EPeninputOpLayoutUpdateAreaRegion:

            {

            TInt num;

            TPckg<TInt> numMsg(num);    

            msg->ReadL(KMsgSlot1,numMsg);

            TInt len = msg->GetDesLengthL(KMsgSlot2);

            TUint8* buf = new (ELeave) TUint8[len*sizeof(TUpdateArea)];

            CleanupArrayDeletePushL( buf );

            TPtr8 ptr(buf,len);

            msg->ReadL(KMsgSlot2,ptr);

            TUpdateArea* area = reinterpret_cast<TUpdateArea*>(buf);

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

                {

                iSpriteFunctions->UpdateMember(0, area[i].iRect,area[i].iFullUpdateFlag);

                }

            CleanupStack::PopAndDestroy( buf );

        	}

        	break;

        case EPeninputOpSetLayoutPos:

            {

            TPoint pt;

            TPckg<TPoint> msgData(pt);

            msg->ReadL(KMsgSlot1,msgData);

            SetPosition(pt);            

            }

            break;

        case EPeninputOpCapturePointer:

            {

            TInt captureCtrlID;

			TPckg<TBool> msgData(iIsPointerCaptured);

			TPckg<TInt> msgCaptureCtrlIDData(captureCtrlID);

            msg->ReadL(KMsgSlot1,msgData);

            msg->ReadL(KMsgSlot2,msgCaptureCtrlIDData);