/*

* Copyright (c) 2006-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 server

*

*/

#include <coedef.h>

#include "peninputanimclientobj.h"

#include "peninputserver.h"

#include "peninputclientserver.h"

#include "peninputanimcommand.h"

#include <coemain.h>

// the animation dll name

_LIT( KAnimDllName, "peninputanim.dll" );

//animation window group name

//_LIT(KPeninputServerAnimName,"peninputserveranimobj");

class RWsSession;

class RWindowGroup;

void HideWindowGroupL(const RWsSession& aWs,const RWindowGroup& aGroup);

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

// CPeninputAnimObj::CPeninputAnimObj

// Default constructor

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

//

CPeninputAnimObj::CPeninputAnimObj(TSpriteMember& aSpriteMember)

                    : CActive( EPriorityStandard ),iSpriteMember(aSpriteMember)

    {

    iOnExiting = EFalse;

    }

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

// CPeninputAnimObj::NewL

// factory method

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

//

CPeninputAnimObj* CPeninputAnimObj::NewL(TSpriteMember& aSpriteMember)

    {    

    CPeninputAnimObj* animObj = new(ELeave) CPeninputAnimObj(aSpriteMember);        

    CleanupStack::PushL(animObj);            

    CActiveScheduler::Add(animObj);

    animObj->ConstructL();

    CleanupStack::Pop(animObj);

    return animObj;

    }

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

// CPeninputAnimObj::~CPeninputAnimObj

// Destructor

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

//

CPeninputAnimObj::~CPeninputAnimObj()

    {        

    Cancel();

    for(int i = 0 ; i < iAnimCmd.Count(); ++i)

    	{

    	const TAnimCmd* cmd = iAnimCmd[i];

    	delete cmd;

    	}

    iAnimCmd.Close();

    // closing the window server session frees all 

    // used resources in the ws session, including:

    //   iSprite

    //   iAnim

    //   iAnimDll

    iSprite.Close();

    iAnim.Close();

    iAnimDll.Close();            

    iWindowGroup.Close();

    iWsSession.Close();

    }

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

// CPeninputAnimObj::RunL

// active ao call back

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

//

void CPeninputAnimObj::RunL()

    {

    ExecuteAnimCommand();

    }

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

// CPeninputAnimObj::DoCancel

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

//

void CPeninputAnimObj::DoCancel()

    {

    //do nothing

    }

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

// CPeninputAnimObj::RunError

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

//    

TInt CPeninputAnimObj::RunError(TInt /*aErr*/)

    {

    //ignore error

    return KErrNone;

    }

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

// CPeninputAnimObj::ConstructL

// 2nd phase constructor

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

//    

void CPeninputAnimObj::ConstructL()

    {

    iAnimCmd.Reset();

    ConstructAnimL();    

    }

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

// CPeninputAnimObj::ExecuteAnimCommand

// Execute animation command

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

//        

void CPeninputAnimObj::ExecuteAnimCommand()

    {    

    TInt i = 0;

    for(; i < iAnimCmd.Count(); ++i)

        {        

    	const TAnimCmd* cmd = iAnimCmd[i];        

        if(!cmd->ExecuteAnimCommand())

        	break; //execution not finished, need wait to next round. 

        delete cmd;        	

        }   

    //remove executed command

    while(--i >= 0)

    	{

    	iAnimCmd.Remove(i);

    	}

    }

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

// CPeninputAnimObj::ExeOnePendingAnimCmd

// Execute the first pending animation command

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

//        

void CPeninputAnimObj::ExeOnePendingAnimCmd()

    {

    //search the first wait command

    for(TInt i = 0 ; i < iAnimCmd.Count(); i++)

        {

        if(!iAnimCmd[i]->Ready())

            {

            iAnimCmd[i]->SetReady(ETrue);

            //break;

            }

        }        

    //CompleteRequest();

    SetObjActive();

    }

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

// CPeninputAnimObj::AddAnimCommand

// Add a animation command

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

//        

void CPeninputAnimObj::AddAnimCommand(TAnimCmd* aCmd)

    {    

    if(iOnExiting) // do nothing if prepare for exiting

        {

        delete aCmd;

        aCmd = 0;    

        return;

        }

    iAnimCmd.Append(aCmd);

    //CompleteRequest();

    SetObjActive();

    }

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

// CPeninputAnimObj::SetObjActive

// Set animation object active so as to be rescheduled by AO scheduler.

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

//        

void CPeninputAnimObj::SetObjActive()

    {

    if(!IsActive())

        {

    	iStatus=KRequestPending;

    	SetActive();    	

    	TRequestStatus *pS=(&iStatus);

        User::RequestComplete(pS,0);

    	}    

    }

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

// CPeninputAnimObj::ConstructSpriteAnimL

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

//

TInt CPeninputAnimObj::ConstructAnimL()

    {                

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

    iWindowGroup = RWindowGroup( iWsSession);

    iWindowGroup.Construct( RThread().Id(), EFalse );    

    iWindowGroup.SetOrdinalPosition( -1, -1);    

    iWindowGroup.SetOrdinalPriorityAdjust( ECoeWinPriorityAlwaysAtFront );

    iWindowGroup.EnableReceiptOfFocus( EFalse );

    iWindowGroup.AutoForeground(EFalse);

	HideWindowGroupL(iWsSession,iWindowGroup);  

    TInt id = iWindowGroup.Identifier();    

    iSprite = RWsSprite( iWsSession);

    User::LeaveIfError( iSprite.Construct( iWindowGroup,

                                           TPoint( 0, 0 ),ESpriteNoChildClip | 

                                                            ESpriteNoShadows ) );

    // add sprite member

    User::LeaveIfError( iSprite.AppendMember( iSpriteMember ));

    // load peninput animation dll

    iAnimDll = RAnimDll( iWsSession );

    User::LeaveIfError( iAnimDll.Load( KAnimDllName ) );    

    // create peninput sprite animation class

    iAnim = RPeninputAnim( iAnimDll);

    iAnim.ConstructL( iSprite );    

    return KErrNone;

    }

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

// CPeninputAnimObj::AddActivationCmd

// Add activation command

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

//

TBool CPeninputAnimObj::AddActivationCmd(TBool aUiFlag, TBool aWaitFlag)

	{

	TAnimActivateUiCmd* cmd = new TAnimActivateUiCmd(iAnim,aUiFlag,!aWaitFlag);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;

	}

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

// CPeninputAnimObj::AddChangeSizeCmd

// Add changing size command

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

//	

TBool CPeninputAnimObj::AddChangeSizeCmd(const TSize& aSize)

	{

	TAnimChangeSizeCmd* cmd = new TAnimChangeSizeCmd(iAnim,aSize);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;	

	}

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

// CPeninputAnimObj::AddSetPosCmd

// Add setting position command

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

//	

TBool CPeninputAnimObj::AddSetPosCmd(const TPoint& aPt)

	{

	TAnimSetPosCmd* cmd = new TAnimSetPosCmd(iAnim,aPt);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;

	}

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

// CPeninputAnimObj::AddChangeDispModeCmd

// Add changing display mode command

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

//		

TBool CPeninputAnimObj::AddChangeDispModeCmd(TSpriteMember& aMember)

	{

    TAnimChangeDispModeCmd* cmd = new	TAnimChangeDispModeCmd(iAnim,

                                                             iSprite,

                                                             aMember);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;	

	}

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

// CPeninputAnimObj::AddUpdateUiCmd

// Add updaing UI command

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

//			

TBool CPeninputAnimObj::AddUpdateUiCmd(const TRect& aRect, TBool aUpdateFlag)

	{

	TAnimUpdateUiRectCmd* cmd = new TAnimUpdateUiRectCmd(iAnim,aRect,aUpdateFlag);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;		

	}

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

// CPeninputAnimObj::AddUpdateUiCmd

// Add updaing UI command

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

//

TBool CPeninputAnimObj::AddUpdateUiCmd(TUpdateArea *aArea,TInt aNum)

    {

	  TAnimUpdateUiRectCmd* cmd = new TAnimUpdateUiRectCmd(iAnim,aArea,aNum);

	  if (!cmd)

		    return EFalse;

	  AddAnimCommand(cmd);

	  return ETrue;		

    }

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

// CPeninputAnimObj::AddCapturePointerCmd

// Add capturing pointer command

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

//				

TBool CPeninputAnimObj::AddCapturePointerCmd(TBool aFlag, TInt aCaptureCtrlID)

	{

	TAnimCapturePtCmd* cmd = new TAnimCapturePtCmd(iAnim,aFlag, aCaptureCtrlID);	

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;		

	}

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

// CPeninputAnimObj::AddSimulatedEventCmd

// Add ignoring similated event command

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

//					

TBool CPeninputAnimObj::AddSimulateEventCmd(const TRawEvent& aEvent)

	{

    TAnimSimulateEventCmd* cmd = new TAnimSimulateEventCmd(iAnim, aEvent);

    if (!cmd)

        return EFalse;

    AddAnimCommand(cmd);

    return ETrue;	

	}

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

// Execute simulate event command

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

//					

TBool CPeninputAnimObj::ExecuteSimulateEventCmd( const TRawEvent& aEvent )

	{

    TAnimSimulateEventCmd* cmd = new TAnimSimulateEventCmd( iAnim, aEvent );    

    if (!cmd)

        return EFalse;

    cmd->ExecuteAnimCommand();

    delete cmd;

    cmd = NULL;

    return ETrue;		

	}

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

// CPeninputAnimObj::AddFlushSessionCmd

// Add flushing session command

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

//						

TBool CPeninputAnimObj::AddFlushSessionCmd()

	{

	TAnimFlushWsSessionCmd* cmd = new TAnimFlushWsSessionCmd(iAnim,iWsSession);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;		

	}

#ifdef RD_TACTILE_FEEDBACK

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

// CPeninputAnimObj::AddRegisterFeedbackAreaCmd

// Add feedback registeration command

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

//							

TBool CPeninputAnimObj::AddRegisterFeedbackAreaCmd(const TTactileFeedbackArea& aArea,

                                                TBool aCmdFlag)		

    { 

	TAnimFeedbackAreaCmd* cmd = new TAnimFeedbackAreaCmd(iAnim,aArea,

	                                                       TAnimFeedbackAreaCmd::TFeedbackAreaOpAdd,

	                                                       aCmdFlag);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;	        

    }

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

// CPeninputAnimObj::AddRegisterFeedbackAreaCmd

// Add feedback registeration command

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

//							

/*TBool CPeninputAnimObj::AddRegisterFeedbackAreaCmd(const RArray<TTactileFeedbackArea>& aAreaList)		

    { 

	TAnimFeedbackAreaCmd* cmd = new TAnimFeedbackAreaCmd(iAnim,aAreaList,

	                                                       TAnimFeedbackAreaCmd::TFeedbackAreaOpAdd,

	                                                       ETrue);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;	        

    }*/

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

// CPeninputAnimObj::AddDeRegisterFeedbackAreaCmd

// Remove feedback registeration command

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

//							

TBool CPeninputAnimObj::AddDeRegisterFeedbackAreaCmd(const TTactileFeedbackArea& aArea,

                                            TBool aCmdFlag)

    { 

	TAnimFeedbackAreaCmd* cmd = new TAnimFeedbackAreaCmd(iAnim,aArea,

	                                                       TAnimFeedbackAreaCmd::TFeedbackAreaOpRemove,

	                                                       aCmdFlag);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;	        

    }

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

// CPeninputAnimObj::AddChangeFeedbackAreaCmd

// Add feedback registeration command

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

//							

TBool CPeninputAnimObj::AddChangeFeedbackAreaCmd(const TTactileFeedbackArea& aArea,

                                            TBool aCmdFlag)

    { 

	TAnimFeedbackAreaCmd* cmd = new TAnimFeedbackAreaCmd(iAnim,aArea,

	                                                       TAnimFeedbackAreaCmd::TFeedbackAreaOpChange,

	                                                       aCmdFlag);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;	        

    }  

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

// CPeninputAnimObj::AddChangeFeedbackTypeCmd

// Add feedback registeration command

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

//							

TBool CPeninputAnimObj::AddChangeFeedbackTypeCmd(const TTactileFeedbackArea& aArea,

                                            TBool aCmdFlag)

    { 

	TAnimFeedbackAreaCmd* cmd = new TAnimFeedbackAreaCmd(iAnim,aArea,

	                                                       TAnimFeedbackAreaCmd::TFeedbackTypeOpChange,

	                                                       aCmdFlag);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;	        

    }  

#endif // RD_TACTILE_FEEDBACK

TBool CPeninputAnimObj::AddEnalbeSpriteCmd(TBool aFlag)

    {

	TAnimEnableSpriteCmd* cmd = new TAnimEnableSpriteCmd(iAnim,aFlag);

	if(!cmd)

		return EFalse;

	AddAnimCommand(cmd);

	return ETrue;	                

    }

RWindowGroup& CPeninputAnimObj::WindowGroup()

    {

    return iWindowGroup;

    }

void CPeninputAnimObj::OnExiting()

    {

    iOnExiting = ETrue;

    }

void CPeninputAnimObj::GetDSAState(TBool& aState)

    {

    iAnim.GetDSAState(aState);    

    }

TBool CPeninputAnimObj::SetDiscreetPopArea(const TRect& aArea)

	{

    TAnimSetDiscreeptPopCmd* cmd = new TAnimSetDiscreeptPopCmd(iAnim,aArea);	

    if(!cmd)

        return EFalse;

    AddAnimCommand(cmd);

    return ETrue;		

	}

//end of file