/*
* 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 class RPeninputAnim
*
*/



#include <w32std.h>

#include "rpeninputanim.h"
#include "peninputcmd.h"
#include "peninputcmdparam.h"
#include "peninputcmdparamext.h"
#include "peninputclientserver.h"


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


// ---------------------------------------------------------------------------
// RPeninputAnim::RPeninputAnim
// Default consturctor to allow RPeninputAnim to be defined
// as non pointer member. To properly initialize this class
// use the other overload.
// ---------------------------------------------------------------------------
//
RPeninputAnim::RPeninputAnim() : RAnim() 
    {
    }

// ---------------------------------------------------------------------------
// RPeninputAnim::RAnim
// Constructor
// ---------------------------------------------------------------------------
//
RPeninputAnim::RPeninputAnim(RAnimDll& aDll) : RAnim( aDll )
    {
    }

// ---------------------------------------------------------------------------
// RPeninputAnim::Construct
// Second phase constructor.
// ---------------------------------------------------------------------------
//
void RPeninputAnim::ConstructL( const RWsSprite& aDevice )
    {
    User::LeaveIfError( RAnim::Construct( aDevice, 0, KNullDesC8() ) );
    FinishConstructionL();
    }

// ---------------------------------------------------------------------------
// RPeninputAnim::Activate
// send activate command
// ---------------------------------------------------------------------------
//
void RPeninputAnim::Activate()
    {
    CommandReply( EPeninputOpActivate );
    }

// ---------------------------------------------------------------------------
// RPeninputAnim::Deactivate
// Send deactive command
// ---------------------------------------------------------------------------
//
void RPeninputAnim::Deactivate()
    {
    CommandReply( EPeninputOpDeactivate );
    }

// ---------------------------------------------------------------------------
// RPeninputAnim::FinishConstructionL
// Send finishing construction command
// ---------------------------------------------------------------------------
//
void RPeninputAnim::FinishConstructionL()
    {    
    User::LeaveIfError( CommandReply( EPeninputOpFinishConstructionL) );
    }

    
// ---------------------------------------------------------------------------
// RPeniputAnim::LayoutSizeChangedL
// Send size change message
// ---------------------------------------------------------------------------
//
TInt RPeninputAnim::LayoutSizeChangedL(const TSize& aSize)
    {
    TInt err;
    TIpcArgs args (TIpcArgs::ENothing,0);        
    TPckgC<TSize> msg(aSize);
    
    args.Set(KMsgSlot1,&msg);
    err = CommandReply(EPeninputOpLayoutSizeChangedWithSize,KNullDesC8,args);
    return err;
    }

// ---------------------------------------------------------------------------
// RPeniputAnim::SetUiLayoutPos
// Get ui layout position
// ---------------------------------------------------------------------------
//
TInt RPeninputAnim::SetUiLayoutPos(const TPoint& aPt)
    {    
    TPckgC<TPoint> msg(aPt);
    TIpcArgs args(TIpcArgs::ENothing);     
    args.Set(KMsgSlot1,&msg);    
    return CommandReply(EPeninputOpSetLayoutPos,KNullDesC8,args);
    }   

// ---------------------------------------------------------------------------
// RPeniputAnim::UpdateArea
// Update screen
// ---------------------------------------------------------------------------
//    
void RPeninputAnim::UpdateArea(const TRect& aRect,TBool aFullUpdate)    
    {
    TPckgC<TBool> flagMsg(aFullUpdate);    
    TPckgC<TRect> rectMsg(aRect);
    
    TIpcArgs args (TIpcArgs::ENothing);        
    /*TUpdateDataArea s;
    s.iRect = aRect;
    s.iUpdateFlag = aFullUpdate;
    
    TPckgC<TUpdateDataArea> pkg(s);
    */
    args.Set(KMsgSlot1,&rectMsg);
    args.Set(KMsgSlot2,&flagMsg);
    
    //args.Set(KMsgSlot1,&pkg);    
    CommandReply(EPeninputOpLayoutUpdateArea,KNullDesC8,args);
    //Command(EPeninputOpLayoutUpdateArea,pkg);    
    }

// ---------------------------------------------------------------------------
// RPeniputAnim::UpdateArea
// Update screen
// ---------------------------------------------------------------------------
//    
void RPeninputAnim::UpdateArea(const RArray<TUpdateArea>& aArea)
    {
    TInt num = aArea.Count();    
    TUpdateArea* area = new TUpdateArea[num];
    
    if (!area)
        return;

    for(TInt i = 0; i < num; ++i)
        {
        area[i] = aArea[i];
        }
    
    TPtrC8 areaMsg(reinterpret_cast<const TUint8*>(area), num*sizeof(TUpdateArea));
    
    TIpcArgs args (TIpcArgs::ENothing);        
    
    TPckgC<TInt> numMsg(num);    
    args.Set(KMsgSlot1,&numMsg);
    args.Set(KMsgSlot2,&areaMsg);
    
    //args.Set(KMsgSlot1,&pkg);    
    CommandReply(EPeninputOpLayoutUpdateAreaRegion, KNullDesC8, args);
    
    delete []area;
    }
    
// ---------------------------------------------------------------------------
// RPeniputAnim::CapturePointer
// Inform pen input animation dll to capture the pointer
// ---------------------------------------------------------------------------
//      
void RPeninputAnim::CapturePointer(TBool aFlag, TInt aCaptureCtrlID)
    {
    TIpcArgs args (TIpcArgs::ENothing);        
    TPckgC<TBool> msgCaptureFlagData(aFlag);
    TPckgC<TInt> msgCaptureCtrlIDData(aCaptureCtrlID);
    args.Set(KMsgSlot1,&msgCaptureFlagData);
    args.Set(KMsgSlot2,&msgCaptureCtrlIDData);
    //Command(EPeninputOpCapturePointer,msgData);            
    CommandReply(EPeninputOpCapturePointer,KNullDesC8,args);
    }    
    
// ---------------------------------------------------------------------------
// RPeniputAnim::SimulateEvent
// ---------------------------------------------------------------------------
//      
void RPeninputAnim::SimulateEvent(const TRawEvent& aEvent)
    {
    TIpcArgs args (TIpcArgs::ENothing);        
    TPckgC<TRawEvent> msgData(aEvent);
    args.Set(KMsgSlot1,&msgData);
    CommandReply(EPeninputOpSimulateEvent,KNullDesC8,args);
    //Command(EPeninputOpSimulateEvent,msgData);            
    }        

#ifdef RD_TACTILE_FEEDBACK     
// ---------------------------------------------------------------------------
// RPeniputAnim::DoFeedbackAreaOpL
// ---------------------------------------------------------------------------
//       
void RPeninputAnim::DoFeedbackAreaOpL(const TTactileFeedbackArea* aArea, 
                                              TInt aCount,TPeninputOpcodes aOp)
    {    
    for(TInt i = 0 ; i < aCount; ++i)
        {
        TTactileFeedbackArea oneArea = aArea[i];
        TPckgC<TTactileFeedbackArea> msgData(oneArea);
        Command(aOp,msgData);        
        }        
    }

// ---------------------------------------------------------------------------
// RPeniputAnim::DoFeedbackAreaOpReplyL
// ---------------------------------------------------------------------------
//       
void RPeninputAnim::DoFeedbackAreaOpReplyL(const TTactileFeedbackArea* aArea, 
                                              TInt aCount,TPeninputOpcodes aOp)
    {    
    TIpcArgs args (TIpcArgs::ENothing);           
    TPckgC<TInt> areaNum(aCount);        
    args.Set(KMsgSlot1,&areaNum);
    
    TInt memByteLen = aCount*sizeof(TTactileFeedbackArea);
    
    TUint8 *buf = new(ELeave) TUint8[memByteLen];
    
    TTactileFeedbackArea *areaBuf = reinterpret_cast<TTactileFeedbackArea *>(buf);
    for(TInt i = 0; i < aCount; ++i)
        {
        areaBuf[i] = aArea[i];
        }
        
    TPtrC msgData(reinterpret_cast<TUint16*>(buf),memByteLen/2);

    args.Set(KMsgSlot2,&msgData);  
    
    CommandReply(aOp,KNullDesC8,args);
    delete []buf;

    }


// ---------------------------------------------------------------------------
// RPeniputAnim::AddFeedbackAreaL
// ---------------------------------------------------------------------------
//       
void RPeninputAnim::AddFeedbackAreaL(const TTactileFeedbackArea* aArea, 
                                              TInt aCount,TBool aReplyFlag)
    {
    if(aReplyFlag)
        DoFeedbackAreaOpReplyL(aArea,aCount,EPeninputOpRegisterFeedbackArea);    
    else
        DoFeedbackAreaOpL(aArea,aCount,EPeninputOpRegisterFeedbackArea);    
    }
    
// ---------------------------------------------------------------------------
// RPeniputAnim::RemoveFeedbackAreaL
// ---------------------------------------------------------------------------
//           
void RPeninputAnim::RemoveFeedbackAreaL(const TTactileFeedbackArea* aArea,
                                             TInt aCount,TBool aReplyFlag)
    {
    if(aReplyFlag)
        DoFeedbackAreaOpReplyL(aArea,aCount,EPeninputOpDeRegisterFeedbackArea);    
    else
        DoFeedbackAreaOpL(aArea,aCount,EPeninputOpDeRegisterFeedbackArea);        
    }    
    
// ---------------------------------------------------------------------------
// RPeniputAnim::ChangeFeedbackAreaL
// ---------------------------------------------------------------------------
//               
void RPeninputAnim::ChangeFeedbackAreaL(const TTactileFeedbackArea* aArea, 
                                             TInt aCount,TBool aReplyFlag)
    {
    if(aReplyFlag)
        DoFeedbackAreaOpReplyL(aArea,aCount,EPeninputOpChangeFeedbackArea);    
    else
        DoFeedbackAreaOpL(aArea,aCount,EPeninputOpChangeFeedbackArea);    
    }   
// ---------------------------------------------------------------------------
// RPeniputAnim::ChangeFeedbackTypeL
// ---------------------------------------------------------------------------
// 
void RPeninputAnim::ChangeFeedbackTypeL(const TTactileFeedbackArea* aArea, 
											 TInt aCount,TBool aReplyFlag)
	{
    if(aReplyFlag)
        DoFeedbackAreaOpReplyL(aArea,aCount,EPeninputOpChangeFeedbackType);    
    else
        DoFeedbackAreaOpL(aArea,aCount,EPeninputOpChangeFeedbackType);
	}

#endif // RD_TACTILE_FEEDBACK 
    
void RPeninputAnim::EnableSprite(TBool aFlag)
    {
    TPckgC<TBool> msgData(aFlag);
    Command(EPeninputOpEnalbeSprite,msgData);
    }

// ---------------------------------------------------------------------------
// RPeniputAnim::GetDSAState
// ---------------------------------------------------------------------------
//      
void RPeninputAnim::GetDSAState(TBool& aState)
    {
    TIpcArgs args (TIpcArgs::ENothing);        
    TPckg<TBool> msgData(aState);
    args.Set(KMsgSlot1,&msgData);
    CommandReply(EPeninputOpRequestDSAState,KNullDesC8,args);
    //Command(EPeninputOpSimulateEvent,msgData);            
    }        

// ---------------------------------------------------------------------------
// RPeniputAnim::SetDiscreeptPop
// ---------------------------------------------------------------------------
//      	
void RPeninputAnim::SetDiscreeptPop(const TRect& aArea)
    {
    TIpcArgs args (TIpcArgs::ENothing);        
    TPckg<TRect> msgData(aArea);
    args.Set(KMsgSlot1,&msgData);
    CommandReply(EPeninputOpSetDiscreeptPop,KNullDesC8,args);           
    } 
// End of File