/*
* 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;
            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:
            {
            TBool used = OnRawButton1Down(aRawEvent);
            
            if ( used )
                {
                StartTimer();
                }
            
            return used;
            }
        case TRawEvent::EButton1Up:
            {
            TBool used = OnRawButton1Up(aRawEvent);
            StopTimer();
            return used;
            }
        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);
#ifdef RD_TACTILE_FEEDBACK
            // When pointer is captured by some ctrl,
            // only the captured ctrl has tactile feedback ablity,
            // disable all other one's.
            if (iIsPointerCaptured)
                {
                // Back up all the tactile area
                iBackupTactileControl.Reset();            
                TInt count = iTactileControl.Count();
                for(TInt i = 0; i < count; ++i)
                    {
                    iBackupTactileControl.Append(iTactileControl[i]);
                    }
                
                // Clean up the original tactile area
                iTactileControl.Reset();               
                
                // Find the captured ctrl, restore its tactile ablity
                for(TInt i = 0; i < count; ++i)
                    {
                    if (iBackupTactileControl[i].iId == captureCtrlID)
                        {
                        iTactileControl.Append(iBackupTactileControl[i]);
                        }
                    }

                }
            // When pointer released captured, 
            // restore all original tactile area.
            else 
                {
                if (iBackupTactileControl.Count() != 0)
                    {
                    iTactileControl.Reset();                   
                    
                    TInt count = iBackupTactileControl.Count();
                    for(TInt i = 0; i < count; ++i)
                        {
                        iTactileControl.Append(iBackupTactileControl[i]);
                        }
                    iBackupTactileControl.Reset();
                    }
                }
#endif                
            }
            break;
        case EPeninputOpLayoutSizeChangedWithSize:
                {
                TPckg<TSize> msgData(iSpriteSize);
                msg->ReadL(1,msgData); 
                iSpriteFunctions->SizeChangedL();
                }
            break;
        case EPeninputOpSimulateEvent:
            {
            TRawEvent event;
            TPckg<TRawEvent> msgData(event);
            msg->ReadL(KMsgSlot1,msgData); 
            iIsSimulatedEvent = ETrue;
            iFunctions->PostRawEvent(event);
            iIsSimulatedEvent = EFalse;
            
            }
            break;    
            
#ifdef RD_TACTILE_FEEDBACK             
        case EPeninputOpRegisterFeedbackArea:
            {                        
            GetFeedbackAreaDataL(iTactileControl,msg);            
            }
            break;
            
        case EPeninputOpDeRegisterFeedbackArea:
            {
            //Advanced Tactile feedback REQ417-47932
            RArray<TTactileControlInfo> controlarray;
            CleanupClosePushL(controlarray);
            
            GetFeedbackAreaDataL(controlarray,msg);
            
            //remove all registered feedback area
            const TInt KRemoveAllId = -1;           
            if(controlarray.Count() && controlarray[0].iId == KRemoveAllId && 
                                        controlarray[0].iArea == TRect(0,0,0,0))
                {
                //remove all
                iTactileControl.Reset();
                }
            else
                {
                //remove the area
                for(TInt i = 0; i < controlarray.Count(); ++i)
                    {
                    //find id first
                    TInt idx = iTactileControl.Find(controlarray[i], 
                                TIdentityRelation<TTactileControlInfo>(CPeninputAnim::MatchItemByControlID));
                    
                    if(idx != KErrNotFound)
                        {
                        iTactileControl.Remove(idx);                       
                        }
                    }
                }
                
            CleanupStack::PopAndDestroy( 1, &controlarray );
            }
            break;
        
            
        case EPeninputOpChangeFeedbackArea:            
            {
            //Advanced Tactile feedback REQ417-47932
            RArray<TTactileControlInfo> controlarray;
            RArray<TRect> prevArea;
            
            CleanupClosePushL(controlarray);
            CleanupClosePushL(prevArea);
            
            GetFeedbackAreaDataL(controlarray,msg,&prevArea);
            //change the area one by one            
            for(TInt i = 0; i < controlarray.Count(); ++i)
                {
                //find id first
                TInt idx = iTactileControl.Find(controlarray[i], 
                           TIdentityRelation<TTactileControlInfo>(CPeninputAnim::MatchItemByControlID));
                                    
                if(idx != KErrNotFound)
                    {
                    //check the rect
                    if(prevArea[i] == iTactileControl[idx].iArea)
                        {
                        //change the rect
                        iTactileControl[idx].iArea = controlarray[i].iArea;
                        break;
                        }
                    }
                }
            
            CleanupStack::PopAndDestroy( 2, &controlarray );
            }
        
            break;
            
        //Advanced Tactile feedback REQ417-47932    
        case EPeninputOpChangeFeedbackType:            
            {           
            RArray<TTactileControlInfo> controlarray;
            CleanupClosePushL(controlarray);
            
            GetFeedbackAreaDataL(controlarray,msg);
            //change the area one by one
            for(TInt i = 0; i < controlarray.Count(); ++i)
                {
                //find id first
                TInt idx = iTactileControl.Find(controlarray[i],                            
                           TIdentityRelation<TTactileControlInfo>(CPeninputAnim::MatchItemByControlID));
                if(idx != KErrNotFound)
                    {
                    //change the tactile feedback type
                    iTactileControl[idx].iTactileType = controlarray[i].iTactileType;
                    break;
                    }
                }
            
            CleanupStack::PopAndDestroy( 1, &controlarray );
            }
  
            break;
            
#endif // RD_TACTILE_FEEDBACK 
        case EPeninputOpRequestDSAState:                        
            {
            TPckgC<TBool> flagMsg(iDSAState);    
            
            msg->WriteL(KMsgSlot1,flagMsg);
            
            }
            break;
        case EPeninputOpSetDiscreeptPop:
            {
            TRect area;
            TPckg<TRect> msgData(area);
            msg->ReadL(KMsgSlot1,msgData);
            SetDiscreeptPop(area); 
            }
            break;
        default:
            // unsupported opcode, panic the client
            {                
            iFunctions->Panic();
            retValue = KErrNotSupported;
            }
            break;
        }

    return retValue;
    }

// ---------------------------------------------------------------------------
// CPeninputAnim::Activate
// Makes PENINPUT window visible
// ---------------------------------------------------------------------------
//
void CPeninputAnim::Activate()
    {
    if(!iIsActive)
        {
        iSpriteFunctions->SetPosition(iSpritePosition);
        if(iEnableSprite)
            iSpriteFunctions->Activate(ETrue);
        iFunctions->GetRawEvents(ETrue);
        iIsActive = ETrue;        
        }        
    }

// ---------------------------------------------------------------------------
// CPeninputAnim::Deactivate
// Makes PENINPUT window invisible
// ---------------------------------------------------------------------------
//
void CPeninputAnim::Deactivate()
    {
    if(iIsActive)
        {
        if(iEnableSprite)
            iSpriteFunctions->Activate(EFalse);
        iFunctions->GetRawEvents(EFalse);        
        iIsActive = EFalse;
        
        StopTimer();
        }        
    }
    
#ifdef RD_TACTILE_FEEDBACK
// ---------------------------------------------------------------------------
// CPeninputAnim::DoTactileFeedBack
// Give tactile feedback
// ---------------------------------------------------------------------------
//                        
void CPeninputAnim::DoTactileFeedBack(const TPoint& aPos)
    {
    if ( iFeedback ) 
        {
        TInt count = iTactileControl.Count();
        for(TInt i = 0; i < count; ++i)
            {
            if(iTactileControl[i].iArea.Contains(aPos))
                {
                iFeedback->InstantFeedback((TTouchLogicalFeedback)iTactileControl[i].iTactileType);
                return;
                }                 
            }           
        }
    }
#endif // RD_TACTILE_FEEDBACK

// ---------------------------------------------------------------------------
// CPeninputAnim::OnRawButton1Down
// Handles raw pen down events
// Can't leave, since this is run in window server side.
// return value indicating whether the event was handled by this function    
// ---------------------------------------------------------------------------
//

TBool CPeninputAnim::OnRawButton1Down(const TRawEvent& aRawEvent)
    {
    if(iIsSimulatedEvent)
        {
        return EFalse;
        }
        
    
    if(iDiscreetPoped && iDiscreetPopArea.Contains(aRawEvent.Pos()))
        {
        iDiscreetPopedCapture = ETrue;
        return EFalse;
        }
    TRect rect(iSpritePosition, iSpriteSize);        
    if(rect.Contains(aRawEvent.Pos()))
        {                
#ifdef RD_TACTILE_FEEDBACK            
        //give tactile feedback        
        if(iTactileSupported)
            DoTactileFeedBack(aRawEvent.Pos() - rect.iTl);
#endif // RD_TACTILE_FEEDBACK    
        iIsPenDown = ETrue;

        // When button downing event is happened, iIsMove is reset to EFalse
        iIsMove = EFalse;              

        // Recording pointer that button is pressing down in at this time
        iPointerDown = aRawEvent.Pos();  
        //

        PostRawEvent(aRawEvent); 
        return ETrue;
        }

    if(iIsPointerCaptured)
        {                    
        PostRawEvent(aRawEvent);
        return ETrue;
        }

    //pointer outside of input area,inform layout
    SendRawEvent(aRawEvent);

    return EFalse;
    }

TBool CPeninputAnim::OnRawButton1Up(const TRawEvent& aRawEvent)
    {
    if(iIsSimulatedEvent)
        {
        return EFalse;
        }

    //For discreetPop
    if(iDiscreetPopedCapture )
        {
        iDiscreetPopedCapture = EFalse;
        return EFalse;
        }
    if(iIsPenDown)
        {      
  
        // When the control key pressing down in is different with the control key pressing up 
        // and pointer moving event isn¡¯t happened,
        // pointer moving event will is supplied 
        if(iPointerDown != aRawEvent.Pos() && !iIsMove)
          {
          TRawEvent rawEvent = aRawEvent;
          rawEvent.Set( TRawEvent::EPointerMove );
          OnRawPointerMove(rawEvent);
          }
        //

        iIsPenDown = EFalse;
        
        TRect rect(iSpritePosition, iSpriteSize);        
        if(rect.Contains(aRawEvent.Pos()))
            {
            //send pen up event immediately
            SendRawEvent(aRawEvent);
            
            // When key pressing up event is completed, iIsMove is reset to EFalse.
            iIsMove = EFalse;   
            //

            return ETrue;                    
            }
        }
    
    if(iIsPointerCaptured)
        {                    
        PostRawEvent(aRawEvent);
        return ETrue;
        }
    
    //pointer outside of input area,inform layout
    SendRawEvent(aRawEvent);

    return EFalse;    
    }

TBool CPeninputAnim::OnRawPointerMove(const TRawEvent& aRawEvent)
    {
    if(iIsSimulatedEvent)
        {
        return EFalse;
        }
    if(iDiscreetPopedCapture)
        {
        return EFalse;
        }
#ifdef RD_TACTILE_FEEDBACK            
    TRect rect(iSpritePosition, iSpriteSize);        
    if( iIsPenDown && iIsPointerCaptured)
        {                
        //give tactile feedback        
        // When pointer moving event is happened, iIsMove is set to ETrue
        iIsMove = ETrue;        
        //

        PostRawEvent(aRawEvent); 
        return ETrue;
        }
#endif // RD_TACTILE_FEEDBACK    

    if(iIsPointerCaptured || iIsPenDown)
        {                    
        // When pointer moving event is happened, iIsMove is set to ETrue
        iIsMove = ETrue;        
        //

        PostRawEvent(aRawEvent);
        return ETrue;
        }
    
    return EFalse;
    }

// ---------------------------------------------------------------------------
// CPeninputAnim::SetPosition
// called when sprite has been moved
// ---------------------------------------------------------------------------
//

TPoint CPeninputAnim::SetPosition(const TPoint& aNewPos)
    {
    if(aNewPos != iSpritePosition)
        {
        iSpritePosition = aNewPos;
        iSpriteFunctions->SetPosition(iSpritePosition);    
        }
    return iSpritePosition;
    }

// ---------------------------------------------------------------------------
// CPeninputAnim::UpdateArea
// Update sprite rect
// ---------------------------------------------------------------------------
//
void CPeninputAnim::UpdateArea(const TRect& aRect, TBool aFullUpdate)
    {
    if(iIsActive)
        {
        // if function is called without specifying the parameter aRect
        // (using default param value) the whole area drawn to is updated
        iSpriteFunctions->UpdateMember(0, aRect, aFullUpdate);
        }
    }

// ---------------------------------------------------------------------------
// CPeninputAnim::TimerCallBack
// Callback function of CPeriodic
// ---------------------------------------------------------------------------
//
TInt CPeninputAnim::FlushTimerCallBack(TAny* aPtr)
    {
    CPeninputAnim* self = static_cast<CPeninputAnim*>(aPtr);            
    self->FlushRawEventBuffer();            
    return KErrNone;
    }
  
// ---------------------------------------------------------------------------
// CPeninputAnim::SendRawEvent
// Send event to pen input server by buffering it
// ---------------------------------------------------------------------------
//    
void CPeninputAnim::SendRawEvent(const TRawEvent& aRawEvent)
    {
    //save to buffer first
    iEventBuffer.iEvent[iEventBuffer.iNum] = aRawEvent;
    iEventBuffer.iNum++;

    FlushRawEventBuffer();
    }

// ---------------------------------------------------------------------------
// CPeninputAnim::PostRawEvent
// Save the event to the buffer
// ---------------------------------------------------------------------------
//        
void CPeninputAnim::PostRawEvent(const TRawEvent& aRawEvent)
    {
    if(iEventBuffer.iNum >= KMaxEvent)
        {
        FlushRawEventBuffer();
        }
    
    iEventBuffer.iEvent[iEventBuffer.iNum] = aRawEvent;
    iEventBuffer.iNum++;
    }

// ---------------------------------------------------------------------------
// CPeninputAnim::FlushRowEventBuffer
// Send pointer event to pen input serrver, and return error code
// ---------------------------------------------------------------------------
//
TInt CPeninputAnim::FlushRawEventBuffer()
    {
    TInt ret = KErrNone;
    
    if(iEventBuffer.iNum > 0)
        {
        ret = iMsgBufQueue.Send(iEventBuffer);
           iEventBuffer.iNum = 0;            
        }
    
    return ret;
    }

// ---------------------------------------------------------------------------
// CPeninputAnim::OnRawKeyEvent
// Send raw key event to pen input server for processing.
// Wait until it's processed or timer out
// ---------------------------------------------------------------------------
//    
TBool CPeninputAnim::OnRawKeyEvent(const TRawEvent& aRawEvent)
    {
    TInt ret = KErrNone;
    
    //first sends all buffered event out
    FlushRawEventBuffer();
    
    //clear the signal and the response msg queue
    TBool isHandled = EFalse;
    ret = iKeyMsgResponseQueue.Receive(isHandled);
    while(ret == KErrNone)
        {
        iResponseQueueSemaphore.Wait();
        ret = iKeyMsgResponseQueue.Receive(isHandled);
        }

    //send the event directly        
    iEventBuffer.iNum = 1;
    iEventBuffer.iEvent[0] = aRawEvent;
    ret = FlushRawEventBuffer();
    
    isHandled = EFalse;
    if(ret == KErrNone) 
        {
        //wait for the key event processed.    
        ret = iResponseQueueSemaphore.Wait(KResponseQueueWaitTime);
        if(ret == KErrNone)
            {        
            //read the response from msg queue
            iKeyMsgResponseQueue.Receive(isHandled);
            }
        }

    return isHandled;
    }

// ---------------------------------------------------------------------------
// CPeninputAnim::StartTimer
// Initial and start timer
// ---------------------------------------------------------------------------
// 
void CPeninputAnim::StartTimer()
    {
    if ( iIsActive && !iFlushTimer->IsActive())
        {
        iFlushTimer->Start(
            KFlushTimerPeriod, 
            KFlushTimerPeriod, 
            TCallBack(FlushTimerCallBack, this));
        }
    }
    
// ---------------------------------------------------------------------------
// CPeninputAnim::StopTimer
// Cancel timer
// ---------------------------------------------------------------------------
// 
void CPeninputAnim::StopTimer()
    {
    iFlushTimer->Cancel();
    FlushRawEventBuffer();
    }

#ifdef RD_TACTILE_FEEDBACK
void CPeninputAnim::GetFeedbackAreaDataL(RArray<TTactileControlInfo>& aTactileControlArray,
                                         const RMessagePtr2* msg, 
                                         RArray<TRect>* aPrevRectArray)
    {
    TInt num;
    TPckg<TInt> numBuf(num);
    msg->ReadL(KMsgSlot1,numBuf);
    TTactileFeedbackArea* area = new(ELeave) TTactileFeedbackArea[num];

    CleanupArrayDeletePushL( area );

    TPtr msgData(reinterpret_cast<TUint16*>(area), num*sizeof(TTactileFeedbackArea)/2);
    msg->ReadL(KMsgSlot2,msgData);           
            
    for(TInt i = 0 ; i < num; ++i)
        {
        //Advanced Tactile feedback REQ417-47932
        aTactileControlArray.Append(TTactileControlInfo(area[i].iId,
                                    area[i].iNewRect,area[i].iTactileType));      
        //aRectArray.Append(area[i].iNewRect);                
        if(aPrevRectArray)
            aPrevRectArray->Append(area[i].iPrevRect);                    
        }

    CleanupStack::PopAndDestroy( area );            
    }

// ---------------------------------------------------------------------------
// CPeninputAnim::MatchItemByControlID
// Compare the Item by ID
// ---------------------------------------------------------------------------
// 
TBool CPeninputAnim::MatchItemByControlID (const TTactileControlInfo& aFirst, const TTactileControlInfo& aSecond)
    {
    if (aFirst.iId == aSecond.iId)
        return ETrue;
    return EFalse;
    }

// ---------------------------------------------------------------------------
// CPeninputAnim::MatchItemByControlIDAndArea
// Compare the Item by ID and Area
// ---------------------------------------------------------------------------
// 
TBool CPeninputAnim::MatchItemByControlIDAndArea (const TTactileControlInfo& aFirst, const TTactileControlInfo& aSecond)
    {
    if ((aFirst.iId == aSecond.iId) && (aFirst.iArea == aSecond.iArea))
        return ETrue;
    return EFalse;
    }
#endif // RD_TACTILE_FEEDBACK    

void CPeninputAnim::SetDiscreeptPop(TRect aArea)
    {
    iDiscreetPopArea = aArea;
    if(iDiscreetPopArea.Size().iWidth > 0)
        {
        iDiscreetPoped = ETrue;
        }    
    else
        {
        iDiscreetPoped = EFalse;
        iDiscreetPopedCapture = EFalse;
        }
    }
// End of File
