/*

* 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"

#include "penpointereventsuppressor.h"

// ----------- 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 * 10;          //1/100 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    

    delete iPointerEventSuppressor;

    }

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

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

    iPointerEventSuppressor = CPenPointerEventSuppressor::NewL();

    }

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

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

    TPointerEvent pointerEvent;

    switch ( aRawEvent.Type() )

        {

        case TRawEvent::EButton1Down:

            {

            pointerEvent.iType = TPointerEvent::EButton1Down;

            pointerEvent.iPosition = aRawEvent.Pos();

            break;

            }

        case TRawEvent::EButton1Up:

            {

            pointerEvent.iType = TPointerEvent::EButton1Up;

            pointerEvent.iPosition = aRawEvent.Pos();

            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;

        }

    TRawEvent rawEvent = aRawEvent;

    if ( aRawEvent.Type() == TRawEvent::EButton1Up 

         && aRawEvent.Pos() != pointerEvent.iPosition )

        {

        rawEvent.Set( TRawEvent::EButton1Up, 

                      pointerEvent.iPosition.iX, 

                      pointerEvent.iPosition.iY );

        }

    switch(aRawEvent.Type())

        {

        case TRawEvent::EKeyUp:

        case TRawEvent::EKeyDown:

            {

            return OnRawKeyEvent( rawEvent );            

            }

        case TRawEvent::EButton1Down:

            {

            TBool used = OnRawButton1Down( rawEvent );

            if ( used )

                {

                StartTimer();

                }

            return used;

            }

        case TRawEvent::EButton1Up:

            {

            TBool used = OnRawButton1Up( rawEvent );

            StopTimer();

            return used;

            }

        case TRawEvent::EPointerMove:

            {

            return OnRawPointerMove( rawEvent );

            }

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